Reorganizes Project (#41)

Projects/Scripts/Spells/Mysticism/AnimatedWeaponSpell.cs

@@ -0,0 +1,66 @@
+using System;
+using Server.Mobiles;
+
+namespace Server.Spells.Mysticism
+{
+  public class AnimatedWeaponSpell : MysticSpell, ISpellTargetingPoint3D
+  {
+    private static SpellInfo m_Info = new SpellInfo(
+      "Animated Weapon", "In Jux Por Ylem",
+      -1,
+      9002,
+      Reagent.Bone,
+      Reagent.BlackPearl,
+      Reagent.MandrakeRoot,
+      Reagent.Nightshade
+    );
+
+    public AnimatedWeaponSpell(Mobile caster, Item scroll = null)
+      : base(caster, scroll, m_Info)
+    {
+    }
+
+    public override TimeSpan CastDelayBase => TimeSpan.FromSeconds(1.5);
+
+    public override double RequiredSkill => 33.0;
+    public override int RequiredMana => 11;
+
+    public override void OnCast()
+    {
+      Caster.Target = new SpellTargetPoint3D(this);
+    }
+
+    public void Target(IPoint3D p)
+    {
+      if (Caster.Followers + 4 > Caster.FollowersMax)
+      {
+        Caster.SendLocalizedMessage(1049645); // You have too many followers to summon that creature.
+        return;
+      }
+
+      Map map = Caster.Map;
+
+      SpellHelper.GetSurfaceTop(ref p);
+
+      if (map == null || Caster.Player && !map.CanSpawnMobile(p.X, p.Y, p.Z))
+      {
+        Caster.SendLocalizedMessage(501942); // That location is blocked.
+      }
+      else if (SpellHelper.CheckTown(p, Caster) && CheckSequence())
+      {
+        int level = (int)((GetBaseSkill(Caster) + GetBoostSkill(Caster)) / 2.0);
+
+        TimeSpan duration = TimeSpan.FromSeconds(10 + level);
+
+        AnimatedWeapon summon = new AnimatedWeapon(Caster, level);
+        BaseCreature.Summon(summon, false, Caster, new Point3D(p), 0x212, duration);
+
+        summon.PlaySound(0x64A);
+
+        Effects.SendTargetParticles(summon, 0x3728, 10, 10, 0x13AA, (EffectLayer)255);
+      }
+
+      FinishSequence();
+    }
+  }
+}

Projects/Scripts/Spells/Mysticism/EagleStrikeSpell.cs

@@ -0,0 +1,69 @@
+using System;
+using Server.Targeting;
+
+namespace Server.Spells.Mysticism
+{
+  public class EagleStrikeSpell : MysticSpell, ISpellTargetingMobile
+  {
+    private static SpellInfo m_Info = new SpellInfo(
+      "Eagle Strike", "Kal Por Xen",
+      -1,
+      9002,
+      Reagent.Bloodmoss,
+      Reagent.Bone,
+      Reagent.SpidersSilk,
+      Reagent.MandrakeRoot
+    );
+
+    public EagleStrikeSpell(Mobile caster, Item scroll = null)
+      : base(caster, scroll, m_Info)
+    {
+    }
+
+    public override TimeSpan CastDelayBase => TimeSpan.FromSeconds(1.25);
+
+    public override double RequiredSkill => 20.0;
+    public override int RequiredMana => 9;
+
+    public override void OnCast()
+    {
+      Caster.Target = new SpellTargetMobile(this, TargetFlags.Harmful);
+    }
+
+    public void Target(Mobile m)
+    {
+      if (m == null)
+        return;
+
+      if (CheckHSequence(m))
+      {
+        /* Conjures a magical eagle that assaults the Target with
+         * its talons, dealing energy damage.
+         */
+
+        SpellHelper.Turn(Caster, m);
+
+        SpellHelper.CheckReflect(2, Caster, ref m);
+
+        Caster.MovingParticles(m, 0x407A, 7, 0, false, true, 0, 0, 0xBBE, 0xFA6, 0xFFFF, 0);
+        Caster.PlaySound(0x2EE);
+
+        Timer.DelayCall(TimeSpan.FromSeconds(1.0), Damage, m);
+      }
+
+      FinishSequence();
+    }
+
+    private void Damage(Mobile to)
+    {
+      if (to == null)
+        return;
+
+      double damage = GetNewAosDamage(19, 1, 5, to);
+
+      SpellHelper.Damage(this, to, damage, 0, 0, 0, 0, 100);
+
+      to.PlaySound(0x64D);
+    }
+  }
+}

Projects/Scripts/Spells/Mysticism/HailStormSpell.cs

@@ -0,0 +1,121 @@
+using System;
+using System.Collections.Generic;
+using Server.Network;
+
+namespace Server.Spells.Mysticism
+{
+  public class HailStormSpell : MysticSpell, ISpellTargetingPoint3D
+  {
+    private static SpellInfo m_Info = new SpellInfo(
+      "Hail Storm", "Kal Des Ylem",
+      -1,
+      9002,
+      Reagent.DragonsBlood,
+      Reagent.Bloodmoss,
+      Reagent.BlackPearl,
+      Reagent.MandrakeRoot
+    );
+
+    public HailStormSpell(Mobile caster, Item scroll = null)
+      : base(caster, scroll, m_Info)
+    {
+    }
+
+    public override TimeSpan CastDelayBase => TimeSpan.FromSeconds(2.25);
+
+    public override double RequiredSkill => 70.0;
+    public override int RequiredMana => 40;
+
+    public override void OnCast()
+    {
+      Caster.Target = new SpellTargetPoint3D(this);
+    }
+
+    public void Target(IPoint3D p)
+    {
+      if (SpellHelper.CheckTown(p, Caster) && CheckSequence())
+      {
+        /* Summons a storm of hailstones that strikes all Targets
+         * within a radius around the Target's Location, dealing
+         * cold damage.
+         */
+
+        SpellHelper.Turn(Caster, p);
+
+        if (p is Item item)
+          p = item.GetWorldLocation();
+
+        List<Mobile> targets = new List<Mobile>();
+
+        Map map = Caster.Map;
+
+        bool pvp = false;
+
+        if (map != null)
+        {
+          PlayEffect(p, Caster.Map);
+
+          foreach (Mobile m in map.GetMobilesInRange(new Point3D(p), 2))
+          {
+            if (m == Caster)
+              continue;
+
+            if (SpellHelper.ValidIndirectTarget(Caster, m) && Caster.CanBeHarmful(m, false) && Caster.CanSee(m))
+            {
+              if (!Caster.InLOS(m))
+                continue;
+
+              targets.Add(m);
+
+              if (m.Player)
+                pvp = true;
+            }
+          }
+        }
+
+        double damage = GetNewAosDamage(51, 1, 5, pvp);
+
+        foreach (Mobile m in targets)
+        {
+          Caster.DoHarmful(m);
+          SpellHelper.Damage(this, m, damage, 0, 0, 100, 0, 0);
+        }
+      }
+
+      FinishSequence();
+    }
+
+    private static void PlayEffect(IPoint3D p, Map map)
+    {
+      Effects.PlaySound(p, map, 0x64F);
+
+      PlaySingleEffect(p, map, -1, 1, -1, 1);
+      PlaySingleEffect(p, map, -2, 0, -3, -1);
+      PlaySingleEffect(p, map, -3, -1, -1, 1);
+      PlaySingleEffect(p, map, 1, 3, -1, 1);
+      PlaySingleEffect(p, map, -1, 1, 1, 3);
+    }
+
+    private static void PlaySingleEffect(IPoint3D p, Map map, int a, int b, int c, int d)
+    {
+      int x = p.X, y = p.Y, z = p.Z + 18;
+
+      SendEffectPacket(p, map, new Point3D(x + a, y + c, z), new Point3D(x + a, y + c, z));
+      SendEffectPacket(p, map, new Point3D(x + b, y + c, z), new Point3D(x + b, y + c, z));
+      SendEffectPacket(p, map, new Point3D(x + b, y + d, z), new Point3D(x + b, y + d, z));
+      SendEffectPacket(p, map, new Point3D(x + a, y + d, z), new Point3D(x + a, y + d, z));
+
+      SendEffectPacket(p, map, new Point3D(x + b, y + c, z), new Point3D(x + a, y + c, z));
+      SendEffectPacket(p, map, new Point3D(x + b, y + d, z), new Point3D(x + b, y + c, z));
+      SendEffectPacket(p, map, new Point3D(x + a, y + d, z), new Point3D(x + b, y + d, z));
+      SendEffectPacket(p, map, new Point3D(x + a, y + c, z), new Point3D(x + a, y + d, z));
+    }
+
+    private static void SendEffectPacket(IPoint3D p, Map map, Point3D orig, Point3D dest)
+    {
+      Effects.SendPacket(p, map,
+        new HuedEffect(EffectType.Moving, Serial.Zero, Serial.Zero, 0x36D4, orig, dest, 0, 0, false, false, 0x63,
+          0x4));
+    }
+  }
+}

Projects/Scripts/Spells/Mysticism/MysticSpell.cs

@@ -0,0 +1,93 @@
+using System;
+
+namespace Server.Spells.Mysticism
+{
+  public abstract class MysticSpell : Spell
+  {
+    public MysticSpell(Mobile caster, Item scroll, SpellInfo info)
+      : base(caster, scroll, info)
+    {
+    }
+
+    public abstract double RequiredSkill{ get; }
+    public abstract int RequiredMana{ get; }
+
+    public override SkillName CastSkill => SkillName.Mysticism;
+
+    /*
+     * As per OSI Publish 64:
+     * Imbuing is not the only skill associated with Mysticism now.
+     * Players can use EITHER their Focus skill or Imbuing skill.
+     * Evaluate Intelligence no longer has any effect on a Mystic’s spell power.
+     */
+    public override double GetDamageSkill(Mobile m)
+    {
+      return Math.Max(m.Skills.Imbuing.Value, m.Skills.Focus.Value);
+    }
+
+    public override int GetDamageFixed(Mobile m)
+    {
+      return Math.Max(m.Skills.Imbuing.Fixed, m.Skills.Focus.Fixed);
+    }
+
+    public override void GetCastSkills(out double min, out double max)
+    {
+      // As per Mysticism page at the UO Herald Playguide
+      // This means that we have 25% success chance at min Required Skill
+
+      min = RequiredSkill - 12.5;
+      max = RequiredSkill + 37.5;
+    }
+
+    public override int GetMana()
+    {
+      return RequiredMana;
+    }
+
+    public override bool CheckCast()
+    {
+      if (!base.CheckCast())
+        return false;
+
+      int mana = ScaleMana(RequiredMana);
+
+      if (Caster.Mana < mana)
+      {
+        Caster.SendLocalizedMessage(1060174,
+          mana.ToString()); // You must have at least ~1_MANA_REQUIREMENT~ Mana to use this ability.
+        return false;
+      }
+
+      if (Caster.Skills[CastSkill].Value < RequiredSkill)
+      {
+        Caster.SendLocalizedMessage(1063013,
+          $"{RequiredSkill.ToString("F1")}\t{CastSkill.ToString()}\t "); // You need at least ~1_SKILL_REQUIREMENT~ ~2_SKILL_NAME~ skill to use that ability.
+        return false;
+      }
+
+      return true;
+    }
+
+    public override void OnBeginCast()
+    {
+      base.OnBeginCast();
+
+      SendCastEffect();
+    }
+
+    public virtual void SendCastEffect()
+    {
+      Caster.FixedEffect(0x37C4, 10, (int)(GetCastDelay().TotalSeconds * 28), 0x66C, 3);
+    }
+
+    public static double GetBaseSkill(Mobile m)
+    {
+      return m.Skills.Mysticism.Value;
+    }
+
+    public static double GetBoostSkill(Mobile m)
+    {
+      return Math.Max(m.Skills.Imbuing.Value, m.Skills.Focus.Value);
+    }
+  }
+}

Projects/Scripts/Spells/Mysticism/NetherCycloneSpell.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using Server.Network;
+
+namespace Server.Spells.Mysticism
+{
+  public class NetherCycloneSpell : MysticSpell, ISpellTargetingPoint3D
+  {
+    private static SpellInfo m_Info = new SpellInfo(
+      "Nether Cyclone", "Grav Hur",
+      -1,
+      9002,
+      Reagent.MandrakeRoot,
+      Reagent.Nightshade,
+      Reagent.SulfurousAsh,
+      Reagent.Bloodmoss
+    );
+
+    public NetherCycloneSpell(Mobile caster, Item scroll = null)
+      : base(caster, scroll, m_Info)
+    {
+    }
+
+    public override TimeSpan CastDelayBase => TimeSpan.FromSeconds(2.5);
+
+    public override double RequiredSkill => 83.0;
+    public override int RequiredMana => 50;
+
+    public override void OnCast()
+    {
+      Caster.Target = new SpellTargetPoint3D(this);
+    }
+
+    public void Target(IPoint3D p)
+    {
+      if (SpellHelper.CheckTown(p, Caster) && CheckSequence())
+      {
+        /* Summons a gale of lethal winds that strikes all Targets within a radius around
+         * the Target's Location, dealing chaos damage. In addition to inflicting damage,
+         * each Target of the Nether Cyclone temporarily loses a percentage of mana and
+         * stamina. The effectiveness of the Nether Cyclone is determined by a comparison
+         * between the Caster's Mysticism and either Focus or Imbuing (whichever is greater)
+         * skills and the Resisting Spells skill of the Target.
+         */
+
+        SpellHelper.Turn(Caster, p);
+
+        if (p is Item item)
+          p = item.GetWorldLocation();
+
+        List<Mobile> targets = new List<Mobile>();
+
+        Map map = Caster.Map;
+
+        bool pvp = false;
+
+        if (map != null)
+        {
+          PlayEffect(p, Caster.Map);
+
+          foreach (Mobile m in map.GetMobilesInRange(new Point3D(p), 2))
+          {
+            if (m == Caster)
+              continue;
+
+            if (SpellHelper.ValidIndirectTarget(Caster, m) && Caster.CanBeHarmful(m, false) && Caster.CanSee(m))
+            {
+              if (!Caster.InLOS(m))
+                continue;
+
+              targets.Add(m);
+
+              if (m.Player)
+                pvp = true;
+            }
+          }
+        }
+
+        int damage = GetNewAosDamage(51, 1, 5, pvp);
+        double reduction = (GetBaseSkill(Caster) + GetBoostSkill(Caster)) / 1200.0;
+
+        foreach (Mobile m in targets)
+        {
+          Caster.DoHarmful(m);
+          SpellHelper.Damage(this, m, damage, 0, 0, 0, 0, 0, 100);
+
+          double resistedReduction = reduction - m.Skills.MagicResist.Value / 800.0;
+
+          m.Stam -= (int)(m.StamMax * resistedReduction);
+          m.Mana -= (int)(m.ManaMax * resistedReduction);
+        }
+      }
+
+      FinishSequence();
+    }
+
+    private static void PlayEffect(IPoint3D p, Map map)
+    {
+      Effects.PlaySound(p, map, 0x64F);
+
+      PlaySingleEffect(p, map, -1, 1, -1, 1);
+      PlaySingleEffect(p, map, -2, 0, -3, -1);
+      PlaySingleEffect(p, map, -3, -1, -1, 1);
+      PlaySingleEffect(p, map, 1, 3, -1, 1);
+      PlaySingleEffect(p, map, -1, 1, 1, 3);
+    }
+
+    private static void PlaySingleEffect(IPoint3D p, Map map, int a, int b, int c, int d)
+    {
+      int x = p.X, y = p.Y, z = p.Z + 18;
+
+      SendEffectPacket(p, map, new Point3D(x + a, y + c, z), new Point3D(x + a, y + c, z));
+      SendEffectPacket(p, map, new Point3D(x + b, y + c, z), new Point3D(x + b, y + c, z));
+      SendEffectPacket(p, map, new Point3D(x + b, y + d, z), new Point3D(x + b, y + d, z));
+      SendEffectPacket(p, map, new Point3D(x + a, y + d, z), new Point3D(x + a, y + d, z));
+
+      SendEffectPacket(p, map, new Point3D(x + b, y + c, z), new Point3D(x + a, y + c, z));
+      SendEffectPacket(p, map, new Point3D(x + b, y + d, z), new Point3D(x + b, y + c, z));
+      SendEffectPacket(p, map, new Point3D(x + a, y + d, z), new Point3D(x + b, y + d, z));
+      SendEffectPacket(p, map, new Point3D(x + a, y + c, z), new Point3D(x + a, y + d, z));
+    }
+
+    private static void SendEffectPacket(IPoint3D p, Map map, Point3D orig, Point3D dest)
+    {
+      Effects.SendPacket(p, map,
+        new HuedEffect(EffectType.Moving, Serial.Zero, Serial.Zero, 0x375A, orig, dest, 0, 0, false, false, 0x49A,
+          0x4));
+    }
+  }
+}

Projects/Scripts/Spells/Mysticism/SpellPlagueSpell.cs

@@ -0,0 +1,217 @@
+using System;
+using System.Collections.Generic;
+using Server.Targeting;
+
+namespace Server.Spells.Mysticism
+{
+  public class SpellPlagueSpell : MysticSpell
+  {
+    private static SpellInfo m_Info = new SpellInfo(
+      "Spell Plague", "Vas Rel Jux Ort",
+      -1,
+      9002,
+      Reagent.DaemonBone,
+      Reagent.DragonsBlood,
+      Reagent.Nightshade,
+      Reagent.SulfurousAsh
+    );
+
+    private static Dictionary<Mobile, SpellPlagueContext> m_Table = new Dictionary<Mobile, SpellPlagueContext>();
+
+    public SpellPlagueSpell(Mobile caster, Item scroll = null)
+      : base(caster, scroll, m_Info)
+    {
+    }
+
+    public override TimeSpan CastDelayBase => TimeSpan.FromSeconds(2.25);
+
+    public override double RequiredSkill => 70.0;
+    public override int RequiredMana => 40;
+
+    public static void Initialize()
+    {
+      EventSink.PlayerDeath += OnPlayerDeath;
+    }
+
+    public override void OnCast()
+    {
+      Caster.Target = new InternalTarget(this);
+    }
+
+    public void Target(Mobile targeted)
+    {
+      if (!Caster.CanSee(targeted))
+      {
+        Caster.SendLocalizedMessage(500237); // Target can not be seen.
+      }
+      else if (CheckHSequence(targeted))
+      {
+        SpellHelper.Turn(Caster, targeted);
+
+        SpellHelper.CheckReflect(6, Caster, ref targeted);
+
+        /* The target is hit with an explosion of chaos damage and then inflicted
+         * with the spell plague curse. Each time the target is damaged while under
+         * the effect of the spell plague, they may suffer an explosion of chaos
+         * damage. The initial chance to trigger the explosion starts at 90% and
+         * reduces by 30% every time an explosion occurs. Once the target is
+         * afflicted by 3 explosions or 8 seconds have passed, that spell plague
+         * is removed from the target. Spell Plague will stack with other spell
+         * plagues so that they are applied one after the other.
+         */
+
+        VisualEffect(targeted);
+
+        int damage = GetNewAosDamage(33, 1, 5, targeted);
+        SpellHelper.Damage(this, targeted, damage, 0, 0, 0, 0, 0);
+
+        SpellPlagueContext context = new SpellPlagueContext(this, targeted);
+
+        if (m_Table.TryGetValue(targeted, out SpellPlagueContext oldContext))
+          oldContext.SetNext(context);
+        else
+        {
+          m_Table[targeted] = context;
+          context.Start();
+        }
+      }
+
+      FinishSequence();
+    }
+
+    public static bool UnderEffect(Mobile m)
+    {
+      return m_Table.ContainsKey(m);
+    }
+
+    public static void RemoveEffect(Mobile m)
+    {
+      if (m_Table.TryGetValue(m, out SpellPlagueContext context))
+        context.EndPlague(false);
+    }
+
+    public static void CheckPlague(Mobile m)
+    {
+      if (m_Table.TryGetValue(m, out SpellPlagueContext context))
+        context.OnDamage();
+    }
+
+    private static void OnPlayerDeath(PlayerDeathEventArgs e)
+    {
+      RemoveEffect(e.Mobile);
+    }
+
+    protected void VisualEffect(Mobile to)
+    {
+      to.PlaySound(0x658);
+
+      to.FixedParticles(0x3728, 1, 13, 0x26B8, 0x47E, 7, EffectLayer.Head, 0);
+      to.FixedParticles(0x3779, 1, 15, 0x251E, 0x43, 7, EffectLayer.Head, 0);
+    }
+
+    private class SpellPlagueContext
+    {
+      private int m_Explosions;
+      private DateTime m_LastExploded;
+      private SpellPlagueContext m_Next;
+      private SpellPlagueSpell m_Owner;
+      private Mobile m_Target;
+      private Timer m_Timer;
+
+      public SpellPlagueContext(SpellPlagueSpell owner, Mobile target)
+      {
+        m_Owner = owner;
+        m_Target = target;
+      }
+
+      public void SetNext(SpellPlagueContext context)
+      {
+        if (m_Next == null)
+          m_Next = context;
+        else
+          m_Next.SetNext(context);
+      }
+
+      public void Start()
+      {
+        m_Timer = Timer.DelayCall(TimeSpan.FromSeconds(8.0), EndPlague);
+        m_Timer.Start();
+
+        BuffInfo.AddBuff(m_Target,
+          new BuffInfo(BuffIcon.SpellPlague, 1031690, 1080167, TimeSpan.FromSeconds(8.5), m_Target));
+      }
+
+      public void OnDamage()
+      {
+        if (DateTime.Now > m_LastExploded + TimeSpan.FromSeconds(2.0))
+        {
+          int exploChance = 90 - m_Explosions * 30;
+
+          double resist = m_Target.Skills.MagicResist.Value;
+
+          if (resist >= 70)
+            exploChance -= (int)((resist - 70.0) * 3.0 / 10.0);
+
+          if (exploChance > Utility.Random(100))
+          {
+            m_Owner.VisualEffect(m_Target);
+
+            int damage = m_Owner.GetNewAosDamage(15 + m_Explosions * 3, 1, 5, m_Target);
+
+            m_Explosions++;
+            m_LastExploded = DateTime.Now;
+
+            SpellHelper.Damage(m_Owner, m_Target, damage, 0, 0, 0, 0, 0, 100);
+
+            if (m_Explosions >= 3)
+              EndPlague();
+          }
+        }
+      }
+
+      private void EndPlague()
+      {
+        EndPlague(true);
+      }
+
+      public void EndPlague(bool restart)
+      {
+        m_Timer?.Stop();
+
+        if (restart && m_Next != null)
+        {
+          m_Table[m_Target] = m_Next;
+          m_Next.Start();
+        }
+        else
+        {
+          m_Table.Remove(m_Target);
+
+          BuffInfo.RemoveBuff(m_Target, BuffIcon.SpellPlague);
+        }
+      }
+    }
+
+    private class InternalTarget : Target
+    {
+      private SpellPlagueSpell m_Owner;
+
+      public InternalTarget(SpellPlagueSpell owner)
+        : base(12, false, TargetFlags.Harmful)
+      {
+        m_Owner = owner;
+      }
+
+      protected override void OnTarget(Mobile from, object o)
+      {
+        if (o is Mobile mobile)
+          m_Owner.Target(mobile);
+      }
+
+      protected override void OnTargetFinish(Mobile from)
+      {
+        m_Owner.FinishSequence();
+      }
+    }
+  }
+}

Projects/Scripts/Spells/Mysticism/StoneFormSpell.cs

@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using Server.Factions;
+using Server.Mobiles;
+using Server.Spells.Fifth;
+using Server.Spells.Ninjitsu;
+using Server.Spells.Seventh;
+
+namespace Server.Spells.Mysticism
+{
+  public class StoneFormSpell : MysticSpell
+  {
+    private static SpellInfo m_Info = new SpellInfo(
+      "Stone Form", "In Rel Ylem",
+      -1,
+      9002,
+      Reagent.Bloodmoss,
+      Reagent.FertileDirt,
+      Reagent.Garlic
+    );
+
+    private static Dictionary<Mobile, ResistanceMod[]> m_Table = new Dictionary<Mobile, ResistanceMod[]>();
+
+    public StoneFormSpell(Mobile caster, Item scroll = null)
+      : base(caster, scroll, m_Info)
+    {
+    }
+
+    public override TimeSpan CastDelayBase => TimeSpan.FromSeconds(1.5);
+
+    public override double RequiredSkill => 33.0;
+    public override int RequiredMana => 11;
+
+    public static void Initialize()
+    {
+      EventSink.PlayerDeath += OnPlayerDeath;
+    }
+
+    public static bool UnderEffect(Mobile m)
+    {
+      return m_Table.ContainsKey(m);
+    }
+
+    public override bool CheckCast()
+    {
+      if (Sigil.ExistsOn(Caster))
+      {
+        Caster.SendLocalizedMessage(1061632); // You can't do that while carrying the sigil.
+        return false;
+      }
+
+      if (!Caster.CanBeginAction<PolymorphSpell>())
+      {
+        Caster.SendLocalizedMessage(1061628); // You can't do that while polymorphed.
+        return false;
+      }
+
+      if (AnimalForm.UnderTransformation(Caster))
+      {
+        Caster.SendLocalizedMessage(1063218); // You cannot use that ability in this form.
+        return false;
+      }
+
+      if (Caster.Flying)
+      {
+        Caster.SendLocalizedMessage(1113415); // You cannot use this ability while flying.
+        return false;
+      }
+
+      return base.CheckCast();
+    }
+
+    public override void OnCast()
+    {
+      if (Sigil.ExistsOn(Caster))
+      {
+        Caster.SendLocalizedMessage(1061632); // You can't do that while carrying the sigil.
+      }
+      else if (!Caster.CanBeginAction<PolymorphSpell>())
+      {
+        Caster.SendLocalizedMessage(1061628); // You can't do that while polymorphed.
+      }
+      else if (!Caster.CanBeginAction<IncognitoSpell>() || Caster.IsBodyMod && !UnderEffect(Caster))
+      {
+        Caster.SendLocalizedMessage(1063218); // You cannot use that ability in this form.
+      }
+      else if (CheckSequence())
+      {
+        if (UnderEffect(Caster))
+        {
+          RemoveEffects(Caster);
+
+          Caster.PlaySound(0xFA);
+          Caster.Delta(MobileDelta.Resistances);
+        }
+        else
+        {
+          IMount mount = Caster.Mount;
+
+          if (mount != null)
+            mount.Rider = null;
+
+          Caster.BodyMod = 0x2C1;
+          Caster.HueMod = 0;
+
+          int offset = (int)((GetBaseSkill(Caster) + GetBoostSkill(Caster)) / 24.0);
+
+          ResistanceMod[] mods = {
+            new ResistanceMod(ResistanceType.Physical, offset),
+            new ResistanceMod(ResistanceType.Fire, offset),
+            new ResistanceMod(ResistanceType.Cold, offset),
+            new ResistanceMod(ResistanceType.Poison, offset),
+            new ResistanceMod(ResistanceType.Energy, offset)
+          };
+
+          for (int i = 0; i < mods.Length; ++i)
+            Caster.AddResistanceMod(mods[i]);
+
+          m_Table[Caster] = mods;
+
+          Caster.PlaySound(0x65A);
+          Caster.Delta(MobileDelta.Resistances);
+
+          BuffInfo.AddBuff(Caster, new BuffInfo(BuffIcon.StoneForm, 1080145, 1080146,
+            $"-10\t-2\t{offset}\t{GetResistCapBonus(Caster)}\t{GetDIBonus(Caster)}", false));
+        }
+      }
+
+      FinishSequence();
+    }
+
+    public static int GetDIBonus(Mobile m)
+    {
+      return (int)((GetBaseSkill(m) + GetBoostSkill(m)) / 12.0);
+    }
+
+    public static int GetResistCapBonus(Mobile m)
+    {
+      return (int)((GetBaseSkill(m) + GetBoostSkill(m)) / 48.0);
+    }
+
+    public static void RemoveEffects(Mobile m)
+    {
+      if (!m_Table.TryGetValue(m, out ResistanceMod[] mods))
+        return;
+
+      for (int i = 0; i < mods.Length; ++i)
+        m.RemoveResistanceMod(mods[i]);
+
+      m.BodyMod = 0;
+      m.HueMod = -1;
+
+      m_Table.Remove(m);
+
+      BuffInfo.RemoveBuff(m, BuffIcon.StoneForm);
+    }
+
+    private static void OnPlayerDeath(PlayerDeathEventArgs e)
+    {
+      RemoveEffects(e.Mobile);
+    }
+  }
+}