public TrackingInfo( Mobile tracker, Mobile target )
			{
				m_Tracker = tracker;
				m_Target = target;
				m_Location = new Point2D( target.X, target.Y );
				m_Map = target.Map;
			}

        public override bool CanMoveTo(Point2D newLocation, ref string err)
        {
            if ( ! base.CanMoveTo (newLocation, ref err) )
                return false;

            // Care only about absolutes for knights
            int dx = Math.Abs( newLocation.X - m_Position.X );
            int dy = Math.Abs( newLocation.Y - m_Position.Y );

            if ( ! ( ( dx == 1 && dy == 2 ) || ( dx == 2 && dy == 1 ) ) )
            {
                err = "Knights can only make L shaped moves (2-3 tiles length)";
                return false; // Wrong move
            }

            // Verify target piece
            BaseChessPiece piece = m_BChessboard[ newLocation ];

            if ( piece == null || piece.Color != m_Color )
                return true;
            else
            {
                err = "You can't capture pieces of your same color";
                return false;
            }
        }

        public override ArrayList GetMoves(bool capture)
        {
            ArrayList moves = new ArrayList();

            for ( int dx = -2; dx <= 2; dx++ )
            {
                for ( int dy = -2; dy <= 2; dy++ )
                {
                    if ( ! ( ( Math.Abs( dx ) == 1 && Math.Abs( dy ) == 2 ) || ( Math.Abs( dx ) == 2 && Math.Abs( dy ) == 1 ) ) )
                        continue;

                    Point2D p = new Point2D( m_Position.X + dx, m_Position.Y + dy );

                    if ( ! m_BChessboard.IsValid( p ) )
                        continue;

                    BaseChessPiece piece = m_BChessboard[ p ];

                    if ( piece == null )
                        moves.Add( p );
                    else if ( capture && piece.Color != m_Color )
                        moves.Add( p );
                }
            }

            return moves;
        }

        private static void LoadLocations()
        {
            string filePath = Path.Combine(Core.BaseDirectory, "Data/treasure.cfg");

            ArrayList list = new ArrayList();
            ArrayList havenList = new ArrayList();

            if (File.Exists(filePath))
            {
                using (StreamReader ip = new StreamReader(filePath))
                {
                    string line;

                    while ((line = ip.ReadLine()) != null)
                    {
                        try
                        {
                            string[] split = line.Split(' ');

                            int x = Convert.ToInt32(split[0]), y = Convert.ToInt32(split[1]);

                            Point2D loc = new Point2D(x, y);
                            list.Add(loc);
                        }
                        catch
                        {
                        }
                    }
                }
            }

            m_Locations = (Point2D[])list.ToArray(typeof(Point2D));
        }

		public MahjongDealerIndicator( MahjongGame game, Point2D position, MahjongPieceDirection direction, MahjongWind wind )
		{
			m_Game = game;
			m_Position = position;
			m_Direction = direction;
			m_Wind = wind;
		}

		public static MahjongPieceDim GetDimensions( Point2D position, MahjongPieceDirection direction )
		{
			if ( direction == MahjongPieceDirection.Up || direction == MahjongPieceDirection.Down )
				return new MahjongPieceDim( position, 40, 20 );
			else
				return new MahjongPieceDim( position, 20, 40 );
		}

		/// <summary>
		/// Creates a new Move object without capturing a piece
		/// </summary>
		/// <param name="piece">The chess piece performing the move</param>
		/// <param name="target">The target location of the move</param>
		public Move( BaseChessPiece piece, Point2D target )
		{
			m_Piece = piece;
			m_From = m_Piece.Position;
			m_To = target;
			m_Captured = m_Piece.GetCaptured( target, ref m_EnPassant );
		}

		public MahjongWallBreakIndicator( MahjongGame game, GenericReader reader )
		{
			m_Game = game;

			int version = reader.ReadInt();

			m_Position = reader.ReadPoint2D();
		}

		//----------------------------------------------------------------------
		//  Here, we are going to search the quadrant that it is ahead of the player, because
		//  he is running
		//----------------------------------------------------------------------
		public static bool FindAhead(
			PlayerMobile pm,
			Point3D centerPoint,
			ref Point3D spawnPoint,
			LandType landType,
			int distance,
			EffectType effectType,
			int effectHue
			)
		{
			Direction dir = (Direction)((int)pm.Direction & 0x0f);

			Point3D foundPoint = new Point3D();

			Tour tour = delegate( Map map, int x, int y )
			{
				if( Utility.RandomDouble() < .5 ) return false; // break it up a little.

				Point2D currentPoint = new Point2D( pm.Location.X + x, pm.Location.Y + y );

				if( FindSpawnTileInternal(
						pm,
						centerPoint,
						currentPoint,
						ref foundPoint,
						landType,
						effectType,
						effectHue
						)
					)
				{
					return true;
				}

				return false;
			};

			bool found = Search.Octant(
				pm.Map,
				dir,
				distance,
				SearchDirection.Inwards,
				tour
				);

			if( found )
			{
				spawnPoint.X = foundPoint.X;
				spawnPoint.Y = foundPoint.Y;
				spawnPoint.Z = foundPoint.Z;

				return true;
			}

			return false;
		}

		public MahjongTile( MahjongGame game, int number, MahjongTileType value, Point2D position, int stackLevel, MahjongPieceDirection direction, bool flipped )
		{
			m_Game = game;
			m_Number = number;
			m_Value = value;
			m_Position = position;
			m_StackLevel = stackLevel;
			m_Direction = direction;
			m_Flipped = flipped;
		}

		public StudyObjective( Point2D point, int range, Map map, string[] messages, int seconds ) : base( 1, seconds )
		{
			Point = point;
			Range = range;
			Map = map;
			Messages = messages;
			OnMessage = 0;

			CheckTimer();
		}

        public void EndCastle( Point2D location )
        {
            m_HasMoved = true;

            m_Move = new Move( this, location );

            Point2D worldLocation = m_BChessboard.BoardToWorld( location );

            m_Piece.GoTo( worldLocation );
        }

		public void Move( Point2D position )
		{
			MahjongPieceDim dim = GetDimensions( position );

			if ( !dim.IsValid() )
				return;

			m_Position = position;

			m_Game.Players.SendGeneralPacket( true, true );
		}

        public MahjongTile( MahjongGame game, GenericReader reader )
        {
            m_Game = game;

            int version = reader.ReadInt();

            m_Number = reader.ReadInt();
            m_Value = (MahjongTileType) reader.ReadInt();
            m_Position = reader.ReadPoint2D();
            m_StackLevel = reader.ReadInt();
            m_Direction = (MahjongPieceDirection) reader.ReadInt();
            m_Flipped = reader.ReadBool();
        }

		public ToolbarInfo(
			Point2D dimensions, List<string> entries, int skin, List<Point3D> points, int font, bool[] switches)
		{
			_Dimensions = dimensions;
			_Entries = entries;
			_Skin = skin;
			_Points = points;
			_Font = font;
			_Phantom = switches[0];
			_Stealth = switches[1];
			_Reverse = switches[2];
			_Lock = switches[3];
		}

        public void Move( Point2D position, MahjongPieceDirection direction, MahjongWind wind )
        {
            MahjongPieceDim dim = GetDimensions( position, direction );

            if ( !dim.IsValid() )
            {
                return;
            }

            m_Position = position;
            m_Direction = direction;
            m_Wind = wind;

            m_Game.Players.SendGeneralPacket( true, true );
        }

		public override void Deserialize( GenericReader reader )
		{
			base.Deserialize( reader );
			int version = reader.ReadEncodedInt();
			Point = reader.ReadPoint2D();
			Range = reader.ReadInt();
			Map = reader.ReadMap();

			int count = reader.ReadInt();
			Messages = new string[ count ];

			for ( int i = 0; i < count; i++ )
				Messages[i] = reader.ReadString();

			OnMessage = reader.ReadInt();
		}	

        public override bool CanMoveTo(Point2D newLocation, ref string err)
        {
            if ( ! base.CanMoveTo (newLocation, ref err) )
                return false;

            int dx = newLocation.X - m_Position.X;
            int dy = newLocation.Y - m_Position.Y;

            if ( Math.Abs( dx ) != Math.Abs( dy ) )
            {
                err = "Bishops can move only on diagonals";
                return false; // Not a diagonal movement
            }

            int xDirection = dx > 0 ? 1 : -1;
            int yDirection = dy > 0 ? 1 : -1;

            if ( Math.Abs( dx ) > 1 )
            {
                // Verify that the path to target is empty
                for ( int i = 1; i < Math.Abs( dx ); i++ ) // Skip the bishop square and stop before target
                {
                    int xOffset = xDirection * i;
                    int yOffset = yDirection * i;

                    if ( m_BChessboard[ m_Position.X + xOffset, m_Position.Y + yOffset ] != null )
                    {
                        err = "Bishops can't move over other pieces";
                        return false;
                    }
                }
            }

            // Verify target piece
            BaseChessPiece piece = m_BChessboard[ newLocation ];

            if ( piece == null || piece.Color != m_Color )
            {
                return true;
            }
            else
            {
                err = "You can't capture pieces of your own color";
                return false;
            }
        }

		public void Move( Point2D position, MahjongPieceDirection direction, bool flip, int validHandArea )
		{
			MahjongPieceDim dim = GetDimensions( position, direction );
			int curHandArea = Dimensions.GetHandArea();
			int newHandArea = dim.GetHandArea();

			if ( !IsMovable || !dim.IsValid() || ( validHandArea >= 0 && ((curHandArea >= 0 && curHandArea != validHandArea) || (newHandArea >= 0 && newHandArea != validHandArea)) ) )
				return;

			m_Position = position;
			m_Direction = direction;
			m_StackLevel = -1; // Avoid self interference
			m_StackLevel = m_Game.GetStackLevel( dim ) + 1;
			m_Flipped = flip;

			m_Game.Players.SendTilePacket( this, true, true );
		}

		/// <summary>
		/// Moves the NPC to the specified location
		/// </summary>
		/// <param name="to">The location the NPC should move to</param>
		public void GoTo( Point2D to )
		{
			AI = AIType.AI_Melee;

			m_NextMove = new Point3D( to, Z );

			if ( m_Piece is Knight )
			{
				WayPoint end = new WayPoint();
				WayPoint start = new WayPoint();

				end.MoveToWorld( m_NextMove, Map );

				// This is a knight, so do L shaped move
				int dx = to.X - X;
				int dy = to.Y - Y;

				Point3D p = Location; // Point3D is a value type

				if ( Math.Abs( dx ) == 1 )
					p.X += dx;
				else
					p.Y += dy;

				start.MoveToWorld( p, Map );
				start.NextPoint = end;

				CurrentWayPoint = start;

				m_WayPoints.Add( start );
				m_WayPoints.Add( end );
			}
			else
			{
				WayPoint wp = new WayPoint();
				wp.MoveToWorld( m_NextMove, Map );
				CurrentWayPoint = wp;

				m_WayPoints.Add( wp );
			}

			Paralyzed = false;
		}