context: #region References
  using System;
  using System.Collections.Generic;
  using System.IO;
  
  using Server.Accounting;
  using Server.ContextMenus;
  using Server.Diagnostics;
  using Server.Gumps;
  using Server.HuePickers;
  using Server.Items;
  using Server.Menus;
  using Server.Mobiles;
  using Server.Prompts;
  using Server.Targeting;
  
  using CV = Server.ClientVersion;
  #endregion
  
  namespace Server.Network
  {
  	public enum MessageType
  	{
  		Regular = 0x00,
  		System = 0x01,
  		Emote = 0x02,
  		Label = 0x06,
  		Focus = 0x07,
  		Whisper = 0x08,
  		Yell = 0x09,
  		Spell = 0x0A,
  
  		Guild = 0x0D,
  		Alliance = 0x0E,
  		Command = 0x0F,
  
  		Encoded = 0xC0
  	}
  
  	public static class PacketHandlers
  	{
  		private static readonly PacketHandler[] m_Handlers;
  		private static readonly PacketHandler[] m_6017Handlers;
  
  		private static readonly PacketHandler[] m_ExtendedHandlersLow;
  		private static readonly Dictionary<int, PacketHandler> m_ExtendedHandlersHigh;
  
  		private static readonly EncodedPacketHandler[] m_EncodedHandlersLow;
  		private static readonly Dictionary<int, EncodedPacketHandler> m_EncodedHandlersHigh;
  
  		public static PacketHandler[] Handlers { get { return m_Handlers; } }
  
  		static PacketHandlers()
  		{
  			m_Handlers = new PacketHandler[0x100];
  			m_6017Handlers = new PacketHandler[0x100];
  
  			m_ExtendedHandlersLow = new PacketHandler[0x100];
  			m_ExtendedHandlersHigh = new Dictionary<int, PacketHandler>();
  
  			m_EncodedHandlersLow = new EncodedPacketHandler[0x100];
  			m_EncodedHandlersHigh = new Dictionary<int, EncodedPacketHandler>();
  
  			Register(0x00, 104, false, CreateCharacter);
  			Register(0x01, 5, false, Disconnect);
  			Register(0x02, 7, true, MovementReq);
  			Register(0x03, 0, true, AsciiSpeech);
  			Register(0x04, 2, true, GodModeRequest);
  			Register(0x05, 5, true, AttackReq);
  			Register(0x06, 5, true, UseReq);
  			Register(0x07, 7, true, LiftReq);
  			Register(0x08, 14, true, DropReq);
  			Register(0x09, 5, true, LookReq);
  			Register(0x0A, 11, true, Edit);
  			Register(0x12, 0, true, TextCommand);
  			Register(0x13, 10, true, EquipReq);
  			Register(0x14, 6, true, ChangeZ);
  			Register(0x22, 3, true, Resynchronize);
  			Register(0x2C, 2, true, DeathStatusResponse);
  			Register(0x34, 10, true, MobileQuery);
  			Register(0x3A, 0, true, ChangeSkillLock);
  			Register(0x3B, 0, true, VendorBuyReply);
  			Register(0x47, 11, true, NewTerrain);
  			Register(0x48, 73, true, NewAnimData);
  			Register(0x58, 106, true, NewRegion);
  			Register(0x5D, 73, false, PlayCharacter);
  			Register(0x61, 9, true, DeleteStatic);
  			Register(0x6C, 19, true, TargetResponse);
  			Register(0x6F, 0, true, SecureTrade);
  			Register(0x72, 5, true, SetWarMode);
  			Register(0x73, 2, false, PingReq);
  			Register(0x75, 35, true, RenameRequest);
  			Register(0x79, 9, true, ResourceQuery);
  			Register(0x7E, 2, true, GodviewQuery);
  			Register(0x7D, 13, true, MenuResponse);
  			Register(0x80, 62, false, AccountLogin);
  			Register(0x83, 39, false, DeleteCharacter);
  			Register(0x91, 65, false, GameLogin);
  			Register(0x95, 9, true, HuePickerResponse);
  			Register(0x96, 0, true, GameCentralMoniter);
  			Register(0x98, 0, true, MobileNameRequest);
  			Register(0x9A, 0, true, AsciiPromptResponse);
  			Register(0x9B, 258, true, HelpRequest);
  			Register(0x9D, 51, true, GMSingle);
  			Register(0x9F, 0, true, VendorSellReply);
  			Register(0xA0, 3, false, PlayServer);
  			Register(0xA4, 149, false, SystemInfo);
  			Register(0xA7, 4, true, RequestScrollWindow);
  			Register(0xAD, 0, true, UnicodeSpeech);
  			Register(0xB1, 0, true, DisplayGumpResponse);
  			Register(0xB6, 9, true, ObjectHelpRequest);
  			Register(0xB8, 0, true, ProfileReq);
  			Register(0xBB, 9, false, AccountID);
  			Register(0xBD, 0, true, ClientVersion);
  			Register(0xBE, 0, true, AssistVersion);
  			Register(0xBF, 0, true, ExtendedCommand);
  			Register(0xC2, 0, true, UnicodePromptResponse);
  			Register(0xC8, 2, true, SetUpdateRange);
  			Register(0xC9, 6, true, TripTime);
  			Register(0xCA, 6, true, UTripTime);
  			Register(0xCF, 0, false, AccountLogin);
  			Register(0xD0, 0, true, ConfigurationFile);
  			Register(0xD1, 2, true, LogoutReq);
  			Register(0xD6, 0, true, BatchQueryProperties);
  			Register(0xD7, 0, true, EncodedCommand);
  			Register(0xE1, 0, false, ClientType);
              Register(0xEC, 0, false, EquipMacro);
              Register(0xED, 0, false, UnequipMacro);
  			Register(0xEF, 21, false, LoginServerSeed);
  			Register(0xF4, 0, false, CrashReport);
  			Register(0xF8, 106, false, CreateCharacter70160);
  
  			Register6017(0x08, 15, true, DropReq6017);
              Register(0x8D, 0, false, ECCreateCharacter);
  
              RegisterExtended(0x05, false, ScreenSize);
  			RegisterExtended(0x06, true, PartyMessage);
  			RegisterExtended(0x07, true, QuestArrow);
  			RegisterExtended(0x09, true, DisarmRequest);
  			RegisterExtended(0x0A, true, StunRequest);
  			RegisterExtended(0x0B, false, Language);
  			RegisterExtended(0x0C, true, CloseStatus);
  			RegisterExtended(0x0E, true, Animate);
  			RegisterExtended(0x0F, false, Empty); // What's this?
  			RegisterExtended(0x10, true, QueryProperties);
  			RegisterExtended(0x13, true, ContextMenuRequest);
  			RegisterExtended(0x15, true, ContextMenuResponse);
  			RegisterExtended(0x1A, true, StatLockChange);
  			RegisterExtended(0x1C, true, CastSpell);
  			RegisterExtended(0x24, false, UnhandledBF);
  			RegisterExtended(0x2C, true, BandageTarget);
  
  			#region Stygian Abyss
  			RegisterExtended(0x32, true, ToggleFlying);
              #endregion
  
              RegisterExtended(0x2D, true, TargetedSpell);
              RegisterExtended(0x2E, true, TargetedSkillUse);
              RegisterExtended(0x30, true, TargetByResourceMacro);
  
              RegisterEncoded(0x19, true, SetAbility);
  			RegisterEncoded(0x28, true, GuildGumpRequest);
  
  			RegisterEncoded(0x32, true, QuestGumpRequest);
  		}
  
  		public static void Register(int packetID, int length, bool ingame, OnPacketReceive onReceive)
  		{
  			m_Handlers[packetID] = new PacketHandler(packetID, length, ingame, onReceive);
  
  			if (m_6017Handlers[packetID] == null)
  			{
  				m_6017Handlers[packetID] = new PacketHandler(packetID, length, ingame, onReceive);
  			}
  		}
  
  		public static PacketHandler GetHandler(int packetID)
  		{
  			return m_Handlers[packetID];
  		}
  
  		public static void Register6017(int packetID, int length, bool ingame, OnPacketReceive onReceive)
  		{
  			m_6017Handlers[packetID] = new PacketHandler(packetID, length, ingame, onReceive);
  		}
  
  		public static PacketHandler Get6017Handler(int packetID)
  		{
  			return m_6017Handlers[packetID];
  		}
  
  		public static void RegisterExtended(int packetID, bool ingame, OnPacketReceive onReceive)
  		{
  			if (packetID >= 0 && packetID < 0x100)
  			{
  				m_ExtendedHandlersLow[packetID] = new PacketHandler(packetID, 0, ingame, onReceive);
  			}
  			else
  			{
  				m_ExtendedHandlersHigh[packetID] = new PacketHandler(packetID, 0, ingame, onReceive);
  			}
  		}
  
  		public static PacketHandler GetExtendedHandler(int packetID)
  		{
  			if (packetID >= 0 && packetID < 0x100)
  			{
  				return m_ExtendedHandlersLow[packetID];
  			}
  			else
  			{
  				PacketHandler handler;
  				m_ExtendedHandlersHigh.TryGetValue(packetID, out handler);
  				return handler;
  			}
  		}
  
  		public static void RemoveExtendedHandler(int packetID)
  		{
  			if (packetID >= 0 && packetID < 0x100)
  			{
  				m_ExtendedHandlersLow[packetID] = null;
  			}
  			else
  			{
  				m_ExtendedHandlersHigh.Remove(packetID);
  			}
  		}
  
  		public static void RegisterEncoded(int packetID, bool ingame, OnEncodedPacketReceive onReceive)
  		{
  			if (packetID >= 0 && packetID < 0x100)
  			{
  				m_EncodedHandlersLow[packetID] = new EncodedPacketHandler(packetID, ingame, onReceive);
  			}
  			else
  			{
  				m_EncodedHandlersHigh[packetID] = new EncodedPacketHandler(packetID, ingame, onReceive);
  			}
  		}
  
  		public static EncodedPacketHandler GetEncodedHandler(int packetID)
  		{
  			if (packetID >= 0 && packetID < 0x100)
  			{
  				return m_EncodedHandlersLow[packetID];
  			}
  			else
  			{
  				EncodedPacketHandler handler;
  				m_EncodedHandlersHigh.TryGetValue(packetID, out handler);
  				return handler;
  			}
  		}
  
  		public static void RemoveEncodedHandler(int packetID)
  		{
  			if (packetID >= 0 && packetID < 0x100)
  			{
  				m_EncodedHandlersLow[packetID] = null;
  			}
  			else
  			{
  				m_EncodedHandlersHigh.Remove(packetID);
  			}
  		}
  
  		public static void RegisterThrottler(int packetID, ThrottlePacketCallback t)
  		{
  			PacketHandler ph = GetHandler(packetID);
  
  			if (ph != null)
  			{
  				ph.ThrottleCallback = t;
  			}
  
  			ph = Get6017Handler(packetID);
  
  			if (ph != null)
  			{
  				ph.ThrottleCallback = t;
  			}
  		}
  
  		private static void UnhandledBF(NetState state, PacketReader pvSrc)
  		{ }
  
  		public static void Empty(NetState state, PacketReader pvSrc)
  		{ }
  
  		public static void SetAbility(NetState state, IEntity e, EncodedReader reader)
  		{
  			EventSink.InvokeSetAbility(new SetAbilityEventArgs(state.Mobile, reader.ReadInt32()));
  		}
  
  		public static void GuildGumpRequest(NetState state, IEntity e, EncodedReader reader)
  		{
  			EventSink.InvokeGuildGumpRequest(new GuildGumpRequestArgs(state.Mobile));
  		}
  
  		public static void QuestGumpRequest(NetState state, IEntity e, EncodedReader reader)
  		{
  			EventSink.InvokeQuestGumpRequest(new QuestGumpRequestArgs(state.Mobile));
  		}
  
  		public static void EncodedCommand(NetState state, PacketReader pvSrc)
  		{
  			IEntity e = World.FindEntity(pvSrc.ReadInt32());
  			int packetID = pvSrc.ReadUInt16();
  
  			EncodedPacketHandler ph = GetEncodedHandler(packetID);
  
  			if (ph != null)
  			{
  				if (ph.Ingame && state.Mobile == null)
  				{
  					Console.WriteLine(
  						"Client: {0}: Sent ingame packet (0xD7x{1:X2}) before having been attached to a mobile", state, packetID);
  					state.Dispose();
  				}
  				else if (ph.Ingame && state.Mobile.Deleted)
  				{
  					state.Dispose();
  				}
  				else
  				{
  					ph.OnReceive(state, e, new EncodedReader(pvSrc));
  				}
  			}
  			else
  			{
  				pvSrc.Trace(state);
  			}
  		}
  
  		public static void RenameRequest(NetState state, PacketReader pvSrc)
  		{
  			Mobile from = state.Mobile;
  			Mobile targ = World.FindMobile(pvSrc.ReadInt32());
  
  			if (targ != null)
  			{
  				EventSink.InvokeRenameRequest(new RenameRequestEventArgs(from, targ, pvSrc.ReadStringSafe()));
  			}
  		}
  
  		public static void SecureTrade(NetState state, PacketReader pvSrc)
  		{
  			switch (pvSrc.ReadByte())
  			{
  				case 1: // Cancel
  				{
  					Serial serial = pvSrc.ReadInt32();
  
  					SecureTradeContainer cont = World.FindItem(serial) as SecureTradeContainer;
  
  					if (cont != null)
  					{
  						SecureTrade trade = cont.Trade;
  
  						if (trade != null)
  						{
  							if (trade.From.Mobile == state.Mobile || trade.To.Mobile == state.Mobile)
  							{
  								trade.Cancel();
  							}
  						}
  					}
  				}
  					break;
  				case 2: // Check
  				{
  					Serial serial = pvSrc.ReadInt32();
  
  					SecureTradeContainer cont = World.FindItem(serial) as SecureTradeContainer;
  
  					if (cont != null)
  					{
  						SecureTrade trade = cont.Trade;
  
  						bool value = pvSrc.ReadInt32() != 0;
  
  						if (trade != null)
  						{
  							if (trade.From.Mobile == state.Mobile)
  							{
  								trade.From.Accepted = value;
  								trade.Update();
  							}
  							else if (trade.To.Mobile == state.Mobile)
  							{
  								trade.To.Accepted = value;
  								trade.Update();
  							}
  						}
  					}
  				}
  					break;
  				case 3: // Update Gold
  				{
  					Serial serial = pvSrc.ReadInt32();
  
  					SecureTradeContainer cont = World.FindItem(serial) as SecureTradeContainer;
  
  					if (cont != null)
  					{
  						int gold = pvSrc.ReadInt32();
  						int plat = pvSrc.ReadInt32();
  
  						SecureTrade trade = cont.Trade;
  
  						if (trade != null)
  						{
  							if (trade.From.Mobile == state.Mobile)
  							{
  								trade.From.Gold = gold;
  								trade.From.Plat = plat;
  								trade.UpdateFromCurrency();
  							}
  							else if (trade.To.Mobile == state.Mobile)
  							{
  								trade.To.Gold = gold;
  								trade.To.Plat = plat;
  								trade.UpdateToCurrency();
  							}
  						}
  					}
  				}
  					break;
  			}
  		}
  
  		public static void VendorBuyReply(NetState state, PacketReader pvSrc)
  		{
  			pvSrc.Seek(1, SeekOrigin.Begin);
  
  			int msgSize = pvSrc.ReadUInt16();
  			Mobile vendor = World.FindMobile(pvSrc.ReadInt32());
  			byte flag = pvSrc.ReadByte();
  
  			if (vendor == null)
  			{
  				return;
  			}
  			else if (vendor.Deleted || !Utility.RangeCheck(vendor.Location, state.Mobile.Location, 10))
  			{
  				state.Send(new EndVendorBuy(vendor));
  				return;
  			}
  
  			if (flag == 0x02)
  			{
  				msgSize -= 1 + 2 + 4 + 1;
  
  				if ((msgSize / 7) > 100)
  				{
  					return;
  				}
  
  				var buyList = new List<BuyItemResponse>(msgSize / 7);
  				for (; msgSize > 0; msgSize -= 7)
  				{
  					byte layer = pvSrc.ReadByte();
  					Serial serial = pvSrc.ReadInt32();
  					int amount = pvSrc.ReadInt16();
  
  					buyList.Add(new BuyItemResponse(serial, amount));
  				}
  
  				if (buyList.Count > 0)
  				{
  					IVendor v = vendor as IVendor;
  
  					if (v != null && v.OnBuyItems(state.Mobile, buyList))
  					{
  						state.Send(new EndVendorBuy(vendor));
  					}
  				}
  			}
  			else
  			{
  				state.Send(new EndVendorBuy(vendor));
  			}
  		}
  
  		public static void VendorSellReply(NetState state, PacketReader pvSrc)
  		{
  			Serial serial = pvSrc.ReadInt32();
  			Mobile vendor = World.FindMobile(serial);
  
  			if (vendor == null)
  			{
  				return;
  			}
  			else if (vendor.Deleted || !Utility.RangeCheck(vendor.Location, state.Mobile.Location, 10))
  			{
  				state.Send(new EndVendorSell(vendor));
  				return;
  			}
  
  			int count = pvSrc.ReadUInt16();
  			if (count < 100 && pvSrc.Size == (1 + 2 + 4 + 2 + (count * 6)))
  			{
  				var sellList = new List<SellItemResponse>(count);
  
  				for (int i = 0; i < count; i++)
  				{
  					Item item = World.FindItem(pvSrc.ReadInt32());
  					int Amount = pvSrc.ReadInt16();
  
  					if (item != null && Amount > 0)
  					{
  						sellList.Add(new SellItemResponse(item, Amount));
  					}
  				}
  
  				if (sellList.Count > 0)
  				{
  					IVendor v = vendor as IVendor;
  
  					if (v != null && v.OnSellItems(state.Mobile, sellList))
  					{
  						state.Send(new EndVendorSell(vendor));
  					}
  				}
  			}
  		}
  
  		public static void DeleteCharacter(NetState state, PacketReader pvSrc)
  		{
  			pvSrc.Seek(30, SeekOrigin.Current);
  			int index = pvSrc.ReadInt32();
  
  			EventSink.InvokeDeleteRequest(new DeleteRequestEventArgs(state, index));
  		}
  
  		public static void ResourceQuery(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{ }
  		}
  
  		public static void GameCentralMoniter(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{
  				int type = pvSrc.ReadByte();
  				int num1 = pvSrc.ReadInt32();
  
  				Console.WriteLine("God Client: {0}: Game central moniter", state);
  				Console.WriteLine(" - Type: {0}", type);
  				Console.WriteLine(" - Number: {0}", num1);
  
  				pvSrc.Trace(state);
  			}
  		}
  
  		public static void GodviewQuery(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{
  				Console.WriteLine("God Client: {0}: Godview query 0x{1:X}", state, pvSrc.ReadByte());
  			}
  		}
  
  		public static void GMSingle(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{
  				pvSrc.Trace(state);
  			}
  		}
  
  		public static void DeathStatusResponse(NetState state, PacketReader pvSrc)
  		{
  			// Ignored
  		}
  
  		public static void ObjectHelpRequest(NetState state, PacketReader pvSrc)
  		{
  			Mobile from = state.Mobile;
  
  			Serial serial = pvSrc.ReadInt32();
  			int unk = pvSrc.ReadByte();
  			string lang = pvSrc.ReadString(3);
  
  			if (serial.IsItem)
  			{
  				Item item = World.FindItem(serial);
  
  				if (item != null && from.Map == item.Map && Utility.InUpdateRange(from, item) && from.CanSee(item))
  				{
  					item.OnHelpRequest(from);
  				}
  			}
  			else if (serial.IsMobile)
  			{
  				Mobile m = World.FindMobile(serial);
  
  				if (m != null && from.Map == m.Map && Utility.InUpdateRange(from, m) && from.CanSee(m))
  				{
  					m.OnHelpRequest(m);
  				}
  			}
  		}
  
  		public static void MobileNameRequest(NetState state, PacketReader pvSrc)
  		{
  			Mobile m = World.FindMobile(pvSrc.ReadInt32());
  
  			if (m != null && Utility.InUpdateRange(state.Mobile, m) && state.Mobile.CanSee(m))
  			{
  				state.Send(new MobileName(m));
  			}
  		}
  
  		public static void RequestScrollWindow(NetState state, PacketReader pvSrc)
  		{
  			int lastTip = pvSrc.ReadInt16();
  			int type = pvSrc.ReadByte();
  		}
  
          public static void AttackReq(NetState state, PacketReader pvSrc)
          {
              Mobile from = state.Mobile;
              Mobile m = World.FindMobile(pvSrc.ReadInt32());
  
              if (m != null)
              {
                  from.Attack(m);
              }
          }
  
  		public static void HuePickerResponse(NetState state, PacketReader pvSrc)
  		{
  			int serial = pvSrc.ReadInt32();
  			int value = pvSrc.ReadInt16();
  			int hue = pvSrc.ReadInt16() & 0x3FFF;
  
  			hue = Utility.ClipDyedHue(hue);
  
  			foreach (HuePicker huePicker in state.HuePickers)
  			{
  				if (huePicker.Serial == serial)
  				{
  					state.RemoveHuePicker(huePicker);
  
  					huePicker.OnResponse(hue);
  
  					break;
  				}
  			}
  		}
  
  		public static void TripTime(NetState state, PacketReader pvSrc)
  		{
  			int unk1 = pvSrc.ReadByte();
  			int unk2 = pvSrc.ReadInt32();
  
  			state.Send(new TripTimeResponse(unk1));
  		}
  
  		public static void UTripTime(NetState state, PacketReader pvSrc)
  		{
  			int unk1 = pvSrc.ReadByte();
  			int unk2 = pvSrc.ReadInt32();
  
  			state.Send(new UTripTimeResponse(unk1));
  		}
  
  		public static void ChangeZ(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{
  				int x = pvSrc.ReadInt16();
  				int y = pvSrc.ReadInt16();
  				int z = pvSrc.ReadSByte();
  
  				Console.WriteLine("God Client: {0}: Change Z ({1}, {2}, {3})", state, x, y, z);
  			}
  		}
  
  		public static void SystemInfo(NetState state, PacketReader pvSrc)
  		{
  			int v1 = pvSrc.ReadByte();
  			int v2 = pvSrc.ReadUInt16();
  			int v3 = pvSrc.ReadByte();
  			string s1 = pvSrc.ReadString(32);
  			string s2 = pvSrc.ReadString(32);
  			string s3 = pvSrc.ReadString(32);
  			string s4 = pvSrc.ReadString(32);
  			int v4 = pvSrc.ReadUInt16();
  			int v5 = pvSrc.ReadUInt16();
  			int v6 = pvSrc.ReadInt32();
  			int v7 = pvSrc.ReadInt32();
  			int v8 = pvSrc.ReadInt32();
  		}
  
  		public static void Edit(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{
  				int type = pvSrc.ReadByte(); // 10 = static, 7 = npc, 4 = dynamic
  				int x = pvSrc.ReadInt16();
  				int y = pvSrc.ReadInt16();
  				int id = pvSrc.ReadInt16();
  				int z = pvSrc.ReadSByte();
  				int hue = pvSrc.ReadUInt16();
  
  				Console.WriteLine("God Client: {0}: Edit {6} ({1}, {2}, {3}) 0x{4:X} (0x{5:X})", state, x, y, z, id, hue, type);
  			}
  		}
  
  		public static void DeleteStatic(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{
  				int x = pvSrc.ReadInt16();
  				int y = pvSrc.ReadInt16();
  				int z = pvSrc.ReadInt16();
  				int id = pvSrc.ReadUInt16();
  
  				Console.WriteLine("God Client: {0}: Delete Static ({1}, {2}, {3}) 0x{4:X}", state, x, y, z, id);
  			}
  		}
  
  		public static void NewAnimData(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{
  				Console.WriteLine("God Client: {0}: New tile animation", state);
  
  				pvSrc.Trace(state);
  			}
  		}
  
  		public static void NewTerrain(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{
  				int x = pvSrc.ReadInt16();
  				int y = pvSrc.ReadInt16();
  				int id = pvSrc.ReadUInt16();
  				int width = pvSrc.ReadInt16();
  				int height = pvSrc.ReadInt16();
  
  				Console.WriteLine("God Client: {0}: New Terrain ({1}, {2})+({3}, {4}) 0x{5:X4}", state, x, y, width, height, id);
  			}
  		}
  
  		public static void NewRegion(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{
  				string name = pvSrc.ReadString(40);
  				int unk = pvSrc.ReadInt32();
  				int x = pvSrc.ReadInt16();
  				int y = pvSrc.ReadInt16();
  				int width = pvSrc.ReadInt16();
  				int height = pvSrc.ReadInt16();
  				int zStart = pvSrc.ReadInt16();
  				int zEnd = pvSrc.ReadInt16();
  				string desc = pvSrc.ReadString(40);
  				int soundFX = pvSrc.ReadInt16();
  				int music = pvSrc.ReadInt16();
  				int nightFX = pvSrc.ReadInt16();
  				int dungeon = pvSrc.ReadByte();
  				int light = pvSrc.ReadInt16();
  
  				Console.WriteLine("God Client: {0}: New Region '{1}' ('{2}')", state, name, desc);
  			}
  		}
  
  		public static void AccountID(NetState state, PacketReader pvSrc)
  		{ }
  
  		public static bool VerifyGC(NetState state)
  		{
  			if (state.Mobile == null || state.Mobile.IsPlayer())
  			{
  				if (state.Running)
  				{
  					Console.WriteLine("Warning: {0}: Player using godclient, disconnecting", state);
  				}
  
  				state.Dispose();
  				return false;
  			}
  			else
  			{
  				return true;
  			}
  		}
  
  		public static void TextCommand(NetState state, PacketReader pvSrc)
  		{
  			int type = pvSrc.ReadByte();
  			string command = pvSrc.ReadString();
  
  			Mobile m = state.Mobile;
  
  			switch (type)
  			{
  				case 0x00: // Go
  					{
  						if (VerifyGC(state))
  						{
  							try
  							{
  								var split = command.Split(' ');
  
  								int x = Utility.ToInt32(split[0]);
  								int y = Utility.ToInt32(split[1]);
  
  								int z;
  
  								if (split.Length >= 3)
  								{
  									z = Utility.ToInt32(split[2]);
  								}
  								else if (m.Map != null)
  								{
  									z = m.Map.GetAverageZ(x, y);
  								}
  								else
  								{
  									z = 0;
  								}
  
  								m.Location = new Point3D(x, y, z);
  							}
  							catch
  							{ }
  						}
  
  						break;
  					}
  				case 0xC7: // Animate
  					{
  						EventSink.InvokeAnimateRequest(new AnimateRequestEventArgs(m, command));
  
  						break;
  					}
  				case 0x24: // Use skill
  					{
  						int skillIndex;
  
  						if (!int.TryParse(command.Split(' ')[0], out skillIndex))
  						{
  							break;
  						}
  
  						Skills.UseSkill(m, skillIndex);
  
  						break;
  					}
  				case 0x43: // Open spellbook
  					{
  						int booktype;
  
  						if (!int.TryParse(command, out booktype))
  						{
  							booktype = 1;
  						}
  
  						EventSink.InvokeOpenSpellbookRequest(new OpenSpellbookRequestEventArgs(m, booktype));
  
  						break;
  					}
  				case 0x27: // Cast spell from book
  					{
  						var split = command.Split(' ');
  
  						if (split.Length > 0)
  						{
  							int spellID = Utility.ToInt32(split[0]) - 1;
  							int serial = split.Length > 1 ? Utility.ToInt32(split[1]) : -1;
  
  							EventSink.InvokeCastSpellRequest(new CastSpellRequestEventArgs(m, spellID, World.FindItem(serial)));
  						}
  
  						break;
  					}
  				case 0x58: // Open door
  					{
  						EventSink.InvokeOpenDoorMacroUsed(new OpenDoorMacroEventArgs(m));
  
  						break;
  					}
  				case 0x56: // Cast spell from macro
  					{
  						int spellID = Utility.ToInt32(command) - 1;
  
  						EventSink.InvokeCastSpellRequest(new CastSpellRequestEventArgs(m, spellID, null));
  
  						break;
  					}
  				case 0xF4: // Invoke virtues from macro
  					{
  						int virtueID = Utility.ToInt32(command) - 1;
  
  						EventSink.InvokeVirtueMacroRequest(new VirtueMacroRequestEventArgs(m, virtueID));
  
  						break;
  					}
  				case 0x2F: // Old scroll double click
  					{
  						/*
  					 * This command is still sent for items 0xEF3 - 0xEF9
  					 *
  					 * Command is one of three, depending on the item ID of the scroll:
  					 * - [scroll serial]
  					 * - [scroll serial] [target serial]
  					 * - [scroll serial] [x] [y] [z]
  					 */
  						break;
  					}
  				default:
  					{
  						Console.WriteLine("Client: {0}: Unknown text-command type 0x{1:X2}: {2}", state, type, command);
  						break;
  					}
  			}
  		}
  
  		public static void GodModeRequest(NetState state, PacketReader pvSrc)
  		{
  			if (VerifyGC(state))
  			{
  				state.Send(new GodModeReply(pvSrc.ReadBoolean()));
  			}
  		}
  
  		public static void AsciiPromptResponse(NetState state, PacketReader pvSrc)
  		{
  			int serial = pvSrc.ReadInt32();
  			int prompt = pvSrc.ReadInt32();
  			int type = pvSrc.ReadInt32();
  			string text = pvSrc.ReadStringSafe();
  
  			if (text.Length > 128)
  			{
  				return;
  			}
  
  			Mobile from = state.Mobile;
  			Prompt p = from.Prompt;
  
              if (p != null && p.Sender.Serial == serial && p.TypeId == prompt)
              {
                  from.Prompt = null;
  
  				if (type == 0)
  				{
  					p.OnCancel(from);
  				}
  				else
  				{
  					p.OnResponse(from, text);
  				}
  			}
  		}
  
  		public static void UnicodePromptResponse(NetState state, PacketReader pvSrc)
  		{
  			int serial = pvSrc.ReadInt32();
  			int prompt = pvSrc.ReadInt32();
  			int type = pvSrc.ReadInt32();
  			string lang = pvSrc.ReadString(4);
  			string text = pvSrc.ReadUnicodeStringLESafe();
  
  			if (text.Length > 128)
  			{
  				return;
  			}
  
  			Mobile from = state.Mobile;
  			Prompt p = from.Prompt;
  
              int promptSerial = (p != null && p.Sender != null) ? p.Sender.Serial.Value : from.Serial.Value;
  
              if (p != null && promptSerial == serial && p.TypeId == prompt)
              {
                  from.Prompt = null;
  
  				if (type == 0)
  				{
  					p.OnCancel(from);
  				}
  				else
  				{
  					p.OnResponse(from, text);
  				}
  			}
  		}
  
  		public static void MenuResponse(NetState state, PacketReader pvSrc)
  		{
  			int serial = pvSrc.ReadInt32();
  			int menuID = pvSrc.ReadInt16(); // unused in our implementation
  			int index = pvSrc.ReadInt16();
  			int itemID = pvSrc.ReadInt16();
  			int hue = pvSrc.ReadInt16();
  
  			index -= 1; // convert from 1-based to 0-based
  
  			foreach (IMenu menu in state.Menus)
  			{
  				if (menu.Serial == serial)
  				{
  					state.RemoveMenu(menu);
  
  					if (index >= 0 && index < menu.EntryLength)
  					{
  						menu.OnResponse(state, index);
  					}
  					else
  					{
  						menu.OnCancel(state);
  					}
  
  					break;
  				}
  			}
  		}
  
  		public static void ProfileReq(NetState state, PacketReader pvSrc)
  		{
  			int type = pvSrc.ReadByte();
  			Serial serial = pvSrc.ReadInt32();
  
  			Mobile beholder = state.Mobile;
  			Mobile beheld = World.FindMobile(serial);
  
  			if (beheld == null)
  			{
  				return;
  			}
  
  			switch (type)
  			{
  				case 0x00: // display request
  					{
  						EventSink.InvokeProfileRequest(new ProfileRequestEventArgs(beholder, beheld));
  
  						break;
  					}
  				case 0x01: // edit request
  					{
  						pvSrc.ReadInt16(); // Skip
  						int length = pvSrc.ReadUInt16();
  
  						if (length > 511)
  						{
  							return;
  						}
  
  						string text = pvSrc.ReadUnicodeString(length);
  
  						EventSink.InvokeChangeProfileRequest(new ChangeProfileRequestEventArgs(beholder, beheld, text));
  
  						break;
  					}
  			}
  		}
  
  		public static void Disconnect(NetState state, PacketReader pvSrc)
  		{
  			int minusOne = pvSrc.ReadInt32();
  		}
  
  		public static void LiftReq(NetState state, PacketReader pvSrc)
  		{
  			Serial serial = pvSrc.ReadInt32();
  			int amount = pvSrc.ReadUInt16();
  			Item item = World.FindItem(serial);
  
  			bool rejected;
  			LRReason reject;
  
  			state.Mobile.Lift(item, amount, out rejected, out reject);
  		}
  
  		public static void EquipReq(NetState state, PacketReader pvSrc)
  		{
  			Mobile from = state.Mobile;
  			Item item = from.Holding;
  
  			bool valid = (item != null && item.HeldBy == from && item.Map == Map.Internal);
  
  			from.Holding = null;
  
  			if (!valid)
  			{
  				return;
  			}
  
  			pvSrc.Seek(5, SeekOrigin.Current);
  			Mobile to = World.FindMobile(pvSrc.ReadInt32());
  
  			if (to == null)
  			{
  				to = from;
  			}
  
  			if (!to.AllowEquipFrom(from) || !to.EquipItem(item))
  			{
  				item.Bounce(from);
  			}
  
  			item.ClearBounce();
  		}
  
  		public static void DropReq(NetState state, PacketReader pvSrc)
  		{
  			Serial serial = pvSrc.ReadInt32(); // serial, ignored
  			int x = pvSrc.ReadInt16();
  			int y = pvSrc.ReadInt16();
  			int z = pvSrc.ReadSByte();
              byte gridloc = pvSrc.ReadByte(); // grid location
              Serial dest = pvSrc.ReadInt32();
  
  			Point3D loc = new Point3D(x, y, z);
  			Mobile from = state.Mobile;
  
              if (serial.IsItem)
              {
                  Item dropped = World.FindItem(serial);
  
                  if (dropped != null)
                  {
                      dropped.GridLocation = gridloc;
                  }
              }
  
  			if (dest.IsMobile)
  			{
  				from.Drop(World.FindMobile(dest), loc);
  			}
  			else if (dest.IsItem)
  			{
  				Item item = World.FindItem(dest);
  
  				if (item is BaseMulti && ((BaseMulti)item).AllowsRelativeDrop)
  				{
  					loc.m_X += item.X;
  					loc.m_Y += item.Y;
  					from.Drop(loc);
  				}
  				else
  				{
  					from.Drop(item, loc);
  				}
  			}
  			else
  			{
  				from.Drop(loc);
  			}
  		}
  
  		public static void DropReq6017(NetState state, PacketReader pvSrc)
  		{
              Serial serial = pvSrc.ReadInt32();
              int x = pvSrc.ReadInt16();
  			int y = pvSrc.ReadInt16();
  			int z = pvSrc.ReadSByte();
              byte gridloc = pvSrc.ReadByte(); // grid location
              Serial dest = pvSrc.ReadInt32();
  
  			Point3D loc = new Point3D(x, y, z);
  			Mobile from = state.Mobile;
  
              if (serial.IsItem)
              {
                  Item dropped = World.FindItem(serial);
  
                  if (dropped != null)
                  {
                      dropped.GridLocation = gridloc;
                  }
              }
  
  			if (dest.IsMobile)
  			{
  				from.Drop(World.FindMobile(dest), loc);
  			}
  			else if (dest.IsItem)
  			{
  				Item item = World.FindItem(dest);
  
  				if (item is BaseMulti && ((BaseMulti)item).AllowsRelativeDrop)
  				{
  					loc.m_X += item.X;
  					loc.m_Y += item.Y;
  					from.Drop(loc);
  				}
  				else
  				{
  					from.Drop(item, loc);
  				}
  			}
  			else
  			{
  				from.Drop(loc);
  			}
  		}
  
  		public static void ConfigurationFile(NetState state, PacketReader pvSrc)
  		{ }
  
  		public static void LogoutReq(NetState state, PacketReader pvSrc)
  		{
  			state.Send(new LogoutAck());
  		}
  
  		public static void ChangeSkillLock(NetState state, PacketReader pvSrc)
  		{
  			Skill s = state.Mobile.Skills[pvSrc.ReadInt16()];
  
  			if (s != null)
  			{
  				s.SetLockNoRelay((SkillLock)pvSrc.ReadByte());
  			}
  		}
  
  		public static void HelpRequest(NetState state, PacketReader pvSrc)
  		{
  			EventSink.InvokeHelpRequest(new HelpRequestEventArgs(state.Mobile));
  		}
  
  		public static void TargetResponse(NetState state, PacketReader pvSrc)
  		{
  			int type = pvSrc.ReadByte();
  			int targetID = pvSrc.ReadInt32();
  			int flags = pvSrc.ReadByte();
  			Serial serial = pvSrc.ReadInt32();
  			int x = pvSrc.ReadInt16(), y = pvSrc.ReadInt16(), z = pvSrc.ReadInt16();
  			int graphic = pvSrc.ReadUInt16();
  
  			if (targetID == unchecked((int)0xDEADBEEF))
  			{
  				return;
  			}
  
  			Mobile from = state.Mobile;
  
  			Target t = from.Target;
  
  			if (t != null)
  			{
  				TargetProfile prof = TargetProfile.Acquire(t.GetType());
  
  				if (prof != null)
  				{
  					prof.Start();
  				}
  
  				try
  				{
  					if (x == -1 && y == -1 && !serial.IsValid)
  					{
  						// User pressed escape
  						t.Cancel(from, TargetCancelType.Canceled);
  					}
  					else if (Target.TargetIDValidation && t.TargetID != targetID)
  					{
  						// Prevent fake target, reported by AssistUO Team!
  						return;
  					}
  					else
  					{
  						object toTarget;
  
  						if (type == 1)
  						{
  							if (graphic == 0)
  							{
  								toTarget = new LandTarget(new Point3D(x, y, z), from.Map);
  							}
  							else
  							{
  								Map map = from.Map;
  
  								if (map == null || map == Map.Internal)
  								{
  									t.Cancel(from, TargetCancelType.Canceled);
  									return;
  								}
  								else
  								{
  									var tiles = map.Tiles.GetStaticTiles(x, y, !t.DisallowMultis);
  
  									bool valid = false;
  
  									if (state.HighSeas)
  									{
  										ItemData id = TileData.ItemTable[graphic & TileData.MaxItemValue];
  										if (id.Surface)
  										{
  											z -= id.Height;
  										}
  									}
  
  									for (int i = 0; !valid && i < tiles.Length; ++i)
  									{
  										if (tiles[i].Z == z && tiles[i].ID == graphic)
  										{
  											valid = true;
  										}
  									}
  
  									if (!valid)
  									{
  										t.Cancel(from, TargetCancelType.Canceled);
  										return;
  									}
  									else
  									{
  										toTarget = new StaticTarget(new Point3D(x, y, z), graphic);
  									}
  								}
  							}
  						}
  						else if (serial.IsMobile)
  						{
  							toTarget = World.FindMobile(serial);
  						}
  						else if (serial.IsItem)
  						{
  							toTarget = World.FindItem(serial);
  						}
  						else
  						{
  							t.Cancel(from, TargetCancelType.Canceled);
  							return;
  						}
  
  						t.Invoke(from, toTarget);
  					}
  				}
  				finally
  				{
  					if (prof != null)
  					{
  						prof.Finish();
  					}
  				}
  			}
  		}
  
  		public static void DisplayGumpResponse(NetState state, PacketReader pvSrc)
  		{
  			int serial = pvSrc.ReadInt32();
  			int typeID = pvSrc.ReadInt32();
  			int buttonID = pvSrc.ReadInt32();
  
  			foreach (Gump gump in state.Gumps)
  			{
  				if (gump.Serial == serial && gump.TypeID == typeID)
  				{
  					var buttonExists = buttonID == 0; // 0 is always 'close'
  
  					if (!buttonExists)
  					{
  						foreach (var e in gump.Entries)
  						{
  							if (e is GumpButton && ((GumpButton)e).ButtonID == buttonID)
  							{
  								buttonExists = true;
  								break;
  							}
  
  							if (e is GumpImageTileButton && ((GumpImageTileButton)e).ButtonID == buttonID)
  							{
  								buttonExists = true;
  								break;
  							}
  						}
  					}
  
  					if (!buttonExists)
  					{
  						Utility.PushColor(ConsoleColor.Red);
  						state.WriteConsole("Invalid gump response, disconnecting...");
  						Utility.PopColor();
  						state.Dispose();
  						return;
  					}
  
  					int switchCount = pvSrc.ReadInt32();
  
  					if (switchCount < 0 || switchCount > gump.m_Switches)
  					{
  						Utility.PushColor(ConsoleColor.Red);
  						state.WriteConsole("Invalid gump response, disconnecting...");
  						Utility.PopColor();
  						state.Dispose();
  						return;
  					}
  
  					var switches = new int[switchCount];
  
  					for (int j = 0; j < switches.Length; ++j)
  					{
  						switches[j] = pvSrc.ReadInt32();
  					}
  
  					int textCount = pvSrc.ReadInt32();
  
  					if (textCount < 0 || textCount > gump.m_TextEntries)
  					{
  						Utility.PushColor(ConsoleColor.Red);
  						state.WriteConsole("Invalid gump response, disconnecting...");
  						Utility.PopColor();
  						state.Dispose();
  						return;
  					}
  
  					var textEntries = new TextRelay[textCount];
  
  					for (int j = 0; j < textEntries.Length; ++j)
  					{
  						int entryID = pvSrc.ReadUInt16();
  						int textLength = pvSrc.ReadUInt16();
  
  						if (textLength > 239)
  						{
  							Utility.PushColor(ConsoleColor.Red);
  							state.WriteConsole("Invalid gump response, disconnecting...");
  							Utility.PopColor();
  							state.Dispose();
  							return;
  						}
  
  						string text = pvSrc.ReadUnicodeStringSafe(textLength);
  						textEntries[j] = new TextRelay(entryID, text);
  					}
  
  					state.RemoveGump(gump);
  
  					GumpProfile prof = GumpProfile.Acquire(gump.GetType());
  
  					if (prof != null)
  					{
  						prof.Start();
  					}
  
  					gump.OnResponse(state, new RelayInfo(buttonID, switches, textEntries));
  
  					if (prof != null)
  					{
  						prof.Finish();
  					}
  
  					return;
  				}
  			}
  
  			if (typeID == 461)
  			{
  				// Virtue gump
  				int switchCount = pvSrc.ReadInt32();
  
  				if (buttonID == 1 && switchCount > 0)
  				{
  					Mobile beheld = World.FindMobile(pvSrc.ReadInt32());
  
  					if (beheld != null)
  					{
  						EventSink.InvokeVirtueGumpRequest(new VirtueGumpRequestEventArgs(state.Mobile, beheld));
  					}
  				}
  				else
  				{
  					Mobile beheld = World.FindMobile(serial);
  
  					if (beheld != null)
  					{
  						EventSink.InvokeVirtueItemRequest(new VirtueItemRequestEventArgs(state.Mobile, beheld, buttonID));
  					}
  				}
  			}
  		}
  
  		public static void SetWarMode(NetState state, PacketReader pvSrc)
  		{
              if (state.Mobile.IsStaff() || Core.TickCount - state.Mobile.NextActionTime >= 0)
              {
                  state.Mobile.DelayChangeWarmode(pvSrc.ReadBoolean());
              }
              else
              {
                  state.Mobile.SendActionMessage();
              }
  		}
  
  		public static void Resynchronize(NetState state, PacketReader pvSrc)
  		{
  			Mobile m = state.Mobile;
  
  			if (state.StygianAbyss)
  			{
  				state.Send(new MobileUpdate(m));
  			}
  			else
  			{
  				state.Send(new MobileUpdateOld(m));
  			}
  
  			state.Send(MobileIncoming.Create(state, m, m));
  
  			m.SendEverything();
  
  			state.Sequence = 0;
  
  			m.ClearFastwalkStack();
  		}
  
  		private static readonly int[] m_EmptyInts = new int[0];
  
  		public static void AsciiSpeech(NetState state, PacketReader pvSrc)
  		{
  			Mobile from = state.Mobile;
  
  			MessageType type = (MessageType)pvSrc.ReadByte();
  			int hue = pvSrc.ReadInt16();
  			pvSrc.ReadInt16(); // font
  			string text = pvSrc.ReadStringSafe().Trim();
  
  			if (text.Length <= 0 || text.Length > 128)
  			{
  				return;
  			}
  
  			if (!Enum.IsDefined(typeof(MessageType), type))
  			{
  				type = MessageType.Regular;
  			}
  
  			from.DoSpeech(text, m_EmptyInts, type, Utility.ClipDyedHue(hue));
  		}
  
  		private static readonly KeywordList m_KeywordList = new KeywordList();
  
  		public static void UnicodeSpeech(NetState state, PacketReader pvSrc)
  		{
  			Mobile from = state.Mobile;
  
  			MessageType type = (MessageType)pvSrc.ReadByte();
  			int hue = pvSrc.ReadInt16();
  			pvSrc.ReadInt16(); // font
  			string lang = pvSrc.ReadString(4);
  			string text;
  
  			bool isEncoded = (type & MessageType.Encoded) != 0;
  			int[] keywords;
  
  			if (isEncoded)
  			{
  				int value = pvSrc.ReadInt16();
  				int count = (value & 0xFFF0) >> 4;
  				int hold = value & 0xF;
  
  				if (count < 0 || count > 50)
  				{
  					return;
  				}
  
  				KeywordList keyList = m_KeywordList;
  
  				for (int i = 0; i < count; ++i)
  				{
  					int speechID;
  
  					if ((i & 1) == 0)
  					{
  						hold <<= 8;
  						hold |= pvSrc.ReadByte();
  						speechID = hold;
  						hold = 0;
  					}
  					else
  					{
  						value = pvSrc.ReadInt16();
  						speechID = (value & 0xFFF0) >> 4;
  						hold = value & 0xF;
  					}
  
  					if (!keyList.Contains(speechID))
  					{
  						keyList.Add(speechID);
  					}
  				}
  
  				text = pvSrc.ReadUTF8StringSafe();
  
  				keywords = keyList.ToArray();
  			}
  			else
  			{
  				text = pvSrc.ReadUnicodeStringSafe();
  
  				keywords = m_EmptyInts;
  			}
  
  			text = text.Trim();
  
  			if (text.Length <= 0 || text.Length > 128)
  			{
  				return;
  			}
  
  			type &= ~MessageType.Encoded;
  
  			if (!Enum.IsDefined(typeof(MessageType), type))
  			{
  				type = MessageType.Regular;
  			}
  
  			from.Language = lang;
  			from.DoSpeech(text, keywords, type, Utility.ClipDyedHue(hue));
  		}
  
  		public static void UseReq(NetState state, PacketReader pvSrc)
  		{
  			Mobile from = state.Mobile;
  
  			if (from.IsStaff() || Core.TickCount - from.NextActionTime >= 0)
  			{
  				int value = pvSrc.ReadInt32();
  
  				if ((value & ~0x7FFFFFFF) != 0)
  				{
  					from.OnPaperdollRequest();
  				}
  				else
  				{
  					Serial s = value;
  
  					if (s.IsMobile)
  					{
  						Mobile m = World.FindMobile(s);
  
  						if (m != null && !m.Deleted)
  						{
  							from.Use(m);
  						}
  					}
  					else if (s.IsItem)
  					{
  						Item item = World.FindItem(s);
  
  						if (item != null && !item.Deleted)
  						{
  							from.Use(item);
  						}
  					}
  				}
  
  				from.NextActionTime = Core.TickCount + Mobile.ActionDelay;
  			}
  			else
  			{
  				from.SendActionMessage();
  			}
  		}
  
  		public static bool SingleClickProps { get; set; }
  
  		public static Func<Mobile, Mobile, bool> MobileClickOverride;
  		public static Func<Mobile, Item, bool> ItemClickOverride;
  
  		private static void HandleSingleClick(Mobile m, IEntity target)
  		{
  			if (m == null || target == null || target.Deleted || !m.CanSee(target))
  			{
  				return;
  			}
  
  			if (target is Item)
  			{
  				var o = (Item)target;
  
  				if (Utility.InUpdateRange(m.Location, o.GetWorldLocation()))
  				{
  					if (ItemClickOverride == null || !ItemClickOverride(m, o))
  					{
  						if (SingleClickProps && m.ViewOPL)
  						{
  							o.OnAosSingleClick(m);
  						}
  						else if (m.Region.OnSingleClick(m, o))
  						{
  							if (o.Parent is Item)
  							{
  								((Item)o.Parent).OnSingleClickContained(m, o);
  							}
  
  							o.OnSingleClick(m);
  						}
  					}
  				}
  			}
  			else if (target is Mobile)
  			{
  				var o = (Mobile)target;
  
  				if (Utility.InUpdateRange(m, o))
  				{
  					if (MobileClickOverride == null || !MobileClickOverride(m, o))
  					{
  						if (SingleClickProps && m.ViewOPL)
  						{
  							o.OnAosSingleClick(m);
  						}
  						else if (m.Region.OnSingleClick(m, o))
  						{
  							o.OnSingleClick(m);
  						}
  					}
  				}
  			}
  		}
  
  		public static void LookReq(NetState state, PacketReader pvSrc)
  		{
  			if (state.Mobile != null && (state.Mobile.ViewOPL || state.Expansion < Expansion.AOS))
  			{
  				HandleSingleClick(state.Mobile, World.FindEntity(pvSrc.ReadInt32()));
  			}
  		}
  
  		public static void PingReq(NetState state, PacketReader pvSrc)
  		{
  			state.Send(PingAck.Instantiate(pvSrc.ReadByte()));
  		}
  
  		public static void SetUpdateRange(NetState state, PacketReader pvSrc)
  		{
              //            min   max  default
              /* 640x480    5     18   15
               * 800x600    5     18   18
               * 1024x768   5     24   24
               * 1152x864   5     24   24 
               * 1280x720   5     24   24
               */
  
  			int range = pvSrc.ReadByte();
  
  			// Don't let range drop below the minimum standard.
  			range = Math.Max(Core.GlobalUpdateRange, range);
  			
              int old = state.UpdateRange;
  
  			if (old == range)
  			{
  				return;
  			}
  
  			state.UpdateRange = range;
  
  			state.Send(ChangeUpdateRange.Instantiate(state.UpdateRange));
  
  
gt:             if (state.Mobile != null)