Overwrite

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

Scripts/Spells/Second/Agility.cs

@@ -0,0 +1,87 @@
+using System;
+using Server.Targeting;
+
+namespace Server.Spells.Second
+{
+    public class AgilitySpell : MagerySpell
+    {
+        private static readonly SpellInfo m_Info = new SpellInfo(
+            "Agility", "Ex Uus",
+            212,
+            9061,
+            Reagent.Bloodmoss,
+            Reagent.MandrakeRoot);
+        public AgilitySpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override SpellCircle Circle
+        {
+            get
+            {
+                return SpellCircle.Second;
+            }
+        }
+        
+        public override void OnCast()
+        {
+            this.Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(Mobile m)
+        {
+            if (!this.Caster.CanSee(m))
+            {
+                this.Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (this.CheckBSequence(m))
+            {
+                int oldDex = SpellHelper.GetBuffOffset(m, StatType.Dex);
+                int newDex = SpellHelper.GetOffset(Caster, m, StatType.Dex, false, true);
+
+                if (newDex < oldDex || newDex == 0)
+                {
+                    DoHurtFizzle();
+                }
+                else
+                {
+                    SpellHelper.Turn(this.Caster, m);
+
+                    SpellHelper.AddStatBonus(this.Caster, m, false, StatType.Dex);
+                    int percentage = (int)(SpellHelper.GetOffsetScalar(this.Caster, m, false) * 100);
+                    TimeSpan length = SpellHelper.GetDuration(this.Caster, m);
+                    BuffInfo.AddBuff(m, new BuffInfo(BuffIcon.Agility, 1075841, length, m, percentage.ToString()));
+
+                    m.FixedParticles(0x375A, 10, 15, 5010, EffectLayer.Waist);
+                    m.PlaySound(0x1e7);
+                }
+            }
+
+            this.FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private readonly AgilitySpell m_Owner;
+            public InternalTarget(AgilitySpell owner)
+                : base(Core.ML ? 10 : 12, false, TargetFlags.Beneficial)
+            {
+                this.m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Mobile)
+                {
+                    this.m_Owner.Target((Mobile)o);
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                this.m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/Spells/Second/Cunning.cs

@@ -0,0 +1,87 @@
+using System;
+using Server.Targeting;
+
+namespace Server.Spells.Second
+{
+    public class CunningSpell : MagerySpell
+    {
+        private static readonly SpellInfo m_Info = new SpellInfo(
+            "Cunning", "Uus Wis",
+            212,
+            9061,
+            Reagent.MandrakeRoot,
+            Reagent.Nightshade);
+        public CunningSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override SpellCircle Circle
+        {
+            get
+            {
+                return SpellCircle.Second;
+            }
+        }
+        
+        public override void OnCast()
+        {
+            this.Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(Mobile m)
+        {
+            if (!this.Caster.CanSee(m))
+            {
+                this.Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (this.CheckBSequence(m))
+            {
+                int oldInt = SpellHelper.GetBuffOffset(m, StatType.Int);
+                int newInt = SpellHelper.GetOffset(Caster, m, StatType.Int, false, true);
+
+                if (newInt < oldInt || newInt == 0)
+                {
+                    DoHurtFizzle();
+                }
+                else
+                {
+                    SpellHelper.Turn(this.Caster, m);
+
+                    SpellHelper.AddStatBonus(this.Caster, m, false, StatType.Int);
+                    int percentage = (int)(SpellHelper.GetOffsetScalar(this.Caster, m, false) * 100);
+                    TimeSpan length = SpellHelper.GetDuration(this.Caster, m);
+                    BuffInfo.AddBuff(m, new BuffInfo(BuffIcon.Cunning, 1075843, length, m, percentage.ToString()));
+
+                    m.FixedParticles(0x375A, 10, 15, 5011, EffectLayer.Head);
+                    m.PlaySound(0x1EB);
+                }
+            }
+
+            this.FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private readonly CunningSpell m_Owner;
+            public InternalTarget(CunningSpell owner)
+                : base(Core.ML ? 10 : 12, false, TargetFlags.Beneficial)
+            {
+                this.m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Mobile)
+                {
+                    this.m_Owner.Target((Mobile)o);
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                this.m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/Spells/Second/Cure.cs

@@ -0,0 +1,95 @@
+using System;
+using Server.Targeting;
+
+namespace Server.Spells.Second
+{
+    public class CureSpell : MagerySpell
+    {
+        private static readonly SpellInfo m_Info = new SpellInfo(
+            "Cure", "An Nox",
+            212,
+            9061,
+            Reagent.Garlic,
+            Reagent.Ginseng);
+        public CureSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override SpellCircle Circle
+        {
+            get
+            {
+                return SpellCircle.Second;
+            }
+        }
+        
+        public override void OnCast()
+        {
+            this.Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(Mobile m)
+        {
+            if (!this.Caster.CanSee(m))
+            {
+                this.Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (this.CheckBSequence(m))
+            {
+                SpellHelper.Turn(this.Caster, m);
+
+                Poison p = m.Poison;
+
+                if (p != null)
+                {
+                    int chanceToCure = 10000 + (int)(this.Caster.Skills[SkillName.Magery].Value * 75) - ((p.RealLevel + 1) * (Core.AOS ? (p.RealLevel < 4 ? 3300 : 3100) : 1750));
+                    chanceToCure /= 100;
+
+                    if (chanceToCure > Utility.Random(100))
+                    {
+                        if (m.CurePoison(this.Caster))
+                        {
+                            if (this.Caster != m)
+                                this.Caster.SendLocalizedMessage(1010058); // You have cured the target of all poisons!
+
+                            m.SendLocalizedMessage(1010059); // You have been cured of all poisons.
+                        }
+                    }
+                    else
+                    {
+                        m.SendLocalizedMessage(1010060); // You have failed to cure your target!
+                    }
+                }
+
+                m.FixedParticles(0x373A, 10, 15, 5012, EffectLayer.Waist);
+                m.PlaySound(0x1E0);
+            }
+
+            this.FinishSequence();
+        }
+
+        public class InternalTarget : Target
+        {
+            private readonly CureSpell m_Owner;
+            public InternalTarget(CureSpell owner)
+                : base(Core.ML ? 10 : 12, false, TargetFlags.Beneficial)
+            {
+                this.m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Mobile)
+                {
+                    this.m_Owner.Target((Mobile)o);
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                this.m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/Spells/Second/Harm.cs

@@ -0,0 +1,134 @@
+using System;
+using Server.Targeting;
+
+namespace Server.Spells.Second
+{
+    public class HarmSpell : MagerySpell
+    {
+        private static readonly SpellInfo m_Info = new SpellInfo(
+            "Harm", "An Mani",
+            212,
+            Core.AOS ? 9001 : 9041,
+            Reagent.Nightshade,
+            Reagent.SpidersSilk);
+        public HarmSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override SpellCircle Circle
+        {
+            get
+            {
+                return SpellCircle.Second;
+            }
+        }
+        public override bool DelayedDamage
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override void OnCast()
+        {
+            this.Caster.Target = new InternalTarget(this);
+        }
+
+        public override double GetSlayerDamageScalar(Mobile target)
+        {
+            return 1.0; //This spell isn't affected by slayer spellbooks
+        }
+
+        public void Target(IDamageable m)
+        {
+            Mobile mob = m as Mobile;
+
+            if (!this.Caster.CanSee(m))
+            {
+                this.Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (this.CheckHSequence(m))
+            {
+                SpellHelper.Turn(this.Caster, m);
+                Mobile source = this.Caster;
+
+                SpellHelper.CheckReflect((int)this.Circle, ref source, ref m);
+
+                double damage = 0;
+				
+                if (Core.AOS)
+                {
+                    damage = GetNewAosDamage(17, 1, 5, m);
+                }
+                else if (mob != null)
+                {
+                    damage = Utility.Random(1, 15);
+
+                    if (this.CheckResisted(mob))
+                    {
+                        damage *= 0.75;
+
+                        mob.SendLocalizedMessage(501783); // You feel yourself resisting magical energy.
+                    }
+
+                    damage *= this.GetDamageScalar(mob);
+                }
+
+                if (!this.Caster.InRange(m, 2))
+                    damage *= 0.25; // 1/4 damage at > 2 tile range
+                else if (!this.Caster.InRange(m, 1))
+                    damage *= 0.50; // 1/2 damage at 2 tile range
+
+                if (Core.AOS)
+                {
+                    if (mob != null)
+                    {
+                        mob.FixedParticles(0x374A, 10, 30, 5013, 1153, 2, EffectLayer.Waist);
+                        mob.PlaySound(0x0FC);
+                    }
+                    else
+                    {
+                        Effects.SendLocationParticles(m, 0x374A, 10, 30, 1153, 2, 5013, 0);
+                        Effects.PlaySound(m.Location, m.Map, 0x0FC);
+                    }
+                }
+                else if (mob != null)
+                {
+                    mob.FixedParticles(0x374A, 10, 15, 5013, EffectLayer.Waist);
+                    mob.PlaySound(0x1F1);
+                }
+
+                if (damage > 0)
+                {
+                    SpellHelper.Damage(this, m, damage, 0, 0, 100, 0, 0);
+                }
+            }
+
+            this.FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private readonly HarmSpell m_Owner;
+            public InternalTarget(HarmSpell owner)
+                : base(Core.ML ? 10 : 12, false, TargetFlags.Harmful)
+            {
+                this.m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is IDamageable)
+                {
+                    this.m_Owner.Target((IDamageable)o);
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                this.m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/Spells/Second/MagicTrap.cs

@@ -0,0 +1,92 @@
+using System;
+using Server.Items;
+using Server.Targeting;
+
+namespace Server.Spells.Second
+{
+    public class MagicTrapSpell : MagerySpell
+    {
+        private static readonly SpellInfo m_Info = new SpellInfo(
+            "Magic Trap", "In Jux",
+            212,
+            9001,
+            Reagent.Garlic,
+            Reagent.SpidersSilk,
+            Reagent.SulfurousAsh);
+        public MagicTrapSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override SpellCircle Circle
+        {
+            get
+            {
+                return SpellCircle.Second;
+            }
+        }
+        public override void OnCast()
+        {
+            this.Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(TrapableContainer item)
+        {
+            if (!this.Caster.CanSee(item))
+            {
+                this.Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (item.TrapType != TrapType.None && item.TrapType != TrapType.MagicTrap)
+            {
+                base.DoFizzle();
+            }
+            else if (this.CheckSequence())
+            {
+                SpellHelper.Turn(this.Caster, item);
+
+                item.TrapType = TrapType.MagicTrap;
+                item.TrapPower = Core.AOS ? Utility.RandomMinMax(10, 50) : 1;
+                item.TrapLevel = 0;
+
+                Point3D loc = item.GetWorldLocation();
+
+                Effects.SendLocationParticles(EffectItem.Create(new Point3D(loc.X + 1, loc.Y, loc.Z), item.Map, EffectItem.DefaultDuration), 0x376A, 9, 10, 9502);
+                Effects.SendLocationParticles(EffectItem.Create(new Point3D(loc.X, loc.Y - 1, loc.Z), item.Map, EffectItem.DefaultDuration), 0x376A, 9, 10, 9502);
+                Effects.SendLocationParticles(EffectItem.Create(new Point3D(loc.X - 1, loc.Y, loc.Z), item.Map, EffectItem.DefaultDuration), 0x376A, 9, 10, 9502);
+                Effects.SendLocationParticles(EffectItem.Create(new Point3D(loc.X, loc.Y + 1, loc.Z), item.Map, EffectItem.DefaultDuration), 0x376A, 9, 10, 9502);
+                Effects.SendLocationParticles(EffectItem.Create(new Point3D(loc.X, loc.Y, loc.Z), item.Map, EffectItem.DefaultDuration), 0, 0, 0, 5014);
+
+                Effects.PlaySound(loc, item.Map, 0x1EF);
+            }
+
+            this.FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private readonly MagicTrapSpell m_Owner;
+            public InternalTarget(MagicTrapSpell owner)
+                : base(Core.ML ? 10 : 12, false, TargetFlags.None)
+            {
+                this.m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is TrapableContainer)
+                {
+                    this.m_Owner.Target((TrapableContainer)o);
+                }
+                else
+                {
+                    from.SendMessage("You can't trap that");
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                this.m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/Spells/Second/Protection.cs

@@ -0,0 +1,200 @@
+using System;
+using System.Collections;
+
+namespace Server.Spells.Second
+{
+    public class ProtectionSpell : MagerySpell
+    {
+        private static readonly Hashtable m_Registry = new Hashtable();
+        private static readonly SpellInfo m_Info = new SpellInfo(
+            "Protection", "Uus Sanct",
+            236,
+            9011,
+            Reagent.Garlic,
+            Reagent.Ginseng,
+            Reagent.SulfurousAsh);
+        private static readonly Hashtable m_Table = new Hashtable();
+        public ProtectionSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public static Hashtable Registry
+        {
+            get
+            {
+                return m_Registry;
+            }
+        }
+        public override SpellCircle Circle
+        {
+            get
+            {
+                return SpellCircle.Second;
+            }
+        }
+        public static void Toggle(Mobile caster, Mobile target, bool archprotection)
+        {
+            /* Players under the protection spell effect can no longer have their spells "disrupted" when hit.
+            * Players under the protection spell have decreased physical resistance stat value (-15 + (Inscription/20),
+            * a decreased "resisting spells" skill value by -35 + (Inscription/20),
+            * and a slower casting speed modifier (technically, a negative "faster cast speed") of 2 points.
+            * The protection spell has an indefinite duration, becoming active when cast, and deactivated when re-cast.
+            * Reactive Armor, Protection, and Magic Reflection will stay on—even after logging out,
+            * even after dying—until you “turn them off” by casting them again.
+            */
+            object[] mods = (object[])m_Table[target];
+
+            if (mods == null)
+            {
+                target.PlaySound(0x1E9);
+                target.FixedParticles(0x375A, 9, 20, 5016, EffectLayer.Waist);
+
+                mods = new object[2]
+                {
+                    new ResistanceMod(ResistanceType.Physical, -15 + Math.Min((int)(caster.Skills[SkillName.Inscribe].Value / 20), 15)),
+                    new DefaultSkillMod(SkillName.MagicResist, true, -35 + Math.Min((int)(caster.Skills[SkillName.Inscribe].Value / 20), 35))
+                };
+
+                m_Table[target] = mods;
+                Registry[target] = 100.0;
+
+                target.AddResistanceMod((ResistanceMod)mods[0]);
+                target.AddSkillMod((SkillMod)mods[1]);
+
+                int physloss = -15 + (int)(caster.Skills[SkillName.Inscribe].Value / 20);
+                int resistloss = -35 + (int)(caster.Skills[SkillName.Inscribe].Value / 20);
+                string args = String.Format("{0}\t{1}", physloss, resistloss);
+                BuffInfo.AddBuff(target, new BuffInfo(archprotection ? BuffIcon.ArchProtection : BuffIcon.Protection, archprotection ? 1075816 : 1075814, 1075815, args.ToString()));
+            }
+            else
+            {
+                target.PlaySound(0x1ED);
+                target.FixedParticles(0x375A, 9, 20, 5016, EffectLayer.Waist);
+
+                m_Table.Remove(target);
+                Registry.Remove(target);
+
+                target.RemoveResistanceMod((ResistanceMod)mods[0]);
+                target.RemoveSkillMod((SkillMod)mods[1]);
+
+                BuffInfo.RemoveBuff(target, BuffIcon.Protection);
+                BuffInfo.RemoveBuff(target, BuffIcon.ArchProtection);
+            }
+        }
+
+        public static void EndProtection(Mobile m)
+        {
+            if (m_Table.Contains(m))
+            {
+                object[] mods = (object[])m_Table[m];
+
+                m_Table.Remove(m);
+                Registry.Remove(m);
+
+                m.RemoveResistanceMod((ResistanceMod)mods[0]);
+                m.RemoveSkillMod((SkillMod)mods[1]);
+
+                BuffInfo.RemoveBuff(m, BuffIcon.Protection);
+                BuffInfo.RemoveBuff(m, BuffIcon.ArchProtection);
+            }
+        }
+
+        public override bool CheckCast()
+        {
+            if (Core.AOS)
+                return true;
+
+            if (m_Registry.ContainsKey(this.Caster))
+            {
+                this.Caster.SendLocalizedMessage(1005559); // This spell is already in effect.
+                return false;
+            }
+            else if (!this.Caster.CanBeginAction(typeof(DefensiveSpell)))
+            {
+                this.Caster.SendLocalizedMessage(1005385); // The spell will not adhere to you at this time.
+                return false;
+            }
+
+            return true;
+        }
+
+        public override void OnCast()
+        {
+            if (Core.AOS)
+            {
+                if (this.CheckSequence())
+                    Toggle(this.Caster, this.Caster, false);
+
+                this.FinishSequence();
+            }
+            else
+            {
+                if (m_Registry.ContainsKey(this.Caster))
+                {
+                    this.Caster.SendLocalizedMessage(1005559); // This spell is already in effect.
+                }
+                else if (!this.Caster.CanBeginAction(typeof(DefensiveSpell)))
+                {
+                    this.Caster.SendLocalizedMessage(1005385); // The spell will not adhere to you at this time.
+                }
+                else if (this.CheckSequence())
+                {
+                    if (this.Caster.BeginAction(typeof(DefensiveSpell)))
+                    {
+                        double value = (int)(this.Caster.Skills[SkillName.EvalInt].Value + this.Caster.Skills[SkillName.Meditation].Value + this.Caster.Skills[SkillName.Inscribe].Value);
+                        value /= 4;
+
+                        if (value < 0)
+                            value = 0;
+                        else if (value > 75)
+                            value = 75.0;
+
+                        Registry.Add(this.Caster, value);
+                        new InternalTimer(this.Caster).Start();
+
+                        this.Caster.FixedParticles(0x375A, 9, 20, 5016, EffectLayer.Waist);
+                        this.Caster.PlaySound(0x1ED);
+                    }
+                    else
+                    {
+                        this.Caster.SendLocalizedMessage(1005385); // The spell will not adhere to you at this time.
+                    }
+                }
+
+                this.FinishSequence();
+            }
+        }
+
+        #region SA
+        public static bool HasProtection(Mobile m)
+        {
+            return m_Table.ContainsKey(m);
+        }
+        #endregion
+
+        private class InternalTimer : Timer
+        {
+            private readonly Mobile m_Caster;
+            public InternalTimer(Mobile caster)
+                : base(TimeSpan.FromSeconds(0))
+            {
+                double val = caster.Skills[SkillName.Magery].Value * 2.0;
+                if (val < 15)
+                    val = 15;
+                else if (val > 240)
+                    val = 240;
+
+                this.m_Caster = caster;
+                this.Delay = TimeSpan.FromSeconds(val);
+                this.Priority = TimerPriority.OneSecond;
+            }
+
+            protected override void OnTick()
+            {
+                ProtectionSpell.Registry.Remove(this.m_Caster);
+                DefensiveSpell.Nullify(this.m_Caster);
+            }
+        }
+    }
+}

Scripts/Spells/Second/RemoveTrap.cs

@@ -0,0 +1,86 @@
+using System;
+using Server.Items;
+using Server.Targeting;
+
+namespace Server.Spells.Second
+{
+    public class RemoveTrapSpell : MagerySpell
+    {
+        private static readonly SpellInfo m_Info = new SpellInfo(
+            "Remove Trap", "An Jux",
+            212,
+            9001,
+            Reagent.Bloodmoss,
+            Reagent.SulfurousAsh);
+        public RemoveTrapSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override SpellCircle Circle
+        {
+            get
+            {
+                return SpellCircle.Second;
+            }
+        }
+        public override void OnCast()
+        {
+            this.Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(TrapableContainer item)
+        {
+            if (!this.Caster.CanSee(item))
+            {
+                this.Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (item.TrapType != TrapType.None && item.TrapType != TrapType.MagicTrap)
+            {
+                base.DoFizzle();
+            }
+            else if (this.CheckSequence())
+            {
+                SpellHelper.Turn(this.Caster, item);
+
+                Point3D loc = item.GetWorldLocation();
+
+                Effects.SendLocationParticles(EffectItem.Create(loc, item.Map, EffectItem.DefaultDuration), 0x376A, 9, 32, 5015);
+                Effects.PlaySound(loc, item.Map, 0x1F0);
+
+                item.TrapType = TrapType.None;
+                item.TrapPower = 0;
+                item.TrapLevel = 0;
+            }
+
+            this.FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private readonly RemoveTrapSpell m_Owner;
+            public InternalTarget(RemoveTrapSpell owner)
+                : base(Core.ML ? 10 : 12, false, TargetFlags.None)
+            {
+                this.m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is TrapableContainer)
+                {
+                    this.m_Owner.Target((TrapableContainer)o);
+                }
+                else
+                {
+                    from.SendLocalizedMessage(501856); // That isn't trapped.
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                this.m_Owner.FinishSequence();
+            }
+        }
+    }
+}

Scripts/Spells/Second/Strength.cs

@@ -0,0 +1,87 @@
+using System;
+using Server.Targeting;
+
+namespace Server.Spells.Second
+{
+    public class StrengthSpell : MagerySpell
+    {
+        private static readonly SpellInfo m_Info = new SpellInfo(
+            "Strength", "Uus Mani",
+            212,
+            9061,
+            Reagent.MandrakeRoot,
+            Reagent.Nightshade);
+        public StrengthSpell(Mobile caster, Item scroll)
+            : base(caster, scroll, m_Info)
+        {
+        }
+
+        public override SpellCircle Circle
+        {
+            get
+            {
+                return SpellCircle.Second;
+            }
+        }
+        
+        public override void OnCast()
+        {
+            this.Caster.Target = new InternalTarget(this);
+        }
+
+        public void Target(Mobile m)
+        {
+            if (!this.Caster.CanSee(m))
+            {
+                this.Caster.SendLocalizedMessage(500237); // Target can not be seen.
+            }
+            else if (this.CheckBSequence(m))
+            {
+                SpellHelper.Turn(this.Caster, m);
+
+                int oldStr = SpellHelper.GetBuffOffset(m, StatType.Str);
+                int newStr = SpellHelper.GetOffset(Caster, m, StatType.Str, false, true);
+
+                if (newStr < oldStr || newStr == 0)
+                {
+                    DoHurtFizzle();
+                }
+                else
+                {
+                    SpellHelper.AddStatBonus(this.Caster, m, false, StatType.Str);
+                    int percentage = (int)(SpellHelper.GetOffsetScalar(this.Caster, m, false) * 100);
+                    TimeSpan length = SpellHelper.GetDuration(this.Caster, m);
+                    BuffInfo.AddBuff(m, new BuffInfo(BuffIcon.Strength, 1075845, length, m, percentage.ToString()));
+
+                    m.FixedParticles(0x375A, 10, 15, 5017, EffectLayer.Waist);
+                    m.PlaySound(0x1EE);
+                }
+            }
+
+            this.FinishSequence();
+        }
+
+        private class InternalTarget : Target
+        {
+            private readonly StrengthSpell m_Owner;
+            public InternalTarget(StrengthSpell owner)
+                : base(Core.ML ? 10 : 12, false, TargetFlags.Beneficial)
+            {
+                this.m_Owner = owner;
+            }
+
+            protected override void OnTarget(Mobile from, object o)
+            {
+                if (o is Mobile)
+                {
+                    this.m_Owner.Target((Mobile)o);
+                }
+            }
+
+            protected override void OnTargetFinish(Mobile from)
+            {
+                this.m_Owner.FinishSequence();
+            }
+        }
+    }
+}