Reorganizes Project (#41)

Projects/Scripts/Items/Skill Items/Camping/Bedroll.cs

@@ -0,0 +1,130 @@
+using System;
+using Server.Gumps;
+using Server.Mobiles;
+using Server.Network;
+
+namespace Server.Items
+{
+  [Flippable(0xA57, 0xA58, 0xA59)]
+  public class Bedroll : Item
+  {
+    [Constructible]
+    public Bedroll() : base(0xA57)
+    {
+      Weight = 5.0;
+    }
+
+    public Bedroll(Serial serial) : base(serial)
+    {
+    }
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (Parent != null || !VerifyMove(from))
+        return;
+
+      if (!from.InRange(this, 2))
+      {
+        from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1019045); // I can't reach that.
+        return;
+      }
+
+      if (ItemID == 0xA57) // rolled
+      {
+        Direction dir = PlayerMobile.GetDirection4(from.Location, Location);
+
+        if (dir == Direction.North || dir == Direction.South)
+          ItemID = 0xA55;
+        else
+          ItemID = 0xA56;
+      }
+      else // unrolled
+      {
+        ItemID = 0xA57;
+
+        if (!from.HasGump<LogoutGump>())
+        {
+          CampfireEntry entry = Campfire.GetEntry(from);
+
+          if (entry?.Safe == true)
+            from.SendGump(new LogoutGump(entry, this));
+        }
+      }
+    }
+
+    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();
+    }
+
+    private class LogoutGump : Gump
+    {
+      private Bedroll m_Bedroll;
+      private Timer m_CloseTimer;
+
+      private CampfireEntry m_Entry;
+
+      public LogoutGump(CampfireEntry entry, Bedroll bedroll) : base(100, 0)
+      {
+        m_Entry = entry;
+        m_Bedroll = bedroll;
+
+        m_CloseTimer = Timer.DelayCall(TimeSpan.FromSeconds(10.0), CloseGump);
+
+        AddBackground(0, 0, 400, 350, 0xA28);
+
+        AddHtmlLocalized(100, 20, 200, 35, 1011015); // <center>Logging out via camping</center>
+
+        /* Using a bedroll in the safety of a camp will log you out of the game safely.
+         * If this is what you wish to do choose CONTINUE and you will be logged out.
+         * Otherwise, select the CANCEL button to avoid logging out at this time.
+         * The camp will remain secure for 10 seconds at which time this window will close
+         * and you not be logged out.
+         */
+        AddHtmlLocalized(50, 55, 300, 140, 1011016, true, true);
+
+        AddButton(45, 298, 0xFA5, 0xFA7, 1);
+        AddHtmlLocalized(80, 300, 110, 35, 1011011); // CONTINUE
+
+        AddButton(200, 298, 0xFA5, 0xFA7, 0);
+        AddHtmlLocalized(235, 300, 110, 35, 1011012); // CANCEL
+      }
+
+      public override void OnResponse(NetState sender, RelayInfo info)
+      {
+        PlayerMobile pm = m_Entry.Player;
+
+        m_CloseTimer.Stop();
+
+        if (Campfire.GetEntry(pm) != m_Entry)
+          return;
+
+        if (info.ButtonID == 1 && m_Entry.Safe && m_Bedroll.Parent == null && m_Bedroll.IsAccessibleTo(pm)
+            && m_Bedroll.VerifyMove(pm) && m_Bedroll.Map == pm.Map && pm.InRange(m_Bedroll, 2))
+        {
+          pm.PlaceInBackpack(m_Bedroll);
+
+          pm.BedrollLogout = true;
+          sender.Dispose();
+        }
+
+        Campfire.RemoveEntry(m_Entry);
+      }
+
+      private void CloseGump()
+      {
+        Campfire.RemoveEntry(m_Entry);
+        m_Entry.Player.CloseGump<LogoutGump>();
+      }
+    }
+  }
+}

Projects/Scripts/Items/Skill Items/Camping/Campfire.cs

