context: using System;
  using System.Collections.Generic;
  using Server.ContextMenus;
  using Server.Gumps;
  
  namespace Server.Multis
  {
      public class HouseSign : Item
      {
          private BaseHouse m_Owner;
          private Mobile m_OrgOwner;
  
          public HouseSign(BaseHouse owner)
              : base(0xBD2)
          {
              m_Owner = owner;
              m_OrgOwner = m_Owner.Owner;
              Movable = false;
          }
  
          public HouseSign(Serial serial)
              : base(serial)
          {
          }
  
          public string GetName()
          {
              if (Name == null)
                  return "An Unnamed House";
  
              return Name;
          }
  
          public BaseHouse Owner
          {
              get
              {
                  return m_Owner;
              }
          }
  
          [CommandProperty(AccessLevel.GameMaster)]
          public bool RestrictDecay
          {
              get
              {
                  return (m_Owner != null && m_Owner.RestrictDecay);
              }
              set
              {
                  if (m_Owner != null)
                      m_Owner.RestrictDecay = value;
              }
          }
  
          [CommandProperty(AccessLevel.GameMaster)]
          public Mobile OriginalOwner
          {
              get
              {
                  return m_OrgOwner;
              }
          }
  
          public override void OnAfterDelete()
          {
              base.OnAfterDelete();
  
              if (m_Owner != null && !m_Owner.Deleted)
                  m_Owner.Delete();
          }
  
          public override void AddNameProperty(ObjectPropertyList list)
          {
              list.Add(1061638); // A House Sign
          }
  
          public override bool ForceShowProperties
          {
              get
              {
                  return ObjectPropertyList.Enabled;
              }
          }
  
          private bool m_GettingProperties;
  
          public bool GettingProperties
          {
              get
              {
                  return m_GettingProperties;
              }
          }
  
          public override void GetProperties(ObjectPropertyList list)
          {
              base.GetProperties(list);
  
              list.Add(1061639, Utility.FixHtml(GetName())); // Name: ~1_NAME~
              list.Add(1061640, (m_Owner == null || m_Owner.Owner == null) ? "nobody" : m_Owner.Owner.Name); // Owner: ~1_OWNER~
  
              if (m_Owner != null)
              {
                  list.Add(m_Owner.Public ? 1061641 : 1061642); // This House is Open to the Public : This is a Private Home
  
                  m_GettingProperties = true;
                  DecayLevel level = m_Owner.DecayLevel;
                  m_GettingProperties = false;
  
                  if (level == DecayLevel.DemolitionPending)
                  {
                      list.Add(1062497); // Demolition Pending
                  }
                  else if (level != DecayLevel.Ageless)
                  {
                      if (level == DecayLevel.Collapsed)
                          level = DecayLevel.IDOC;
  
                      list.Add(1062028, String.Format("#{0}", 1043009 + (int)level)); // Condition: This structure is ...
                  }
              }
          }
  
          public override void OnSingleClick(Mobile from)
          {
              if (m_Owner != null && BaseHouse.DecayEnabled && m_Owner.DecayPeriod != TimeSpan.Zero)
              {
                  string message;
  
                  switch ( m_Owner.DecayLevel )
                  {
                      case DecayLevel.Ageless:
                          message = "ageless";
                          break;
                      case DecayLevel.Fairly:
                          message = "fairly worn";
                          break;
                      case DecayLevel.Greatly:
                          message = "greatly worn";
                          break;
                      case DecayLevel.LikeNew:
                          message = "like new";
                          break;
                      case DecayLevel.Slightly:
                          message = "slightly worn";
                          break;
                      case DecayLevel.Somewhat:
                          message = "somewhat worn";
                          break;
                      default:
                          message = "in danger of collapsing";
                          break;
                  }
  
                  LabelTo(from, "This house is {0}.", message);
              }
  
              base.OnSingleClick(from);
          }
  
          public void ShowSign(Mobile m)
          {
              if (m_Owner != null && m.AccessLevel == AccessLevel.Player)
              {
                  if ((Core.ML && m_Owner.IsFriend(m)) || !Core.ML)
                  {
                      m_Owner.RefreshDecay();
                  }
  
                  if (!Core.AOS && m_Owner.IsFriend(m))
                  {
                      m.SendLocalizedMessage(501293); // Welcome back to the house, friend!
                  }
              }
  
              if (m_Owner.IsAosRules)
              {
                  m.SendGump(new HouseGumpAOS(HouseGumpPageAOS.Information, m, m_Owner));
              }
              else
              {
                  m.SendGump(new HouseGump(m, m_Owner));
              }
          }
  
          public void ClaimGump_Callback(Mobile from, bool okay, object state)
          {
              if (okay && m_Owner != null && m_Owner.Owner == null && m_Owner.DecayLevel != DecayLevel.DemolitionPending)
              {
                  bool canClaim = false;
  
                  if (m_Owner.CoOwners == null || m_Owner.CoOwners.Count == 0)
                      canClaim = m_Owner.IsFriend(from);
                  else
                      canClaim = m_Owner.IsCoOwner(from);
  
                  if (canClaim && !BaseHouse.AtAccountHouseLimit(from))
                  {
                      m_Owner.Owner = from;
                      m_Owner.LastTraded = DateTime.UtcNow;
                  }
              }
  
              ShowSign(from);
          }
  
          public override void OnDoubleClick(Mobile m)
          {
              if (m_Owner == null)
                  return;
  
              if (m.AccessLevel < AccessLevel.GameMaster && m_Owner.Owner == null && m_Owner.DecayLevel != DecayLevel.DemolitionPending)
              {
                  bool canClaim = false;
  
                  if (m_Owner.CoOwners == null || m_Owner.CoOwners.Count == 0)
                      canClaim = m_Owner.IsFriend(m);
                  else
                      canClaim = m_Owner.IsCoOwner(m);
  
                  if (canClaim && !BaseHouse.AtAccountHouseLimit(m))
                  {
                      /* You do not currently own any house on any shard with this account,
                      * and this house currently does not have an owner.  If you wish, you
                      * may choose to claim this house and become its rightful owner.  If
                      * you do this, it will become your Primary house and automatically
                      * refresh.  If you claim this house, you will be unable to place
                      * another house or have another house transferred to you for the
                      * next 7 days.  Do you wish to claim this house?
                      */
                      m.SendGump(new WarningGump(501036, 32512, 1049719, 32512, 420, 280, new WarningGumpCallback(ClaimGump_Callback), null));
                  }
              }
  
              ShowSign(m);
          }
  
          public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
          {
              base.GetContextMenuEntries(from, list);
  
              if (BaseHouse.NewVendorSystem && from.Alive && Owner != null && Owner.IsAosRules)
              {
                  if (Owner.AreThereAvailableVendorsFor(from))
                      list.Add(new VendorsEntry(this));
  
                  if (Owner.VendorInventories.Count > 0)
                      list.Add(new ReclaimVendorInventoryEntry(this));
              }
          }
  
          private class VendorsEntry : ContextMenuEntry
          {
              private readonly HouseSign m_Sign;
  
              public VendorsEntry(HouseSign sign)
                  : base(6211)
              {
                  m_Sign = sign;
              }
  
              public override void OnClick()
              {
                  Mobile from = Owner.From;
  
                  if (!from.CheckAlive() || m_Sign.Deleted || m_Sign.Owner == null || !m_Sign.Owner.AreThereAvailableVendorsFor(from))
                      return;
  
                  if (from.Map != m_Sign.Map || !from.InRange(m_Sign, 5))
                  {
                      from.SendLocalizedMessage(1062429); // You must be within five paces of the house sign to use this option.
                  }
                  else
                  {
                      from.SendGump(new HouseGumpAOS(HouseGumpPageAOS.Vendors, from, m_Sign.Owner));
                  }
              }
          }
  
          private class ReclaimVendorInventoryEntry : ContextMenuEntry
          {
              private readonly HouseSign m_Sign;
  
              public ReclaimVendorInventoryEntry(HouseSign sign)
                  : base(6213)
              {
                  m_Sign = sign;
              }
  
              public override void OnClick()
              {
                  Mobile from = Owner.From;
  
                  if (m_Sign.Deleted || m_Sign.Owner == null || m_Sign.Owner.VendorInventories.Count == 0 || !from.CheckAlive())
                      return;
  
                  if (from.Map != m_Sign.Map || !from.InRange(m_Sign, 5))
                  {
                      from.SendLocalizedMessage(1062429); // You must be within five paces of the house sign to use this option.
                  }
                  else
                  {
                      from.CloseGump(typeof(VendorInventoryGump));
                      from.SendGump(new VendorInventoryGump(m_Sign.Owner, from));
                  }
              }
          }
  
          public override void Serialize(GenericWriter writer)
          {
              base.Serialize(writer);
  
              writer.Write((int)0); // version
  
              writer.Write(m_Owner);
              writer.Write(m_OrgOwner);
          }
  
          public override void Deserialize(GenericReader reader)
          {
              base.Deserialize(reader);
  
  
gt:             int version = reader.ReadInt();