servuo/Scripts/Multis/BaseHouse.cs

using System;
using System.Collections.Generic;
using System.Linq;

using Server.Accounting;
using Server.ContextMenus;
using Server.Guilds;
using Server.Gumps;
using Server.Items;
using Server.Misc;
using Server.Mobiles;
using Server.Multis.Deeds;
using Server.Network;
using Server.Regions;
using Server.Targeting;
using Server.Engines.Auction;
using Server.Engines.NewMagincia;

namespace Server.Multis
{
    public abstract class BaseHouse : BaseMulti
    {
        public static int AccountHouseLimit { get; } = Config.Get("Housing.AccountHouseLimit", 1);

        public static bool NewVendorSystem { get { return Core.AOS; } } // Is new player vendor system enabled?

        public static double GlobalBonusStorageScalar { get { return Core.ML ? Core.SA ? 1.4 : 1.2 : 1.0; } }

        public const int MaxCoOwners = 15;
        public static int MaxFriends { get { return !Core.AOS ? 50 : 140; } }
        public static int MaxBans { get { return !Core.AOS ? 50 : 140; } }

        #region Dynamic decay system
        private DecayLevel m_CurrentStage;

        [CommandProperty(AccessLevel.GameMaster)]
        public DateTime NextDecayStage { get; set; }

        public void ResetDynamicDecay()
        {
            m_CurrentStage = DecayLevel.Ageless;
            NextDecayStage = DateTime.MinValue;
        }

        public void SetDynamicDecay(DecayLevel level)
        {
            m_CurrentStage = level;

            if (DynamicDecay.Decays(level))
                NextDecayStage = DateTime.UtcNow + DynamicDecay.GetRandomDuration(level);
            else
                NextDecayStage = DateTime.MinValue;
        }

        #endregion

        public const bool DecayEnabled = true;

