Reorganizes Project (#41)

Projects/Scripts/Engines/Factions/Items/Sigil.cs

@@ -0,0 +1,456 @@
+using System;
+using System.Collections.Generic;
+using Server.Items;
+using Server.Mobiles;
+using Server.Network;
+using Server.Targeting;
+
+namespace Server.Factions
+{
+  public class Sigil : BaseSystemController
+  {
+    public const int OwnershipHue = 0xB;
+
+    // ?? time corrupting faction has to return the sigil before corruption time resets ?
+    public static readonly TimeSpan CorruptionGrace = TimeSpan.FromMinutes(Core.SE ? 30.0 : 15.0);
+
+    // Sigil must be held at a stronghold for this amount of time in order to become corrupted
+    public static readonly TimeSpan CorruptionPeriod = Core.SE ? TimeSpan.FromHours(10.0) : TimeSpan.FromHours(24.0);
+
+    // After a sigil has been corrupted it must be returned to the town within this period of time
+    public static readonly TimeSpan ReturnPeriod = TimeSpan.FromHours(1.0);
+
+    // Once it's been returned the corrupting faction owns the town for this period of time
+    public static readonly TimeSpan PurificationPeriod = TimeSpan.FromDays(3.0);
+    private Faction m_Corrupted;
+    private Faction m_Corrupting;
+
+    private Town m_Town;
+
+    public Sigil(Town town) : base(0x1869)
+    {
+      Movable = false;
+      Town = town;
+
+      Sigils.Add(this);
+    }
+
+    public Sigil(Serial serial) : base(serial)
+    {
+      Sigils.Add(this);
+    }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.Administrator)]
+    public DateTime LastStolen{ get; set; }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.Administrator)]
+    public DateTime GraceStart{ get; set; }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.Administrator)]
+    public DateTime CorruptionStart{ get; set; }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.Administrator)]
+    public DateTime PurificationStart{ get; set; }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.Administrator)]
+    public Town Town
+    {
+      get => m_Town;
+      set
+      {
+        m_Town = value;
+        Update();
+      }
+    }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.Administrator)]
+    public Faction Corrupted
+    {
+      get => m_Corrupted;
+      set
+      {
+        m_Corrupted = value;
+        Update();
+      }
+    }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.Administrator)]
+    public Faction Corrupting
+    {
+      get => m_Corrupting;
+      set
+      {
+        m_Corrupting = value;
+        Update();
+      }
+    }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.Administrator)]
+    public BaseMonolith LastMonolith{ get; set; }
+
+    [CommandProperty(AccessLevel.Counselor)]
+    public bool IsBeingCorrupted => LastMonolith is StrongholdMonolith && LastMonolith.Faction == m_Corrupting &&
+                                    m_Corrupting != null;
+
+    [CommandProperty(AccessLevel.Counselor)]
+    public bool IsCorrupted => m_Corrupted != null;
+
+    [CommandProperty(AccessLevel.Counselor)]
+    public bool IsPurifying => PurificationStart != DateTime.MinValue;
+
+    [CommandProperty(AccessLevel.Counselor)]
+    public bool IsCorrupting => m_Corrupting != null && m_Corrupting != m_Corrupted;
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public TimeSpan TimeUntilCorruption
+    {
+      get
+      {
+        if (!IsBeingCorrupted)
+          return TimeSpan.Zero;
+
+        TimeSpan ts = CorruptionStart + CorruptionPeriod - DateTime.UtcNow;
+
+        if (ts < TimeSpan.Zero)
+          ts = TimeSpan.Zero;
+
+        return ts;
+      }
+    }
+
+    public static List<Sigil> Sigils{ get; } = new List<Sigil>();
+
+    public void Update()
+    {
+      ItemID = m_Town?.Definition.SigilID ?? 0x1869;
+
+      if (m_Town == null)
+        AssignName(null);
+      else if (IsCorrupted || IsPurifying)
+        AssignName(m_Town.Definition.CorruptedSigilName);
+      else
+        AssignName(m_Town.Definition.SigilName);
+
+      InvalidateProperties();
+    }
+
+    public override void GetProperties(ObjectPropertyList list)
+    {
+      base.GetProperties(list);
+
+      if (IsCorrupted)
+        TextDefinition.AddTo(list, m_Corrupted.Definition.SigilControl);
+      else
+        list.Add(1042256); // This sigil is not corrupted.
+
+      if (IsCorrupting)
+        list.Add(1042257); // This sigil is in the process of being corrupted.
+      else if (IsPurifying)
+        list.Add(1042258); // This sigil has recently been corrupted, and is undergoing purification.
+      else
+        list.Add(1042259); // This sigil is not in the process of being corrupted.
+    }
+
+    public override void OnSingleClick(Mobile from)
+    {
+      base.OnSingleClick(from);
+
+      if (IsCorrupted)
+      {
+        if (m_Corrupted.Definition.SigilControl.Number > 0)
+          LabelTo(from, m_Corrupted.Definition.SigilControl.Number);
+        else if (m_Corrupted.Definition.SigilControl.String != null)
+          LabelTo(from, m_Corrupted.Definition.SigilControl.String);
+      }
+      else
+      {
+        LabelTo(from, 1042256); // This sigil is not corrupted.
+      }
+
+      if (IsCorrupting)
+        LabelTo(from, 1042257); // This sigil is in the process of being corrupted.
+      else if (IsPurifying)
+        LabelTo(from, 1042258); // This sigil has been recently corrupted, and is undergoing purification.
+      else
+        LabelTo(from, 1042259); // This sigil is not in the process of being corrupted.
+    }
+
+    public override bool CheckLift(Mobile from, Item item, ref LRReason reject)
+    {
+      from.SendLocalizedMessage(1005225); // You must use the stealing skill to pick up the sigil
+      return false;
+    }
+
+    private Mobile FindOwner(IEntity parent)
+    {
+      if (parent is Item item)
+        return item.RootParent as Mobile;
+
+      if (parent is Mobile mobile)
+        return mobile;
+
+      return null;
+    }
+
+    public override void OnAdded(IEntity parent)
+    {
+      base.OnAdded(parent);
+
+      Mobile mob = FindOwner(parent);
+
+      if (mob != null)
+        mob.SolidHueOverride = OwnershipHue;
+    }
+
+    public override void OnRemoved(IEntity parent)
+    {
+      base.OnRemoved(parent);
+
+      Mobile mob = FindOwner(parent);
+
+      if (mob != null)
+        mob.SolidHueOverride = -1;
+    }
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (IsChildOf(from.Backpack))
+      {
+        from.BeginTarget(1, false, TargetFlags.None, Sigil_OnTarget);
+        from.SendLocalizedMessage(1042251); // Click on a sigil monolith or player
+      }
+    }
+
+    public static bool ExistsOn(Mobile mob)
+    {
+      return mob.Backpack?.FindItemByType<Sigil>() != null;
+    }
+
+    private void BeginCorrupting(Faction faction)
+    {
+      m_Corrupting = faction;
+      CorruptionStart = DateTime.UtcNow;
+    }
+
+    private void ClearCorrupting()
+    {
+      m_Corrupting = null;
+      CorruptionStart = DateTime.MinValue;
+    }
+
+    private void Sigil_OnTarget(Mobile from, object obj)
+    {
+      if (Deleted || !IsChildOf(from.Backpack))
+        return;
+
+      #region Give To Mobile
+
+      if (obj is Mobile)
+      {
+        if (obj is PlayerMobile targ)
+        {
+          Faction toFaction = Faction.Find(targ);
+          Faction fromFaction = Faction.Find(from);
+
+          if (toFaction == null)
+          {
+            from.SendLocalizedMessage(1005223); // You cannot give the sigil to someone not in a faction
+          }
+          else if (fromFaction != toFaction)
+          {
+            from.SendLocalizedMessage(1005222); // You cannot give the sigil to someone not in your faction
+          }
+          else if (ExistsOn(targ))
+          {
+            from.SendLocalizedMessage(1005220); // You cannot give this sigil to someone who already has a sigil
+          }
+          else if (!targ.Alive)
+          {
+            from.SendLocalizedMessage(1042248); // You cannot give a sigil to a dead person.
+          }
+          else if (from.NetState != null && targ.NetState != null)
+          {
+            Container pack = targ.Backpack;
+
+            pack?.DropItem(this);
+          }
+        }
+        else
+        {
+          from.SendLocalizedMessage(1005221); //You cannot give the sigil to them
+        }
+      }
+
+      #endregion
+
+      else if (obj is BaseMonolith)
+      {
+        #region Put in Stronghold
+
+        if (obj is StrongholdMonolith sm)
+        {
+          if (sm.Faction == null || sm.Faction != Faction.Find(from))
+          {
+            from.SendLocalizedMessage(1042246); // You can't place that on an enemy monolith
+          }
+          else if (sm.Town == null || sm.Town != m_Town)
+          {
+            from.SendLocalizedMessage(1042247); // That is not the correct faction monolith
+          }
+          else
+          {
+            sm.Sigil = this;
+
+            Faction newController = sm.Faction;
+            Faction oldController = m_Corrupting;
+
+            if (oldController == null)
+            {
+              if (m_Corrupted != newController)
+                BeginCorrupting(newController);
+            }
+            else if (GraceStart > DateTime.MinValue && GraceStart + CorruptionGrace < DateTime.UtcNow)
+            {
+              if (m_Corrupted != newController)
+                BeginCorrupting(newController); // grace time over, reset period
+              else
+                ClearCorrupting();
+
+              GraceStart = DateTime.MinValue;
+            }
+            else if (newController == oldController)
+            {
+              GraceStart = DateTime.MinValue; // returned within grace period
+            }
+            else if (GraceStart == DateTime.MinValue)
+            {
+              GraceStart = DateTime.UtcNow;
+            }
+
+            PurificationStart = DateTime.MinValue;
+          }
+        }
+
+        #endregion
+
+        #region Put in Town
+
+        else if (obj is TownMonolith tm)
+        {
+          if (tm.Town == null || tm.Town != m_Town)
+          {
+            from.SendLocalizedMessage(1042245); // This is not the correct town sigil monolith
+          }
+          else if (m_Corrupted == null || m_Corrupted != Faction.Find(from))
+          {
+            from.SendLocalizedMessage(
+              1042244); // Your faction did not corrupt this sigil.  Take it to your stronghold.
+          }
+          else
+          {
+            tm.Sigil = this;
+
+            m_Corrupting = null;
+            PurificationStart = DateTime.UtcNow;
+            CorruptionStart = DateTime.MinValue;
+
+            m_Town.Capture(m_Corrupted);
+            m_Corrupted = null;
+          }
+        }
+
+        #endregion
+      }
+      else
+      {
+        from.SendLocalizedMessage(1005224); //	You can't use the sigil on that
+      }
+
+      Update();
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+
+      Town.WriteReference(writer, m_Town);
+      Faction.WriteReference(writer, m_Corrupted);
+      Faction.WriteReference(writer, m_Corrupting);
+
+      writer.Write(LastMonolith);
+
+      writer.Write(LastStolen);
+      writer.Write(GraceStart);
+      writer.Write(CorruptionStart);
+      writer.Write(PurificationStart);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 0:
+        {
+          m_Town = Town.ReadReference(reader);
+          m_Corrupted = Faction.ReadReference(reader);
+          m_Corrupting = Faction.ReadReference(reader);
+
+          LastMonolith = reader.ReadItem() as BaseMonolith;
+
+          LastStolen = reader.ReadDateTime();
+          GraceStart = reader.ReadDateTime();
+          CorruptionStart = reader.ReadDateTime();
+          PurificationStart = reader.ReadDateTime();
+
+          Update();
+
+          if (RootParent is Mobile mob)
+            mob.SolidHueOverride = OwnershipHue;
+
+          break;
+        }
+      }
+    }
+
+    public bool ReturnHome()
+    {
+      BaseMonolith monolith = LastMonolith;
+
+      if (monolith == null && m_Town != null)
+        monolith = m_Town.Monolith;
+
+      if (monolith?.Deleted == false)
+        monolith.Sigil = this;
+
+      return monolith?.Deleted == false;
+    }
+
+    public override void OnParentDeleted(IEntity parent)
+    {
+      base.OnParentDeleted(parent);
+
+      ReturnHome();
+    }
+
+    public override void OnAfterDelete()
+    {
+      base.OnAfterDelete();
+
+      Sigils.Remove(this);
+    }
+
+    public override void Delete()
+    {
+      if (ReturnHome())
+        return;
+
+      base.Delete();
+    }
+  }
+}