Mobile.cs

/*************************************************************************
 * ModernUO                                                              *
 * Copyright 2019-2024 - ModernUO Development Team                       *
 * Email: hi@modernuo.com                                                *
 * File: Mobile.cs                                                       *
 *                                                                       *
 * This program is free software: you can redistribute it and/or modify  *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation, either version 3 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * You should have received a copy of the GNU General Public License     *
 * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
 *************************************************************************/

using Server.Accounting;
using Server.Collections;
using Server.ContextMenus;
using Server.Guilds;
using Server.HuePickers;
using Server.Items;
using Server.Logging;
using Server.Menus;
using Server.Mobiles;
using Server.Network;
using Server.Prompts;
using Server.Targeting;
using Server.Text;
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using CalcMoves = Server.Movement.Movement;

namespace Server;

public delegate void TargetCallback(Mobile from, object targeted);

public delegate void TargetStateCallback<in T>(Mobile from, object targeted, T state);

public delegate void PromptCallback(Mobile from, string text);

public delegate void PromptStateCallback<in T>(Mobile from, string text, T state);

public class DamageEntry
{
    public DamageEntry(Mobile damager) => Damager = damager;

    public Mobile Damager { get; }

    public int DamageGiven { get; set; }

    public DateTime LastDamage { get; set; }

    public bool HasExpired => Core.Now > LastDamage + ExpireDelay;

    public List<DamageEntry> Responsible { get; set; }

    public static TimeSpan ExpireDelay { get; set; } = TimeSpan.FromMinutes(2.0);
}

[Flags]
public enum StatType : byte
{
    Str = 1,
    Dex = 2,
    Int = 4,
    All = 7
}

public enum StatLockType : byte
{
    Up,
    Down,
    Locked
}

[Flags]
[CustomEnum(new[] { "North", "Right", "East", "Down", "South", "Left", "West", "Up" })]
public enum Direction : byte
{
    North = 0x0,
    Right = 0x1,
    East = 0x2,
    Down = 0x3,
    South = 0x4,
    Left = 0x5,
    West = 0x6,
    Up = 0x7,

    Mask = 0x7,
    Running = 0x80,
    ValueMask = 0x87
}

[Flags]
public enum MobileDelta
{
    None = 0x00000000,
    Name = 0x00000001,
    Flags = 0x00000002,
    Hits = 0x00000004,
    Mana = 0x00000008,
    Stam = 0x00000010,
    Stat = 0x00000020,
    Noto = 0x00000040,
    Gold = 0x00000080,
    Weight = 0x00000100,
    Direction = 0x00000200,
    Hue = 0x00000400,
    Body = 0x00000800,
    Armor = 0x00001000,
    StatCap = 0x00002000,
    GhostUpdate = 0x00004000,
    Followers = 0x00008000,
    Properties = 0x00010000,
    TithingPoints = 0x00020000,
    Resistances = 0x00040000,
    WeaponDamage = 0x00080000,
    Hair = 0x00100000,
    FacialHair = 0x00200000,
    Race = 0x00400000,
    HealthbarYellow = 0x00800000,
    HealthbarPoison = 0x01000000,

    Attributes = 0x0000001C
}

public enum Healthbar
{
    Normal,
    Poison,
    Yellow
}

public enum AccessLevel
{
    Player,
    Counselor,
    GameMaster,
    Seer,
    Administrator,
    Developer,
    Owner
}

public enum VisibleDamageType
{
    None,
    Related,
    Everyone,
    Selective
}

public enum ResistanceType
{
    Physical,
    Fire,
    Cold,
    Poison,
    Energy
}

public enum ApplyPoisonResult
{
    Poisoned,
    Immune,
    HigherPoisonActive,
    Cured
}

public delegate bool SkillCheckTargetHandler(
    Mobile from, SkillName skill, object target, double minSkill,
    double maxSkill
);

public delegate bool SkillCheckLocationHandler(Mobile from, SkillName skill, double minSkill, double maxSkill);

public delegate bool SkillCheckDirectTargetHandler(Mobile from, SkillName skill, object target, double chance);

public delegate bool SkillCheckDirectLocationHandler(Mobile from, SkillName skill, double chance);

public delegate TimeSpan RegenRateHandler(Mobile from);

public delegate bool AllowBeneficialHandler(Mobile from, Mobile target);

public delegate bool AllowHarmfulHandler(Mobile from, Mobile target);

public delegate Container CreateCorpseHandler(
    Mobile from, List<Item> initialContent, List<Item> equippedItems
);

public delegate int AOSStatusHandler(Mobile from, int index);

/// <summary>
///     Base class representing players, npcs, and creatures.
/// </summary>
public partial class Mobile : IHued, IComparable<Mobile>, ISpawnable, IObjectPropertyListEntity, IValueLinkListNode<Mobile>
{
    // Allow four warmode changes in 0.5 seconds, any more will be delay for two seconds
    private const int WarmodeCatchCount = 4;

    private static readonly ILogger logger = LogFactory.GetLogger(typeof(Mobile));

    // TODO: Make these configurations
    private static readonly TimeSpan WarmodeSpamCatch = TimeSpan.FromSeconds(Core.SE ? 1.0 : 0.5);
    private static readonly TimeSpan WarmodeSpamDelay = TimeSpan.FromSeconds(Core.SE ? 4.0 : 2.0);
    private static readonly TimeSpan ExpireCombatantDelay = TimeSpan.FromMinutes(1.0);
    private static readonly TimeSpan ExpireAggressorsDelay = TimeSpan.FromSeconds(5.0);

    private static readonly object m_GhostMutateContext = new();

    private static readonly List<Mobile> m_Hears = new();
    private static readonly List<IEntity> m_OnSpeech = new();

    private static readonly string[] m_AccessLevelNames =
    {
        "a player",
        "a counselor",
        "a game master",
        "a seer",
        "an administrator",
        "a developer",
        "an owner"
    };

    private static readonly int[] m_InvalidBodies =
    {
        32,
        95,
        156,
        197,
        198
    };

    private static readonly Queue<Mobile> m_DeltaQueue = new();

    private static bool _disableCastParalyze = true;

    public static void Configure()
    {
        _disableCastParalyze = ServerConfiguration.GetSetting("spellCasting.disableCastParalyze", true);
    }

    private List<object> _actions;
    private AccessLevel m_AccessLevel;

    private TimerExecutionToken _autoManifestTimerToken;

    private Container m_Backpack;

    private BankBox m_BankBox;
    private Body m_Body;
    private Body m_BodyMod;
    private bool m_CanHearGhosts;

    private int m_ChangingCombatant;
    private Mobile m_Combatant;
    private TimerExecutionToken _combatTimerToken;
    private bool m_Criminal;

    private MobileDelta m_DeltaFlags;
    private Direction m_Direction;

    private TimerExecutionToken _expireAggrTimerToken;
    private TimerExecutionToken _expireCombatantTimerToken;
    private TimerExecutionToken _expireCriminalTimerToken;
    private VirtualHairInfo _facialHair;
    public VirtualHairInfo FacialHair => _facialHair ??= new VirtualHairInfo(FacialHairItemID, FacialHairHue);

    private int m_Fame, m_Karma;
    private bool m_Female, m_Warmode, m_Hidden, m_Blessed, m_Flying;
    private int m_Followers, m_FollowersMax;
    private bool m_Frozen;
    private TimerExecutionToken _frozenTimerToken;

    private VirtualHairInfo _hair;
    public VirtualHairInfo Hair => _hair ??= new VirtualHairInfo(HairItemID, HairHue);

    private int m_Hits, m_Stam, m_Mana;

    private Item m_Holding;
    private int m_Hue;

    private int m_HueMod = -1;
    private int m_Hunger;

    private bool m_InDeltaQueue;
    private int m_Kills;
    private string m_Language;
    private int m_LightLevel;
    private Point3D m_Location;
    private TimerExecutionToken _logoutTimerToken;
    private Timer m_ManaTimer, m_HitsTimer, m_StamTimer;

    private Map m_Map;

    /* Logout:
     *
     * When a client logs into mobile x
     *  - if (x is Internalized ) move x to logout location and map
     *
     * When a client attached to a mobile disconnects
     *  - LogoutTimer is started
     *     - Delay is taken from Region.GetLogoutDelay to allow insta-logout regions.
     *     - OnTick : Location and map are stored, and mobile is internalized
     *
     * Some things to consider:
     *  - An internalized person getting killed (say, by poison). Where does the body go?
     *  - Regions now have a GetLogoutDelay( Mobile m ); virtual function (see above)
     */

    private Item m_MountItem;
    private string m_Name;

    private string m_NameMod;
    private NetState m_NetState;
    private DateTime m_NextWarmodeChange;
    private bool m_Paralyzed;
    private TimerExecutionToken _paraTimerToken;
    private bool m_Player;
    private Poison m_Poison;
    private Prompt m_Prompt;
    private ObjectPropertyList m_PropertyList;
    private Race m_Race;
    private Region m_Region;

    private int m_SolidHueOverride = -1;
    private ISpell m_Spell;
    private int m_StatCap;
    private int m_Str, m_Dex, m_Int;

    private StatLockType m_StrLock, m_DexLock, m_IntLock;
    private Target m_Target;
    private int m_TithingPoints;
    private string m_Title;
    private int m_TotalGold, m_TotalItems, m_TotalWeight;
    private int m_VirtualArmor;
    private int m_VirtualArmorMod;
    private int m_WarmodeChanges;
    private bool _warmodeSpamValue;
    private IWeapon m_Weapon;
    private bool _ignoreMobiles;

    private bool m_YellowHealthbar;
    private List<StatMod> _statMods;
    private List<ResistanceMod> _resistanceMods;
    private List<SkillMod> _skillMods;

    public Mobile()
    {
        m_Region = Map.Internal.DefaultRegion;
        Serial = World.NewMobile;

        DefaultMobileInit();

        World.AddEntity(this);
    }

    public Mobile(Serial serial)
    {
        m_Region = Map.Internal.DefaultRegion;
        Serial = serial;
        Aggressors = new List<AggressorInfo>();
        Aggressed = new List<AggressorInfo>();
        NextSkillTime = Core.TickCount;
        DamageEntries = new List<DamageEntry>();
    }

    // Sectors
    public Mobile Next { get; set; }
    public Mobile Previous { get; set; }
    public bool OnLinkList { get; set; }

    public static bool DragEffects { get; set; } = true;

    [CommandProperty(AccessLevel.GameMaster)]
    public Race Race
    {
        get => m_Race ??= Race.DefaultRace;
        set
        {
            var oldRace = Race;

            m_Race = value ?? Race.DefaultRace;

            Body = m_Race.Body(this);
            UpdateResistances();

            Delta(MobileDelta.Race);

            OnRaceChange(oldRace);
        }
    }

    public virtual double RacialSkillBonus => 0;

    public int[] Resistances { get; private set; }

    public virtual int BasePhysicalResistance => 0;
    public virtual int BaseFireResistance => 0;
    public virtual int BaseColdResistance => 0;
    public virtual int BasePoisonResistance => 0;
    public virtual int BaseEnergyResistance => 0;

    [CommandProperty(AccessLevel.Counselor)]
    public virtual int PhysicalResistance => GetResistance(ResistanceType.Physical);

    [CommandProperty(AccessLevel.Counselor)]
    public virtual int FireResistance => GetResistance(ResistanceType.Fire);

    [CommandProperty(AccessLevel.Counselor)]
    public virtual int ColdResistance => GetResistance(ResistanceType.Cold);

    [CommandProperty(AccessLevel.Counselor)]
    public virtual int PoisonResistance => GetResistance(ResistanceType.Poison);

    [CommandProperty(AccessLevel.Counselor)]
    public virtual int EnergyResistance => GetResistance(ResistanceType.Energy);

    public static int MaxPlayerResistance { get; set; } = 70;

    public virtual bool NewGuildDisplay => false;

    [CommandProperty(AccessLevel.GameMaster)]
    public virtual bool IgnoreMobiles
    {
        get => _ignoreMobiles;
        set
        {
            if (_ignoreMobiles != value)
            {
                _ignoreMobiles = value;
                Delta(MobileDelta.Flags);
            }
        }
    }

    public object Party { get; set; }

    public List<SkillMod> SkillMods => _skillMods;
    public List<StatMod> StatMods => _statMods;
    public List<ResistanceMod> ResistanceMods => _resistanceMods;

    [CommandProperty(AccessLevel.GameMaster)]
    public int VirtualArmorMod
    {
        get => m_VirtualArmorMod;
        set
        {
            if (m_VirtualArmorMod != value)
            {
                m_VirtualArmorMod = value;

                Delta(MobileDelta.Armor);
            }
        }
    }

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

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

    [CommandProperty(AccessLevel.GameMaster)]
    public int SkillsTotal => Skills?.Total ?? 0;

    [CommandProperty(AccessLevel.GameMaster)]
    public int SkillsCap
    {
        get => Skills?.Cap ?? 0;
        set
        {
            if (Skills != null)
            {
                Skills.Cap = value;
            }
        }
    }

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

    public long NextCombatTime { get; set; }

    [CommandProperty(AccessLevel.GameMaster)]
    public int NameHue { get; set; } = -1;

    [CommandProperty(AccessLevel.GameMaster)]
    public int Hunger
    {
        get => m_Hunger;
        set
        {
            var oldValue = m_Hunger;

            if (oldValue != value)
            {
                m_Hunger = value;
                OnHungerChanged(oldValue);
            }
        }
    }

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

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

    /// <summary>
    ///     Gets or sets the number of steps this player may take when hidden before being revealed.
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public int AllowedStealthSteps { get; set; }

    public Item Holding
    {
        get => m_Holding;
        set
        {
            if (m_Holding != value)
            {
                if (m_Holding != null)
                {
                    UpdateTotal(m_Holding, TotalType.Weight, -(m_Holding.TotalWeight + m_Holding.PileWeight));

                    if (m_Holding.HeldBy == this)
                    {
                        m_Holding.HeldBy = null;
                    }
                }

                if (value != null && m_Holding != null)
                {
                    DropHolding();
                }

                m_Holding = value;

                if (m_Holding != null)
                {
                    UpdateTotal(m_Holding, TotalType.Weight, m_Holding.TotalWeight + m_Holding.PileWeight);

                    m_Holding.HeldBy ??= this;
                }
            }
        }
    }

    public long LastMoveTime { get; set; }

    [CommandProperty(AccessLevel.GameMaster)]
    public virtual bool Paralyzed
    {
        get => m_Paralyzed;
        set
        {
            if (m_Paralyzed != value)
            {
                m_Paralyzed = value;
                Delta(MobileDelta.Flags);

                SendLocalizedMessage(m_Paralyzed ? 502381 : 502382);
                _paraTimerToken.Cancel();
            }

            if (!value && m_NetState != null)
            {
                var now = Core.TickCount;
                if (now - m_NetState._nextMovementTime > 0)
                {
                    m_NetState._nextMovementTime = now;
                }
            }
        }
    }

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

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

    [CommandProperty(AccessLevel.GameMaster)]
    public bool Frozen
    {
        get => m_Frozen;
        set
        {
            if (m_Frozen != value)
            {
                m_Frozen = value;
                Delta(MobileDelta.Flags);
                _frozenTimerToken.Cancel();
            }
        }
    }

    /// <summary>
    ///     Gets or sets the <see cref="StatLockType">lock state</see> for the <see cref="RawStr" /> property.
    /// </summary>
    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public StatLockType StrLock
    {
        get => m_StrLock;
        set
        {
            if (m_StrLock != value)
            {
                m_StrLock = value;

                m_NetState.SendStatLockInfo(this);
            }
        }
    }

    /// <summary>
    ///     Gets or sets the <see cref="StatLockType">lock state</see> for the <see cref="RawDex" /> property.
    /// </summary>
    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public StatLockType DexLock
    {
        get => m_DexLock;
        set
        {
            if (m_DexLock != value)
            {
                m_DexLock = value;

                m_NetState.SendStatLockInfo(this);
            }
        }
    }

    /// <summary>
    ///     Gets or sets the <see cref="StatLockType">lock state</see> for the <see cref="RawInt" /> property.
    /// </summary>
    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public StatLockType IntLock
    {
        get => m_IntLock;
        set
        {
            if (m_IntLock != value)
            {
                m_IntLock = value;

                m_NetState.SendStatLockInfo(this);
            }
        }
    }

    public long NextActionTime { get; set; }

    public long NextActionMessage { get; set; }

    public static int ActionMessageDelay { get; set; } = 125;

    public static bool GlobalRegenThroughPoison { get; set; } = true;

    public virtual bool RegenThroughPoison => GlobalRegenThroughPoison;

    public virtual bool CanRegenHits => Alive && (RegenThroughPoison || !Poisoned);
    public virtual bool CanRegenStam => Alive;
    public virtual bool CanRegenMana => Alive;

    public long NextSkillTime { get; set; }

    public List<AggressorInfo> Aggressors { get; private set; }

    public List<AggressorInfo> Aggressed { get; private set; }

    public bool ChangingCombatant => m_ChangingCombatant > 0;

    private void ExpireCombatant()
    {
        Combatant = null;
        _expireCombatantTimerToken.Cancel();
    }

    /// <summary>
    ///     Overridable. Gets or sets which Mobile that this Mobile is currently engaged in combat with.
    ///     <seealso cref="OnCombatantChange" />
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public virtual Mobile Combatant
    {
        get => m_Combatant;
        set
        {
            if (Deleted)
            {
                return;
            }

            if (m_Combatant != value && value != this)
            {
                var old = m_Combatant;

                ++m_ChangingCombatant;
                m_Combatant = value;

                if (m_Combatant != null && !CanBeHarmful(m_Combatant, false) ||
                    !Region.OnCombatantChange(this, old, m_Combatant))
                {
                    m_Combatant = old;
                    --m_ChangingCombatant;
                    return;
                }

                if (m_Combatant == null)
                {
                    m_NetState.SendChangeCombatant(Serial.Zero);
                    _expireCombatantTimerToken.Cancel();
                    _combatTimerToken.Cancel();
                }
                else
                {
                    m_NetState.SendChangeCombatant(m_Combatant.Serial);
                    if (!_expireCombatantTimerToken.Running)
                    {
                        Timer.StartTimer(ExpireCombatantDelay, ExpireCombatant, out _expireCombatantTimerToken);
                    }

                    if (!_combatTimerToken.Running)
                    {
                        Timer.StartTimer(TimeSpan.FromSeconds(0.01), 0, CheckCombatTime, out _combatTimerToken);
                    }

                    if (CanBeHarmful(m_Combatant, false))
                    {
                        DoHarmful(m_Combatant); // due to reflection, might make m_Combatant null
                        m_Combatant?.PlaySound(m_Combatant.GetAngerSound());
                    }
                }

                OnCombatantChange();
                --m_ChangingCombatant;
            }
        }
    }