        public static void Decay_OnTick()
        {
            for (int i = 0; i < AllHouses.Count; ++i)
                AllHouses[i].CheckDecay();
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public DateTime LastRefreshed { get; set; }

        [CommandProperty(AccessLevel.GameMaster)]
        public bool RestrictDecay { get; set; }

        public virtual TimeSpan DecayPeriod { get { return TimeSpan.FromDays(5.0); } }

        public virtual DecayType DecayType
        {
            get
            {
                if (RestrictDecay || !DecayEnabled || DecayPeriod == TimeSpan.Zero)
                    return DecayType.Ageless;

                if (m_Owner == null)
                    return Core.AOS ? DecayType.Condemned : DecayType.ManualRefresh;

                Account acct = m_Owner.Account as Account;

                if (acct == null)
                    return Core.AOS ? DecayType.Condemned : DecayType.ManualRefresh;

                if (acct.AccessLevel >= AccessLevel.GameMaster)
                    return DecayType.Ageless;

                for (int i = 0; i < acct.Length; ++i)
                {
                    Mobile mob = acct[i];

                    if (mob != null && mob.AccessLevel >= AccessLevel.GameMaster)
                        return DecayType.Ageless;
                }

                if (!Core.AOS)
                    return DecayType.ManualRefresh;

                if (acct.Inactive)
                    return DecayType.Condemned;

                List<BaseHouse> allHouses = GetHouses(m_Owner);

                BaseHouse newest = null;

                for (int i = 0; i < allHouses.Count; ++i)
                {
                    BaseHouse check = allHouses[i];

                    if (newest == null || IsNewer(check, newest))
                        newest = check;
                }

                ColUtility.Free(allHouses);

                if (this == newest)
                    return DecayType.AutoRefresh;

                return DecayType.ManualRefresh;
            }
        }

        public bool IsNewer(BaseHouse check, BaseHouse house)
        {
            DateTime checkTime = check.LastTraded > check.BuiltOn ? check.LastTraded : check.BuiltOn;
            DateTime houseTime = house.LastTraded > house.BuiltOn ? house.LastTraded : house.BuiltOn;

            return checkTime > houseTime;
        }

        private DecayType _CurrentDecay;

        public virtual bool CanDecay
        {
            get
            {
                var decay = DecayType;

                if (!World.Loading)
                {
                    if (_CurrentDecay != DecayType.Condemned)
                    {
                        if (decay == DecayType.Condemned)
                        {
                            OnCondemned();
                        }
                    }

                    _CurrentDecay = decay;
                }

                return decay == DecayType.Condemned || decay == DecayType.ManualRefresh;
            }
        }

        private DecayLevel m_LastDecayLevel;

        [CommandProperty(AccessLevel.GameMaster)]
        public virtual DecayLevel DecayLevel
        {
            get
            {
                DecayLevel result;

                if (!CanDecay)
                {
                    if (DynamicDecay.Enabled)
                        ResetDynamicDecay();

                    LastRefreshed = DateTime.UtcNow;
                    result = DecayLevel.Ageless;
                }
                else if (DynamicDecay.Enabled)
                {
                    DecayLevel stage = m_CurrentStage;

                    if (stage == DecayLevel.Ageless || (DynamicDecay.Decays(stage) && NextDecayStage <= DateTime.UtcNow))
                        SetDynamicDecay(++stage);

                    if (stage == DecayLevel.Collapsed && (HasRentedVendors || VendorInventories.Count > 0))
                        result = DecayLevel.DemolitionPending;
                    else
                        result = stage;
                }
                else
                {
                    result = GetOldDecayLevel();
                }

                if (result != m_LastDecayLevel)
                {
                    m_LastDecayLevel = result;

                    if (Sign != null && !Sign.GettingProperties)
                        Sign.InvalidateProperties();
                }

                return result;
            }
        }

        public DecayLevel GetOldDecayLevel()
        {
            TimeSpan timeAfterRefresh = DateTime.UtcNow - LastRefreshed;
            int percent = (int)(timeAfterRefresh.Ticks * 1000 / DecayPeriod.Ticks);

            if (percent >= 1000) // 100.0%
                return (HasRentedVendors || VendorInventories.Count > 0) ? DecayLevel.DemolitionPending : DecayLevel.Collapsed;
            else if (percent >= 950) // 95.0% - 99.9%
                return DecayLevel.IDOC;
            else if (percent >= 750) // 75.0% - 94.9%
                return DecayLevel.Greatly;
            else if (percent >= 500) // 50.0% - 74.9%
                return DecayLevel.Fairly;
            else if (percent >= 250) // 25.0% - 49.9%
                return DecayLevel.Somewhat;
            else if (percent >= 005) // 00.5% - 24.9%
                return DecayLevel.Slightly;

            return DecayLevel.LikeNew;
        }

        public virtual bool RefreshDecay()
        {
            if (DecayType == DecayType.Condemned)
                return false;

            DecayLevel oldLevel = DecayLevel;

            LastRefreshed = DateTime.UtcNow;

            if (DynamicDecay.Enabled)
                ResetDynamicDecay();

            if (Sign != null)
                Sign.InvalidateProperties();

            return oldLevel > DecayLevel.LikeNew;
        }

        public virtual bool CheckDecay()
        {
            if (!Deleted && DecayLevel == DecayLevel.Collapsed)
            {
                Timer.DelayCall(TimeSpan.Zero, new TimerCallback(Decay_Sandbox));
                return true;
            }

            return false;
        }

        public virtual void KillVendors()
        {
            PlayerVendors.OfType<PlayerVendor>().IterateReverse(o => o.Destroy(true));

            PlayerBarkeepers.IterateReverse(o => o.Delete());
        }

        public virtual void Decay_Sandbox()
        {
            if (Deleted)
                return;

            if (Core.ML)
                new TempNoHousingRegion(this, null);

            if (Core.SA)
            {
                Rectangle3D[] recs = m_Region.Area;
                Map map = Map;

                Timer.DelayCall(TimeSpan.FromMilliseconds(250), () => OnAfterDecay(recs, map));
            }

            KillVendors();
            Delete();
        }

        public virtual void OnAfterDecay(Rectangle3D[] recs, Map map)
        {
            if (map != null && recs.Length > 0)
            {
                int count = Utility.RandomMinMax(1, 4);

                for (int i = 0; i < count; i++)
                {
                    var rec3D = recs[Utility.Random(recs.Length)];
                    var rec2D = new Rectangle2D(rec3D.Start, rec3D.End);

                    var eable = map.GetItemsInBounds(rec2D);
                    var list = new List<Item>();

                    foreach (Item item in eable)
                    {
                        if (item.RootParent == null && item.Movable && item.LootType != LootType.Blessed)
                        {
                            list.Add(item);
                        }
                    }

                    if (list.Count > 0)
                    {
                        Item item = list[Utility.Random(list.Count)];

                        if (item != null)
                        {
                            var grubber = new Grubber();
                            grubber.MoveToWorld(item.Location, item.Map);

                            grubber.PackItem(item);
                        }
                    }

                    eable.Free();
                    ColUtility.Free(list);
                }
            }
        }

        public virtual TimeSpan RestrictedPlacingTime { get { return TimeSpan.FromHours(1.0); } }

        [CommandProperty(AccessLevel.GameMaster)]
        public virtual double BonusStorageScalar
        {
            get
            {
                return GlobalBonusStorageScalar;
            }
        }

        private bool m_Public;

        private HouseRegion m_Region;
        private TrashBarrel m_Trash;
        private Mobile m_Owner;
        private Point3D m_RelativeBanLocation;

        private static readonly Dictionary<Mobile, List<BaseHouse>> m_Table = new Dictionary<Mobile, List<BaseHouse>>();

        public virtual bool IsAosRules { get { return Core.AOS; } }

        public virtual bool IsActive { get { return true; } }

        public virtual HousePlacementEntry GetAosEntry()
        {
            return HousePlacementEntry.Find(this);
        }

        public virtual int GetAosMaxSecures()
        {
            HousePlacementEntry hpe = GetAosEntry();

            if (hpe == null)
                return 0;

            return (int)(hpe.Storage * BonusStorageScalar);
        }

        public virtual int GetAosMaxLockdowns()
        {
            HousePlacementEntry hpe = GetAosEntry();

            if (hpe == null)
                return 0;

            return (int)(hpe.Lockdowns * BonusStorageScalar);
        }

        private Type[] _NoItemCountTable = new Type[]
        {
            typeof(Engines.Plants.SeedBox), typeof(GardenShedAddon),
            typeof(GardenShedBarrel),       typeof(BaseSpecialScrollBook),
            typeof(JewelryBox)
        };

        private Type[] _NoDecayItems = new Type[]
        {
            typeof(BaseBoard),              typeof(Aquarium),
            typeof(FishBowl),               typeof(BaseSpecialScrollBook),
            typeof(Engines.Plants.SeedBox), typeof(JewelryBox),
        };

        // Not Included Storage
        public virtual bool CheckCounts(Item item)
        {
            if (_NoItemCountTable.Any(x => item.GetType() == x || item.GetType().IsSubclassOf(x)))
            {
                return false;
            }

            return true;
        }

        // Contents will not decay
        public virtual bool CheckContentsDecay(Item item)
        {
            if (_NoDecayItems.Any(x => item.GetType() == x ||item.GetType().IsSubclassOf(x)))
            {
                return false;
            }

            return true;
        }

        public virtual int GetAosCurSecures(out int fromSecures, out int fromVendors, out int fromLockdowns, out int fromMovingCrate)
        {
            /* Secured container, container counts as fromLockdowns, items count as fromSecures
             * Locked Down Container, container and items count as fromLockdowns */

            fromSecures = 0;
            fromVendors = 0;
            fromLockdowns = 0;
            fromMovingCrate = 0;

            List<SecureInfo> list = Secures;

            if (list != null)
            {
                for (int i = 0; i < list.Count; ++i)
                {
                    SecureInfo si = (SecureInfo)list[i];

                    if (CheckCounts(si.Item) && !LockDowns.ContainsKey(si.Item))
                    {
                        fromSecures += si.Item.TotalItems;
                    }
                }

                fromLockdowns += list.Where(x => !LockDowns.ContainsKey(x.Item)).Count();
            }

            fromLockdowns += GetLockdowns();

            fromLockdowns += GetCommissionVendorLockdowns();

            if (!NewVendorSystem)
            {
                foreach (var vendor in PlayerVendors)
                {
                    if (vendor.Backpack != null)
                    {
                        fromVendors += vendor.Backpack.TotalItems;
                    }
                }
            }

            if (MovingCrate != null)
            {
                fromMovingCrate += MovingCrate.TotalItems;

                foreach (Item item in MovingCrate.Items)
                {
                    if (item is PackingBox)
                        fromMovingCrate--;
                }
            }

            return fromSecures + fromVendors + fromLockdowns + fromMovingCrate;
        }

        public bool InRange(IPoint2D from, int range)
        {
            if (Region == null)
                return false;

            foreach (Rectangle3D rect in Region.Area)
            {
                if (from.X >= rect.Start.X - range && from.Y >= rect.Start.Y - range && from.X < rect.End.X + range && from.Y < rect.End.Y + range)
                    return true;
            }

            return false;
        }

        public virtual int GetNewVendorSystemMaxVendors()
        {
            HousePlacementEntry hpe = GetAosEntry();

            if (hpe == null)
                return 0;

            return (int)(hpe.Vendors * BonusStorageScalar);
        }

        public virtual bool CanPlaceNewVendor()
        {
            if (!IsAosRules)
                return true;

            if (!NewVendorSystem)
                return CheckAosLockdowns(10);

            return (PlayerVendors.Count + VendorRentalContracts.Count) < GetNewVendorSystemMaxVendors();
        }

        public const int MaximumBarkeepCount = 2;

        public virtual bool CanPlaceNewBarkeep()
        {
            return PlayerBarkeepers.Count < MaximumBarkeepCount;
        }

        public static void IsThereVendor(Point3D location, Map map, out bool vendor, out bool rentalContract)
        {
            vendor = false;
            rentalContract = false;

            IPooledEnumerable eable = map.GetObjectsInRange(location, 0);

            foreach (IEntity entity in eable)
            {
                if (Math.Abs(location.Z - entity.Z) <= 16)
                {
                    if (entity is PlayerVendor || entity is PlayerBarkeeper || entity is PlayerVendorPlaceholder)
                    {
                        vendor = true;
                        break;
                    }

                    if (entity is VendorRentalContract)
                    {
                        rentalContract = true;
                        break;
                    }
                }
            }

            eable.Free();
        }

        public bool HasPersonalVendors
        {
            get
            {
                foreach (var vendor in PlayerVendors)
                {
                    if (!(vendor is RentedVendor))
                        return true;
                }

                return false;
            }
        }

        public bool HasRentedVendors
        {
            get
            {
                foreach (var vendor in PlayerVendors)
                {
                    if (vendor is RentedVendor)
                        return true;
                }

                return false;
            }
        }

        #region Mondain's Legacy
        public bool HasAddonContainers
        {
            get
            {
                foreach (Item item in Addons.Keys)
                {
                    if (item is BaseAddonContainer || item is RaisedGardenAddon || item is WallSafe)
                        return true;
                }

                return false;
            }
        }
        #endregion

        #region TOL
        public bool HasActiveAuction
        {
            get
            {
                foreach (Item item in Addons.Keys)
                {
                    if (item is AuctionSafe && ((AuctionSafe)item).Auction != null && ((AuctionSafe)item).Auction.OnGoing)
                        return true;
                }

                return false;
            }
        }
        #endregion
        
        public List<Mobile> AvailableVendorsFor(Mobile m)
        {
            List<Mobile> list = new List<Mobile>();

            foreach (var vendor in PlayerVendors.OfType<PlayerVendor>())
            {
                if (vendor.CanInteractWith(m, false))
                    list.Add(vendor);
            }

            return list;
        }

        public bool AreThereAvailableVendorsFor(Mobile m)
        {
            foreach (var vendor in PlayerVendors.OfType<PlayerVendor>())
            {
                if (vendor.CanInteractWith(m, false))
                    return true;
            }

            return false;
        }

        public void MoveAllToCrate()
        {
            RelocatedEntities.Clear();

            if (MovingCrate != null)
                MovingCrate.Hide();

            if (m_Trash != null)
            {
                m_Trash.Delete();
                m_Trash = null;
            }

            foreach (Item item in LockDowns.Keys)
            {
                if (!item.Deleted)
                {
                    item.IsLockedDown = false;
                    item.IsSecure = false;
                    item.Movable = true;

                    if (item.Parent == null)
                        DropToMovingCrate(item);
                }
            }

            LockDowns.Clear();

            foreach (Item item in VendorRentalContracts)
            {
                if (!item.Deleted)
                {
                    item.IsLockedDown = false;
                    item.IsSecure = false;
                    item.Movable = true;

                    if (item.Parent == null)
                        DropToMovingCrate(item);
                }
            }

            VendorRentalContracts.Clear();

            foreach (SecureInfo info in Secures)
            {
                Item item = info.Item;

                if (!item.Deleted)
                {
                    if (item is StrongBox)
                        item = ((StrongBox)item).ConvertToStandardContainer();

                    item.IsLockedDown = false;
                    item.IsSecure = false;
                    item.Movable = true;

                    if (item.Parent == null)
                        DropToMovingCrate(item);
                }
            }

            Secures.Clear();

            foreach (Item addon in Addons.Keys)
            {
                if (!addon.Deleted)
                {
                    Item deed = null;
                    bool retainDeedHue = false;	//if the items aren't hued but the deed itself is
                    int hue = 0;

                    if (addon is IAddon)
                    {
                        deed = ((IAddon)addon).Deed;

                        if (addon is BaseAddon && ((BaseAddon)addon).RetainDeedHue)	//There are things that are IAddon which aren't BaseAddon
                        {
                            BaseAddon ba = (BaseAddon)addon;
                            retainDeedHue = true;

                            for (int i = 0; hue == 0 && i < ba.Components.Count; ++i)
                            {
                                AddonComponent c = ba.Components[i];

                                if (c.Hue != 0)
                                    hue = c.Hue;
                            }
                        }
                    }

                    if (deed != null)
                    {
                        #region Mondain's Legacy
                        if (deed is BaseAddonContainerDeed && addon is BaseAddonContainer)
                        {
                            BaseAddonContainer c = (BaseAddonContainer)addon;
                            c.DropItemsToGround();

                            ((BaseAddonContainerDeed)deed).Resource = c.Resource;
                        }
                        else if (deed is BaseAddonDeed && addon is BaseAddon)
                            ((BaseAddonDeed)deed).Resource = ((BaseAddon)addon).Resource;
                        #endregion

                        addon.Delete();

                        if (retainDeedHue)
                            deed.Hue = hue;

                        DropToMovingCrate(deed);
                    }
                    else
                    {
                        DropToMovingCrate(addon);
                    }
                }
            }

            Addons.Clear();

            foreach (var mobile in PlayerVendors.OfType<PlayerVendor>())
            {
                mobile.Return();
                mobile.Internalize();
                InternalizedVendors.Add(mobile);
            }

            foreach (Mobile mobile in PlayerBarkeepers)
            {
                mobile.Internalize();
                InternalizedVendors.Add(mobile);
            }
        }

        public Dictionary<IEntity, Mobile> GetHouseEntities()
        {
            Dictionary<IEntity, Mobile> list = new Dictionary<IEntity, Mobile>();

            if (MovingCrate != null)
                MovingCrate.Hide();

            if (m_Trash != null && m_Trash.Map != Map.Internal)
                list[m_Trash] = Owner;

            foreach (Item item in LockDowns.Keys)
            {
                if (item.Parent == null && item.Map != Map.Internal)
                    list[item] = LockDowns[item];
            }

            foreach (Item item in VendorRentalContracts)
            {
                if (item.Parent == null && item.Map != Map.Internal)
                    list[item] = Owner;
            }

            foreach (SecureInfo info in Secures.Where(i => !LockDowns.ContainsKey(i.Item)))
            {
                Item item = info.Item;

                if (item.Parent == null && item.Map != Map.Internal)
                    list[item] = Owner;
            }

            foreach (Item item in Addons.Keys)
            {
                if (item.Parent == null && item.Map != Map.Internal)
                    list[item] = Owner;
            }

            foreach (var mobile in PlayerVendors.OfType<PlayerVendor>())
            {
                mobile.Return();

                if (mobile.Map != Map.Internal)
                    list[mobile] = Owner;
            }

            foreach (Mobile mobile in PlayerBarkeepers)
            {
                if (mobile.Map != Map.Internal)
                    list[mobile] = Owner;
            }

            return list;
        }

        public void RelocateEntities()
        {
            Dictionary<IEntity, Mobile> entities = GetHouseEntities();

            foreach (IEntity entity in entities.Keys)
            {
                Point3D relLoc = new Point3D(entity.X - X, entity.Y - Y, entity.Z - Z);
                RelocatedEntity relocEntity = new RelocatedEntity(entity, relLoc, entities[entity]);

                RelocatedEntities.Add(relocEntity);

                if (entity is Item)
                    ((Item)entity).Internalize();
                else
                    ((Mobile)entity).Internalize();
            }
        }

        public void RestoreRelocatedEntities()
        {
            foreach (RelocatedEntity relocEntity in RelocatedEntities)
            {
                Point3D relLoc = relocEntity.RelativeLocation;
                Point3D location = new Point3D(relLoc.X + X, relLoc.Y + Y, relLoc.Z + Z);

                IEntity entity = relocEntity.Entity;

                if (entity is Item)
                {
                    Item item = (Item)entity;

                    if (!item.Deleted)
                    {
                        if (item is IAddon)
                        {
                            if (((IAddon)item).CouldFit(location, Map))
                            {
                                item.MoveToWorld(location, Map);
                                continue;
                            }
                        }
                        else
                        {
                            int height;
                            bool requireSurface;
                            if (item is VendorRentalContract)
                            {
                                height = 16;
                                requireSurface = true;
                            }
                            else
                            {
                                height = item.ItemData.Height;
                                requireSurface = false;
                            }

                            if (Map.CanFit(location.X, location.Y, location.Z, height, false, false, requireSurface))
                            {
                                item.MoveToWorld(location, Map);
                                continue;
                            }
                        }

                        // The item can't fit

                        if (item is TrashBarrel)
                        {
                            item.Delete(); // Trash barrels don't go to the moving crate
                        }
                        else
                        {
                            SetLockdown(relocEntity.Owner, item, false);
                            item.IsSecure = false;
                            item.Movable = true;

                            Item relocateItem = item;

                            if (item is StrongBox)
                                relocateItem = ((StrongBox)item).ConvertToStandardContainer();

                            if (item is IAddon)
                            {
                                Item deed;

                                if (item is FishTrophy)
                                {
                                    deed = ((FishTrophy)item).TrophyDeed;
                                }
                                else
                                {
                                    deed = ((IAddon)item).Deed;
                                }

                                bool retainDeedHue = false;	//if the items aren't hued but the deed itself is
                                int hue = 0;

                                if (item is BaseAddon && ((BaseAddon)item).RetainDeedHue)	//There are things that are IAddon which aren't BaseAddon
                                {
                                    BaseAddon ba = (BaseAddon)item;
                                    retainDeedHue = true;

                                    for (int i = 0; hue == 0 && i < ba.Components.Count; ++i)
                                    {
                                        AddonComponent c = ba.Components[i];

                                        if (c.Hue != 0)
                                            hue = c.Hue;
                                    }
                                }

                                #region Mondain's Legacy
                                if (deed != null)
                                {
                                    if (deed is BaseAddonContainerDeed && item is BaseAddonContainer)
                                    {
                                        BaseAddonContainer c = (BaseAddonContainer)item;
                                        c.DropItemsToGround();

                                        ((BaseAddonContainerDeed)deed).Resource = c.Resource;
                                    }
                                    else if (deed is BaseAddonDeed && item is BaseAddon)
                                        ((BaseAddonDeed)deed).Resource = ((BaseAddon)item).Resource;

                                    if (retainDeedHue)
                                        deed.Hue = hue;
                                }
                                #endregion

                                relocateItem = deed;
                                item.Delete();
                            }

                            if (relocateItem != null)
                                DropToMovingCrate(relocateItem);
                        }
                    }

                    if (m_Trash == item)
                        m_Trash = null;

                    LockDowns.Remove(item);
                    VendorRentalContracts.Remove(item);
                    Addons.Remove(item);
                    for (int i = Secures.Count - 1; i >= 0; i--)
                    {
                        if (((SecureInfo)Secures[i]).Item == item)
                            Secures.RemoveAt(i);
                    }
                }
                else
                {
                    Mobile mobile = (Mobile)entity;

                    if (!mobile.Deleted)
                    {
                        if (Map.CanFit(location, 16, false, false))
                        {
                            mobile.MoveToWorld(location, Map);
                        }
                        else
                        {
                            InternalizedVendors.Add(mobile);
                        }
                    }
                }
            }

            RelocatedEntities.Clear();
        }

        public void DropToMovingCrate(Item item)
        {
            if (MovingCrate == null)
                MovingCrate = new MovingCrate(this);

            MovingCrate.DropItem(item);
        }

        public List<Item> GetItems()
        {
            if (Map == null || Map == Map.Internal)
                return new List<Item>();

            Point2D start = new Point2D(X + Components.Min.X, Y + Components.Min.Y);
            Point2D end = new Point2D(X + Components.Max.X + 1, Y + Components.Max.Y + 1);
            Rectangle2D rect = new Rectangle2D(start, end);

            List<Item> list = new List<Item>();

            IPooledEnumerable eable = Map.GetItemsInBounds(rect);

            foreach (Item item in eable)
                if (item.Movable && IsInside(item))
                    list.Add(item);

            eable.Free();

            return list;
        }

        public List<Mobile> GetMobiles()
        {
            if (Map == null || Map == Map.Internal)
                return new List<Mobile>();

            List<Mobile> list = new List<Mobile>();

            foreach (Mobile mobile in Region.GetMobiles())
                if (IsInside(mobile))
                    list.Add(mobile);

            return list;
        }

        public virtual bool CheckAosLockdowns(int need)
        {
            return (GetAosCurLockdowns() + need) <= GetAosMaxLockdowns();
        }

        public virtual bool CheckAosStorage(int need)
        {
            int fromSecures, fromVendors, fromLockdowns, fromMovingCrate;

            return (GetAosCurSecures(out fromSecures, out fromVendors, out fromLockdowns, out fromMovingCrate) + need) <= GetAosMaxSecures();
        }

        public static void Configure()
        {
            LockedDownFlag = 1;
            SecureFlag = 2;

            Timer.DelayCall(TimeSpan.FromMinutes(1.0), TimeSpan.FromMinutes(1.0), new TimerCallback(Decay_OnTick));
        }

        public virtual int GetAosCurLockdowns()
        {
            int v = 0;

            v += GetLockdowns();

            v += GetCommissionVendorLockdowns();

            if (Secures != null)
                v += Secures.Where(x => !LockDowns.ContainsKey(x.Item)).Count();

            if (!NewVendorSystem)
                v += PlayerVendors.Count * 10;

            return v;
        }

        public static bool CheckLockedDown(Item item)
        {
            BaseHouse house = FindHouseAt(item);

            return house != null && house.IsLockedDown(item);
        }

        public static bool CheckSecured(Item item)
        {
            BaseHouse house = FindHouseAt(item);

            return house != null && house.IsSecure(item);
        }

        public static bool CheckLockedDownOrSecured(Item item)
        {
            BaseHouse house = FindHouseAt(item);

            return house != null && (house.IsSecure(item) || house.IsLockedDown(item));
        }

        public static List<BaseHouse> GetHouses(Mobile m)
        {
            List<BaseHouse> list = new List<BaseHouse>();

            if (m != null)
            {
                m_Table.TryGetValue(m, out List<BaseHouse> exists);

                if (exists != null)
                {
                    for (int i = 0; i < exists.Count; ++i)
                    {
                        BaseHouse house = exists[i];

                        if (house != null && !house.Deleted && house.Owner == m)
                            list.Add(house);
                    }
                }
            }

            return list;
        }

        public static bool CheckHold(Mobile m, Container cont, Item item, bool message, bool checkItems, int plusItems, int plusWeight)
        {
            BaseHouse house = FindHouseAt(cont);

            if (house == null || !house.IsAosRules)
                return true;

            if (house.IsSecure(cont) && !house.CheckAosStorage(1 + item.TotalItems + plusItems))
            {
                if (message)
                    m.SendLocalizedMessage(1061839); // This action would exceed the secure storage limit of the house.

                return false;
            }

            return true;
        }

        public static bool CheckAccessible(Mobile m, Item item)
        {
            if (m.AccessLevel >= AccessLevel.GameMaster)
                return true; // Staff can access anything

            BaseHouse house = FindHouseAt(item);

            if (house == null)
                return true;

            SecureAccessResult res = house.CheckSecureAccess(m, item);

            switch ( res )
            {
                case SecureAccessResult.Insecure:
                    break;
                case SecureAccessResult.Accessible:
                    return true;
                case SecureAccessResult.Inaccessible:
                    return false;
            }

            if (house.IsLockedDown(item))
                return house.IsCoOwner(m) && (item is Container);

            return true;
        }

        public static BaseHouse FindHouseAt(Mobile m)
        {
            if (m == null || m.Deleted)
                return null;

            return FindHouseAt(m.Location, m.Map, 16);
        }

        public static BaseHouse FindHouseAt(Item item)
        {
            if (item == null || item.Deleted)
                return null;

            return FindHouseAt(item.GetWorldLocation(), item.Map, item.ItemData.Height);
        }

        public static BaseHouse FindHouseAt(Point3D loc, Map map, int height)
        {
            if (map == null || map == Map.Internal)
                return null;

            Sector sector = map.GetSector(loc);

            for (int i = 0; i < sector.Multis.Count; ++i)
            {
                BaseHouse house = sector.Multis[i] as BaseHouse;

                if (house != null && house.IsInside(loc, height))
                    return house;
            }

            return null;
        }

        public bool IsInside(Mobile m)
        {
            if (m == null || m.Deleted || m.Map != Map)
                return false;

            return IsInside(m.Location, 16);
        }

        public bool IsInside(Item item)
        {
            if (item == null || item.Deleted || item.Map != Map)
                return false;

            return IsInside(item.Location, item.ItemData.Height);
        }

        public bool CheckAccessibility(Item item, Mobile from)
        {
            SecureAccessResult res = CheckSecureAccess(from, item);

            switch ( res )
            {
                case SecureAccessResult.Insecure:
                    break;
                case SecureAccessResult.Accessible:
                    return true;
                case SecureAccessResult.Inaccessible:
                    return false;
            }

            // staff or not locked down
            if (from.AccessLevel >= AccessLevel.GameMaster || IsOwner(from) || !IsLockedDown(item))
                return true;

            bool lockedDown = LockDowns.ContainsKey(item);

            // lockdown owner can access it
            if (lockedDown && CheckLockdownOwnership(from, item))
                return true;

            // ISecurable will set its own rules
            if (item is ISecurable)
                return HasSecureAccess(from, ((ISecurable)item).Level);

            if (item.Stackable)
                return true;

            // locked down
            if (lockedDown)
            {
                // non friend, but item is on friends only list
                if (!IsFriend(from) && IsInList(item, _AccessibleToFriends))
                    return false;

                // anyone can use list, house must be public or player must have access to house
                if (IsInList(item, _AccessibleToAll) && (m_Public || Access.Contains(from)))
                    return true;

                return false;
            }

            return true;
        }

        private bool IsInList(Item item, Type[] list)
        {
            foreach (var t in list)
            {
                if (t == item.GetType() || item.GetType().IsSubclassOf(t))
                    return true;
            }

            return false;
        }

        private Type[] _AccessibleToAll =
        {
            typeof(TenthAnniversarySculpture), typeof(RewardBrazier), typeof(VendorRentalContract), typeof(Dyes), typeof(DyeTub),
            typeof(BaseInstrument), typeof(Clock), typeof(TreasureMap), typeof(RecallRune), typeof(Dices), typeof(BaseBoard), 
            typeof(Runebook)
        };

        private Type[] _AccessibleToFriends =
        {
            typeof(PotionKeg)
        };

        public virtual bool IsInside(Point3D p, int height)
        {
            if (Deleted)
                return false;

            MultiComponentList mcl = Components;

            int x = p.X - (X + mcl.Min.X);
            int y = p.Y - (Y + mcl.Min.Y);

            if (x < 0 || x >= mcl.Width || y < 0 || y >= mcl.Height)
                return false;

            if (this is HouseFoundation && y < (mcl.Height - 1) && p.Z >= Z)
                return true;

            StaticTile[] tiles = mcl.Tiles[x][y];

            for (int j = 0; j < tiles.Length; ++j)
            {
                StaticTile tile = tiles[j];
                int id = tile.ID & TileData.MaxItemValue;
                ItemData data = TileData.ItemTable[id];

                // Slanted roofs do not count; they overhang blocking south and east sides of the multi
                if ((data.Flags & TileFlag.Roof) != 0)
                    continue;

                // Signs and signposts are not considered part of the multi
                if ((id >= 0xB95 && id <= 0xC0E) || (id >= 0xC43 && id <= 0xC44))
                    continue;

                int tileZ = tile.Z + Z;

                if (p.Z == tileZ || (p.Z + height) > tileZ)
                    return true;
            }

            return IsInsideSpecial(p, tiles);
        }

        protected virtual bool IsInsideSpecial(Point3D p, StaticTile[] tiles)
        {
            return false;
        }

        public SecureAccessResult CheckSecureAccess(Mobile m, Item item)
        {
            if (Secures == null || !(item is Container))
                return SecureAccessResult.Insecure;

            for (int i = 0; i < Secures.Count; ++i)
            {
                SecureInfo info = (SecureInfo)Secures[i];

                if (info.Item == item)
                    return HasSecureAccess(m, info) ? SecureAccessResult.Accessible : SecureAccessResult.Inaccessible;
            }

            return SecureAccessResult.Insecure;
        }

        public static List<BaseHouse> AllHouses { get; } = new List<BaseHouse>();

        public BaseHouse(int multiID, Mobile owner, int MaxLockDown, int MaxSecure)
            : base(multiID)
        {
            AllHouses.Add(this);

            LastRefreshed = DateTime.UtcNow;

            BuiltOn = DateTime.UtcNow;
            LastTraded = DateTime.MinValue;

            Doors = new List<Item>();
            LockDowns = new Dictionary<Item, Mobile>();
            Secures = new List<SecureInfo>();
            Addons = new Dictionary<Item, Mobile>();
            Carpets = new List<Item>();

            CoOwners = new List<Mobile>();
            Friends = new List<Mobile>();
            Bans = new List<Mobile>();
            Access = new List<Mobile>();

            VendorRentalContracts = new List<Item>();
            InternalizedVendors = new List<Mobile>();

            Visits = new Dictionary<Mobile, DateTime>();

            m_Owner = owner;

            MaxLockDowns = MaxLockDown;
            MaxSecures = MaxSecure;

            m_RelativeBanLocation = BaseBanLocation;

            UpdateRegion();

            if (owner != null)
            {
                List<BaseHouse> list = null;
                m_Table.TryGetValue(owner, out list);

                if (list == null)
                    m_Table[owner] = list = new List<BaseHouse>();

                list.Add(this);
            }

            Movable = false;
        }

        public BaseHouse(Serial serial)
            : base(serial)
        {
            AllHouses.Add(this);
        }

        public override void OnMapChange()
        {
            if (LockDowns == null)
                return;

            UpdateRegion();

            if (Sign != null && !Sign.Deleted)
                Sign.Map = Map;

            if (Doors != null)
            {
                foreach (Item item in Doors)
                    item.Map = Map;
            }

            foreach (IEntity entity in GetHouseEntities().Keys)
            {
                if (entity is Item)
                    ((Item)entity).Map = Map;
                else
                    ((Mobile)entity).Map = Map;
            }
        }

        public virtual void ChangeSignType(int itemID)
        {
            if (Sign != null)
                Sign.ItemID = itemID;
        }

        public abstract Rectangle2D[] Area { get; }
        public abstract Point3D BaseBanLocation { get; }

        public virtual void UpdateRegion()
        {
            if (m_Region != null)
                m_Region.Unregister();

            if (Map != null)
            {
                m_Region = new HouseRegion(this);
                m_Region.Register();
            }
            else
            {
                m_Region = null;
            }
        }

        public override void OnLocationChange(Point3D oldLocation)
        {
            if (LockDowns == null)
                return;

            int x = base.Location.X - oldLocation.X;
            int y = base.Location.Y - oldLocation.Y;
            int z = base.Location.Z - oldLocation.Z;

            if (Sign != null && !Sign.Deleted)
                Sign.Location = new Point3D(Sign.X + x, Sign.Y + y, Sign.Z + z);

            UpdateRegion();

            if (Doors != null)
            {
                foreach (Item item in Doors)
                {
                    if (!item.Deleted)
                        item.Location = new Point3D(item.X + x, item.Y + y, item.Z + z);
                }
            }

            foreach (IEntity entity in GetHouseEntities().Keys)
            {
                Point3D newLocation = new Point3D(entity.X + x, entity.Y + y, entity.Z + z);

                if (entity is Item)
                    ((Item)entity).Location = newLocation;
                else
                    ((Mobile)entity).Location = newLocation;
            }
        }

        public BaseDoor AddEastDoor(int x, int y, int z)
        {
            return AddEastDoor(true, x, y, z);
        }

        public BaseDoor AddEastDoor(bool wood, int x, int y, int z)
        {
            BaseDoor door = MakeDoor(wood, DoorFacing.SouthCW);

            AddDoor(door, x, y, z);

            return door;
        }

        public BaseDoor AddSouthDoor(int x, int y, int z)
        {
            return AddSouthDoor(true, x, y, z);
        }

        public BaseDoor AddSouthDoor(bool wood, int x, int y, int z)
        {
            BaseDoor door = MakeDoor(wood, DoorFacing.WestCW);

            AddDoor(door, x, y, z);

            return door;
        }

        public BaseDoor AddEastDoor(int x, int y, int z, uint k)
        {
            return AddEastDoor(true, x, y, z, k);
        }

        public BaseDoor AddEastDoor(bool wood, int x, int y, int z, uint k)
        {
            BaseDoor door = MakeDoor(wood, DoorFacing.SouthCW);

            door.KeyValue = k;
            AddDoor(door, x, y, z);

            return door;
        }

        public BaseDoor AddSouthDoor(int x, int y, int z, uint k)
        {
            return AddSouthDoor(true, x, y, z, k);
        }

        public BaseDoor AddSouthDoor(bool wood, int x, int y, int z, uint k)
        {
            BaseDoor door = MakeDoor(wood, DoorFacing.WestCW);

            door.KeyValue = k;
            AddDoor(door, x, y, z);

            return door;
        }

        public BaseDoor[] AddSouthDoors(int x, int y, int z, uint k)
        {
            return AddSouthDoors(true, x, y, z, k);
        }

        public BaseDoor[] AddSouthDoors(bool wood, int x, int y, int z, uint k)
        {
            BaseDoor westDoor = MakeDoor(wood, DoorFacing.WestCW);
            BaseDoor eastDoor = MakeDoor(wood, DoorFacing.EastCCW);

            westDoor.KeyValue = k;
            eastDoor.KeyValue = k;

            westDoor.Link = eastDoor;
            eastDoor.Link = westDoor;

            AddDoor(westDoor, x, y, z);
            AddDoor(eastDoor, x + 1, y, z);

            return new BaseDoor[2] { westDoor, eastDoor };
        }

        public BaseDoor[] AddEastDoors(int x, int y, int z, uint k)
        {
            return AddEastDoors(true, x, y, z, k, false);
        }

        public BaseDoor[] AddEastDoors(bool wood, int x, int y, int z, uint k)
        {
            return AddEastDoors(wood, x, y, z, k, false, false);
        }

        public BaseDoor[] AddEastDoors(bool wood, int x, int y, int z, uint k, bool invert)
        {
            return AddEastDoors(wood, x, y, z, k, invert, false);
        }

        public BaseDoor[] AddEastDoors(bool wood, int x, int y, int z)
        {
            return AddEastDoors(wood, x, y, z, 0, false, false);
        }

        public BaseDoor[] AddEastDoors(bool wood, int x, int y, int z, bool invert, bool altopen)
        {
            return AddEastDoors(wood, x, y, z, 0, invert, altopen);
        }

        public BaseDoor[] AddEastDoors(bool wood, int x, int y, int z, uint k, bool invert, bool altopen)
        {
            BaseDoor northDoor = MakeDoor(wood, invert ? DoorFacing.SouthCCW : altopen ? DoorFacing.NorthCCW : DoorFacing.NorthCW);
            BaseDoor southDoor = MakeDoor(wood, invert ? DoorFacing.NorthCW : altopen ? DoorFacing.SouthCW : DoorFacing.SouthCCW);

            northDoor.KeyValue = k;
            southDoor.KeyValue = k;

            northDoor.Link = southDoor;
            southDoor.Link = northDoor;

            AddDoor(northDoor, x, y, z);
            AddDoor(southDoor, x, y + 1, z);

            return new BaseDoor[2] { northDoor, southDoor };
        }

        protected void ConvertDoor(BaseDoor door, int closedID, bool invert)
        {
            door.ItemID = closedID;
            door.ClosedID = closedID;
            door.OpenedID = closedID + 1;
        }

        protected BaseDoor AddDoor(int itemID, int xOffset, int yOffset, int zOffset)
        {
            return AddDoor(null, itemID, xOffset, yOffset, zOffset);
        }

        protected BaseDoor AddDoor(Mobile from, int itemID, int xOffset, int yOffset, int zOffset)
        {
            BaseDoor door = null;

            if (itemID >= 0x675 && itemID < 0x6F5)
            {
                int type = (itemID - 0x675) / 16;
                DoorFacing facing = (DoorFacing)(((itemID - 0x675) / 2) % 8);

                switch (type)
                {
                    case 0:
                        door = new GenericHouseDoor(facing, 0x675, 0xEC, 0xF3);
                        break;
                    case 1:
                        door = new GenericHouseDoor(facing, 0x685, 0xEC, 0xF3);
                        break;
                    case 2:
                        door = new GenericHouseDoor(facing, 0x695, 0xEB, 0xF2);
                        break;
                    case 3:
                        door = new GenericHouseDoor(facing, 0x6A5, 0xEA, 0xF1);
                        break;
                    case 4:
                        door = new GenericHouseDoor(facing, 0x6B5, 0xEA, 0xF1);
                        break;
                    case 5:
                        door = new GenericHouseDoor(facing, 0x6C5, 0xEC, 0xF3);
                        break;
                    case 6:
                        door = new GenericHouseDoor(facing, 0x6D5, 0xEA, 0xF1);
                        break;
                    case 7:
                        door = new GenericHouseDoor(facing, 0x6E5, 0xEA, 0xF1);
                        break;
                }
            }
            else if (itemID >= 0x314 && itemID < 0x364)
            {
                int type = (itemID - 0x314) / 16;
                DoorFacing facing = (DoorFacing)(((itemID - 0x314) / 2) % 8);
                door = new GenericHouseDoor(facing, 0x314 + (type * 16), 0xED, 0xF4);
            }
            else if (itemID >= 0x824 && itemID < 0x834)
            {
                DoorFacing facing = (DoorFacing)(((itemID - 0x824) / 2) % 8);
                door = new GenericHouseDoor(facing, 0x824, 0xEC, 0xF3);
            }
            else if (itemID >= 0x839 && itemID < 0x849)
            {
                DoorFacing facing = (DoorFacing)(((itemID - 0x839) / 2) % 8);
                door = new GenericHouseDoor(facing, 0x839, 0xEB, 0xF2);
            }
            else if (itemID >= 0x84C && itemID < 0x85C)
            {
                DoorFacing facing = (DoorFacing)(((itemID - 0x84C) / 2) % 8);
                door = new GenericHouseDoor(facing, 0x84C, 0xEC, 0xF3);
            }
            else if (itemID >= 0x866 && itemID < 0x876)
            {
                DoorFacing facing = (DoorFacing)(((itemID - 0x866) / 2) % 8);
                door = new GenericHouseDoor(facing, 0x866, 0xEB, 0xF2);
            }
            else if (itemID >= 0xE8 && itemID < 0xF8)
            {
                DoorFacing facing = (DoorFacing)(((itemID - 0xE8) / 2) % 8);
                door = new GenericHouseDoor(facing, 0xE8, 0xED, 0xF4);
            }
            else if (itemID >= 0x1FED && itemID < 0x1FFD)
            {
                DoorFacing facing = (DoorFacing)(((itemID - 0x1FED) / 2) % 8);
                door = new GenericHouseDoor(facing, 0x1FED, 0xEC, 0xF3);
            }
            else if (itemID >= 0x241F && itemID < 0x2421)
            {
                //DoorFacing facing = (DoorFacing)(((itemID - 0x241F) / 2) % 8);
                door = new GenericHouseDoor(DoorFacing.NorthCCW, 0x2415, -1, -1);
            }
            else if (itemID >= 0x2423 && itemID < 0x2425)
            {
                //DoorFacing facing = (DoorFacing)(((itemID - 0x241F) / 2) % 8);
                //This one and the above one are 'special' cases, ie: OSI had the ItemID pattern discombobulated for these
                door = new GenericHouseDoor(DoorFacing.WestCW, 0x2423, -1, -1);
            }
            else if (itemID >= 0x2A05 && itemID < 0x2A1D)
            {
                DoorFacing facing = (DoorFacing)((((itemID - 0x2A05) / 2) % 4) + 8);

                int sound = (itemID >= 0x2A0D && itemID < 0x2a15) ? 0x539 : -1;

                door = new GenericHouseDoor(facing, 0x29F5 + (8 * ((itemID - 0x2A05) / 8)), sound, sound);
            }
            else if (itemID == 0x2D46)
            {
                door = new GenericHouseDoor(DoorFacing.NorthCW, 0x2D46, 0xEA, 0xF1, false);
            }
            else if (itemID == 0x2D48 || itemID == 0x2FE2)
            {
                door = new GenericHouseDoor(DoorFacing.SouthCCW, itemID, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x2D63 && itemID < 0x2D70)
            {
                int mod = (itemID - 0x2D63) / 2 % 2;
                DoorFacing facing = ((mod == 0) ? DoorFacing.SouthCCW : DoorFacing.WestCCW);

                int type = (itemID - 0x2D63) / 4;

                door = new GenericHouseDoor(facing, 0x2D63 + 4 * type + mod * 2, 0xEA, 0xF1, false);
            }
            else if (itemID == 0x2FE4 || itemID == 0x31AE)
            {
                door = new GenericHouseDoor(DoorFacing.WestCCW, itemID, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x319C && itemID < 0x31AE)
            {
                //special case for 0x31aa <-> 0x31a8 (a9)
                int mod = (itemID - 0x319C) / 2 % 2;

                //bool specialCase = (itemID == 0x31AA || itemID == 0x31A8);

                DoorFacing facing;

                if (itemID == 0x31AA || itemID == 0x31A8)
                    facing = ((mod == 0) ? DoorFacing.NorthCW : DoorFacing.EastCW);
                else
                    facing = ((mod == 0) ? DoorFacing.EastCW : DoorFacing.NorthCW);

                int type = (itemID - 0x319C) / 4;

                door = new GenericHouseDoor(facing, 0x319C + 4 * type + mod * 2, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x367B && itemID < 0x369B)
            {
                int type = (itemID - 0x367B) / 16;
                DoorFacing facing = (DoorFacing)(((itemID - 0x367B) / 2) % 8);

                switch (type)
                {
                    case 0:
                        door = new GenericHouseDoor(facing, 0x367B, 0xED, 0xF4);
                        break;	//crystal
                    case 1:
                        door = new GenericHouseDoor(facing, 0x368B, 0xEC, 0x3E7);
                        break;	//shadow
                }
            }
            else if (itemID >= 0x409B && itemID < 0x40A3)
            {
                door = new GenericHouseDoor(GetSADoorFacing(itemID - 0x409B), itemID, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x410C && itemID < 0x4114)
            {
                door = new GenericHouseDoor(GetSADoorFacing(itemID - 0x410C), itemID, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x41C2 && itemID < 0x41CA)
            {
                door = new GenericHouseDoor(GetSADoorFacing(itemID - 0x41C2), itemID, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x41CF && itemID < 0x41D7)
            {
                door = new GenericHouseDoor(GetSADoorFacing(itemID - 0x41CF), itemID, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x436E && itemID < 0x437E)
            {
                /* These ones had to be different...
                * Offset		0	2	4	6	8	10	12	14
                * DoorFacing	2	3	2	3	6	7	6	7
                */
                int offset = itemID - 0x436E;
                DoorFacing facing = (DoorFacing)((offset / 2 + 2 * ((1 + offset / 4) % 2)) % 8);
                door = new GenericHouseDoor(facing, itemID, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x46DD && itemID < 0x46E5)
            {
                door = new GenericHouseDoor(GetSADoorFacing(itemID - 0x46DD), itemID, 0xEB, 0xF2, false);
            }
            else if (itemID >= 0x4D22 && itemID < 0x4D2A)
            {
                door = new GenericHouseDoor(GetSADoorFacing(itemID - 0x4D22), itemID, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x50C8 && itemID < 0x50D0)
            {
                door = new GenericHouseDoor(GetSADoorFacing(itemID - 0x50C8), itemID, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x50D0 && itemID < 0x50D8)
            {
                door = new GenericHouseDoor(GetSADoorFacing(itemID - 0x50D0), itemID, 0xEA, 0xF1, false);
            }
            else if (itemID >= 0x5142 && itemID < 0x514A)
            {
                door = new GenericHouseDoor(GetSADoorFacing(itemID - 0x5142), itemID, 0xF0, 0xEF, false);
            }
            else if (itemID >= 0x9AD7 && itemID <= 0x9AE6)
            {
                int type = (itemID - 0x9AD7) / 16;
                DoorFacing facing = (DoorFacing)(((itemID - 0x9AD7) / 2) % 8);
                door = new GenericHouseDoor(facing, 0x9AD7 + (type * 16), 0xED, 0xF4);
            }
            else if (itemID >= 0x9B3C && itemID <= 0x9B4B)
            {
                int type = (itemID - 0x9B3C) / 16;
                DoorFacing facing = (DoorFacing)(((itemID - 0x9B3C) / 2) % 8);
                door = new GenericHouseDoor(facing, 0x9B3C + (type * 16), 0xED, 0xF4);
            }

            if (door != null)
            {
                if (from != null)
                {
                    door.KeyValue = CreateKeys(from);
                }

                AddDoor(door, xOffset, yOffset, zOffset);
            }
            else
            {
                Console.WriteLine("Warning: Unsupported DoorID: {0}", itemID);
            }

            return door;
        }

        private static DoorFacing GetSADoorFacing(int offset)
        {
            /* Offset		0	2	4	6
            * DoorFacing	2	3	6	7
            */
            return (DoorFacing)((offset / 2 + 2 * (1 + offset / 4)) % 8);
        }

        public uint CreateKeys(Mobile m)
        {
            uint value = Key.RandomValue();

            if (!IsAosRules)
            {
                Key packKey = new Key(KeyType.Gold);
                Key bankKey = new Key(KeyType.Gold);

                packKey.KeyValue = value;
                bankKey.KeyValue = value;

                packKey.LootType = LootType.Newbied;
                bankKey.LootType = LootType.Newbied;

                BankBox box = m.BankBox;

                if (!box.TryDropItem(m, bankKey, false))
                    bankKey.Delete();

                m.AddToBackpack(packKey);
            }

            return value;
        }

        public BaseDoor[] AddSouthDoors(int x, int y, int z)
        {
            return AddSouthDoors(true, x, y, z, false);
        }

        public BaseDoor[] AddSouthDoors(bool wood, int x, int y, int z)
        {
            return AddSouthDoors(wood, x, y, z, false);
        }

        public BaseDoor[] AddSouthDoors(bool wood, int x, int y, int z, bool inv)
        {
            BaseDoor westDoor = MakeDoor(wood, inv ? DoorFacing.WestCCW : DoorFacing.WestCW);
            BaseDoor eastDoor = MakeDoor(wood, inv ? DoorFacing.EastCW : DoorFacing.EastCCW);

            westDoor.Link = eastDoor;
            eastDoor.Link = westDoor;

            AddDoor(westDoor, x, y, z);
            AddDoor(eastDoor, x + 1, y, z);

            return new BaseDoor[2] { westDoor, eastDoor };
        }

        public BaseDoor MakeDoor(bool wood, DoorFacing facing)
        {
            if (wood)
                return new DarkWoodHouseDoor(facing);
            else
                return new MetalHouseDoor(facing);
        }

        public void AddDoor(BaseDoor door, int xoff, int yoff, int zoff)
        {
            door.Locked = true;

            door.MoveToWorld(new Point3D(xoff + X, yoff + Y, zoff + Z), Map);
            Doors.Add(door);
        }

        public void AddTrashBarrel(Mobile from)
        {
            if (!IsActive)
                return;

            for (int i = 0; Doors != null && i < Doors.Count; ++i)
            {
                BaseDoor door = Doors[i] as BaseDoor;
                Point3D p = door.Location;

                if (door.Open)
                    p = new Point3D(p.X - door.Offset.X, p.Y - door.Offset.Y, p.Z - door.Offset.Z);

                if ((from.Z + 16) >= p.Z && (p.Z + 16) >= from.Z)
                {
                    if (from.InRange(p, 1))
                    {
                        from.SendLocalizedMessage(502120); // You cannot place a trash barrel near a door or near steps.
                        return;
                    }
                }
            }

            if (m_Trash == null || m_Trash.Deleted)
            {
                m_Trash = new TrashBarrel();

                m_Trash.Movable = false;
                m_Trash.MoveToWorld(from.Location, from.Map);

                from.SendLocalizedMessage(502121); /* You have a new trash barrel.
                * Three minutes after you put something in the barrel, the trash will be emptied.
                * Be forewarned, this is permanent! */
            }
            else
            {
                from.SendLocalizedMessage(502117); // You already have a trash barrel!
            }
        }

        public void SetSign(int xoff, int yoff, int zoff)
        {
            Sign = new HouseSign(this);
            Sign.MoveToWorld(new Point3D(X + xoff, Y + yoff, Z + zoff), Map);
        }

        public void SetLockdown(Item i, bool locked)
        {
            SetLockdown(null, i, locked);
        }

        public void SetLockdown(Mobile m, Item i, bool locked)
        {
            if (LockDowns == null || (locked && LockDowns.ContainsKey(i)) || (!locked && !LockDowns.ContainsKey(i)))
                return;

            if (i is BaseAddonContainer)
                i.Movable = false;
            else
            	i.Movable = !locked;

            i.IsLockedDown = locked;

            if (i is BaseContainer)
            {
                if (!locked)
                {
                    var secure = GetSecureInfoFor(i);

                    if (secure != null)
                        Secures.Remove(secure);
                }
                else
                {
                    Secures.Add(new SecureInfo(i, SecureLevel.Owner, m, true));
                }
            }

            if (m == null)
                m = Owner;

            Timer.DelayCall(() =>
                i.PrivateOverheadMessage(MessageType.Regular, 0, locked ? 501721 : 501657, m.NetState)); // locked down! : [no longer locked down]

            if (locked)
            {
                if (i is VendorRentalContract && i.RootParent == null)
                {
                    if (!VendorRentalContracts.Contains(i))
                        VendorRentalContracts.Add(i);
                }
                else
                {
                    LockDowns[i] = m;
                }
            }
            else
            {
                VendorRentalContracts.Remove(i);
                LockDowns.Remove(i);

                var secure = GetSecureInfoFor(i);

                if (secure != null)
                    Secures.Remove(secure);
            }

            if (!locked)
                i.SetLastMoved();

            if (i is Container && CheckContentsDecay(i))
            {
                foreach (Item c in i.Items)
                    SetLockdown(m, c, locked);
            }
        }

        public bool LockDown(Mobile m, Item item)
        {
            return LockDown(m, item, true);
        }

        public bool LockDown(Mobile m, Item item, bool checkIsInside)
        {
            if (!IsFriend(m) || !IsActive)
                return false;

            if ((item is BaseAddonContainer || item.Movable) && !IsSecure(item))
            {
                int amt = 1 + item.TotalItems;

                Item rootItem = item.RootParent as Item;
                Item parentItem = item.Parent as Item;

                if (checkIsInside && item.RootParent is Mobile)
                {
                    m.SendLocalizedMessage(1005525);//That is not in your house
                }
                else if (checkIsInside && !IsInside(item.GetWorldLocation(), item.ItemData.Height))
                {
                    m.SendLocalizedMessage(1005525);//That is not in your house
                }
                else if (Ethics.Ethic.IsImbued(item))
                {
                    m.SendLocalizedMessage(1005377);//You cannot lock that down
                }
                else if (IsSecure(rootItem))
                {
                    m.SendLocalizedMessage(501737); // You need not lock down items in a secure container.
                }
                else if (parentItem != null && !IsLockedDown(parentItem))
                {
                    m.SendLocalizedMessage(501736); // You must lockdown the container first!
                }
                else if (!(item is VendorRentalContract) && (IsAosRules ? (!CheckAosLockdowns(amt) || !CheckAosStorage(amt)) : (LockDownCount + amt) > MaxLockDowns))
                {
                    m.SendLocalizedMessage(1005379);//That would exceed the maximum lock down limit for this house
                }
                else
                {
                    SetLockdown(m, item, true);
                    return true;
                }
            }
            else if (LockDowns.ContainsKey(item))
            {
                m.LocalOverheadMessage(MessageType.Regular, 0x3E9, 1005526); //That is already locked down
                return true;
            }
            else if (item is HouseSign || item is Static)
            {
                m.LocalOverheadMessage(MessageType.Regular, 0x3E9, 1005526); // This is already locked down.
            }
            else
            {
                m.SendLocalizedMessage(1005377);//You cannot lock that down
            }

            return false;
        }

        private class TransferItem : Item
        {
            private readonly BaseHouse m_House;

            public override string DefaultName
            {
                get
                {
                    return "a house transfer contract";
                }
            }

            public TransferItem(BaseHouse house)
                : base(0x14F0)
            {
                m_House = house;

                Hue = 0x480;
                Movable = false;
            }

            public override void GetProperties(ObjectPropertyList list)
            {
                base.GetProperties(list);

                string houseName, owner, location;

                houseName = (m_House == null ? "an unnamed house" : m_House.Sign.GetName());

                Mobile houseOwner = (m_House == null ? null : m_House.Owner);

                if (houseOwner == null)
                    owner = "nobody";
                else
                    owner = houseOwner.Name;

                int xLong = 0, yLat = 0, xMins = 0, yMins = 0;
                bool xEast = false, ySouth = false;

                bool valid = m_House != null && Sextant.Format(m_House.Location, m_House.Map, ref xLong, ref yLat, ref xMins, ref yMins, ref xEast, ref ySouth);

                if (valid)
                    location = String.Format("{0}° {1}'{2}, {3}° {4}'{5}", yLat, yMins, ySouth ? "S" : "N", xLong, xMins, xEast ? "E" : "W");
                else
                    location = "unknown";

                list.Add(1061112, Utility.FixHtml(houseName)); // House Name: ~1_val~
                list.Add(1061113, owner); // Owner: ~1_val~
                list.Add(1061114, location); // Location: ~1_val~
            }

            public TransferItem(Serial serial)
                : base(serial)
            {
            }

            public override void Serialize(GenericWriter writer)
            {
                base.Serialize(writer);
                writer.Write((int)0); // version
            }

            public override void Deserialize(GenericReader reader)
            {
                base.Deserialize(reader);
                int version = reader.ReadInt();

                Delete();
            }

            public override bool AllowSecureTrade(Mobile from, Mobile to, Mobile newOwner, bool accepted)
            {
                if (!base.AllowSecureTrade(from, to, newOwner, accepted))
                    return false;
                else if (!accepted)
                    return true;

                if (Deleted || m_House == null || m_House.Deleted || !m_House.IsOwner(from) || !from.CheckAlive() || !to.CheckAlive())
                    return false;

                if (AtAccountHouseLimit(to))
                {
                    from.SendLocalizedMessage(501388); // You cannot transfer ownership to another house owner or co-owner!
                    return false;
                }

                return m_House.CheckTransferPosition(from, to);
            }

            public override void OnSecureTrade(Mobile from, Mobile to, Mobile newOwner, bool accepted)
            {
                if (Deleted)
                    return;

                Delete();

                if (m_House == null || m_House.Deleted || !m_House.IsOwner(from) || !from.CheckAlive() || !to.CheckAlive())
                    return;

                if (!accepted)
                    return;

                from.SendLocalizedMessage(501338); // You have transferred ownership of the house.
                to.SendLocalizedMessage(501339); /* You are now the owner of this house.
                * The house's co-owner, friend, ban, and access lists have been cleared.
                * You should double-check the security settings on any doors and teleporters in the house.
                */

                m_House.RemoveKeys(from);
                m_House.Owner = to;
                m_House.Bans.Clear();
                m_House.Friends.Clear();
                m_House.CoOwners.Clear();
                m_House.ChangeLocks(to);
                m_House.LastTraded = DateTime.UtcNow;

                m_House.OnTransfer();
            }
        }

        public bool CheckTransferPosition(Mobile from, Mobile to)
        {
            bool isValid = true;
            Item sign = Sign;
            Point3D p = (sign == null ? Point3D.Zero : sign.GetWorldLocation());

            if (from.Map != Map || to.Map != Map)
                isValid = false;
            else if (sign == null)
                isValid = false;
            else if (from.Map != sign.Map || to.Map != sign.Map)
                isValid = false;
            else if (IsInside(from))
                isValid = false;
            else if (IsInside(to))
                isValid = false;
            else if (!from.InRange(p, 2))
                isValid = false;
            else if (!to.InRange(p, 2))
                isValid = false;

            if (!isValid)
                from.SendLocalizedMessage(1062067); // In order to transfer the house, you and the recipient must both be outside the building and within two paces of the house sign.

            return isValid;
        }

        public void BeginConfirmTransfer(Mobile from, Mobile to)
        {
            if (Deleted || !from.CheckAlive() || !IsOwner(from))
                return;

            if (NewVendorSystem && HasPersonalVendors)
            {
                from.SendLocalizedMessage(1062467); // You cannot trade this house while you still have personal vendors inside.
            }
            else if (DecayLevel == DecayLevel.DemolitionPending)
            {
                from.SendLocalizedMessage(1005321); // This house has been marked for demolition, and it cannot be transferred.
            }
            else if (from == to)
            {
                from.SendLocalizedMessage(1005330); // You cannot transfer a house to yourself, silly.
            }
            else if (to.Player)
            {
                if (AtAccountHouseLimit(to))
                {
                    from.SendLocalizedMessage(501388); // You cannot transfer ownership to another house owner or co-owner!
                }
                else if (CheckTransferPosition(from, to))
                {
                    from.SendLocalizedMessage(1005326); // Please wait while the other player verifies the transfer.

                    if (HasRentedVendors)
                    {
                        /* You are about to be traded a home that has active vendor contracts.
                        * While there are active vendor contracts in this house, you
                        * <strong>cannot</strong> demolish <strong>OR</strong> customize the home.
                        * When you accept this house, you also accept landlordship for every
                        * contract vendor in the house.
                        */
                        to.SendGump(new WarningGump(1060635, 30720, 1062487, 32512, 420, 280, new WarningGumpCallback(ConfirmTransfer_Callback), from));
                    }
                    else
                    {
                        to.CloseGump(typeof(HouseTransferGump));
                        to.SendGump(new HouseTransferGump(from, to, this));
                    }
                }
            }
            else
            {
                from.SendLocalizedMessage(501384); // Only a player can own a house!
            }
        }

        private void ConfirmTransfer_Callback(Mobile to, bool ok, object state)
        {
            Mobile from = (Mobile)state;

            if (!ok || Deleted || !from.CheckAlive() || !IsOwner(from))
                return;

            if (CheckTransferPosition(from, to))
            {
                to.CloseGump(typeof(HouseTransferGump));
                to.SendGump(new HouseTransferGump(from, to, this));
            }
        }

        public void EndConfirmTransfer(Mobile from, Mobile to)
        {
            if (Deleted || !from.CheckAlive() || !IsOwner(from))
                return;

            if (NewVendorSystem && HasPersonalVendors)
            {
                from.SendLocalizedMessage(1062467); // You cannot trade this house while you still have personal vendors inside.
            }
            else if (DecayLevel == DecayLevel.DemolitionPending)
            {
                from.SendLocalizedMessage(1005321); // This house has been marked for demolition, and it cannot be transferred.
            }
            else if (from == to)
            {
                from.SendLocalizedMessage(1005330); // You cannot transfer a house to yourself, silly.
            }
            else if (to.Player)
            {
                if (AtAccountHouseLimit(to))
                {
                    from.SendLocalizedMessage(501388); // You cannot transfer ownership to another house owner or co-owner!
                }
                else if (CheckTransferPosition(from, to))
                {
                    NetState fromState = from.NetState, toState = to.NetState;

                    if (fromState != null && toState != null)
                    {
                        if (from.HasTrade)
                        {
                            from.SendLocalizedMessage(1062071); // You cannot trade a house while you have other trades pending.
                        }
                        else if (to.HasTrade)
                        {
                            to.SendLocalizedMessage(1062071); // You cannot trade a house while you have other trades pending.
                        }
                        else if (!to.Alive)
                        {
                            // TODO: Check if the message is correct.
                            from.SendLocalizedMessage(1062069); // You cannot transfer this house to that person.
                        }
                        else
                        {
                            Container c = fromState.AddTrade(toState);

                            c.DropItem(new TransferItem(this));
                        }
                    }
                }
            }
            else
            {
                from.SendLocalizedMessage(501384); // Only a player can own a house!
            }
        }

        public virtual void OnTransfer()
        {
            foreach (var vendor in PlayerVendors.OfType<RentedVendor>())
            {
                vendor.RenterRenew = false;
                vendor.LandlordRenew = false;
            }
        }

        public void OnCondemned()
        {
            foreach (var vendor in PlayerVendors.OfType<RentedVendor>())
            {
                string name = Sign == null || Sign.Name == null ? "An Unnamed House" : Sign.Name;

                var message = new NewMaginciaMessage(null, new TextDefinition(1154338), string.Format("{0}\t{1}", vendor.ShopName, name));
                /* Your rental vendor named ~1_VENDOR~ located in house: ~2_HOUSE~ is in danger of deletion. 
                 * This house has been condemned and you should remove everything on your vendor AS SOON AS 
                 * POSSIBLE or risk possible deletion.*/

                MaginciaLottoSystem.SendMessageTo(vendor.Owner, message);
            }
        }

        public bool CheckLockdownOwnership(Mobile m, Item item)
        {
            if(item == null)
                return false;

            if(IsOwner(m))
                return true;

            if(item is BaseContainer || item.Parent is BaseContainer)
            {
                Item check = item.Parent is BaseContainer ? (Item)item.Parent : item;

                return Secures.FirstOrDefault(i => i.Item == check && HasSecureAccess(m, i)) != null;
            }

            return LockDowns.ContainsKey(item) && IsSameAccount(m, LockDowns[item]);
        }

        public bool IsSameAccount(Mobile one, Mobile two)
        {
            if (one == null || two == null)
                return false;

            if (one == two)
                return true;

            Account acct = one.Account as Account;

            for (int i = 0; i < acct.Length; ++i)
            {
                if (acct[i] != null && acct[i] == two)
                    return true;
            }

            return false;
        }

        public bool Release(Mobile m, Item item)
        {
            if (!IsFriend(m) || !IsActive)
                return false;

            if (IsLockedDown(item))
            {
                if (!CheckLockdownOwnership(m, item))
                {
                    m.LocalOverheadMessage(MessageType.Regular, 0x3E9, 1010418); // You did not lock this down, and you are not able to release this.
                }
                else if (CanRelease(m, item))
                {
                    SetLockdown(m, item, false);

                    if (item is RewardBrazier)
                        ((RewardBrazier)item).TurnOff();

                    return true;
                }

                return false;
            }
            else if (IsSecure(item))
            {
                return ReleaseSecure(m, item);
            }
            else
            {
                m.LocalOverheadMessage(MessageType.Regular, 0x3E9, 1010416); // This is not locked down or secured.
            }

            return false;
        }

        public void AddSecure(Mobile m, Item item)
        {
            if (Secures == null || !IsCoOwner(m) || !IsActive)
                return;

            if (!IsInside(item))
            {
                m.SendLocalizedMessage(1005525); // That is not in your house
            }
            else if (IsLockedDown(item))
            {
                m.SendLocalizedMessage(1010550); // This is already locked down and cannot be secured.
            }
            else if (!(item is Container) || item is BaseSpecialScrollBook)
            {
                LockDown(m, item);
            }
            else
            {
                SecureInfo info = null;

                for (int i = 0; info == null && i < Secures.Count; ++i)
                    if (((SecureInfo)Secures[i]).Item == item)
                        info = (SecureInfo)Secures[i];

                if (info != null)
                {
                    m.CloseGump(typeof (SetSecureLevelGump));
                    m.SendGump(new SetSecureLevelGump(m, info, this));
                }
                else if (item.Parent != null)
                {
                    m.SendLocalizedMessage(1010423); // You cannot secure this, place it on the ground first.
                }
                // Mondain's Legacy mod
                else if (!(item is BaseAddonContainer) && !item.Movable)
                {
                    m.SendLocalizedMessage(1010424); // You cannot secure 
                }
                else if (!IsAosRules && SecureCount >= MaxSecures)
                {
                    // The maximum number of secure items has been reached :
                    m.SendLocalizedMessage(1008142, true, MaxSecures.ToString());
                }
                else if (IsAosRules ? !CheckAosLockdowns(1) : ((LockDownCount + 125) >= MaxLockDowns))
                {
                    m.SendLocalizedMessage(1005379); // That would exceed the maximum lock down limit for this house
                }
                else if (IsAosRules && !CheckAosStorage(item.TotalItems))
                {
                    m.SendLocalizedMessage(1061839); // This action would exceed the secure storage limit of the house.
                }
                else
                {
                    info = new SecureInfo((Container)item, SecureLevel.Owner, m);

                    item.IsLockedDown = false;
                    item.IsSecure = true;

                    Secures.Add(info);

                    if(LockDowns.ContainsKey(item))
                        LockDowns.Remove(item);

                    item.Movable = false;

                    if (item is GardenShedAddon)
                    {
                        GardenShedBarrel ad = ((GardenShedAddon)item).SecondContainer as GardenShedBarrel;

                        SecureInfo info2 = new SecureInfo((Container)ad, SecureLevel.Owner, m);

                        ad.IsLockedDown = false;
                        ad.IsSecure = true;

                        Secures.Add(info2);

                        if (LockDowns.ContainsKey(ad))
                            LockDowns.Remove(ad);

                        ad.Movable = false;
                    }

                    m.CloseGump(typeof (SetSecureLevelGump));
                    m.SendGump(new SetSecureLevelGump(m, info, this));
                }
            }
        }

        public virtual bool IsCombatRestricted(Mobile m)
        {
            if (m == null || !m.Player || m.AccessLevel >= AccessLevel.GameMaster || !IsAosRules || (m_Owner != null && m_Owner.AccessLevel >= AccessLevel.GameMaster))
                return false;

            for (int i = 0; i < m.Aggressed.Count; ++i)
            {
                AggressorInfo info = m.Aggressed[i];

                Guild attackerGuild = m.Guild as Guild;
                Guild defenderGuild = info.Defender.Guild as Guild;

                if (info.Defender.Player && info.Defender.Alive && (DateTime.UtcNow - info.LastCombatTime) < HouseRegion.CombatHeatDelay && (attackerGuild == null || defenderGuild == null || defenderGuild != attackerGuild && !defenderGuild.IsEnemy(attackerGuild)))
                    return true;
            }

            return false;
        }

        public bool HasSecureAccess(Mobile m, SecureInfo info)
        {
            if (info.Owner == m)
                return true;

            return HasSecureAccess(m, info.Level);
        }

        public bool HasSecureAccess(Mobile m, SecureLevel level)
        {
            if (m.AccessLevel >= AccessLevel.GameMaster)
                return true;

            if (IsCombatRestricted(m))
                return false;

            switch (level)
            {
                case SecureLevel.Owner:
                    return IsOwner(m);
                case SecureLevel.CoOwners:
                    return IsCoOwner(m);
                case SecureLevel.Friends:
                    return IsFriend(m);
                case SecureLevel.Anyone:
                    return true;
                case SecureLevel.Guild:
                    return IsGuildMember(m) | IsOwner(m);
            }

            return false;
        }

        public SecureLevel GetSecureAccess(Mobile m)
        {
            if (IsOwner(m) || m.AccessLevel > AccessLevel.Player)
                return SecureLevel.Owner;

            if (IsCoOwner(m))
                return SecureLevel.CoOwners;

            if (IsFriend(m))
                return SecureLevel.Friends;

            if (IsGuildMember(m))
                return SecureLevel.Guild;

            return SecureLevel.Anyone;
        }

        public SecureInfo GetSecureInfoFor(Item item)
        {
            return Secures.FirstOrDefault(info => info.Item == item);
        }

        public SecureInfo GetSecureInfoFor(Mobile from, Item item)
        {
            return Secures.FirstOrDefault(info => info.Item == item && (info.Owner == from || IsOwner(from)));
        }

        public List<SecureInfo> GetSecureInfosFor(Mobile from)
        {
            return Secures.Where(s => s.Owner == from).ToList();
        }

        public bool ReleaseSecure(Mobile m, Item item)
        {
            if (Secures == null || item is StrongBox || !IsActive || !CanRelease(m, item))
                return false;

            var info = GetSecureInfoFor(item);

            if (info != null)
            {
                if ((IsOwner(m) || info.Owner == m) /*&& HasSecureAccess(m, info.Level)*/)
                {
                    item.IsLockedDown = false;
                    item.IsSecure = false;

                    if (item is BaseAddonContainer)
                        item.Movable = false;
                    else
                        item.Movable = true;

                    item.SetLastMoved();
                    item.PublicOverheadMessage(MessageType.Label, 0x3B2, 501656); // [no longer secure]

                    Secures.Remove(info);

                    return true;
                }
                else
                {
                    m.LocalOverheadMessage(MessageType.Regular, 0x3E9, 1010418); // You did not lock this down, and you are not able to release this.
                }

                return false;
            }

            m.SendLocalizedMessage(501717); //This isn't secure...

            return false;
        }

        private bool CanRelease(Mobile from, Item item)
        {
            if (item is Container && item.Items.Any(i => i is CraftableHouseItem || i is CraftableMetalHouseDoor || i is CraftableStoneHouseDoor))
            {
                from.SendLocalizedMessage(1010417); // You may not release this at this time.
                return false;
            }

            return true;
        }

        public override bool Decays { get { return false; } }

        public void AddStrongBox(Mobile from)
        {
            if (!IsCoOwner(from) || !IsActive)
                return;

            if (from == Owner)
            {
                from.SendLocalizedMessage(502109); // Owners don't get a strong box
                return;
            }

            if (IsAosRules ? !CheckAosLockdowns(1) : ((LockDownCount + 1) > MaxLockDowns))
            {
                from.SendLocalizedMessage(1005379);//That would exceed the maximum lock down limit for this house
                return;
            }

            foreach (SecureInfo info in Secures)
            {
                StrongBox c = info.Item as StrongBox;

                if (c != null && !c.Deleted && c.Owner == from)
                {
                    from.SendLocalizedMessage(502112);//You already have a strong box
                    return;
                }
            }

            for (int i = 0; Doors != null && i < Doors.Count; ++i)
            {
                BaseDoor door = Doors[i] as BaseDoor;
                Point3D p = door.Location;

                if (door.Open)
                    p = new Point3D(p.X - door.Offset.X, p.Y - door.Offset.Y, p.Z - door.Offset.Z);

                if ((from.Z + 16) >= p.Z && (p.Z + 16) >= from.Z)
                {
                    if (from.InRange(p, 1))
                    {
                        from.SendLocalizedMessage(502113); // You cannot place a strongbox near a door or near steps.
                        return;
                    }
                }
            }

            StrongBox sb = new StrongBox(from, this);
            sb.Movable = false;
            sb.IsLockedDown = false;
            sb.IsSecure = true;
            Secures.Add(new SecureInfo(sb, SecureLevel.CoOwners, from));
            sb.MoveToWorld(from.Location, from.Map);
        }

        public void Kick(Mobile from, Mobile targ)
        {
            if (!IsFriend(from) || Friends == null)
                return;

            if (targ.IsStaff() && from.AccessLevel <= targ.AccessLevel)
            {
                from.SendLocalizedMessage(501346); // Uh oh...a bigger boot may be required!
            }
            else if (IsFriend(targ) && !Core.ML)
            {
                from.SendLocalizedMessage(501348); // You cannot eject a friend of the house!
            }
            else if (targ is PlayerVendor)
            {
                from.SendLocalizedMessage(501351); // You cannot eject a vendor.
            }
            else if (!IsInside(targ))
            {
                from.SendLocalizedMessage(501352); // You may not eject someone who is not in your house!
            }
            else if (targ is BaseCreature && ((BaseCreature)targ).NoHouseRestrictions)
            {
                from.SendLocalizedMessage(501347); // You cannot eject that from the house!
            }
            else
            {
                targ.MoveToWorld(BanLocation, Map);

                from.SendLocalizedMessage(1042840, targ.Name); // ~1_PLAYER NAME~ has been ejected from this house.
                targ.SendLocalizedMessage(501341); /* You have been ejected from this house.
                * If you persist in entering, you may be banned from the house.
                */
            }
        }

        public void RemoveAccess(Mobile from, Mobile targ)
        {
            if (!IsFriend(from) || Access == null)
                return;

            if (Access.Contains(targ))
            {
                Access.Remove(targ);

                if (!HasAccess(targ) && IsInside(targ))
                {
                    targ.Location = BanLocation;
                    targ.SendLocalizedMessage(1060734); // Your access to this house has been revoked.
                }

                from.SendLocalizedMessage(1050051); // The invitation has been revoked.
            }
        }

        public void RemoveBan(Mobile from, Mobile targ)
        {
            if (!IsCoOwner(from) || Bans == null)
                return;

            if (Bans.Contains(targ))
            {
                Bans.Remove(targ);

                from.SendLocalizedMessage(501297); // The ban is lifted.
            }
        }

        public void Ban(Mobile from, Mobile targ)
        {
            if (!IsFriend(from) || Bans == null)
                return;

            if (targ.IsStaff() && from.AccessLevel <= targ.AccessLevel)
            {
                from.SendLocalizedMessage(501354); // Uh oh...a bigger boot may be required.
            }
            else if (IsFriend(targ))
            {
                from.SendLocalizedMessage(501348); // You cannot eject a friend of the house!
            }
            else if (targ is PlayerVendor)
            {
                from.SendLocalizedMessage(501351); // You cannot eject a vendor.
            }
            else if (Bans.Count >= MaxBans)
            {
                from.SendLocalizedMessage(501355); // The ban limit for this house has been reached!
            }
            else if (IsBanned(targ))
            {
                from.SendLocalizedMessage(501356); // This person is already banned!
            }
            else if (!IsInside(targ))
            {
                from.SendLocalizedMessage(501352); // You may not eject someone who is not in your house!
            }
            else if (!Public && IsAosRules)
            {
                from.SendLocalizedMessage(1062521); // You cannot ban someone from a private house.  Revoke their access instead.
            }
            else if (targ is BaseCreature && ((BaseCreature)targ).NoHouseRestrictions)
            {
                from.SendLocalizedMessage(1062040); // You cannot ban that.
            }
            else
            {
                Bans.Add(targ);

                from.SendLocalizedMessage(1042839, targ.Name); // ~1_PLAYER_NAME~ has been banned from this house.
                targ.SendLocalizedMessage(501340); // You have been banned from this house.

                targ.MoveToWorld(BanLocation, Map);
            }
        }

        public void GrantAccess(Mobile from, Mobile targ)
        {
            if (!IsFriend(from) || Access == null)
                return;

            if (HasAccess(targ))
            {
                from.SendLocalizedMessage(1060729); // That person already has access to this house.
            }
            else if (!targ.Player)
            {
                from.SendLocalizedMessage(1060712); // That is not a player.
            }
            else if (IsBanned(targ))
            {
                from.SendLocalizedMessage(501367); // This person is banned!  Unban them first.
            }
            else
            {
                Access.Add(targ);

                targ.SendLocalizedMessage(1060735); // You have been granted access to this house.
            }
        }

        public void AddCoOwner(Mobile from, Mobile targ)
        {
            if (!IsOwner(from) || CoOwners == null || Friends == null)
                return;

            if (IsOwner(targ))
            {
                from.SendLocalizedMessage(501360); // This person is already the house owner!
            }
            else if (Friends.Contains(targ))
            {
                from.SendLocalizedMessage(501361); // This person is a friend of the house. Remove them first.
            }
            else if (!targ.Player)
            {
                from.SendLocalizedMessage(501362); // That can't be a co-owner of the house.
            }
            else if (IsBanned(targ))
            {
                from.SendLocalizedMessage(501367); // This person is banned!  Unban them first.
            }
            else if (CoOwners.Count >= MaxCoOwners)
            {
                from.SendLocalizedMessage(501368); // Your co-owner list is full!
            }
            else if (CoOwners.Contains(targ))
            {
                from.SendLocalizedMessage(501369); // This person is already on your co-owner list!
            }
            else
            {
                AddCoOwner(targ);

                targ.Delta(MobileDelta.Noto);
                targ.SendLocalizedMessage(501343); // You have been made a co-owner of this house.
            }
        }

        public void AddCoOwner(Mobile targ)
        {
            CoOwners.Add(targ);

            List<Mobile> remove = new List<Mobile>();
            
            foreach(Mobile m in CoOwners)
            {
                if (AccountHandler.CheckAccount(m, targ) && m != targ)
                    remove.Add(m);
            }

            foreach (Mobile m in remove)
                CoOwners.Remove(m);

            remove.Clear();

            foreach (Mobile m in Friends)
            {
                if (AccountHandler.CheckAccount(m, targ))
                    remove.Add(m);
            }

            foreach (Mobile m in remove)
                Friends.Remove(m);

            remove.Clear();
            remove.TrimExcess();
        }

        public void RemoveCoOwner(Mobile from, Mobile targ)
        {
            RemoveCoOwner(from, targ, true);
        }

        public void RemoveCoOwner(Mobile from, Mobile targ, bool fromMessage)
        {
            if (!IsOwner(from) || CoOwners == null)
                return;

            if (CoOwners.Contains(targ))
            {
                CoOwners.Remove(targ);

                targ.Delta(MobileDelta.Noto);

                if(fromMessage)
                    from.SendLocalizedMessage(501299); // Co-owner removed from list.

                targ.SendLocalizedMessage(501300); // You have been removed as a house co-owner.

                var infos = GetSecureInfosFor(targ);

                foreach (var info in infos)
                {
                    if (info.Item is StrongBox)
                    {
                        StrongBox c = info.Item as StrongBox;

                        c.IsLockedDown = false;
                        c.IsSecure = false;
                        c.Destroy();

                        Secures.Remove(info);
                    }
                    else
                    {
                        info.Owner = from;
                    }
                }
            }
        }

        public void AddFriend(Mobile from, Mobile targ)
        {
            if (!IsCoOwner(from) || Friends == null || CoOwners == null)
                return;

            if (IsOwner(targ))
            {
                from.SendLocalizedMessage(501370); // This person is already an owner of the house!
            }
            else if (CoOwners.Contains(targ))
            {
                from.SendLocalizedMessage(501369); // This person is already on your co-owner list!
            }
            else if (!targ.Player)
            {
                from.SendLocalizedMessage(501371); // That can't be a friend of the house.
            }
            else if (IsBanned(targ))
            {
                from.SendLocalizedMessage(501374); // This person is banned!  Unban them first.
            }
            else if (Friends.Count >= MaxFriends)
            {
                from.SendLocalizedMessage(501375); // Your friends list is full!
            }
            else if (Friends.Contains(targ))
            {
                from.SendLocalizedMessage(501376); // This person is already on your friends list!
            }
            else
            {
                Friends.Add(targ);

                targ.Delta(MobileDelta.Noto);
                targ.SendLocalizedMessage(501337); // You have been made a friend of this house.
            }
        }

        public void RemoveFriend(Mobile from, Mobile targ)
        {
            RemoveFriend(from, targ, true);
        }

        public void RemoveFriend(Mobile from, Mobile targ, bool fromMessage)
        {
            if (!IsCoOwner(from) || Friends == null)
                return;

            if (Friends.Contains(targ))
            {
                Friends.Remove(targ);

                targ.Delta(MobileDelta.Noto);

                if(fromMessage)
                    from.SendLocalizedMessage(501298); // Friend removed from list.

                targ.SendLocalizedMessage(1060751); // You are no longer a friend of this house.

                var infos = GetSecureInfosFor(targ);

                foreach (var info in infos)
                {
                    info.Owner = from;
                }
            }
        }

        public override void Serialize(GenericWriter writer)
        {
            base.Serialize(writer);
            writer.Write((int)22); // version

            writer.Write((int)_CurrentDecay);

            writer.WriteItemList(Carpets, true);

            if (!DynamicDecay.Enabled)
            {
                writer.Write((int)-1);
            }
            else
            {
                writer.Write((int)m_CurrentStage);
                writer.Write(NextDecayStage);
            }

            writer.Write((Point3D)m_RelativeBanLocation);

            writer.WriteItemList(VendorRentalContracts, true);
            writer.WriteMobileList(InternalizedVendors, true);

            writer.WriteEncodedInt(RelocatedEntities.Count);
            foreach (RelocatedEntity relEntity in RelocatedEntities)
            {
                writer.Write(relEntity.Owner);
                writer.Write((Point3D)relEntity.RelativeLocation);

                if ((relEntity.Entity is Item && ((Item)relEntity.Entity).Deleted) || (relEntity.Entity is Mobile && ((Mobile)relEntity.Entity).Deleted))
                    writer.Write((int)Serial.MinusOne);
                else
                    writer.Write((int)relEntity.Entity.Serial);
            }

            writer.WriteEncodedInt(VendorInventories.Count);
            for (int i = 0; i < VendorInventories.Count; i++)
            {
                VendorInventory inventory = VendorInventories[i];
                inventory.Serialize(writer);
            }

            writer.Write((DateTime)LastRefreshed);
            writer.Write((bool)RestrictDecay);

            writer.Write(Visits.Count);
            foreach (var kvp in Visits)
            {
                writer.Write(kvp.Key);
                writer.Write(kvp.Value);
            }

            writer.Write((int)Price);

            writer.WriteMobileList(Access);

            writer.Write(BuiltOn);
            writer.Write(LastTraded);

            //writer.WriteItemList(m_Addons, true);
            writer.Write(Addons.Count);
            foreach (var kvp in Addons)
            {
                writer.Write(kvp.Key);
                writer.Write(kvp.Value);
            }

            writer.Write(Secures.Count);

            for (int i = 0; i < Secures.Count; ++i)
                ((SecureInfo)Secures[i]).Serialize(writer);

            writer.Write(m_Public);

            writer.Write(m_Owner);

            writer.WriteMobileList(CoOwners, true);
            writer.WriteMobileList(Friends, true);
            writer.WriteMobileList(Bans, true);

            writer.Write(Sign);
            writer.Write(m_Trash);

            writer.WriteItemList(Doors, true);

            writer.Write(LockDowns.Count);
            ColUtility.ForEach(LockDowns, (key, value) =>
                {
                    writer.Write(key);
                    writer.Write(value);
                });

            writer.Write((int)MaxLockDowns);
            writer.Write((int)MaxSecures);

            // Items in locked down containers that aren't locked down themselves must decay!
            foreach(KeyValuePair<Item, Mobile> kvp in LockDowns)
            {
                Item item = kvp.Key;

                if (item is Container && CheckContentsDecay(item))
                {
                    Container cont = (Container)item;
                    List<Item> children = cont.Items;

                    for (int j = 0; j < children.Count; ++j)
                    {
                        Item child = children[j];

                        if (child.Decays && !child.IsLockedDown && !child.IsSecure && (child.LastMoved + child.DecayTime) <= DateTime.UtcNow)
                            Timer.DelayCall(TimeSpan.Zero, new TimerCallback(child.Delete));
                    }
                }
            }
        }

        public override void Deserialize(GenericReader reader)
        {
            base.Deserialize(reader);
            int version = reader.ReadInt();

            int count;
            bool loadedDynamicDecay = false;

            Visits = new Dictionary<Mobile, DateTime>();

            if (version < 21)
            {
                SecureInfo.VersionInsertion = true;
            }

            switch (version)
            {
                case 22:
                    {
                        _CurrentDecay = (DecayType)reader.ReadInt();
                        goto case 21;
                    }
                case 21: // version 21, version insertion for secureinfo
                case 20: // version 20, Addons resulted in version 18 bug added to dictionary
                case 19: // version 19, Visit change to dictionary
                case 18: // version 18, converted addons list to dictionary
                case 17:
                    {
                        Carpets = reader.ReadStrongItemList();
                        goto case 16;
                    }
                case 16: // version 16, converted lockdown list to dictionary
                case 15:
                    {
                        int stage = reader.ReadInt();

                        if (stage != -1)
                        {
                            m_CurrentStage = (DecayLevel)stage;
                            NextDecayStage = reader.ReadDateTime();
                            loadedDynamicDecay = true;
                        }

                        goto case 14;
                    }
                case 14:
                    {
                        m_RelativeBanLocation = reader.ReadPoint3D();
                        goto case 13;
                    }
                case 13: // removed ban location serialization
                case 12:
                    {
                        VendorRentalContracts = reader.ReadStrongItemList();
                        InternalizedVendors = reader.ReadStrongMobileList();

                        int relocatedCount = reader.ReadEncodedInt();
                        for (int i = 0; i < relocatedCount; i++)
                        {
                            Mobile m;

                            if (version > 15)
                                m = reader.ReadMobile();
                            else
                                m = Owner;

                            Point3D relLocation = reader.ReadPoint3D();
                            IEntity entity = World.FindEntity(reader.ReadInt());

                            if (entity != null)
                                RelocatedEntities.Add(new RelocatedEntity(entity, relLocation, m));
                        }

                        int inventoryCount = reader.ReadEncodedInt();
                        for (int i = 0; i < inventoryCount; i++)
                        {
                            VendorInventory inventory = new VendorInventory(this, reader);
                            VendorInventories.Add(inventory);
                        }

                        goto case 11;
                    }
                case 11:
                    {
                        LastRefreshed = reader.ReadDateTime();
                        RestrictDecay = reader.ReadBool();
                        goto case 10;
                    }
                case 10: // just a signal for updates
                case 9:
                    {
                        if (version <= 18)
                        {
                            reader.ReadInt();
                        }
                        else
                        {
                            int c = reader.ReadInt();
                            for (int i = 0; i < c; i++)
                            {
                                Mobile visitor = reader.ReadMobile();
                                DateTime lastVisit = reader.ReadDateTime();

                                if (visitor != null)
                                    Visits[visitor] = lastVisit;
                            }
                        }
                        goto case 8;
                    }
                case 8:
                    {
                        Price = reader.ReadInt();
                        goto case 7;
                    }
                case 7:
                    {
                        Access = reader.ReadStrongMobileList();
                        goto case 6;
                    }
                case 6:
                    {
                        BuiltOn = reader.ReadDateTime();
                        LastTraded = reader.ReadDateTime();
                        goto case 5;
                    }
                case 5: // just removed fields
                case 4:
                    {
                        Addons = new Dictionary<Item, Mobile>();

                        if (version < 18)
                        {
                            var list = reader.ReadStrongItemList();
                            foreach (var item in list)
                            {
                                Addons[item] = Owner;
                            }
                        }
                        else
                        {
                            int c = reader.ReadInt();
                            for (int i = 0; i < c; i++)
                            {
                                var item = reader.ReadItem();
                                var mob = reader.ReadMobile();

                                if (item != null)
                                {
                                    Addons[item] = mob != null ? mob : Owner;
                                }
                            }
                        }
                        goto case 3;
                    }
                case 3:
                    {
                        count = reader.ReadInt();
                        Secures = new List<SecureInfo>(count);

                        for (int i = 0; i < count; ++i)
                        {
                            SecureInfo info = new SecureInfo(reader);

                            if (info.Item != null)
                            {
                                info.Item.IsSecure = info.IsLockdown ? false : true;
                                Secures.Add(info);
                            }
                        }

                        goto case 2;
                    }
                case 2:
                    {
                        m_Public = reader.ReadBool();
                        goto case 1;
                    }
                case 1:
                    {
                        if (version < 13)
                            reader.ReadPoint3D(); // house ban location
                        goto case 0;
                    }
                case 0:
                    {
                        if (version < 17)
                            Carpets = new List<Item>();

                        if (version < 14)
                            m_RelativeBanLocation = BaseBanLocation;

                        if (version < 12)
                        {
                            VendorRentalContracts = new List<Item>();
                            InternalizedVendors = new List<Mobile>();
                        }

                        if (version < 4)
                            Addons = new Dictionary<Item, Mobile>();

                        if (version < 7)
                            Access = new List<Mobile>();

                        if (version < 8)
                            Price = DefaultPrice;

                        m_Owner = reader.ReadMobile();

                        if (version < 5)
                        {
                            count = reader.ReadInt();

                            for (int i = 0; i < count; i++)
                                reader.ReadRect2D();
                        }

                        UpdateRegion();

                        CoOwners = reader.ReadStrongMobileList();
                        Friends = reader.ReadStrongMobileList();
                        Bans = reader.ReadStrongMobileList();

                        Sign = reader.ReadItem() as HouseSign;
                        m_Trash = reader.ReadItem() as TrashBarrel;

                        Doors = reader.ReadStrongItemList();

                        LockDowns = new Dictionary<Item, Mobile>();

                        if (version < 16)
                        {
                            List<Item> list = reader.ReadStrongItemList();

                            foreach (Item item in list)
                            {
                                item.IsLockedDown = true;
                                LockDowns[item] = Owner;
                            }
                        }
                        else
                        {
                            int c = reader.ReadInt();
                            for (int i = 0; i < c; i++)
                            {
                                Item item = reader.ReadItem();
                                Mobile m = reader.ReadMobile();

                                if (item != null)
                                {
                                    item.IsLockedDown = true;
                                    LockDowns[item] = m != null ? m : Owner;
                                }
                            }
                        }

                        for (int i = 0; i < VendorRentalContracts.Count; ++i)
                            ((Item)VendorRentalContracts[i]).IsLockedDown = true;

                        if (version < 3)
                        {
                            List<Item> items = reader.ReadStrongItemList();
                            Secures = new List<SecureInfo>(items.Count);

                            for (int i = 0; i < items.Count; ++i)
                            {
                                Container c = items[i] as Container;

                                if (c != null)
                                {
                                    c.IsSecure = true;
                                    Secures.Add(new SecureInfo(c, SecureLevel.CoOwners, Owner));
                                }
                            }
                        }

                        MaxLockDowns = reader.ReadInt();
                        MaxSecures = reader.ReadInt();

                        if ((Map == null || Map == Map.Internal) && Location == Point3D.Zero)
                            Delete();

                        if (m_Owner != null)
                        {
                            List<BaseHouse> list = null;
                            m_Table.TryGetValue(m_Owner, out list);

                            if (list == null)
                                m_Table[m_Owner] = list = new List<BaseHouse>();

                            list.Add(this);
                        }
                        break;
                    }
            }

            if (version <= 1)
                ChangeSignType(0xBD2);//private house, plain brass sign

            if (version < 10)
            {
                /* NOTE: This can exceed the house lockdown limit. It must be this way, because
                * we do not want players' items to decay without them knowing. Or not even
                * having a chance to fix it themselves.
                */
                Timer.DelayCall(TimeSpan.Zero, new TimerCallback(FixLockdowns_Sandbox));
            }

            if (version < 11)
                LastRefreshed = DateTime.UtcNow + TimeSpan.FromHours(24 * Utility.RandomDouble());

            if (DynamicDecay.Enabled && !loadedDynamicDecay)
            {
                DecayLevel old = GetOldDecayLevel();

                if (old == DecayLevel.DemolitionPending)
                    old = DecayLevel.Collapsed;

                SetDynamicDecay(old);
            }

            if (!CheckDecay())
            {
                if (RelocatedEntities.Count > 0)
                    Timer.DelayCall(TimeSpan.Zero, new TimerCallback(RestoreRelocatedEntities));

                //if (m_Owner == null && m_Friends.Count == 0 && m_CoOwners.Count == 0)
                //    Timer.DelayCall(TimeSpan.FromSeconds(10.0), new TimerCallback(Delete));
            }

            if (version == 19)
            {
                Timer.DelayCall(CheckUnregisteredAddons);
            }
        }

        private void CheckUnregisteredAddons()
        {
            if (Region == null || Addons == null)
                return;

            foreach (var item in Region.GetEnumeratedItems().Where(i => i is IAddon))
            {
                if(Addons.ContainsKey(item))
                    continue;

                Addons[item] = Owner;
            }

            foreach (var item in Region.GetEnumeratedItems().Where(i => i is AddonComponent && ((AddonComponent)i).Addon == null))
            {
                item.Delete();
            }
        }

        private void FixLockdowns_Sandbox()
        {
            Dictionary<Item, Mobile> lockDowns = new Dictionary<Item, Mobile>();

            foreach(KeyValuePair<Item, Mobile> kvp in LockDowns)
            {
                if (kvp.Key is Container)
                    lockDowns.Add(kvp.Key, kvp.Value);
            }

            foreach (KeyValuePair<Item, Mobile> kvp in lockDowns)
                SetLockdown(kvp.Value, kvp.Key, true);
        }

        public static void HandleDeletion(Mobile mob)
        {
            List<BaseHouse> houses = GetHouses(mob);

            if (houses.Count == 0)
                return;

            Account acct = mob.Account as Account;
            Mobile trans = null;

            for (int i = 0; i < acct.Length; ++i)
            {
                if (acct[i] != null && acct[i] != mob)
                    trans = acct[i];
            }

            for (int i = 0; i < houses.Count; ++i)
            {
                BaseHouse house = houses[i];

                bool canClaim = false;

                if (trans == null)
                    canClaim = house.CoOwners.Count > 0;

                if (trans == null && !canClaim)
                    Timer.DelayCall(TimeSpan.Zero, new TimerCallback(house.Delete));
                else
                    house.Owner = trans;
            }

            ColUtility.Free(houses);
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public Mobile Owner
        {
            get
            {
                return m_Owner;
            }
            set
            {
                if (m_Owner != null)
                {
                    m_Table.TryGetValue(m_Owner, out List<BaseHouse> list);

                    if (list == null)
                        m_Table[m_Owner] = list = new List<BaseHouse>();

                    list.Remove(this);
                    m_Owner.Delta(MobileDelta.Noto);
                }

                m_Owner = value;

                if (m_Owner != null)
                {
                    List<BaseHouse> list = null;
                    m_Table.TryGetValue(m_Owner, out list);

                    if (list == null)
                        m_Table[m_Owner] = list = new List<BaseHouse>();

                    list.Add(this);
                    m_Owner.Delta(MobileDelta.Noto);
                }

                if (Sign != null)
                    Sign.InvalidateProperties();
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public Dictionary<Mobile, DateTime> Visits { get; set; }

        [CommandProperty(AccessLevel.GameMaster)]
        public int TotalVisits
        { 
            get { return Visits.Count; } 
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public bool Public
        {
            get
            {
                return m_Public;
            }
            set
            {
                if (m_Public != value)
                {
                    m_Public = value;

                    if (!m_Public) // Privatizing the house, change to brass sign
                        ChangeSignType(0xBD2);

                    if (Sign != null)
                        Sign.InvalidateProperties();
                }
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public int MaxSecures { get; set; }

        [CommandProperty(AccessLevel.GameMaster)]
        public Point3D BanLocation
        {
            get
            {
                if (m_Region != null)
                    return m_Region.GoLocation;

                Point3D rel = m_RelativeBanLocation;
                return new Point3D(X + rel.X, Y + rel.Y, Z + rel.Z);
            }
            set
            {
                RelativeBanLocation = new Point3D(value.X - X, value.Y - Y, value.Z - Z);
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public Point3D RelativeBanLocation
        {
            get
            {
                return m_RelativeBanLocation;
            }
            set
            {
                m_RelativeBanLocation = value;

                if (m_Region != null)
                    m_Region.GoLocation = new Point3D(X + value.X, Y + value.Y, Z + value.Z);
            }
        }

        [CommandProperty(AccessLevel.GameMaster)]
        public int MaxLockDowns { get; set; }

        public Region Region
        {
            get
            {
                return m_Region;
            }
        }
        public List<Mobile> CoOwners { get; set; }
        public List<Mobile> Friends { get; set; }
        public List<Mobile> Access { get; set; }
        public List<Mobile> Bans { get; set; }
        public List<Item> Doors { get; set; }

        public int GetLockdowns()
        {
            int count = 0;

            if (LockDowns != null)
            {
                foreach(KeyValuePair<Item, Mobile> kvp in LockDowns)
                {
                    Item item = kvp.Key;

                    if (!(item is Container))
                        count += item.TotalItems;

                    count++;
                }
            }

            return count;
        }

        public int GetCommissionVendorLockdowns()
        {
            int count = 0;

            foreach (var vendor in PlayerVendors.OfType<CommissionPlayerVendor>())
            {
                if (vendor.Backpack != null)
                {
                    count += vendor.Backpack.TotalItems;
                }
            }

            return count;
        }

        public int LockDownCount
        {
            get
            {
                int count = 0;

                count += GetLockdowns();

                if (Secures != null)
                {
                    for (int i = 0; i < Secures.Count; ++i)
                    {
                        SecureInfo info = Secures[i];

                        if (info.Item.Deleted)
                            continue;
                        else if (info.Item is StrongBox)
                            count += 1;
                        else
                            count += 125;
                    }
                }

                return count;
            }
        }

        public int SecureCount
        {
            get
            {
                int count = 0;

                if (Secures != null)
                {
                    for (int i = 0; i < Secures.Count; i++)
                    {
                        SecureInfo info = Secures[i];

                        if (info.Item.Deleted)
                            continue;
                        else if (!(info.Item is StrongBox))
                            count += 1;
                    }
                }

                return count;
            }
        }

        public List<Item> Carpets { get; set; }

        public Dictionary<Item, Mobile> Addons { get; set; }

        public Dictionary<Item, Mobile> LockDowns { get; private set; }

        public List<SecureInfo> Secures { get; private set; }
        public HouseSign Sign { get; set; }
        public List<Mobile> PlayerVendors { get; } = new List<Mobile>();
        public List<Mobile> PlayerBarkeepers { get; } = new List<Mobile>();
        public List<Item> VendorRentalContracts { get; private set; }
        public List<VendorInventory> VendorInventories { get; } = new List<VendorInventory>();
        public List<RelocatedEntity> RelocatedEntities { get; } = new List<RelocatedEntity>();
        public MovingCrate MovingCrate { get; set; }
        public List<Mobile> InternalizedVendors { get; private set; }

        public DateTime BuiltOn { get; set; }

        public DateTime LastTraded { get; set; }

        public override void OnDelete()
        {
            RestoreRelocatedEntities();

            new FixColumnTimer(this).Start();

            base.OnDelete();
        }

        private class FixColumnTimer : Timer
        {
            private readonly Map m_Map;
            private readonly int m_StartX;

            private readonly int m_StartY;

            private readonly int m_EndX;

            private readonly int m_EndY;

            public FixColumnTimer(BaseMulti multi)
                : base(TimeSpan.Zero)
            {
                m_Map = multi.Map;

                MultiComponentList mcl = multi.Components;

                m_StartX = multi.X + mcl.Min.X;
                m_StartY = multi.Y + mcl.Min.Y;
                m_EndX = multi.X + mcl.Max.X;
                m_EndY = multi.Y + mcl.Max.Y;
            }

            protected override void OnTick()
            {
                if (m_Map == null)
                    return;

                for (int x = m_StartX; x <= m_EndX; ++x)
                    for (int y = m_StartY; y <= m_EndY; ++y)
                        m_Map.FixColumn(x, y);
            }
        }

        public DateTime LastVisit(Mobile m)
        {
            if (Visits.ContainsKey(m))
            {
                return Visits[m];
            }

            return DateTime.MinValue;
        }

        public void AddVisit(Mobile m)
        {
            if (m is PlayerMobile && !IsOwner(m))
            {
                Visits[m] = DateTime.Now;
            }
        }

        public override void OnAfterDelete()
        {
            base.OnAfterDelete();

            if (m_Owner != null)
            {
                List<BaseHouse> list = null;
                m_Table.TryGetValue(m_Owner, out list);

                if (list == null)
                    m_Table[m_Owner] = list = new List<BaseHouse>();

                list.Remove(this);
            }

            CheckUnregisteredAddons();

            foreach (var m in GetMobiles().Where(m => m is Mannequin || m is Steward))
            {
                Mannequin.ForceRedeed(m);
            }

            if (m_Region != null)
            {
                m_Region.Unregister();
                m_Region = null;
            }

            if (Sign != null)
                Sign.Delete();

            if (m_Trash != null)
                m_Trash.Delete();

            if (Doors != null)
            {
                for (int i = 0; i < Doors.Count; ++i)
                {
                    Item item = (Item)Doors[i];

                    if (item != null)
                        item.Delete();
                }

                Doors.Clear();
            }

            if (LockDowns != null)
            {
                foreach(KeyValuePair<Item, Mobile> kvp in LockDowns)
                {
                    Item item = kvp.Key;

                    if (item != null)
                    {
                        item.IsLockedDown = false;
                        item.IsSecure = false;
                        item.Movable = true;
                        item.SetLastMoved();

                        item.SendLocalizedMessage(501657, ""); // [no longer locked down]
                    }
                }

                LockDowns.Clear();
            }

            if (VendorRentalContracts != null)
            {
                for (int i = 0; i < VendorRentalContracts.Count; ++i)
                {
                    Item item = (Item)VendorRentalContracts[i];

                    if (item != null)
                    {
                        item.IsLockedDown = false;
                        item.IsSecure = false;
                        item.Movable = true;
                        item.SetLastMoved();

                        item.SendLocalizedMessage(501657, ""); // [no longer locked down]
                    }
                }

                VendorRentalContracts.Clear();
            }

            if (Secures != null)
            {
                for (int i = 0; i < Secures.Count; ++i)
                {
                    SecureInfo info = Secures[i];

                    if (info.Item is StrongBox)
                    {
                        ((StrongBox)info.Item).Destroy();
                    }
                    else
                    {
                        info.Item.IsLockedDown = false;
                        info.Item.IsSecure = false;
                        info.Item.Movable = true;
                        info.Item.SetLastMoved();

                        info.Item.SendLocalizedMessage(501718, ""); // no longer secure!
                    }
                }

                Secures.Clear();
            }

            if (Addons != null)
            {
                foreach(var kvp in Addons)
                {
                    Item item = kvp.Key;

                    if (item != null)
                    {
                        if (!item.Deleted && item is IAddon)
                        {
                            Item deed = ((IAddon)item).Deed;
                            bool retainDeedHue = false;	//if the items aren't hued but the deed itself is
                            int hue = 0;

                            if (item is BaseAddon && ((BaseAddon)item).RetainDeedHue)	//There are things that are IAddon which aren't BaseAddon
                            {
                                BaseAddon ba = (BaseAddon)item;
                                retainDeedHue = true;

                                for (int j = 0; hue == 0 && j < ba.Components.Count; ++j)
                                {
                                    AddonComponent c = ba.Components[j];

                                    if (c.Hue != 0)
                                        hue = c.Hue;
                                }
                            }

                            if (deed != null)
                            {
                                if (retainDeedHue)
                                    deed.Hue = hue;

                                deed.MoveToWorld(item.Location, item.Map);
                                deed.SendLocalizedMessage(501657, ""); // [no longer locked down]
                            }
                        }

                        item.Delete();
                    }
                }

                Addons.Clear();
            }

            if (Carpets != null)
            {
                for (int i = 0; i < Carpets.Count; ++i)
                {
                    Item carpet = (Item)Carpets[i];

                    if (carpet != null)
                    {
                        carpet.Movable = true;
                        carpet.SetLastMoved();
                        carpet.InvalidateProperties();
                    }
                }
            }

            VendorInventories.IterateReverse(o => o.Delete());

            if (MovingCrate != null)
                MovingCrate.Delete();

            KillVendors();

            AllHouses.Remove(this);
        }

        public static int GetAccountHouseCount(Mobile m)
        {
            Account a = m.Account as Account;

            if (a == null)
                return 0;

            int count = 0;

            for (int i = 0; i < a.Length; ++i)
            {
                if (a[i] != null)
                {
                    count += GetHouseCount(a[i]);
                }
            }

            return count;
        }

        public static int GetHouseCount(Mobile m)
        {
            if (m == null)
                return 0;

            List<BaseHouse> list = null;
            m_Table.TryGetValue(m, out list);

            if (list == null)
                return 0;

            int count = 0;

            for (int i = 0; i < list.Count; ++i)
            {
                BaseHouse h = list[i];

                if (!h.Deleted)
                    count++;
            }

            return count;
        }

        public static bool HasHouse(Mobile m)
        {
            return GetHouseCount(m) > 0;
        }

        public static bool AtAccountHouseLimit(Mobile m)
        {
            return GetAccountHouseCount(m) >= GetAccountHouseLimit(m);
        }

        public static int GetAccountHouseLimit(Mobile m)
        {
            var max = AccountHouseLimit;
            
            return max;
        }

        public static bool CheckAccountHouseLimit(Mobile m, bool message = true)
        {
            if (AtAccountHouseLimit(m))
            {
                if (message)
                {
                    if (AccountHouseLimit == 1)
                    {
                        m.SendLocalizedMessage(501271); // You already own a house, you may not place another!
                    }
                    else
                    {
                        m.SendMessage("You already own {0} houses, you may not place any more!", BaseHouse.AccountHouseLimit.ToString());
                    }
                }

                return false;
            }

            return true;
        }

        public bool IsOwner(Mobile m)
        {
            if (m == null)
                return false;

            if (m == m_Owner || m.AccessLevel >= AccessLevel.GameMaster)
                return true;

            return IsAosRules && AccountHandler.CheckAccount(m, m_Owner);
        }

        public bool IsCoOwner(Mobile m)
        {
            if (m == null || CoOwners == null)
                return false;

            if (IsOwner(m) || CoOwners.Contains(m))
                return true;

            foreach (Mobile mob in CoOwners)
            {
                if (AccountHandler.CheckAccount(mob, m))
                    return true;
            }

            return !IsAosRules && AccountHandler.CheckAccount(m, m_Owner);
        }

        public bool IsGuildMember(Mobile m)
        {
            if (m == null || Owner == null || Owner.Guild == null)
                return false;

            return (m.Guild == Owner.Guild);
        }

        public void RemoveKeys(Mobile m)
        {
            if (Doors != null)
            {
                uint keyValue = 0;

                for (int i = 0; keyValue == 0 && i < Doors.Count; ++i)
                {
                    BaseDoor door = Doors[i] as BaseDoor;

                    if (door != null)
                        keyValue = door.KeyValue;
                }

                Key.RemoveKeys(m, keyValue);
            }
        }

        public void ChangeLocks(Mobile m)
        {
            uint keyValue = CreateKeys(m);

            if (Doors != null)
            {
                for (int i = 0; i < Doors.Count; ++i)
                {
                    BaseDoor door = Doors[i] as BaseDoor;

                    if (door != null)
                        door.KeyValue = keyValue;
                }
            }
        }

        public void RemoveLocks()
        {
            if (Doors != null)
            {
                for (int i = 0; i < Doors.Count; ++i)
                {
                    BaseDoor door = Doors[i] as BaseDoor;

                    if (door != null)
                    {
                        door.KeyValue = 0;
                        door.Locked = false;
                    }
                }
            }
        }

        public virtual HousePlacementEntry ConvertEntry { get { return null; } }
        public virtual int ConvertOffsetX { get { return 0; } }
        public virtual int ConvertOffsetY { get { return 0; } }
        public virtual int ConvertOffsetZ { get { return 0; } }

        public virtual int DefaultPrice { get { return 0; } }

        [CommandProperty(AccessLevel.GameMaster)]
        public int Price { get; set; }

        public virtual HouseDeed GetDeed()
        {
            return null;
        }

        public bool IsFriend(Mobile m)
        {
            if (m == null || Friends == null)
                return false;

            return IsCoOwner(m) || Friends.Contains(m);
        }

        public bool IsBanned(Mobile m)
        {
            if (m == null || m == Owner || m.IsStaff() || Bans == null)
                return false;

            Account theirAccount = m.Account as Account;

            for (int i = 0; i < Bans.Count; ++i)
            {
                Mobile c = (Mobile)Bans[i];

                if (c == m)
                    return true;

                Account bannedAccount = c.Account as Account;

                if (bannedAccount != null && bannedAccount == theirAccount)
                    return true;
            }

            return false;
        }

        public bool HasAccess(Mobile m)
        {
            if (m == null)
                return false;

            if (m.IsStaff() || IsFriend(m) || (Access != null && Access.Contains(m)))
                return true;

            if (m is BaseCreature)
            {
                BaseCreature bc = (BaseCreature)m;

                if (bc.NoHouseRestrictions)
                    return true;

                if (bc.Controlled || bc.Summoned)
                {
                    m = bc.ControlMaster;

                    if (m == null)
                        m = bc.SummonMaster;

                    if (m == null)
                        return false;

                    if (m.IsStaff() || IsFriend(m) || (Access != null && Access.Contains(m)))
                        return true;
                }
            }

            return false;
        }

        public new bool IsLockedDown(Item check)
        {
            if (check == null)
                return false;

            if (LockDowns == null)
                return false;

            return (LockDowns.ContainsKey(check) || VendorRentalContracts.Contains(check));
        }

        public new bool IsSecure(Item item)
        {
            if (item == null)
                return false;

            if (Secures == null)
                return false;

            bool contains = false;

            for (int i = 0; !contains && i < Secures.Count; ++i)
                contains = Secures[i].Item == item;

            return contains;
        }

        public virtual Guildstone FindGuildstone()
        {
            Map map = Map;

            if (map == null)
                return null;

            MultiComponentList mcl = Components;
            IPooledEnumerable eable = map.GetItemsInBounds(new Rectangle2D(X + mcl.Min.X, Y + mcl.Min.Y, mcl.Width, mcl.Height));

            foreach (Item item in eable)
            {
                if (item is Guildstone && Contains(item))
                {
                    eable.Free();
                    return (Guildstone)item;
                }
            }

            eable.Free();
            return null;
        }
    }

    public enum DecayType
    {
        Ageless,
        AutoRefresh,
        ManualRefresh,
        Condemned
    }

    public enum DecayLevel
    {
        Ageless,
        LikeNew,
        Slightly,
        Somewhat,
        Fairly,
        Greatly,
        IDOC,
        Collapsed,
        DemolitionPending
    }

    public enum SecureAccessResult
    {
        Insecure,
        Accessible,
        Inaccessible
    }

    public enum SecureLevel
    {
        Owner,
        CoOwners,
        Friends,
        Anyone,
        Guild
    }

    public class SecureInfo : ISecurable
    {
        public Item Item { get; }
        public SecureLevel Level { get; set; }
        public Mobile Owner { get; set; }
        public bool IsLockdown { get; set; }

        #region *ONLY USED IN BASEHOUSE VERSION 21*
        public static bool VersionInsertion { get; set; }
        #endregion

        public SecureInfo(Item item, SecureLevel level, Mobile owner, bool isLockdown = false)
        {
            Item = item;
            Level = level;
            Owner = owner;
            IsLockdown = isLockdown;
        }

        public SecureInfo(GenericReader reader)
        {
            int version = VersionInsertion ? 0 : reader.ReadInt();

            switch (version)
            {
                case 1:
                    {
                        IsLockdown = reader.ReadBool();
                        Owner = reader.ReadMobile();
                        goto case 0;
                    }
                case 0:
                    {
                        Item = reader.ReadItem();
                        Level = (SecureLevel)reader.ReadByte();
                        break;
                    }
            }
        }

        public void Serialize(GenericWriter writer)
        {
            writer.Write(1); // version

            writer.Write(IsLockdown);
            writer.Write(Owner);

            writer.Write(Item);
            writer.Write((byte)Level);
        }
    }

    public class RelocatedEntity
    {
        public IEntity Entity { get; }

        public Point3D RelativeLocation { get; }

        public Mobile Owner { get; }

        public RelocatedEntity(IEntity entity, Point3D relativeLocation, Mobile owner)
        {
            Entity = entity;
            RelativeLocation = relativeLocation;
            Owner = owner;
        }
    }

    #region Targets

    public class LockdownTarget : Target
    {
        private readonly bool m_Release;
        private readonly BaseHouse m_House;

        public LockdownTarget(bool release, BaseHouse house)
            : base(12, false, TargetFlags.None)
        {
            CheckLOS = false;

            m_Release = release;
            m_House = house;
        }

        protected override void OnTargetNotAccessible(Mobile from, object targeted)
        {
            OnTarget(from, targeted);
        }

        protected override void OnTarget(Mobile from, object targeted)
        {
            if (!from.Alive || m_House.Deleted || !m_House.IsFriend(from))
                return;

            if (targeted is Item)
            {
                Item item = targeted as Item;

                if (m_Release)
                {
                    #region Mondain's legacy
                    if (targeted is AddonContainerComponent)
                    {
                        AddonContainerComponent component = (AddonContainerComponent)targeted;

                        if (component.Addon != null)
                            m_House.Release(from, component.Addon);
                    }
                    #endregion
                    else if (item.Parent is Container)
                    {
                        from.SendLocalizedMessage(1080387); // You may not release this while it is in a container. 
                    }
                    else
                    {
                        m_House.Release(from, (Item)targeted);
                    }
                }
                else
                {
                    if (targeted is VendorRentalContract)
                    {
                        from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1062392); // You must double click the contract in your pack to lock it down.
                        from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 501732); // I cannot lock this down!
                    }
                    else if ((Item)targeted is AddonComponent)
                    {
                        from.LocalOverheadMessage(MessageType.Regular, 0x3E9, 501727); // You cannot lock that down!
                        from.LocalOverheadMessage(MessageType.Regular, 0x3E9, 501732); // I cannot lock this down!
                    }
                    else
                    {
                        #region Mondain's legacy
                        if (targeted is AddonContainerComponent)
                        {
                            AddonContainerComponent component = (AddonContainerComponent)targeted;

                            if (component.Addon != null)
                                m_House.LockDown(from, component.Addon);
                        }
                        else
                        #endregion
                        {
                            m_House.LockDown(from, (Item)targeted);
                        }
                    }
                }
            }
            else if (targeted is StaticTarget)
            {
                return;
            }
            else
            {
                from.SendLocalizedMessage(1005377); //You cannot lock that down
            }
        }
    }

    public class SecureTarget : Target
    {
        private readonly bool m_Release;
        private readonly BaseHouse m_House;

        public SecureTarget(bool release, BaseHouse house)
            : base(12, false, TargetFlags.None)
        {
            CheckLOS = false;

            m_Release = release;
            m_House = house;
        }

        protected override void OnTargetNotAccessible(Mobile from, object targeted)
        {
            OnTarget(from, targeted);
        }

        protected override void OnTarget(Mobile from, object targeted)
        {
            if (!from.Alive || m_House.Deleted || !m_House.IsCoOwner(from))
                return;

            if (targeted is Item)
            {
                if (m_Release)
                {
                    #region Mondain's legacy
                    if (targeted is AddonContainerComponent)
                    {
                        AddonContainerComponent component = (AddonContainerComponent)targeted;

                        if (component.Addon != null)
                            m_House.ReleaseSecure(from, component.Addon);
                    }
                    else
                    #endregion

                        m_House.ReleaseSecure(from, (Item)targeted);
                }
                else
                {
                    if (targeted is VendorRentalContract)
                    {
                        from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1062392); // You must double click the contract in your pack to lock it down.
                        from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 501732); // I cannot lock this down!
                    }
                    else
                    {
                        #region Mondain's legacy
                        if (targeted is AddonContainerComponent)
                        {
                            AddonContainerComponent component = (AddonContainerComponent)targeted;

                            if (component.Addon != null)
                                m_House.AddSecure(from, component.Addon);
                        }
                        else
                        #endregion

                            m_House.AddSecure(from, (Item)targeted);
                    }
                }
            }
            else
            {
                from.SendLocalizedMessage(1010424);//You cannot secure this
            }
        }
    }

    public class HouseKickTarget : Target
    {
        private readonly BaseHouse m_House;

        public HouseKickTarget(BaseHouse house)
            : base(-1, false, TargetFlags.None)
        {
            CheckLOS = false;

            m_House = house;
        }

        protected override void OnTarget(Mobile from, object targeted)
        {
            if (!from.Alive || m_House.Deleted || !m_House.IsFriend(from))
                return;

            if (targeted is Mobile)
            {
                m_House.Kick(from, (Mobile)targeted);
            }
            else
            {
                from.SendLocalizedMessage(501347);//You cannot eject that from the house!
            }
        }
    }

    public class HouseBanTarget : Target
    {
        private readonly BaseHouse m_House;
        private readonly bool m_Banning;

        public HouseBanTarget(bool ban, BaseHouse house)
            : base(-1, false, TargetFlags.None)
        {
            CheckLOS = false;

            m_House = house;
            m_Banning = ban;
        }

        protected override void OnTarget(Mobile from, object targeted)
        {
            if (!from.Alive || m_House.Deleted || !m_House.IsFriend(from))
                return;

            if (targeted is Mobile)
            {
                if (m_Banning)
                    m_House.Ban(from, (Mobile)targeted);
                else
                    m_House.RemoveBan(from, (Mobile)targeted);
            }
            else
            {
                from.SendLocalizedMessage(501347);//You cannot eject that from the house!
            }
        }
    }

    public class HouseAccessTarget : Target
    {
        private readonly BaseHouse m_House;

        public HouseAccessTarget(BaseHouse house)
            : base(-1, false, TargetFlags.None)
        {
            CheckLOS = false;

            m_House = house;
        }

        protected override void OnTarget(Mobile from, object targeted)
        {
            if (!from.Alive || m_House.Deleted || !m_House.IsFriend(from))
                return;

            if (targeted is Mobile)
                m_House.GrantAccess(from, (Mobile)targeted);
            else
                from.SendLocalizedMessage(1060712); // That is not a player.
        }
    }

    public class CoOwnerTarget : Target
    {
        private readonly BaseHouse m_House;
        private readonly bool m_Add;

        public CoOwnerTarget(bool add, BaseHouse house)
            : base(12, false, TargetFlags.None)
        {
            CheckLOS = false;

            m_House = house;
            m_Add = add;
        }

        protected override void OnTarget(Mobile from, object targeted)
        {
            if (!from.Alive || m_House.Deleted || !m_House.IsOwner(from))
                return;

            if (targeted is Mobile)
            {
                if (m_Add)
                    m_House.AddCoOwner(from, (Mobile)targeted);
                else
                    m_House.RemoveCoOwner(from, (Mobile)targeted);
            }
            else
            {
                from.SendLocalizedMessage(501362);//That can't be a coowner
            }
        }
    }

    public class HouseFriendTarget : Target
    {
        private readonly BaseHouse m_House;
        private readonly bool m_Add;

        public HouseFriendTarget(bool add, BaseHouse house)
            : base(12, false, TargetFlags.None)
        {
            CheckLOS = false;

            m_House = house;
            m_Add = add;
        }

        protected override void OnTarget(Mobile from, object targeted)
        {
            if (!from.Alive || m_House.Deleted || !m_House.IsCoOwner(from))
                return;

            if (targeted is Mobile)
            {
                if (m_Add)
                    m_House.AddFriend(from, (Mobile)targeted);
                else
                    m_House.RemoveFriend(from, (Mobile)targeted);
            }
            else
            {
                from.SendLocalizedMessage(501371); // That can't be a friend
            }
        }
    }

    public class HouseOwnerTarget : Target
    {
        private readonly BaseHouse m_House;

        public HouseOwnerTarget(BaseHouse house)
            : base(12, false, TargetFlags.None)
        {
            CheckLOS = false;

            m_House = house;
        }

        protected override void OnTarget(Mobile from, object targeted)
        {
            if (targeted is Mobile)
                m_House.BeginConfirmTransfer(from, (Mobile)targeted);
            else
                from.SendLocalizedMessage(501384); // Only a player can own a house!
        }
    }

    #endregion

    public class SetSecureLevelEntry : ContextMenuEntry
    {
        private readonly Item m_Item;
        private readonly ISecurable m_Securable;

        public SetSecureLevelEntry(Item item, ISecurable securable)
            : base(6203, 6)
        {
            m_Item = item;
            m_Securable = securable;
        }

        public static ISecurable GetSecurable(Mobile from, Item item)
        {
            BaseHouse house = BaseHouse.FindHouseAt(item);

            if (house == null || !house.IsAosRules)
                return null;

            bool owner = house.IsOwner(from) || (house.IsLockedDown(item) && house.CheckLockdownOwnership(from, item));
            ISecurable sec = null;

            if (item is ISecurable)
            {
                if (!owner)
                    return null;

                bool isOwned = house.Doors.Contains(item);

                if (!isOwned)
                    isOwned = (house is HouseFoundation && ((HouseFoundation)house).IsFixture(item));

                if (!isOwned)
                    isOwned = house.IsLockedDown(item);

                if (!isOwned)
                    isOwned = item is BaseAddon;

                if (isOwned)
                    sec = (ISecurable)item;
            }
            else
            {
                sec = house.GetSecureInfoFor(from, item);
            }

            return sec;
        }

        public static void AddTo(Mobile from, Item item, List<ContextMenuEntry> list)
        {
            ISecurable sec = GetSecurable(from, item);

            if (sec != null)
                list.Add(new SetSecureLevelEntry(item, sec));
        }

        public override void OnClick()
        {
            if (m_Item is AuctionSafe)
            {
                AuctionSafe safe = (AuctionSafe)m_Item;

                if (safe.Auction != null && !safe.Auction.CanModify)
                {
                    Owner.From.SendLocalizedMessage(1156431); // You cannot modify this while an auction is in progress.
                    return;
                }
            }

            ISecurable sec = GetSecurable(Owner.From, m_Item);
            BaseHouse house = BaseHouse.FindHouseAt(m_Item);

            if (house != null && sec != null)
            {
                Owner.From.CloseGump(typeof (SetSecureLevelGump));
                Owner.From.SendGump(new SetSecureLevelGump(Owner.From, sec, house));
            }
        }
    }

    public class ReLocateEntry : ContextMenuEntry
    {
        public Mobile Mobile { get; set; }
        public Item Item { get; set; }
        public BaseHouse House { get; set; }

        public ReLocateEntry(Mobile m, Item item, BaseHouse house)
            : base(1159158, 8) // Relocate Container
        {
            Item = item;
            Mobile = m;
            House = house;

            Enabled = Mobile.Alive;
        }

        public override void OnClick()
        {
            if (Mobile.Alive && BaseHouse.FindHouseAt(Mobile) == House && House.IsOwner(Mobile))
            {
                Mobile.Target = new InternalTarget(Item, House);
                Mobile.SendLocalizedMessage(1159160); // Target the location that you wish to relocate this container. Once selected the container will no longer be secured.
            }
            else
            {
                Mobile.SendLocalizedMessage(1153882); // You do not own that.
            }
        }

        public static AddonFitResult CouldFit(Point3D p, Map map, Mobile from, ref BaseHouse house)
        {
            if (!map.CanFit(p.X, p.Y, p.Z, 20, true, true, true))
                return AddonFitResult.Blocked;
            else if (!BaseAddon.CheckHouse(from, p, map, 20, ref house))
                return AddonFitResult.NotInHouse;
            else
                return CheckDoors(p, 20, house);
        }

        public static AddonFitResult CheckDoors(Point3D p, int height, BaseHouse house)
        {
            List<Item> doors = house.Doors;

            for (int i = 0; i < doors.Count; i++)
            {
                BaseDoor door = doors[i] as BaseDoor;

                Point3D doorLoc = door.GetWorldLocation();
                int doorHeight = door.ItemData.CalcHeight;

                if (Utility.InRange(doorLoc, p, 1) && (p.Z == doorLoc.Z || ((p.Z + height) > doorLoc.Z && (doorLoc.Z + doorHeight) > p.Z)))
                    return AddonFitResult.DoorTooClose;
            }

            return AddonFitResult.Valid;
        }

        private class InternalTarget : Target
        {
            public Item Item { get; set; }
            public BaseHouse House { get; set; }

            public InternalTarget(Item item, BaseHouse house)
                : base(8, true, TargetFlags.None)
            {
                Item = item;
                House = house;
            }

            protected override void OnTarget(Mobile from, object targeted)
            {
                IPoint3D p = targeted as IPoint3D;

                Point3D point = new Point3D(p.X, p.Y, p.Z);

                BaseHouse house = BaseHouse.FindHouseAt(point, from.Map, 0);

                AddonFitResult result = CouldFit(point, from.Map, from, ref house);

                if (house != null && house == House && house.Owner == from && result == AddonFitResult.Valid)
                {
                    if (House.Release(from, Item))
                    {
                        Item.MoveToWorld(point, from.Map);
                        Item.Movable = true;

                        from.SendLocalizedMessage(1159159); // This container has been released and is no longer secure.
                    }
                }
                else
                {
                    from.SendLocalizedMessage(1149667); // Invalid target.
                }
            }

            protected override void OnTargetCancel(Mobile from, TargetCancelType cancelType)
            {
                from.SendLocalizedMessage(500979); // You cannot see that location.
            }
        }        
    }

    public class ReleaseEntry : ContextMenuEntry
    {
        public Mobile Mobile { get; set; }
        public Item Item { get; set; }
        public BaseHouse House { get; set; }

        public ReleaseEntry(Mobile m, Item item, BaseHouse house)
            : base(1153880, 8) // Retrieve
        {
            Item = item;
            Mobile = m;
            House = house;

            Enabled = Mobile.Alive;
        }

        public override void OnClick()
        {
            if (Mobile.Alive && BaseHouse.FindHouseAt(Mobile) == House && House.IsOwner(Mobile))
            {
                if (Mobile.Backpack == null || !Mobile.Backpack.CheckHold(Mobile, Item, false))
                {
                    Mobile.SendLocalizedMessage(1153881); // Your pack cannot hold this
                }
                else if (House.Release(Mobile, Item))
                {
                    Mobile.Backpack.DropItem(Item);

                    if (Item.IsLockedDown)
                    {
                        Item.IsLockedDown = false;
                        Item.Movable = true;
                    }
                }
            }
            else
            {
                Mobile.SendLocalizedMessage(1153882); // You do not own that.
            }
        }
    }

    public class TempNoHousingRegion : BaseRegion
    {
        private readonly Mobile m_RegionOwner;

        public TempNoHousingRegion(BaseHouse house, Mobile regionowner)
            : base(null, house.Map, DefaultPriority, house.Region.Area)
        {
            Register();

            m_RegionOwner = regionowner;

            Timer.DelayCall(house.RestrictedPlacingTime, Unregister);
        }

        public override bool AllowHousing(Mobile from, Point3D p)
        {
            return from == m_RegionOwner || AccountHandler.CheckAccount(from, m_RegionOwner);
        }
    }
}