Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Server/Targeting/Target.cs

@@ -0,0 +1,332 @@
+#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;
+				}
+
+				loc = item.GetWorldLocation();
+				map = item.Map;
+			}
+			else
+			{
+				OnTargetCancel(from, TargetCancelType.Canceled);
+				OnTargetFinish(from);
+				return;
+			}
+
+			if (map == null || map != from.Map || (m_Range != -1 && !from.InRange(loc, m_Range)))
+			{
+				OnTargetOutOfRange(from, targeted);
+			}
+			else
+			{
+                if (!from.CanSee(targeted))
+				{
+					OnCantSeeTarget(from, targeted);
+				}
+				else if (m_CheckLOS && !from.InLOS(targeted))
+				{
+					OnTargetOutOfLOS(from, targeted);
+				}
+				else if (targeted is Item && ((Item)targeted).InSecureTrade)
+				{
+					OnTargetInSecureTrade(from, targeted);
+				}
+				else if (targeted is Item && !((Item)targeted).IsAccessibleTo(from))
+				{
+					OnTargetNotAccessible(from, targeted);
+				}
+				else if (targeted is Item && !((Item)targeted).CheckTarget(from, this, targeted))
+				{
+					OnTargetUntargetable(from, targeted);
+				}
+				else if (targeted is Mobile && !((Mobile)targeted).CheckTarget(from, this, targeted))
+				{
+					OnTargetUntargetable(from, targeted);
+				}
+				else if (from.Region.OnTarget(from, this, targeted))
+				{
+					OnTarget(from, targeted);
+				}
+			}
+
+			OnTargetFinish(from);
+		}
+
+		protected virtual void OnTarget(Mobile from, object targeted)
+		{ }
+
+		protected virtual void OnTargetNotAccessible(Mobile from, object targeted)
+		{
+			from.SendLocalizedMessage(500447); // That is not accessible.
+		}
+
+		protected virtual void OnTargetInSecureTrade(Mobile from, object targeted)
+		{
+			from.SendLocalizedMessage(500447); // That is not accessible.
+		}
+
+		protected virtual void OnNonlocalTarget(Mobile from, object targeted)
+		{
+			from.SendLocalizedMessage(500447); // That is not accessible.
+		}
+
+		protected virtual void OnCantSeeTarget(Mobile from, object targeted)
+		{
+			from.SendLocalizedMessage(500237); // Target can not be seen.
+		}
+
+		protected virtual void OnTargetOutOfLOS(Mobile from, object targeted)
+		{
+			from.SendLocalizedMessage(500237); // Target can not be seen.
+		}
+
+		protected virtual void OnTargetOutOfRange(Mobile from, object targeted)
+		{
+			from.SendLocalizedMessage(500446); // That is too far away.
+		}
+
+		protected virtual void OnTargetDeleted(Mobile from, object targeted)
+		{ }
+
+		protected virtual void OnTargetUntargetable(Mobile from, object targeted)
+		{
+			from.SendLocalizedMessage(500447); // That is not accessible.
+		}
+
+		protected virtual void OnTargetCancel(Mobile from, TargetCancelType cancelType)
+		{ }
+
+		protected virtual void OnTargetFinish(Mobile from)
+		{ }
+
+		public int Range { get { return m_Range; } set { m_Range = value; } }
+
+		public bool AllowGround { get; set; }
+
+		public TargetFlags Flags { get; set; }
+	}
+}