Overwrite

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

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/AwakenAllSpell.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Collections;
+using Server.Items;
+using Server.Misc;
+using Server.Network;
+using Server.Spells;
+using Server.Targeting;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientAwakenAllSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Awaken All", "Vas An Zu",
+                                                        218,
+                                                        9031,
+                                                        Reagent.Garlic,
+                                                        Reagent.Ginseng
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public AncientAwakenAllSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if(CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (CheckSequence())
+            {
+                SpellHelper.Turn(Caster, p);
+
+
+                ArrayList targets = new ArrayList();
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                Map map = Caster.Map;
+
+                if (map != null)
+                {
+
+                    IPooledEnumerable eable = map.GetItemsInRange(new Point3D(p), 3);
+
+                    foreach (Item m in eable)
+                    {
+
+
+                        if (Caster.CanSee(m) && m is SleepingBody)
+                            targets.Add(m);
+                    }
+
+                    eable.Free();
+                }
+
+                for (int i = 0; i < targets.Count; ++i)
+                {
+
+                    SleepingBody m = (SleepingBody)targets[i];
+
+
+                    if (m != null)
+                    {
+                        m.Owner.RevealingAction();
+                        m.Owner.Frozen = false;
+                        m.Owner.Squelched = false;
+                        m.Owner.Map = m.Map;
+                        m.Owner.Location = m.Location;
+                        m.Owner.Animate(21, 6, 1, false, false, 0);
+
+                        m.Owner.SendMessage("You wake up!");
+
+                        m.Delete();
+                    }
+                    Caster.SendMessage("You awaken them!");
+
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientAwakenAllSpell m_Owner;
+
+            public InternalTarget(AncientAwakenAllSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is SleepingBody)
+                {
+                    IPoint3D p = o as IPoint3D;
+
+                    if (p != null)
+                        m_Owner.Target(p);
+                }
+                else
+                    from.SendMessage("That is not a slumbering being");
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/AwakenSpell.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Items;
+using Server.Gumps;
+using Server.Spells;
+using Server.Targeting;
+using Server.Network;
+using Server.Regions;
+
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientAwakenSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Awaken", "An Zu",
+                                                        218,
+                                                        9002,
+                                                        Reagent.SulfurousAsh
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public override double CastDelay { get { return 1.0; } }
+        public override double RequiredSkill { get { return 0.0; } }
+        public override int RequiredMana { get { return 5; } }
+
+        public AncientAwakenSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if(CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(SleepingBody slumber)
+        {
+            if (!Caster.CanSee(slumber))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+
+            else if (CheckSequence())
+            {
+
+                if (slumber != null)
+                {
+                    if (slumber.Owner != null)
+                    {
+                        slumber.Owner.RevealingAction();
+                        slumber.Owner.Frozen = false;
+                        slumber.Owner.Squelched = false;
+                        slumber.Owner.Map = slumber.Map;
+                        slumber.Owner.Location = slumber.Location;
+                        slumber.Owner.Animate(21, 6, 1, false, false, 0); ;
+
+
+                        slumber.Delete();
+                        slumber.Owner.SendMessage("You wake up!");
+                        Caster.SendMessage("You awaken them!");
+                    }
+                    else
+                        Caster.SendMessage("They are beyond your power to awaken...");
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientAwakenSpell m_Owner;
+
+            public InternalTarget(AncientAwakenSpell owner)
+                : base(12, false, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is SleepingBody)
+                {
+                    m_Owner.Target((SleepingBody)o);
+                }
+                else
+                {
+                    from.SendMessage("That cannot be awoken."); // I cannot mark that object.
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/CauseFearSpell.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+using Server.Network;
+using Server.Items;
+using Server.Targeting;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientCauseFearSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Cause Fear", "Quas Wis",
+                                                        230,
+                                                        9022,
+                                                        Reagent.Garlic,
+                                                        Reagent.Nightshade,
+                                                        Reagent.MandrakeRoot
+                                                       );
+
+        public override Server.Spells.SpellCircle Circle
+        {
+            get { return SpellCircle.Sixth; }
+        }
+
+        public AncientCauseFearSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+            {
+                List<Mobile> targets = new List<Mobile>();
+
+                foreach (Mobile m in Caster.GetMobilesInRange(8))
+                {
+                    if (Caster != m && SpellHelper.ValidIndirectTarget(Caster, m) && Caster.CanBeHarmful(m, false))
+                        targets.Add(m);
+                }
+
+                Caster.PlaySound(0x245);
+                Caster.PlaySound(0x3EA);
+                Caster.FixedParticles(0x2109, 1, 25, 9922, 14, 3, EffectLayer.Head);
+                IEntity from = new Entity(Serial.Zero, new Point3D(Caster.X, Caster.Y, Caster.Z), Caster.Map);
+                IEntity to = new Entity(Serial.Zero, new Point3D(Caster.X, Caster.Y, Caster.Z + 32), Caster.Map);
+                Effects.SendMovingParticles(from, to, 0x3192, 1, 0, false, false, 33, 3, 9501, 1, 0, EffectLayer.Head, 0x100);
+
+
+                int dispelSkill = Caster.Int;
+
+                double mag = Caster.Skills.Magery.Value;
+
+                for (int i = 0; i < targets.Count; ++i)
+                {
+                    if (targets[i] is BaseCreature)
+                    {
+                        BaseCreature m = targets[i] as BaseCreature;
+
+                        if (m != null)
+                        {
+                            bool dispellable = m.Summoned && !m.IsAnimatedDead;
+
+                            if (dispellable)
+                            {
+                                double dispelChance = (50.0 + ((100 * (mag - m.DispelDifficulty)) / (m.DispelFocus * 2))) / 100;
+                                dispelChance *= dispelSkill / 100.0;
+
+                                if (dispelChance > Utility.RandomDouble())
+                                {
+                                    Effects.SendLocationParticles(EffectItem.Create(m.Location, m.Map, EffectItem.DefaultDuration), 0x3728, 8, 20, 5042);
+                                    Effects.PlaySound(m, m.Map, 0x201);
+
+                                    m.Delete();
+                                    continue;
+                                }
+                            }
+
+                            bool evil = !m.Controlled && !m.Blessed;
+
+                            if (evil)
+                            {
+
+                                double fleeChance = (100 - Math.Sqrt(m.Fame / 2)) * mag * dispelSkill;
+                                fleeChance /= 1000000;
+
+                                if (fleeChance > Utility.RandomDouble())
+                                {
+                                    m.PlaySound(m.Female ? 814 : 1088);
+                                    m.BeginFlee(TimeSpan.FromSeconds(15.0));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            FinishSequence();
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/CharmSpell.cs

@@ -0,0 +1,369 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Targeting;
+using Server.Items;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientCharmSpell : AncientSpell
+    {
+        private Timer m_Timer;
+
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Charm", "An Xen Ex",
+                                                        218,
+                                                        9012,
+                                                        Reagent.BlackPearl,
+                                                        Reagent.Nightshade,
+                                                        Reagent.SpidersSilk
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Fifth; }
+        }
+
+        public AncientCharmSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(Mobile ma)
+        {
+            BaseCreature m = ma as BaseCreature;
+            if (ma is CharmedMobile)
+            {
+                ma.Kill();
+                Caster.SendMessage("You free them from their charm!");
+            }
+            else if (m != null)
+            {
+                if (!Caster.CanSee(m))
+                {
+                    Caster.SendLocalizedMessage(500237); // Target can not be seen.
+                }
+                else if (m.Controlled || m.Summoned)
+                {
+                    Caster.SendMessage("That target is already under somone's control!");
+                }
+                else if (!m.Alive)
+                {
+                    Caster.SendMessage("The dead are beyond your charms.");
+                }
+                else if (!m.Tamable || m.Blessed)
+                {
+
+                    Caster.SendMessage("You have no chance of charming that!");
+
+                }
+                else if (Caster.Followers >= 1)
+                {
+                    Caster.SendMessage("You couldn't control that if you did charm it!");
+                }
+                else if (CheckHSequence(m))
+                {
+                    SpellHelper.Turn(Caster, m);
+
+
+                    if (!m.Controlled && m != null && !m.Deleted)
+                    {
+                        double taming;
+                        if (m.MinTameSkill <= 1.0)
+                            taming = 1.0;
+                        else
+                            taming = m.MinTameSkill;
+
+                        double charmchance = (Caster.Skills[SkillName.Magery].Value / taming);
+                        if (charmchance <= 0.5)
+                        {
+                            Caster.SendMessage("You have no chance of charming them.");
+                        }
+                        else if (charmchance >= 0.9)
+                        {
+                            Caster.SendMessage("You charm them!");
+                            Point3D mloc = new Point3D(m.X, m.Y, m.Z);
+                            CharmedMobile dg = new CharmedMobile(m);
+                            dg.Owner = m;
+
+                            dg.Body = m.Body;
+                            dg.AI = m.AI;
+                            dg.Hue = m.Hue;
+                            dg.Name = m.Name;
+                            dg.SpeechHue = m.SpeechHue;
+                            dg.Fame = m.Fame;
+                            dg.Karma = m.Karma;
+                            dg.EmoteHue = m.EmoteHue;
+                            dg.Title = m.Title;
+                            dg.Criminal = (m.Criminal);
+                            dg.Str = m.Str;
+                            dg.Int = m.Int;
+                            dg.Hits = m.Hits;
+                            dg.Dex = m.Dex;
+                            dg.Mana = m.Mana;
+                            dg.Stam = m.Stam;
+
+                            dg.VirtualArmor = (m.VirtualArmor);
+                            dg.SetSkill(SkillName.Wrestling, m.Skills[SkillName.Wrestling].Value);
+                            dg.SetSkill(SkillName.Tactics, m.Skills[SkillName.Tactics].Value);
+                            dg.SetSkill(SkillName.Anatomy, m.Skills[SkillName.Anatomy].Value);
+
+                            dg.SetSkill(SkillName.Magery, m.Skills[SkillName.Magery].Value);
+                            dg.SetSkill(SkillName.MagicResist, m.Skills[SkillName.MagicResist].Value);
+                            dg.SetSkill(SkillName.Meditation, m.Skills[SkillName.Meditation].Value);
+                            dg.SetSkill(SkillName.EvalInt, m.Skills[SkillName.EvalInt].Value);
+
+                            dg.SetSkill(SkillName.Archery, m.Skills[SkillName.Archery].Value);
+                            dg.SetSkill(SkillName.Macing, m.Skills[SkillName.Macing].Value);
+                            dg.SetSkill(SkillName.Swords, m.Skills[SkillName.Swords].Value);
+                            dg.SetSkill(SkillName.Fencing, m.Skills[SkillName.Fencing].Value);
+                            dg.SetSkill(SkillName.Lumberjacking, m.Skills[SkillName.Lumberjacking].Value);
+                            dg.SetSkill(SkillName.Alchemy, m.Skills[SkillName.Alchemy].Value);
+                            dg.SetSkill(SkillName.Parry, m.Skills[SkillName.Parry].Value);
+                            dg.SetSkill(SkillName.Focus, m.Skills[SkillName.Focus].Value);
+                            dg.SetSkill(SkillName.Necromancy, m.Skills[SkillName.Necromancy].Value);
+                            dg.SetSkill(SkillName.Chivalry, m.Skills[SkillName.Chivalry].Value);
+                            dg.SetSkill(SkillName.ArmsLore, m.Skills[SkillName.ArmsLore].Value);
+                            dg.SetSkill(SkillName.Poisoning, m.Skills[SkillName.Poisoning].Value);
+                            dg.SetSkill(SkillName.SpiritSpeak, m.Skills[SkillName.SpiritSpeak].Value);
+                            dg.SetSkill(SkillName.Stealing, m.Skills[SkillName.Stealing].Value);
+                            dg.SetSkill(SkillName.Inscribe, m.Skills[SkillName.Inscribe].Value);
+                            dg.Kills = (m.Kills);
+
+
+                            // Clear Items
+                            RemoveFromAllLayers(dg);
+
+                            // Then copy
+                            CopyFromLayer(m, dg, Layer.FirstValid);
+                            CopyFromLayer(m, dg, Layer.TwoHanded);
+                            CopyFromLayer(m, dg, Layer.Shoes);
+                            CopyFromLayer(m, dg, Layer.Pants);
+                            CopyFromLayer(m, dg, Layer.Shirt);
+                            CopyFromLayer(m, dg, Layer.Helm);
+                            CopyFromLayer(m, dg, Layer.Gloves);
+                            CopyFromLayer(m, dg, Layer.Ring);
+                            CopyFromLayer(m, dg, Layer.Talisman);
+                            CopyFromLayer(m, dg, Layer.Neck);
+                            CopyFromLayer(m, dg, Layer.Hair);
+                            CopyFromLayer(m, dg, Layer.Waist);
+                            CopyFromLayer(m, dg, Layer.InnerTorso);
+                            CopyFromLayer(m, dg, Layer.Bracelet);
+                        //    CopyFromLayer(m, dg, Layer.Unused_xF);
+                            CopyFromLayer(m, dg, Layer.FacialHair);
+                            CopyFromLayer(m, dg, Layer.MiddleTorso);
+                            CopyFromLayer(m, dg, Layer.Earrings);
+                            CopyFromLayer(m, dg, Layer.Arms);
+                            CopyFromLayer(m, dg, Layer.Cloak);
+                            CopyFromLayer(m, dg, Layer.OuterTorso);
+                            CopyFromLayer(m, dg, Layer.OuterLegs);
+                            CopyFromLayer(m, dg, Layer.LastUserValid);
+                            CopyFromLayer(m, dg, Layer.Mount);
+                            dg.ControlSlots = 5;
+                            dg.Controlled = true;
+                            dg.ControlMaster = Caster;
+                            TimeSpan duration = TimeSpan.FromSeconds(Caster.Skills[SkillName.Magery].Value * 1.2); // 120% of magery
+                            m_Timer = new InternalTimer(dg, duration);
+                            m_Timer.Start();
+                            dg.Map = m.Map;
+                            dg.Location = m.Location;
+                            m.Blessed = true;
+                            m.Hidden = true;
+
+                            m.Location = new Point3D(m.X, m.Y, m.Z - 95);
+                        }
+                        else if (charmchance >= Utility.RandomDouble())
+                        {
+                            Caster.SendMessage("You charm them!");
+                            CharmedMobile dg = new CharmedMobile(m);
+                            dg.Owner = m;
+
+                            dg.Body = m.Body;
+
+                            dg.Hue = m.Hue;
+                            dg.Name = m.Name;
+                            dg.SpeechHue = m.SpeechHue;
+                            dg.Fame = m.Fame;
+                            dg.Karma = m.Karma;
+                            dg.EmoteHue = m.EmoteHue;
+                            dg.Title = m.Title;
+                            dg.Criminal = (m.Criminal);
+                            dg.Str = m.Str;
+                            dg.Int = m.Int;
+                            dg.Hits = m.Hits;
+                            dg.Dex = m.Dex;
+                            dg.Mana = m.Mana;
+                            dg.Stam = m.Stam;
+                            dg.AI = m.AI;
+
+                            dg.VirtualArmor = (m.VirtualArmor);
+                            dg.SetSkill(SkillName.Wrestling, m.Skills[SkillName.Wrestling].Value);
+                            dg.SetSkill(SkillName.Tactics, m.Skills[SkillName.Tactics].Value);
+                            dg.SetSkill(SkillName.Anatomy, m.Skills[SkillName.Anatomy].Value);
+
+                            dg.SetSkill(SkillName.Magery, m.Skills[SkillName.Magery].Value);
+                            dg.SetSkill(SkillName.MagicResist, m.Skills[SkillName.MagicResist].Value);
+                            dg.SetSkill(SkillName.Meditation, m.Skills[SkillName.Meditation].Value);
+                            dg.SetSkill(SkillName.EvalInt, m.Skills[SkillName.EvalInt].Value);
+
+                            dg.SetSkill(SkillName.Archery, m.Skills[SkillName.Archery].Value);
+                            dg.SetSkill(SkillName.Macing, m.Skills[SkillName.Macing].Value);
+                            dg.SetSkill(SkillName.Swords, m.Skills[SkillName.Swords].Value);
+                            dg.SetSkill(SkillName.Fencing, m.Skills[SkillName.Fencing].Value);
+                            dg.SetSkill(SkillName.Lumberjacking, m.Skills[SkillName.Lumberjacking].Value);
+                            dg.SetSkill(SkillName.Alchemy, m.Skills[SkillName.Alchemy].Value);
+                            dg.SetSkill(SkillName.Parry, m.Skills[SkillName.Parry].Value);
+                            dg.SetSkill(SkillName.Focus, m.Skills[SkillName.Focus].Value);
+                            dg.SetSkill(SkillName.Necromancy, m.Skills[SkillName.Necromancy].Value);
+                            dg.SetSkill(SkillName.Chivalry, m.Skills[SkillName.Chivalry].Value);
+                            dg.SetSkill(SkillName.ArmsLore, m.Skills[SkillName.ArmsLore].Value);
+                            dg.SetSkill(SkillName.Poisoning, m.Skills[SkillName.Poisoning].Value);
+                            dg.SetSkill(SkillName.SpiritSpeak, m.Skills[SkillName.SpiritSpeak].Value);
+                            dg.SetSkill(SkillName.Stealing, m.Skills[SkillName.Stealing].Value);
+                            dg.SetSkill(SkillName.Inscribe, m.Skills[SkillName.Inscribe].Value);
+                            dg.Kills = (m.Kills);
+
+
+                            // Clear Items
+                            RemoveFromAllLayers(dg);
+
+                            // Then copy
+                            CopyFromLayer(m, dg, Layer.FirstValid);
+                            CopyFromLayer(m, dg, Layer.TwoHanded);
+                            CopyFromLayer(m, dg, Layer.Shoes);
+                            CopyFromLayer(m, dg, Layer.Pants);
+                            CopyFromLayer(m, dg, Layer.Shirt);
+                            CopyFromLayer(m, dg, Layer.Helm);
+                            CopyFromLayer(m, dg, Layer.Gloves);
+                            CopyFromLayer(m, dg, Layer.Ring);
+                            CopyFromLayer(m, dg, Layer.Talisman);
+                            CopyFromLayer(m, dg, Layer.Neck);
+                            CopyFromLayer(m, dg, Layer.Hair);
+                            CopyFromLayer(m, dg, Layer.Waist);
+                            CopyFromLayer(m, dg, Layer.InnerTorso);
+                            CopyFromLayer(m, dg, Layer.Bracelet);
+                           // CopyFromLayer(m, dg, Layer.Unused_xF);
+                            CopyFromLayer(m, dg, Layer.FacialHair);
+                            CopyFromLayer(m, dg, Layer.MiddleTorso);
+                            CopyFromLayer(m, dg, Layer.Earrings);
+                            CopyFromLayer(m, dg, Layer.Arms);
+                            CopyFromLayer(m, dg, Layer.Cloak);
+                            CopyFromLayer(m, dg, Layer.OuterTorso);
+                            CopyFromLayer(m, dg, Layer.OuterLegs);
+                            CopyFromLayer(m, dg, Layer.LastUserValid);
+                            CopyFromLayer(m, dg, Layer.Mount);
+                            dg.ControlSlots = 5;
+                            dg.Controlled = true;
+                            dg.ControlMaster = Caster;
+                            TimeSpan duration = TimeSpan.FromSeconds(Caster.Skills[SkillName.Magery].Value * 1.2); // 120% of magery
+                            m_Timer = new InternalTimer(dg, duration);
+                            dg.Map = m.Map;
+                            dg.Location = m.Location;
+                            m.Blessed = true;
+                            m.Hidden = true;
+                            m.Location = new Point3D(m.X, m.Y, m.Z - 95);
+                        }
+                        else
+                        {
+                            Caster.SendMessage("You fail to charm them.");
+                        }
+                    }
+                }
+                else
+                {
+                    Caster.SendMessage("You have no chance of charming them.");
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private void CopyFromLayer(Mobile from, Mobile mimic, Layer layer)
+        {
+            if (mimic.FindItemOnLayer(layer) != null && mimic.FindItemOnLayer(layer).LootType != LootType.Blessed)
+                mimic.FindItemOnLayer(layer).LootType = LootType.Newbied;
+        }
+
+        private void DeleteFromLayer(Mobile from, Layer layer)
+        {
+            if (from.FindItemOnLayer(layer) != null)
+                from.RemoveItem(from.FindItemOnLayer(layer));
+        }
+        private void RemoveFromAllLayers(Mobile from)
+        {
+            DeleteFromLayer(from, Layer.FirstValid);
+            DeleteFromLayer(from, Layer.TwoHanded);
+            DeleteFromLayer(from, Layer.Shoes);
+            DeleteFromLayer(from, Layer.Pants);
+            DeleteFromLayer(from, Layer.Shirt);
+            DeleteFromLayer(from, Layer.Helm);
+            DeleteFromLayer(from, Layer.Gloves);
+            DeleteFromLayer(from, Layer.Ring);
+            DeleteFromLayer(from, Layer.Talisman);
+            DeleteFromLayer(from, Layer.Neck);
+            DeleteFromLayer(from, Layer.Hair);
+            DeleteFromLayer(from, Layer.Waist);
+            DeleteFromLayer(from, Layer.InnerTorso);
+            DeleteFromLayer(from, Layer.Bracelet);
+            //DeleteFromLayer(from, Layer.Unused_xF);
+            DeleteFromLayer(from, Layer.FacialHair);
+            DeleteFromLayer(from, Layer.MiddleTorso);
+            DeleteFromLayer(from, Layer.Earrings);
+            DeleteFromLayer(from, Layer.Arms);
+            DeleteFromLayer(from, Layer.Cloak);
+            DeleteFromLayer(from, Layer.OuterTorso);
+            DeleteFromLayer(from, Layer.OuterLegs);
+            DeleteFromLayer(from, Layer.LastUserValid);
+            DeleteFromLayer(from, Layer.Mount);
+
+        }
+
+        private class InternalTimer : Timer
+        {
+            private CharmedMobile m_Item;
+
+            public InternalTimer(CharmedMobile item, TimeSpan duration)
+                : base(duration)
+            {
+                m_Item = item;
+            }
+
+            protected override void OnTick()
+            {
+                if (m_Item != null)
+                    m_Item.Delete();
+
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientCharmSpell m_Owner;
+
+            public InternalTarget(AncientCharmSpell owner)
+                : base(12, false, TargetFlags.Harmful)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Mobile)
+                    m_Owner.Target((Mobile)o);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/CloneSpell.cs

@@ -0,0 +1,312 @@
+using System;
+using System.Reflection;
+using Server.Targeting;
+using Server.Network;
+using Server.Mobiles;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientCloneSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Clone", "In Quas Xen",
+            //SpellCircle.Sixth,
+                                                        230,
+                                                        9022,
+                                                        Reagent.SulfurousAsh,
+                                                        Reagent.SpidersSilk,
+                                                        Reagent.Bloodmoss,
+                                                        Reagent.Ginseng,
+                                                        Reagent.Nightshade,
+                                                        Reagent.MandrakeRoot
+                                                       );
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Sixth; }
+        }
+
+        public AncientCloneSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if(CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public override TimeSpan CastDelayBase
+        {
+            get { return base.CastDelayBase.Add(TimeSpan.FromSeconds(28)); }
+        }
+
+        public override double CastDelayFastScalar
+        {
+            get { return 5.0; }
+        }
+
+        public override TimeSpan GetCastDelay()
+        {
+            if (Core.AOS)
+                return base.GetCastDelay();
+
+            return base.GetCastDelay() + TimeSpan.FromSeconds(6.0);
+        }
+
+        public void Target(Mobile m)
+        {
+            if (!Caster.CanSee(m))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (CheckHSequence(m))
+            {
+                Mobile source = Caster;
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                SpellHelper.Turn(Caster, m);
+
+                Clone dg = new Clone(m);
+
+                dg.Body = m.Body;
+
+                dg.Hue = m.Hue;
+                dg.Name = m.Name;
+                dg.SpeechHue = m.SpeechHue;
+                dg.Fame = m.Fame;
+                dg.Karma = (0 - m.Karma);
+                dg.EmoteHue = m.EmoteHue;
+                dg.Title = m.Title;
+                dg.Criminal = (m.Criminal);
+                dg.Str = m.Str;
+                dg.Int = m.Int;
+                dg.Hits = m.Hits;
+                dg.Dex = m.Dex;
+                dg.Mana = m.Mana;
+                dg.Stam = m.Stam;
+                dg.Female = m.Female;
+                dg.AccessLevel = m.AccessLevel;
+
+                dg.VirtualArmor = (m.VirtualArmor);
+                dg.SetSkill(SkillName.Wrestling, m.Skills[SkillName.Wrestling].Value);
+                dg.SetSkill(SkillName.Tactics, m.Skills[SkillName.Tactics].Value);
+                dg.SetSkill(SkillName.Anatomy, m.Skills[SkillName.Anatomy].Value);
+
+                dg.SetSkill(SkillName.Magery, m.Skills[SkillName.Magery].Value);
+                dg.SetSkill(SkillName.MagicResist, m.Skills[SkillName.MagicResist].Value);
+                dg.SetSkill(SkillName.Meditation, m.Skills[SkillName.Meditation].Value);
+                dg.SetSkill(SkillName.EvalInt, m.Skills[SkillName.EvalInt].Value);
+
+                dg.SetSkill(SkillName.Archery, m.Skills[SkillName.Archery].Value);
+                dg.SetSkill(SkillName.Macing, m.Skills[SkillName.Macing].Value);
+                dg.SetSkill(SkillName.Swords, m.Skills[SkillName.Swords].Value);
+                dg.SetSkill(SkillName.Fencing, m.Skills[SkillName.Fencing].Value);
+                dg.SetSkill(SkillName.Lumberjacking, m.Skills[SkillName.Lumberjacking].Value);
+                dg.SetSkill(SkillName.Alchemy, m.Skills[SkillName.Alchemy].Value);
+                dg.SetSkill(SkillName.Parry, m.Skills[SkillName.Parry].Value);
+                dg.SetSkill(SkillName.Focus, m.Skills[SkillName.Focus].Value);
+                dg.SetSkill(SkillName.Necromancy, m.Skills[SkillName.Necromancy].Value);
+                dg.SetSkill(SkillName.Chivalry, m.Skills[SkillName.Chivalry].Value);
+                dg.SetSkill(SkillName.ArmsLore, m.Skills[SkillName.ArmsLore].Value);
+                dg.SetSkill(SkillName.Poisoning, m.Skills[SkillName.Poisoning].Value);
+                dg.SetSkill(SkillName.SpiritSpeak, m.Skills[SkillName.SpiritSpeak].Value);
+                dg.SetSkill(SkillName.Stealing, m.Skills[SkillName.Stealing].Value);
+                dg.SetSkill(SkillName.Inscribe, m.Skills[SkillName.Inscribe].Value);
+                dg.Kills = (m.Kills);
+
+
+                // Clear Items
+                RemoveFromAllLayers(dg);
+
+                // Then copy
+                CopyFromLayer(m, dg, Layer.FirstValid);
+                CopyFromLayer(m, dg, Layer.TwoHanded);
+                CopyFromLayer(m, dg, Layer.Shoes);
+                CopyFromLayer(m, dg, Layer.Pants);
+                CopyFromLayer(m, dg, Layer.Shirt);
+                CopyFromLayer(m, dg, Layer.Helm);
+                CopyFromLayer(m, dg, Layer.Gloves);
+                CopyFromLayer(m, dg, Layer.Ring);
+                CopyFromLayer(m, dg, Layer.Talisman);
+                CopyFromLayer(m, dg, Layer.Neck);
+                CopyFromLayer(m, dg, Layer.Hair);
+                CopyFromLayer(m, dg, Layer.Waist);
+                CopyFromLayer(m, dg, Layer.InnerTorso);
+                CopyFromLayer(m, dg, Layer.Bracelet);
+                //CopyFromLayer(m, dg, Layer.Unused_xF);
+                CopyFromLayer(m, dg, Layer.FacialHair);
+                CopyFromLayer(m, dg, Layer.MiddleTorso);
+                CopyFromLayer(m, dg, Layer.Earrings);
+                CopyFromLayer(m, dg, Layer.Arms);
+                CopyFromLayer(m, dg, Layer.Cloak);
+                CopyFromLayer(m, dg, Layer.OuterTorso);
+                CopyFromLayer(m, dg, Layer.OuterLegs);
+                CopyFromLayer(m, dg, Layer.LastUserValid);
+                DupeFromLayer(m, dg, Layer.Mount);
+                dg.ControlSlots = 5;
+                SpellHelper.Summon(dg, Caster, 0x215, TimeSpan.FromSeconds(4.0 * Caster.Skills[SkillName.Magery].Value), false, false);
+
+            }
+
+            FinishSequence();
+        }
+
+        private void CopyFromLayer(Mobile from, Mobile mimic, Layer layer)
+        {
+            if (from.FindItemOnLayer(layer) != null)
+            {
+                Item copy = (Item)from.FindItemOnLayer(layer);
+                Type t = copy.GetType();
+
+                ConstructorInfo[] info = t.GetConstructors();
+
+                foreach (ConstructorInfo c in info)
+                {
+                    //if ( !c.IsDefined( typeof( ConstructableAttribute ), false ) ) continue;
+
+                    ParameterInfo[] paramInfo = c.GetParameters();
+
+                    if (paramInfo.Length == 0)
+                    {
+                        object[] objParams = new object[0];
+
+                        try
+                        {
+                            Item newItem = null;
+                            object o = c.Invoke(objParams);
+
+                            if (o != null && o is Item)
+                            {
+                                newItem = (Item)o;
+                                CopyProperties(newItem, copy);//copy.Dupe( item, copy.Amount );
+                                newItem.Parent = null;
+
+                                mimic.EquipItem(newItem);
+                            }
+
+                            if (newItem != null)
+                            {
+                                if (newItem is BaseWeapon && o is BaseWeapon)
+                                {
+                                    BaseWeapon weapon = newItem as BaseWeapon;
+                                    BaseWeapon oweapon = o as BaseWeapon;
+                                    weapon.Attributes = oweapon.Attributes;
+                                    weapon.WeaponAttributes = oweapon.WeaponAttributes;
+
+                                }
+                                if (newItem is BaseArmor && o is BaseArmor)
+                                {
+                                    BaseArmor armor = newItem as BaseArmor;
+                                    BaseArmor oarmor = o as BaseArmor;
+                                    armor.Attributes = oarmor.Attributes;
+                                    armor.ArmorAttributes = oarmor.ArmorAttributes;
+                                    armor.SkillBonuses = oarmor.SkillBonuses;
+
+                                }
+
+                                mimic.EquipItem(newItem);
+                            }
+                        }
+                        catch
+                        {
+                            from.Say("Error!");
+                            return;
+                        }
+                    }
+                }
+            }
+
+            if (mimic.FindItemOnLayer(layer) != null && mimic.FindItemOnLayer(layer).LootType != LootType.Blessed)
+                mimic.FindItemOnLayer(layer).LootType = LootType.Newbied;
+        }
+
+        private void DupeFromLayer(Mobile from, Mobile mimic, Layer layer)
+        {
+            //if (from.FindItemOnLayer(layer) != null)
+            //	mimic.AddItem(from.FindItemOnLayer(layer).Dupe(1));
+
+            if (mimic.FindItemOnLayer(layer) != null && mimic.FindItemOnLayer(layer).LootType != LootType.Blessed)
+                mimic.FindItemOnLayer(layer).LootType = LootType.Newbied;
+        }
+
+        private static void CopyProperties(Item dest, Item src)
+        {
+            PropertyInfo[] props = src.GetType().GetProperties();
+
+            for (int i = 0; i < props.Length; i++)
+            {
+                try
+                {
+                    if (props[i].CanRead && props[i].CanWrite)
+                    {
+                        //Console.WriteLine( "Setting {0} = {1}", props[i].Name, props[i].GetValue( src, null ) );
+                        props[i].SetValue(dest, props[i].GetValue(src, null), null);
+                    }
+                }
+                catch
+                {
+                    //Console.WriteLine( "Denied" );
+                }
+            }
+        }
+
+        private void DeleteFromLayer(Mobile from, Layer layer)
+        {
+            if (from.FindItemOnLayer(layer) != null)
+                from.RemoveItem(from.FindItemOnLayer(layer));
+        }
+
+        private void RemoveFromAllLayers(Mobile from)
+        {
+            DeleteFromLayer(from, Layer.FirstValid);
+            DeleteFromLayer(from, Layer.TwoHanded);
+            DeleteFromLayer(from, Layer.Shoes);
+            DeleteFromLayer(from, Layer.Pants);
+            DeleteFromLayer(from, Layer.Shirt);
+            DeleteFromLayer(from, Layer.Helm);
+            DeleteFromLayer(from, Layer.Gloves);
+            DeleteFromLayer(from, Layer.Ring);
+            DeleteFromLayer(from, Layer.Talisman);
+            DeleteFromLayer(from, Layer.Neck);
+            DeleteFromLayer(from, Layer.Hair);
+            DeleteFromLayer(from, Layer.Waist);
+            DeleteFromLayer(from, Layer.InnerTorso);
+            DeleteFromLayer(from, Layer.Bracelet);
+           // DeleteFromLayer(from, Layer.Unused_xF);
+            DeleteFromLayer(from, Layer.FacialHair);
+            DeleteFromLayer(from, Layer.MiddleTorso);
+            DeleteFromLayer(from, Layer.Earrings);
+            DeleteFromLayer(from, Layer.Arms);
+            DeleteFromLayer(from, Layer.Cloak);
+            DeleteFromLayer(from, Layer.OuterTorso);
+            DeleteFromLayer(from, Layer.OuterLegs);
+            DeleteFromLayer(from, Layer.LastUserValid);
+            DeleteFromLayer(from, Layer.Mount);
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientCloneSpell m_Owner;
+
+            public InternalTarget(AncientCloneSpell owner)
+                : base(12, false, TargetFlags.Harmful)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Mobile)
+                    m_Owner.Target((Mobile)o);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/DanceSpell.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections;
+using Server.Misc;
+using Server.Targeting;
+using Server.Network;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientDanceSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Dance", "Por Xen",
+                                                        218,
+                                                        9031,
+                                                        Reagent.Garlic,
+                                                        Reagent.Bloodmoss,
+                                                        Reagent.MandrakeRoot
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Fifth; }
+        }
+
+        public AncientDanceSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else
+            {
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                SpellHelper.Turn(Caster, p);
+
+                SpellHelper.GetSurfaceTop(ref p);
+
+                ArrayList targets = new ArrayList();
+
+                Map map = Caster.Map;
+
+                if (map != null)
+                {
+                    IPooledEnumerable eable = map.GetMobilesInRange(new Point3D(p), 3);
+
+                    foreach (Mobile m in eable)
+                    {
+                        if (Core.AOS && m == Caster)
+                            continue;
+
+                        if (SpellHelper.ValidIndirectTarget(Caster, m) && Caster.CanSee(m))
+                            targets.Add(m);
+                    }
+
+                    eable.Free();
+                }
+
+                for (int i = 0; i < targets.Count; ++i)
+                {
+                    Mobile m = (Mobile)targets[i];
+                    if (Caster.CanBeHarmful(m, false))
+                    {
+                        Caster.DoHarmful(m);
+                        m.Stam = 0;
+                    }
+                    m.Freeze(TimeSpan.FromSeconds(4)); //freeze for animation
+
+                    m.Animate(111, 5, 1, true, false, 0); // Do a little dance...
+
+
+                    m.FixedParticles(0x374A, 10, 15, 5028, EffectLayer.CenterFeet);
+                    m.PlaySound(0x1FB);
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientDanceSpell m_Owner;
+
+            public InternalTarget(AncientDanceSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                IPoint3D p = o as IPoint3D;
+
+                if (p != null)
+                    m_Owner.Target(p);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/DeathVortexSpell.cs

@@ -0,0 +1,101 @@
+using System;
+using Server.Mobiles;
+using Server.Network;
+using Server.Targeting;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientDeathVortexSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Death Vortex", "Vas Corp Hur",
+                                                        260,
+                                                        9032,
+                                                        false,
+                                                        Reagent.Bloodmoss,
+                                                        Reagent.SulfurousAsh,
+                                                        Reagent.MandrakeRoot,
+                                                        Reagent.Nightshade
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Eighth; }
+        }
+
+        public AncientDeathVortexSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override bool CheckCast()
+        {
+            if (!base.CheckCast())
+                return false;
+
+            if ((Caster.Followers + 1) > Caster.FollowersMax)
+            {
+                Caster.SendLocalizedMessage(1049645); // You have too many followers to summon that creature.
+                return false;
+            }
+
+            return true;
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(IPoint3D p)
+        {
+            Map map = Caster.Map;
+
+            SpellHelper.GetSurfaceTop(ref p);
+
+            if (map == null || !map.CanSpawnMobile(p.X, p.Y, p.Z))
+            {
+                Caster.SendLocalizedMessage(501942); // That location is blocked.
+            }
+            else if (SpellHelper.CheckTown(p, Caster) && CheckSequence())
+            {
+                BaseCreature.Summon(new DeathVortex(), false, Caster, new Point3D(p), 0x212, TimeSpan.FromSeconds(Utility.Random(80, 40)));
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientDeathVortexSpell m_Owner;
+
+            public InternalTarget(AncientDeathVortexSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is IPoint3D)
+                    m_Owner.Target((IPoint3D)o);
+            }
+
+            protected override void OnTargetOutOfLOS(Mobile from, object o)
+            {
+                from.SendLocalizedMessage(501943); // Target cannot be seen. Try again.
+                from.Target = new InternalTarget(m_Owner);
+                from.Target.BeginTimeout(from, TimeoutTime - DateTime.Now);
+                m_Owner = null;
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                if (m_Owner != null)
+                    m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/DestroyTrapSpell.cs

@@ -0,0 +1,94 @@
+using System;
+using Server.Targeting;
+using Server.Network;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientDestroyTrapSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Destroy Trap", "An Jux",
+                                                        212,
+                                                        9001,
+                                                        Reagent.Bloodmoss,
+                                                        Reagent.SulfurousAsh
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Second; }
+        }
+
+        public AncientDestroyTrapSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+            {
+                Caster.Target = new InternalTarget(this);
+                Caster.SendMessage("Which trap do you wish to destroy?");
+            }
+        }
+
+        public void Target(HouseTrap item)
+        {
+            if (!Caster.CanSee(item))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (CheckSequence())
+            {
+                SpellHelper.Turn(Caster, item);
+
+                Point3D loc = item.GetWorldLocation();
+
+                Blood shards = new Blood();
+                shards.ItemID = 0xC2D;
+                shards.Map = item.Map;
+                shards.Location = loc;
+                Effects.PlaySound(loc, item.Map, 0x305);
+                if (item.Placer != null)
+                    item.Placer.SendMessage("A trap you placed has been destroyed!");
+
+
+                item.Delete();
+                Caster.SendMessage("You destroy the trap!");
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientDestroyTrapSpell m_Owner;
+
+            public InternalTarget(AncientDestroyTrapSpell owner)
+                : base(12, false, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is HouseTrap)
+                {
+                    m_Owner.Target((HouseTrap)o);
+                }
+                else
+                {
+                    from.SendMessage("You can't destroy that");
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/DetectTrapSpell.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections;
+using Server.Misc;
+using Server.Targeting;
+using Server.Network;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientDetectTrapSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Detect Trap", "Wis Jux",
+                                                        206,
+                                                        9002,
+                                                        Reagent.SpidersSilk,
+                                                        Reagent.Nightshade
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public AncientDetectTrapSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        private static Hashtable m_UnderEffect = new Hashtable();
+
+        private static void RemoveEffect(object state)
+        {
+            Mobile m = (Mobile)state;
+
+            m_UnderEffect.Remove(m);
+
+            m.SendMessage("You can no longer see hidden traps");
+        }
+
+        public static bool UnderEffect(Mobile m)
+        {
+            return m_UnderEffect.Contains(m);
+        }
+
+        public void Target(Mobile m)
+        {
+            if (!Caster.CanSee(m))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (CheckSequence())
+            {
+                SpellHelper.Turn(Caster, m);
+
+                Timer t = (Timer)m_UnderEffect[m];
+
+                if (Caster.Player && m.Player && t == null)
+                {
+                    TimeSpan duration = SpellHelper.GetDuration(Caster, m);
+                    m_UnderEffect[m] = t = Timer.DelayCall(duration, new TimerStateCallback(RemoveEffect), m);
+                    m.SendMessage("You can now see hidden traps!");
+                    Map duck = m.Map;
+                    if (duck == Map.Felucca)
+                        m.Map = Map.Malas;
+                    else
+                        m.Map = Map.Felucca;
+                    m.Map = duck;
+                    m.FixedParticles(0x3818, 10, 15, 5028, EffectLayer.Head);
+                    m.PlaySound(0x104);
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientDetectTrapSpell m_Owner;
+
+            public InternalTarget(AncientDetectTrapSpell owner)
+                : base(12, false, TargetFlags.Beneficial)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Mobile)
+                    m_Owner.Target((Mobile)o);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/DouseSpell.cs

@@ -0,0 +1,100 @@
+using System;
+using Server.Targeting;
+using Server.Network;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientDouseSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Douse", "An Flam",
+                                                        212,
+                                                        9001,
+                                                        Reagent.Bloodmoss
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public override double CastDelay { get { return 1.0; } }
+        public override double RequiredSkill { get { return 0.0; } }
+        public override int RequiredMana { get { return 5; } }
+
+        public AncientDouseSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+            {
+                Caster.Target = new InternalTarget(this);
+                Caster.SendMessage("What do you wish to douse?");
+            }
+        }
+
+        public void Target(NaturalFire item)
+        {
+            if (!Caster.CanSee(item))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+
+            else if (CheckSequence())
+            {
+                SpellHelper.Turn(Caster, item);
+
+                Point3D loc = item.GetWorldLocation();
+
+
+                Effects.PlaySound(loc, item.Map, 0x11);
+                IEntity to = new Entity(Serial.Zero, new Point3D(Caster.X, Caster.Y, Caster.Z), Caster.Map);
+                IEntity from = new Entity(Serial.Zero, new Point3D(Caster.X, Caster.Y, Caster.Z + 50), Caster.Map);
+                Effects.SendMovingParticles(from, to, 0x376A, 1, 0, false, false, 33, 3, 1263, 1, 0, EffectLayer.Head, 0x100);
+
+
+                item.Delete();
+                Caster.SendMessage("You douse the flames!");
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientDouseSpell m_Owner;
+
+            public InternalTarget(AncientDouseSpell owner)
+                : base(12, false, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is NaturalFire)
+                {
+                    m_Owner.Target((NaturalFire)o);
+                }
+                else if (o is GreaterNaturalFire)
+                {
+                    from.SendMessage("Your spell is not powerful enough to douse that!");
+                }
+                else
+                {
+                    from.SendMessage("You can't douse that!");
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/EnchantSpell.cs

@@ -0,0 +1,180 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Items;
+using Server.Gumps;
+using Server.Spells;
+using Server.Targeting;
+using Server.Network;
+using Server.Regions;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientEnchantSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Enchant", "Ort Ylem",
+                                                        218,
+                                                        9002,
+                                                        Reagent.BlackPearl,
+                                                        Reagent.MandrakeRoot
+                                                       );
+
+        private int m_Hue;
+        private string m_Name;
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Second; }
+        }
+
+        public AncientEnchantSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+            {
+                m_Name = null;
+                Caster.Target = new InternalTarget(this);
+            }
+        }
+
+        public override bool CheckCast()
+        {
+            if (!base.CheckCast())
+                return false;
+
+            return SpellHelper.CheckTravel(Caster, TravelCheckType.Mark);
+        }
+
+        public void Target(BaseRanged weapon)
+        {
+            if (!Caster.CanSee(weapon))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (!Caster.CanBeginAction(typeof(AncientEnchantSpell)))
+            {
+                Caster.SendLocalizedMessage(1005559); // This spell is already in effect.
+
+            }
+            else if (CheckSequence())
+            {
+                if (Caster.BeginAction(typeof(AncientEnchantSpell)))
+                {
+                    if (this.Scroll != null)
+                        Scroll.Consume();
+                    m_Hue = weapon.Hue;
+                    m_Name = weapon.Name;
+                    weapon.Name = "" + m_Name + " [enchanted]";
+                    weapon.Hue = 1366;
+                    weapon.Attributes.WeaponDamage += 10;
+                    weapon.Attributes.AttackChance += 1000;
+
+                    Caster.PlaySound(0x20C);
+                    Caster.PlaySound(0x145);
+                    Caster.FixedParticles(0x3779, 1, 30, 9964, 3, 3, EffectLayer.Waist);
+
+                    IEntity from = new Entity(Serial.Zero, new Point3D(Caster.X, Caster.Y, Caster.Z), Caster.Map);
+                    IEntity to = new Entity(Serial.Zero, new Point3D(Caster.X, Caster.Y, Caster.Z + 50), Caster.Map);
+                    Effects.SendMovingParticles(from, to, 0x13B1, 1, 0, false, false, 33, 3, 9501, 1, 0, EffectLayer.Head, 0x100);
+                    StopTimer(Caster);
+
+                    Timer t = new InternalTimer(Caster, weapon, m_Hue, m_Name);
+
+                    m_Timers[Caster] = t;
+
+                    t.Start();
+                }
+                else if (!Caster.CanBeginAction(typeof(AncientEnchantSpell)))
+                {
+                    DoFizzle();
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientEnchantSpell m_Owner;
+
+            public InternalTarget(AncientEnchantSpell owner)
+                : base(12, false, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is BaseRanged)
+                {
+                    m_Owner.Target((BaseRanged)o);
+                }
+                else
+                {
+                    from.SendMessage("That cannot be enchanted."); // I cannot mark that object.
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+        private static Hashtable m_Timers = new Hashtable();
+
+        public static bool StopTimer(Mobile m)
+        {
+            Timer t = (Timer)m_Timers[m];
+
+            if (t != null)
+            {
+                t.Stop();
+                m_Timers.Remove(m);
+            }
+
+            return (t != null);
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Mobile m_Owner;
+            private BaseRanged m_Weapon;
+            private int m_weaponhue;
+            private string m_Name;
+
+            public InternalTimer(Mobile owner, BaseRanged weapon, int m_Hue, string m_WeaponName)
+                : base(TimeSpan.FromSeconds(0))
+            {
+                m_Owner = owner;
+                m_Weapon = weapon;
+                m_weaponhue = m_Hue;
+                m_Name = m_WeaponName;
+
+                int val = (int)owner.Skills[SkillName.Magery].Value;
+
+                if (val > 100)
+                    val = 100;
+
+                Delay = TimeSpan.FromSeconds(val);
+                Priority = TimerPriority.TwoFiftyMS;
+            }
+
+            protected override void OnTick()
+            {
+                if (!m_Owner.CanBeginAction(typeof(AncientEnchantSpell)))
+                {
+                    m_Weapon.Hue = m_weaponhue;
+                    m_Weapon.Name = m_Name;
+                    m_Weapon.Attributes.WeaponDamage -= 10;
+                    m_Weapon.Attributes.AttackChance -= 1000;
+                    m_Owner.EndAction(typeof(AncientEnchantSpell));
+                }
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/FalseCoinSpell.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Items;
+using Server.Gumps;
+using Server.Spells;
+using Server.Targeting;
+using Server.Network;
+using Server.Regions;
+using Server.Mobiles;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientFalseCoinSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "False Coin", "Rel Ylem",
+                                                        218,
+                                                        9002,
+                                                        Reagent.Nightshade,
+                                                        Reagent.SulfurousAsh
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Second; }
+        }
+
+        private FakeGold m_Fake;
+
+        public AncientFalseCoinSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public override bool CheckCast()
+        {
+            if (!base.CheckCast())
+                return false;
+
+            return SpellHelper.CheckTravel(Caster, TravelCheckType.Mark);
+        }
+
+        public void Target(Gold weapon)
+        {
+            if (!Caster.CanSee(weapon))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+
+            else if (CheckSequence())
+            {
+                if (Caster.BeginAction(typeof(AncientFalseCoinSpell)))
+                {
+                    if (this.Scroll != null)
+                        Scroll.Consume();
+                    FakeGold fake = new FakeGold();
+                    fake.m_Amount = weapon.Amount * 5;
+                    fake.Name = "" + (weapon.Amount * 5) + " Gold Coins";
+                    m_Fake = fake;
+                    Caster.AddToBackpack(fake);
+                    Caster.PlaySound(0x2E6);
+
+                    IEntity from = new Entity(Serial.Zero, new Point3D(Caster.X, Caster.Y, Caster.Z + 50), Caster.Map);
+                    IEntity to = new Entity(Serial.Zero, new Point3D(Caster.X, Caster.Y, Caster.Z), Caster.Map);
+                    Effects.SendMovingParticles(from, to, 0x1EC6, 1, 0, false, false, 33, 3, 9501, 1, 0, EffectLayer.Head, 0x100);
+                    StopTimer(Caster);
+
+
+                    Timer t = new InternalTimer(Caster, m_Fake);
+
+                    m_Timers[Caster] = t;
+
+                    t.Start();
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientFalseCoinSpell m_Owner;
+
+            public InternalTarget(AncientFalseCoinSpell owner)
+                : base(12, false, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Gold)
+                {
+                    m_Owner.Target((Gold)o);
+                }
+                else
+                {
+                    from.SendMessage("That cannot be copied."); // I cannot mark that object.
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+        private static Hashtable m_Timers = new Hashtable();
+
+        public static bool StopTimer(Mobile m)
+        {
+            Timer t = (Timer)m_Timers[m];
+
+            if (t != null)
+            {
+                t.Stop();
+                m_Timers.Remove(m);
+            }
+
+            return (t != null);
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Mobile m_Owner;
+            private FakeGold m_Weapon;
+
+
+            public InternalTimer(Mobile owner, FakeGold weapon)
+                : base(TimeSpan.FromSeconds(0))
+            {
+                m_Owner = owner;
+                m_Weapon = weapon;
+
+                int val = (int)owner.Skills[SkillName.Magery].Value;
+
+                if (val > 100)
+                    val = 100;
+
+                Delay = TimeSpan.FromSeconds(val);
+                Priority = TimerPriority.TwoFiftyMS;
+            }
+
+            protected override void OnTick()
+            {
+                if (!m_Owner.CanBeginAction(typeof(AncientFalseCoinSpell)))
+                {
+                    if (m_Weapon != null)
+                    {
+                        m_Weapon.Delete();
+                        m_Owner.SendMessage("The forged coins fade away!");
+                    }
+
+                    m_Owner.EndAction(typeof(AncientFalseCoinSpell));
+                }
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/FireRingSpell.cs

@@ -0,0 +1,339 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+using Server.Misc;
+using Server.Items;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientFireRingSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Fire Ring", "Kal Flam Grav",
+                                                        233,
+                                                        9012,
+                                                        false,
+                                                        Reagent.BlackPearl,
+                                                        Reagent.SpidersSilk,
+                                                        Reagent.SulfurousAsh,
+                                                        Reagent.MandrakeRoot
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Sixth; }
+        }
+
+        public AncientFireRingSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (SpellHelper.CheckTown(p, Caster) && CheckSequence())
+            {
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                SpellHelper.Turn(Caster, p);
+
+                SpellHelper.GetSurfaceTop(ref p);
+
+                Effects.PlaySound(p, Caster.Map, 0x1DD);
+
+                Point3D loc = new Point3D(p.X, p.Y, p.Z);
+                int mushx;
+                int mushy;
+                int mushz;
+
+                InternalItem firstFlamea = new InternalItem(Caster.Location, Caster.Map, Caster);
+                mushx = loc.X - 2;
+                mushy = loc.Y - 2;
+                mushz = loc.Z;
+                Point3D mushxyz = new Point3D(mushx, mushy, mushz);
+                firstFlamea.MoveToWorld(mushxyz, Caster.Map);
+
+                InternalItem firstFlamec = new InternalItem(Caster.Location, Caster.Map, Caster);
+                mushx = loc.X;
+                mushy = loc.Y - 3;
+                mushz = loc.Z;
+                Point3D mushxyzb = new Point3D(mushx, mushy, mushz);
+                firstFlamec.MoveToWorld(mushxyzb, Caster.Map);
+
+                InternalItem firstFlamed = new InternalItem(Caster.Location, Caster.Map, Caster);
+                firstFlamed.ItemID = 0x3709;
+                mushx = loc.X + 2;
+                mushy = loc.Y - 2;
+                mushz = loc.Z;
+                Point3D mushxyzc = new Point3D(mushx, mushy, mushz);
+                firstFlamed.MoveToWorld(mushxyzc, Caster.Map);
+                InternalItem firstFlamee = new InternalItem(Caster.Location, Caster.Map, Caster);
+                mushx = loc.X + 3;
+                firstFlamee.ItemID = 0x3709;
+                mushy = loc.Y;
+                mushz = loc.Z;
+                Point3D mushxyzd = new Point3D(mushx, mushy, mushz);
+                firstFlamee.MoveToWorld(mushxyzd, Caster.Map);
+                InternalItem firstFlamef = new InternalItem(Caster.Location, Caster.Map, Caster);
+                firstFlamef.ItemID = 0x3709;
+                mushx = loc.X + 2;
+                mushy = loc.Y + 2;
+                mushz = loc.Z;
+                Point3D mushxyze = new Point3D(mushx, mushy, mushz);
+                firstFlamef.MoveToWorld(mushxyze, Caster.Map);
+                InternalItem firstFlameg = new InternalItem(Caster.Location, Caster.Map, Caster);
+                mushx = loc.X;
+                firstFlameg.ItemID = 0x3709;
+                mushy = loc.Y + 3;
+                mushz = loc.Z;
+                Point3D mushxyzf = new Point3D(mushx, mushy, mushz);
+                firstFlameg.MoveToWorld(mushxyzf, Caster.Map);
+                InternalItem firstFlameh = new InternalItem(Caster.Location, Caster.Map, Caster);
+                mushx = loc.X - 2;
+                firstFlameh.ItemID = 0x3709;
+                mushy = loc.Y + 2;
+                mushz = loc.Z;
+                Point3D mushxyzg = new Point3D(mushx, mushy, mushz);
+                firstFlameh.MoveToWorld(mushxyzg, Caster.Map);
+                InternalItem firstFlamei = new InternalItem(Caster.Location, Caster.Map, Caster);
+                mushx = loc.X - 3;
+                firstFlamei.ItemID = 0x3709;
+                mushy = loc.Y;
+                mushz = loc.Z;
+                Point3D mushxyzh = new Point3D(mushx, mushy, mushz);
+                firstFlamei.MoveToWorld(mushxyzh, Caster.Map);
+            }
+
+            FinishSequence();
+        }
+
+        [DispellableField]
+        private class InternalItem : Item
+        {
+            private Timer m_Timer;
+            private Timer m_Burn;
+            private DateTime m_End;
+            private Mobile m_Caster;
+
+            public override bool BlocksFit { get { return true; } }
+
+            public InternalItem(Point3D loc, Map map, Mobile caster)
+                : base(0x3709)
+            {
+                Visible = false;
+                Movable = false;
+                Light = LightType.Circle150;
+                MoveToWorld(loc, map);
+                m_Caster = caster;
+
+                if (caster.InLOS(this))
+                    Visible = true;
+                else
+                    Delete();
+
+                if (Deleted)
+                    return;
+
+                m_Timer = new InternalTimer(this, TimeSpan.FromSeconds(30.0));
+                m_Timer.Start();
+                m_Burn = new BurnTimer(this, m_Caster);
+                m_Burn.Start();
+
+                m_End = DateTime.Now + TimeSpan.FromSeconds(30.0);
+            }
+
+            public InternalItem(Serial serial)
+                : base(serial)
+            {
+            }
+
+            public override bool OnMoveOver(Mobile m)
+            {
+                if (Visible && m_Caster != null && SpellHelper.ValidIndirectTarget(m_Caster, m) && m_Caster.CanBeHarmful(m, false))
+                {
+                    m_Caster.DoHarmful(m);
+
+                    int damage = Utility.Random(18, 24);
+
+                    if (!Core.AOS && m.CheckSkill(SkillName.MagicResist, 0.0, 30.0))
+                    {
+                        damage = Utility.Random(9, 12);
+
+                        m.SendLocalizedMessage(501783); // You feel yourself resisting magical energy.
+                    }
+
+                    AOS.Damage(m, m_Caster, damage, 0, 100, 0, 0, 0);
+                    m.PlaySound(0x1DD);
+                }
+
+                return true;
+            }
+
+            public override void Serialize(GenericWriter writer)
+            {
+                base.Serialize(writer);
+
+                writer.Write((int)1); // version
+
+                writer.Write(m_End - DateTime.Now);
+            }
+
+            public override void Deserialize(GenericReader reader)
+            {
+                base.Deserialize(reader);
+
+                int version = reader.ReadInt();
+
+                switch (version)
+                {
+                    case 1:
+                        {
+                            TimeSpan duration = reader.ReadTimeSpan();
+
+                            m_Timer = new InternalTimer(this, duration);
+                            m_Timer.Start();
+
+                            m_End = DateTime.Now + duration;
+
+                            break;
+                        }
+                    case 0:
+                        {
+                            TimeSpan duration = TimeSpan.FromSeconds(10.0);
+
+                            m_Timer = new InternalTimer(this, duration);
+                            m_Timer.Start();
+
+                            m_End = DateTime.Now + duration;
+
+                            break;
+                        }
+                }
+            }
+
+            public override void OnAfterDelete()
+            {
+                base.OnAfterDelete();
+
+                if (m_Timer != null)
+                    m_Timer.Stop();
+            }
+
+            private class InternalTimer : Timer
+            {
+                private InternalItem m_Item;
+
+                public InternalTimer(InternalItem item, TimeSpan duration)
+                    : base(duration)
+                {
+                    m_Item = item;
+                }
+
+                protected override void OnTick()
+                {
+                    m_Item.Delete();
+                }
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientFireRingSpell m_Owner;
+
+            public InternalTarget(AncientFireRingSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is IPoint3D)
+                    m_Owner.Target((IPoint3D)o);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+
+        private class BurnTimer : Timer
+        {
+            private Item m_FireRing;
+            private Mobile m_Caster;
+            private DateTime m_Duration;
+
+            private static Queue m_Queue = new Queue();
+
+            public BurnTimer(Item ap, Mobile ca)
+                : base(TimeSpan.FromSeconds(0.25), TimeSpan.FromSeconds(0.5))
+            {
+                Priority = TimerPriority.FiftyMS;
+
+                m_FireRing = ap;
+                m_Caster = ca;
+                m_Duration = DateTime.Now + TimeSpan.FromSeconds(15.0 + (Utility.RandomDouble() * 15.0));
+            }
+
+            protected override void OnTick()
+            {
+                if (m_FireRing.Deleted)
+                    return;
+
+                if (DateTime.Now > m_Duration)
+                {
+                    Stop();
+                }
+                else
+                {
+                    Map map = m_FireRing.Map;
+
+                    if (map != null)
+                    {
+                        foreach (Mobile m in m_FireRing.GetMobilesInRange(1))
+                        {
+                            if ((m.Z + 16) > m_FireRing.Z && (m_FireRing.Z + 12) > m.Z)
+                                m_Queue.Enqueue(m);
+                        }
+
+                        while (m_Queue.Count > 0)
+                        {
+                            Mobile m = (Mobile)m_Queue.Dequeue();
+
+                            if (m_FireRing.Visible && m_Caster != null && SpellHelper.ValidIndirectTarget(m_Caster, m) && m_Caster.CanBeHarmful(m, false))
+                            {
+                                m_Caster.DoHarmful(m);
+
+                                int damage = Utility.Random(5, 8);
+
+                                if (!Core.AOS && m.CheckSkill(SkillName.MagicResist, 0.0, 30.0))
+                                {
+                                    damage = Utility.Random(1, 3);
+                                    m.SendLocalizedMessage(501783); // You feel yourself resisting magical energy.
+                                }
+
+                                AOS.Damage(m, m_Caster, damage, 0, 100, 0, 0, 0);
+                                m.PlaySound(0x1DD);
+                                m.SendLocalizedMessage(503000);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/FireworksSpell.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+using Server.Items;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientFireworksSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Fireworks", "Bet Ort",
+                                                        236,
+                                                        9011,
+                                                        Reagent.SulfurousAsh
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public override double CastDelay { get { return 0.5; } }
+        public override double RequiredSkill { get { return 0.0; } }
+        public override int RequiredMana { get { return 1; } }
+
+        public AncientFireworksSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override bool CheckCast()
+        {
+            return true;
+        }
+
+        private static Hashtable m_Table = new Hashtable();
+
+        public static void DrawFirework(Mobile from)
+        {
+            int[] intEffectID = { 14138, 14154, 14201 };
+
+            Point3D EffectLocation = new Point3D((from.X + Utility.Random(-4, 8)), (from.Y + Utility.Random(-4, 8)), from.Z + 20);
+            //	Effects.SendMovingParticles( from, EffectLocation, 0x36E4, 5, 0, false, false, 3006, 4006, 9501, 1, 0, EffectLayer.RightHand, 0x100 );
+            IEntity to = new Entity(Serial.Zero, EffectLocation, from.Map);
+            from.MovingParticles(to, 0x36E4, 5, 0, false, false, 3006, 4006, 0);
+            Timer t = new InternalTimer(from, EffectLocation, intEffectID);
+
+            m_Table[from] = t;
+
+            t.Start();
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Mobile m_Mobile;
+            private Point3D EffectLocation;
+            private int[] intEffectID;
+
+            public InternalTimer(Mobile m, Point3D local, int[] fwoosh)
+                : base(TimeSpan.FromSeconds(0.3))
+            {
+                m_Mobile = m;
+                EffectLocation = local;
+                intEffectID = fwoosh;
+            }
+
+            protected override void OnTick()
+            {
+                Effects.SendLocationEffect(EffectLocation, m_Mobile.Map, intEffectID[Utility.Random(0, 3)], 70, (int)(5 * Utility.Random(0, 20)) + 3, 2);
+
+                switch (Utility.Random(3))
+                {
+                    case 0: m_Mobile.PlaySound(0x11C); break;
+                    case 1: m_Mobile.PlaySound(0x11E); break;
+                    case 2: m_Mobile.PlaySound(0x11D); break;
+                }
+            }
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+            {
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                DrawFirework(Caster);
+                if (Caster.Skills[SkillName.Magery].Base >= 110)
+                    DrawFirework(Caster);
+                if (Caster.Skills[SkillName.Magery].Base >= 100)
+                    DrawFirework(Caster);
+                if (Caster.Skills[SkillName.Magery].Base >= 75)
+                    DrawFirework(Caster);
+                if (Caster.Skills[SkillName.Magery].Base >= 50)
+                    DrawFirework(Caster);
+                if (Caster.Skills[SkillName.Magery].Base >= 25)
+                    DrawFirework(Caster);
+
+                FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/GlimmerSpell.cs

@@ -0,0 +1,222 @@
+using System;
+using Server.Targeting;
+using Server.Network;
+using Server.Misc;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientGlimmerSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Glimmer", "Bet Lor",
+                                                        227,
+                                                        9011,
+                                                        Reagent.Bloodmoss
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Second; }
+        }
+
+        public override double CastDelay { get { return 1.5; } }
+        public override double RequiredSkill { get { return 0.0; } }
+        public override int RequiredMana { get { return 3; } }
+
+        public AncientGlimmerSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else
+            {
+                SpellHelper.Turn(Caster, p);
+
+                int dx = Caster.Location.X - p.X;
+                int dy = Caster.Location.Y - p.Y;
+                int rx = (dx - dy) * 44;
+                int ry = (dx + dy) * 44;
+
+                bool eastToWest;
+
+                if (rx >= 0 && ry >= 0)
+                {
+                    eastToWest = false;
+                }
+                else if (rx >= 0)
+                {
+                    eastToWest = true;
+                }
+                else if (ry >= 0)
+                {
+                    eastToWest = true;
+                }
+                else
+                {
+                    eastToWest = false;
+                }
+
+                Effects.PlaySound(p, Caster.Map, 0x1EE);
+
+                for (int i = -1; i <= 1; ++i)
+                {
+                    Point3D loc = new Point3D(eastToWest ? p.X + i : p.X, eastToWest ? p.Y : p.Y + i, p.Z);
+                    bool canFit = SpellHelper.AdjustField(ref loc, Caster.Map, 22, true);
+
+                    //Effects.SendLocationParticles( EffectItem.Create( loc, Caster.Map, EffectItem.DefaultDuration ), 0x376A, 9, 10, 5025 );
+
+                    if (!canFit)
+                        continue;
+
+                    Item item = new InternalItem(loc, Caster.Map, Caster);
+                    if (this.Scroll != null)
+                        Scroll.Consume();
+                    Effects.SendLocationParticles(item, 0x376A, 9, 10, 5025);
+
+                    //new InternalItem( loc, Caster.Map, Caster );
+                }
+            }
+
+            FinishSequence();
+        }
+
+        [DispellableField]
+        private class InternalItem : Item
+        {
+            private Timer m_Timer;
+            private DateTime m_End;
+
+            public override bool BlocksFit { get { return true; } }
+
+            public InternalItem(Point3D loc, Map map, Mobile caster)
+                : base(0x1647)
+            {
+                Visible = false;
+                Movable = false;
+
+                MoveToWorld(loc, map);
+
+                if (caster.InLOS(this))
+                {
+                    Visible = true;
+                    Light = LightType.Circle150;
+                }
+                else
+                    Delete();
+
+                if (Deleted)
+                    return;
+
+                m_Timer = new InternalTimer(this, TimeSpan.FromSeconds(3.0));
+                m_Timer.Start();
+
+                m_End = DateTime.Now + TimeSpan.FromSeconds(3.0);
+            }
+
+            public InternalItem(Serial serial)
+                : base(serial)
+            {
+            }
+
+            public override void Serialize(GenericWriter writer)
+            {
+                base.Serialize(writer);
+
+                writer.Write((int)1); // version
+
+                writer.WriteDeltaTime(m_End);
+            }
+
+            public override void Deserialize(GenericReader reader)
+            {
+                base.Deserialize(reader);
+
+                int version = reader.ReadInt();
+
+                switch (version)
+                {
+                    case 1:
+                        {
+                            m_End = reader.ReadDeltaTime();
+
+                            m_Timer = new InternalTimer(this, m_End - DateTime.Now);
+                            m_Timer.Start();
+
+                            break;
+                        }
+                    case 0:
+                        {
+                            TimeSpan duration = TimeSpan.FromSeconds(3.0);
+
+                            m_Timer = new InternalTimer(this, duration);
+                            m_Timer.Start();
+
+                            m_End = DateTime.Now + duration;
+
+                            break;
+                        }
+                }
+            }
+
+            public override void OnAfterDelete()
+            {
+                base.OnAfterDelete();
+
+                if (m_Timer != null)
+                    m_Timer.Stop();
+            }
+
+            private class InternalTimer : Timer
+            {
+                private InternalItem m_Item;
+
+                public InternalTimer(InternalItem item, TimeSpan duration)
+                    : base(duration)
+                {
+                    m_Item = item;
+                }
+
+                protected override void OnTick()
+                {
+                    m_Item.Delete();
+                }
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientGlimmerSpell m_Owner;
+
+            public InternalTarget(AncientGlimmerSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is IPoint3D)
+                    m_Owner.Target((IPoint3D)o);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/GreatIgniteSpell.cs

@@ -0,0 +1,88 @@
+using System;
+using Server.Targeting;
+using Server.Network;
+using Server.Misc;
+using Server.Items;
+using System.Collections;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientGreatIgniteSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Great Ignite", "Vas In Flam",
+                                                        233,
+                                                        9012,
+                                                        false,
+                                                        Reagent.SulfurousAsh,
+                                                        Reagent.SpidersSilk
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public AncientGreatIgniteSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientGreatIgniteSpell m_Owner;
+
+            public InternalTarget(AncientGreatIgniteSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is IPoint3D)
+                    m_Owner.Target((IPoint3D)o);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (SpellHelper.CheckTown(p, Caster) && CheckSequence())
+            {
+
+                SpellHelper.Turn(Caster, p);
+
+                SpellHelper.GetSurfaceTop(ref p);
+
+                Effects.PlaySound(p, Caster.Map, 0x1DD);
+
+                Point3D loc = new Point3D(p.X, p.Y, p.Z);
+
+                IEntity to = new Entity(Serial.Zero, new Point3D(p), Caster.Map);
+                Effects.SendMovingParticles(Caster, to, 0xf53, 1, 0, false, false, 33, 3, 1260, 1, 0, EffectLayer.Head, 0x100);
+
+                GreaterNaturalFire fire = new GreaterNaturalFire(Caster.Location, Caster.Map, Caster);
+                fire.MoveToWorld(loc, Caster.Map);
+            }
+
+            FinishSequence();
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/GreatLightSpell.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Collections;
+using Server.Network;
+using Server.Items;
+using Server.Targeting;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientGreatLightSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Great Light", "Vas Lor",
+                                                        215,
+                                                        9061,
+                                                        Reagent.SulfurousAsh,
+                                                        Reagent.MandrakeRoot
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Second; }
+        }
+
+        public AncientGreatLightSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (CheckSequence())
+            {
+                SpellHelper.Turn(Caster, p);
+
+                SpellHelper.GetSurfaceTop(ref p);
+
+                ArrayList targets = new ArrayList();
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                Map map = Caster.Map;
+
+                if (map != null)
+                {
+                    IPooledEnumerable eable = map.GetMobilesInRange(new Point3D(p), 3);
+
+                    foreach (Mobile m in eable)
+                    {
+                        if (Caster.CanBeBeneficial(m, false))
+                            targets.Add(m);
+                    }
+
+                    eable.Free();
+                }
+
+                Effects.PlaySound(p, Caster.Map, 0x299);
+
+                if (targets.Count > 0)
+                {
+                    for (int i = 0; i < targets.Count; ++i)
+                    {
+                        Mobile targ = (Mobile)targets[i];
+
+                        if (targ.BeginAction(typeof(LightCycle)))
+                        {
+                            new LightCycle.NightSightTimer(targ).Start();
+                            int level = (int)Math.Abs(LightCycle.DungeonLevel * (Caster.Skills[SkillName.Magery].Base / 100));
+
+                            if (level > 25 || level < 0)
+                                level = 25;
+
+                            targ.LightLevel = level;
+
+                            targ.FixedParticles(0x376A, 9, 32, 5007, EffectLayer.Waist);
+                            targ.PlaySound(0x1E3);
+                        }
+                    }
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientGreatLightSpell m_Owner;
+
+            public InternalTarget(AncientGreatLightSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                IPoint3D p = o as IPoint3D;
+
+                if (p != null)
+                    m_Owner.Target(p);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/GreaterDouseSpell.cs

@@ -0,0 +1,94 @@
+using System;
+using Server.Targeting;
+using Server.Network;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientGreatDouseSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Great Douse", "Vas An Flam",
+                                                        212,
+                                                        9001,
+                                                        Reagent.Garlic,
+                                                        Reagent.SpidersSilk
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public AncientGreatDouseSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+            {
+                Caster.Target = new InternalTarget(this);
+                Caster.SendMessage("What do you wish to douse?");
+            }
+        }
+
+        public void Target(Item item)
+        {
+            if (!Caster.CanSee(item))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (CheckSequence())
+            {
+                SpellHelper.Turn(Caster, item);
+
+                Point3D loc = item.GetWorldLocation();
+
+                Effects.PlaySound(loc, item.Map, 0x10);
+                IEntity to = new Entity(Serial.Zero, loc, Caster.Map);
+                IEntity from = new Entity(Serial.Zero, new Point3D(loc.X, loc.Y, loc.Z + 50), Caster.Map);
+                Effects.SendMovingParticles(from, to, 0x376A, 1, 0, false, false, 33, 3, 1263, 1, 0, EffectLayer.Head, 1263);
+
+                item.Delete();
+                Caster.SendMessage("You douse the flames!");
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientGreatDouseSpell m_Owner;
+
+            public InternalTarget(AncientGreatDouseSpell owner)
+                : base(12, false, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is NaturalFire)
+                {
+                    m_Owner.Target((NaturalFire)o);
+                }
+                else if (o is GreaterNaturalFire)
+                {
+                    m_Owner.Target((GreaterNaturalFire)o);
+                }
+                else
+                {
+                    from.SendMessage("You can't douse that!");
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/IgniteSpell.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+using Server.Misc;
+using Server.Items;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientIgniteSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Ignite", "In Flam",
+                                                        233,
+                                                        9012,
+                                                        false,
+                                                        Reagent.BlackPearl
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public override double CastDelay { get { return 3.0; } }
+        public override double RequiredSkill { get { return 0.0; } }
+        public override int RequiredMana { get { return 10; } }
+
+        public AncientIgniteSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientIgniteSpell m_Owner;
+
+            public InternalTarget(AncientIgniteSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is IPoint3D)
+                    m_Owner.Target((IPoint3D)o);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (SpellHelper.CheckTown(p, Caster) && CheckSequence())
+            {
+
+                SpellHelper.Turn(Caster, p);
+
+                SpellHelper.GetSurfaceTop(ref p);
+
+                Effects.PlaySound(p, Caster.Map, 0x1DD);
+
+                IEntity to = new Entity(Serial.Zero, new Point3D(p), Caster.Map);
+                Effects.SendMovingParticles(Caster, to, 0xf53, 1, 0, false, false, 33, 3, 1260, 1, 0, EffectLayer.Head, 0x100);
+
+                Point3D loc = new Point3D(p.X, p.Y, p.Z);
+
+                NaturalFire fire = new NaturalFire(Caster.Location, Caster.Map, Caster);
+                fire.MoveToWorld(loc, Caster.Map);
+            }
+
+            FinishSequence();
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/InvisibilityAllSpell.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Collections;
+using Server.Network;
+using Server.Items;
+using Server.Targeting;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientInvisibilityAllSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Invisibility All", "Vas Sanct Lor",
+                                                        215,
+                                                        9061,
+                                                        Reagent.Nightshade,
+                                                        Reagent.Bloodmoss,
+                                                        Reagent.BlackPearl,
+                                                        Reagent.MandrakeRoot
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Eighth; }
+        }
+
+        public AncientInvisibilityAllSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (CheckSequence())
+            {
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                SpellHelper.Turn(Caster, p);
+
+                SpellHelper.GetSurfaceTop(ref p);
+
+                ArrayList targets = new ArrayList();
+
+                Map map = Caster.Map;
+
+                if (map != null)
+                {
+                    IPooledEnumerable eable = map.GetMobilesInRange(new Point3D(p), 3);
+
+                    foreach (Mobile m in eable)
+                    {
+                        if (Caster.CanBeBeneficial(m, false))
+                            targets.Add(m);
+                    }
+
+                    eable.Free();
+                }
+
+                if (targets.Count > 0)
+                {
+                    for (int i = 0; i < targets.Count; ++i)
+                    {
+                        Mobile m = (Mobile)targets[i];
+
+                        Caster.DoBeneficial(m);
+
+                        Effects.SendLocationParticles(EffectItem.Create(new Point3D(m.X, m.Y, m.Z + 16), Caster.Map, EffectItem.DefaultDuration), 0x376A, 10, 15, 5045);
+                        m.PlaySound(0x3C4);
+
+                        m.Hidden = true;
+
+                        RemoveTimer(m);
+
+                        TimeSpan duration = TimeSpan.FromSeconds(Caster.Skills[SkillName.Magery].Value * 1.2); // 120% of magery
+
+                        Timer t = new InternalTimer(m, duration);
+
+                        m_Table[m] = t;
+
+                        t.Start();
+                    }
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private static Hashtable m_Table = new Hashtable();
+
+        public static void RemoveTimer(Mobile m)
+        {
+            Timer t = (Timer)m_Table[m];
+
+            if (t != null)
+            {
+                t.Stop();
+                m_Table.Remove(m);
+            }
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Mobile m_Mobile;
+
+            public InternalTimer(Mobile m, TimeSpan duration)
+                : base(duration)
+            {
+                m_Mobile = m;
+            }
+
+            protected override void OnTick()
+            {
+                m_Mobile.RevealingAction();
+                RemoveTimer(m_Mobile);
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientInvisibilityAllSpell m_Owner;
+
+            public InternalTarget(AncientInvisibilityAllSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                IPoint3D p = o as IPoint3D;
+
+                if (p != null)
+                    m_Owner.Target(p);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/LocateSpell.cs

@@ -0,0 +1,111 @@
+using System;
+using Server;
+using Server.Targeting;
+using Server.Network;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientLocateSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Locate", "In Wis",
+                                                        224,
+                                                        9061,
+                                                        Reagent.Nightshade
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public AncientLocateSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+            {
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                int xLong = 0, yLat = 0;
+                int xMins = 0, yMins = 0;
+                bool xEast = false, ySouth = false;
+
+                if (AncientLocateSpell.Format(Caster.Location, Caster.Map, ref xLong, ref yLat, ref xMins, ref yMins, ref xEast, ref ySouth))
+                {
+                    string location = String.Format("Your current location is: {0} {1}'{2}, {3} {4}'{5}", yLat, yMins, ySouth ? "S" : "N", xLong, xMins, xEast ? "E" : "W");
+                    Caster.LocalOverheadMessage(MessageType.Regular, Caster.SpeechHue, false, location);
+                }
+            }
+        }
+
+        public static bool Format(Point3D p, Map map, ref int xLong, ref int yLat, ref int xMins, ref int yMins, ref bool xEast, ref bool ySouth)
+        {
+            if (map == null || map == Map.Internal)
+                return false;
+
+            int x = p.X, y = p.Y;
+            int xCenter, yCenter;
+            int xWidth, yHeight;
+
+            xWidth = 5120; yHeight = 4096;
+
+            if (map == Map.Trammel || map == Map.Felucca)
+            {
+                if (x >= 0 && y >= 0 && x < 5120 && y < 4096)
+                {
+                    xCenter = 1323; yCenter = 1624;
+                }
+                else if (x >= 0 && y >= 0 && x < map.Width && y < map.Height)
+                {
+                    xCenter = 1323; yCenter = 1624;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            else if (x >= 0 && y >= 0 && x < map.Width && y < map.Height)
+            {
+                xCenter = 5936; yCenter = 3112;
+            }
+            else
+            {
+                return false;
+            }
+
+            double absLong = (double)((x - xCenter) * 360) / xWidth;
+            double absLat = (double)((y - yCenter) * 360) / yHeight;
+
+            if (absLong > 180.0)
+                absLong = -180.0 + (absLong % 180.0);
+
+            if (absLat > 180.0)
+                absLat = -180.0 + (absLat % 180.0);
+
+            bool east = (absLong >= 0), south = (absLat >= 0);
+
+            if (absLong < 0.0)
+                absLong = -absLong;
+
+            if (absLat < 0.0)
+                absLat = -absLat;
+
+            xLong = (int)absLong;
+            yLat = (int)absLat;
+
+            xMins = (int)((absLong % 1.0) * 60);
+            yMins = (int)((absLat % 1.0) * 60);
+
+            xEast = east;
+            ySouth = south;
+
+            return true;
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/MassCharmSpell.cs

@@ -0,0 +1,263 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Targeting;
+using Server.Items;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientMassCharmSpell : AncientSpell
+    {
+        private Timer m_Timer;
+
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Mass Charm", "Vas An Xen Ex",
+                                                        218,
+                                                        9012,
+                                                        Reagent.BlackPearl,
+                                                        Reagent.Nightshade,
+                                                        Reagent.SpidersSilk,
+                                                        Reagent.MandrakeRoot
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Seventh; }
+        }
+
+        public AncientMassCharmSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(Mobile ma)
+        {
+            BaseCreature m = ma as BaseCreature;
+
+            if (ma is CharmedMobile)
+            {
+                ma.Kill();
+                Caster.SendMessage("You free them from their charm!");
+            }
+            else if (m != null)
+            {
+                if (!Caster.CanSee(m))
+                {
+                    Caster.SendLocalizedMessage(500237); // Target can not be seen.
+                }
+                else if (m.Controlled || m.Summoned)
+                {
+                    Caster.SendMessage("That target is already under somone's control!");
+                }
+                else if (!m.Alive)
+                {
+                    Caster.SendMessage("The dead are beyond your charms.");
+                }
+                else if (m.Blessed)
+                {
+                    Caster.SendMessage("You have no chance of charming that!");
+                }
+                else if (Caster.Followers >= 2)
+                {
+                    Caster.SendMessage("You couldn't control that if you did charm it!");
+                }
+                else if (CheckHSequence(m))
+                {
+                    SpellHelper.Turn(Caster, m);
+
+                    if (!m.Controlled && m != null && !m.Deleted)
+                    {
+                        int charmchance = Caster.Int + Utility.Random(1, 6);
+                        if (charmchance <= m.Int + Utility.Random(1, 6))
+                        {
+                            Caster.SendMessage("You have no chance of charming them.");
+                        }
+                        else
+                        {
+                            Caster.SendMessage("You charm them!");
+                            Point3D mloc = new Point3D(m.X, m.Y, m.Z);
+                            CharmedMobile dg = new CharmedMobile(m);
+                            dg.Owner = m;
+
+                            dg.Body = m.Body;
+                            dg.AI = m.AI;
+                            dg.Hue = m.Hue;
+                            dg.Name = m.Name;
+                            dg.SpeechHue = m.SpeechHue;
+                            dg.Fame = m.Fame;
+                            dg.Karma = m.Karma;
+                            dg.EmoteHue = m.EmoteHue;
+                            dg.Title = m.Title;
+                            dg.Criminal = (m.Criminal);
+                            dg.Str = m.Str;
+                            dg.Int = m.Int;
+                            dg.Hits = m.Hits;
+                            dg.Dex = m.Dex;
+                            dg.Mana = m.Mana;
+                            dg.Stam = m.Stam;
+
+                            dg.VirtualArmor = (m.VirtualArmor);
+                            dg.SetSkill(SkillName.Wrestling, m.Skills[SkillName.Wrestling].Value);
+                            dg.SetSkill(SkillName.Tactics, m.Skills[SkillName.Tactics].Value);
+                            dg.SetSkill(SkillName.Anatomy, m.Skills[SkillName.Anatomy].Value);
+
+                            dg.SetSkill(SkillName.Magery, m.Skills[SkillName.Magery].Value);
+                            dg.SetSkill(SkillName.MagicResist, m.Skills[SkillName.MagicResist].Value);
+                            dg.SetSkill(SkillName.Meditation, m.Skills[SkillName.Meditation].Value);
+                            dg.SetSkill(SkillName.EvalInt, m.Skills[SkillName.EvalInt].Value);
+
+                            dg.SetSkill(SkillName.Archery, m.Skills[SkillName.Archery].Value);
+                            dg.SetSkill(SkillName.Macing, m.Skills[SkillName.Macing].Value);
+                            dg.SetSkill(SkillName.Swords, m.Skills[SkillName.Swords].Value);
+                            dg.SetSkill(SkillName.Fencing, m.Skills[SkillName.Fencing].Value);
+                            dg.SetSkill(SkillName.Lumberjacking, m.Skills[SkillName.Lumberjacking].Value);
+                            dg.SetSkill(SkillName.Alchemy, m.Skills[SkillName.Alchemy].Value);
+                            dg.SetSkill(SkillName.Parry, m.Skills[SkillName.Parry].Value);
+                            dg.SetSkill(SkillName.Focus, m.Skills[SkillName.Focus].Value);
+                            dg.SetSkill(SkillName.Necromancy, m.Skills[SkillName.Necromancy].Value);
+                            dg.SetSkill(SkillName.Chivalry, m.Skills[SkillName.Chivalry].Value);
+                            dg.SetSkill(SkillName.ArmsLore, m.Skills[SkillName.ArmsLore].Value);
+                            dg.SetSkill(SkillName.Poisoning, m.Skills[SkillName.Poisoning].Value);
+                            dg.SetSkill(SkillName.SpiritSpeak, m.Skills[SkillName.SpiritSpeak].Value);
+                            dg.SetSkill(SkillName.Stealing, m.Skills[SkillName.Stealing].Value);
+                            dg.SetSkill(SkillName.Inscribe, m.Skills[SkillName.Inscribe].Value);
+                            dg.Kills = (m.Kills);
+
+                            // Clear Items
+                            RemoveFromAllLayers(dg);
+
+                            // Then copy
+                            CopyFromLayer(m, dg, Layer.FirstValid);
+                            CopyFromLayer(m, dg, Layer.TwoHanded);
+                            CopyFromLayer(m, dg, Layer.Shoes);
+                            CopyFromLayer(m, dg, Layer.Pants);
+                            CopyFromLayer(m, dg, Layer.Shirt);
+                            CopyFromLayer(m, dg, Layer.Helm);
+                            CopyFromLayer(m, dg, Layer.Gloves);
+                            CopyFromLayer(m, dg, Layer.Ring);
+                            CopyFromLayer(m, dg, Layer.Talisman);
+                            CopyFromLayer(m, dg, Layer.Neck);
+                            CopyFromLayer(m, dg, Layer.Hair);
+                            CopyFromLayer(m, dg, Layer.Waist);
+                            CopyFromLayer(m, dg, Layer.InnerTorso);
+                            CopyFromLayer(m, dg, Layer.Bracelet);
+                           // CopyFromLayer(m, dg, Layer.Unused_xF);
+                            CopyFromLayer(m, dg, Layer.FacialHair);
+                            CopyFromLayer(m, dg, Layer.MiddleTorso);
+                            CopyFromLayer(m, dg, Layer.Earrings);
+                            CopyFromLayer(m, dg, Layer.Arms);
+                            CopyFromLayer(m, dg, Layer.Cloak);
+                            CopyFromLayer(m, dg, Layer.OuterTorso);
+                            CopyFromLayer(m, dg, Layer.OuterLegs);
+                            CopyFromLayer(m, dg, Layer.LastUserValid);
+                            CopyFromLayer(m, dg, Layer.Mount);
+                            dg.ControlSlots = 5;
+                            dg.Controlled = true;
+                            dg.ControlMaster = Caster;
+                            TimeSpan duration = TimeSpan.FromSeconds(Caster.Skills[SkillName.Magery].Value * 1.2); // 120% of magery
+                            m_Timer = new InternalTimer(dg, duration);
+                            m_Timer.Start();
+                            dg.Map = m.Map;
+                            dg.Location = m.Location;
+                            m.Blessed = true;
+                            m.Hidden = true;
+
+                            m.Location = new Point3D(m.X, m.Y, m.Z - 95);
+                        }
+                    }
+                }
+                else
+                    Caster.SendMessage("You have no chance of charming them.");
+            }
+
+            FinishSequence();
+        }
+
+        private void CopyFromLayer(Mobile from, Mobile mimic, Layer layer)
+        {
+            if (mimic.FindItemOnLayer(layer) != null && mimic.FindItemOnLayer(layer).LootType != LootType.Blessed)
+                mimic.FindItemOnLayer(layer).LootType = LootType.Newbied;
+        }
+
+        private void DeleteFromLayer(Mobile from, Layer layer)
+        {
+            if (from.FindItemOnLayer(layer) != null)
+                from.RemoveItem(from.FindItemOnLayer(layer));
+        }
+
+        private void RemoveFromAllLayers(Mobile from)
+        {
+            DeleteFromLayer(from, Layer.FirstValid);
+            DeleteFromLayer(from, Layer.TwoHanded);
+            DeleteFromLayer(from, Layer.Shoes);
+            DeleteFromLayer(from, Layer.Pants);
+            DeleteFromLayer(from, Layer.Shirt);
+            DeleteFromLayer(from, Layer.Helm);
+            DeleteFromLayer(from, Layer.Gloves);
+            DeleteFromLayer(from, Layer.Ring);
+            DeleteFromLayer(from, Layer.Talisman);
+            DeleteFromLayer(from, Layer.Neck);
+            DeleteFromLayer(from, Layer.Hair);
+            DeleteFromLayer(from, Layer.Waist);
+            DeleteFromLayer(from, Layer.InnerTorso);
+            DeleteFromLayer(from, Layer.Bracelet);
+           // DeleteFromLayer(from, Layer.Unused_xF);
+            DeleteFromLayer(from, Layer.FacialHair);
+            DeleteFromLayer(from, Layer.MiddleTorso);
+            DeleteFromLayer(from, Layer.Earrings);
+            DeleteFromLayer(from, Layer.Arms);
+            DeleteFromLayer(from, Layer.Cloak);
+            DeleteFromLayer(from, Layer.OuterTorso);
+            DeleteFromLayer(from, Layer.OuterLegs);
+            DeleteFromLayer(from, Layer.LastUserValid);
+            DeleteFromLayer(from, Layer.Mount);
+        }
+
+        private class InternalTimer : Timer
+        {
+            private CharmedMobile m_Item;
+
+            public InternalTimer(CharmedMobile item, TimeSpan duration)
+                : base(duration)
+            {
+                m_Item = item;
+            }
+
+            protected override void OnTick()
+            {
+                if (m_Item != null)
+                    m_Item.Delete();
+            }
+        }
+
+        public class InternalTarget : Target
+        {
+            private AncientMassCharmSpell m_Owner;
+
+            public InternalTarget(AncientMassCharmSpell owner)
+                : base(12, false, TargetFlags.Harmful)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Mobile)
+                    m_Owner.Target((Mobile)o);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/MassDeathSpell.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections;
+using Server.Network;
+using Server.Items;
+using Server.Targeting;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientMassDeathSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Mass Death", "Vas Corp",
+                                                        233,
+                                                        9012,
+                                                        false,
+                                                        Reagent.Bloodmoss,
+                                                        Reagent.Ginseng,
+                                                        Reagent.Garlic,
+                                                        Reagent.MandrakeRoot,
+                                                        Reagent.Nightshade
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Eighth; }
+        }
+
+        public AncientMassDeathSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override bool DelayedDamage { get { return !Core.AOS; } }
+
+        public override void OnCast()
+        {
+            if (SpellHelper.CheckTown(Caster, Caster) && CheckSequence())
+            {
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                ArrayList targets = new ArrayList();
+
+                Map map = Caster.Map;
+
+                if (map != null)
+                {
+                    foreach (Mobile m in Caster.GetMobilesInRange(1 + (int)(Caster.Skills[SkillName.Magery].Value / 15.0)))
+                    {
+                        if (Caster != m && SpellHelper.ValidIndirectTarget(Caster, m) && Caster.CanBeHarmful(m, false) && (!Core.AOS || Caster.InLOS(m)))
+                            targets.Add(m);
+                    }
+                }
+
+                Caster.PlaySound(0x309);
+
+                for (int i = 0; i < targets.Count; ++i)
+                {
+                    Mobile m = (Mobile)targets[i];
+
+                    double damage = Core.AOS ? m.Hits - (m.Hits / 3.0) : m.Hits * 0.6;
+
+                    if (!m.Player && damage < 10.0)
+                        damage = 10.0;
+                    else if (damage > (Core.AOS ? 100.0 : 75.0))
+                        damage = Core.AOS ? 100.0 : 75.0;
+
+                    Caster.DoHarmful(m);
+                    SpellHelper.Damage(TimeSpan.Zero, m, Caster, damage, 100, 0, 0, 0, 0);
+                    m.Kill();
+                }
+            }
+
+            FinishSequence();
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/MassMightSpell.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections;
+using Server.Network;
+using Server.Items;
+using Server.Targeting;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientMassMightSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Mass Might", "In Vas Por",
+                                                        215,
+                                                        9061,
+                                                        Reagent.BlackPearl,
+                                                        Reagent.MandrakeRoot,
+                                                        Reagent.Ginseng
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Seventh; }
+        }
+
+        public AncientMassMightSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (CheckSequence())
+            {
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                SpellHelper.Turn(Caster, p);
+
+                SpellHelper.GetSurfaceTop(ref p);
+
+                ArrayList targets = new ArrayList();
+
+                Map map = Caster.Map;
+
+                if (map != null)
+                {
+                    IPooledEnumerable eable = map.GetMobilesInRange(new Point3D(p), 3);
+
+                    foreach (Mobile m in eable)
+                    {
+                        if (Caster.CanBeBeneficial(m, false))
+                            targets.Add(m);
+                    }
+
+                    eable.Free();
+                }
+
+                Effects.PlaySound(p, Caster.Map, 0x299);
+
+                if (targets.Count > 0)
+                {
+
+                    for (int i = 0; i < targets.Count; ++i)
+                    {
+                        Mobile targ = (Mobile)targets[i];
+
+                        SpellHelper.AddStatBonus(Caster, targ, true,StatType.Str); //SpellHelper.DisableSkillCheck = true;
+                        SpellHelper.AddStatBonus(Caster, targ, true,StatType.Dex);
+                        SpellHelper.AddStatBonus(Caster, targ, true,StatType.Int); //SpellHelper.DisableSkillCheck = false;
+
+                        targ.FixedParticles(0x373A, 10, 15, 5018, EffectLayer.Waist);
+                        targ.PlaySound(0x1EA);
+                    }
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientMassMightSpell m_Owner;
+
+            public InternalTarget(AncientMassMightSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                IPoint3D p = o as IPoint3D;
+
+                if (p != null)
+                    m_Owner.Target(p);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/MassSleepSpell.cs

@@ -0,0 +1,171 @@
+using System;
+using System.Collections;
+using Server.Network;
+using Server.Items;
+using Server.Targeting;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientMassSleepSpell : AncientSpell
+    {
+        private SleepingBody m_Body;
+
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Mass Sleep", "Vas Zu",
+                                                        215,
+                                                        9061,
+                                                        Reagent.Nightshade,
+                                                        Reagent.Ginseng,
+                                                        Reagent.SpidersSilk
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Fifth; }
+        }
+
+        public AncientMassSleepSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (CheckSequence())
+            {
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                SpellHelper.Turn(Caster, p);
+
+                SpellHelper.GetSurfaceTop(ref p);
+
+                ArrayList targets = new ArrayList();
+
+                Map map = Caster.Map;
+
+                if (map != null)
+                {
+                    IPooledEnumerable eable = map.GetMobilesInRange(new Point3D(p), 3);
+
+                    foreach (Mobile m in eable)
+                    {
+                        if (m != Caster && m.AccessLevel <= Caster.AccessLevel)
+                            targets.Add(m);
+                    }
+
+                    eable.Free();
+                }
+
+                if (targets.Count > 0)
+                {
+                    for (int i = 0; i < targets.Count; ++i)
+                    {
+                        Mobile m = (Mobile)targets[i];
+
+                        Effects.SendLocationParticles(EffectItem.Create(new Point3D(m.X, m.Y, m.Z + 16), Caster.Map, EffectItem.DefaultDuration), 0x376A, 10, 15, 5045);
+                        m.PlaySound(0x3C4);
+
+                        m.Hidden = true;
+                        m.Frozen = true;
+                        m.Squelched = true;
+
+                        SleepingBody body = new SleepingBody(m, m.Blessed);
+                        body.Map = m.Map;
+                        body.Location = m.Location;
+                        m_Body = body;
+                        m.Z -= 100;
+
+                        m.SendMessage("You fall asleep");
+
+                        RemoveTimer(m);
+
+                        TimeSpan duration = TimeSpan.FromSeconds(Caster.Skills[SkillName.Magery].Value * 1.2); // 120% of magery
+
+                        Timer t = new InternalTimer(m, duration, m_Body);
+
+                        m_Table[m] = t;
+
+                        t.Start();
+                    }
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private static Hashtable m_Table = new Hashtable();
+
+        public static void RemoveTimer(Mobile m)
+        {
+            Timer t = (Timer)m_Table[m];
+
+            if (t != null)
+            {
+                t.Stop();
+                m_Table.Remove(m);
+            }
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Mobile m_Mobile;
+            private SleepingBody m_Body;
+
+            public InternalTimer(Mobile m, TimeSpan duration, SleepingBody body)
+                : base(duration)
+            {
+                m_Mobile = m;
+                m_Body = body;
+            }
+
+            protected override void OnTick()
+            {
+                m_Mobile.RevealingAction();
+                m_Mobile.Frozen = false;
+                m_Mobile.Squelched = false;
+                m_Mobile.Z = m_Body.Z;
+                m_Mobile.Map = m_Body.Map;
+                if (m_Body != null)
+                {
+                    m_Body.Delete();
+                    m_Mobile.SendMessage("You wake up!");
+                }
+                RemoveTimer(m_Mobile);
+            }
+        }
+        private class InternalTarget : Target
+        {
+            private AncientMassSleepSpell m_Owner;
+
+            public InternalTarget(AncientMassSleepSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                IPoint3D p = o as IPoint3D;
+
+                if (p != null)
+                    m_Owner.Target(p);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/PeerSpell.cs

@@ -0,0 +1,310 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Targeting;
+using Server.Items;
+using Server.Network;
+using Server.Mobiles;
+using Server.Spells;
+using Server.Spells.Fifth;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientPeerSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Peer", "Vas Wis",
+                                                        221,
+                                                        9002,
+                                                        Reagent.MandrakeRoot,
+                                                        Reagent.Nightshade
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Third; }
+        }
+
+        private int m_OldBody;
+        private Souless m_Fake;
+        public ArrayList m_PeerMod;
+
+        public AncientPeerSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (!CheckSequence())
+                return;
+            else if (Caster.Mounted)
+            {
+                Caster.SendLocalizedMessage(1042561); //Please dismount first.
+            }
+            else if (!Caster.CanBeginAction(typeof(AncientPeerSpell)))
+            {
+                Caster.SendLocalizedMessage(1005559); // This spell is already in effect.
+            }
+            else if (Server.Spells.TransformationSpellHelper.UnderTransformation(Caster))
+            {
+                Caster.SendMessage("Your eyes stay firmly inside your body.");
+            }
+            else if (Caster.BodyMod == 183 || Caster.BodyMod == 184)
+            {
+                Caster.SendMessage("Your eyes stay firmly inside your body.");
+            }
+            else if (!Caster.CanBeginAction(typeof(IncognitoSpell)) || Caster.IsBodyMod)
+            {
+                DoFizzle();
+            }
+            else if (CheckSequence())
+            {
+                if (Caster.BeginAction(typeof(AncientPeerSpell)))
+                {
+                    if (this.Scroll != null)
+                        Scroll.Consume();
+                    Caster.PlaySound(0x2DF);
+
+                    Caster.SendMessage("Your sight leaves your body.");
+
+                    Souless dg = new Souless(this);
+
+                    dg.Body = Caster.Body;
+
+                    dg.Hue = Caster.Hue;
+                    dg.Name = Caster.Name;
+                    dg.SpeechHue = Caster.SpeechHue;
+                    dg.Fame = Caster.Fame;
+                    dg.Karma = Caster.Karma;
+                    dg.EmoteHue = Caster.EmoteHue;
+                    dg.Title = Caster.Title;
+                    dg.Criminal = (Caster.Criminal);
+                    dg.AccessLevel = Caster.AccessLevel;
+                    dg.Str = Caster.Str;
+                    dg.Int = Caster.Int;
+                    dg.Hits = Caster.Hits;
+                    dg.Dex = Caster.Dex;
+                    dg.Mana = Caster.Mana;
+                    dg.Stam = Caster.Stam;
+
+                    dg.VirtualArmor = (Caster.VirtualArmor);
+                    dg.SetSkill(SkillName.Wrestling, Caster.Skills[SkillName.Wrestling].Value);
+                    dg.SetSkill(SkillName.Tactics, Caster.Skills[SkillName.Tactics].Value);
+                    dg.SetSkill(SkillName.Anatomy, Caster.Skills[SkillName.Anatomy].Value);
+
+                    dg.SetSkill(SkillName.Magery, Caster.Skills[SkillName.Magery].Value);
+                    dg.SetSkill(SkillName.MagicResist, Caster.Skills[SkillName.MagicResist].Value);
+                    dg.SetSkill(SkillName.Meditation, Caster.Skills[SkillName.Meditation].Value);
+                    dg.SetSkill(SkillName.EvalInt, Caster.Skills[SkillName.EvalInt].Value);
+
+                    dg.SetSkill(SkillName.Archery, Caster.Skills[SkillName.Archery].Value);
+                    dg.SetSkill(SkillName.Macing, Caster.Skills[SkillName.Macing].Value);
+                    dg.SetSkill(SkillName.Swords, Caster.Skills[SkillName.Swords].Value);
+                    dg.SetSkill(SkillName.Fencing, Caster.Skills[SkillName.Fencing].Value);
+                    dg.SetSkill(SkillName.Lumberjacking, Caster.Skills[SkillName.Lumberjacking].Value);
+                    dg.SetSkill(SkillName.Alchemy, Caster.Skills[SkillName.Alchemy].Value);
+                    dg.SetSkill(SkillName.Parry, Caster.Skills[SkillName.Parry].Value);
+                    dg.SetSkill(SkillName.Focus, Caster.Skills[SkillName.Focus].Value);
+                    dg.SetSkill(SkillName.Necromancy, Caster.Skills[SkillName.Necromancy].Value);
+                    dg.SetSkill(SkillName.Chivalry, Caster.Skills[SkillName.Chivalry].Value);
+                    dg.SetSkill(SkillName.ArmsLore, Caster.Skills[SkillName.ArmsLore].Value);
+                    dg.SetSkill(SkillName.Poisoning, Caster.Skills[SkillName.Poisoning].Value);
+                    dg.SetSkill(SkillName.SpiritSpeak, Caster.Skills[SkillName.SpiritSpeak].Value);
+                    dg.SetSkill(SkillName.Stealing, Caster.Skills[SkillName.Stealing].Value);
+                    dg.SetSkill(SkillName.Inscribe, Caster.Skills[SkillName.Inscribe].Value);
+                    dg.Kills = (Caster.Kills);
+
+                    m_PeerMod = new ArrayList();
+                    double loss = (0 - Caster.Skills[SkillName.AnimalTaming].Base);
+                    SkillMod sk = new DefaultSkillMod(SkillName.AnimalTaming, true, loss);
+                    Caster.AddSkillMod(sk);
+                    m_PeerMod.Add(sk);
+                    double loss1 = (0 - Caster.Skills[SkillName.AnimalLore].Base);
+                    SkillMod sk1 = new DefaultSkillMod(SkillName.AnimalLore, true, loss1);// Druidry
+                    Caster.AddSkillMod(sk1);
+                    m_PeerMod.Add(sk1);
+
+                    double loss3 = (0 - Caster.Skills[SkillName.Necromancy].Base);
+                    SkillMod sk3 = new DefaultSkillMod(SkillName.Necromancy, true, loss3);
+                    Caster.AddSkillMod(sk3);
+                    m_PeerMod.Add(sk3);
+                    double loss4 = (0 - Caster.Skills[SkillName.TasteID].Base);
+                    SkillMod sk4 = new DefaultSkillMod(SkillName.TasteID, true, loss4);
+                    Caster.AddSkillMod(sk4);
+                    m_PeerMod.Add(sk4);
+                    // Clear Items
+                    RemoveFromAllLayers(dg);
+
+                    // Then copy
+                    CopyFromLayer(Caster, dg, Layer.FirstValid);
+                    CopyFromLayer(Caster, dg, Layer.OneHanded);
+                    CopyFromLayer(Caster, dg, Layer.TwoHanded);
+                    CopyFromLayer(Caster, dg, Layer.Shoes);
+                    CopyFromLayer(Caster, dg, Layer.Pants);
+                    CopyFromLayer(Caster, dg, Layer.Shirt);
+                    CopyFromLayer(Caster, dg, Layer.Helm);
+                    CopyFromLayer(Caster, dg, Layer.Gloves);
+                    CopyFromLayer(Caster, dg, Layer.Ring);
+                    CopyFromLayer(Caster, dg, Layer.Talisman);
+                    CopyFromLayer(Caster, dg, Layer.Neck);
+                    CopyFromLayer(Caster, dg, Layer.Hair);
+                    CopyFromLayer(Caster, dg, Layer.Waist);
+                    CopyFromLayer(Caster, dg, Layer.InnerTorso);
+                    CopyFromLayer(Caster, dg, Layer.Bracelet);
+                    //CopyFromLayer(Caster, dg, Layer.Unused_xF);
+                    CopyFromLayer(Caster, dg, Layer.FacialHair);
+                    CopyFromLayer(Caster, dg, Layer.MiddleTorso);
+                    CopyFromLayer(Caster, dg, Layer.Earrings);
+                    CopyFromLayer(Caster, dg, Layer.Arms);
+                    CopyFromLayer(Caster, dg, Layer.Cloak);
+                    CopyFromLayer(Caster, dg, Layer.Backpack);
+                    CopyFromLayer(Caster, dg, Layer.OuterTorso);
+                    CopyFromLayer(Caster, dg, Layer.OuterLegs);
+                    CopyFromLayer(Caster, dg, Layer.InnerLegs);
+                    CopyFromLayer(Caster, dg, Layer.LastUserValid);
+                    CopyFromLayer(Caster, dg, Layer.Mount);
+
+                    dg.Owner = Caster;
+                    dg.OldBody = m_OldBody;
+                    m_Fake = dg;
+                    dg.Map = Caster.Map;
+                    dg.Location = Caster.Location;
+                    BaseArmor.ValidateMobile(Caster);
+                    m_OldBody = Caster.Body;
+                    Caster.BodyValue = 903;
+                    Caster.Blessed = true;
+                    StopTimer(Caster);
+
+                    Timer t = new InternalTimer(Caster, m_OldBody, m_Fake, this);
+
+                    m_Timers[Caster] = t;
+
+                    t.Start();
+                }
+                else
+                {
+                    Caster.SendLocalizedMessage(1005559); // This spell is already in effect.
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private void CopyFromLayer(Mobile from, Mobile mimic, Layer layer)
+        {
+            if (mimic.FindItemOnLayer(layer) != null && mimic.FindItemOnLayer(layer).LootType != LootType.Blessed)
+                mimic.FindItemOnLayer(layer).LootType = LootType.Newbied;
+        }
+
+        private void DeleteFromLayer(Mobile from, Layer layer)
+        {
+            if (from.FindItemOnLayer(layer) != null)
+                from.RemoveItem(from.FindItemOnLayer(layer));
+        }
+
+        private void RemoveFromAllLayers(Mobile from)
+        {
+            DeleteFromLayer(from, Layer.FirstValid);
+            DeleteFromLayer(from, Layer.OneHanded);
+            DeleteFromLayer(from, Layer.TwoHanded);
+            DeleteFromLayer(from, Layer.Shoes);
+            DeleteFromLayer(from, Layer.Pants);
+            DeleteFromLayer(from, Layer.Shirt);
+            DeleteFromLayer(from, Layer.Helm);
+            DeleteFromLayer(from, Layer.Gloves);
+            DeleteFromLayer(from, Layer.Ring);
+            DeleteFromLayer(from, Layer.Talisman);
+            DeleteFromLayer(from, Layer.Neck);
+            DeleteFromLayer(from, Layer.Hair);
+            DeleteFromLayer(from, Layer.Waist);
+            DeleteFromLayer(from, Layer.InnerTorso);
+            DeleteFromLayer(from, Layer.Bracelet);
+            //DeleteFromLayer(from, Layer.Unused_xF);
+            DeleteFromLayer(from, Layer.FacialHair);
+            DeleteFromLayer(from, Layer.MiddleTorso);
+            DeleteFromLayer(from, Layer.Earrings);
+            DeleteFromLayer(from, Layer.Arms);
+            DeleteFromLayer(from, Layer.Cloak);
+            DeleteFromLayer(from, Layer.Backpack);
+            DeleteFromLayer(from, Layer.OuterTorso);
+            DeleteFromLayer(from, Layer.OuterLegs);
+            DeleteFromLayer(from, Layer.InnerLegs);
+            DeleteFromLayer(from, Layer.LastUserValid);
+            DeleteFromLayer(from, Layer.Mount);
+        }
+
+        public void RemovePeerMod()
+        {
+            if (m_PeerMod == null)
+                return;
+
+            for (int i = 0; i < m_PeerMod.Count; ++i)
+                ((SkillMod)m_PeerMod[i]).Remove();
+            m_PeerMod = null;
+        }
+        private static Hashtable m_Timers = new Hashtable();
+
+        public static bool StopTimer(Mobile m)
+        {
+            Timer t = (Timer)m_Timers[m];
+
+            if (t != null)
+            {
+                t.Stop();
+                m_Timers.Remove(m);
+            }
+
+            return (t != null);
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Mobile m_Owner;
+            private int m_OldBody;
+            private Souless fake;
+            private Point3D loc;
+            private AncientPeerSpell m_spell;
+            public InternalTimer(Mobile owner, int body, Souless m_Fake, AncientPeerSpell spell)
+                : base(TimeSpan.FromSeconds(0))
+            {
+                m_Owner = owner;
+                m_OldBody = body;
+                fake = m_Fake;
+                m_spell = spell;
+
+                int val = (int)owner.Skills[SkillName.Magery].Value;
+
+                if (val > 100)
+                    val = 100;
+                double loss2 = (0 - m_Owner.Skills[SkillName.Magery].Base);
+                SkillMod sk2 = new DefaultSkillMod(SkillName.Magery, true, loss2);
+                m_Owner.AddSkillMod(sk2);
+                m_spell.m_PeerMod.Add(sk2);
+
+                Delay = TimeSpan.FromSeconds(val);
+                Priority = TimerPriority.TwoFiftyMS;
+            }
+
+            protected override void OnTick()
+            {
+                if (!m_Owner.CanBeginAction(typeof(AncientPeerSpell)))
+                {
+                    if (fake != null && !fake.Deleted)
+                    {
+                        loc = new Point3D(fake.X, fake.Y, fake.Z);
+                        m_Owner.Location = loc;
+                        m_Owner.Blessed = fake.Blessed;
+                        fake.Delete();
+
+                    }
+                    m_Owner.BodyValue = m_OldBody;
+                    m_spell.RemovePeerMod();
+                    m_Owner.EndAction(typeof(AncientPeerSpell));
+
+                    BaseArmor.ValidateMobile(m_Owner);
+                }
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/SeanceSpell.cs

@@ -0,0 +1,176 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Items;
+using Server.Gumps;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientSeanceSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Seance", "Kal Wis Corp",
+                                                        221,
+                                                        9002,
+                                                        Reagent.Bloodmoss,
+                                                        Reagent.SpidersSilk,
+                                                        Reagent.MandrakeRoot,
+                                                        Reagent.Nightshade,
+                                                        Reagent.SulfurousAsh
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Fourth; }
+        }
+
+        private int m_NewBody;
+        private int m_OldBody;
+
+        public AncientSeanceSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override bool CheckCast()
+        {
+            if (Caster.Mounted)
+            {
+                Caster.SendLocalizedMessage(1042561); //Please dismount first.
+                return false;
+            }
+            else if (TransformationSpellHelper.UnderTransformation(Caster))
+            {
+                Caster.SendMessage("You cannot enter the realm of the dead while in that form.");
+                return false;
+            }
+            else if (Caster.BodyMod == 183 || Caster.BodyMod == 184)
+            {
+                Caster.SendMessage("You cannot enter the realm of the dead without removing your paint.");
+                return false;
+            }
+            else if (!Caster.CanBeginAction(typeof(AncientSeanceSpell)))
+            {
+                Caster.SendLocalizedMessage(1005559); // This spell is already in effect.
+                return false;
+            }
+            else if (Caster.Female)
+            {
+                m_NewBody = 403;
+
+            }
+            else
+            {
+                m_NewBody = 402;
+
+
+            }
+            m_OldBody = Caster.Body;
+            return true;
+        }
+
+        public override void OnCast()
+        {
+            if (!CheckSequence())
+            {
+                return;
+            }
+            else if (!Caster.CanBeginAction(typeof(AncientSeanceSpell)))
+            {
+                Caster.SendLocalizedMessage(1005559); // This spell is already in effect.
+            }
+            else if (TransformationSpellHelper.UnderTransformation(Caster))
+            {
+                Caster.SendMessage("You cannot enter the realm of the dead while in that form.");
+            }
+            else if (Caster.BodyMod == 183 || Caster.BodyMod == 184)
+            {
+                Caster.SendMessage("You cannot enter the realm of the dead without removing your paint.");
+            }
+            else if (!Caster.CanBeginAction(typeof(Server.Spells.Fifth.IncognitoSpell)) || Caster.IsBodyMod)
+            {
+                DoFizzle();
+            }
+            else if (CheckSequence())
+            {
+
+                if (Caster.BeginAction(typeof(AncientSeanceSpell)))
+                {
+                    if (m_NewBody != 0)
+                    {
+                        if (this.Scroll != null)
+                            Scroll.Consume();
+                        Caster.PlaySound(0x379);
+
+                        Caster.BodyValue = m_NewBody;
+
+                        Caster.SendMessage("You enter the realm of the dead.");
+                        BaseArmor.ValidateMobile(Caster);
+
+                        StopTimer(Caster);
+
+                        Timer t = new InternalTimer(Caster, m_OldBody);
+
+                        m_Timers[Caster] = t;
+
+                        t.Start();
+                    }
+                }
+                else
+                {
+                    Caster.SendLocalizedMessage(1005559); // This spell is already in effect.
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private static Hashtable m_Timers = new Hashtable();
+
+        public static bool StopTimer(Mobile m)
+        {
+            Timer t = (Timer)m_Timers[m];
+
+            if (t != null)
+            {
+                t.Stop();
+                m_Timers.Remove(m);
+            }
+
+            return (t != null);
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Mobile m_Owner;
+            private int m_OldBody;
+
+            public InternalTimer(Mobile owner, int body)
+                : base(TimeSpan.FromSeconds(0))
+            {
+                m_Owner = owner;
+                m_OldBody = body;
+
+                int val = (int)owner.Skills[SkillName.Magery].Value;
+
+                if (val > 100)
+                    val = 100;
+
+                Delay = TimeSpan.FromSeconds(val);
+                Priority = TimerPriority.TwoFiftyMS;
+            }
+
+            protected override void OnTick()
+            {
+                if (!m_Owner.CanBeginAction(typeof(AncientSeanceSpell)))
+                {
+                    m_Owner.BodyValue = m_OldBody;
+                    m_Owner.EndAction(typeof(AncientSeanceSpell));
+
+                    BaseArmor.ValidateMobile(m_Owner);
+                }
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/SleepFieldSpell.cs

@@ -0,0 +1,349 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+using Server.Misc;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientSleepFieldSpell : AncientSpell
+    {
+
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Sleep Field", "In Zu Grav",
+                                                        230,
+                                                        9052,
+                                                        false,
+                                                        Reagent.BlackPearl,
+                                                        Reagent.Ginseng,
+                                                        Reagent.SpidersSilk
+                                                       );
+
+        public override Server.Spells.SpellCircle Circle
+        {
+            get { return SpellCircle.Sixth; ; }
+        }
+
+        public AncientSleepFieldSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(IPoint3D p)
+        {
+            if (!Caster.CanSee(p))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (SpellHelper.CheckTown(p, Caster) && CheckSequence())
+            {
+
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                SpellHelper.Turn(Caster, p);
+
+                SpellHelper.GetSurfaceTop(ref p);
+
+                int dx = Caster.Location.X - p.X;
+                int dy = Caster.Location.Y - p.Y;
+                int rx = (dx - dy) * 44;
+                int ry = (dx + dy) * 44;
+
+                bool eastToWest;
+
+                if (rx >= 0 && ry >= 0)
+                {
+                    eastToWest = false;
+                }
+                else if (rx >= 0)
+                {
+                    eastToWest = true;
+                }
+                else if (ry >= 0)
+                {
+                    eastToWest = true;
+                }
+                else
+                {
+                    eastToWest = false;
+                }
+
+                Effects.PlaySound(p, Caster.Map, 0x20B);
+
+                int itemID = eastToWest ? 0x3915 : 0x3922;
+
+                TimeSpan duration = TimeSpan.FromSeconds(3.0 + (Caster.Skills[SkillName.Magery].Value * 0.4));
+
+                for (int i = -2; i <= 2; ++i)
+                {
+                    Point3D loc = new Point3D(eastToWest ? p.X + i : p.X, eastToWest ? p.Y : p.Y + i, p.Z);
+
+                    new InternalItem(itemID, loc, Caster, Caster.Map, duration, i);
+                }
+            }
+
+            FinishSequence();
+        }
+
+        [DispellableField]
+        private class InternalItem : Item
+        {
+            private Timer m_Timer;
+            private DateTime m_End;
+            private Mobile m_Caster;
+            private SleepingBody m_Body;
+
+            public override bool BlocksFit { get { return true; } }
+
+            public InternalItem(int itemID, Point3D loc, Mobile caster, Map map, TimeSpan duration, int val)
+                : base(itemID)
+            {
+                bool canFit = SpellHelper.AdjustField(ref loc, map, 12, false);
+
+                Visible = false;
+                Movable = false;
+                Light = LightType.Circle300;
+                Hue = 1169;
+                Name = "sleep field";
+
+                MoveToWorld(loc, map);
+
+                m_Caster = caster;
+
+                m_End = DateTime.Now + duration;
+
+                m_Timer = new InternalTimer(this, TimeSpan.FromSeconds(Math.Abs(val) * 0.2), caster.InLOS(this), canFit);
+                m_Timer.Start();
+            }
+
+            public override void OnAfterDelete()
+            {
+                base.OnAfterDelete();
+
+                if (m_Timer != null)
+                    m_Timer.Stop();
+            }
+
+            public InternalItem(Serial serial)
+                : base(serial)
+            {
+            }
+
+            public override void Serialize(GenericWriter writer)
+            {
+                base.Serialize(writer);
+
+                writer.Write((int)1); // version
+
+                writer.Write(m_Caster);
+                writer.WriteDeltaTime(m_End);
+            }
+
+            public override void Deserialize(GenericReader reader)
+            {
+                base.Deserialize(reader);
+
+                int version = reader.ReadInt();
+
+                switch (version)
+                {
+                    case 1:
+                        {
+                            m_Caster = reader.ReadMobile();
+
+                            goto case 0;
+                        }
+                    case 0:
+                        {
+                            m_End = reader.ReadDeltaTime();
+
+                            m_Timer = new InternalTimer(this, TimeSpan.Zero, true, true);
+                            m_Timer.Start();
+
+                            break;
+                        }
+                }
+            }
+
+            public void ApplySleepTo(Mobile m)
+            {
+                m.Hidden = true;
+                m.Frozen = true;
+                m.Squelched = true;
+
+                SleepingBody body = new SleepingBody(m, m.Blessed);
+
+                body.Map = m.Map;
+                body.Location = m.Location;
+                m_Body = body;
+                m.Z -= 100;
+
+
+                m.SendMessage("You fall asleep");
+
+                RemoveTimer(m);
+
+                TimeSpan duration = TimeSpan.FromSeconds(m_Caster.Skills[SkillName.Magery].Value * 1.2); // 120% of magery
+
+                Timer t = new BodyTimer(m, duration, m_Body);
+
+                m_Table[m] = t;
+
+                t.Start();
+            }
+            private static Hashtable m_Table = new Hashtable();
+
+            public static void RemoveTimer(Mobile m)
+            {
+                Timer t = (Timer)m_Table[m];
+
+                if (t != null)
+                {
+                    t.Stop();
+                    m_Table.Remove(m);
+                }
+            }
+
+            private class BodyTimer : Timer
+            {
+                private Mobile m_Mobile;
+                private SleepingBody m_Body;
+
+                public BodyTimer(Mobile m, TimeSpan duration, SleepingBody body)
+                    : base(duration)
+                {
+                    m_Mobile = m;
+                    m_Body = body;
+                }
+
+                protected override void OnTick()
+                {
+                    m_Mobile.RevealingAction();
+                    m_Mobile.Frozen = false;
+                    m_Mobile.Squelched = false;
+                    m_Mobile.Z = m_Body.Z;
+
+                    if (m_Body != null)
+                    {
+                        m_Body.Delete();
+                        m_Mobile.SendMessage("You wake up!");
+                    }
+                    RemoveTimer(m_Mobile);
+                }
+            }
+
+            public override bool OnMoveOver(Mobile m)
+            {
+                if (Visible && m_Caster != null && SpellHelper.ValidIndirectTarget(m_Caster, m) && m_Caster.CanBeHarmful(m, false))
+                {
+
+                    ApplySleepTo(m);
+                    m.PlaySound(0x474);
+                }
+                m.Hidden = true;
+                return false;
+            }
+
+            private class InternalTimer : Timer
+            {
+                private InternalItem m_Item;
+                private bool m_InLOS, m_CanFit;
+
+                private static Queue m_Queue = new Queue();
+
+                public InternalTimer(InternalItem item, TimeSpan delay, bool inLOS, bool canFit)
+                    : base(delay, TimeSpan.FromSeconds(1.5))
+                {
+                    m_Item = item;
+                    m_InLOS = inLOS;
+                    m_CanFit = canFit;
+
+                    Priority = TimerPriority.FiftyMS;
+                }
+
+                protected override void OnTick()
+                {
+                    if (m_Item.Deleted)
+                        return;
+
+                    if (!m_Item.Visible)
+                    {
+                        if (m_InLOS && m_CanFit)
+                            m_Item.Visible = true;
+                        else
+                            m_Item.Delete();
+
+                        if (!m_Item.Deleted)
+                        {
+                            m_Item.ProcessDelta();
+                            Effects.SendLocationParticles(EffectItem.Create(m_Item.Location, m_Item.Map, EffectItem.DefaultDuration), 0x376A, 9, 10, 5040);
+                        }
+                    }
+                    else if (DateTime.Now > m_Item.m_End)
+                    {
+                        m_Item.Delete();
+                        Stop();
+                    }
+                    else
+                    {
+                        Map map = m_Item.Map;
+                        Mobile caster = m_Item.m_Caster;
+
+                        if (map != null && caster != null)
+                        {
+                            bool eastToWest = (m_Item.ItemID == 0x3915);
+                            IPooledEnumerable eable = map.GetMobilesInBounds(new Rectangle2D(m_Item.X - (eastToWest ? 0 : 1), m_Item.Y - (eastToWest ? 1 : 0), (eastToWest ? 1 : 2), (eastToWest ? 2 : 1))); ;
+
+                            foreach (Mobile m in eable)
+                            {
+                                if ((m.Z + 16) > m_Item.Z && (m_Item.Z + 12) > m.Z && SpellHelper.ValidIndirectTarget(caster, m) && caster.CanBeHarmful(m, false))
+                                    m_Queue.Enqueue(m);
+                            }
+
+                            eable.Free();
+
+                            while (m_Queue.Count > 0)
+                            {
+                                Mobile m = (Mobile)m_Queue.Dequeue();
+
+                                m.PlaySound(0x3C4);
+                                m_Item.ApplySleepTo(m);
+
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientSleepFieldSpell m_Owner;
+
+            public InternalTarget(AncientSleepFieldSpell owner)
+                : base(12, true, TargetFlags.None)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is IPoint3D)
+                    m_Owner.Target((IPoint3D)o);
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/SleepSpell.cs

@@ -0,0 +1,150 @@
+using System;
+using System.Collections;
+using Server;
+using Server.Targeting;
+using Server.Items;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientSleepSpell : AncientSpell
+    {
+        private SleepingBody m_Body;
+
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Sleep", "In Zu",
+                                                        206,
+                                                        9002,
+                                                        Reagent.SpidersSilk,
+                                                        Reagent.BlackPearl,
+                                                        Reagent.Nightshade
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Third; }
+        }
+
+        public AncientSleepSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(Mobile m)
+        {
+            if (!Caster.CanSee(m))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else
+            {
+                SpellHelper.Turn(Caster, m);
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                Effects.SendLocationParticles(EffectItem.Create(new Point3D(m.X, m.Y, m.Z + 16), Caster.Map, EffectItem.DefaultDuration), 0x376A, 10, 15, 5045);
+                m.PlaySound(0x3C4);
+
+                m.Hidden = true;
+                m.Frozen = true;
+                m.Squelched = true;
+
+                ArrayList sleepequip = new ArrayList();
+
+                Item hat = m.FindItemOnLayer(Layer.Helm);
+                if (hat != null)
+                {
+                    sleepequip.Add(hat);
+                }
+                SleepingBody body = new SleepingBody(m, false);
+                body.Map = m.Map;
+                body.Location = m.Location;
+                m_Body = body;
+                m.Z -= 100;
+
+                m.SendMessage("You fall asleep");
+
+                RemoveTimer(m);
+
+                TimeSpan duration = TimeSpan.FromSeconds(Caster.Skills[SkillName.Magery].Value * 1.2); // 120% of magery
+
+                Timer t = new InternalTimer(m, duration, m_Body);
+
+                m_Table[m] = t;
+
+                t.Start();
+            }
+        }
+
+        private static Hashtable m_Table = new Hashtable();
+
+        public static void RemoveTimer(Mobile m)
+        {
+            Timer t = (Timer)m_Table[m];
+
+            if (t != null)
+            {
+                t.Stop();
+                m_Table.Remove(m);
+            }
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Mobile m_Mobile;
+            private Item m_Body;
+
+            public InternalTimer(Mobile m, TimeSpan duration, Item body)
+                : base(duration)
+            {
+                m_Mobile = m;
+                m_Body = body;
+            }
+
+            protected override void OnTick()
+            {
+                m_Mobile.RevealingAction();
+                m_Mobile.Frozen = false;
+                m_Mobile.Squelched = false;
+
+                if (m_Body != null)
+                {
+                    m_Body.Delete();
+                    m_Mobile.SendMessage("You wake up!");
+                    m_Mobile.Z = m_Body.Z;
+                    m_Mobile.Animate(21, 6, 1, false, false, 0);
+                }
+                RemoveTimer(m_Mobile);
+            }
+        }
+
+        public class InternalTarget : Target
+        {
+            private AncientSleepSpell m_Owner;
+
+            public InternalTarget(AncientSleepSpell owner)
+                : base(12, false, TargetFlags.Beneficial)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Mobile)
+                {
+                    m_Owner.Target((Mobile)o);
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/SwarmSpell.cs

@@ -0,0 +1,238 @@
+using System;
+using System.Collections;
+using Server.Network;
+using Server.Items;
+using Server.Targeting;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientSwarmSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Swarm", "Kal Bet Xen",
+                                                        203,
+                                                        9051,
+                                                        Reagent.Nightshade,
+                                                        Reagent.MandrakeRoot,
+                                                        Reagent.Bloodmoss
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Third; }
+        }
+
+        public AncientSwarmSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+                Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(Mobile m)
+        {
+            if (!Caster.CanSee(m))
+            {
+                Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (CheckHSequence(m))
+            {
+                if (this.Scroll != null)
+                    Scroll.Consume();
+                SpellHelper.Turn(Caster, m);
+
+                SpellHelper.CheckReflect((int)this.Circle, Caster, ref m);
+
+                if (m.Spell != null)
+                    m.Spell.OnCasterHurt();
+
+                m.Paralyzed = false;
+
+                if (CheckResisted(m))
+                {
+                    m.SendLocalizedMessage(501783); // You feel yourself resisting magical energy.
+                }
+                else
+                {
+                    if (!m_Table.Contains(m))
+                    {
+                        Timer t = new InternalTimer(m, Caster);
+                        t.Start();
+
+                        m_Table[m] = t;
+                    }
+
+                    m.SendMessage("A swarm of insects surrounds you, and starts to sting you!");
+                    m.FixedParticles(0x91B, 1, 240, 9916, 1159, 3, EffectLayer.Head);
+                    m.PlaySound(0x230);
+                }
+            }
+
+            FinishSequence();
+        }
+
+        public virtual bool CheckResisted(Mobile target)
+        {
+            double n = GetResistPercent(target, Circle);
+
+            n /= 100.0;
+
+            if (n <= 0.0)
+                return false;
+
+            if (n >= 1.0)
+                return true;
+
+            int maxSkill = (1 + (int)Circle) * 10;
+            maxSkill += (1 + ((int)Circle / 6)) * 25;
+
+            if (target.Skills[SkillName.MagicResist].Value < maxSkill)
+                target.CheckSkill(SkillName.MagicResist, 0.0, 120.0);
+
+            return (n >= Utility.RandomDouble());
+        }
+
+        public virtual double GetResistPercent(Mobile target, SpellCircle circle)
+        {
+            double firstPercent = target.Skills[SkillName.MagicResist].Value / 5.0;
+            double secondPercent = target.Skills[SkillName.MagicResist].Value - (((Caster.Skills[CastSkill].Value - 20.0) / 5.0) + (1 + (int)circle) * 5.0);
+
+            return (firstPercent > secondPercent ? firstPercent : secondPercent) / 2.0; // Seems should be about half of what stratics says.
+        }
+
+        private static Hashtable m_Table = new Hashtable();
+
+        public static void RemoveCurse(Mobile m)
+        {
+            Timer t = (Timer)m_Table[m];
+
+            if (t == null)
+                return;
+
+            t.Stop();
+            m.SendMessage("The swarm stop stinging.");
+
+            m_Table.Remove(m);
+        }
+
+        private class InternalTimer : Timer
+        {
+            private Mobile m_Target, m_From;
+            private double m_MinBaseDamage, m_MaxBaseDamage;
+
+            private DateTime m_NextHit;
+            private int m_HitDelay;
+
+            private int m_Count, m_MaxCount;
+
+            public InternalTimer(Mobile target, Mobile from)
+                : base(TimeSpan.FromSeconds(0.1), TimeSpan.FromSeconds(0.1))
+            {
+                Priority = TimerPriority.FiftyMS;
+
+                m_Target = target;
+                m_From = from;
+
+                double timeLevel = from.Skills[SkillName.EvalInt].Value / 10;
+
+                m_MinBaseDamage = timeLevel - 2;
+                m_MaxBaseDamage = timeLevel + 1;
+
+                m_HitDelay = 5;
+                m_NextHit = DateTime.Now + TimeSpan.FromSeconds(m_HitDelay);
+
+                m_Count = (int)timeLevel;
+
+                if (m_Count < 4)
+                    m_Count = 4;
+
+                m_MaxCount = m_Count;
+            }
+
+            protected override void OnTick()
+            {
+                if (!m_Target.Alive)
+                {
+                    m_Table.Remove(m_Target);
+                    Stop();
+                }
+
+                if (!m_Target.Alive || DateTime.Now < m_NextHit)
+                    return;
+
+                --m_Count;
+
+                if (m_HitDelay > 1)
+                {
+                    m_Target.FixedParticles(0x91B, 1, 240, 9916, 1159, 3, EffectLayer.Head);
+                    m_Target.PlaySound(0x230);
+                    if (m_MaxCount < 5)
+                    {
+                        --m_HitDelay;
+                    }
+                    else
+                    {
+                        int delay = (int)(Math.Ceiling((1.0 + (5 * m_Count)) / m_MaxCount));
+
+                        if (delay <= 5)
+                            m_HitDelay = delay;
+                        else
+                            m_HitDelay = 5;
+                    }
+                }
+
+                if (m_Count == 0)
+                {
+                    m_Target.SendMessage("The swarm stop stinging.");
+                    m_Table.Remove(m_Target);
+                    Stop();
+                }
+                else
+                {
+                    m_NextHit = DateTime.Now + TimeSpan.FromSeconds(m_HitDelay);
+
+                    double damage = m_MinBaseDamage + (Utility.RandomDouble() * (m_MaxBaseDamage - m_MinBaseDamage));
+
+                    damage *= (3 - (((double)m_Target.Stam / m_Target.StamMax) * 2));
+
+                    if (damage < 1)
+                        damage = 1;
+
+                    if (!m_Target.Player)
+                        damage *= 1.75;
+
+                    AOS.Damage(m_Target, m_From, (int)damage, 0, 0, 0, 100, 0);
+                }
+            }
+        }
+
+        private class InternalTarget : Target
+        {
+            private AncientSwarmSpell m_Owner;
+
+            public InternalTarget(AncientSwarmSpell owner)
+                : base(12, false, TargetFlags.Harmful)
+            {
+                m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Mobile)
+                {
+                    m_Owner.Target((Mobile)o);
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/ThunderSpell.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientThunderSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Thunder", "Vas Kal",
+                                                        236,
+                                                        9011,
+                                                        Reagent.SulfurousAsh
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public override double CastDelay { get { return 0.5; } }
+        public override double RequiredSkill { get { return 0.0; } }
+        public override int RequiredMana { get { return 2; } }
+
+        public AncientThunderSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override bool CheckCast()
+        {
+            return true;
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+            {
+                switch (Utility.Random(3))
+                {
+                    case 0: Caster.PlaySound(0x28); break;
+                    case 1: Caster.PlaySound(0x29); break;
+                    case 2: Caster.PlaySound(0x206); break;
+                }
+
+                if (Caster.Skills[SkillName.Magery].Base >= 50)
+                {
+                    foreach (Mobile ma in Caster.GetMobilesInRange(5))
+                    {
+                        BaseCreature m = ma as BaseCreature;
+                        if (m != null)
+                        {
+                            if (!m.Blessed && !m.Controlled && !m.Summoned && m.Alive && m.Int <= (Caster.Int + Caster.Str))
+                            {
+                                m.FocusMob = Caster;
+                                m.AIObject.DoActionFlee();
+                            }
+                        }
+                    }
+                }
+            }
+
+            FinishSequence();
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/TremorSpell.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Collections;
+using Server.Network;
+using Server.Items;
+using Server.Targeting;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientTremorSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Tremor", "Vas Por Ylem",
+                                                        233,
+                                                        9012,
+                                                        false,
+                                                        Reagent.Bloodmoss,
+                                                        Reagent.MandrakeRoot,
+                                                        Reagent.SulfurousAsh
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.Sixth; }
+        }
+
+        public AncientTremorSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override bool DelayedDamage { get { return !Core.AOS; } }
+
+        public override void OnCast()
+        {
+            if (SpellHelper.CheckTown(Caster, Caster) && CheckSequence())
+            {
+                ArrayList targets = new ArrayList();
+
+                Map map = Caster.Map;
+
+                if (map != null)
+                {
+                    foreach (Mobile m in Caster.GetMobilesInRange(1 + (int)(Caster.Skills[SkillName.Magery].Value / 15.0)))
+                    {
+                        if (Caster != m && m.AccessLevel == AccessLevel.Player && SpellHelper.ValidIndirectTarget(Caster, m) && Caster.CanBeHarmful(m, false) && (!Core.AOS || Caster.InLOS(m)))
+                            targets.Add(m);
+                    }
+                }
+
+                Caster.PlaySound(0x2F3);
+
+                for (int i = 0; i < targets.Count; ++i)
+                {
+                    Mobile m = (Mobile)targets[i];
+
+                    m.Stam = 0;
+                    m.Mana = 0;
+                    m.SendMessage("A powerful tremor in the ground makes you stumble and tremble!");
+                    int damage = (Utility.Random(10, 15));
+                    Caster.DoHarmful(m);
+                    SpellHelper.Damage(TimeSpan.Zero, m, Caster, damage, 100, 0, 0, 0, 0);
+                }
+            }
+
+            FinishSequence();
+        }
+    }
+}

Scripts/SubSystem/ACC/Complete Spell System/-=+ 03 Systems/Ancient/Spells/WeatherSpell.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections;
+using Server.Targeting;
+using Server.Network;
+using Server.Mobiles;
+using Server.Spells;
+
+namespace Server.ACC.CSS.Systems.Ancient
+{
+    public class AncientWeatherSpell : AncientSpell
+    {
+        private static SpellInfo m_Info = new SpellInfo(
+                                                        "Weather", "Rel Hur",
+                                                        236,
+                                                        9011,
+                                                        Reagent.SulfurousAsh
+                                                       );
+
+        public override SpellCircle Circle
+        {
+            get { return SpellCircle.First; }
+        }
+
+        public override double CastDelay { get { return 0.5; } }
+        public override double RequiredSkill { get { return 0.0; } }
+        public override int RequiredMana { get { return 7; } }
+
+        public AncientWeatherSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override void OnCast()
+        {
+            if (CheckSequence())
+            {
+                if (this.Scroll != null)
+                    Scroll.Consume();
+
+                Timer t = (Timer)m_UnderEffect[Caster];
+
+                if (Caster != null && t == null)
+                {
+                    TimeSpan duration = SpellHelper.GetDuration(Caster, Caster);
+                    m_UnderEffect[Caster] = t = Timer.DelayCall(duration, new TimerStateCallback(RemoveEffect), Caster);
+                    Caster.SendMessage("Clouds swirl and boil above your head!");
+                    Caster.FixedParticles(0xC4A, 10, 15, 5028, EffectLayer.Head);
+                    Caster.PlaySound(0x16);
+                }
+            }
+
+            FinishSequence();
+        }
+
+        private static Hashtable m_UnderEffect = new Hashtable();
+
+        private static void RemoveEffect(object state)
+        {
+            Mobile m = (Mobile)state;
+
+            m_UnderEffect.Remove(m);
+
+            m.SendMessage("The magical weather fades away.");
+        }
+
+        public static bool UnderEffect(Mobile m)
+        {
+            return m_UnderEffect.Contains(m);
+        }
+    }
+}