    private void CheckCombatTime()
    {
        if (Core.TickCount - NextCombatTime < 0)
        {
            return;
        }

        var combatant = Combatant;

        // If no combatant, wrong map, one of us is a ghost, or cannot see, or deleted, then stop combat
        if (combatant?.Deleted != false || Deleted || combatant.m_Map != m_Map ||
            !combatant.Alive || !Alive || !CanSee(combatant) || combatant.IsDeadBondedPet ||
            IsDeadBondedPet)
        {
            Combatant = null;
            return;
        }

        var weapon = Weapon;

        if (weapon == null || !InRange(combatant, weapon.MaxRange))
        {
            return;
        }

        if (InLOS(combatant))
        {
            weapon.OnBeforeSwing(this, combatant);
            RevealingAction();
            NextCombatTime =
                Core.TickCount + (int)weapon.OnSwing(this, combatant).TotalMilliseconds;
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public int TotalGold => GetTotal(TotalType.Gold);

    [CommandProperty(AccessLevel.GameMaster)]
    public int TotalItems => GetTotal(TotalType.Items);

    [CommandProperty(AccessLevel.GameMaster)]
    public int TotalWeight => GetTotal(TotalType.Weight);

    [CommandProperty(AccessLevel.GameMaster)]
    public int TithingPoints
    {
        get => m_TithingPoints;
        set
        {
            if (m_TithingPoints != value)
            {
                m_TithingPoints = value;

                Delta(MobileDelta.TithingPoints);
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public int Followers
    {
        get => m_Followers;
        set
        {
            if (m_Followers != value)
            {
                m_Followers = value;

                Delta(MobileDelta.Followers);
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public int FollowersMax
    {
        get => m_FollowersMax;
        set
        {
            if (m_FollowersMax != value)
            {
                m_FollowersMax = value;

                Delta(MobileDelta.Followers);
            }
        }
    }

    public bool TargetLocked { get; set; }

    public Target Target
    {
        get => m_Target;
        set
        {
            var oldTarget = m_Target;
            var newTarget = value;

            if (oldTarget == newTarget)
            {
                return;
            }

            m_Target = null;

            if (oldTarget != null && newTarget != null)
            {
                oldTarget.Cancel(this, TargetCancelType.Overridden);
            }

            m_Target = newTarget;

            if (newTarget != null && !TargetLocked)
            {
                newTarget.SendTargetTo(m_NetState);
            }

            OnTargetChange();
        }
    }

    [IgnoreDupe]
    public bool Pushing { get; set; }

    public virtual bool IsDeadBondedPet => false;

    [IgnoreDupe]
    public ISpell Spell
    {
        get => m_Spell;
        set
        {
            if (m_Spell != null && value != null)
            {
                logger.Warning("Spell has been overwritten.");
            }

            m_Spell = value;
        }
    }

    [CommandProperty(AccessLevel.Administrator)]
    public bool AutoPageNotify { get; set; }

    [CommandProperty(AccessLevel.GameMaster, AccessLevel.Owner)]
    public IAccount Account { get; set; }

    [CommandProperty(AccessLevel.GameMaster)]
    public int VirtualArmor
    {
        get => m_VirtualArmor;
        set
        {
            if (m_VirtualArmor != value)
            {
                m_VirtualArmor = value;

                Delta(MobileDelta.Armor);
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public virtual double ArmorRating => 0.0;

    /// <summary>
    ///     Overridable. Returns true if the player is alive, false if otherwise. By default, this is computed by:
    ///     <c>!Deleted &amp;&amp; (!Player || !Body.IsGhost)</c>
    /// </summary>
    [CommandProperty(AccessLevel.Counselor)]
    public virtual bool Alive => !Deleted && (!m_Player || !m_Body.IsGhost);

    public static CreateCorpseHandler CreateCorpseHandler { get; set; }

    public virtual bool RetainPackLocsOnDeath => Core.AOS;

    [CommandProperty(AccessLevel.GameMaster)]
    public Container Corpse { get; set; }

    public static char[] GhostChars { get; set; }
    public static bool NoSpeechLOS { get; set; }

    public static TimeSpan AutoManifestTimeout { get; set; } = TimeSpan.FromSeconds(5.0);

    public static bool InsuranceEnabled { get; set; }

    public static int ActionDelay { get; set; } = 500;

    public static VisibleDamageType VisibleDamageType { get; set; }

    public List<DamageEntry> DamageEntries { get; private set; }

    [CommandProperty(AccessLevel.GameMaster)]
    public Mobile LastKiller { get; set; }

    public static bool DefaultShowVisibleDamage { get; set; }

    public static bool DefaultCanSeeVisibleDamage { get; set; }

    public virtual bool ShowVisibleDamage => DefaultShowVisibleDamage;
    public virtual bool CanSeeVisibleDamage => DefaultCanSeeVisibleDamage;

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

    public virtual bool ShouldCheckStatTimers => true;

    [CommandProperty(AccessLevel.GameMaster)]
    public int LightLevel
    {
        get => m_LightLevel;
        set
        {
            if (m_LightLevel != value)
            {
                m_LightLevel = value;

                CheckLightLevels(false);
            }
        }
    }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public string Profile { get; set; }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public bool ProfileLocked { get; set; }

    [CommandProperty(AccessLevel.GameMaster, AccessLevel.Administrator)]
    public bool Player
    {
        get => m_Player;
        set
        {
            m_Player = value;
            InvalidateProperties();
            CheckStatTimers();
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public string Title
    {
        get => m_Title;
        set
        {
            m_Title = value;
            InvalidateProperties();
        }
    }

    public List<Item> Items { get; private set; }

    public virtual int MaxWeight => int.MaxValue;

    public static IWeapon DefaultWeapon { get; set; }

    [CommandProperty(AccessLevel.Counselor, canModify: true)]
    public Skills Skills { get; private set; }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.Administrator)]
    public AccessLevel AccessLevel
    {
        get => m_AccessLevel;
        set
        {
            var oldValue = m_AccessLevel;

            if (oldValue != value)
            {
                m_AccessLevel = value;
                Delta(MobileDelta.Noto);
                InvalidateProperties();

                SendMessage($"Your access level has been changed. You are now {GetAccessLevelName(value)}.");

                ClearScreen();
                SendEverything();

                OnAccessLevelChanged(oldValue);
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public int Fame
    {
        get => m_Fame;
        set
        {
            var oldValue = m_Fame;

            if (oldValue != value)
            {
                m_Fame = value;

                if (ShowFameTitle && (m_Player || m_Body.IsHuman) && oldValue >= 10000 != value >= 10000)
                {
                    InvalidateProperties();
                }

                OnFameChange(oldValue);
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public int Karma
    {
        get => m_Karma;
        set
        {
            var old = m_Karma;

            if (old != value)
            {
                m_Karma = value;
                OnKarmaChange(old);
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public bool Blessed
    {
        get => m_Blessed;
        set
        {
            if (m_Blessed != value)
            {
                m_Blessed = value;
                Delta(MobileDelta.HealthbarYellow);
            }
        }
    }

    public virtual int Luck => 0;

    [Hue]
    [CommandProperty(AccessLevel.GameMaster)]
    public int HueMod
    {
        get => m_HueMod;
        set
        {
            if (m_HueMod != value)
            {
                m_HueMod = value;

                Delta(MobileDelta.Hue);
            }
        }
    }

    [Hue]
    [CommandProperty(AccessLevel.GameMaster)]
    public virtual int Hue
    {
        get => m_HueMod != -1 ? m_HueMod : m_Hue;
        set
        {
            var oldHue = m_Hue;

            if (oldHue != value)
            {
                m_Hue = value;

                Delta(MobileDelta.Hue);
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public Direction Direction
    {
        get => m_Direction;
        set
        {
            if (m_Direction != value)
            {
                m_Direction = value;
                Delta(MobileDelta.Direction);
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public bool Female
    {
        get => m_Female;
        set
        {
            if (m_Female != value)
            {
                m_Female = value;
                Delta(MobileDelta.Flags);
                OnGenderChanged(!m_Female);
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public bool Flying
    {
        get => m_Flying;
        set
        {
            if (m_Flying != value)
            {
                m_Flying = value;
                Delta(MobileDelta.Flags);
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public bool Warmode
    {
        get => m_Warmode;
        set
        {
            if (Deleted)
            {
                return;
            }

            if (m_Warmode != value)
            {
                _autoManifestTimerToken.Cancel();

                m_Warmode = value;
                Delta(MobileDelta.Flags);

                m_NetState.SendSetWarMode(value);

                if (!m_Warmode)
                {
                    Combatant = null;
                }

                if (!Alive)
                {
                    if (value)
                    {
                        Delta(MobileDelta.GhostUpdate);
                    }
                    else
                    {
                        SendRemovePacket(false);
                    }
                }

                OnWarmodeChanged();
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public bool Hidden
    {
        get => m_Hidden;
        set
        {
            if (m_Hidden != value)
            {
                m_Hidden = value;
                // Delta( MobileDelta.Flags );

                OnHiddenChanged();
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster, AccessLevel.Owner)]
    public NetState NetState
    {
        get
        {
            if (m_NetState?.Connection == null)
            {
                m_NetState = null;
            }

            return m_NetState;
        }
        set
        {
            if (m_NetState == value)
            {
                return;
            }

#if THREADGUARD
            if (Thread.CurrentThread != Core.Thread)
            {
                Utility.PushColor(ConsoleColor.Red);
                Console.WriteLine("Attempting to set Mobile.NetState value from an invalid thread!");
                Console.WriteLine(new StackTrace());
                Utility.PopColor();
                return;
            }
#endif

            m_Map?.OnClientChange(m_NetState, value, this);
            m_Target?.Cancel(this, TargetCancelType.Disconnected);
            m_Spell?.OnConnectionChanged();
            m_NetState?.CancelAllTrades();

            var box = FindBankNoCreate();

            if (box?.Opened == true)
            {
                box.Close();
            }

            OnBeforeDisconnected();
            EventSink.InvokeBeforeDisconnected(this);

            m_NetState = value;
            _logoutTimerToken.Cancel();

            if (m_NetState == null)
            {
                OnDisconnected();
                EventSink.InvokeDisconnected(this);

                // Disconnected, start the logout timer
                Timer.StartTimer(GetLogoutDelay(), Logout, out _logoutTimerToken);
            }
            else
            {
                OnConnected();
                EventSink.InvokeConnected(this);

                if (m_Map == Map.Internal && LogoutMap != null)
                {
                    Map = LogoutMap;
                    Location = LogoutLocation;
                }
            }

            for (var i = Items.Count - 1; i >= 0; --i)
            {
                if (i >= Items.Count)
                {
                    continue;
                }

                var item = Items[i];

                if (item is SecureTradeContainer)
                {
                    for (var j = item.Items.Count - 1; j >= 0; --j)
                    {
                        if (j < item.Items.Count)
                        {
                            item.Items[j].OnSecureTrade(this, this, this, false);
                            AddToBackpack(item.Items[j]);
                        }
                    }

                    Timer.StartTimer(item.Delete);
                }
            }

            DropHolding();
            OnNetStateChanged();
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public string Language
    {
        get => m_Language;
        set => m_Language = value;
    }

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

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

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

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

    [CommandProperty(AccessLevel.GameMaster)]
    public string NameMod
    {
        get => m_NameMod;
        set
        {
            if (m_NameMod != value)
            {
                m_NameMod = value;
                Delta(MobileDelta.Name);
                InvalidateProperties();
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public bool YellowHealthbar
    {
        get => m_YellowHealthbar;
        set
        {
            m_YellowHealthbar = value;
            Delta(MobileDelta.HealthbarYellow);
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public string RawName
    {
        get => m_Name;
        set => Name = value;
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public virtual string Name
    {
        get => m_NameMod ?? m_Name;
        set
        {
            if (m_Name != value) // I'm leaving out the && m_NameMod == null
            {
                var oldName = m_Name;
                m_Name = value;
                OnAfterNameChange(oldName, m_Name);
                Delta(MobileDelta.Name);
                InvalidateProperties();
            }
        }
    }

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

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

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

    public DateTime LastStatGain
    {
        get
        {
            var d = LastStrGain;

            if (LastIntGain > d)
            {
                d = LastIntGain;
            }

            if (LastDexGain > d)
            {
                d = LastDexGain;
            }

            return d;
        }
        set
        {
            LastStrGain = value;
            LastIntGain = value;
            LastDexGain = value;
        }
    }

    public Region WalkRegion { get; set; }

    [CommandProperty(AccessLevel.GameMaster)]
    public bool Poisoned => m_Poison != null;

    [CommandProperty(AccessLevel.GameMaster)]
    public bool IsBodyMod => m_BodyMod.BodyID != 0;

    [CommandProperty(AccessLevel.GameMaster)]
    public Body BodyMod
    {
        get => m_BodyMod;
        set
        {
            if (m_BodyMod != value)
            {
                m_BodyMod = value;

                Delta(MobileDelta.Body);
                InvalidateProperties();

                CheckStatTimers();
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public Body Body
    {
        get => IsBodyMod ? m_BodyMod : m_Body;
        set
        {
            if (m_Body != value && !IsBodyMod)
            {
                m_Body = SafeBody(value);

                Delta(MobileDelta.Body);
                InvalidateProperties();

                CheckStatTimers();
            }
        }
    }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public Point3D LogoutLocation { get; set; }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public Map LogoutMap { get; set; }

    public Region Region => m_Region ?? (Map == null ? Map.Internal.DefaultRegion : Map.DefaultRegion);

    [CommandProperty(AccessLevel.GameMaster)]
    public int SolidHueOverride
    {
        get => m_SolidHueOverride;
        set
        {
            if (m_SolidHueOverride == value)
            {
                return;
            }

            m_SolidHueOverride = value;
            Delta(MobileDelta.Hue | MobileDelta.Body);
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public virtual IWeapon Weapon
    {
        get
        {
            if (m_Weapon is Item item && !item.Deleted && item.Parent == this && CanSee(item))
            {
                return m_Weapon;
            }

            m_Weapon = null;

            item = FindItemOnLayer(Layer.OneHanded) ?? FindItemOnLayer(Layer.TwoHanded);

            if (item is IWeapon weapon)
            {
                return m_Weapon = weapon;
            }

            return GetDefaultWeapon();
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public BankBox BankBox
    {
        get
        {
            if (m_BankBox?.Deleted == false && m_BankBox.Parent == this)
            {
                return m_BankBox;
            }

            m_BankBox = FindItemOnLayer<BankBox>(Layer.Bank);

            if (m_BankBox == null)
            {
                AddItem(m_BankBox = new BankBox(this));
            }

            return m_BankBox;
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public Container Backpack
    {
        get
        {
            if (m_Backpack?.Deleted != false || m_Backpack.Parent != this)
            {
                m_Backpack = FindItemOnLayer<Container>(Layer.Backpack);
            }

            return m_Backpack;
        }
    }

    public virtual bool KeepsItemsOnDeath => m_AccessLevel > AccessLevel.Player;

    public bool HasTrade => m_NetState?.Trades.Count > 0;

    public bool NoMoveHS { get; set; }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public int Kills
    {
        get => m_Kills;
        set
        {
            var oldValue = m_Kills;

            if (m_Kills != value)
            {
                m_Kills = Math.Max(value, 0);

                if (oldValue >= 5 != m_Kills >= 5)
                {
                    Delta(MobileDelta.Noto);
                    InvalidateProperties();
                }

                OnKillsChange(oldValue);
            }
        }
    }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public virtual bool Criminal
    {
        get => m_Criminal;
        set
        {
            if (m_Criminal != value)
            {
                m_Criminal = value;
                Delta(MobileDelta.Noto);
                InvalidateProperties();
            }

            _expireCriminalTimerToken.Cancel();

            if (m_Criminal)
            {
                Timer.StartTimer(ExpireCriminalDelay, ExpireCriminal, out _expireCriminalTimerToken);
            }
        }
    }

    public static bool DisableDismountInWarmode { get; set; }

    public static int BodyWeight { get; set; } = 11; // 11 + 3 for the backpack

    [CommandProperty(AccessLevel.GameMaster)]
    public IMount Mount
    {
        get
        {
            Item item = null;

            if (m_MountItem?.Deleted == false && m_MountItem.Parent == this)
            {
                item = m_MountItem;
            }

            item ??= FindItemOnLayer(Layer.Mount);

            if (item is not IMountItem mountItem)
            {
                return null;
            }

            m_MountItem = item;
            return mountItem.Mount;
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public bool Mounted => Mount != null;

    public virtual bool CanTarget => true;
    public virtual bool ClickTitle => true;

    public virtual bool PropertyTitle => OldPropertyTitles ? ClickTitle : true;

    public static bool DisableHiddenSelfClick { get; set; } = true;

    public static bool AsciiClickMessage { get; set; } = true;

    public static bool OldPropertyTitles { get; set; }

    public virtual bool ShowFameTitle // (m_Player || m_Body.IsHuman) && m_Fame >= 10000; }
        => true;

    /// <summary>
    ///     Gets or sets the maximum attainable value for <see cref="RawStr" />, <see cref="RawDex" />, and <see cref="RawInt" />.
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public int StatCap
    {
        get => m_StatCap;
        set
        {
            if (m_StatCap != value)
            {
                m_StatCap = value;

                Delta(MobileDelta.StatCap);
            }
        }
    }

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

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

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

    [CommandProperty(AccessLevel.GameMaster)]
    public bool CanHearGhosts
    {
        get => m_CanHearGhosts || AccessLevel >= AccessLevel.Counselor;
        set => m_CanHearGhosts = value;
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public int RawStatTotal => RawStr + RawDex + RawInt;

    public long NextSpellTime { get; set; }

    public static AllowBeneficialHandler AllowBeneficialHandler { get; set; }

    public static AllowHarmfulHandler AllowHarmfulHandler { get; set; }

    public static SkillCheckTargetHandler SkillCheckTargetHandler { get; set; }

    public static SkillCheckLocationHandler SkillCheckLocationHandler { get; set; }

    public static SkillCheckDirectTargetHandler SkillCheckDirectTargetHandler { get; set; }

    public static SkillCheckDirectLocationHandler SkillCheckDirectLocationHandler { get; set; }

    public static AOSStatusHandler AOSStatusHandler { get; set; }

    public static RegenRateHandler HitsRegenRateHandler { get; set; }

    public static TimeSpan DefaultHitsRate { get; set; }

    public static RegenRateHandler StamRegenRateHandler { get; set; }

    public static TimeSpan DefaultStamRate { get; set; }

    public static RegenRateHandler ManaRegenRateHandler { get; set; }

    public static TimeSpan DefaultManaRate { get; set; }

    public static TimeSpan ExpireCriminalDelay { get; set; } = TimeSpan.FromMinutes(2.0);

    public Prompt Prompt
    {
        get => m_Prompt;
        set
        {
            var oldPrompt = m_Prompt;
            var newPrompt = value;

            if (oldPrompt == newPrompt)
            {
                return;
            }

            m_Prompt = null;

            // TODO: Cancel the prompt anyway?
            if (newPrompt != null)
            {
                oldPrompt?.OnCancel(this);
            }

            m_Prompt = newPrompt;
            NetState.SendPrompt(newPrompt);
        }
    }

    /// <summary>
    ///     Gets or sets the base, unmodified, strength of the Mobile. Ranges from 1 to 65000, inclusive.
    ///     <seealso cref="Str" />
    ///     <seealso cref="StatMod" />
    ///     <seealso cref="OnRawStrChange" />
    ///     <seealso cref="OnRawStatChange" />
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public int RawStr
    {
        get => m_Str;
        set
        {
            value = Math.Clamp(value, 1, 65000);

            if (m_Str != value)
            {
                var oldValue = m_Str;

                m_Str = value;
                Delta(MobileDelta.Stat | MobileDelta.Hits);

                if (Hits < HitsMax)
                {
                    m_HitsTimer ??= new HitsTimer(this);
                    m_HitsTimer.Start();
                }
                else if (Hits > HitsMax)
                {
                    Hits = HitsMax;
                }

                OnRawStrChange(oldValue);
                OnRawStatChange(StatType.Str, oldValue);
            }
        }
    }

    /// <summary>
    ///     Gets or sets the effective strength of the Mobile. This is the sum of the <see cref="RawStr" /> plus any additional
    ///     modifiers. Any attempts to set this value when under the influence of a <see cref="StatMod" /> will result in no change.
    ///     It ranges from 1 to 65000, inclusive.
    ///     <seealso cref="RawStr" />
    ///     <seealso cref="StatMod" />
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public virtual int Str
    {
        get => Math.Clamp(m_Str + GetStatOffset(StatType.Str), 1, 65000);
        set
        {
            if (_statMods == null || _statMods.Count == 0)
            {
                RawStr = value;
            }
        }
    }

    /// <summary>
    ///     Gets or sets the base, unmodified, dexterity of the Mobile. Ranges from 1 to 65000, inclusive.
    ///     <seealso cref="Dex" />
    ///     <seealso cref="StatMod" />
    ///     <seealso cref="OnRawDexChange" />
    ///     <seealso cref="OnRawStatChange" />
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public int RawDex
    {
        get => m_Dex;
        set
        {
            value = Math.Clamp(value, 1, 65000);

            if (m_Dex != value)
            {
                var oldValue = m_Dex;

                m_Dex = value;
                Delta(MobileDelta.Stat | MobileDelta.Stam);

                if (Stam < StamMax)
                {
                    m_StamTimer ??= new StamTimer(this);
                    m_StamTimer.Start();
                }
                else if (Stam > StamMax)
                {
                    Stam = StamMax;
                }

                OnRawDexChange(oldValue);
                OnRawStatChange(StatType.Dex, oldValue);
            }
        }
    }

    /// <summary>
    ///     Gets or sets the effective dexterity of the Mobile. This is the sum of the <see cref="RawDex" /> plus any additional
    ///     modifiers. Any attempts to set this value when under the influence of a <see cref="StatMod" /> will result in no change.
    ///     It ranges from 1 to 65000, inclusive.
    ///     <seealso cref="RawDex" />
    ///     <seealso cref="StatMod" />
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public virtual int Dex
    {
        get => Math.Clamp(m_Dex + GetStatOffset(StatType.Dex), 0, 65000);
        set
        {
            if (_statMods == null || _statMods.Count == 0)
            {
                RawDex = value;
            }
        }
    }

    /// <summary>
    ///     Gets or sets the base, unmodified, intelligence of the Mobile. Ranges from 1 to 65000, inclusive.
    ///     <seealso cref="Int" />
    ///     <seealso cref="StatMod" />
    ///     <seealso cref="OnRawIntChange" />
    ///     <seealso cref="OnRawStatChange" />
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public int RawInt
    {
        get => m_Int;
        set
        {
            value = Math.Clamp(value, 1, 65000);

            if (m_Int != value)
            {
                var oldValue = m_Int;

                m_Int = value;
                Delta(MobileDelta.Stat | MobileDelta.Mana);

                if (Mana < ManaMax)
                {
                    m_ManaTimer ??= new ManaTimer(this);
                    m_ManaTimer.Start();
                }
                else if (Mana > ManaMax)
                {
                    Mana = ManaMax;
                }

                OnRawIntChange(oldValue);
                OnRawStatChange(StatType.Int, oldValue);
            }
        }
    }

    /// <summary>
    ///     Gets or sets the effective intelligence of the Mobile. This is the sum of the <see cref="RawInt" /> plus any additional
    ///     modifiers. Any attempts to set this value when under the influence of a <see cref="StatMod" /> will result in no change.
    ///     It ranges from 1 to 65000, inclusive.
    ///     <seealso cref="RawInt" />
    ///     <seealso cref="StatMod" />
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public virtual int Int
    {
        get => Math.Clamp(m_Int + GetStatOffset(StatType.Int), 0, 65000);
        set
        {
            if (_statMods == null || _statMods.Count == 0)
            {
                RawInt = value;
            }
        }
    }

    /// <summary>
    ///     Gets or sets the current hit point of the Mobile. This value ranges from 0 to <see cref="HitsMax" />, inclusive. When
    ///     set
    ///     to the value of <see cref="HitsMax" />, the <see cref="AggressorInfo.CanReportMurder">CanReportMurder</see> flag of all
    ///     aggressors is reset to false, and the list of damage entries is cleared.
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public int Hits
    {
        get => m_Hits;
        set
        {
            if (Deleted)
            {
                return;
            }

            value = Math.Clamp(value, 0, HitsMax);

            if (value == HitsMax)
            {
                m_HitsTimer?.Stop();

                for (var i = 0; i < Aggressors.Count; i++) // reset reports on full HP
                {
                    Aggressors[i].CanReportMurder = false;
                }

                if (DamageEntries.Count > 0)
                {
                    DamageEntries.Clear(); // reset damage entries on full HP
                }
            }
            else if (CanRegenHits)
            {
                m_HitsTimer ??= new HitsTimer(this);
                m_HitsTimer.Start();
            }
            else
            {
                m_HitsTimer?.Stop();
            }

            if (m_Hits != value)
            {
                var oldValue = m_Hits;
                m_Hits = value;
                Delta(MobileDelta.Hits);
                OnHitsChange(oldValue);
            }
        }
    }

    /// <summary>
    ///     Overridable. Gets the maximum hit point of the Mobile. By default, this returns: <c>50 + (<see cref="Str" /> / 2)</c>
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public virtual int HitsMax => 50 + Str / 2;

    /// <summary>
    ///     Gets or sets the current stamina of the Mobile. This value ranges from 0 to <see cref="StamMax" />, inclusive.
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public int Stam
    {
        get => m_Stam;
        set
        {
            if (Deleted)
            {
                return;
            }

            value = Math.Clamp(value, 0, StamMax);

            if (CanRegenStam && value < StamMax)
            {
                m_StamTimer ??= new StamTimer(this);
                m_StamTimer.Start();
            }
            else
            {
                m_StamTimer?.Stop();
            }

            if (m_Stam != value)
            {
                var oldValue = m_Stam;
                m_Stam = value;
                Delta(MobileDelta.Stam);
                OnStamChange(oldValue);
            }
        }
    }

    /// <summary>
    ///     Overridable. Gets the maximum stamina of the Mobile. By default, this returns:
    ///     <c>
    ///         <see cref="Dex" />
    ///     </c>
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public virtual int StamMax => Dex;

    /// <summary>
    ///     Gets or sets the current stamina of the Mobile. This value ranges from 0 to <see cref="ManaMax" />, inclusive.
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public int Mana
    {
        get => m_Mana;
        set
        {
            if (Deleted)
            {
                return;
            }

            value = Math.Clamp(value, 0, ManaMax);

            if (value == ManaMax)
            {
                m_ManaTimer?.Stop();

                if (Meditating)
                {
                    Meditating = false;
                    SendLocalizedMessage(501846); // You are at peace.
                }
            }
            else if (CanRegenMana)
            {
                m_ManaTimer ??= new ManaTimer(this);
                m_ManaTimer.Start();
            }
            else
            {
                m_ManaTimer?.Stop();
            }

            if (m_Mana != value)
            {
                var oldValue = m_Mana;
                m_Mana = value;
                Delta(MobileDelta.Mana);
                OnManaChange(oldValue);
            }
        }
    }

    /// <summary>
    ///     Overridable. Gets the maximum mana of the Mobile. By default, this returns:
    ///     <c>
    ///         <see cref="Int" />
    ///     </c>
    /// </summary>
    [CommandProperty(AccessLevel.GameMaster)]
    public virtual int ManaMax => Int;

    public Timer PoisonTimer { get; private set; }

    [CommandProperty(AccessLevel.GameMaster)]
    public Poison Poison
    {
        get => m_Poison;
        set
        {
            m_Poison = value;
            Delta(MobileDelta.HealthbarPoison);

            if (PoisonTimer != null)
            {
                PoisonTimer.Stop();
                PoisonTimer = null;
            }

            if (m_Poison != null)
            {
                PoisonTimer = m_Poison.ConstructTimer(this);

                PoisonTimer?.Start();
            }

            CheckStatTimers();
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public int HairItemID
    {
        get => _hair?.ItemId ?? 0;
        set
        {
            if (_hair == null && value > 0)
            {
                _hair = new VirtualHairInfo(value);
            }
            else if (value <= 0)
            {
                _hair = null;
            }
            else if (_hair != null)
            {
                _hair.ItemId = value;
            }

            Delta(MobileDelta.Hair);
            this.MarkDirty();
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public int FacialHairItemID
    {
        get => _facialHair?.ItemId ?? 0;
        set
        {
            if (_facialHair == null && value > 0)
            {
                _facialHair = new VirtualHairInfo(value);
            }
            else if (value <= 0)
            {
                _facialHair = null;
            }
            else if (_facialHair != null)
            {
                _facialHair.ItemId = value;
            }

            Delta(MobileDelta.FacialHair);
            this.MarkDirty();
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public int HairHue
    {
        get => _hair?.Hue ?? 0;
        set
        {
            if (_hair != null)
            {
                _hair.Hue = value;
                Delta(MobileDelta.Hair);
                this.MarkDirty();
            }
        }
    }

    [CommandProperty(AccessLevel.GameMaster)]
    public int FacialHairHue
    {
        get => _facialHair?.Hue ?? 0;
        set
        {
            if (_facialHair != null)
            {
                _facialHair.Hue = value;
                Delta(MobileDelta.FacialHair);
                this.MarkDirty();
            }
        }
    }

    public Item ShieldArmor => FindItemOnLayer(Layer.TwoHanded);

    public Item NeckArmor => FindItemOnLayer(Layer.Neck);

    public Item HandArmor => FindItemOnLayer(Layer.Gloves);

    public Item HeadArmor => FindItemOnLayer(Layer.Helm);

    public Item ArmsArmor => FindItemOnLayer(Layer.Arms);

    public Item LegsArmor => FindItemOnLayer(Layer.InnerLegs) ?? FindItemOnLayer(Layer.Pants);

    public Item ChestArmor => FindItemOnLayer(Layer.InnerTorso) ?? FindItemOnLayer(Layer.Shirt);

    public Item Talisman => FindItemOnLayer(Layer.Talisman);

    public int CompareTo(Mobile other) => other == null ? -1 : Serial.CompareTo(other.Serial);

    public virtual int HuedItemID => m_Female ? 0x2107 : 0x2106;
    public ObjectPropertyList PropertyList => m_PropertyList ??= InitializePropertyList(new ObjectPropertyList(this));

    public virtual void GetProperties(IPropertyList list)
    {
        AddNameProperties(list);
    }

    [IgnoreDupe]
    [CommandProperty(AccessLevel.GameMaster, readOnly: true)]
    public DateTime Created { get; set; } = Core.Now;

    [IgnoreDupe]
    [CommandProperty(AccessLevel.Counselor)]
    public Serial Serial { get; }

    public byte SerializedThread { get; set; }
    public int SerializedPosition { get; set; }
    public int SerializedLength { get; set; }

    public virtual void Serialize(IGenericWriter writer)
    {
        writer.Write(37); // version

        writer.WriteDeltaTime(LastStrGain);
        writer.WriteDeltaTime(LastIntGain);
        writer.WriteDeltaTime(LastDexGain);

        byte hairflag = 0x00;

        if (_hair != null)
        {
            hairflag |= 0x01;
        }

        if (_facialHair != null)
        {
            hairflag |= 0x02;
        }

        writer.Write(hairflag);

        if ((hairflag & 0x01) != 0)
        {
            _hair?.Serialize(writer);
        }

        if ((hairflag & 0x02) != 0)
        {
            _facialHair?.Serialize(writer);
        }

        writer.Write(Race);

        writer.Write(m_TithingPoints);

        writer.Write(Corpse);

        writer.Write(CantWalk);

        // VirtueInfo.Serialize(writer, Virtues);

        writer.Write(Thirst);
        writer.Write(BAC);

        writer.Write(m_FollowersMax);

        writer.Write(MagicDamageAbsorb);

        writer.Write(CanSwim);

        writer.Write(Squelched);

        writer.Write(m_Holding);

        writer.Write(m_VirtualArmor);

        writer.Write(BaseSoundID);

        writer.Write(DisarmReady);
        writer.Write(StunReady);

        writer.Write(m_StatCap);

        writer.Write(NameHue);

        writer.Write(m_Hunger);

        writer.Write(m_Location);
        writer.Write(m_Body);
        writer.Write(m_Name);
        writer.Write(m_Criminal);
        writer.Write(m_Kills);
        writer.Write(SpeechHue);
        writer.Write(EmoteHue);
        writer.Write(WhisperHue);
        writer.Write(YellHue);
        writer.Write(m_Language);
        writer.Write(m_Female);
        writer.Write(m_Warmode);
        writer.Write(m_Hidden);
        writer.Write((byte)m_Direction);
        writer.Write(m_Hue);
        writer.Write(m_Str);
        writer.Write(m_Dex);
        writer.Write(m_Int);
        writer.Write(m_Hits);
        writer.Write(m_Stam);
        writer.Write(m_Mana);

        writer.Write(m_Map);

        writer.Write(m_Blessed);
        writer.Write(m_Fame);
        writer.Write(m_Karma);
        writer.Write((byte)m_AccessLevel);
        Skills.Serialize(writer);

        writer.Write(Items);

        writer.Write(m_Player);
        writer.Write(m_Title);
        writer.Write(Profile);
        writer.Write(ProfileLocked);
        writer.Write(AutoPageNotify);

        writer.Write(LogoutLocation);
        writer.Write(LogoutMap);

        writer.Write((byte)m_StrLock);
        writer.Write((byte)m_DexLock);
        writer.Write((byte)m_IntLock);
    }

    public bool Deleted { get; private set; }

    public virtual void Delete()
    {
        if (Deleted)
        {
            return;
        }

        if (m_NetState != null)
        {
            m_NetState.CancelAllTrades();
            m_NetState.Disconnect($"Player {this} has been deleted.");
        }

        DropHolding();

        Region.OnRegionChange(this, m_Region, null);

        m_Region = null;
        // Is the above line REALLY needed?  The old Region system did NOT have said line
        // and worked fine, because of this a LOT of extra checks have to be done everywhere...
        // I guess this should be there for Garbage collection purposes, but, still, is it /really/ needed?

        OnDelete();

        for (var i = Items.Count - 1; i >= 0; --i)
        {
            if (i < Items.Count)
            {
                Items[i].OnParentDeleted(this);
            }
        }

        SendRemovePacket();

        Deleted = true;

        m_Map?.OnLeave(this);
        m_Map = null;

        _hair = null;
        _facialHair = null;
        m_MountItem = null;

        World.RemoveEntity(this);

        OnAfterDelete();

        m_PropertyList = null;
    }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public Map Map
    {
        get => m_Map;
        set
        {
            if (Deleted)
            {
                return;
            }

            if (m_Map != value)
            {
                m_NetState?.ValidateAllTrades();

                var oldMap = m_Map;

                if (m_Map != null)
                {
                    m_Map.OnLeave(this);

                    ClearScreen();
                    SendRemovePacket();
                }

                for (var i = 0; i < Items.Count; ++i)
                {
                    Items[i].Map = value;
                }

                m_Map = value;
                InternalMapChange(oldMap);
            }
        }
    }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public Point3D Location
    {
        get => m_Location;
        set => SetLocation(value, true);
    }

    private void InternalMapChange(Map oldMap)
    {
        var ns = m_NetState;
        m_Map?.OnEnter(this);
        UpdateRegion();

        if (ns != null)
        {
            ns.Sequence = 0;

            if (m_Map != null)
            {
                ns.SendMapChange(Map);

                ns.SendMapPatches();

                ns.SendSeasonChange((byte)GetSeason(), true);

                ns.SendMobileUpdate(this);
                ns.SendServerChange(m_Location, m_Map);
            }

            ns.SendMobileIncoming(this, this);

            ns.SendMobileUpdate(this);
            CheckLightLevels(true);
            ns.SendMobileUpdate(this);
        }

        SendEverything();
        SendIncomingPacket();

        ns.SendMobileIncoming(this, this);
        ns.SendSupportedFeature();
        ns.SendMobileUpdate(this);
        ns.SendMobileAttributes(this);

        OnMapChange(oldMap);
    }

    public virtual void MoveToWorld(Point3D newLocation, Map map)
    {
        if (Deleted)
        {
            return;
        }

        if (m_Map == map)
        {
            SetLocation(newLocation, true);
            return;
        }

        var box = FindBankNoCreate();

        if (box?.Opened == true)
        {
            box.Close();
        }

        var oldLocation = m_Location;
        var oldMap = m_Map;

        if (oldMap != null)
        {
            oldMap.OnLeave(this);

            ClearScreen();
            SendRemovePacket();
        }

        for (var i = 0; i < Items.Count; ++i)
        {
            Items[i].Map = map;
        }

        m_Map = map;

        m_Location = newLocation;
        InternalMapChange(oldMap);
        OnLocationChange(oldLocation);

        m_Region?.OnLocationChanged(this, oldLocation);
    }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public int X
    {
        get => m_Location.m_X;
        set => Location = new Point3D(value, m_Location.m_Y, m_Location.m_Z);
    }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public int Y
    {
        get => m_Location.m_Y;
        set => Location = new Point3D(m_Location.m_X, value, m_Location.m_Z);
    }

    [CommandProperty(AccessLevel.Counselor, AccessLevel.GameMaster)]
    public int Z
    {
        get => m_Location.m_Z;
        set => Location = new Point3D(m_Location.m_X, m_Location.m_Y, value);
    }

    public virtual void ProcessDelta()
    {
        var delta = m_DeltaFlags;
        if (delta == MobileDelta.None)
        {
            return;
        }

        var attrs = delta & MobileDelta.Attributes;

        m_DeltaFlags = MobileDelta.None;
        m_InDeltaQueue = false;

        bool sendHits = false, sendStam = false, sendMana = false, sendAll = false, sendAny = false;
        bool sendIncoming = false, sendNonlocalIncoming = false;
        bool sendUpdate = false, sendRemove = false;
        bool sendPublicStats = false, sendPrivateStats = false;
        bool sendMoving = false, sendNonlocalMoving = false;
        var sendOPLUpdate = ObjectPropertyList.Enabled && (delta & MobileDelta.Properties) != 0;

        bool sendHair = false, sendFacialHair = false, removeHair = false, removeFacialHair = false;

        bool sendHealthbarPoison = false, sendHealthbarYellow = false;

        if (attrs != MobileDelta.None)
        {
            sendAny = true;

            if (attrs == MobileDelta.Attributes)
            {
                sendAll = true;
            }
            else
            {
                sendHits = (attrs & MobileDelta.Hits) != 0;
                sendStam = (attrs & MobileDelta.Stam) != 0;
                sendMana = (attrs & MobileDelta.Mana) != 0;
            }
        }

        if ((delta & MobileDelta.GhostUpdate) != 0)
        {
            sendNonlocalIncoming = true;
        }

        if ((delta & MobileDelta.Hue) != 0)
        {
            sendNonlocalIncoming = true;
            sendUpdate = true;
            sendRemove = true;
        }

        if ((delta & MobileDelta.Direction) != 0)
        {
            sendNonlocalMoving = true;
            sendUpdate = true;
        }

        if ((delta & MobileDelta.Body) != 0)
        {
            sendUpdate = true;
            sendIncoming = true;
        }

        if ((delta & (MobileDelta.Flags | MobileDelta.Noto)) != 0)
        {
            sendMoving = true;
        }

        if ((delta & MobileDelta.HealthbarPoison) != 0)
        {
            sendHealthbarPoison = true;
        }

        if ((delta & MobileDelta.HealthbarYellow) != 0)
        {
            sendHealthbarYellow = true;
        }

        if ((delta & MobileDelta.Name) != 0)
        {
            sendAll = false;
            sendHits = false;
            sendAny = sendStam || sendMana;
            sendPublicStats = true;
        }

        if ((delta & (MobileDelta.WeaponDamage | MobileDelta.Resistances | MobileDelta.Stat |
                      MobileDelta.Weight | MobileDelta.Gold | MobileDelta.Armor | MobileDelta.StatCap |
                      MobileDelta.Followers | MobileDelta.TithingPoints | MobileDelta.Race)) != 0)
        {
            sendPrivateStats = true;
        }

        if ((delta & MobileDelta.Hair) != 0)
        {
            if (HairItemID <= 0)
            {
                removeHair = true;
            }

            sendHair = true;
        }

        if ((delta & MobileDelta.FacialHair) != 0)
        {
            if (FacialHairItemID <= 0)
            {
                removeFacialHair = true;
            }

            sendFacialHair = true;
        }

        var hairSerial = Hair.VirtualSerial;
        var hairLength = removeHair
            ? OutgoingVirtualHairPackets.RemovePacketLength
            : OutgoingVirtualHairPackets.EquipUpdatePacketLength;

        Span<byte> hairPacket = stackalloc byte[hairLength].InitializePacket();

        var facialHairSerial = FacialHair.VirtualSerial;
        var facialHairLength = removeFacialHair
            ? OutgoingVirtualHairPackets.RemovePacketLength
            : OutgoingVirtualHairPackets.EquipUpdatePacketLength;

        Span<byte> facialHairPacket = stackalloc byte[facialHairLength].InitializePacket();

        const int cacheLength = OutgoingMobilePackets.MobileMovingPacketCacheByteLength;

        Span<byte> mobileMovingCache = stackalloc byte[cacheLength];
        mobileMovingCache.Clear();

        var ourState = m_NetState;

        if (ourState != null)
        {
            if (sendUpdate)
            {
                ourState.Sequence = 0;
                ourState.SendMobileUpdate(this);
            }

            if (sendIncoming)
            {
                ourState.SendMobileIncoming(this, this);
            }

            if (sendMoving || !ourState.StygianAbyss && (sendHealthbarPoison || sendHealthbarYellow))
            {
                ourState.SendMobileMovingUsingCache(mobileMovingCache, this, this);
            }

            if (ourState.StygianAbyss)
            {
                if (sendHealthbarPoison)
                {
                    ourState.SendMobileHealthbar(this, Healthbar.Poison);
                }

                if (sendHealthbarYellow)
                {
                    ourState.SendMobileHealthbar(this, Healthbar.Yellow);
                }
            }

            if (sendPublicStats || sendPrivateStats)
            {
                ourState.SendMobileStatus(this);
            }
            else if (sendAll)
            {
                ourState.SendMobileAttributes(this);
            }
            else if (sendAny)
            {
                if (sendHits)
                {
                    ourState.SendMobileHits(this);
                }

                if (sendMana)
                {
                    ourState.SendMobileMana(this);
                }

                if (sendStam)
                {
                    ourState.SendMobileStam(this);
                }
            }

            if (sendStam || sendMana)
            {
                if (Party is IParty ip)
                {
                    if (sendMana)
                    {
                        ip.OnManaChanged(this);
                    }

                    if (sendStam)
                    {
                        ip.OnStamChanged(this);
                    }
                }
            }

            if (sendHair)
            {
                if (removeHair)
                {
                    OutgoingVirtualHairPackets.CreateRemoveHairPacket(hairPacket, (uint)hairSerial);
                }
                else
                {
                    OutgoingVirtualHairPackets.CreateHairEquipUpdatePacket(
                        hairPacket,
                        this,
                        (uint)hairSerial,
                        HairItemID,
                        HairHue,
                        Layer.Hair
                    );
                }

                ourState.Send(hairPacket);
            }

            if (sendFacialHair)
            {
                if (removeFacialHair)
                {
                    OutgoingVirtualHairPackets.CreateRemoveHairPacket(facialHairPacket, (uint)facialHairSerial);
                }
                else
                {
                    OutgoingVirtualHairPackets.CreateHairEquipUpdatePacket(
                        facialHairPacket,
                        this,
                        (uint)facialHairSerial,
                        FacialHairItemID,
                        FacialHairHue,
                        Layer.FacialHair
                    );
                }

                ourState.Send(facialHairPacket);
            }

            if (sendOPLUpdate)
            {
                SendOPLPacketTo(ourState);
            }
        }

        // TODO: Is it even valid to send packets to our state while we have a null map? Look into failing fast
        if (m_Map == null)
        {
            return;
        }

        sendMoving = sendMoving || sendNonlocalMoving;
        sendIncoming = sendIncoming || sendNonlocalIncoming;
        sendHits = sendHits || sendAll;

        if (!(sendRemove || sendIncoming || sendPublicStats || sendHits || sendMoving ||
              sendOPLUpdate || sendHair || sendFacialHair || sendHealthbarPoison ||
              sendHealthbarYellow))
        {
            return;
        }

        Span<byte> statBufferTrue = stackalloc byte[OutgoingMobilePackets.MobileStatusCompactLength].InitializePacket();
        Span<byte> statBufferFalse = stackalloc byte[OutgoingMobilePackets.MobileStatusCompactLength].InitializePacket();
        Span<byte> hbpBuffer = stackalloc byte[OutgoingMobilePackets.MobileHealthbarPacketLength].InitializePacket();
        Span<byte> hbyBuffer = stackalloc byte[OutgoingMobilePackets.MobileHealthbarPacketLength].InitializePacket();
        Span<byte> deadBuffer = stackalloc byte[OutgoingMobilePackets.BondedStatusPacketLength].InitializePacket();
        Span<byte> removeEntity = stackalloc byte[OutgoingEntityPackets.RemoveEntityLength].InitializePacket();
        Span<byte> hitsPacket = stackalloc byte[OutgoingMobilePackets.MobileAttributePacketLength].InitializePacket();

        foreach (var state in Map.GetClientsInRange(m_Location))
        {
            var beholder = state.Mobile;

            if (beholder == this || !beholder.CanSee(this))
            {
                continue;
            }

            if (sendRemove)
            {
                OutgoingEntityPackets.CreateRemoveEntity(removeEntity, Serial);
                state.Send(removeEntity);
            }

            if (sendIncoming)
            {
                state.SendMobileIncoming(beholder, this);

                if (IsDeadBondedPet)
                {
                    OutgoingMobilePackets.CreateBondedStatus(deadBuffer, Serial, true);
                    state.Send(deadBuffer);
                }
            }

            if (sendMoving || !state.StygianAbyss && (sendHealthbarPoison || sendHealthbarYellow))
            {
                state.SendMobileMovingUsingCache(mobileMovingCache, beholder, this);
            }

            if (state.StygianAbyss)
            {
                if (sendHealthbarPoison)
                {
                    OutgoingMobilePackets.CreateMobileHealthbar(hbpBuffer, this, Healthbar.Poison);
                    state.Send(hbpBuffer);
                }

                if (sendHealthbarYellow)
                {
                    OutgoingMobilePackets.CreateMobileHealthbar(hbyBuffer, this, Healthbar.Yellow);
                    state.Send(hbyBuffer);
                }
            }

            if (sendPublicStats)
            {
                if (CanBeRenamedBy(beholder))
                {
                    OutgoingMobilePackets.CreateMobileStatusCompact(statBufferTrue, this, true);
                    state.Send(statBufferTrue);
                }
                else
                {
                    OutgoingMobilePackets.CreateMobileStatusCompact(statBufferFalse, this, false);
                    state.Send(statBufferFalse);
                }
            }
            else if (sendHits)
            {
                OutgoingMobilePackets.CreateMobileHits(hitsPacket, this, true);
                state.Send(hitsPacket);
            }

            if (sendHair)
            {
                if (removeHair)
                {
                    OutgoingVirtualHairPackets.CreateRemoveHairPacket(hairPacket, (uint)hairSerial);
                }
                else
                {
                    OutgoingVirtualHairPackets.CreateHairEquipUpdatePacket(
                        hairPacket,
                        this,
                        (uint)hairSerial,
                        HairItemID,
                        HairHue,
                        Layer.Hair
                    );
                }

                state.Send(hairPacket);
            }

            if (sendFacialHair)
            {
                if (removeFacialHair)
                {
                    OutgoingVirtualHairPackets.CreateRemoveHairPacket(facialHairPacket, (uint)facialHairSerial);
                }
                else
                {
                    OutgoingVirtualHairPackets.CreateHairEquipUpdatePacket(
                        facialHairPacket,
                        this,
                        (uint)facialHairSerial,
                        FacialHairItemID,
                        FacialHairHue,
                        Layer.FacialHair
                    );
                }

                state.Send(facialHairPacket);
            }

            SendOPLPacketTo(state);
        }
    }

    public ISpawner Spawner { get; set; }

    public virtual void OnBeforeSpawn(Point3D location, Map m)
    {
    }

    public virtual void OnAfterSpawn()
    {
    }

    public virtual bool InRange(Point2D p, int range) =>
        p.m_X >= Location.m_X - range
        && p.m_X <= Location.m_X + range
        && p.m_Y >= Location.m_Y - range
        && p.m_Y <= Location.m_Y + range;

    public virtual bool InRange(Point3D p, int range) =>
        p.m_X >= Location.m_X - range
        && p.m_X <= Location.m_X + range
        && p.m_Y >= Location.m_Y - range
        && p.m_Y <= Location.m_Y + range;

    public virtual bool InRange(IPoint2D p, int range) =>
        p.X >= Location.m_X - range
        && p.X <= Location.m_X + range
        && p.Y >= Location.m_Y - range
        && p.Y <= Location.m_Y + range;

    protected virtual void OnRaceChange(Race oldRace)
    {
    }

    public virtual void ComputeLightLevels(out int global, out int personal)
    {
        ComputeBaseLightLevels(out global, out personal);

        m_Region?.AlterLightLevel(this, ref global, ref personal);
    }

    public virtual void ComputeBaseLightLevels(out int global, out int personal)
    {
        global = 0;
        personal = m_LightLevel;
    }

    public virtual void CheckLightLevels(bool forceResend)
    {
    }

    public virtual void UpdateResistances()
    {
        var delta = false;

        if (Resistances == null)
        {
            Resistances = new[] { int.MinValue, int.MinValue, int.MinValue, int.MinValue, int.MinValue };
        }
        else
        {
            for (var i = 0; i < Resistances.Length; ++i)
            {
                if (Resistances[i] != int.MinValue)
                {
                    Resistances[i] = int.MinValue;
                    delta = true;
                }
            }
        }

        if (delta)
        {
            Delta(MobileDelta.Resistances);
        }
    }

    public virtual int GetResistance(ResistanceType type)
    {
        var v = (int)type;

        if (Resistances == null || Resistances.Length == 0 || v < 0 || v >= Resistances.Length)
        {
            return 0;
        }

        var res = Resistances[v];

        if (res == int.MinValue)
        {
            ComputeResistances();
            res = Resistances[v];
        }

        return res;
    }

    public virtual void AddResistanceMod(ResistanceMod mod)
    {
        if (mod == null)
        {
            return;
        }

        _resistanceMods ??= new List<ResistanceMod>();
        _resistanceMods.Add(mod);

        UpdateResistances();
    }

    public virtual ResistanceMod GetResistanceMod(string name)
    {
        if (_resistanceMods == null || name == null)
        {
            return null;
        }

        for (var i = 0; i < _resistanceMods.Count; i++)
        {
            var mod = _resistanceMods[i];
            if (mod.Name == name)
            {
                return mod;
            }
        }

        return null;
    }

    public virtual void RemoveResistanceMod(string name)
    {
        if (_resistanceMods == null || name == null)
        {
            return;
        }

        for (var i = _resistanceMods.Count - 1; i >= 0; i--)
        {
            var mod = _resistanceMods[i];
            if (mod.Name == name)
            {
                _resistanceMods.RemoveAt(i);
            }
        }

        if (_resistanceMods.Count == 0)
        {
            _resistanceMods = null;
        }

        UpdateResistances();
    }

    public virtual void RemoveResistanceMod(ResistanceMod mod)
    {
        if (_resistanceMods == null)
        {
            return;
        }

        _resistanceMods.Remove(mod);

        if (_resistanceMods.Count == 0)
        {
            _resistanceMods = null;
        }

        UpdateResistances();
    }

    public virtual void ComputeResistances()
    {
        Resistances ??= new[] { int.MinValue, int.MinValue, int.MinValue, int.MinValue, int.MinValue };

        for (var i = 0; i < Resistances.Length; ++i)
        {
            Resistances[i] = 0;
        }

        Resistances[0] += BasePhysicalResistance;
        Resistances[1] += BaseFireResistance;
        Resistances[2] += BaseColdResistance;
        Resistances[3] += BasePoisonResistance;
        Resistances[4] += BaseEnergyResistance;

        if (_resistanceMods != null)
        {
            for (var i = 0; i < _resistanceMods.Count; i++)
            {
                var mod = _resistanceMods[i];
                var v = (int)mod.Type;

                if (v >= 0 && v < Resistances.Length)
                {
                    Resistances[v] += mod.Offset;
                }
            }
        }

        for (var i = 0; i < Items.Count; ++i)
        {
            var item = Items[i];

            if (item.CheckPropertyConflict(this))
            {
                continue;
            }

            Resistances[0] += item.PhysicalResistance;
            Resistances[1] += item.FireResistance;
            Resistances[2] += item.ColdResistance;
            Resistances[3] += item.PoisonResistance;
            Resistances[4] += item.EnergyResistance;
        }

        for (var i = 0; i < Resistances.Length; ++i)
        {
            var min = GetMinResistance((ResistanceType)i);
            var max = GetMaxResistance((ResistanceType)i);

            if (max < min)
            {
                max = min;
            }

            if (Resistances[i] > max)
            {
                Resistances[i] = max;
            }
            else if (Resistances[i] < min)
            {
                Resistances[i] = min;
            }
        }
    }

    public virtual int GetMinResistance(ResistanceType type) => int.MinValue;

    public virtual int GetMaxResistance(ResistanceType type) => m_Player ? MaxPlayerResistance : int.MaxValue;

    public int GetAOSStatus(int index) => AOSStatusHandler?.Invoke(this, index) ?? 0;

    public virtual void SendPropertiesTo(NetState ns)
    {
        ns?.Send(PropertyList.Buffer);
    }

    public virtual void OnAosSingleClick(Mobile from)
    {
        var opl = PropertyList;

        if (opl.Header > 0)
        {
            int hue;

            if (NameHue != -1)
            {
                hue = NameHue;
            }
            else if (m_AccessLevel > AccessLevel.Player)
            {
                hue = 11;
            }
            else
            {
                hue = Notoriety.GetHue(Notoriety.Compute(from, this));
            }

            from.NetState.SendMessageLocalized(Serial, Body, MessageType.Label, hue, 3, opl.Header, Name, opl.HeaderArgs);
        }
    }

    public virtual string ApplyNameSuffix(string suffix) => suffix;

    public virtual void AddNameProperties(IPropertyList list)
    {
        string prefix;

        if (ShowFameTitle && (m_Player || m_Body.IsHuman) && m_Fame >= 10000)
        {
            prefix = m_Female ? "Lady " : "Lord ";
        }
        else
        {
            prefix = " ";
        }

        var hasTitle = PropertyTitle && !string.IsNullOrEmpty(Title);

        string suffix = hasTitle ? $"{Title}" : "";

        list.Add(1050045, $"{prefix}\t{Name ?? " "}\t{ApplyNameSuffix(suffix).DefaultIfNullOrEmpty(" ")}"); // ~1_PREFIX~~2_NAME~~3_SUFFIX~
    }

    public virtual void GetChildProperties(IPropertyList list, Item item)
    {
    }

    public virtual void GetChildNameProperties(IPropertyList list, Item item)
    {
    }

    private void UpdateAggrExpire()
    {
        if (Deleted || Aggressors.Count == 0 && Aggressed.Count == 0)
        {
            StopAggrExpire();
        }
        else if (!_expireAggrTimerToken.Running)
        {
            Timer.StartTimer(ExpireAggressorsDelay, ExpireAggressorsDelay, ExpireAggr, out _expireAggrTimerToken);
        }
    }

    private void ExpireAggr()
    {
        if (Deleted || Aggressors.Count == 0 && Aggressed.Count == 0)
        {
            StopAggrExpire();
        }
        else
        {
            CheckAggrExpire();
        }
    }

    private void StopAggrExpire()
    {
        _expireAggrTimerToken.Cancel();
    }

    private void CheckAggrExpire()
    {
        for (var i = Aggressors.Count - 1; i >= 0; --i)
        {
            if (i >= Aggressors.Count)
            {
                continue;
            }

            var info = Aggressors[i];

            if (info.Expired)
            {
                var attacker = info.Attacker;
                attacker.RemoveAggressed(this);

                Aggressors.RemoveAt(i);
                info.Free();

                if (m_NetState != null && CanSee(attacker) && Utility.InUpdateRange(m_Location, attacker.m_Location))
                {
                    m_NetState.SendMobileIncoming(this, attacker);
                }
            }
        }

        for (var i = Aggressed.Count - 1; i >= 0; --i)
        {
            if (i >= Aggressed.Count)
            {
                continue;
            }

            var info = Aggressed[i];

            if (info.Expired)
            {
                var defender = info.Defender;
                defender.RemoveAggressor(this);

                Aggressed.RemoveAt(i);
                info.Free();

                if (m_NetState != null && CanSee(defender) && Utility.InUpdateRange(m_Location, defender.m_Location))
                {
                    m_NetState.SendMobileIncoming(this, defender);
                }
            }
        }

        UpdateAggrExpire();
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when <paramref name="skill" /> changes in some way.
    /// </summary>
    public virtual void OnSkillInvalidated(Skill skill)
    {
    }

    public virtual void ValidateSkillMods()
    {
        if (_skillMods == null)
        {
            return;
        }

        for (var i = _skillMods.Count - 1; i >= 0; i--)
        {
            var mod = _skillMods[i];

            if (!mod.CheckCondition())
            {
                _skillMods.RemoveAt(i);
                mod.Owner = null;
                Skills[mod.Skill]?.Update();
            }
        }
    }

    public virtual void AddSkillMod(SkillMod mod)
    {
        if (mod == null)
        {
            return;
        }

        ValidateSkillMods();
        _skillMods ??= new List<SkillMod>();
        _skillMods.Add(mod);
        mod.Owner = this;
        Skills[mod.Skill]?.Update();
    }

    public virtual SkillMod GetSkillMod(string name)
    {
        if (_skillMods == null || name == null)
        {
            return null;
        }

        ValidateSkillMods();

        for (var i = 0; i < _skillMods.Count; i++)
        {
            var mod = _skillMods[i];
            if (mod.Name == name)
            {
                return mod;
            }
        }

        return null;
    }

    public virtual void RemoveSkillMod(string name)
    {
        if (_skillMods == null || name == null)
        {
            return;
        }

        for (var i = _skillMods.Count - 1; i >= 0; i--)
        {
            var mod = _skillMods[i];
            if (mod.Name == name)
            {
                mod.Owner = null;
                Skills[mod.Skill]?.Update();
                _skillMods.RemoveAt(i);
            }
        }

        ValidateSkillMods();

        if (_skillMods.Count == 0)
        {
            _skillMods = null;
        }
    }

    public virtual void RemoveSkillMod(SkillMod mod)
    {
        if (_skillMods == null || mod == null)
        {
            return;
        }

        if (_skillMods.Remove(mod))
        {
            mod.Owner = null;
            Skills[mod.Skill]?.Update();
        }

        ValidateSkillMods();

        if (_skillMods.Count == 0)
        {
            _skillMods = null;
        }
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when a client, <paramref name="from" />, invokes a 'help request' for the Mobile.
    ///     Seemingly no longer functional in newer clients.
    /// </summary>
    public virtual void OnHelpRequest(Mobile from)
    {
    }

    public void DelayChangeWarmode(bool value)
    {
        if (m_WarmodeChanges > WarmodeCatchCount)
        {
            _warmodeSpamValue = value;
            m_WarmodeChanges++;
            return;
        }

        if (m_Warmode == value)
        {
            return;
        }

        var now = Core.Now;
        var next = m_NextWarmodeChange;

        if (now > next || m_WarmodeChanges == 0)
        {
            m_WarmodeChanges = 1;
            m_NextWarmodeChange = now + WarmodeSpamCatch;
        }
        else if (m_WarmodeChanges++ == WarmodeCatchCount)
        {
            Timer.StartTimer(WarmodeSpamDelay, WarmodeSpamTimeout);
            return;
        }

        Warmode = value;
    }

    private void WarmodeSpamTimeout()
    {
        Warmode = _warmodeSpamValue;
        m_WarmodeChanges = 0;
    }

    public bool InLOS(Mobile target) =>
        !Deleted && m_Map != null &&
        (target == this || m_AccessLevel > AccessLevel.Player || m_Map.LineOfSight(this, target));

    public bool InLOS(object target) =>
        !Deleted && m_Map != null &&
        (target == this || m_AccessLevel > AccessLevel.Player || target is Item item && item.RootParent == this
         || m_Map.LineOfSight(this, target));

    public bool InLOS(Point3D target) =>
        !Deleted && m_Map != null && (m_AccessLevel > AccessLevel.Player || m_Map.LineOfSight(this, target));

    public bool AtPoint(int x, int y) => m_Location.m_X == x && m_Location.m_Y == y;

    public bool BeginAction<T>() => BeginAction(typeof(T));

    public bool BeginAction(object toLock)
    {
        if (_actions == null)
        {
            _actions = new List<object> { toLock };
            return true;
        }

        if (!_actions.Contains(toLock))
        {
            _actions.Add(toLock);
            return true;
        }

        return false;
    }

    public bool CanBeginAction<T>() => CanBeginAction(typeof(T));

    public bool CanBeginAction(object toLock) => _actions?.Contains(toLock) != true;

    public void EndAction<T>() => EndAction(typeof(T));

    public void EndAction(object toLock)
    {
        if (_actions != null)
        {
            _actions.Remove(toLock);

            if (_actions.Count == 0)
            {
                _actions = null;
            }
        }
    }

    public virtual TimeSpan GetLogoutDelay() => Region.GetLogoutDelay(this);

    private void ExpireParalyzed()
    {
        Paralyzed = false;
    }

    public virtual void Paralyze(TimeSpan duration)
    {
        if (!m_Paralyzed)
        {
            Paralyzed = true;
            Timer.StartTimer(duration, ExpireParalyzed, out _paraTimerToken);
        }
    }

    private void ExpireFrozen()
    {
        Frozen = false;
    }

    public virtual void Freeze(TimeSpan duration)
    {
        if (!m_Frozen)
        {
            Frozen = true;
            Timer.StartTimer(duration, ExpireFrozen, out _frozenTimerToken);
        }
    }

    public override string ToString() => $"{Serial} \"{Name}\"";

    public virtual void SendSkillMessage()
    {
        if (NextActionMessage - Core.TickCount >= 0)
        {
            return;
        }

        NextActionMessage = Core.TickCount + ActionMessageDelay;

        SendLocalizedMessage(500118); // You must wait a few moments to use another skill.
    }

    public virtual void SendActionMessage()
    {
        if (NextActionMessage - Core.TickCount >= 0)
        {
            return;
        }

        NextActionMessage = Core.TickCount + ActionMessageDelay;

        SendLocalizedMessage(500119); // You must wait to perform another action.
    }

    public virtual void ClearHands()
    {
        ClearHand(FindItemOnLayer(Layer.OneHanded));
        ClearHand(FindItemOnLayer(Layer.TwoHanded));
    }

    public virtual void ClearHand(Item item)
    {
        if (item?.Movable == true && !item.AllowEquippedCast(this))
        {
            var pack = Backpack;

            if (pack == null)
            {
                AddToBackpack(item);
            }
            else
            {
                pack.DropItem(item);
            }
        }
    }

    public virtual void Attack(Mobile m)
    {
        if (CheckAttack(m))
        {
            Combatant = m;
        }
    }

    public virtual bool CheckAttack(Mobile m) => Utility.InUpdateRange(Location, m.Location) && CanSee(m) && InLOS(m);

    /// <summary>
    ///     Overridable. Virtual event invoked after the <see cref="Combatant" /> property has changed.
    ///     <seealso cref="Combatant" />
    /// </summary>
    public virtual void OnCombatantChange()
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked after the <see cref="Hunger" /> property has changed.
    ///     <seealso cref="Hunger" />
    /// </summary>
    public virtual void OnHungerChanged(int oldValue)
    {
    }

    public double GetDistanceToSqrt(Point3D p)
    {
        var xDelta = m_Location.m_X - p.m_X;
        var yDelta = m_Location.m_Y - p.m_Y;

        return Math.Sqrt(xDelta * xDelta + yDelta * yDelta);
    }

    public double GetDistanceToSqrt(Mobile m)
    {
        var xDelta = m_Location.m_X - m.m_Location.m_X;
        var yDelta = m_Location.m_Y - m.m_Location.m_Y;

        return Math.Sqrt(xDelta * xDelta + yDelta * yDelta);
    }

    public double GetDistanceToSqrt(Point2D p)
    {
        var xDelta = m_Location.m_X - p.X;
        var yDelta = m_Location.m_Y - p.Y;

        return Math.Sqrt(xDelta * xDelta + yDelta * yDelta);
    }

    public double GetDistanceToSqrt(IPoint2D p)
    {
        var xDelta = m_Location.m_X - p.X;
        var yDelta = m_Location.m_Y - p.Y;

        return Math.Sqrt(xDelta * xDelta + yDelta * yDelta);
    }

    public virtual void AggressiveAction(Mobile aggressor) => AggressiveAction(aggressor, false);

    public virtual void AggressiveAction(Mobile aggressor, bool criminal)
    {
        if (aggressor == this)
        {
            return;
        }

        var args = AggressiveActionEventArgs.Create(this, aggressor, criminal);

        EventSink.InvokeAggressiveAction(args);

        args.Free();

        if (Combatant == aggressor)
        {
            _expireCombatantTimerToken.Cancel();
            Timer.StartTimer(ExpireCombatantDelay, ExpireCombatant, out _expireCombatantTimerToken);
        }

        var addAggressor = true;

        var list = Aggressors;

        for (var i = 0; i < list.Count; ++i)
        {
            var info = list[i];

            if (info.Attacker == aggressor)
            {
                info.Refresh();
                info.CriminalAggression = criminal;
                info.CanReportMurder = criminal;

                addAggressor = false;
            }
        }

        list = aggressor.Aggressors;

        for (var i = 0; i < list.Count; ++i)
        {
            var info = list[i];

            if (info.Attacker == this)
            {
                info.Refresh();

                addAggressor = false;
            }
        }

        var addAggressed = true;

        list = Aggressed;

        for (var i = 0; i < list.Count; ++i)
        {
            var info = list[i];

            if (info.Defender == aggressor)
            {
                info.Refresh();

                addAggressed = false;
            }
        }

        list = aggressor.Aggressed;

        for (var i = 0; i < list.Count; ++i)
        {
            var info = list[i];

            if (info.Defender == this)
            {
                info.Refresh();
                info.CriminalAggression = criminal;
                info.CanReportMurder = criminal;

                addAggressed = false;
            }
        }

        var setCombatant = false;

        if (addAggressor)
        {
            Aggressors.Add(
                AggressorInfo.Create(
                    aggressor,
                    this,
                    criminal
                )
            );

            if (CanSee(aggressor))
            {
                m_NetState.SendMobileIncoming(this, aggressor);
            }

            if (Combatant == null)
            {
                setCombatant = true;
            }

            UpdateAggrExpire();
        }

        if (addAggressed)
        {
            aggressor.Aggressed.Add(
                AggressorInfo.Create(
                    aggressor,
                    this,
                    criminal
                )
            );

            if (CanSee(aggressor))
            {
                m_NetState.SendMobileIncoming(this, aggressor);
            }

            if (Combatant == null)
            {
                setCombatant = true;
            }

            UpdateAggrExpire();
        }

        if (setCombatant)
        {
            Combatant = aggressor;
        }

        Region.OnAggressed(aggressor, this, criminal);
    }

    public void RemoveAggressed(Mobile aggressed)
    {
        if (Deleted)
        {
            return;
        }

        var list = Aggressed;

        for (var i = 0; i < list.Count; ++i)
        {
            var info = list[i];

            if (info.Defender == aggressed)
            {
                Aggressed.RemoveAt(i);
                info.Free();

                if (m_NetState != null && CanSee(aggressed))
                {
                    m_NetState.SendMobileIncoming(this, aggressed);
                }

                break;
            }
        }

        UpdateAggrExpire();
    }

    public void RemoveAggressor(Mobile aggressor)
    {
        if (Deleted)
        {
            return;
        }

        var list = Aggressors;

        for (var i = 0; i < list.Count; ++i)
        {
            var info = list[i];

            if (info.Attacker == aggressor)
            {
                Aggressors.RemoveAt(i);
                info.Free();

                if (m_NetState != null && CanSee(aggressor))
                {
                    m_NetState.SendMobileIncoming(this, aggressor);
                }

                break;
            }
        }

        UpdateAggrExpire();
    }

    public virtual int GetTotal(TotalType type) =>
        type switch
        {
            TotalType.Gold   => m_TotalGold,
            TotalType.Items  => m_TotalItems,
            TotalType.Weight => m_TotalWeight,
            _                => 0
        };

    public virtual void UpdateTotal(Item sender, TotalType type, int delta)
    {
        if (delta == 0 || sender.IsVirtualItem)
        {
            return;
        }

        switch (type)
        {
            default:
                {
                    m_TotalGold += delta;
                    Delta(MobileDelta.Gold);
                    break;
                }

            case TotalType.Items:
                {
                    m_TotalItems += delta;
                    break;
                }

            case TotalType.Weight:
                {
                    m_TotalWeight += delta;
                    Delta(MobileDelta.Weight);
                    OnWeightChange(m_TotalWeight - delta);
                    break;
                }
        }
    }

    public virtual void UpdateTotals()
    {
        if (Items == null)
        {
            return;
        }

        var oldWeight = m_TotalWeight;

        m_TotalGold = 0;
        m_TotalItems = 0;
        m_TotalWeight = 0;

        for (var i = 0; i < Items.Count; ++i)
        {
            var item = Items[i];

            item.UpdateTotals();

            if (item.IsVirtualItem)
            {
                continue;
            }

            m_TotalGold += item.TotalGold;
            m_TotalItems += item.TotalItems + 1;
            m_TotalWeight += item.TotalWeight + item.PileWeight;
        }

        if (m_Holding != null)
        {
            m_TotalWeight += m_Holding.TotalWeight + m_Holding.PileWeight;
        }

        if (m_TotalWeight != oldWeight)
        {
            OnWeightChange(oldWeight);
        }
    }

    public void ClearTarget() => m_Target = null;

    public Target BeginTarget(int range, bool allowGround, TargetFlags flags, TargetCallback callback) =>
        Target = new SimpleTarget(range, flags, allowGround, callback);

    public Target BeginTarget<T>(
        int range, bool allowGround, TargetFlags flags, TargetStateCallback<T> callback,
        T state
    ) =>
        Target = new SimpleStateTarget<T>(range, flags, allowGround, callback, state);

    /// <summary>
    ///     Overridable. Virtual event invoked after the <see cref="Target">Target property</see> has changed.
    /// </summary>
    protected virtual void OnTargetChange()
    {
    }

    public virtual bool CheckContextMenuDisplay(IEntity target) => true;

    private bool InternalOnMove(Direction d)
    {
        if (!OnMove(d))
        {
            return false;
        }

        var e = MovementEventArgs.Create(this, d);

        EventSink.InvokeMovement(e);

        var ret = !e.Blocked;

        e.Free();

        return ret;
    }

    /// <summary>
    ///     Overridable. Event invoked before the Mobile <see cref="Move">moves</see>.
    /// </summary>
    /// <returns>True if the move is allowed, false if not.</returns>
    protected virtual bool OnMove(Direction d)
    {
        if (m_Hidden && m_AccessLevel == AccessLevel.Player)
        {
            if (AllowedStealthSteps-- <= 0 || (d & Direction.Running) != 0 || Mounted)
            {
                RevealingAction();
            }
        }

        return true;
    }

    public virtual bool CheckMovement(Direction d, out int newZ) => CalcMoves.CheckMovement(this, d, out newZ);

    private bool CanMove(Direction d, Point3D oldLocation, out Point3D newLocation)
    {
        newLocation = oldLocation;

        if (m_Spell?.OnCasterMoving(d) == false)
        {
            return false;
        }

        if (m_Paralyzed || m_Frozen)
        {
            SendLocalizedMessage(500111); // You are frozen and can not move.

            return false;
        }

        if (!CheckMovement(d, out var newZ))
        {
            return false;
        }

        var oldX = oldLocation.m_X;
        var oldY = oldLocation.m_Y;
        var oldZ = oldLocation.m_Z;
        var x = oldX;
        var y = oldY;
        CalcMoves.Offset(d, ref x, ref y);
        newLocation = new Point3D(x, y, newZ);

        Pushing = false;

        var map = m_Map;

        if (map == null || !Region.CanMove(this, d, newLocation, oldLocation, map))
        {
            return false;
        }

        var oldSector = map.GetSector(oldX, oldY);
        var newSector = map.GetSector(x, y);

        if (oldSector != newSector)
        {
            using var queue = PooledRefQueue<IEntity>.Create(2048);
            foreach (var m in oldSector.Mobiles)
            {
                if (m != this && m.X == oldX && m.Y == oldY && m.Z + 15 > oldZ && oldZ + 15 > m.Z)
                {
                    queue.Enqueue(m);
                }
            }

            while (queue.Count > 0)
            {
                if (!queue.Dequeue().OnMoveOff(this))
                {
                    return false;
                }
            }

            foreach (var item in oldSector.Items)
            {
                if (item.AtWorldPoint(oldX, oldY) &&
                    (item.Z == oldZ || item.Z + item.ItemData.Height > oldZ && oldZ + 15 > item.Z))
                {
                    queue.Enqueue(item);
                }
            }

            while (queue.Count > 0)
            {
                if (!queue.Dequeue().OnMoveOff(this))
                {
                    return false;
                }
            }

            foreach (var m in newSector.Mobiles)
            {
                if (m.X == x && m.Y == y && m.Z + 15 > newZ && newZ + 15 > m.Z)
                {
                    queue.Enqueue(m);
                }
            }

            while (queue.Count > 0)
            {
                if (!queue.Dequeue().OnMoveOver(this))
                {
                    return false;
                }
            }

            foreach (var item in newSector.Items)
            {
                if (item.AtWorldPoint(x, y) &&
                    (item.Z == newZ || item.Z + item.ItemData.Height > newZ && newZ + 15 > item.Z))
                {
                    queue.Enqueue(item);
                }
            }

            while (queue.Count > 0)
            {
                if (!queue.Dequeue().OnMoveOver(this))
                {
                    return false;
                }
            }
        }
        else
        {
            using var queue = PooledRefQueue<(IEntity, byte)>.Create(2048);
            foreach (var m in oldSector.Mobiles)
            {
                byte flag;
                if (m != this && m.X == oldX && m.Y == oldY && m.Z + 15 > oldZ && oldZ + 15 > m.Z)
                {
                    flag = 1;
                }
                else
                {
                    flag = 0;
                }

                if (m.X == x && m.Y == y && m.Z + 15 > newZ && newZ + 15 > m.Z)
                {
                    flag += 2;
                }

                if (flag > 0)
                {
                    queue.Enqueue((m, flag));
                }
            }

            while (queue.Count > 0)
            {
                var (entity, flag) = queue.Dequeue();

                if (flag > 0 && !entity.OnMoveOff(this) || flag > 1 && !entity.OnMoveOver(this))
                {
                    return false;
                }
            }

            foreach (var item in oldSector.Items)
            {
                byte flag;
                if (item.AtWorldPoint(oldX, oldY) &&
                    (item.Z == oldZ || item.Z + item.ItemData.Height > oldZ && oldZ + 15 > item.Z))
                {
                    flag = 1;
                }
                else
                {
                    flag = 0;
                }

                if (item.AtWorldPoint(x, y) &&
                    (item.Z == newZ || item.Z + item.ItemData.Height > newZ && newZ + 15 > item.Z))
                {
                    flag += 2;
                }

                if (flag > 0)
                {
                    queue.Enqueue((item, flag));
                }
            }

            while (queue.Count > 0)
            {
                var (entity, flag) = queue.Dequeue();

                if (flag > 0 && !entity.OnMoveOff(this) || flag > 1 && !entity.OnMoveOver(this))
                {
                    return false;
                }
            }
        }

        if (!InternalOnMove(d))
        {
            return false;
        }

        LastMoveTime = Core.TickCount;

        return true;
    }

    public virtual bool Move(Direction d)
    {
        if (Deleted)
        {
            return false;
        }

        var box = FindBankNoCreate();

        if (box?.Opened == true)
        {
            box.Close();
        }

        var oldLocation = m_Location;
        Point3D newLocation;

        if ((m_Direction & Direction.Mask) == (d & Direction.Mask))
        {
            // We are actually moving (not just a direction change)
            if (!CanMove(d, oldLocation, out newLocation))
            {
                return false;
            }

            DisruptiveAction();
        }
        else
        {
            newLocation = oldLocation;
        }

        if (m_NetState != null)
        {
            m_NetState._nextMovementTime += ComputeMovementSpeed(d);
            m_NetState.SendMovementAck(m_NetState.Sequence, this);
        }

        SetLocation(newLocation, false);
        SetDirection(d);

        if (m_Map != null)
        {
            using var moveQueue = PooledRefQueue<IEntity>.Create(2048);
            using var moveClientQueue = PooledRefQueue<Mobile>.Create(2048);

            foreach (var mob in m_Map.GetMobilesInRange(m_Location, Core.GlobalMaxUpdateRange))
            {
                if (mob == this)
                {
                    continue;
                }

                if (mob.NetState != null)
                {
                    moveClientQueue.Enqueue(mob);
                }

                moveQueue.Enqueue(mob);
            }

            foreach (var item in m_Map.GetItemsInRange(m_Location, Core.GlobalMaxUpdateRange))
            {
                if (item.HandlesOnMovement)
                {
                    moveQueue.Enqueue(item);
                }
            }

            if (moveClientQueue.Count > 0)
            {
                const int cacheLength = OutgoingMobilePackets.MobileMovingPacketCacheByteLength;

                Span<byte> mobileMovingCache = stackalloc byte[cacheLength];
                mobileMovingCache.Clear();

                while (moveClientQueue.Count > 0)
                {
                    var m = moveClientQueue.Dequeue();
                    var ns = m.NetState;

                    if (ns != null && Utility.InUpdateRange(m_Location, m.m_Location) && m.CanSee(this))
                    {
                        ns.SendMobileMovingUsingCache(mobileMovingCache, m, this);
                    }
                }
            }

            while (moveQueue.Count > 0)
            {
                moveQueue.Dequeue().OnMovement(this, oldLocation);
            }
        }

        OnAfterMove(oldLocation);

        return true;
    }

    public virtual void OnAfterMove(Point3D oldLocation)
    {
    }

    public int ComputeMovementSpeed() => ComputeMovementSpeed(Direction, false);

    public virtual int ComputeMovementSpeed(Direction dir, bool checkTurning = true)
    {
        if (Mounted)
        {
            return (dir & Direction.Running) != 0 ? CalcMoves.RunMountDelay : CalcMoves.WalkMountDelay;
        }

        return (dir & Direction.Running) != 0 ? CalcMoves.RunFootDelay : CalcMoves.WalkFootDelay;
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when a Mobile <paramref name="m" /> moves off this Mobile.
    /// </summary>
    /// <returns>True if the move is allowed, false if not.</returns>
    public virtual bool OnMoveOff(Mobile m) => true;

    /// <summary>
    ///     Overridable. Event invoked when a Mobile <paramref name="m" /> moves over this Mobile.
    /// </summary>
    /// <returns>True if the move is allowed, false if not.</returns>
    public virtual bool OnMoveOver(Mobile m) => m_Map == null || Deleted || m.CheckShove(this);

    public virtual bool CheckShove(Mobile shoved)
    {
        if ((m_Map.Rules & MapRules.FreeMovement) == 0)
        {
            if (!shoved.Alive || !Alive || shoved.IsDeadBondedPet || IsDeadBondedPet)
            {
                return true;
            }

            if (shoved.m_Hidden && shoved.m_AccessLevel > AccessLevel.Player)
            {
                return true;
            }

            if (!Pushing)
            {
                Pushing = true;

                int number;

                if (AccessLevel > AccessLevel.Player)
                {
                    number = shoved.m_Hidden ? 1019041 : 1019040;
                }
                else
                {
                    if (Stam == StamMax)
                    {
                        number = shoved.m_Hidden ? 1019043 : 1019042;
                        Stam -= 10;

                        RevealingAction();
                    }
                    else
                    {
                        return false;
                    }
                }

                SendLocalizedMessage(number);
            }
        }

        return true;
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile sees another Mobile, <paramref name="m" />, move.
    /// </summary>
    public virtual void OnMovement(Mobile m, Point3D oldLocation)
    {
    }

    public virtual void CriminalAction(bool message)
    {
        if (Deleted)
        {
            return;
        }

        Criminal = true;

        Region.OnCriminalAction(this, message);
    }

    public virtual bool IsSnoop(Mobile from) => from != this;

    /// <summary>
    ///     Overridable. Any call to <see cref="Resurrect" /> will silently fail if this method returns false.
    ///     <seealso cref="Resurrect" />
    /// </summary>
    public virtual bool CheckResurrect() => true;

    /// <summary>
    ///     Overridable. Event invoked before the Mobile is <see cref="Resurrect">resurrected</see>.
    ///     <seealso cref="Resurrect" />
    /// </summary>
    public virtual void OnBeforeResurrect()
    {
    }

    /// <summary>
    ///     Overridable. Event invoked after the Mobile is <see cref="Resurrect">resurrected</see>.
    ///     <seealso cref="Resurrect" />
    /// </summary>
    public virtual void OnAfterResurrect()
    {
    }

    public virtual void Resurrect()
    {
        if (!Alive)
        {
            if (!Region.OnResurrect(this))
            {
                return;
            }

            if (!CheckResurrect())
            {
                return;
            }

            OnBeforeResurrect();

            var box = FindBankNoCreate();

            if (box?.Opened == true)
            {
                box.Close();
            }

            Poison = null;

            Warmode = false;

            Hits = 10;
            Stam = StamMax;
            Mana = 0;

            BodyMod = 0;
            Body = Race.AliveBody(this);

            ProcessDelta();

            for (var i = Items.Count - 1; i >= 0; --i)
            {
                if (i >= Items.Count)
                {
                    continue;
                }

                var item = Items[i];

                if (item.ItemID == 0x204E)
                {
                    item.Delete();
                }
            }

            SendIncomingPacket();

            OnAfterResurrect();
        }
    }

    public void DropHolding()
    {
        var holding = m_Holding;

        if (holding != null)
        {
            if (!holding.Deleted && holding.HeldBy == this && holding.Map == Map.Internal)
            {
                AddToBackpack(holding);
            }

            Holding = null;
            holding.ClearBounce();
        }
    }

    /// <summary>
    ///     Overridable. Virtual event invoked before the Mobile is deleted.
    /// </summary>
    public virtual void OnDelete()
    {
        Spawner?.Remove(this);
        Spawner = null;
    }

    public virtual bool CheckSpellCast(ISpell spell) => true;

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile casts a <paramref name="spell" />.
    /// </summary>
    /// <param name="spell"></param>
    public virtual void OnSpellCast(ISpell spell)
    {
        var now = Core.TickCount;
        if (m_NetState != null && now - m_NetState._nextMovementTime > 0)
        {
            m_NetState._nextMovementTime = now;
        }
    }

    /// <summary>
    ///     Overridable. Virtual event invoked after <see cref="TotalWeight" /> changes.
    /// </summary>
    public virtual void OnWeightChange(int oldValue)
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the <see cref="Skill.Base" /> or <see cref="Skill.BaseFixedPoint" /> property of
    ///     <paramref name="skill" /> changes.
    /// </summary>
    public virtual void OnSkillChange(SkillName skill, double oldBase)
    {
    }

    /// <summary>
    ///     Overridable. Invoked after the mobile is deleted. When overridden, be sure to call the base method.
    /// </summary>
    public virtual void OnAfterDelete()
    {
        StopAggrExpire();

        CheckAggrExpire();

        PoisonTimer?.Stop();
        m_HitsTimer?.Stop();
        m_StamTimer?.Stop();
        m_ManaTimer?.Stop();
        _combatTimerToken.Cancel();
        _expireCombatantTimerToken.Cancel();
        _logoutTimerToken.Cancel();
        _expireCriminalTimerToken.Cancel();
        _paraTimerToken.Cancel();
        _frozenTimerToken.Cancel();
        _autoManifestTimerToken.Cancel();
    }

    public virtual bool AllowSkillUse(SkillName name) => true;

    public virtual bool UseSkill(SkillName name) => Skills.UseSkill(this, name);

    public virtual bool UseSkill(int skillID) => Skills.UseSkill(this, skillID);

    public virtual DeathMoveResult GetParentMoveResultFor(Item item) => item.OnParentDeath(this);

    public virtual DeathMoveResult GetInventoryMoveResultFor(Item item) => item.OnInventoryDeath(this);

    public virtual void Kill()
    {
        if (!CanBeDamaged())
        {
            return;
        }

        if (!Alive || IsDeadBondedPet)
        {
            return;
        }

        if (Deleted)
        {
            return;
        }

        if (!Region.OnBeforeDeath(this))
        {
            return;
        }

        if (!OnBeforeDeath())
        {
            return;
        }

        var box = FindBankNoCreate();

        if (box?.Opened == true)
        {
            box.Close();
        }

        m_NetState?.CancelAllTrades();

        m_Spell?.OnCasterKilled();
        // m_Spell.Disturb( DisturbType.Kill );

        m_Target?.Cancel(this, TargetCancelType.Canceled);

        DisruptiveAction();

        Warmode = false;

        DropHolding();

        Hits = 0;
        Stam = 0;
        Mana = 0;

        Poison = null;
        Combatant = null;

        if (Paralyzed)
        {
            Paralyzed = false;
        }

        if (Frozen)
        {
            Frozen = false;
        }

        var content = new List<Item>();
        var equip = new List<Item>();
        var moveToPack = new List<Item>();

        var itemsCopy = new List<Item>(Items);

        var pack = Backpack;

        for (var i = 0; i < itemsCopy.Count; ++i)
        {
            var item = itemsCopy[i];

            if (item == pack)
            {
                continue;
            }

            var res = GetParentMoveResultFor(item);

            switch (res)
            {
                case DeathMoveResult.MoveToCorpse:
                    {
                        content.Add(item);
                        equip.Add(item);
                        break;
                    }
                case DeathMoveResult.MoveToBackpack:
                    {
                        moveToPack.Add(item);
                        break;
                    }
            }
        }

        if (pack != null)
        {
            var packCopy = new List<Item>(pack.Items);

            for (var i = 0; i < packCopy.Count; ++i)
            {
                var item = packCopy[i];

                var res = GetInventoryMoveResultFor(item);

                if (res == DeathMoveResult.MoveToCorpse)
                {
                    content.Add(item);
                }
                else
                {
                    moveToPack.Add(item);
                }
            }

            for (var i = 0; i < moveToPack.Count; ++i)
            {
                var item = moveToPack[i];

                if (RetainPackLocsOnDeath && item.Parent == pack)
                {
                    continue;
                }

                pack.DropItem(item);
            }
        }

        var c = CreateCorpseHandler?.Invoke(this, content, equip);

        if (m_Map != null)
        {
            var corpseSerial = c?.Serial ?? Serial.Zero;

            Span<byte> deathAnimation = stackalloc byte[OutgoingMobilePackets.DeathAnimationPacketLength].InitializePacket();
            Span<byte> removeEntity = stackalloc byte[OutgoingEntityPackets.RemoveEntityLength].InitializePacket();

            foreach (var state in m_Map.GetClientsInRange(m_Location))
            {
                if (state != m_NetState)
                {
                    OutgoingMobilePackets.CreateDeathAnimation(deathAnimation, Serial, corpseSerial);
                    state.Send(deathAnimation);

                    if (!state.Mobile.CanSee(this))
                    {
                        OutgoingEntityPackets.CreateRemoveEntity(removeEntity, Serial);
                        state.Send(removeEntity);
                    }
                }
            }
        }

        Region.OnDeath(this);
        OnDeath(c);
    }

    /// <summary>
    ///     Overridable. Event invoked before the Mobile is <see cref="Kill">killed</see>.
    ///     <seealso cref="Kill" />
    ///     <seealso cref="OnDeath" />
    /// </summary>
    /// <returns>True to continue with death, false to override it.</returns>
    public virtual bool OnBeforeDeath() => true;

    /// <summary>
    ///     Overridable. Event invoked after the Mobile is <see cref="Kill">killed</see>. Primarily, this method is responsible for
    ///     deleting an NPC or turning a PC into a ghost.
    ///     <seealso cref="Kill" />
    ///     <seealso cref="OnBeforeDeath" />
    /// </summary>
    public virtual void OnDeath(Container c)
    {
        var sound = GetDeathSound();

        if (sound >= 0)
        {
            Effects.PlaySound(this, sound);
        }

        if (!m_Player)
        {
            Delete();
            return;
        }

        m_NetState.SendDeathStatus();

        Warmode = false;

        BodyMod = 0;
        // Body = this.Female ? 0x193 : 0x192;
        Body = Race.GhostBody(this);

        var deathShroud = new Item(0x204E) { Movable = false, Layer = Layer.OuterTorso };

        AddItem(deathShroud);

        Items.Remove(deathShroud);
        Items.Insert(0, deathShroud);

        Poison = null;
        Combatant = null;

        Hits = 0;
        Stam = 0;
        Mana = 0;

        ProcessDelta();

        CheckStatTimers();
    }

    public virtual bool CheckTarget(Mobile from, Target targ, object targeted) => true;

    public virtual void Use(Item item)
    {
        if (item?.Deleted != false || item.QuestItem || Deleted)
        {
            return;
        }

        DisruptiveAction();

        if (m_Spell?.OnCasterUsingObject(item) == false)
        {
            return;
        }

        var root = item.RootParent;
        var okay = false;

        if (!Utility.InUpdateRange(Location, item.GetWorldLocation()))
        {
            item.OnDoubleClickOutOfRange(this);
        }
        else if (!CanSee(item))
        {
            item.OnDoubleClickCantSee(this);
        }
        else if (!item.IsAccessibleTo(this))
        {
            var reg = Region.Find(item.GetWorldLocation(), item.Map);

            if (reg?.SendInaccessibleMessage(item, this) != true)
            {
                item.OnDoubleClickNotAccessible(this);
            }
        }
        else if (!CheckAlive(false))
        {
            item.OnDoubleClickDead(this);
        }
        else if (item.InSecureTrade)
        {
            item.OnDoubleClickSecureTrade(this);
        }
        else if (!AllowItemUse(item))
        {
        }
        else if (!item.CheckItemUse(this, item))
        {
        }
        else if (root is Mobile mobile && mobile.IsSnoop(this))
        {
            item.OnSnoop(this);
        }
        else if (Region.OnDoubleClick(this, item))
        {
            okay = true;
        }

        if (okay)
        {
            // TODO: Is this correct?
            if (!item.Deleted)
            {
                item.OnItemUsed(this, item);
            }

            // TODO: Is this correct?
            if (!item.Deleted)
            {
                item.OnDoubleClick(this);
            }
        }
    }

    public virtual void Use(Mobile m)
    {
        if (m?.Deleted != false || Deleted)
        {
            return;
        }

        DisruptiveAction();

        if (m_Spell?.OnCasterUsingObject(m) == false)
        {
            return;
        }

        if (!Utility.InUpdateRange(Location, m.Location))
        {
            m.OnDoubleClickOutOfRange(this);
        }
        else if (!CanSee(m))
        {
            m.OnDoubleClickCantSee(this);
        }
        else if (!CheckAlive(false))
        {
            m.OnDoubleClickDead(this);
        }
        else if (Region.OnDoubleClick(this, m) && !m.Deleted)
        {
            m.OnDoubleClick(this);
        }
    }

    public virtual void Lift(Item item, int amount, out bool rejected, out LRReason reject)
    {
        rejected = true;
        reject = LRReason.Inspecific;

        if (item == null)
        {
            return;
        }

        var from = this;
        var state = m_NetState;

        if (from.AccessLevel >= AccessLevel.GameMaster || Core.TickCount - from.NextActionTime >= 0)
        {
            if (from.CheckAlive())
            {
                from.DisruptiveAction();

                if (from.Holding != null)
                {
                    reject = LRReason.AreHolding;
                }
                else if (from.AccessLevel < AccessLevel.GameMaster && !from.InRange(item.GetWorldLocation(), 2))
                {
                    reject = LRReason.OutOfRange;
                }
                else if (!from.CanSee(item) || !from.InLOS(item))
                {
                    reject = LRReason.OutOfSight;
                }
                else if (!item.VerifyMove(from))
                {
                    reject = LRReason.CannotLift;
                }
                else if (!item.IsAccessibleTo(from))
                {
                    reject = LRReason.CannotLift;
                }
                else if (item.Nontransferable && amount != item.Amount)
                {
                    if (item.QuestItem)
                    {
                        from.SendLocalizedMessage(1074868); // Stacks of quest items cannot be unstacked.
                    }

                    reject = LRReason.CannotLift;
                }
                else if (!item.CheckLift(from, item, ref reject))
                {
                }
                else
                {
                    var root = item.RootParent;

                    if (root is Mobile mobile && !mobile.CheckNonlocalLift(from, item))
                    {
                        reject = LRReason.TryToSteal;
                    }
                    else if (!from.OnDragLift(item) || !item.OnDragLift(from))
                    {
                        reject = LRReason.Inspecific;
                    }
                    else if (!from.CheckAlive())
                    {
                        reject = LRReason.Inspecific;
                    }
                    else
                    {
                        item.SetLastMoved();

                        if (item.Spawner != null)
                        {
                            item.Spawner.Remove(item);
                            item.Spawner = null;
                        }

                        var oldAmount = item.Amount;

                        if (oldAmount <= 0)
                        {
                            logger.Error(
                                "Item {Type} ({Serial}) has amount of {OldAmount}, but must be at least 1",
                                item.GetType(),
                                item.Serial,
                                oldAmount
                            );
                        }
                        else
                        {
                            amount = Math.Clamp(amount, 1, oldAmount);

                            if (amount < oldAmount)
                            {
                                LiftItemDupe(item, amount);
                            }
                        }

                        var map = from.Map;

                        if (DragEffects && map != null && root is null or Item)
                        {
                            var rootItem = root as Item;

                            Span<byte> buffer = stackalloc byte[OutgoingPlayerPackets.DragEffectPacketLength]
                                .InitializePacket();

                            foreach (var ns in map.GetClientsInRange(from.Location))
                            {
                                if (ns.Mobile != from && ns.Mobile.CanSee(from) && ns.Mobile.InLOS(from) &&
                                    ns.Mobile.CanSee(root))
                                {
                                    OutgoingPlayerPackets.CreateDragEffect(
                                        buffer,
                                        rootItem?.Serial ?? Serial.Zero,
                                        rootItem?.Location ?? item.Location,
                                        from.Serial,
                                        from.Location,
                                        item.ItemID,
                                        item.Hue,
                                        amount
                                    );

                                    ns.Send(buffer);
                                }
                            }
                        }

                        var fixLoc = item.Location;
                        var fixMap = item.Map;
                        var shouldFix = item.Parent == null;

                        item.RecordBounce();
                        item.OnItemLifted(from, item);
                        item.Internalize();

                        from.Holding = item;

                        from.SendSound(item.GetLiftSound(from));

                        from.NextActionTime = Core.TickCount + ActionDelay;

                        if (fixMap != null && shouldFix)
                        {
                            fixMap.FixColumn(fixLoc.m_X, fixLoc.m_Y);
                        }

                        reject = LRReason.Inspecific;
                        rejected = false;
                    }
                }
            }
            else
            {
                reject = LRReason.Inspecific;
            }
        }
        else
        {
            SendActionMessage();
            reject = LRReason.Inspecific;
        }

        if (rejected && state != null)
        {
            state.SendLiftReject(reject);

            if (item.Deleted)
            {
                return;
            }

            if (item.Parent is Item)
            {
                state.SendContainerContentUpdate(item);
            }
            else if (item.Parent is Mobile)
            {
                state.SendEquipUpdate(item);
            }
            else
            {
                item.SendInfoTo(state);
            }

            if (item.Parent != null)
            {
                item.SendOPLPacketTo(state);
            }
        }
    }

    public static T LiftItemDupe<T>(T oldItem, int amount) where T : Item
    {
        T item;
        try
        {
            item = oldItem.GetType().CreateInstance<T>();
        }
        catch (Exception e)
        {
            logger.Warning(
                e,
                "[{Serial} {Name}]: Item must have a zero parameter constructor to be separated from a stack.",
                oldItem.Serial,
                oldItem.GetType().Name
            );

            return null;
        }

        var oldAmount = oldItem.Amount;
        oldItem.Amount = amount;

        item.Visible = oldItem.Visible;
        item.Movable = oldItem.Movable;
        item.LootType = oldItem.LootType;
        item.Direction = oldItem.Direction;
        item.Hue = oldItem.Hue;
        item.ItemID = oldItem.ItemID;
        item.Location = oldItem.Location;
        item.Layer = oldItem.Layer;
        item.Name = oldItem.Name;
        item.Weight = oldItem.Weight;

        item.Amount = oldAmount - amount;
        item.Map = oldItem.Map;

        oldItem.OnAfterDuped(item);

        if (oldItem.Parent is Mobile parentMobile)
        {
            parentMobile.AddItem(item);
        }
        else if (oldItem.Parent is Item parentItem)
        {
            parentItem.AddItem(item);
        }

        item.Delta(ItemDelta.Update);

        return item;
    }

    public virtual void SendDropEffect(Item item)
    {
        if (!DragEffects || item.Deleted)
        {
            return;
        }

        var map = m_Map;
        var root = item.RootParent;
        var rootItem = root as Item;

        if (map == null || root != null && rootItem == null)
        {
            return;
        }

        Span<byte> buffer = stackalloc byte[OutgoingPlayerPackets.DragEffectPacketLength].InitializePacket();

        foreach (var ns in map.GetClientsInRange(m_Location))
        {
            if (ns.StygianAbyss || ns.Mobile == this ||
                !ns.Mobile.CanSee(this) || !ns.Mobile.InLOS(this) || !ns.Mobile.CanSee(root))
            {
                continue;
            }

            OutgoingPlayerPackets.CreateDragEffect(
                buffer,
                Serial,
                Location,
                rootItem?.Serial ?? Serial.Zero,
                rootItem?.Location ?? item.Location,
                item.ItemID,
                item.Hue,
                item.Amount
            );

            ns.Send(buffer);
        }
    }

    public virtual bool Drop(Item to, Point3D loc)
    {
        var from = this;
        var item = from.Holding;

        var valid = item != null && item.HeldBy == from && item.Map == Map.Internal;

        from.Holding = null;

        if (!valid)
        {
            return false;
        }

        var bounced = true;

        item.SetLastMoved();

        if (to == null || !item.DropToItem(from, to, loc))
        {
            item.Bounce(from);
        }
        else
        {
            bounced = false;
        }

        item.ClearBounce();

        if (!bounced)
        {
            SendDropEffect(item);
        }

        return !bounced;
    }

    public virtual bool Drop(Point3D loc)
    {
        var from = this;
        var item = from.Holding;

        var valid = item != null && item.HeldBy == from && item.Map == Map.Internal;

        from.Holding = null;

        if (!valid)
        {
            return false;
        }

        var bounced = true;

        item.SetLastMoved();

        if (!item.DropToWorld(from, loc))
        {
            item.Bounce(from);
        }
        else
        {
            bounced = false;
        }

        item.ClearBounce();

        if (!bounced)
        {
            SendDropEffect(item);
        }

        return !bounced;
    }

    public virtual bool Drop(Mobile to, Point3D loc)
    {
        var from = this;
        var item = from.Holding;

        var valid = item != null && item.HeldBy == from && item.Map == Map.Internal;

        from.Holding = null;

        if (!valid)
        {
            return false;
        }

        var bounced = true;

        item.SetLastMoved();

        if (to == null || !item.DropToMobile(from, to, loc))
        {
            item.Bounce(from);
        }
        else
        {
            bounced = false;
        }

        item.ClearBounce();

        if (!bounced)
        {
            SendDropEffect(item);
        }

        return !bounced;
    }

    public virtual bool MutateSpeech(List<Mobile> hears, ref string text, ref object context)
    {
        if (Alive)
        {
            return false;
        }

        using var sb = new ValueStringBuilder(stackalloc char[Math.Min(text.Length, 256)]);
        for (var i = 0; i < text.Length; ++i)
        {
            sb.Append(text[i] != ' ' ? (GhostChars ?? DefaultGhostChars).RandomElement() : ' ');
        }

        text = sb.ToString();
        context = m_GhostMutateContext;
        return true;
    }

    private void AutoManifest()
    {
        if (!Alive)
        {
            Warmode = false;
        }
    }

    public virtual void Manifest(TimeSpan delay)
    {
        Warmode = true;
        _autoManifestTimerToken.Cancel();
        Timer.StartTimer(delay, AutoManifest, out _autoManifestTimerToken);
    }

    public virtual bool CheckSpeechManifest()
    {
        if (Alive)
        {
            return false;
        }

        var delay = AutoManifestTimeout;

        if (delay > TimeSpan.Zero && (!Warmode || _autoManifestTimerToken.Running))
        {
            Manifest(delay);
            return true;
        }

        return false;
    }

    public virtual bool CheckHearsMutatedSpeech(Mobile m, object context) =>
        context != m_GhostMutateContext || m.Alive && !m.CanHearGhosts;

    private void AddSpeechItemsFrom(List<IEntity> list, Container cont)
    {
        for (var i = 0; i < cont.Items.Count; ++i)
        {
            var item = cont.Items[i];

            if (item.HandlesOnSpeech)
            {
                list.Add(item);
            }

            if (item is Container container)
            {
                AddSpeechItemsFrom(list, container);
            }
        }
    }

    public virtual void DoSpeech(string text, int[] keywords, MessageType type, int hue)
    {
        if (Deleted || CommandSystem.Handle(this, text, type))
        {
            return;
        }

        var range = 15;

        switch (type)
        {
            case MessageType.Regular:
                {
                    SpeechHue = hue;
                    break;
                }
            case MessageType.Emote:
                {
                    EmoteHue = hue;
                    break;
                }
            case MessageType.Whisper:
                {
                    WhisperHue = hue;
                    range = 1;
                    break;
                }
            case MessageType.Yell:
                {
                    YellHue = hue;
                    range = 18;
                    break;
                }
            case MessageType.System:
                {
                    break;
                }
            case MessageType.Label:
                {
                    break;
                }
            case MessageType.Focus:
                {
                    break;
                }
            case MessageType.Spell:
                {
                    break;
                }
            case MessageType.Guild:
                {
                    break;
                }
            case MessageType.Alliance:
                {
                    break;
                }
            case MessageType.Command:
                {
                    break;
                }
            case MessageType.Encoded:
                {
                    break;
                }
            default:
                {
                    type = MessageType.Regular;
                    break;
                }
        }

        var regArgs = new SpeechEventArgs(this, text, type, hue, keywords);

        EventSink.InvokeSpeech(regArgs);
        Region.OnSpeech(regArgs);
        OnSaid(regArgs);

        if (regArgs.Blocked)
        {
            return;
        }

        text = regArgs.Speech;

        if (string.IsNullOrEmpty(text))
        {
            return;
        }

        var hears = m_Hears;
        var onSpeech = m_OnSpeech;

        if (m_Map != null)
        {
            foreach (var heard in m_Map.GetMobilesInRange(m_Location, range))
            {
                if (!heard.CanSee(this) || !NoSpeechLOS && heard.Player && !heard.InLOS(this))
                {
                    continue;
                }

                if (heard.m_NetState != null)
                {
                    hears.Add(heard);
                }

                if (heard.HandlesOnSpeech(this))
                {
                    onSpeech.Add(heard);
                }

                for (var i = 0; i < heard.Items.Count; ++i)
                {
                    var item = heard.Items[i];

                    if (item.HandlesOnSpeech)
                    {
                        onSpeech.Add(item);
                    }

                    if (item is Container container)
                    {
                        AddSpeechItemsFrom(onSpeech, container);
                    }
                }
            }

            foreach (var item in m_Map.GetItemsInRange(m_Location, range))
            {
                if (item.HandlesOnSpeech)
                {
                    onSpeech.Add(item);
                }

                if (item is Container container)
                {
                    AddSpeechItemsFrom(onSpeech, container);
                }
            }

            object mutateContext = null;
            var mutatedText = text;
            SpeechEventArgs mutatedArgs = null;

            if (MutateSpeech(hears, ref mutatedText, ref mutateContext))
            {
                mutatedArgs = new SpeechEventArgs(this, mutatedText, type, hue, Array.Empty<int>());
            }

            CheckSpeechManifest();

            ProcessDelta();

            Span<byte> regBuffer = stackalloc byte[OutgoingMessagePackets.GetMaxMessageLength(text)].InitializePacket();
            Span<byte> mutBuffer =
                stackalloc byte[OutgoingMessagePackets.GetMaxMessageLength(mutatedText)].InitializePacket();

            // TODO: Should this be sorted like onSpeech is below?
            for (var i = 0; i < hears.Count; ++i)
            {
                var heard = hears[i];

                if (mutatedArgs == null || !CheckHearsMutatedSpeech(heard, mutateContext))
                {
                    var length = OutgoingMessagePackets.CreateMessage(
                        regBuffer,
                        Serial,
                        Body,
                        type,
                        hue,
                        3,
                        false,
                        m_Language,
                        Name,
                        text
                    );

                    if (length != regBuffer.Length)
                    {
                        regBuffer = regBuffer[..length]; // Adjust to the actual size
                    }

                    heard.OnSpeech(regArgs);
                    heard.NetState?.Send(regBuffer);
                }
                else
                {
                    var length = OutgoingMessagePackets.CreateMessage(
                        mutBuffer,
                        Serial,
                        Body,
                        type,
                        hue,
                        3,
                        false,
                        m_Language,
                        Name,
                        mutatedText
                    );

                    if (length != mutBuffer.Length)
                    {
                        mutBuffer = mutBuffer[..length]; // Adjust to the actual size
                    }

                    heard.OnSpeech(mutatedArgs);
                    heard.NetState?.Send(mutBuffer);
                }
            }

            if (onSpeech.Count > 1)
            {
                onSpeech.Sort(LocationComparer.GetInstance(this));
            }

            for (var i = 0; i < onSpeech.Count; ++i)
            {
                var obj = onSpeech[i];

                if (obj is Mobile heard)
                {
                    if (mutatedArgs == null || !CheckHearsMutatedSpeech(heard, mutateContext))
                    {
                        heard.OnSpeech(regArgs);
                    }
                    else
                    {
                        heard.OnSpeech(mutatedArgs);
                    }
                }
                else
                {
                    ((Item)obj).OnSpeech(regArgs);
                }
            }

            if (m_Hears.Count > 0)
            {
                m_Hears.Clear();
            }

            if (m_OnSpeech.Count > 0)
            {
                m_OnSpeech.Clear();
            }
        }
    }

    public Mobile FindMostRecentDamager(bool allowSelf) => FindMostRecentDamageEntry(allowSelf)?.Damager;

    public DamageEntry FindMostRecentDamageEntry(bool allowSelf)
    {
        for (var i = DamageEntries.Count - 1; i >= 0; --i)
        {
            if (i >= DamageEntries.Count)
            {
                continue;
            }

            var de = DamageEntries[i];

            if (de.HasExpired)
            {
                DamageEntries.RemoveAt(i);
            }
            else if (allowSelf || de.Damager != this)
            {
                return de;
            }
        }

        return null;
    }

    public Mobile FindLeastRecentDamager(bool allowSelf) => FindLeastRecentDamageEntry(allowSelf)?.Damager;

    public DamageEntry FindLeastRecentDamageEntry(bool allowSelf)
    {
        for (var i = 0; i < DamageEntries.Count; ++i)
        {
            if (i < 0)
            {
                continue;
            }

            var de = DamageEntries[i];

            if (de.HasExpired)
            {
                DamageEntries.RemoveAt(i);
                --i;
            }
            else if (allowSelf || de.Damager != this)
            {
                return de;
            }
        }

        return null;
    }

    public Mobile FindMostTotalDamager(bool allowSelf) => FindMostTotalDamageEntry(allowSelf)?.Damager;

    public DamageEntry FindMostTotalDamageEntry(bool allowSelf)
    {
        DamageEntry mostTotal = null;

        for (var i = DamageEntries.Count - 1; i >= 0; --i)
        {
            if (i >= DamageEntries.Count)
            {
                continue;
            }

            var de = DamageEntries[i];

            if (de.HasExpired)
            {
                DamageEntries.RemoveAt(i);
            }
            else if ((allowSelf || de.Damager != this) && (mostTotal == null || de.DamageGiven > mostTotal.DamageGiven))
            {
                mostTotal = de;
            }
        }

        return mostTotal;
    }

    public Mobile FindLeastTotalDamager(bool allowSelf) => FindLeastTotalDamageEntry(allowSelf)?.Damager;

    public DamageEntry FindLeastTotalDamageEntry(bool allowSelf)
    {
        DamageEntry mostTotal = null;

        for (var i = DamageEntries.Count - 1; i >= 0; --i)
        {
            if (i >= DamageEntries.Count)
            {
                continue;
            }

            var de = DamageEntries[i];

            if (de.HasExpired)
            {
                DamageEntries.RemoveAt(i);
            }
            else if ((allowSelf || de.Damager != this) && (mostTotal == null || de.DamageGiven < mostTotal.DamageGiven))
            {
                mostTotal = de;
            }
        }

        return mostTotal;
    }

    public DamageEntry FindDamageEntryFor(Mobile m)
    {
        for (var i = DamageEntries.Count - 1; i >= 0; --i)
        {
            if (i >= DamageEntries.Count)
            {
                continue;
            }

            var de = DamageEntries[i];

            if (de.HasExpired)
            {
                DamageEntries.RemoveAt(i);
            }
            else if (de.Damager == m)
            {
                return de;
            }
        }

        return null;
    }

    public virtual Mobile GetDamageMaster(Mobile damagee) => null;

    public virtual DamageEntry RegisterDamage(int amount, Mobile from)
    {
        var de = FindDamageEntryFor(from) ?? new DamageEntry(from);

        de.DamageGiven += amount;
        de.LastDamage = Core.Now;

        DamageEntries.Remove(de);
        DamageEntries.Add(de);

        var master = from.GetDamageMaster(this);

        if (master != null)
        {
            var list = de.Responsible;

            if (list == null)
            {
                de.Responsible = list = new List<DamageEntry>();
            }

            DamageEntry resp = null;
            foreach (var check in list)
            {
                if (check.Damager == master)
                {
                    resp = check;
                    break;
                }
            }

            if (resp == null)
            {
                list.Add(resp = new DamageEntry(master));
            }

            resp.DamageGiven += amount;
            resp.LastDamage = Core.Now;
        }

        return de;
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile is <see cref="Damage">damaged</see>. It is called before
    ///     <see cref="Hits">hit points</see> are lowered or the Mobile is <see cref="Kill">killed</see>.
    ///     <seealso cref="Damage" />
    ///     <seealso cref="Hits" />
    ///     <seealso cref="Kill" />
    /// </summary>
    public virtual void OnDamage(int amount, Mobile from, bool willKill)
    {
    }

    public virtual bool CanBeDamaged() => !m_Blessed;

    public virtual void Damage(int amount, Mobile from = null, bool informMount = true, bool ignoreEvilOmen = false)
    {
        if (amount <= 0)
        {
            return;
        }

        if (!CanBeDamaged() || Deleted)
        {
            return;
        }

        if (!Region.OnDamage(this, ref amount))
        {
            return;
        }

        var oldHits = Hits;
        var newHits = oldHits - amount;

        m_Spell?.OnCasterHurt();

        // if (m_Spell != null && m_Spell.State == SpellState.Casting)
        // m_Spell.Disturb( DisturbType.Hurt, false, true );

        if (from != null)
        {
            RegisterDamage(amount, from);
        }

        DisruptiveAction();

        Paralyzed = false;

        switch (VisibleDamageType)
        {
            case VisibleDamageType.Related:
                {
                    SendVisibleDamageRelated(from, amount);
                    break;
                }
            case VisibleDamageType.Everyone:
                {
                    SendVisibleDamageEveryone(amount);
                    break;
                }
            case VisibleDamageType.Selective:
                {
                    SendVisibleDamageSelective(from, amount);
                    break;
                }
        }

        OnDamage(amount, from, newHits < 0);

        if (informMount)
        {
            Mount?.OnRiderDamaged(amount, from, newHits < 0);
        }

        if (newHits < 0)
        {
            LastKiller = from;

            Hits = 0;

            if (oldHits >= 0)
            {
                Kill();
            }
        }
        else
        {
            Hits = newHits;
        }
    }

    public void SendVisibleDamageRelated(Mobile from, int amount)
    {
        var ourState = m_NetState ?? GetDamageMaster(from)?.m_NetState;
        var theirState = from?.m_NetState ?? from?.GetDamageMaster(this)?.m_NetState;

        if (amount > 0)
        {
            ourState.SendDamage(Serial, amount);

            if (theirState != null && theirState != ourState)
            {
                theirState.SendDamage(Serial, amount);
            }
        }
    }

    public void SendVisibleDamageEveryone(int amount)
    {
        if (amount < 0)
        {
            return;
        }

        var map = m_Map;

        if (map == null)
        {
            return;
        }

        foreach (var ns in map.GetClientsInRange(m_Location))
        {
            if (ns.Mobile.CanSee(this))
            {
                ns.SendDamage(Serial, amount);
            }
        }
    }

    public void SendVisibleDamageSelective(Mobile from, int amount)
    {
        var ourState = m_NetState;
        var theirState = from?.m_NetState;

        var damager = from;
        var damaged = this;

        if (ourState == null)
        {
            var master = GetDamageMaster(from);

            if (master != null)
            {
                damaged = master;
                ourState = master.m_NetState;
            }
        }

        if (!damaged.ShowVisibleDamage)
        {
            return;
        }

        if (theirState == null && from != null)
        {
            var master = from.GetDamageMaster(this);

            if (master != null)
            {
                damager = master;
                theirState = master.m_NetState;
            }
        }

        if (amount > 0)
        {
            if (damaged.CanSeeVisibleDamage)
            {
                ourState.SendDamage(Serial, amount);
            }

            if (theirState != null && theirState != ourState && damager.CanSeeVisibleDamage)
            {
                theirState.SendDamage(Serial, amount);
            }
        }
    }

    public void Heal(int amount) => Heal(amount, this);

    public void Heal(int amount, Mobile from, bool message = true)
    {
        if (!Alive || IsDeadBondedPet)
        {
            return;
        }

        if (!Region.OnHeal(this, ref amount))
        {
            return;
        }

        OnHeal(ref amount, from);

        if (Hits + amount > HitsMax)
        {
            amount = HitsMax - Hits;
        }

        Hits += amount;

        if (message && amount > 0)
        {
            m_NetState.SendMessageLocalizedAffix(
                Serial.MinusOne,
                -1,
                MessageType.Label,
                0x3B2,
                3,
                1008158,
                "",
                AffixType.Append | AffixType.System,
                amount.ToString()
            );
        }
    }

    public virtual void OnHeal(ref int amount, Mobile from)
    {
    }

    public virtual void Deserialize(IGenericReader reader)
    {
        var version = reader.ReadInt();

        GuildInfo guildInfo = version <= 36 ? new GuildInfo(this) : null;

        switch (version)
        {
            case 37: // Moved guild to PlayerMobile
            case 36: // Moved virtues to VirtueSystem
            case 35: // Moved short term murders to PlayerMurderSystem
            case 34: // Moved Stabled to PlayerMobile
            case 33: // Removed created
            case 32: // Removed StuckMenu
            case 31:
                {
                    LastStrGain = reader.ReadDeltaTime();
                    LastIntGain = reader.ReadDeltaTime();
                    LastDexGain = reader.ReadDeltaTime();

                    goto case 30;
                }
            case 30:
                {
                    var hairflag = reader.ReadByte();

                    if ((hairflag & 0x01) != 0)
                    {
                        _hair = new VirtualHairInfo();
                        _hair.Deserialize(reader);
                    }

                    if ((hairflag & 0x02) != 0)
                    {
                        _facialHair = new VirtualHairInfo();
                        _facialHair.Deserialize(reader);
                    }

                    goto case 29;
                }
            case 29:
                {
                    m_Race = reader.ReadRace();
                    goto case 28;
                }
            case 28:
                {
                    if (version <= 30)
                    {
                        LastStatGain = reader.ReadDeltaTime();
                    }

                    goto case 27;
                }
            case 27:
                {
                    m_TithingPoints = reader.ReadInt();

                    goto case 26;
                }
            case 26:
            case 25:
            case 24:
                {
                    Corpse = reader.ReadEntity<Container>();

                    goto case 23;
                }
            case 23:
                {
                    if (version < 33)
                    {
                        Created = reader.ReadDateTime();
                    }

                    goto case 22;
                }
            case 22: // Just removed followers
            case 21:
                {
                    if (version < 34)
                    {
                        // Migrated to PlayerMobile
                        AddToStabledMigration(this, reader.ReadEntitySet<Mobile>(true));
                    }

                    goto case 20;
                }
            case 20:
                {
                    CantWalk = reader.ReadBool();

                    goto case 19;
                }
            case 19: // Just removed variables
            case 18:
                {
                    if (version < 36)
                    {
                        reader.ReadByte(); // VirtueInfo version

                        int mask = reader.ReadByte();

                        if (mask != 0)
                        {
                            var virtueValues = new int[8];

                            for (var i = 0; i < 8; ++i)
                            {
                                if ((mask & (1 << i)) != 0)
                                {
                                    virtueValues[i] = reader.ReadInt();
                                }
                            }

                            AddToVirtueMigration(this, virtueValues);
                        }
                    }

                    goto case 17;
                }
            case 17:
                {
                    Thirst = reader.ReadInt();
                    BAC = reader.ReadInt();

                    goto case 16;
                }
            case 16:
                {
                    if (version < 35)
                    {
                        // Migrated to PlayerMurderSystem
                        AddToMurderMigration(this, reader.ReadInt());
                    }

                    if (version <= 24)
                    {
                        reader.ReadDateTime();
                        reader.ReadDateTime();
                    }

                    goto case 15;
                }
            case 15:
                {
                    if (version < 22)
                    {
                        reader.ReadInt(); // followers
                    }

                    m_FollowersMax = reader.ReadInt();

                    goto case 14;
                }
            case 14:
                {
                    MagicDamageAbsorb = reader.ReadInt();

                    goto case 13;
                }
            case 13:
                {
                    if (guildInfo != null)
                    {
                        guildInfo.GuildFealty = reader.ReadEntity<Mobile>();
                    }

                    goto case 12;
                }
            case 12:
                {
                    if (guildInfo != null)
                    {
                        guildInfo.Guild = reader.ReadEntity<BaseGuild>();
                    }

                    goto case 11;
                }
            case 11:
                {
                    if (guildInfo != null)
                    {
                        guildInfo.DisplayGuildTitle = reader.ReadBool();
                    }

                    goto case 10;
                }
            case 10:
                {
                    CanSwim = reader.ReadBool();

                    goto case 9;
                }
            case 9:
                {
                    Squelched = reader.ReadBool();

                    goto case 8;
                }
            case 8:
                {
                    m_Holding = reader.ReadEntity<Item>();

                    goto case 7;
                }
            case 7:
                {
                    m_VirtualArmor = reader.ReadInt();

                    goto case 6;
                }
            case 6:
                {
                    BaseSoundID = reader.ReadInt();

                    goto case 5;
                }
            case 5:
                {
                    DisarmReady = reader.ReadBool();
                    StunReady = reader.ReadBool();

                    goto case 4;
                }
            case 4:
                {
                    if (version <= 25)
                    {
                        reader.ReadPoison();
                    }

                    goto case 3;
                }
            case 3:
                {
                    m_StatCap = reader.ReadInt();

                    goto case 2;
                }
            case 2:
                {
                    NameHue = reader.ReadInt();

                    goto case 1;
                }
            case 1:
                {
                    m_Hunger = reader.ReadInt();

                    goto case 0;
                }
            case 0:
                {
                    if (version < 3)
                    {
                        m_StatCap = 225;
                    }

                    if (version < 15)
                    {
                        m_Followers = 0;
                        m_FollowersMax = 5;
                    }

                    m_Location = reader.ReadPoint3D();
                    m_Body = new Body(reader.ReadInt());
                    m_Name = reader.ReadString();

                    if (guildInfo != null)
                    {
                        guildInfo.GuildTitle = reader.ReadString();
                    }

                    m_Criminal = reader.ReadBool();
                    m_Kills = reader.ReadInt();
                    SpeechHue = reader.ReadInt();
                    EmoteHue = reader.ReadInt();
                    WhisperHue = reader.ReadInt();
                    YellHue = reader.ReadInt();
                    m_Language = reader.ReadString();
                    m_Female = reader.ReadBool();
                    m_Warmode = reader.ReadBool();
                    m_Hidden = reader.ReadBool();
                    m_Direction = (Direction)reader.ReadByte();
                    m_Hue = reader.ReadInt();
                    m_Str = reader.ReadInt();
                    m_Dex = reader.ReadInt();
                    m_Int = reader.ReadInt();
                    m_Hits = reader.ReadInt();
                    m_Stam = reader.ReadInt();
                    m_Mana = reader.ReadInt();
                    m_Map = reader.ReadMap();
                    m_Blessed = reader.ReadBool();
                    m_Fame = reader.ReadInt();
                    m_Karma = reader.ReadInt();
                    m_AccessLevel = (AccessLevel)reader.ReadByte();

                    Skills = new Skills(this, reader);

                    Items = reader.ReadEntityList<Item>();

                    m_Player = reader.ReadBool();
                    m_Title = reader.ReadString();
                    Profile = reader.ReadString();
                    ProfileLocked = reader.ReadBool();

                    if (version <= 18)
                    {
                        reader.ReadInt();
                        reader.ReadInt();
                        reader.ReadInt();
                    }

                    AutoPageNotify = reader.ReadBool();

                    LogoutLocation = reader.ReadPoint3D();
                    LogoutMap = reader.ReadMap();

                    m_StrLock = (StatLockType)reader.ReadByte();
                    m_DexLock = (StatLockType)reader.ReadByte();
                    m_IntLock = (StatLockType)reader.ReadByte();

                    _statMods = new List<StatMod>();
                    _skillMods = new List<SkillMod>();

                    if (version < 32)
                    {
                        if (reader.ReadBool())
                        {
                            var count = reader.ReadInt();
                            for (var i = 0; i < count; ++i)
                            {
                                reader.ReadDateTime();
                            }
                        }
                    }

                    if (m_Player && m_Map != Map.Internal)
                    {
                        LogoutLocation = m_Location;
                        LogoutMap = m_Map;

                        m_Map = Map.Internal;
                    }

                    m_Map?.OnEnter(this);

                    if (m_Criminal)
                    {
                        Timer.StartTimer(ExpireCriminalDelay, ExpireCriminal, out _expireCriminalTimerToken);
                    }

                    if (ShouldCheckStatTimers)
                    {
                        CheckStatTimers();
                    }

                    UpdateRegion();

                    UpdateResistances();

                    break;
                }
        }

        if (!m_Player)
        {
            Utility.Intern(ref m_Name);
        }

        Utility.Intern(ref m_Title);
        Utility.Intern(ref m_Language);

        if (guildInfo != null)
        {
            AddToGuildMigration(guildInfo);
        }
    }

    public void ConvertHair()
    {
        Item hair;

        if ((hair = FindItemOnLayer(Layer.Hair)) != null)
        {
            HairItemID = hair.ItemID;
            HairHue = hair.Hue;
            hair.Delete();
        }

        if ((hair = FindItemOnLayer(Layer.FacialHair)) != null)
        {
            FacialHairItemID = hair.ItemID;
            FacialHairHue = hair.Hue;
            hair.Delete();
        }
    }

    public virtual void CheckStatTimers()
    {
        if (Deleted)
        {
            return;
        }

        if (Hits < HitsMax)
        {
            if (CanRegenHits)
            {
                m_HitsTimer ??= new HitsTimer(this);
                m_HitsTimer.Start();
            }
            else
            {
                m_HitsTimer?.Stop();
            }
        }
        else
        {
            Hits = HitsMax;
        }

        if (Stam < StamMax)
        {
            if (CanRegenStam)
            {
                m_StamTimer ??= new StamTimer(this);
                m_StamTimer.Start();
            }
            else
            {
                m_StamTimer?.Stop();
            }
        }
        else
        {
            Stam = StamMax;
        }

        if (Mana < ManaMax)
        {
            if (CanRegenMana)
            {
                m_ManaTimer ??= new ManaTimer(this);
                m_ManaTimer.Start();
            }
            else
            {
                m_ManaTimer?.Stop();
            }
        }
        else
        {
            Mana = ManaMax;
        }
    }

    public static string GetAccessLevelName(AccessLevel level) => m_AccessLevelNames[(int)level];

    public virtual bool CanPaperdollBeOpenedBy(Mobile from) => Body.IsHuman || Body.IsGhost || IsBodyMod;

    public virtual void GetChildContextMenuEntries(Mobile from, ref PooledRefList<ContextMenuEntry> list, Item item)
    {
    }

    public virtual void GetContextMenuEntries(Mobile from, ref PooledRefList<ContextMenuEntry> list)
    {
    }

    public void Internalize()
    {
        Map = Map.Internal;
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when <paramref name="item" /> is <see cref="AddItem">added</see> from the Mobile,
    ///     such
    ///     as when it is equipped.
    ///     <seealso cref="Items" />
    ///     <seealso cref="OnItemRemoved" />
    /// </summary>
    public virtual void OnItemAdded(Item item)
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when <paramref name="item" /> is <see cref="RemoveItem">removed</see> from the
    ///     Mobile.
    ///     <seealso cref="Items" />
    ///     <seealso cref="OnItemAdded" />
    /// </summary>
    public virtual void OnItemRemoved(Item item)
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when <paramref name="item" /> is becomes a child of the Mobile; it's worn or
    ///     contained
    ///     at some level of the Mobile's <see cref="Mobile.Backpack">backpack</see> or <see cref="Mobile.BankBox">bank box</see>
    ///     <seealso cref="OnSubItemRemoved" />
    ///     <seealso cref="OnItemAdded" />
    /// </summary>
    public virtual void OnSubItemAdded(Item item)
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when <paramref name="item" /> is removed from the Mobile, its
    ///     <see cref="Mobile.Backpack">backpack</see>, or its <see cref="Mobile.BankBox">bank box</see>.
    ///     <seealso cref="OnSubItemAdded" />
    ///     <seealso cref="OnItemRemoved" />
    /// </summary>
    public virtual void OnSubItemRemoved(Item item)
    {
    }

    public virtual void OnItemBounceCleared(Item item)
    {
    }

    public virtual void OnSubItemBounceCleared(Item item)
    {
    }

    public void AddItem(Item item)
    {
        if (item?.Deleted != false)
        {
            return;
        }

        if (item.Parent == this)
        {
            return;
        }

        if (item.Parent is Mobile parentMobile)
        {
            parentMobile.RemoveItem(item);
        }
        else if (item.Parent is Item parentItem)
        {
            parentItem.RemoveItem(item);
        }
        else
        {
            item.SendRemovePacket();
        }

        item.Parent = this;
        item.Map = m_Map;

        Items.Add(item);

        if (!item.IsVirtualItem)
        {
            UpdateTotal(item, TotalType.Gold, item.TotalGold);
            UpdateTotal(item, TotalType.Items, item.TotalItems + 1);
            UpdateTotal(item, TotalType.Weight, item.TotalWeight + item.PileWeight);
        }

        item.Delta(ItemDelta.Update);

        item.OnAdded(this);
        OnItemAdded(item);

        if (item.PhysicalResistance != 0 || item.FireResistance != 0 || item.ColdResistance != 0 ||
            item.PoisonResistance != 0 || item.EnergyResistance != 0)
        {
            UpdateResistances();
        }
    }

    public void RemoveItem(Item item)
    {
        if (item == null || Items == null)
        {
            return;
        }

        if (Items.Remove(item))
        {
            item.SendRemovePacket();

            if (!item.IsVirtualItem)
            {
                UpdateTotal(item, TotalType.Gold, -item.TotalGold);
                UpdateTotal(item, TotalType.Items, -(item.TotalItems + 1));
                UpdateTotal(item, TotalType.Weight, -(item.TotalWeight + item.PileWeight));
            }

            item.Parent = null;

            item.OnRemoved(this);
            OnItemRemoved(item);

            if (item.PhysicalResistance != 0 || item.FireResistance != 0 || item.ColdResistance != 0 ||
                item.PoisonResistance != 0 || item.EnergyResistance != 0)
            {
                UpdateResistances();
            }
        }
    }

    public virtual void Animate(int action, int frameCount, int repeatCount, bool forward, bool repeat, int delay)
    {
        var map = m_Map;

        if (map == null)
        {
            return;
        }

        ProcessDelta();

        Span<byte> buffer = stackalloc byte[OutgoingMobilePackets.MobileAnimationPacketLength].InitializePacket();

        foreach (var state in map.GetClientsInRange(m_Location))
        {
            if (!state.Mobile.CanSee(this))
            {
                continue;
            }

            state.Mobile.ProcessDelta();

            if (Body.IsGargoyle)
            {
                frameCount = 10;

                if (Flying)
                {
                    action = action switch
                    {
                        >= 9 and <= 11    => 71,
                        >= 12 and <= 14   => 72,
                        20                => 77,
                        31                => 71,
                        34                => 78,
                        >= 200 and <= 259 => 75,
                        >= 260 and <= 270 => 75,
                        _                 => action
                    };
                }
                else
                {
                    action = action switch
                    {
                        >= 200 and <= 259 => 17,
                        >= 260 and <= 270 => 16,
                        _                 => action
                    };
                }
            }

            OutgoingMobilePackets.CreateMobileAnimation(
                buffer,
                Serial,
                action,
                frameCount,
                repeatCount,
                forward,
                repeat,
                delay
            );

            state.Send(buffer);
        }
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void SendSound(int soundID)
    {
        m_NetState.SendSoundEffect(soundID, this);
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public void SendSound(int soundID, IPoint3D p)
    {
        m_NetState.SendSoundEffect(soundID, p);
    }

    /**
         * Plays a sound to netstates that can see this mobile
         */
    public void PlaySound(int soundID)
    {
        if (soundID == -1 || m_Map == null)
        {
            return;
        }

        Span<byte> buffer = stackalloc byte[OutgoingEffectPackets.SoundPacketLength].InitializePacket();

        foreach (var state in m_Map.GetClientsInRange(m_Location))
        {
            if (state.Mobile.CanSee(this))
            {
                OutgoingEffectPackets.CreateSoundEffect(buffer, soundID, this);
                state.Send(buffer);
            }
        }
    }

    public virtual void SendOPLPacketTo(NetState ns)
    {
        if (ObjectPropertyList.Enabled)
        {
            ns.SendOPLInfo(this);
        }
    }

    public virtual void OnAccessLevelChanged(AccessLevel oldLevel)
    {
    }

    public virtual void OnFameChange(int oldValue)
    {
    }

    public virtual void OnKarmaChange(int oldValue)
    {
    }

    // Mobile did something which should unhide him
    public virtual void RevealingAction()
    {
        if (m_Hidden && m_AccessLevel == AccessLevel.Player)
        {
            Hidden = false;
        }

        DisruptiveAction(); // Anything that unhides you will also distrupt meditation
    }

    public void SendRemovePacket(bool everyone = true)
    {
        if (m_Map == null)
        {
            return;
        }

        Span<byte> removeEntity = stackalloc byte[OutgoingEntityPackets.RemoveEntityLength].InitializePacket();

        foreach (var state in m_Map.GetClientsInRange(m_Location))
        {
            if (state != m_NetState && (everyone || !state.Mobile.CanSee(this)))
            {
                OutgoingEntityPackets.CreateRemoveEntity(removeEntity, Serial);
                state.Send(removeEntity);
            }
        }
    }

    public void ClearScreen()
    {
        if (m_Map == null || m_NetState == null)
        {
            return;
        }

        foreach (var m in m_Map.GetMobilesInRange(m_Location, Core.GlobalMaxUpdateRange))
        {
            if (m != this && Utility.InUpdateRange(m_Location, m.m_Location))
            {
                m_NetState.SendRemoveEntity(m.Serial);
            }
        }

        foreach (var item in m_Map.GetItemsInRange(m_Location, Core.GlobalMaxUpdateRange))
        {
            if (InRange(item.Location, item.GetUpdateRange(this)))
            {
                m_NetState.SendRemoveEntity(item.Serial);
            }
        }
    }

    /// <summary>
    ///     Overridable. Event invoked before the Mobile says something.
    ///     <seealso cref="DoSpeech" />
    /// </summary>
    public virtual void OnSaid(SpeechEventArgs e)
    {
        if (Squelched)
        {
            if (Core.ML)
            {
                SendLocalizedMessage(500168); // You can not say anything, you have been muted.
            }
            else
            {
                SendMessage("You can not say anything, you have been squelched."); // Cliloc ITSELF changed during ML.
            }

            e.Blocked = true;
        }

        if (!e.Blocked)
        {
            RevealingAction();
        }
    }

    public virtual bool HandlesOnSpeech(Mobile from) => false;

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile hears speech. This event will only be invoked if
    ///     <see cref="HandlesOnSpeech" /> returns true.
    ///     <seealso cref="DoSpeech" />
    /// </summary>
    public virtual void OnSpeech(SpeechEventArgs e)
    {
    }

    public void SendEverything()
    {
        var ns = m_NetState;

        if (m_Map == null || ns == null)
        {
            return;
        }

        foreach (var m in m_Map.GetMobilesInRange(m_Location, Core.GlobalMaxUpdateRange))
        {
            if (CanSee(m) && Utility.InUpdateRange(m_Location, m.m_Location))
            {
                ns.SendMobileIncoming(this, m);

                if (ns.StygianAbyss)
                {
                    ns.SendMobileHealthbar(m, Healthbar.Yellow);
                    ns.SendMobileHealthbar(m, Healthbar.Poison);
                }

                if (m.IsDeadBondedPet)
                {
                    ns.SendBondedStatus(m.Serial, true);
                }

                m.SendOPLPacketTo(ns);
            }
        }

        foreach (var item in m_Map.GetItemsInRange(m_Location, Core.GlobalMaxUpdateRange))
        {
            if (CanSee(item) && InRange(item.Location, item.GetUpdateRange(this)))
            {
                item.SendInfoTo(ns);
            }
        }

        var range = new Rectangle2D(
            m_Location.X - Core.GlobalMaxUpdateRange,
            m_Location.Y - Core.GlobalMaxUpdateRange,
            Core.GlobalMaxUpdateRange * 2 + 1,
            Core.GlobalMaxUpdateRange * 2 + 1
        );

        foreach (var multi in m_Map.GetMultisInBounds(range))
        {
            multi.SendInfoTo(ns);
        }
    }

    public void UpdateRegion()
    {
        if (Deleted)
        {
            return;
        }

        var newRegion = Region.Find(m_Location, m_Map);

        if (newRegion != m_Region)
        {
            Region.OnRegionChange(this, m_Region, newRegion);

            var oldRegion = m_Region;
            m_Region = newRegion;
            OnRegionChange(oldRegion, newRegion);
        }
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when <see cref="Map" /> changes.
    /// </summary>
    protected virtual void OnMapChange(Map oldMap)
    {
    }

    public void SetDirection(Direction dir)
    {
        m_Direction = dir;
    }

    public virtual int GetSeason() => m_Map?.Season ?? 1;

    public virtual int GetPacketFlags(bool stygianAbyss)
    {
        var flags = 0x0;

        if (m_Paralyzed || m_Frozen || _disableCastParalyze && m_Spell?.BlocksMovement == true)
        {
            flags |= 0x01;
        }

        if (m_Female)
        {
            flags |= 0x02;
        }

        if (stygianAbyss)
        {
            if (m_Flying)
            {
                flags |= 0x04;
            }
        }
        else
        {
            if (m_Poison != null)
            {
                flags |= 0x04;
            }
        }

        if (m_Blessed || m_YellowHealthbar)
        {
            flags |= 0x08;
        }

        if (IgnoreMobiles)
        {
            flags |= 0x10;
        }

        if (m_Warmode)
        {
            flags |= 0x40;
        }

        if (m_Hidden)
        {
            flags |= 0x80;
        }

        return flags;
    }

    public virtual void OnGenderChanged(bool oldFemale)
    {
    }

    public virtual void ToggleFlying()
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked after the Warmode property has changed.
    /// </summary>
    public virtual void OnWarmodeChanged()
    {
    }

    public virtual void OnHiddenChanged()
    {
        AllowedStealthSteps = 0;

        if (m_Map == null)
        {
            return;
        }

        Span<byte> removeEntity = stackalloc byte[OutgoingEntityPackets.RemoveEntityLength].InitializePacket();

        foreach (var state in m_Map.GetClientsInRange(m_Location))
        {
            var m = state.Mobile;
            if (!m.CanSee(this))
            {
                OutgoingEntityPackets.CreateRemoveEntity(removeEntity, Serial);
                state.Send(removeEntity);
            }
            else
            {
                state.SendMobileIncoming(m, this);

                if (IsDeadBondedPet)
                {
                    state.SendBondedStatus(Serial, true);
                }

                SendOPLPacketTo(state);
            }
        }
    }

    public virtual void OnConnected()
    {
    }

    public virtual void OnBeforeDisconnected()
    {
    }

    public virtual void OnDisconnected()
    {
    }

    public virtual void OnNetStateChanged()
    {
    }

    public virtual bool CanSee(object o)
    {
        return o switch
        {
            Item item     => CanSee(item),
            Mobile mobile => CanSee(mobile),
            _             => true
        };
    }

    public virtual bool CanSee(Item item)
    {
        if (m_Map == Map.Internal)
        {
            return false;
        }

        if (item.Map == Map.Internal)
        {
            return false;
        }

        if (item.Parent is Item parent)
        {
            if (!(CanSee(parent) && parent.IsChildVisibleTo(this, item)))
            {
                return false;
            }
        }
        else if (item.Parent is Mobile mobile && !CanSee(mobile))
        {
            return false;
        }

        if (item is BankBox box && m_AccessLevel <= AccessLevel.Counselor && (box.Owner != this || !box.Opened))
        {
            return false;
        }

        if (item is SecureTradeContainer container)
        {
            var trade = container.Trade;

            if (trade != null && trade.From.Mobile != this && trade.To.Mobile != this)
            {
                return false;
            }
        }

        return !item.Deleted && item.Map == m_Map && (item.Visible || item.CanSeeStaffOnly(this));
    }

    public virtual bool CanSee(Mobile m)
    {
        if (Deleted || m.Deleted || m_Map == Map.Internal || m.m_Map == Map.Internal)
        {
            return false;
        }

        return this == m || m.m_Map == m_Map &&
            (!m.Hidden || m_AccessLevel != AccessLevel.Player &&
                (m_AccessLevel >= m.AccessLevel || m_AccessLevel >= AccessLevel.Administrator)) &&
            (m.Alive || Core.SE && Skills.SpiritSpeak.Value >= 100.0 || !Alive ||
             m_AccessLevel > AccessLevel.Player || m.Warmode);
    }

    public virtual bool CanBeRenamedBy(Mobile from) =>
        from.AccessLevel >= AccessLevel.GameMaster && from.m_AccessLevel > m_AccessLevel;

    public virtual void OnAfterNameChange(string oldName, string newName)
    {
    }

    public virtual int SafeBody(int body)
    {
        var delta = -1;

        for (var i = 0; delta < 0 && i < m_InvalidBodies.Length; ++i)
        {
            delta = m_InvalidBodies[i] - body;
        }

        return delta != 0 ? body : 0;
    }

    private ObjectPropertyList InitializePropertyList(ObjectPropertyList list)
    {
        GetProperties(list);
        list.Terminate();
        return list;
    }

    public void ClearProperties()
    {
        m_PropertyList = null;
    }

#nullable enable
    public void InvalidateProperties()
    {
        if (!ObjectPropertyList.Enabled)
        {
            return;
        }

        if (m_Map != null && m_Map != Map.Internal && !World.Loading)
        {
            int? oldHash;
            int newHash;
            if (m_PropertyList != null)
            {
                oldHash = m_PropertyList.Hash;
                m_PropertyList.Reset();
                InitializePropertyList(m_PropertyList);
                newHash = m_PropertyList.Hash;
            }
            else
            {
                oldHash = null;
                newHash = PropertyList.Hash;
            }

            if (oldHash != newHash)
            {
                Delta(MobileDelta.Properties);
            }
        }
        else
        {
            ClearProperties();
        }
    }
#nullable restore

    public virtual void SetLocation(Point3D newLocation, bool isTeleport)
    {
        if (Deleted)
        {
            return;
        }

        var oldLocation = m_Location;

        if (oldLocation == newLocation)
        {
            return;
        }

        m_Location = newLocation;
        m_Map?.OnMove(oldLocation, this);
        UpdateRegion();

        var box = FindBankNoCreate();

        if (box?.Opened == true)
        {
            box.Close();
        }

        if (m_NetState != null)
        {
            m_NetState.ValidateAllTrades();

            if (isTeleport && (!m_NetState.HighSeas || !NoMoveHS))
            {
                m_NetState.Sequence = 0;
                m_NetState.SendMobileUpdate(this);
            }
        }

        var map = m_Map;

        if (map != null)
        {
            // First, send a remove message to everyone who can no longer see us. (inOldRange && !inNewRange)
            Span<byte> removeEntity = stackalloc byte[OutgoingEntityPackets.RemoveEntityLength].InitializePacket();

            foreach (var ns in map.GetClientsInRange(oldLocation))
            {
                if (ns != m_NetState && !Utility.InUpdateRange(newLocation, ns.Mobile.Location))
                {
                    OutgoingEntityPackets.CreateRemoveEntity(removeEntity, Serial);
                    ns.Send(removeEntity);
                }
            }

            var ourState = m_NetState;

            // Check to see if we are attached to a client
            if (ourState != null)
            {
                // We are attached to a client, so it's a bit more complex. We need to send new items and people to ourself, and ourself to other clients

                foreach (var m in map.GetMobilesInRange(newLocation, Core.GlobalMaxUpdateRange))
                {
                    if (m == this)
                    {
                        continue;
                    }

                    if (!Utility.InUpdateRange(newLocation, m.m_Location))
                    {
                        continue;
                    }

                    var inOldRange = Utility.InUpdateRange(oldLocation, m.m_Location);
                    var ns = m.m_NetState;

                    if (ns != null &&
                        (isTeleport && (!ns.HighSeas || !NoMoveHS) || !inOldRange) && m.CanSee(this))
                    {
                        ns.SendMobileIncoming(m, this);

                        if (ns.StygianAbyss)
                        {
                            ns.SendMobileHealthbar(this, Healthbar.Poison);
                            ns.SendMobileHealthbar(this, Healthbar.Yellow);
                        }

                        if (IsDeadBondedPet)
                        {
                            ns.SendBondedStatus(Serial, true);
                        }

                        SendOPLPacketTo(ns);
                    }

                    if (inOldRange || !CanSee(m))
                    {
                        continue;
                    }

                    ourState.SendMobileIncoming(this, m);

                    if (ourState.StygianAbyss)
                    {
                        ourState.SendMobileHealthbar(m, Healthbar.Poison);
                        ourState.SendMobileHealthbar(m, Healthbar.Yellow);
                    }

                    if (m.IsDeadBondedPet)
                    {
                        ourState.SendBondedStatus(m.Serial, true);
                    }

                    m.SendOPLPacketTo(ourState);
                }

                foreach (var item in map.GetItemsInRange(newLocation, Core.GlobalMaxUpdateRange))
                {
                    var range = item.GetUpdateRange(this);
                    var loc = item.Location;

                    if (!Utility.InRange(oldLocation, loc, range) && Utility.InRange(newLocation, loc, range) &&
                        CanSee(item))
                    {
                        item.SendInfoTo(ourState);
                    }
                }
            }
            else
            {
                // We're not attached to a client, so simply send an Incoming
                foreach (var ns in map.GetClientsInRange(newLocation))
                {
                    var m = ns.Mobile;
                    if ((isTeleport && (!ns.HighSeas || !NoMoveHS) || !Utility.InUpdateRange(oldLocation, m.Location)) &&
                        m.CanSee(this))
                    {
                        ns.SendMobileIncoming(m, this);

                        if (ns.StygianAbyss)
                        {
                            ns.SendMobileHealthbar(this, Healthbar.Poison);
                            ns.SendMobileHealthbar(this, Healthbar.Yellow);
                        }

                        if (IsDeadBondedPet)
                        {
                            ns.SendBondedStatus(Serial, true);
                        }

                        SendOPLPacketTo(ns);
                    }
                }
            }
        }

        OnLocationChange(oldLocation);

        Region.OnLocationChanged(this, oldLocation);
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when <see cref="Location" /> changes.
    /// </summary>
    protected virtual void OnLocationChange(Point3D oldLocation)
    {
    }

    public bool HasFreeHand() => FindItemOnLayer(Layer.TwoHanded) == null;

    public virtual IWeapon GetDefaultWeapon() => DefaultWeapon;

    public BankBox FindBankNoCreate()
    {
        if (m_BankBox?.Deleted != false || m_BankBox.Parent != this)
        {
            m_BankBox = FindItemOnLayer<BankBox>(Layer.Bank);
        }

        return m_BankBox;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public T FindItemOnLayer<T>(Layer layer) where T : Item => FindItemOnLayer(layer) as T;

    public Item FindItemOnLayer(Layer layer)
    {
        var eq = Items;
        var count = eq.Count;

        for (var i = 0; i < count; ++i)
        {
            var item = eq[i];

            // TODO: We only allow 1 item per layer. It's an implicit contract.
            if (!item.Deleted && item.Layer == layer)
            {
                return item;
            }
        }

        return null;
    }

    public void SendIncomingPacket()
    {
        if (m_Map == null)
        {
            return;
        }

        foreach (var state in m_Map.GetClientsInRange(m_Location))
        {
            var m = state.Mobile;
            if (m.CanSee(this))
            {
                state.SendMobileIncoming(m, this);

                if (state.StygianAbyss)
                {
                    state.SendMobileHealthbar(this, Healthbar.Poison);
                    state.SendMobileHealthbar(this, Healthbar.Yellow);
                }

                if (IsDeadBondedPet)
                {
                    state.SendBondedStatus(Serial, true);
                }

                SendOPLPacketTo(state);
            }
        }
    }

    public bool PlaceInBackpack(Item item) =>
        !item.Deleted && Backpack?.TryDropItem(this, item, false) == true;

    public bool AddToBackpack(Item item)
    {
        if (item.Deleted)
        {
            return false;
        }

        if (!PlaceInBackpack(item))
        {
            var loc = m_Location;
            var map = m_Map;

            if ((map == null || map == Map.Internal) && LogoutMap != null)
            {
                loc = LogoutLocation;
                map = LogoutMap;
            }

            item.MoveToWorld(loc, map);
            return false;
        }

        return true;
    }

    public virtual bool CheckLift(Mobile from, Item item, ref LRReason reject) => true;

    public virtual bool CheckNonlocalLift(Mobile from, Item item) =>
        from == this || from.AccessLevel > AccessLevel && from.AccessLevel >= AccessLevel.GameMaster;

    public virtual bool CheckTrade(
        Mobile to, Item item, SecureTradeContainer cont, bool message, bool checkItems, int plusItems, int plusWeight
    ) => true;

    public virtual bool OpenTrade(Mobile from, Item offer = null)
    {
        if (!from.Player || !Player || !from.Alive || !Alive)
        {
            return false;
        }

        var ourState = m_NetState;
        var theirState = from.m_NetState;

        if (ourState == null || theirState == null)
        {
            return false;
        }

        var cont = theirState.FindTradeContainer(this);

        if (!from.CheckTrade(this, offer, cont, true, true, 0, 0))
        {
            return false;
        }

        cont ??= theirState.AddTrade(ourState);

        if (offer != null)
        {
            cont.DropItem(offer);
        }

        return true;
    }

    /// <summary>
    ///     Overridable. Event invoked when a Mobile (<paramref name="from" />) drops an
    ///     <see cref="Item">
    ///         <paramref name="dropped" />
    ///     </see>
    ///     onto the Mobile.
    /// </summary>
    public virtual bool OnDragDrop(Mobile from, Item dropped)
    {
        if (from == this)
        {
            var pack = Backpack;
            return pack != null && dropped.DropToItem(from, pack, new Point3D(-1, -1, 0));
        }

        return from.InRange(Location, 2) && OpenTrade(from, dropped);
    }

    public virtual bool CheckEquip(Item item)
    {
        for (var i = 0; i < Items.Count; ++i)
        {
            if (Items[i].CheckConflictingLayer(this, item, item.Layer) ||
                item.CheckConflictingLayer(this, Items[i], Items[i].Layer))
            {
                return false;
            }
        }

        return true;
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile attempts to wear <paramref name="item" />.
    /// </summary>
    /// <returns>True if the request is accepted, false if otherwise.</returns>
    public virtual bool OnEquip(Item item)
    {
        // For some reason OSI allows equipping quest items, but they are unmarked in the process
        if (item.QuestItem)
        {
            item.QuestItem = false;

            // An item must be in your backpack (and not in a container within) to be toggled as a quest item.
            SendLocalizedMessage(1074769);
        }

        return true;
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile attempts to lift <paramref name="item" />.
    /// </summary>
    /// <returns>True if the lift is allowed, false if otherwise.</returns>
    /// <example>
    ///     The following example demonstrates usage. It will disallow any attempts to pick up a pick axe if the Mobile does not
    ///     have
    ///     enough strength.
    ///     <code>
    ///   public override bool OnDragLift( Item item )
    ///   {
    ///     if (item is Pickaxe &amp;&amp; this.Str &lt; 60)
    ///     {
    ///       SendMessage( "That is too heavy for you to lift." );
    ///       return false;
    ///     }
    ///
    ///     return base.OnDragLift( item );
    ///   }</code>
    /// </example>
    public virtual bool OnDragLift(Item item) => true;

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile attempts to drop <paramref name="item" /> into a
    ///     <see cref="Container">
    ///         <paramref name="container" />
    ///     </see>
    ///     .
    /// </summary>
    /// <returns>True if the drop is allowed, false if otherwise.</returns>
    public virtual bool OnDroppedItemInto(Item item, Container container, Point3D loc) => true;

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile attempts to drop <paramref name="item" /> directly onto another
    ///     <see cref="Item" />, <paramref name="target" />. This is the case of stacking items.
    /// </summary>
    /// <returns>True if the drop is allowed, false if otherwise.</returns>
    public virtual bool OnDroppedItemOnto(Item item, Item target) => true;

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile attempts to drop <paramref name="item" /> into another
    ///     <see cref="Item" />, <paramref name="target" />. The target item is most likely a <see cref="Container" />.
    /// </summary>
    /// <returns>True if the drop is allowed, false if otherwise.</returns>
    public virtual bool OnDroppedItemToItem(Item item, Item target, Point3D loc) => true;

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile attempts to give <paramref name="item" /> to a Mobile (
    ///     <paramref name="target" />).
    /// </summary>
    /// <returns>True if the drop is allowed, false if otherwise.</returns>
    public virtual bool OnDroppedItemToMobile(Item item, Mobile target) => true;

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile attempts to drop <paramref name="item" /> to the world at a
    ///     <see cref="Point3D">
    ///         <paramref name="location" />
    ///     </see>
    ///     .
    /// </summary>
    /// <returns>True if the drop is allowed, false if otherwise.</returns>
    public virtual bool OnDroppedItemToWorld(Item item, Point3D location) => true;

    /// <summary>
    ///     Overridable. Virtual event when <paramref name="from" /> successfully uses <paramref name="item" /> while it's on this
    ///     Mobile.
    ///     <seealso cref="Item.OnItemUsed" />
    /// </summary>
    public virtual void OnItemUsed(Mobile from, Item item)
    {
    }

    public virtual bool CheckNonlocalDrop(Mobile from, Item item, Item target) =>
        from == this || from.AccessLevel > AccessLevel && from.AccessLevel >= AccessLevel.GameMaster;

    public virtual bool CheckItemUse(Mobile from, Item item) => true;

    /// <summary>
    ///     Overridable. Virtual event invoked when <paramref name="from" /> successfully lifts <paramref name="item" /> from this
    ///     Mobile.
    ///     <seealso cref="Item.OnItemLifted" />
    /// </summary>
    public virtual void OnItemLifted(Mobile from, Item item)
    {
    }

    public virtual bool AllowItemUse(Item item) => true;

    public virtual bool AllowEquipFrom(Mobile mob) =>
        mob == this || mob.AccessLevel >= AccessLevel.GameMaster && mob.AccessLevel > AccessLevel;

    public virtual bool EquipItem(Item item)
    {
        if (item?.Deleted != false || !item.CanEquip(this))
        {
            return false;
        }

        if (CheckEquip(item) && OnEquip(item) && item.OnEquip(this))
        {
            if (m_Spell?.OnCasterEquipping(item) == false)
            {
                return false;
            }

            // if (m_Spell != null && m_Spell.State == SpellState.Casting)
            // m_Spell.Disturb( DisturbType.EquipRequest );

            AddItem(item);
            return true;
        }

        return false;
    }

    public void DefaultMobileInit()
    {
        m_StatCap = 225;
        m_FollowersMax = 5;
        Skills = new Skills(this);
        Items = new List<Item>();
        _statMods = new List<StatMod>();
        _skillMods = new List<SkillMod>();
        Map = Map.Internal;
        AutoPageNotify = true;
        Aggressors = new List<AggressorInfo>();
        Aggressed = new List<AggressorInfo>();
        DamageEntries = new List<DamageEntry>();

        NextSkillTime = Core.TickCount;
    }

    public virtual void Delta(MobileDelta flag)
    {
#if THREADGUARD
            if (Thread.CurrentThread != Core.Thread)
            {
                Utility.PushColor(ConsoleColor.Red);
                Console.WriteLine("Attempting to queue a delta change from an invalid thread!");
                Console.WriteLine(new StackTrace());
                Utility.PopColor();
                return;
            }
#endif

        if (m_Map == null || m_Map == Map.Internal || Deleted)
        {
            return;
        }

        m_DeltaFlags |= flag;

        if (!m_InDeltaQueue)
        {
            m_InDeltaQueue = true;
            m_DeltaQueue.Enqueue(this);
        }
    }

    public static void ProcessDeltaQueue()
    {
        var limit = m_DeltaQueue.Count;

        while (m_DeltaQueue.Count > 0 && --limit >= 0)
        {
            var mob = m_DeltaQueue.Dequeue();

            if (mob == null)
            {
                continue;
            }

            mob.m_InDeltaQueue = false;

            try
            {
                mob.ProcessDelta();
            }
            catch (Exception ex)
            {
                logger.Debug(ex, "Process Delta Queue for {Mobile} failed", mob);
            }
        }

        if (m_DeltaQueue.Count > 0)
        {
            logger.Warning("{Count} mobiles left in delta queue after processing.", m_DeltaQueue.Count);
        }
    }

    public virtual void OnKillsChange(int oldValue)
    {
    }

    public bool CheckAlive(bool message = true)
    {
        if (Alive)
        {
            return true;
        }

        if (message)
        {
            LocalOverheadMessage(MessageType.Regular, 0x3B2, 1019048); // I am dead and cannot do that.
        }

        return false;
    }

    public void LaunchBrowser(string url)
    {
        m_NetState?.LaunchBrowser(url);
    }

    public void InitStats(int str, int dex, int intel)
    {
        m_Str = str;
        m_Dex = dex;
        m_Int = intel;

        Hits = HitsMax;
        Stam = StamMax;
        Mana = ManaMax;

        Delta(MobileDelta.Stat | MobileDelta.Hits | MobileDelta.Stam | MobileDelta.Mana);
    }

    public virtual void DisplayPaperdollTo(Mobile to)
    {
        EventSink.InvokePaperdollRequest(to, this);
    }

    /// <summary>
    ///     Overridable. Event invoked when the Mobile requests to open his own paperdoll via the 'Open Paperdoll' macro.
    /// </summary>
    public virtual void OnPaperdollRequest()
    {
        if (CanPaperdollBeOpenedBy(this))
        {
            DisplayPaperdollTo(this);
        }
    }

    /// <summary>
    ///     Overridable. Event invoked when <paramref name="from" /> wants to see this Mobile's stats.
    /// </summary>
    /// <param name="from"></param>
    public virtual void OnStatsQuery(Mobile from)
    {
        if (from.Map == Map && Utility.InUpdateRange(Location, from.Location) && from.CanSee(this))
        {
            from.m_NetState.SendMobileStatus(from, this);
        }

        if (from == this)
        {
            m_NetState.SendStatLockInfo(this);
        }

        if (Party is IParty ip)
        {
            ip.OnStatsQuery(from, this);
        }
    }

    /// <summary>
    ///     Overridable. Event invoked when <paramref name="from" /> wants to see this Mobile's skills.
    /// </summary>
    public virtual void OnSkillsQuery(Mobile from)
    {
        if (from == this)
        {
            m_NetState.SendSkillsUpdate(Skills);
        }
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when <see cref="Region" /> changes.
    /// </summary>
    public virtual void OnRegionChange(Region old, Region @new)
    {
    }

    /// <summary>
    ///     Overridable. Event invoked when the Mobile is single clicked.
    /// </summary>
    public virtual void OnSingleClick(Mobile from)
    {
        if (Deleted || AccessLevel == AccessLevel.Player && DisableHiddenSelfClick && Hidden && from == this)
        {
            return;
        }

        int hue;

        if (NameHue != -1)
        {
            hue = NameHue;
        }
        else if (AccessLevel > AccessLevel.Player)
        {
            hue = 11;
        }
        else
        {
            hue = Notoriety.GetHue(Notoriety.Compute(from, this));
        }

        var name = Name ?? "";

        var prefix = "";

        if (ShowFameTitle && (m_Player || m_Body.IsHuman) && m_Fame >= 10000)
        {
            prefix = m_Female ? "Lady" : "Lord";
        }

        var suffix = ApplyNameSuffix(ClickTitle && !string.IsNullOrEmpty(Title) ? Title : "");

        string val;

        if (prefix.Length > 0 && suffix.Length > 0)
        {
            val = $"{prefix} {name} {suffix}";
        }
        else if (prefix.Length > 0)
        {
            val = $"{prefix} {name}";
        }
        else if (suffix.Length > 0)
        {
            val = $"{name} {suffix}";
        }
        else
        {
            val = name;
        }

        PrivateOverheadMessage(MessageType.Label, hue, AsciiClickMessage, val, from.NetState);
    }

    public bool CheckSkill(SkillName skill, double minSkill, double maxSkill) =>
        SkillCheckLocationHandler?.Invoke(this, skill, minSkill, maxSkill) == true;

    public bool CheckSkill(SkillName skill, double chance) =>
        SkillCheckDirectLocationHandler?.Invoke(this, skill, chance) == true;

    public bool CheckTargetSkill(SkillName skill, object target, double minSkill, double maxSkill) =>
        SkillCheckTargetHandler?.Invoke(this, skill, target, minSkill, maxSkill) == true;

    public bool CheckTargetSkill(SkillName skill, object target, double chance) =>
        SkillCheckDirectTargetHandler?.Invoke(this, skill, target, chance) == true;

    public virtual void DisruptiveAction()
    {
        if (Meditating)
        {
            Meditating = false;
            SendLocalizedMessage(500134); // You stop meditating.
        }
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the sector this Mobile is in gets <see cref="Map.Sector.Activate">activated</see>.
    /// </summary>
    public virtual void OnSectorActivate()
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the sector this Mobile is in gets
    ///     <see cref="Map.Sector.Deactivate">deactivated</see>.
    /// </summary>
    public virtual void OnSectorDeactivate()
    {
    }

    public static TimeSpan GetHitsRegenRate(Mobile m) => HitsRegenRateHandler?.Invoke(m) ?? DefaultHitsRate;

    public static TimeSpan GetStamRegenRate(Mobile m) => StamRegenRateHandler?.Invoke(m) ?? DefaultStamRate;

    public static TimeSpan GetManaRegenRate(Mobile m) => ManaRegenRateHandler?.Invoke(m) ?? DefaultManaRate;

    public static char[] DefaultGhostChars = { 'o', 'O' };

    public Prompt BeginPrompt(PromptCallback callback, PromptCallback cancelCallback) =>
        Prompt = new SimplePrompt(callback, cancelCallback);

    public Prompt BeginPrompt(PromptCallback callback, bool callbackHandlesCancel = false) =>
        Prompt = new SimplePrompt(callback, callbackHandlesCancel);

    public Prompt BeginPrompt<T>(PromptStateCallback<T> callback, PromptStateCallback<T> cancelCallback, T state) =>
        Prompt = new SimpleStatePrompt<T>(callback, cancelCallback, state);

    public Prompt BeginPrompt<T>(PromptStateCallback<T> callback, bool callbackHandlesCancel, T state) =>
        Prompt = new SimpleStatePrompt<T>(callback, callbackHandlesCancel, state);

    public Prompt BeginPrompt<T>(PromptStateCallback<T> callback, T state) =>
        BeginPrompt(callback, false, state);

    public virtual int GetAngerSound()
    {
        if (BaseSoundID != 0)
        {
            return BaseSoundID;
        }

        return -1;
    }

    public virtual int GetIdleSound()
    {
        if (BaseSoundID != 0)
        {
            return BaseSoundID + 1;
        }

        return -1;
    }

    public virtual int GetAttackSound()
    {
        if (BaseSoundID != 0)
        {
            return BaseSoundID + 2;
        }

        return -1;
    }

    public virtual int GetHurtSound()
    {
        if (BaseSoundID != 0)
        {
            return BaseSoundID + 3;
        }

        return -1;
    }

    public virtual int GetDeathSound()
    {
        if (BaseSoundID != 0)
        {
            return BaseSoundID + 4;
        }

        if (m_Body.IsHuman)
        {
            return Utility.Random(m_Female ? 0x314 : 0x423, m_Female ? 4 : 5);
        }

        return -1;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Map.ItemAtEnumerable<Item> GetItemsAt() =>
        m_Map == null ? Map.ItemAtEnumerable<Item>.Empty : m_Map.GetItemsAt(m_Location);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Map.ItemAtEnumerable<T> GetItemsAt<T>() where T : Item =>
        m_Map == null ? Map.ItemAtEnumerable<T>.Empty : m_Map.GetItemsAt<T>(m_Location);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Map.ItemBoundsEnumerable<Item> GetItemsInRange(int range) => GetItemsInRange<Item>(range);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Map.ItemBoundsEnumerable<T> GetItemsInRange<T>(int range) where T : Item =>
        m_Map == null ? Map.ItemBoundsEnumerable<T>.Empty : m_Map.GetItemsInRange<T>(m_Location, range);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Map.MobileAtEnumerable<Mobile> GetMobilesInRange() => GetMobilesInRange<Mobile>();

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Map.MobileAtEnumerable<T> GetMobilesInRange<T>() where T : Mobile =>
        m_Map == null ? Map.MobileAtEnumerable<T>.Empty : m_Map.GetMobilesAt<T>(m_Location);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Map.MobileBoundsEnumerable<Mobile> GetMobilesInRange(int range) => GetMobilesInRange<Mobile>(range);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Map.MobileBoundsEnumerable<T> GetMobilesInRange<T>(int range) where T : Mobile =>
        m_Map == null ? Map.MobileBoundsEnumerable<T>.Empty : m_Map.GetMobilesInRange<T>(m_Location, range);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Map.ClientAtEnumerable GetClientsAt() =>
        m_Map == null ? Map.ClientAtEnumerable.Empty : Map.GetClientsAt(m_Location);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Map.ClientBoundsEnumerable GetClientsInRange(int range) =>
        m_Map == null ? Map.ClientBoundsEnumerable.Empty : Map.GetClientsInRange(m_Location, range);

    public void SayTo(Mobile to, bool ascii, string text) =>
        PrivateOverheadMessage(MessageType.Regular, SpeechHue, ascii, text, to.NetState);

    public void SayTo(Mobile to, string text) => SayTo(to, false, text);

    public void SayTo(Mobile to, int number, string args = "") =>
        to.NetState.SendMessageLocalized(Serial, Body, MessageType.Regular, SpeechHue, 3, number, Name, args);

    public void Say(bool ascii, string text) => PublicOverheadMessage(MessageType.Regular, SpeechHue, ascii, text);

    public void Say(string text) => PublicOverheadMessage(MessageType.Regular, SpeechHue, false, text);

    public void Say(int number, AffixType type, string affix, string args) =>
        PublicOverheadMessage(MessageType.Regular, SpeechHue, number, type, affix, args);

    public void Say(int number, string args = "") => PublicOverheadMessage(MessageType.Regular, SpeechHue, number, args);

    public void Emote(string text) => PublicOverheadMessage(MessageType.Emote, EmoteHue, false, text);

    public void Emote(int number, string args = "") => PublicOverheadMessage(MessageType.Emote, EmoteHue, number, args);

    public void Whisper(string text) => PublicOverheadMessage(MessageType.Whisper, WhisperHue, false, text);

    public void Whisper(int number, string args = "") =>
        PublicOverheadMessage(MessageType.Whisper, WhisperHue, number, args);

    public void Yell(string text) => PublicOverheadMessage(MessageType.Yell, YellHue, false, text);

    public void Yell(int number, string args = "") =>
        PublicOverheadMessage(MessageType.Yell, YellHue, number, args);

    public bool SendHuePicker(HuePicker p)
    {
        if (m_NetState != null)
        {
            p.SendTo(m_NetState);
            return true;
        }

        return false;
    }

    public bool SendMenu(IMenu m)
    {
        if (m_NetState == null)
        {
            return false;
        }

        m.SendTo(m_NetState);
        return true;
    }

    public virtual bool CanBeBeneficial(Mobile target) => CanBeBeneficial(target, true, false);

    public virtual bool CanBeBeneficial(Mobile target, bool message) => CanBeBeneficial(target, message, false);

    public virtual bool CanBeBeneficial(Mobile target, bool message, bool allowDead)
    {
        if (target == null)
        {
            return false;
        }

        if (Deleted || target.Deleted || !Alive || IsDeadBondedPet ||
            !allowDead && (!target.Alive || target.IsDeadBondedPet))
        {
            if (message)
            {
                SendLocalizedMessage(1001017); // You can not perform beneficial acts on your target.
            }

            return false;
        }

        if (target == this)
        {
            return true;
        }

        if ( /*m_Player &&*/!Region.AllowBeneficial(this, target))
        {
            // TODO: Pets
            // if (!(target.m_Player || target.Body.IsHuman || target.Body.IsAnimal))
            // {
            if (message)
            {
                SendLocalizedMessage(1001017); // You can not perform beneficial acts on your target.
            }

            return false;
            // }
        }

        return true;
    }

    public virtual bool IsBeneficialCriminal(Mobile target)
    {
        if (this == target)
        {
            return false;
        }

        var n = Notoriety.Compute(this, target);

        return n is Notoriety.Criminal or Notoriety.Murderer;
    }

    /// <summary>
    ///     Overridable. Event invoked when the Mobile <see cref="DoBeneficial">does a beneficial action</see>.
    /// </summary>
    public virtual void OnBeneficialAction(Mobile target, bool isCriminal)
    {
        if (isCriminal)
        {
            CriminalAction(false);
        }
    }

    public virtual void DoBeneficial(Mobile target)
    {
        if (target == null)
        {
            return;
        }

        OnBeneficialAction(target, IsBeneficialCriminal(target));

        Region.OnBeneficialAction(this, target);
        target.Region.OnGotBeneficialAction(this, target);
    }

    public virtual bool BeneficialCheck(Mobile target)
    {
        if (CanBeBeneficial(target, true))
        {
            DoBeneficial(target);
            return true;
        }

        return false;
    }

    public virtual bool CanBeHarmful(Mobile target) => CanBeHarmful(target, true);

    public virtual bool CanBeHarmful(Mobile target, bool message) => CanBeHarmful(target, message, false);

    public virtual bool CanBeHarmful(Mobile target, bool message, bool ignoreOurBlessedness)
    {
        if (target == null)
        {
            return false;
        }

        if (Deleted || !ignoreOurBlessedness && m_Blessed || target.Deleted || target.m_Blessed || !Alive ||
            IsDeadBondedPet || !target.Alive || target.IsDeadBondedPet)
        {
            if (message)
            {
                SendLocalizedMessage(1001018); // You can not perform negative acts on your target.
            }

            return false;
        }

        if (target == this)
        {
            return true;
        }

        // TODO: Pets
        if (!Region.AllowHarmful(this, target))
        {
            if (message)
            {
                SendLocalizedMessage(1001018); // You can not perform negative acts on your target.
            }

            return false;
        }

        return true;
    }

    public virtual bool IsHarmfulCriminal(Mobile target) =>
        this != target && Notoriety.Compute(this, target) == Notoriety.Innocent;

    /// <summary>
    ///     Overridable. Event invoked when the Mobile <see cref="DoHarmful">does a harmful action</see>.
    /// </summary>
    public virtual void OnHarmfulAction(Mobile target, bool isCriminal)
    {
        if (isCriminal)
        {
            CriminalAction(false);
        }
    }

    public virtual void DoHarmful(Mobile target, bool indirect = false)
    {
        if (target == null || Deleted)
        {
            return;
        }

        var isCriminal = IsHarmfulCriminal(target);

        OnHarmfulAction(target, isCriminal);
        target.AggressiveAction(this, isCriminal);

        Region.OnDidHarmful(this, target);
        target.Region.OnGotHarmful(this, target);

        if (!indirect)
        {
            Combatant = target;
        }

        _expireCombatantTimerToken.Cancel();
        Timer.StartTimer(ExpireCombatantDelay, ExpireCombatant, out _expireCombatantTimerToken);
    }

    public virtual bool HarmfulCheck(Mobile target)
    {
        if (CanBeHarmful(target))
        {
            DoHarmful(target);
            return true;
        }

        return false;
    }

    public virtual void RemoveStatMod(StatMod mod)
    {
        if (mod == null)
        {
            return;
        }

        // Remove it just in case it was orphaned somehow.
        mod.Remove();

        if (_statMods == null)
        {
            return;
        }

        if (_statMods.Remove(mod))
        {
            CheckStatTimers();
            Delta(MobileDelta.Stat | GetStatDelta(mod.Type));
        }

        if (_statMods.Count == 0)
        {
            _statMods = null;
        }
    }

    public virtual void RemoveStatMod(string name)
    {
        if (_statMods == null || name == null)
        {
            return;
        }

        for (var i = _statMods.Count - 1; i >= 0; i--)
        {
            var mod = _statMods[i];
            if (mod.Name == name)
            {
                _statMods.RemoveAt(i);
                mod.Remove();
                CheckStatTimers();
                Delta(MobileDelta.Stat | GetStatDelta(mod.Type));
            }
        }

        if (_statMods.Count == 0)
        {
            _statMods = null;
        }
    }

    public virtual StatMod GetStatMod(string name, bool includeElapsed = false)
    {
        if (_statMods == null || name == null)
        {
            return null;
        }

        for (var i = 0; i < _statMods.Count; i++)
        {
            var mod = _statMods[i];
            if (mod.Name == name && !mod.HasElapsed() || includeElapsed)
            {
                return mod;
            }
        }

        return null;
    }

    public virtual void AddStatMod(StatMod mod)
    {
        if (mod == null)
        {
            return;
        }

        mod.Owner = this;

        _statMods ??= new List<StatMod>();
        _statMods.Add(mod);
        Delta(MobileDelta.Stat | GetStatDelta(mod.Type));
        CheckStatTimers();
    }

    private static MobileDelta GetStatDelta(StatType type)
    {
        MobileDelta delta = 0;

        if ((type & StatType.Str) != 0)
        {
            delta |= MobileDelta.Hits;
        }

        if ((type & StatType.Dex) != 0)
        {
            delta |= MobileDelta.Stam;
        }

        if ((type & StatType.Int) != 0)
        {
            delta |= MobileDelta.Mana;
        }

        return delta;
    }

    /// <summary>
    ///     Computes the total modified offset for the specified stat type.
    /// </summary>
    public int GetStatOffset(StatType type)
    {
        if (_statMods == null || _statMods.Count == 0)
        {
            return 0;
        }

        var offset = 0;

        for (var i = 0; i < _statMods.Count; i++)
        {
            var mod = _statMods[i];
            if ((mod.Type & type) != 0 && !mod.HasElapsed())
            {
                offset += mod.Offset;
            }
        }

        return offset;
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the <see cref="RawStr" /> changes.
    ///     <seealso cref="RawStr" />
    ///     <seealso cref="OnRawStatChange" />
    /// </summary>
    public virtual void OnRawStrChange(int oldValue)
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when <see cref="RawDex" /> changes.
    ///     <seealso cref="RawDex" />
    ///     <seealso cref="OnRawStatChange" />
    /// </summary>
    public virtual void OnRawDexChange(int oldValue)
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the <see cref="RawInt" /> changes.
    ///     <seealso cref="RawInt" />
    ///     <seealso cref="OnRawStatChange" />
    /// </summary>
    public virtual void OnRawIntChange(int oldValue)
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the <see cref="RawStr" />, <see cref="RawDex" />, or <see cref="RawInt" />
    ///     changes.
    ///     <seealso cref="OnRawStrChange" />
    ///     <seealso cref="OnRawDexChange" />
    ///     <seealso cref="OnRawIntChange" />
    /// </summary>
    public virtual void OnRawStatChange(StatType stat, int oldValue)
    {
    }

    public virtual void OnHitsChange(int oldValue)
    {
    }

    public virtual void OnStamChange(int oldValue)
    {
    }

    public virtual void OnManaChange(int oldValue)
    {
    }

    /// <summary>
    ///     Overridable. Event invoked when a call to <see cref="ApplyPoison" /> failed because <see cref="CheckPoisonImmunity" />
    ///     returned false: the Mobile was resistant to the poison. By default, this broadcasts an overhead message: * The poison
    ///     seems to have no effect. *
    ///     <seealso cref="CheckPoisonImmunity" />
    ///     <seealso cref="ApplyPoison" />
    ///     <seealso cref="Poison" />
    /// </summary>
    public virtual void OnPoisonImmunity(Mobile from, Poison poison)
    {
        PublicOverheadMessage(MessageType.Emote, 0x3B2, 1005534); // * The poison seems to have no effect. *
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when a call to <see cref="ApplyPoison" /> failed because
    ///     <see cref="CheckHigherPoison" /> returned false: the Mobile was already poisoned by an equal or greater strength poison.
    ///     <seealso cref="CheckHigherPoison" />
    ///     <seealso cref="ApplyPoison" />
    ///     <seealso cref="Poison" />
    /// </summary>
    public virtual void OnHigherPoison(Mobile from, Poison poison)
    {
    }

    /// <summary>
    ///     Overridable. Event invoked when a call to <see cref="ApplyPoison" /> succeeded. By default, this broadcasts an overhead
    ///     message varying by the level of the poison. Example: * Zippy begins to spasm uncontrollably. *
    ///     <seealso cref="ApplyPoison" />
    ///     <seealso cref="Poison" />
    /// </summary>
    public virtual void OnPoisoned(Mobile from, Poison poison, Poison oldPoison)
    {
        if (poison != null)
        {
            LocalOverheadMessage(MessageType.Regular, 0x21, 1042857 + poison.Level * 2);
            NonlocalOverheadMessage(MessageType.Regular, 0x21, 1042858 + poison.Level * 2, Name);
        }
    }

    /// <summary>
    ///     Overridable. Called from <see cref="ApplyPoison" />, this method checks if the Mobile is immune to some
    ///     <see cref="Poison" />. If true, <see cref="OnPoisonImmunity" /> will be invoked and
    ///     <see cref="ApplyPoisonResult.Immune" /> is returned.
    ///     <seealso cref="OnPoisonImmunity" />
    ///     <seealso cref="ApplyPoison" />
    ///     <seealso cref="Poison" />
    /// </summary>
    public virtual bool CheckPoisonImmunity(Mobile from, Poison poison) => false;

    /// <summary>
    ///     Overridable. Called from <see cref="ApplyPoison" />, this method checks if the Mobile is already poisoned by some
    ///     <see cref="Poison" /> of equal or greater strength. If true, <see cref="OnHigherPoison" /> will be invoked and
    ///     <see cref="ApplyPoisonResult.HigherPoisonActive" /> is returned.
    ///     <seealso cref="OnHigherPoison" />
    ///     <seealso cref="ApplyPoison" />
    ///     <seealso cref="Poison" />
    /// </summary>
    public virtual bool CheckHigherPoison(Mobile from, Poison poison) =>
        m_Poison != null && m_Poison.Level >= poison.Level;

    /// <summary>
    ///     Overridable. Attempts to apply poison to the Mobile. Checks are made such that no
    ///     <see cref="CheckHigherPoison">higher poison is active</see> and that the Mobile is not
    ///     <see cref="CheckPoisonImmunity">immune to the poison</see>. Provided those assertions are true, the
    ///     <paramref name="poison" /> is applied and <see cref="OnPoisoned" /> is invoked.
    ///     <seealso cref="Poison" />
    ///     <seealso cref="CurePoison" />
    /// </summary>
    /// <returns>
    ///     One of four possible values:
    ///     <list type="table">
    ///         <item>
    ///             <term>
    ///                 <see cref="ApplyPoisonResult.Cured">Cured</see>
    ///             </term>
    ///             <description>The <paramref name="poison" /> parameter was null and so <see cref="CurePoison" /> was invoked.</description>
    ///         </item>
    ///         <item>
    ///             <term>
    ///                 <see cref="ApplyPoisonResult.HigherPoisonActive">HigherPoisonActive</see>
    ///             </term>
    ///             <description>The call to <see cref="CheckHigherPoison" /> returned false.</description>
    ///         </item>
    ///         <item>
    ///             <term>
    ///                 <see cref="ApplyPoisonResult.Immune">Immune</see>
    ///             </term>
    ///             <description>The call to <see cref="CheckPoisonImmunity" /> returned false.</description>
    ///         </item>
    ///         <item>
    ///             <term>
    ///                 <see cref="ApplyPoisonResult.Poisoned">Poisoned</see>
    ///             </term>
    ///             <description>The <paramref name="poison" /> was successfully applied.</description>
    ///         </item>
    ///     </list>
    /// </returns>
    public virtual ApplyPoisonResult ApplyPoison(Mobile from, Poison poison)
    {
        if (poison == null)
        {
            CurePoison(from);
            return ApplyPoisonResult.Cured;
        }

        if (CheckHigherPoison(from, poison))
        {
            OnHigherPoison(from, poison);
            return ApplyPoisonResult.HigherPoisonActive;
        }

        if (CheckPoisonImmunity(from, poison))
        {
            OnPoisonImmunity(from, poison);
            return ApplyPoisonResult.Immune;
        }

        var oldPoison = m_Poison;
        Poison = poison;

        OnPoisoned(from, poison, oldPoison);

        return ApplyPoisonResult.Poisoned;
    }

    /// <summary>
    ///     Overridable. Called from <see cref="CurePoison" />, this method checks to see that the Mobile can be cured of
    ///     <see cref="Poison" />
    ///     <seealso cref="CurePoison" />
    ///     <seealso cref="Poison" />
    /// </summary>
    public virtual bool CheckCure(Mobile from) => true;

    /// <summary>
    ///     Overridable. Virtual event invoked when a call to <see cref="CurePoison" /> succeeded.
    ///     <seealso cref="CurePoison" />
    ///     <seealso cref="CheckCure" />
    ///     <seealso cref="Poison" />
    /// </summary>
    public virtual void OnCured(Mobile from, Poison oldPoison)
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when a call to <see cref="CurePoison" /> failed.
    ///     <seealso cref="CurePoison" />
    ///     <seealso cref="CheckCure" />
    ///     <seealso cref="Poison" />
    /// </summary>
    public virtual void OnFailedCure(Mobile from)
    {
    }

    /// <summary>
    ///     Overridable. Attempts to cure any poison that is currently active.
    /// </summary>
    /// <returns>True if poison was cured, false if otherwise.</returns>
    public virtual bool CurePoison(Mobile from)
    {
        if (CheckCure(from))
        {
            var oldPoison = m_Poison;
            Poison = null;

            OnCured(from, oldPoison);

            return true;
        }

        OnFailedCure(from);

        return false;
    }

    public void MovingEffect(
        IEntity to, int itemID, int speed, int duration, bool fixedDirection, bool explodes,
        int hue, int renderMode
    ) =>
        Effects.SendMovingEffect(this, to, itemID, speed, duration, fixedDirection, explodes, hue, renderMode);

    public void MovingEffect(IEntity to, int itemID, int speed, int duration, bool fixedDirection, bool explodes) =>
        Effects.SendMovingEffect(this, to, itemID, speed, duration, fixedDirection, explodes);

    public void MovingParticles(
        IEntity to, int itemID, int speed, int duration, bool fixedDirection, bool explodes,
        int hue, int renderMode, int effect, int explodeEffect, int explodeSound, EffectLayer layer, int unknown
    ) =>
        Effects.SendMovingParticles(
            this,
            to,
            itemID,
            speed,
            duration,
            fixedDirection,
            explodes,
            hue,
            renderMode,
            effect,
            explodeEffect,
            explodeSound,
            layer,
            unknown
        );

    public void MovingParticles(
        IEntity to, int itemID, int speed, int duration, bool fixedDirection, bool explodes,
        int hue, int renderMode, int effect, int explodeEffect, int explodeSound, int unknown
    ) =>
        Effects.SendMovingParticles(
            this,
            to,
            itemID,
            speed,
            duration,
            fixedDirection,
            explodes,
            hue,
            renderMode,
            effect,
            explodeEffect,
            explodeSound,
            (EffectLayer)255,
            unknown
        );

    public void MovingParticles(
        IEntity to, int itemID, int speed, int duration, bool fixedDirection, bool explodes,
        int effect, int explodeEffect, int explodeSound, int unknown
    ) =>
        Effects.SendMovingParticles(
            this,
            to,
            itemID,
            speed,
            duration,
            fixedDirection,
            explodes,
            effect,
            explodeEffect,
            explodeSound,
            unknown
        );

    public void MovingParticles(
        IEntity to, int itemID, int speed, int duration, bool fixedDirection, bool explodes,
        int effect, int explodeEffect, int explodeSound
    ) =>
        Effects.SendMovingParticles(
            this,
            to,
            itemID,
            speed,
            duration,
            fixedDirection,
            explodes,
            0,
            0,
            effect,
            explodeEffect,
            explodeSound,
            0
        );

    public void FixedEffect(int itemID, int speed, int duration, int hue, int renderMode) =>
        Effects.SendTargetEffect(this, itemID, speed, duration, hue, renderMode);

    public void FixedEffect(int itemID, int speed, int duration) =>
        Effects.SendTargetEffect(this, itemID, speed, duration);

    public void FixedParticles(
        int itemID, int speed, int duration, int effect, int hue, int renderMode, EffectLayer layer, int unknown
    ) =>
        Effects.SendTargetParticles(this, itemID, speed, duration, hue, renderMode, effect, layer, unknown);

    public void FixedParticles(
        int itemID, int speed, int duration, int effect, int hue, int renderMode, EffectLayer layer
    ) =>
        Effects.SendTargetParticles(this, itemID, speed, duration, hue, renderMode, effect, layer);

    public void FixedParticles(int itemID, int speed, int duration, int effect, EffectLayer layer, int unknown) =>
        Effects.SendTargetParticles(this, itemID, speed, duration, 0, 0, effect, layer, unknown);

    public void FixedParticles(int itemID, int speed, int duration, int effect, EffectLayer layer) =>
        Effects.SendTargetParticles(this, itemID, speed, duration, 0, 0, effect, layer);

    public void BoltEffect(int hue) => Effects.SendBoltEffect(this, true, hue);

    public Direction GetDirectionTo(int x, int y, bool run = false)
    {
        var dx = m_Location.m_X - x;
        var dy = m_Location.m_Y - y;

        var rx = (dx - dy) * 44;
        var ry = (dx + dy) * 44;

        var ax = rx.Abs();
        var ay = ry.Abs();

        Direction ret;

        if ((ay >> 1) - ax >= 0)
        {
            ret = ry > 0 ? Direction.Up : Direction.Down;
        }
        else if ((ax >> 1) - ay >= 0)
        {
            ret = rx > 0 ? Direction.Left : Direction.Right;
        }
        else
        {
            ret = rx switch
            {
                >= 0 when ry >= 0 => Direction.West,
                >= 0              => Direction.South,
                < 0 when ry < 0   => Direction.East,
                _                 => Direction.North
            };
        }

        if (run)
        {
            ret |= Direction.Running;
        }

        return ret;
    }

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Direction GetDirectionTo(Point2D p, bool run = false) => GetDirectionTo(p.m_X, p.m_Y, run);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Direction GetDirectionTo(Point3D p, bool run = false) => GetDirectionTo(p.m_X, p.m_Y, run);

    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    public Direction GetDirectionTo(IPoint2D p, bool run = false) =>
        p == null ? Direction.North | (run ? Direction.Running : 0) : GetDirectionTo(p.X, p.Y, run);

    public void PublicOverheadMessage(
        MessageType type, int hue, bool ascii, string text, bool noLineOfSight = true,
        AccessLevel accessLevel = AccessLevel.Player
    )
    {
        if (m_Map == null)
        {
            return;
        }

        Span<byte> buffer = stackalloc byte[OutgoingMessagePackets.GetMaxMessageLength(text)].InitializePacket();

        foreach (var state in m_Map.GetClientsInRange(m_Location))
        {
            if (
                state.Mobile.AccessLevel >= accessLevel &&
                state.Mobile.CanSee(this) &&
                (noLineOfSight || state.Mobile.InLOS(this))
            )
            {
                var length = OutgoingMessagePackets.CreateMessage(
                    buffer,
                    Serial,
                    Body,
                    type,
                    hue,
                    3,
                    ascii,
                    Language,
                    Name,
                    text
                );

                if (length != buffer.Length)
                {
                    buffer = buffer[..length]; // Adjust to the actual size
                }

                state.Send(buffer);
            }
        }
    }

    public void PublicOverheadMessage(MessageType type, int hue, int number, string args = "", bool noLineOfSight = true)
    {
        if (m_Map == null)
        {
            return;
        }

        Span<byte> buffer = stackalloc byte[OutgoingMessagePackets.GetMaxMessageLocalizedLength(args)].InitializePacket();

        foreach (var state in m_Map.GetClientsInRange(m_Location))
        {
            if (state.Mobile.CanSee(this) && (noLineOfSight || state.Mobile.InLOS(this)))
            {
                var length = OutgoingMessagePackets.CreateMessageLocalized(
                    buffer,
                    Serial,
                    Body,
                    type,
                    hue,
                    3,
                    number,
                    Name,
                    args
                );

                if (length != buffer.Length)
                {
                    buffer = buffer[..length]; // Adjust to the actual size
                }

                state.Send(buffer);
            }
        }
    }

    public void PublicOverheadMessage(
        MessageType type, int hue, int number, AffixType affixType, string affix,
        string args = "", bool noLineOfSight = false,
        AccessLevel accessLevel = AccessLevel.Player
    )
    {
        if (m_Map == null)
        {
            return;
        }

        Span<byte> buffer = stackalloc byte[OutgoingMessagePackets.GetMaxMessageLocalizedAffixLength(affix, args)]
            .InitializePacket();

        foreach (var state in m_Map.GetClientsInRange(m_Location))
        {
            if (
                state.Mobile.AccessLevel >= accessLevel &&
                state.Mobile.CanSee(this) &&
                (noLineOfSight || state.Mobile.InLOS(this))
            )
            {
                var length = OutgoingMessagePackets.CreateMessageLocalizedAffix(
                    buffer,
                    Serial,
                    Body,
                    type,
                    hue,
                    3,
                    number,
                    Name,
                    affixType,
                    affix,
                    args
                );

                if (length != buffer.Length)
                {
                    buffer = buffer[..length]; // Adjust to the actual size
                }

                state.Send(buffer);
            }
        }
    }

    public void PrivateOverheadMessage(MessageType type, int hue, bool ascii, string text, NetState state)
    {
        state.SendMessage(Serial, Body, type, hue, 3, ascii, m_Language, Name, text);
    }

    public void PrivateOverheadMessage(MessageType type, int hue, int number, NetState state) =>
        PrivateOverheadMessage(type, hue, number, "", state);

    public void PrivateOverheadMessage(MessageType type, int hue, int number, string args, NetState state) =>
        state.SendMessageLocalized(Serial, Body, type, hue, 3, number, Name, args);

    public void LocalOverheadMessage(MessageType type, int hue, bool ascii, string text) =>
        m_NetState.SendMessage(Serial, Body, type, hue, 3, ascii, m_Language, Name, text);

    public void LocalOverheadMessage(MessageType type, int hue, int number, string args = "") =>
        m_NetState.SendMessageLocalized(Serial, Body, type, hue, 3, number, Name, args);

    public void NonlocalOverheadMessage(MessageType type, int hue, int number, string args = "")
    {
        if (m_Map == null)
        {
            return;
        }

        Span<byte> buffer = stackalloc byte[OutgoingMessagePackets.GetMaxMessageLocalizedLength(args)].InitializePacket();

        foreach (var state in m_Map.GetClientsInRange(m_Location))
        {
            if (state != m_NetState && state.Mobile.CanSee(this))
            {
                var length = OutgoingMessagePackets.CreateMessageLocalized(
                    buffer,
                    Serial,
                    Body,
                    type,
                    hue,
                    3,
                    number,
                    Name,
                    args
                );

                if (length != buffer.Length)
                {
                    buffer = buffer[..length]; // Adjust to the actual size
                }

                state.Send(buffer);
            }
        }
    }

    public void NonlocalOverheadMessage(MessageType type, int hue, bool ascii, string text)
    {
        if (m_Map == null)
        {
            return;
        }

        Span<byte> buffer = stackalloc byte[OutgoingMessagePackets.GetMaxMessageLength(text)].InitializePacket();

        foreach (var state in m_Map.GetClientsInRange(m_Location))
        {
            if (state != m_NetState && state.Mobile.CanSee(this))
            {
                var length = OutgoingMessagePackets.CreateMessage(
                    buffer,
                    Serial,
                    Body,
                    type,
                    hue,
                    3,
                    ascii,
                    Language,
                    Name,
                    text
                );

                if (length != buffer.Length)
                {
                    buffer = buffer[..length]; // Adjust to the actual size
                }

                state.Send(buffer);
            }
        }
    }

    public void SendLocalizedMessage(int number, string args = "", int hue = 0x3B2) =>
        m_NetState.SendMessageLocalized(Serial.MinusOne, -1, MessageType.Regular, hue, 3, number, "System", args);

    public void SendLocalizedMessage(int number, bool append, string affix, string args = "", int hue = 0x3B2) =>
        m_NetState.SendMessageLocalizedAffix(
            Serial.MinusOne,
            -1,
            MessageType.Regular,
            hue,
            3,
            number,
            "System",
            (append ? AffixType.Append : AffixType.Prepend) | AffixType.System,
            affix,
            args
        );

    public void SendMessage(string text) => SendMessage(0x3B2, text);

    public void SendMessage(int hue, string text) =>
        m_NetState.SendMessage(Serial.MinusOne, -1, MessageType.Regular, hue, 3, false, "ENU", "System", text);

    public void SendAsciiMessage(string text) => SendAsciiMessage(0x3B2, text);

    public void SendAsciiMessage(int hue, string text) =>
        m_NetState.SendMessage(Serial.MinusOne, -1, MessageType.Regular, hue, 3, true, null, "System", text);

    /// <summary>
    ///     Overridable. Event invoked when the Mobile is double clicked. By default, this method can either dismount or open the
    ///     paperdoll.
    ///     <seealso cref="CanPaperdollBeOpenedBy" />
    ///     <seealso cref="DisplayPaperdollTo" />
    /// </summary>
    public virtual void OnDoubleClick(Mobile from)
    {
        if (this == from && (!DisableDismountInWarmode || !m_Warmode))
        {
            var mount = Mount;

            if (mount != null)
            {
                mount.Rider = null;
                return;
            }
        }

        if (CanPaperdollBeOpenedBy(from))
        {
            DisplayPaperdollTo(from);
        }
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile is double clicked by someone who is over 18 tiles away.
    ///     <seealso cref="OnDoubleClick" />
    /// </summary>
    public virtual void OnDoubleClickOutOfRange(Mobile from)
    {
    }

    /// <summary>
    ///     Overridable. Virtual event invoked when the Mobile is double clicked by someone who can no longer see the Mobile. This
    ///     may
    ///     happen, for example, using 'Last Object' after the Mobile has hidden.
    ///     <seealso cref="OnDoubleClick" />
    /// </summary>
    public virtual void OnDoubleClickCantSee(Mobile from)
    {
    }

    /// <summary>
    ///     Overridable. Event invoked when the Mobile is double clicked by someone who is not alive. Similar to
    ///     <see cref="OnDoubleClick" />, this method will show the paperdoll. It does not, however, provide any dismount
    ///     functionality.
    ///     <seealso cref="OnDoubleClick" />
    /// </summary>
    public virtual void OnDoubleClickDead(Mobile from)
    {
        if (CanPaperdollBeOpenedBy(from))
        {
            DisplayPaperdollTo(from);
        }
    }

    private class ManaTimer : Timer
    {
        private readonly Mobile m_Owner;

        public ManaTimer(Mobile m) : base(GetManaRegenRate(m), GetManaRegenRate(m)) => m_Owner = m;

        protected override void OnTick()
        {
            if (m_Owner.CanRegenMana)
            {
                m_Owner.Mana++;
            }

            Delay = Interval = GetManaRegenRate(m_Owner);
        }
    }

    private class HitsTimer : Timer
    {
        private readonly Mobile m_Owner;

        public HitsTimer(Mobile m) : base(GetHitsRegenRate(m), GetHitsRegenRate(m)) => m_Owner = m;

        protected override void OnTick()
        {
            if (m_Owner.CanRegenHits)
            {
                m_Owner.Hits++;
            }

            Delay = Interval = GetHitsRegenRate(m_Owner);
        }
    }

    private class StamTimer : Timer
    {
        private readonly Mobile m_Owner;

        public StamTimer(Mobile m) : base(GetStamRegenRate(m), GetStamRegenRate(m)) => m_Owner = m;

        protected override void OnTick()
        {
            if (m_Owner.CanRegenStam)
            {
                m_Owner.Stam++;
            }

            Delay = Interval = GetStamRegenRate(m_Owner);
        }
    }

    private void Logout()
    {
        if (m_Map != Map.Internal)
        {
            EventSink.InvokeLogout(this);

            LogoutLocation = m_Location;
            LogoutMap = m_Map;

            Internalize();
        }
    }

    private void ExpireCriminal()
    {
        Criminal = false;
    }
}