context: #region References
  using System;
  
  using Server.Network;
  #endregion
  
  namespace Server.Targeting
  {
  	public abstract class Target
  	{
  		private static int m_NextTargetID;
  
  		private static bool m_TargetIDValidation = true;
  
  		public static bool TargetIDValidation { get { return m_TargetIDValidation; } set { m_TargetIDValidation = value; } }
  
  		private readonly int m_TargetID;
  		private int m_Range;
  		private bool m_CheckLOS;
  		private bool m_AllowNonlocal;
  		private DateTime m_TimeoutTime;
  
  		public DateTime TimeoutTime { get { return m_TimeoutTime; } }
  
  		protected Target(int range, bool allowGround, TargetFlags flags)
  		{
  			m_TargetID = ++m_NextTargetID;
  			m_Range = range;
  			AllowGround = allowGround;
  			Flags = flags;
  
  			m_CheckLOS = true;
  		}
  
  		public static void Cancel(Mobile m)
  		{
  			NetState ns = m.NetState;
  
  			if (ns != null)
  			{
  				ns.Send(CancelTarget.Instance);
  			}
  
  			Target targ = m.Target;
  
  			if (targ != null)
  			{
  				targ.OnTargetCancel(m, TargetCancelType.Canceled);
  			}
  		}
  
  		private Timer m_TimeoutTimer;
  
  		public void BeginTimeout(Mobile from, TimeSpan delay)
  		{
  			m_TimeoutTime = DateTime.UtcNow + delay;
  
  			if (m_TimeoutTimer != null)
  			{
  				m_TimeoutTimer.Stop();
  			}
  
  			m_TimeoutTimer = new TimeoutTimer(this, from, delay);
  			m_TimeoutTimer.Start();
  		}
  
  		public void CancelTimeout()
  		{
  			if (m_TimeoutTimer != null)
  			{
  				m_TimeoutTimer.Stop();
  			}
  
  			m_TimeoutTimer = null;
  		}
  
  		public void Timeout(Mobile from)
  		{
  			CancelTimeout();
  			from.ClearTarget();
  
  			Cancel(from);
  
  			OnTargetCancel(from, TargetCancelType.Timeout);
  			OnTargetFinish(from);
  		}
  
  		private class TimeoutTimer : Timer
  		{
  			private readonly Target m_Target;
  			private readonly Mobile m_Mobile;
  
  			private static readonly TimeSpan ThirtySeconds = TimeSpan.FromSeconds(30.0);
  			private static readonly TimeSpan TenSeconds = TimeSpan.FromSeconds(10.0);
  			private static readonly TimeSpan OneSecond = TimeSpan.FromSeconds(1.0);
  
  			public TimeoutTimer(Target target, Mobile m, TimeSpan delay)
  				: base(delay)
  			{
  				m_Target = target;
  				m_Mobile = m;
  
  				if (delay >= ThirtySeconds)
  				{
  					Priority = TimerPriority.FiveSeconds;
  				}
  				else if (delay >= TenSeconds)
  				{
  					Priority = TimerPriority.OneSecond;
  				}
  				else if (delay >= OneSecond)
  				{
  					Priority = TimerPriority.TwoFiftyMS;
  				}
  				else
  				{
  					Priority = TimerPriority.TwentyFiveMS;
  				}
  			}
  
  			protected override void OnTick()
  			{
  				if (m_Mobile.Target == m_Target)
  				{
  					m_Target.Timeout(m_Mobile);
  				}
  			}
  		}
  
  		public bool CheckLOS { get { return m_CheckLOS; } set { m_CheckLOS = value; } }
  
  		public bool DisallowMultis { get; set; }
  
  		public bool AllowNonlocal { get { return m_AllowNonlocal; } set { m_AllowNonlocal = value; } }
  
  		public int TargetID { get { return m_TargetID; } }
  
  		public virtual Packet GetPacketFor(NetState ns)
  		{
  			return new TargetReq(this);
  		}
  
  		public void Cancel(Mobile from, TargetCancelType type)
  		{
  			CancelTimeout();
  			from.ClearTarget();
  
  			OnTargetCancel(from, type);
  			OnTargetFinish(from);
  		}
  
  		public void Invoke(Mobile from, object targeted)
  		{
              bool enhancedClient = from.NetState != null && from.NetState.IsEnhancedClient;
  
  			CancelTimeout();
  			from.ClearTarget();
  
              if (from.Deleted)
  			{
  				OnTargetCancel(from, TargetCancelType.Canceled);
  				OnTargetFinish(from);
  				return;
  			}
  
  			Point3D loc;
  			Map map;
  
  			if (targeted is LandTarget)
  			{
  				loc = ((LandTarget)targeted).Location;
  				map = from.Map;
  
                  if (enhancedClient && (loc.X == 0 && loc.Y == 0) && !from.InRange(loc, 10))
                  {
                      OnTargetCancel(from, TargetCancelType.Canceled);
                      OnTargetFinish(from);
                      return;
                  }
  			}
  			else if (targeted is StaticTarget)
  			{
  				loc = ((StaticTarget)targeted).Location;
  				map = from.Map;
  			}
  			else if (targeted is Mobile)
  			{
  				if (((Mobile)targeted).Deleted)
  				{
  					OnTargetDeleted(from, targeted);
  					OnTargetFinish(from);
  					return;
  				}
  				else if (!((Mobile)targeted).CanTarget)
  				{
  					OnTargetUntargetable(from, targeted);
  					OnTargetFinish(from);
  					return;
  				}
  
  				loc = ((Mobile)targeted).Location;
  				map = ((Mobile)targeted).Map;
  			}
  			else if (targeted is Item)
  			{
  				Item item = (Item)targeted;
  
  				if (item.Deleted)
  				{
  					OnTargetDeleted(from, targeted);
  					OnTargetFinish(from);
  					return;
  				}
  				else if (!item.CanTarget)
  				{
  					OnTargetUntargetable(from, targeted);
  					OnTargetFinish(from);
  					return;
  				}
  
  				object root = item.RootParent;
  
  				if (!m_AllowNonlocal && root is Mobile && root != from && from.AccessLevel == AccessLevel.Player)
  				{
  					OnNonlocalTarget(from, targeted);
  					OnTargetFinish(from);
  					return;
  				}
  
  
gt: 				loc = item.GetWorldLocation();