@@ -0,0 +1,199 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Server.Mobiles;
+using Server.Network;
+
+namespace Server.Items
+{
+  public enum CampfireStatus
+  {
+    Burning,
+    Extinguishing,
+    Off
+  }
+
+  public class Campfire : Item
+  {
+    public static readonly int SecureRange = 7;
+
+    private static readonly Dictionary<Mobile, CampfireEntry> m_Table = new Dictionary<Mobile, CampfireEntry>();
+
+    private List<CampfireEntry> m_Entries;
+
+    private Timer m_Timer;
+
+    public Campfire() : base(0xDE3)
+    {
+      Movable = false;
+      Light = LightType.Circle300;
+
+      m_Entries = new List<CampfireEntry>();
+
+      Created = DateTime.UtcNow;
+      m_Timer = Timer.DelayCall(TimeSpan.FromSeconds(1.0), TimeSpan.FromSeconds(1.0), OnTick);
+    }
+
+    public Campfire(Serial serial) : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public DateTime Created{ get; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public CampfireStatus Status
+    {
+      get
+      {
+        switch (ItemID)
+        {
+          case 0xDE3:
+            return CampfireStatus.Burning;
+
+          case 0xDE9:
+            return CampfireStatus.Extinguishing;
+
+          default:
+            return CampfireStatus.Off;
+        }
+      }
+      set
+      {
+        if (Status == value)
+          return;
+
+        switch (value)
+        {
+          case CampfireStatus.Burning:
+            ItemID = 0xDE3;
+            Light = LightType.Circle300;
+            break;
+
+          case CampfireStatus.Extinguishing:
+            ItemID = 0xDE9;
+            Light = LightType.Circle150;
+            break;
+
+          default:
+            ItemID = 0xDEA;
+            Light = LightType.ArchedWindowEast;
+            ClearEntries();
+            break;
+        }
+      }
+    }
+
+    public static CampfireEntry GetEntry(Mobile player)
+    {
+      m_Table.TryGetValue(player, out CampfireEntry value);
+      return value;
+    }
+
+    public static void RemoveEntry(CampfireEntry entry)
+    {
+      m_Table.Remove(entry.Player);
+      entry.Fire.m_Entries.Remove(entry);
+    }
+
+    private void OnTick()
+    {
+      DateTime now = DateTime.UtcNow;
+      TimeSpan age = now - Created;
+
+      if (age >= TimeSpan.FromSeconds(100.0))
+        Delete();
+      else if (age >= TimeSpan.FromSeconds(90.0))
+        Status = CampfireStatus.Off;
+      else if (age >= TimeSpan.FromSeconds(60.0))
+        Status = CampfireStatus.Extinguishing;
+
+      if (Status == CampfireStatus.Off || Deleted)
+        return;
+
+      foreach (CampfireEntry entry in m_Entries.ToList())
+        if (!entry.Valid || entry.Player.NetState == null)
+          RemoveEntry(entry);
+        else if (!entry.Safe && now - entry.Start >= TimeSpan.FromSeconds(30.0))
+        {
+          entry.Safe = true;
+          entry.Player.SendLocalizedMessage(500621); // The camp is now secure.
+        }
+
+      IPooledEnumerable<NetState> eable = GetClientsInRange(SecureRange);
+
+      foreach (NetState state in eable)
+        if (state.Mobile is PlayerMobile pm && GetEntry(pm) == null)
+        {
+          CampfireEntry entry = new CampfireEntry(pm, this);
+
+          m_Table[pm] = entry;
+          m_Entries.Add(entry);
+
+          pm.SendLocalizedMessage(500620); // You feel it would take a few moments to secure your camp.
+        }
+
+      eable.Free();
+    }
+
+    private void ClearEntries()
+    {
+      if (m_Entries == null)
+        return;
+
+      foreach (CampfireEntry entry in m_Entries.ToList())
+        RemoveEntry(entry);
+    }
+
+    public override void OnAfterDelete()
+    {
+      m_Timer?.Stop();
+
+      ClearEntries();
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      Delete();
+    }
+  }
+
+  public class CampfireEntry
+  {
+    private bool m_Safe;
+
+    public CampfireEntry(PlayerMobile player, Campfire fire)
+    {
+      Player = player;
+      Fire = fire;
+      Start = DateTime.UtcNow;
+      m_Safe = false;
+    }
+
+    public PlayerMobile Player{ get; }
+
+    public Campfire Fire{ get; }
+
+    public DateTime Start{ get; }
+
+    public bool Valid => !Fire.Deleted && Fire.Status != CampfireStatus.Off && Player.Map == Fire.Map &&
+                         Player.InRange(Fire, Campfire.SecureRange);
+
+    public bool Safe
+    {
+      get => Valid && m_Safe;
+      set => m_Safe = value;
+    }
+  }
+}

Projects/Scripts/Items/Skill Items/Camping/Kindling.cs

@@ -0,0 +1,112 @@
+using System.Collections.Generic;
+using Server.Network;
+using Server.Regions;
+
+namespace Server.Items
+{
+  public class Kindling : Item
+  {
+    [Constructible]
+    public Kindling(int amount = 1) : base(0xDE1)
+    {
+      Stackable = true;
+      Weight = 5.0;
+      Amount = amount;
+    }
+
+    public Kindling(Serial serial) : base(serial)
+    {
+    }
+
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+    }
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (!VerifyMove(from))
+        return;
+
+      if (!from.InRange(GetWorldLocation(), 2))
+      {
+        from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1019045); // I can't reach that.
+        return;
+      }
+
+      Point3D fireLocation = GetFireLocation(from);
+
+      if (fireLocation == Point3D.Zero)
+      {
+        from.SendLocalizedMessage(501695); // There is not a spot nearby to place your campfire.
+      }
+      else if (!from.CheckSkill(SkillName.Camping, 0.0, 100.0))
+      {
+        from.SendLocalizedMessage(501696); // You fail to ignite the campfire.
+      }
+      else
+      {
+        Consume();
+
+        if (!Deleted && Parent == null)
+          from.PlaceInBackpack(this);
+
+        new Campfire().MoveToWorld(fireLocation, from.Map);
+      }
+    }
+
+    private Point3D GetFireLocation(Mobile from)
+    {
+      if (from.Region.IsPartOf<DungeonRegion>())
+        return Point3D.Zero;
+
+      if (Parent == null)
+        return Location;
+
+      List<Point3D> list = new List<Point3D>(4);
+
+      AddOffsetLocation(from, 0, -1, list);
+      AddOffsetLocation(from, -1, 0, list);
+      AddOffsetLocation(from, 0, 1, list);
+      AddOffsetLocation(from, 1, 0, list);
+
+      if (list.Count == 0)
+        return Point3D.Zero;
+
+      int idx = Utility.Random(list.Count);
+      return list[idx];
+    }
+
+    private void AddOffsetLocation(Mobile from, int offsetX, int offsetY, List<Point3D> list)
+    {
+      Map map = from.Map;
+
+      int x = from.X + offsetX;
+      int y = from.Y + offsetY;
+
+      Point3D loc = new Point3D(x, y, from.Z);
+
+      if (map.CanFit(loc, 1) && from.InLOS(loc))
+      {
+        list.Add(loc);
+      }
+      else
+      {
+        loc = new Point3D(x, y, map.GetAverageZ(x, y));
+
+        if (map.CanFit(loc, 1) && from.InLOS(loc))
+          list.Add(loc);
+      }
+    }
+  }
+}