Reorganizes Project (#41)

Projects/Scripts/Items/Misc/Firebomb.cs

@@ -0,0 +1,286 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Server.Network;
+using Server.Spells;
+using Server.Targeting;
+
+namespace Server.Items
+{
+  public class Firebomb : Item
+  {
+    private Mobile m_LitBy;
+    private int m_Ticks;
+    private Timer m_Timer;
+    private List<Mobile> m_Users;
+
+    [Constructible]
+    public Firebomb(int itemID = 0x99B) : base(itemID)
+    {
+      //Name = "a firebomb";
+      Weight = 2.0;
+      Hue = 1260;
+    }
+
+    public Firebomb(Serial serial) : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.WriteEncodedInt(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadEncodedInt();
+    }
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (!IsChildOf(from.Backpack))
+      {
+        from.SendLocalizedMessage(1042001); // That must be in your pack for you to use it.
+        return;
+      }
+
+      if (Core.AOS && (from.Paralyzed || from.Frozen || from.Spell != null && from.Spell.IsCasting))
+      {
+        // to prevent exploiting for pvp
+        from.SendLocalizedMessage(1075857); // You cannot use that while paralyzed.
+        return;
+      }
+
+      if (m_Timer == null)
+      {
+        m_Timer = Timer.DelayCall(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1), OnFirebombTimerTick);
+        m_LitBy = from;
+        from.SendLocalizedMessage(1060582); // You light the firebomb.  Throw it now!
+      }
+      else
+      {
+        from.SendLocalizedMessage(1060581); // You've already lit it!  Better throw it now!
+      }
+
+      if (m_Users == null)
+        m_Users = new List<Mobile>();
+
+      if (!m_Users.Contains(from))
+        m_Users.Add(from);
+
+      from.Target = new ThrowTarget(this);
+    }
+
+    private void OnFirebombTimerTick()
+    {
+      if (Deleted)
+      {
+        m_Timer.Stop();
+        return;
+      }
+
+      if (Map == Map.Internal && HeldBy == null)
+        return;
+
+      switch (m_Ticks)
+      {
+        case 0:
+        case 1:
+        case 2:
+        {
+          ++m_Ticks;
+
+          if (HeldBy != null)
+            HeldBy.PublicOverheadMessage(MessageType.Regular, 957, false, m_Ticks.ToString());
+          else if (RootParent == null)
+            PublicOverheadMessage(MessageType.Regular, 957, false, m_Ticks.ToString());
+          else if (RootParent is Mobile mobile)
+            mobile.PublicOverheadMessage(MessageType.Regular, 957, false, m_Ticks.ToString());
+
+          break;
+        }
+        default:
+        {
+          HeldBy?.DropHolding();
+
+          if (m_Users != null)
+          {
+            foreach (Mobile m in m_Users)
+              if (m.Target is ThrowTarget targ && targ.Bomb == this)
+                Target.Cancel(m);
+
+            m_Users.Clear();
+            m_Users = null;
+          }
+
+          if (RootParent is Mobile parent)
+          {
+            parent.SendLocalizedMessage(1060583); // The firebomb explodes in your hand!
+            AOS.Damage(parent, Utility.Random(3) + 4, 0, 100, 0, 0, 0);
+          }
+          else if (RootParent == null)
+          {
+            IPooledEnumerable<Mobile> eable = Map.GetMobilesInRange(Location, 1);
+            List<Mobile> toDamage = eable.ToList();
+
+            eable.Free();
+
+            for (int i = 0; i < toDamage.Count; ++i)
+            {
+              Mobile victim = toDamage[i];
+
+              if (m_LitBy == null || SpellHelper.ValidIndirectTarget(m_LitBy, victim) &&
+                  m_LitBy.CanBeHarmful(victim, false))
+              {
+                m_LitBy?.DoHarmful(victim);
+
+                AOS.Damage(victim, m_LitBy, Utility.Random(3) + 4, 0, 100, 0, 0, 0);
+              }
+            }
+
+            new FirebombField(m_LitBy, toDamage).MoveToWorld(Location, Map);
+          }
+
+          m_Timer.Stop();
+          Delete();
+          break;
+        }
+      }
+    }
+
+    private void OnFirebombTarget(Mobile from, object obj)
+    {
+      if (Deleted || Map == Map.Internal || !IsChildOf(from.Backpack))
+        return;
+
+      if (!(obj is IPoint3D p))
+        return;
+
+      SpellHelper.GetSurfaceTop(ref p);
+
+      from.RevealingAction();
+
+      IEntity to = p as IEntity ?? new Entity(Serial.Zero, new Point3D(p), Map);
+
+      Effects.SendMovingEffect(from, to, ItemID, 7, 0, false, false, Hue);
+
+      Timer.DelayCall(TimeSpan.FromSeconds(1.0), () => FirebombReposition_OnTick(p, Map));
+      Internalize();
+    }
+
+    private void FirebombReposition_OnTick(IPoint3D p, Map map)
+    {
+      if (Deleted)
+        return;
+
+      MoveToWorld(new Point3D(p), map);
+    }
+
+    private class ThrowTarget : Target
+    {
+      public ThrowTarget(Firebomb bomb)
+        : base(12, true, TargetFlags.None)
+      {
+        Bomb = bomb;
+      }
+
+      public Firebomb Bomb{ get; }
+
+      protected override void OnTarget(Mobile from, object targeted)
+      {
+        Bomb.OnFirebombTarget(from, targeted);
+      }
+    }
+  }
+
+  public class FirebombField : Item
+  {
+    private List<Mobile> m_Burning;
+    private DateTime m_Expire;
+    private Mobile m_LitBy;
+    private Timer m_Timer;
+
+    public FirebombField(Mobile litBy, List<Mobile> toDamage) : base(0x376A)
+    {
+      Movable = false;
+      m_LitBy = litBy;
+      m_Expire = DateTime.UtcNow + TimeSpan.FromSeconds(10);
+      m_Burning = toDamage;
+      m_Timer = Timer.DelayCall(TimeSpan.FromSeconds(1.0), TimeSpan.FromSeconds(1.0), OnFirebombFieldTimerTick);
+    }
+
+    public FirebombField(Serial serial) : base(serial)
+    {
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      // Don't serialize these...
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+    }
+
+    public override bool OnMoveOver(Mobile m)
+    {
+      if (ItemID == 0x398C && m_LitBy == null ||
+          SpellHelper.ValidIndirectTarget(m_LitBy, m) && m_LitBy.CanBeHarmful(m, false))
+      {
+        m_LitBy?.DoHarmful(m);
+
+        AOS.Damage(m, m_LitBy, 2, 0, 100, 0, 0, 0);
+        m.PlaySound(0x208);
+
+        if (!m_Burning.Contains(m))
+          m_Burning.Add(m);
+      }
+
+      return true;
+    }
+
+    private void OnFirebombFieldTimerTick()
+    {
+      if (Deleted)
+      {
+        m_Timer.Stop();
+        return;
+      }
+
+      if (ItemID == 0x376A)
+      {
+        ItemID = 0x398C;
+        return;
+      }
+
+      for (int i = 0; i < m_Burning.Count;)
+      {
+        Mobile victim = m_Burning[i];
+
+        if (victim.Location == Location && victim.Map == Map &&
+            (m_LitBy == null || SpellHelper.ValidIndirectTarget(m_LitBy, victim) &&
+             m_LitBy.CanBeHarmful(victim, false)))
+        {
+          m_LitBy?.DoHarmful(victim);
+
+          AOS.Damage(victim, m_LitBy, Utility.Random(3) + 4, 0, 100, 0, 0, 0);
+          ++i;
+        }
+        else
+        {
+          m_Burning.RemoveAt(i);
+        }
+      }
+
+      if (DateTime.UtcNow >= m_Expire)
+      {
+        m_Timer.Stop();
+        Delete();
+      }
+    }
+  }
+}