Reorganizes Project (#41)

Projects/Scripts/Items/Skill Items/Magical/Misc/BlankScroll.cs

@@ -0,0 +1,34 @@
+namespace Server.Items
+{
+  public class BlankScroll : Item, ICommodity
+  {
+    [Constructible]
+    public BlankScroll(int amount = 1) : base(0xEF3)
+    {
+      Stackable = true;
+      Weight = 1.0;
+      Amount = amount;
+    }
+
+    public BlankScroll(Serial serial) : base(serial)
+    {
+    }
+
+    int ICommodity.DescriptionNumber => LabelNumber;
+    bool ICommodity.IsDeedable => Core.ML;
+
+    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();
+    }
+  }
+}

Projects/Scripts/Items/Skill Items/Magical/Misc/Bottle.cs

@@ -0,0 +1,35 @@
+namespace Server.Items
+{
+  public class Bottle : Item, ICommodity
+  {
+    [Constructible]
+    public Bottle(int amount = 1) : base(0xF0E)
+    {
+      Stackable = true;
+      Weight = 1.0;
+      Amount = amount;
+    }
+
+    public Bottle(Serial serial) : base(serial)
+    {
+    }
+
+    int ICommodity.DescriptionNumber => LabelNumber;
+    bool ICommodity.IsDeedable => Core.ML;
+
+
+    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();
+    }
+  }
+}

Projects/Scripts/Items/Skill Items/Magical/Misc/Moongate.cs

@@ -0,0 +1,393 @@
+using System;
+using Server.Factions;
+using Server.Gumps;
+using Server.Misc;
+using Server.Mobiles;
+using Server.Network;
+using Server.Regions;
+
+namespace Server.Items
+{
+  [DispellableField]
+  public class Moongate : Item
+  {
+
+    [Constructible]
+    public Moongate(bool dispellable = true) :
+      this(Point3D.Zero, null, dispellable)
+    {
+    }
+
+    [Constructible]
+    public Moongate(Point3D target, Map targetMap = null, bool dispellable = true) : base(0xF6C)
+    {
+      Movable = false;
+      Light = LightType.Circle300;
+
+      Target = target;
+      TargetMap = targetMap;
+      Dispellable = dispellable;
+    }
+
+    public Moongate(Serial serial) : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public Point3D Target{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public Map TargetMap{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public bool Dispellable{ get; set; }
+
+    public virtual bool ShowFeluccaWarning => false;
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (!from.Player)
+        return;
+
+      if (from.InRange(GetWorldLocation(), 1))
+        CheckGate(from, 1);
+      else
+        from.SendLocalizedMessage(500446); // That is too far away.
+    }
+
+    public override bool OnMoveOver(Mobile m)
+    {
+      if (m.Player)
+        CheckGate(m, 0);
+
+      return true;
+    }
+
+    public virtual void CheckGate(Mobile m, int range)
+    {
+      #region Mondain's Legacy
+
+      if (m.Hidden && m.AccessLevel == AccessLevel.Player && Core.ML)
+        m.RevealingAction();
+
+      #endregion
+
+      new DelayTimer(m, this, range).Start();
+    }
+
+    public virtual void OnGateUsed(Mobile m)
+    {
+    }
+
+    public virtual void UseGate(Mobile m)
+    {
+      ClientFlags flags = m.NetState?.Flags ?? ClientFlags.None;
+
+      if (Sigil.ExistsOn(m))
+      {
+        m.SendLocalizedMessage(1061632); // You can't do that while carrying the sigil.
+      }
+      else if (TargetMap == Map.Felucca && m is PlayerMobile mobile && mobile.Young)
+      {
+        mobile.SendLocalizedMessage(1049543); // You decide against traveling to Felucca while you are still young.
+      }
+      else if (m.Kills >= 5 && TargetMap != Map.Felucca ||
+               TargetMap == Map.Tokuno && (flags & ClientFlags.Tokuno) == 0 ||
+               TargetMap == Map.Malas && (flags & ClientFlags.Malas) == 0 ||
+               TargetMap == Map.Ilshenar && (flags & ClientFlags.Ilshenar) == 0)
+      {
+        m.SendLocalizedMessage(1019004); // You are not allowed to travel there.
+      }
+      else if (m.Spell != null)
+      {
+        m.SendLocalizedMessage(1049616); // You are too busy to do that at the moment.
+      }
+      else if (TargetMap != null && TargetMap != Map.Internal)
+      {
+        BaseCreature.TeleportPets(m, Target, TargetMap);
+
+        m.MoveToWorld(Target, TargetMap);
+
+        if (m.AccessLevel == AccessLevel.Player || !m.Hidden)
+          m.PlaySound(0x1FE);
+
+        OnGateUsed(m);
+      }
+      else
+      {
+        m.SendMessage("This moongate does not seem to go anywhere.");
+      }
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(1); // version
+
+      writer.Write(Target);
+      writer.Write(TargetMap);
+
+      // Version 1
+      writer.Write(Dispellable);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      Target = reader.ReadPoint3D();
+      TargetMap = reader.ReadMap();
+
+      if (version >= 1)
+        Dispellable = reader.ReadBool();
+    }
+
+    public virtual bool ValidateUse(Mobile from, bool message)
+    {
+      if (from.Deleted || Deleted)
+        return false;
+
+      if (from.Map != Map || !from.InRange(this, 1))
+      {
+        if (message)
+          from.SendLocalizedMessage(500446); // That is too far away.
+
+        return false;
+      }
+
+      return true;
+    }
+
+    public virtual void BeginConfirmation(Mobile from)
+    {
+      if (IsInTown(from.Location, from.Map) && !IsInTown(Target, TargetMap) ||
+          from.Map != Map.Felucca && TargetMap == Map.Felucca && ShowFeluccaWarning)
+      {
+        if (from.AccessLevel == AccessLevel.Player || !from.Hidden)
+          from.Send(new PlaySound(0x20E, from.Location));
+        from.CloseGump<MoongateConfirmGump>();
+        from.SendGump(new MoongateConfirmGump(from, this));
+      }
+      else
+      {
+        EndConfirmation(from);
+      }
+    }
+
+    public virtual void EndConfirmation(Mobile from)
+    {
+      if (!ValidateUse(from, true))
+        return;
+
+      UseGate(from);
+    }
+
+    public virtual void DelayCallback(Mobile from, int range)
+    {
+      if (!ValidateUse(from, false) || !from.InRange(this, range))
+        return;
+
+      if (TargetMap != null)
+        BeginConfirmation(from);
+      else
+        from.SendMessage("This moongate does not seem to go anywhere.");
+    }
+
+    public static bool IsInTown(Point3D p, Map map)
+    {
+      return map != null && Region.Find(p, map).GetRegion<GuardedRegion>()?.IsDisabled() == false;
+    }
+
+    private class DelayTimer : Timer
+    {
+      private Mobile m_From;
+      private Moongate m_Gate;
+      private int m_Range;
+
+      public DelayTimer(Mobile from, Moongate gate, int range) : base(TimeSpan.FromSeconds(1.0))
+      {
+        m_From = from;
+        m_Gate = gate;
+        m_Range = range;
+      }
+
+      protected override void OnTick()
+      {
+        m_Gate.DelayCallback(m_From, m_Range);
+      }
+    }
+  }
+
+  public class ConfirmationMoongate : Moongate
+  {
+    [Constructible]
+    public ConfirmationMoongate() : this(Point3D.Zero)
+    {
+    }
+
+    [Constructible]
+    public ConfirmationMoongate(Point3D target, Map targetMap = null) : base(target, targetMap)
+    {
+    }
+
+    public ConfirmationMoongate(Serial serial) : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public int GumpWidth{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public int GumpHeight{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public int TitleColor{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public int MessageColor{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public int TitleNumber{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public int MessageNumber{ get; set; }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public string MessageString{ get; set; }
+
+    public virtual void Warning_Callback(Mobile from, bool okay)
+    {
+      if (okay)
+        EndConfirmation(from);
+    }
+
+    public override void BeginConfirmation(Mobile from)
+    {
+      if (GumpWidth > 0 && GumpHeight > 0 && TitleNumber > 0 && (MessageNumber > 0 || MessageString != null))
+      {
+        from.CloseGump<WarningGump>();
+        from.SendGump(new WarningGump(TitleNumber, TitleColor,
+          MessageString == null ? MessageNumber : (object)MessageString, MessageColor, GumpWidth, GumpHeight,
+          okay => Warning_Callback(from, okay)));
+      }
+      else
+      {
+        base.BeginConfirmation(from);
+      }
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(0); // version
+
+      writer.WriteEncodedInt(GumpWidth);
+      writer.WriteEncodedInt(GumpHeight);
+
+      writer.WriteEncodedInt(TitleColor);
+      writer.WriteEncodedInt(MessageColor);
+
+      writer.WriteEncodedInt(TitleNumber);
+      writer.WriteEncodedInt(MessageNumber);
+
+      writer.Write(MessageString);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 0:
+        {
+          GumpWidth = reader.ReadEncodedInt();
+          GumpHeight = reader.ReadEncodedInt();
+
+          TitleColor = reader.ReadEncodedInt();
+          MessageColor = reader.ReadEncodedInt();
+
+          TitleNumber = reader.ReadEncodedInt();
+          MessageNumber = reader.ReadEncodedInt();
+
+          MessageString = reader.ReadString();
+
+          break;
+        }
+      }
+    }
+  }
+
+  public class MoongateConfirmGump : Gump
+  {
+    private Mobile m_From;
+    private Moongate m_Gate;
+
+    public MoongateConfirmGump(Mobile from, Moongate gate) : base(Core.AOS ? 110 : 20, Core.AOS ? 100 : 30)
+    {
+      m_From = from;
+      m_Gate = gate;
+
+      if (Core.AOS)
+      {
+        Closable = false;
+
+        AddPage(0);
+
+        AddBackground(0, 0, 420, 280, 5054);
+
+        AddImageTiled(10, 10, 400, 20, 2624);
+        AddAlphaRegion(10, 10, 400, 20);
+
+        AddHtmlLocalized(10, 10, 400, 20, 1062051, 30720); // Gate Warning
+
+        AddImageTiled(10, 40, 400, 200, 2624);
+        AddAlphaRegion(10, 40, 400, 200);
+
+        if (from.Map != Map.Felucca && gate.TargetMap == Map.Felucca && gate.ShowFeluccaWarning)
+          AddHtmlLocalized(10, 40, 400, 200, 1062050, 32512, false,
+            true); // This Gate goes to Felucca... Continue to enter the gate, Cancel to stay here
+        else
+          AddHtmlLocalized(10, 40, 400, 200, 1062049, 32512, false,
+            true); // Dost thou wish to step into the moongate? Continue to enter the gate, Cancel to stay here
+
+        AddImageTiled(10, 250, 400, 20, 2624);
+        AddAlphaRegion(10, 250, 400, 20);
+
+        AddButton(10, 250, 4005, 4007, 1);
+        AddHtmlLocalized(40, 250, 170, 20, 1011036, 32767); // OKAY
+
+        AddButton(210, 250, 4005, 4007, 0);
+        AddHtmlLocalized(240, 250, 170, 20, 1011012, 32767); // CANCEL
+      }
+      else
+      {
+        AddPage(0);
+
+        AddBackground(0, 0, 420, 400, 5054);
+        AddBackground(10, 10, 400, 380, 3000);
+
+        AddHtml(20, 40, 380, 60,
+          @"Dost thou wish to step into the moongate? Continue to enter the gate, Cancel to stay here");
+
+        AddHtmlLocalized(55, 110, 290, 20, 1011012); // CANCEL
+        AddButton(20, 110, 4005, 4007, 0);
+
+        AddHtmlLocalized(55, 140, 290, 40, 1011011); // CONTINUE
+        AddButton(20, 140, 4005, 4007, 1);
+      }
+    }
+
+    public override void OnResponse(NetState state, RelayInfo info)
+    {
+      if (info.ButtonID == 1)
+        m_Gate.EndConfirmation(m_From);
+    }
+  }
+}

Projects/Scripts/Items/Skill Items/Magical/Misc/PotionKeg.cs

@@ -0,0 +1,342 @@
+using System;
+using Server.Network;
+
+namespace Server.Items
+{
+  public class PotionKeg : Item
+  {
+    private int m_Held;
+    private PotionEffect m_Type;
+
+    [Constructible]
+    public PotionKeg() : base(0x1940)
+    {
+      UpdateWeight();
+    }
+
+    public PotionKeg(Serial serial) : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public int Held
+    {
+      get => m_Held;
+      set
+      {
+        if (m_Held != value)
+        {
+          m_Held = value;
+          UpdateWeight();
+          InvalidateProperties();
+        }
+      }
+    }
+
+    [CommandProperty(AccessLevel.GameMaster)]
+    public PotionEffect Type
+    {
+      get => m_Type;
+      set
+      {
+        m_Type = value;
+        InvalidateProperties();
+      }
+    }
+
+    public override int LabelNumber
+    {
+      get
+      {
+        if (m_Held > 0 && (int)m_Type >= (int)PotionEffect.Conflagration)
+          return 1072658 + (int)m_Type - (int)PotionEffect.Conflagration;
+
+        return m_Held > 0 ? 1041620 + (int)m_Type : 1041641;
+      }
+    }
+
+    public virtual void UpdateWeight()
+    {
+      int held = Math.Max(0, Math.Min(m_Held, 100));
+
+      Weight = 20 + held * 80 / 100;
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      writer.Write(1); // version
+
+      writer.Write((int)m_Type);
+      writer.Write(m_Held);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 1:
+        case 0:
+        {
+          m_Type = (PotionEffect)reader.ReadInt();
+          m_Held = reader.ReadInt();
+
+          break;
+        }
+      }
+
+      if (version < 1)
+        Timer.DelayCall(TimeSpan.Zero, UpdateWeight);
+    }
+
+    public override void GetProperties(ObjectPropertyList list)
+    {
+      base.GetProperties(list);
+
+      int number;
+
+      if (m_Held <= 0)
+        number = 502246; // The keg is empty.
+      else if (m_Held < 5)
+        number = 502248; // The keg is nearly empty.
+      else if (m_Held < 20)
+        number = 502249; // The keg is not very full.
+      else if (m_Held < 30)
+        number = 502250; // The keg is about one quarter full.
+      else if (m_Held < 40)
+        number = 502251; // The keg is about one third full.
+      else if (m_Held < 47)
+        number = 502252; // The keg is almost half full.
+      else if (m_Held < 54)
+        number = 502254; // The keg is approximately half full.
+      else if (m_Held < 70)
+        number = 502253; // The keg is more than half full.
+      else if (m_Held < 80)
+        number = 502255; // The keg is about three quarters full.
+      else if (m_Held < 96)
+        number = 502256; // The keg is very full.
+      else if (m_Held < 100)
+        number = 502257; // The liquid is almost to the top of the keg.
+      else
+        number = 502258; // The keg is completely full.
+
+      list.Add(number);
+    }
+
+    public override void OnSingleClick(Mobile from)
+    {
+      base.OnSingleClick(from);
+
+      int number;
+
+      if (m_Held <= 0)
+        number = 502246; // The keg is empty.
+      else if (m_Held < 5)
+        number = 502248; // The keg is nearly empty.
+      else if (m_Held < 20)
+        number = 502249; // The keg is not very full.
+      else if (m_Held < 30)
+        number = 502250; // The keg is about one quarter full.
+      else if (m_Held < 40)
+        number = 502251; // The keg is about one third full.
+      else if (m_Held < 47)
+        number = 502252; // The keg is almost half full.
+      else if (m_Held < 54)
+        number = 502254; // The keg is approximately half full.
+      else if (m_Held < 70)
+        number = 502253; // The keg is more than half full.
+      else if (m_Held < 80)
+        number = 502255; // The keg is about three quarters full.
+      else if (m_Held < 96)
+        number = 502256; // The keg is very full.
+      else if (m_Held < 100)
+        number = 502257; // The liquid is almost to the top of the keg.
+      else
+        number = 502258; // The keg is completely full.
+
+      LabelTo(from, number);
+    }
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      if (from.InRange(GetWorldLocation(), 2))
+      {
+        if (m_Held > 0)
+        {
+          Container pack = from.Backpack;
+
+          if (pack?.ConsumeTotal(typeof(Bottle)) == true)
+          {
+            from.SendLocalizedMessage(502242); // You pour some of the keg's contents into an empty bottle...
+
+            BasePotion pot = FillBottle();
+
+            if (pack.TryDropItem(from, pot, false))
+            {
+              from.SendLocalizedMessage(502243); // ...and place it into your backpack.
+              from.PlaySound(0x240);
+
+              if (--Held == 0)
+                from.SendLocalizedMessage(502245); // The keg is now empty.
+            }
+            else
+            {
+              from.SendLocalizedMessage(502244); // ...but there is no room for the bottle in your backpack.
+              pot.Delete();
+            }
+          }
+        }
+        else
+        {
+          from.SendLocalizedMessage(502246); // The keg is empty.
+        }
+      }
+      else
+      {
+        from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1019045); // I can't reach that.
+      }
+    }
+
+    public override bool OnDragDrop(Mobile from, Item item)
+    {
+      if (!(item is BasePotion pot))
+      {
+        from.SendLocalizedMessage(502232); // The keg is not designed to hold that type of object.
+        return false;
+      }
+
+      int toHold = Math.Min(100 - m_Held, pot.Amount);
+
+      if (toHold <= 0)
+      {
+        from.SendLocalizedMessage(502233); // The keg will not hold any more!
+        return false;
+      }
+
+      if (m_Held == 0)
+      {
+        #region Mondain's Legacy
+
+        if ((int)pot.PotionEffect >= (int)PotionEffect.Invisibility)
+        {
+          from.SendLocalizedMessage(502232); // The keg is not designed to hold that type of object.
+          return false;
+        }
+
+        #endregion
+
+        if (GiveBottle(from, toHold))
+        {
+          m_Type = pot.PotionEffect;
+          Held = toHold;
+
+          from.PlaySound(0x240);
+
+          from.SendLocalizedMessage(502237); // You place the empty bottle in your backpack.
+
+          pot.Consume(toHold);
+
+          if (!pot.Deleted)
+            pot.Bounce(from);
+
+          return true;
+        }
+
+        from.SendLocalizedMessage(502238); // You don't have room for the empty bottle in your backpack.
+        return false;
+      }
+
+      if (pot.PotionEffect != m_Type)
+      {
+        from.SendLocalizedMessage(
+          502236); // You decide that it would be a bad idea to mix different types of potions.
+        return false;
+      }
+
+      if (GiveBottle(from, toHold))
+      {
+        Held += toHold;
+
+        from.PlaySound(0x240);
+
+        from.SendLocalizedMessage(502237); // You place the empty bottle in your backpack.
+
+        pot.Consume(toHold);
+
+        if (!pot.Deleted)
+          pot.Bounce(from);
+
+        return true;
+      }
+
+      from.SendLocalizedMessage(502238); // You don't have room for the empty bottle in your backpack.
+      return false;
+    }
+
+    public bool GiveBottle(Mobile m, int amount)
+    {
+      Container pack = m.Backpack;
+
+      Bottle bottle = new Bottle(amount);
+
+      if (pack?.TryDropItem(m, bottle, false) != true)
+      {
+        bottle.Delete();
+        return false;
+      }
+
+      return true;
+    }
+
+    public BasePotion FillBottle()
+    {
+      switch (m_Type)
+      {
+        default:
+        case PotionEffect.Nightsight: return new NightSightPotion();
+
+        case PotionEffect.CureLesser: return new LesserCurePotion();
+        case PotionEffect.Cure: return new CurePotion();
+        case PotionEffect.CureGreater: return new GreaterCurePotion();
+
+        case PotionEffect.Agility: return new AgilityPotion();
+        case PotionEffect.AgilityGreater: return new GreaterAgilityPotion();
+
+        case PotionEffect.Strength: return new StrengthPotion();
+        case PotionEffect.StrengthGreater: return new GreaterStrengthPotion();
+
+        case PotionEffect.PoisonLesser: return new LesserPoisonPotion();
+        case PotionEffect.Poison: return new PoisonPotion();
+        case PotionEffect.PoisonGreater: return new GreaterPoisonPotion();
+        case PotionEffect.PoisonDeadly: return new DeadlyPoisonPotion();
+
+        case PotionEffect.Refresh: return new RefreshPotion();
+        case PotionEffect.RefreshTotal: return new TotalRefreshPotion();
+
+        case PotionEffect.HealLesser: return new LesserHealPotion();
+        case PotionEffect.Heal: return new HealPotion();
+        case PotionEffect.HealGreater: return new GreaterHealPotion();
+
+        case PotionEffect.ExplosionLesser: return new LesserExplosionPotion();
+        case PotionEffect.Explosion: return new ExplosionPotion();
+        case PotionEffect.ExplosionGreater: return new GreaterExplosionPotion();
+
+        case PotionEffect.Conflagration: return new ConflagrationPotion();
+        case PotionEffect.ConflagrationGreater: return new GreaterConflagrationPotion();
+
+        case PotionEffect.ConfusionBlast: return new ConfusionBlastPotion();
+        case PotionEffect.ConfusionBlastGreater: return new GreaterConfusionBlastPotion();
+      }
+    }
+
+    public static void Initialize()
+    {
+      TileData.ItemTable[0x1940].Height = 4;
+    }
+  }
+}

Projects/Scripts/Items/Skill Items/Magical/Misc/RecallRune.cs

@@ -0,0 +1,308 @@
+using Server.Multis;
+using Server.Prompts;
+using Server.Regions;
+
+namespace Server.Items
+{
+  [Flippable(0x1f14, 0x1f15, 0x1f16, 0x1f17)]
+  public class RecallRune : Item
+  {
+    private const string RuneFormat = "a recall rune for {0}";
+    private string m_Description;
+    private BaseHouse m_House;
+    private bool m_Marked;
+    private Map m_TargetMap;
+
+    [Constructible]
+    public RecallRune() : base(0x1F14)
+    {
+      Weight = 1.0;
+      CalculateHue();
+    }
+
+    public RecallRune(Serial serial) : base(serial)
+    {
+    }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
+    public BaseHouse House
+    {
+      get
+      {
+        if (m_House?.Deleted == true)
+          House = null;
+
+        return m_House;
+      }
+      set
+      {
+        m_House = value;
+        CalculateHue();
+        InvalidateProperties();
+      }
+    }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
+    public string Description
+    {
+      get => m_Description;
+      set
+      {
+        m_Description = value;
+        InvalidateProperties();
+      }
+    }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
+    public bool Marked
+    {
+      get => m_Marked;
+      set
+      {
+        if (m_Marked != value)
+        {
+          m_Marked = value;
+          CalculateHue();
+          InvalidateProperties();
+        }
+      }
+    }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
+    public Point3D Target{ get; set; }
+
+    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
+    public Map TargetMap
+    {
+      get => m_TargetMap;
+      set
+      {
+        if (m_TargetMap != value)
+        {
+          m_TargetMap = value;
+          CalculateHue();
+          InvalidateProperties();
+        }
+      }
+    }
+
+    public override void Serialize(GenericWriter writer)
+    {
+      base.Serialize(writer);
+
+      if (m_House?.Deleted == false)
+      {
+        writer.Write(1); // version
+
+        writer.Write(m_House);
+      }
+      else
+      {
+        writer.Write(0); // version
+      }
+
+      writer.Write(m_Description);
+      writer.Write(m_Marked);
+      writer.Write(Target);
+      writer.Write(m_TargetMap);
+    }
+
+    public override void Deserialize(GenericReader reader)
+    {
+      base.Deserialize(reader);
+
+      int version = reader.ReadInt();
+
+      switch (version)
+      {
+        case 1:
+        {
+          m_House = reader.ReadItem() as BaseHouse;
+          goto case 0;
+        }
+        case 0:
+        {
+          m_Description = reader.ReadString();
+          m_Marked = reader.ReadBool();
+          Target = reader.ReadPoint3D();
+          m_TargetMap = reader.ReadMap();
+
+          CalculateHue();
+
+          break;
+        }
+      }
+    }
+
+    private void CalculateHue()
+    {
+      if (!m_Marked)
+        Hue = 0;
+      else if (m_TargetMap == Map.Trammel)
+        Hue = House != null ? 0x47F : 50;
+      else if (m_TargetMap == Map.Felucca)
+        Hue = House != null ? 0x66D : 0;
+      else if (m_TargetMap == Map.Ilshenar)
+        Hue = House != null ? 0x55F : 1102;
+      else if (m_TargetMap == Map.Malas)
+        Hue = House != null ? 0x55F : 1102;
+      else if (m_TargetMap == Map.Tokuno)
+        Hue = House != null ? 0x47F : 1154;
+    }
+
+    public void Mark(Mobile m)
+    {
+      m_Marked = true;
+
+      bool setDesc = false;
+      if (Core.AOS)
+      {
+        m_House = BaseHouse.FindHouseAt(m);
+
+        if (m_House == null)
+        {
+          Target = m.Location;
+          m_TargetMap = m.Map;
+        }
+        else
+        {
+          HouseSign sign = m_House.Sign;
+
+          if (sign != null)
+            m_Description = sign.Name;
+          else
+            m_Description = null;
+
+          if (m_Description == null || (m_Description = m_Description.Trim()).Length == 0)
+            m_Description = "an unnamed house";
+
+          setDesc = true;
+
+          int x = m_House.BanLocation.X;
+          int y = m_House.BanLocation.Y + 2;
+          int z = m_House.BanLocation.Z;
+
+          Map map = m_House.Map;
+
+          if (map?.CanFit(x, y, z, 16, false, false) == false)
+            z = map.GetAverageZ(x, y);
+
+          Target = new Point3D(x, y, z);
+          m_TargetMap = map;
+        }
+      }
+      else
+      {
+        m_House = null;
+        Target = m.Location;
+        m_TargetMap = m.Map;
+      }
+
+      if (!setDesc)
+        m_Description = BaseRegion.GetRuneNameFor(Region.Find(Target, m_TargetMap));
+
+      CalculateHue();
+      InvalidateProperties();
+    }
+
+    public override void GetProperties(ObjectPropertyList list)
+    {
+      base.GetProperties(list);
+
+      if (m_Marked)
+      {
+        string desc;
+
+        if ((desc = m_Description) == null || (desc = desc.Trim()).Length == 0)
+          desc = "an unknown location";
+
+        if (m_TargetMap == Map.Tokuno)
+          list.Add(House != null ? 1063260 : 1063259, RuneFormat, desc); // ~1_val~ (Tokuno Islands)[(House)]
+        else if (m_TargetMap == Map.Malas)
+          list.Add(House != null ? 1062454 : 1060804, RuneFormat, desc); // ~1_val~ (Malas)[(House)]
+        else if (m_TargetMap == Map.Felucca)
+          list.Add(House != null ? 1062452 : 1060805, RuneFormat, desc); // ~1_val~ (Felucca)[(House)]
+        else if (m_TargetMap == Map.Trammel)
+          list.Add(House != null ? 1062453 : 1060806, RuneFormat, desc); // ~1_val~ (Trammel)[(House)]
+        else
+          list.Add(House != null ? "{0} ({1})(House)" : "{0} ({1})", string.Format(RuneFormat, desc), m_TargetMap);
+      }
+    }
+
+    public override void OnSingleClick(Mobile from)
+    {
+      if (m_Marked)
+      {
+        string desc;
+
+        if ((desc = m_Description) == null || (desc = desc.Trim()).Length == 0)
+          desc = "an unknown location";
+
+        if (m_TargetMap == Map.Tokuno)
+          LabelTo(from, House != null ? 1063260 : 1063259,
+            string.Format(RuneFormat, desc)); // ~1_val~ (Tokuno Islands)[(House)]
+        else if (m_TargetMap == Map.Malas)
+          LabelTo(from, House != null ? 1062454 : 1060804,
+            string.Format(RuneFormat, desc)); // ~1_val~ (Malas)[(House)]
+        else if (m_TargetMap == Map.Felucca)
+          LabelTo(from, House != null ? 1062452 : 1060805,
+            string.Format(RuneFormat, desc)); // ~1_val~ (Felucca)[(House)]
+        else if (m_TargetMap == Map.Trammel)
+          LabelTo(from, House != null ? 1062453 : 1060806,
+            string.Format(RuneFormat, desc)); // ~1_val~ (Trammel)[(House)]
+        else
+          LabelTo(from, House != null ? "{0} ({1})(House)" : "{0} ({1})", string.Format(RuneFormat, desc),
+            m_TargetMap);
+      }
+      else
+      {
+        LabelTo(from, "an unmarked recall rune");
+      }
+    }
+
+    public override void OnDoubleClick(Mobile from)
+    {
+      int number;
+
+      if (!IsChildOf(from.Backpack))
+      {
+        number = 1042001; // That must be in your pack for you to use it.
+      }
+      else if (House != null)
+      {
+        number = 1062399; // You cannot edit the description for this rune.
+      }
+      else if (m_Marked)
+      {
+        number = 501804; // Please enter a description for this marked object.
+
+        from.Prompt = new RenamePrompt(this);
+      }
+      else
+      {
+        number = 501805; // That rune is not yet marked.
+      }
+
+      from.SendLocalizedMessage(number);
+    }
+
+    private class RenamePrompt : Prompt
+    {
+      private RecallRune m_Rune;
+
+      public RenamePrompt(RecallRune rune)
+      {
+        m_Rune = rune;
+      }
+
+      public override void OnResponse(Mobile from, string text)
+      {
+        if (m_Rune.House == null && m_Rune.Marked)
+        {
+          m_Rune.Description = text;
+          from.SendLocalizedMessage(1010474); // The etching on the rune has been changed.
+        }
+      }
+    }
+  }
+}