#region Using Statements
using System;
using System.IO;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using DW.Stream;
using DW.Data.GameObjects;
using DW.Globals;
#endregion

namespace DW.Data.World
{
    /// <summary>
    /// World map class represents walkable map in the MapWorld.
    /// </summary>
    public partial class WorldMap
    {
        // Class represents exact number of tiles the display is showing
        private class TrueDisplaySize
        {
            public int WidthInTiles;
            public int WidthInPixels;
            public int HeightInTiles;
            public int HeightInPixels;
        }

        // The TileSet class holds information on an individual tileset that has
        // been loaded.
        private class TileSet
        {
            public Texture2D t2dTexture;
            public string mapFileName;
            public int verticalSpacing;
            public int horizontalSpacing;
            public int tileWidth;
            public int tileHeight;
            public int tilesPerRow;
        }

        
        // The t2dTileSets list holds our tilesets.  Each tileset must be the
        // same size, and all tiles are also the same size.
        private List<TileSet> tileSets = new List<TileSet>();

        // Positions of AI players when the map first loads
        private List<TileCoordinates> aiPositions = new List<TileCoordinates>();
        
        // Position of the human player when the map first loads
        private TileCoordinates humanPosition;
        
        // Width and Height of a single tile
        private int tileWidth = 1, tileHeight = 1;  
        
        // Number of active tilesets
        private int tileSetCount;       
        
        // Map Width and Height
        private int entireMapWidthInTiles, entireMapHeightInTiles;     
        
        // The currently active game map data
        private int[,] map, mapTrans, mapObj, mapData;
        
        // Current Map Location
        private int currentMapTileX, currentMapTileY, displayedMapTileSubX, displayedMapSubTileY;
        
        // Will we draw the Base layer?
        private bool drawBase = true;   
        
        // Will we draw the Trans layer?
        private bool drawTrans = true;  
        
        // Will we draw the Obj layer?
        private bool drawObj = true;                          
        
        // Draw Top Row Tiles on Trans/Obj layers?
        private bool drawFirstRowTiles = true;   
        
        // Used in Drawing loop to hold current tile
        private int currentTileToDraw;      
        
        // Used in Drawing loop to track tile locations
        private int tileXLoc, tileYLoc;            
        
        // Content Manager Instance
       // private ContentManager contentManager;
        
        // map definition file name
        string fileName = "";

		// Resoluton width and height. Muset be set every time the resolution changes.
        private int resolutionWidth, resolutionHeight;              

        /// <summary>
        /// Constructor.
        /// </summary>       
        public WorldMap()
        {
            ResolutionWidth = Renderer.graphics.GraphicsDevice.Viewport.Width;
            ResolutionHeight = Renderer.graphics.GraphicsDevice.Viewport.Height;
            Initialize();
        }

        /// <summary>
        /// Allows the game component to perform any initialization it needs to before starting
        /// to run.  This is where it can query for any required services and load content.
        /// </summary>
        public void Initialize()
        {
            // Set the tileset count to 0
            tileSetCount = 0;

            // Create a new content manager
            //contentManager = new ContentManager(screenManager.Game.Services);

        
            this.DisplayedMapX = 0;
            this.DisplayedMapY = 0;            
        }

       
        /// <summary>
        /// Loads the map from the definition file.
        /// </summary>
        /// <param name="sFileName">Map definition file name.</param>
        public void LoadMap(string sFileName)
        {
            fileName = sFileName;
            
            // Load a map from the definition file.              
            MapLoader.LoadMap(sFileName, this);
        }

        /// <summary>
        /// Returns a list of AI player position when the map first starts.
        /// </summary>        
        public IList<TileCoordinates> AIPositions
        {
            get { return aiPositions.AsReadOnly(); }
        }

        /// <summary>
        /// Returns a position of the human player when the map first starts.
        /// </summary>
        public TileCoordinates HumanPosition
        {
            get { return humanPosition; }
        }

        /// <summary>
        /// Load a new tileset from a file and add it to the tileset list. 
        /// Each tileset must be the same size, and all tiles must be the same size.
        /// </summary>
        /// <param name="sFileName">Path to the definition file.</param>
        /// <param name="iTileWidth">Width of the tiles.</param>
        /// <param name="iTileHeight">Heigh of the tiles.</param>
        /// <param name="iHorizontalSpacing">Horizontal spacing between tiles.</param>
        /// <param name="iVerticalSpacing">Vertical spacing between tiles.</param>
        public void AddTileset(string sFileName, int iTileWidth, int iTileHeight, int iHorizontalSpacing, int iVerticalSpacing)
        {
            TileSet NewTileSet = new TileSet();            
            NewTileSet.t2dTexture = Renderer.content.Load<Texture2D>("_textures/spriteSheet");
            NewTileSet.mapFileName = sFileName;
            NewTileSet.tileWidth = iTileWidth;
            NewTileSet.tileHeight = iTileHeight;
            NewTileSet.horizontalSpacing = iHorizontalSpacing;
            NewTileSet.verticalSpacing = iVerticalSpacing;
            NewTileSet.tilesPerRow = NewTileSet.t2dTexture.Width /
                                     (NewTileSet.tileWidth + NewTileSet.horizontalSpacing);
            tileSets.Add(NewTileSet);
            tileSetCount++;            
        }


        /// <summary>
        /// Converts tile coordinates to screen pixel coordinates.
        /// </summary>
        /// <param name="x">Tile X coordinate.</param>
        /// <param name="y">Tile Y coordinate.</param>
        public TileCoordinates TileToScreenPixels(int x, int y)
        {
        	// Calculate coordinates based on what part of the map is showing
            int newX = (x - DisplayedMapX) * TileWidth - DisplayedMapSubtileX + DisplayedMapLeft;
            int newY = (y - DisplayedMapY) * TileHeight - DisplayedMapSubtileY + DisplayedMapTop;
            return new TileCoordinates(newX, newY);
        }

        /// <summary>
        /// Converts tile coordinates to absolute screen pixel coordinates.
        /// </summary>
        /// <param name="x">Tile X coordinate.</param>
        /// <param name="y">Tile Y coordinate.</param>
        public TileCoordinates TileToAbsolutePixels(int x, int y)
        {
            int newX = x * TileWidth;
            int newY = y * TileHeight;
            return new TileCoordinates(newX, newY);
        }

        private class BoundingCorners
        {
            TileCoordinates topLeft, topRight, bottomRight, bottomLeft;
            BoundingCorners(TileCoordinates topLeft, TileCoordinates topRight, TileCoordinates bottomLeft, TileCoordinates bottomRight)
            {
                this.topLeft = topLeft;
                this.topRight = topRight;
                this.bottomLeft = bottomLeft;
                this.bottomRight = bottomRight;
            }

            static BoundingCorners Calculate(Human player, WorldMap map)
            {
                TileCoordinates topLeft = map.AbsolutePixelToTile((int)(player.position.X), (int)(player.position.Y));
                TileCoordinates topRight = map.AbsolutePixelToTile((int)(player.position.X) + (int)player.texture.Width, (int)(player.position.Y));
                TileCoordinates bottomRight = map.AbsolutePixelToTile((int)(player.position.X) + (int)player.texture.Width, (int)(player.position.Y) + (int)player.texture.Height);
                TileCoordinates bottomLeft = map.AbsolutePixelToTile((int)(player.position.X), (int)(player.position.Y) + (int)player.texture.Height);

                return new BoundingCorners(topLeft, topRight, bottomLeft, bottomRight);
            }
        }

        public bool IsOnOneTile(Human player)
        {
            TileCoordinates topLeft = AbsolutePixelToTile((int)(player.position.X), (int)(player.position.Y));
            TileCoordinates topRight = AbsolutePixelToTile((int)(player.position.X) + (int)player.texture.Width, (int)(player.position.Y));
            TileCoordinates bottomRight = AbsolutePixelToTile((int)(player.position.X) + (int)player.texture.Width, (int)(player.position.Y) + (int)player.texture.Height);
            TileCoordinates bottomLeft = AbsolutePixelToTile((int)(player.position.X), (int)(player.position.Y) + (int)player.texture.Height);

            return topLeft.Equals(topRight) &&
                topRight.Equals(bottomRight) &&
                bottomRight.Equals(bottomLeft);
        }

        public bool IsPartiallyOnTile(Human player, TileCoordinates tileCoordinates)
        {
            TileCoordinates topLeft = AbsolutePixelToTile((int)(player.position.X), (int)(player.position.Y));
            TileCoordinates topRight = AbsolutePixelToTile((int)(player.position.X) + (int)player.texture.Width, (int)(player.position.Y));
            TileCoordinates bottomRight = AbsolutePixelToTile((int)(player.position.X) + (int)player.texture.Width, (int)(player.position.Y) + (int)player.texture.Height);
            TileCoordinates bottomLeft = AbsolutePixelToTile((int)(player.position.X), (int)(player.position.Y) + (int)player.texture.Height);

            return tileCoordinates.Equals(topRight) ||
                tileCoordinates.Equals(topLeft) ||
                tileCoordinates.Equals(bottomRight) ||
                tileCoordinates.Equals(bottomLeft);
        }
           

        /// <summary>
        /// Converts absolute pixel coordinates to tile coordinates.
        /// </summary>
        /// <param name="x">Absolute pixel X coordinate.</param>
        /// <param name="y">Absolute pixel Y coordinate.</param>
        public TileCoordinates AbsolutePixelToTile(int x, int y)
        {
            int newX = x / TileWidth;
            int newY = y / TileHeight;            
            return new TileCoordinates(newX, newY);
        }

        /// <summary>
        /// Converts absolute pixel coordinates to tile coordinates.
        /// </summary>
        /// <param name="x">Absolute pixel X coordinate.</param>
        /// <param name="y">Absolute pixel Y coordinate.</param>
        public TileCoordinates AbsolutePixelToTile(Human player)
        {
            int newX = (int)player.position.X / TileWidth;
            int newY = (int)player.position.Y / TileHeight;
            return new TileCoordinates(newX, newY);
        }

        /// <summary>
        /// Converts absolute pixel coordinates to tile coordinates.
        /// </summary>
        /// <param name="x">Absolute pixel X coordinate.</param>
        /// <param name="y">Absolute pixel Y coordinate.</param>
        public TileCoordinates AbsolutePixelToTileRound(int x, int y)
        {
            int newX = x / TileWidth;
            if (x % TileWidth > TileWidth / 2) ++newX;

            int newY = y / TileHeight;
            if (y % TileHeight > TileHeight / 2) ++newY;

            return new TileCoordinates(newX, newY);
        }

        /// <summary>
        /// Converts absolute pixel coordinates to tile coordinates.
        /// </summary>
        /// <param name="x">Absolute pixel X coordinate.</param>
        /// <param name="y">Absolute pixel Y coordinate.</param>
        public TileCoordinates AbsolutePixelToCompleteTile(Human player)
        {
            TileCoordinates previousTile = AbsolutePixelToTileRound((int)player.lastPosition.X, (int)player.lastPosition.Y);

            // Bounding box of the player on the map
            TileCoordinates topLeft = AbsolutePixelToTile((int)(player.position.X), (int)(player.position.Y));
            TileCoordinates topRight = AbsolutePixelToTile((int)(player.position.X) + (int)player.texture.Width, (int)(player.position.Y));
            TileCoordinates bottomRight = AbsolutePixelToTile((int)(player.position.X) + (int)player.texture.Width, (int)(player.position.Y) + (int)player.texture.Height);
            TileCoordinates bottomLeft = AbsolutePixelToTile((int)(player.position.X), (int)(player.position.Y) + (int)player.texture.Height);

            if (topLeft.Equals(topRight) &&
                topRight.Equals(bottomRight) &&
                bottomRight.Equals(bottomLeft))
            {
                return topLeft;
            }
            else
            {
                return previousTile;
            }            
        }
        
        /// <summary>
        /// Converts absolute pixel coordinates to tile coordinates.
        /// </summary>
        /// <param name="fx">Absolute pixel X coordinate.</param>
        /// <param name="fy">Absolute pixel Y coordinate.</param>
        public TileCoordinates AbsolutePixelToTile(float fx, float fy)
        {        	
        	return AbsolutePixelToTile((int)fx, (int)fy);
        }

		/// <summary>
        /// Converts absolute pixel coordinates to screen pixel coordinates.
        /// </summary>
        /// <param name="fx">Absolute pixel X coordinate.</param>
        /// <param name="fy">Absolute pixel Y coordinate.</param>
        public TileCoordinates AbsolutePixelToScreenPixel(float fx, float fy)
        {
        	return AbsolutePixelToScreenPixel((int)fx, (int)fy);            
        }
        
        /// <summary>
        /// Converts absolute pixel coordinates to screen pixel coordinates.
        /// </summary>
        /// <param name="x">Absolute pixel X coordinate.</param>
        /// <param name="y">Absolute pixel Y coordinate.</param>
        public TileCoordinates AbsolutePixelToScreenPixel(int x, int y)
        {            
            int newX = x - (DisplayedMapX * TileWidth + DisplayedMapSubtileX) + DisplayedMapLeft;
            int newY = y - (DisplayedMapY * TileHeight + DisplayedMapSubtileY) + DisplayedMapTop;
            return new TileCoordinates(newX, newY);
        }

        /// <summary>
        /// Sets the current map location, providing the X,Y coordintate of the tile
        /// as well as the Sub-Tile pixel X and Y positions. If the coordinates make
        /// the map run off, they will be clamped.
        /// </summary>
        /// <param name="x">X coordinate of the tile.</param>
        /// <param name="y">Y coordinate of the tile.</param>
        /// <param name="subX">X pixel coordinate within the tile specified by X, Y</param>
        /// <param name="subY">Y pixel coordinate within the tile specified by X, Y</param>
        public void SetMapLocation(int x, int y, int subX, int subY)
        {
        	// Clam coodinates we we don;t run outside of the map
            ClampCoordinatesToFit(ref x, ref y, ref subX, ref subY);

            // Set current map coordinates
            currentMapTileX = x;
            currentMapTileY = y;
            displayedMapTileSubX = subX;
            displayedMapSubTileY = subY;
        }


        /// <summary>
        /// Centers map around tile with coordinates X and Y
        /// </summary>
        /// <param name="x">Tile X coordinate.</param>
        /// <param name="y">Tile Y coordinate.</param>
        public void CenterMap(int x, int y)
        {
        	// Calculate where the map display shoudl dtart based on 
        	// the desired center.
            int subX = 0, subY = 0;

            int offsetX = ((ResolutionWidth - TileWidth) / 2);
            int tileOffsetX = offsetX / TileWidth + 2;
            subX = TileWidth - offsetX % TileWidth;

            int offsetY = (ResolutionHeight - TileHeight) / 2;
            int tileOffsetY = offsetY / TileHeight + 2;
            subY = TileHeight - offsetY % TileHeight;

            // Set map location so it is centered
            SetMapLocation(x - tileOffsetX, y - tileOffsetY, subX, subY);
        }


        /// <summary>
        /// Clamps coordinates so they do not go off the map.
        /// </summary>
        /// <param name="x">Tile X coordinate.</param>
        /// <param name="y">Tile Y coordinate.</param>
        /// <param name="subX">SubTile X coordinate.</param>
        /// <param name="subY">SubTile Y coordinate.</param>
        private void ClampCoordinatesToFit(ref int x, ref int y, ref int subX, ref int subY)
        {
            TrueDisplaySize trueDisplaySize = GetTrueDisplaySize();

            if (x < 0)
            {
                x = 0;
                subX = 0;
            }
            else if ((x + trueDisplaySize.WidthInTiles) * TileWidth + subX > EntireMapWidth * TileWidth)
            {
                x = EntireMapWidth - trueDisplaySize.WidthInTiles - 1;
                subX = 0;               
            }

            if (y < 0)
            {
                y = 0;
                subY = 0;
            }
            else if ((y + trueDisplaySize.HeightInTiles) * TileHeight + subY > EntireMapHeight * TileHeight)
            {
                y = EntireMapHeight - trueDisplaySize.HeightInTiles - 1;
                subY = 0;                
            }
        }

        /// <summary>
        /// returns true display size.
        /// </summary> 
        /// <returns><code>TrueDisplaySize</code> object.</returns>       
        private TrueDisplaySize GetTrueDisplaySize()
        {
            TrueDisplaySize trueDisplaySize = new TrueDisplaySize();
            trueDisplaySize.WidthInTiles = (ResolutionWidth - DisplayedMapLeft) / TileWidth;
            trueDisplaySize.WidthInPixels = ResolutionWidth - DisplayedMapLeft;
            trueDisplaySize.HeightInTiles = (ResolutionHeight - DisplayedMapTop) / TileHeight;
            trueDisplaySize.HeightInPixels = ResolutionHeight - DisplayedMapTop;
            return trueDisplaySize;
        }


        /// <summary>
        /// Move the map by X pixels horizontally and Y pixels vertically. 
        /// If the movements makes the map run off, the scroll will not take place.
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        public void ScrollByPixels(int x, int y)
        {
            if (x == 0 && y == 0)
            {
                return;
            }

            // See if the scroll will make us run off the map.
            if (!CanScroll(0, 0, x, y))
            {
                return;
            }

            // Scroll
            displayedMapTileSubX += x;
            displayedMapSubTileY += y;
            while (displayedMapTileSubX >= tileWidth)
            {
                displayedMapTileSubX -= tileWidth;
                currentMapTileX++;
            }

            while (displayedMapSubTileY >= tileHeight)
            {
                displayedMapSubTileY -= tileHeight;
                currentMapTileY++;
            }

            while (displayedMapTileSubX < 0)
            {
                displayedMapTileSubX += tileWidth;
                currentMapTileX--;
            }

            while (displayedMapSubTileY < 0)
            {
                displayedMapSubTileY += tileHeight;
                currentMapTileY--;
            }

            if (currentMapTileX >= entireMapWidthInTiles)
            {
                currentMapTileX = entireMapWidthInTiles;
            }

            if (currentMapTileX < 0)
            {
                currentMapTileX = 0;
            }

            if (currentMapTileY >= entireMapHeightInTiles)
            {
                currentMapTileY = entireMapHeightInTiles;
            }

            if (currentMapTileY < 0)
            {
                currentMapTileY = 0;
            }
        }

        /// <summary>
        /// Determines if the map can be scrolled in a specified direction without running off
        /// the map.
        /// </summary>
        /// <param name="x">Number of tiles to scroll in X direction.</param>
        /// <param name="y">Number of tiles to scroll in Y direction.</param>
        /// <param name="subX">Number of pixels to scroll in X direction.</param>
        /// <param name="subY">Number of pixels to scroll in Y direction.</param>
        /// <returns><code>true</code> if the map can be scrolled; <code>false</code> otherwise.</returns>
        public bool CanScroll(int x, int y, int subX, int subY)
        {
            return IsXCoordinateWithinDisplay(currentMapTileX + x, displayedMapTileSubX + subX) &&
                IsYCoordinateWithinDisplay(currentMapTileY + y, displayedMapSubTileY + subY);
        }

		/// <summary>
        /// Determines if the supllied X coordinates are within the map.
        /// </summary>
        /// <param name="x">Tile X coordinate.</param>
        /// <param name="subX">SubTile X coordinate.</param>    
        /// <returns><code>true</code> if the coordinate is within display; <code>false</code> otherwise.</returns>    		
        private bool IsXCoordinateWithinDisplay(int x, int subX)
        {
            return x * TileWidth + subX >= 0 && x * TileWidth + ResolutionWidth + subX < EntireMapWidth * TileWidth;
        }

        /// <summary>
        /// Determines if the supllied Y coordinates are within the map.
        /// </summary>
        /// <param name="y">Tile Y coordinate.</param>
        /// <param name="subY">SubTile Y coordinate.</param>
        /// <returns><code>true</code> if the coordinate is within display; <code>false</code> otherwise.</returns>
        private bool IsYCoordinateWithinDisplay(int y, int subY)
        {
            return y * TileHeight + subY >= 0 && y * TileHeight + ResolutionHeight + subY < EntireMapHeight * TileHeight;
        }

        /// <summary>
        /// Determines if the player can move to a tile position on the map.
        /// </summary>
        /// <param name="x">X coordinate of the tile.</param>
        /// <param name="y">Y coordinate of the tile.</param>
        /// <returns><code>true</code> if the tile is walkable; <code>false</code> otherwise.</returns>
        public bool IsWalkable(int x, int y)
        {
            if (x < 0 || x >= EntireMapWidth || y < 0 || y >= EntireMapHeight)
            {
                return false;
            }
            return GetMapWalkable(x, y) == Statics.MAP_WALKABLE_CHARACTER;
        }

        /// <summary>
        /// Determines if the player can move to a tile position on the map.
        /// </summary>
        /// <param name="tc">Tile coordinates of the player.</param>
        /// <returns><code>true</code> if the tile is walkable; <code>false</code> otherwise.</returns>
        public bool IsWalkable(TileCoordinates tc)
        {
            if (tc.X < 0 || tc.X >= EntireMapWidth || tc.Y < 0 || tc.Y >= EntireMapHeight)
            {
                return false;
            }
            return GetMapWalkable(tc.X, tc.Y) == Statics.MAP_WALKABLE_CHARACTER;
        }


        /// <summary>
        /// Edits current map data.
        /// </summary>
        /// <param name="x">X coordinate of the tile.</param>
        /// <param name="y">Y coordinate of the tile.</param>
        /// <param name="iBase">Base/Terrain layer value.</param>
        /// <param name="iTrans">Transition layer value.</param>
        /// <param name="iObj">Object layer value.</param>
        /// <param name="iData">Data layer value.</param>        
        public void EditMap(int x, int y, int iBase, int iTrans, int iObj, int iData)
        {
            map[y, x] = iBase;
            mapTrans[y, x] = iTrans;
            mapObj[y, x] = iObj;
            mapData[y, x] = iData;
        }

        /// <summary>
        /// Returns data in the terrain layer at position x, y.
        /// </summary>
        /// <param name="x">X coordinate of the tile.</param>
        /// <param name="y">Y coordinate of the tile.</param>
        /// <returns>Integer value in the terrain layer data.</returns>
        public int GetMapTerrain(int x, int y)
        {
            return map[y, x];
        }

        /// <summary>
        /// Returns data in the transition layer at position x, y.
        /// </summary>
        /// <param name="x">X coordinate of the tile.</param>
        /// <param name="y">Y coordinate of the tile.</param>
        /// <returns>Integer value in the transition layer data.</returns>
        public int GetMapTransition(int x, int y)
        {
            return mapTrans[y, x];
        }

        /// <summary>
        /// Returns data in the object layer at position x, y.
        /// </summary>
        /// <param name="x">X coordinate of the tile.</param>
        /// <param name="y">Y coordinate of the tile.</param>
        /// <returns>Integer value in the object layer data.</returns>
        public int GetMapObjects(int x, int y)
        {
            return mapObj[y, x];
        }

        /// <summary>
        /// Returns data in the walkable layer at position x, y.
        /// </summary>
        /// <param name="x">X coordinate of the tile.</param>
        /// <param name="y">Y coordinate of the tile.</param>
        /// <returns>Integer value in the walkable layer data.</returns>
        public int GetMapWalkable(int x, int y)
        {
            return mapData[y, x];
        }

        /// <summary>
        /// Returns the walkable layer.
        /// </summary>       
        /// <returns>Integer 2D array representing the walkable layer data.</returns>
        public int[,] GetMapWalkable()
        {
            return mapData;
        }


        /// <summary>
        /// Returns a rectangle representing the location on the tileset that 
        /// contains the requested tile.
        /// </summary>
        /// <param name="iTileNumber">Tile number.</param>        
        /// <returns><code>Rectangle</code> of the tile.</returns>
        private Rectangle GetTileRectangle(int iTileNumber)
        {
            // Returns a rectangle representing the location on the tileset that
            // contains the requested tile.
            // The 10000's digit determines the tileset number.  The remainder 
            // determines the tile within the set, so seperate out the remainder 
            // to determine where to pull the rectangle from.
            int iTile = iTileNumber % 10000;
            int iTileSet = iTileNumber / 10000;

            // Return a rectangle representing a location of a tile on the tileset
            return new Rectangle(
              (iTile % tileSets[iTileSet].tilesPerRow) * tileSets[iTileSet].tileWidth,
              (iTile / tileSets[iTileSet].tilesPerRow) * tileSets[iTileSet].tileHeight,
              tileSets[iTileSet].tileWidth,
              tileSets[iTileSet].tileHeight
            );
        }

        /// <summary>
        /// Determines if the coordinates specified are at the castle for the final map.        
        /// </summary>
        /// <param name="mapX">X coordinate on the map.</param>        
        /// <param name="mapY">Y coordinate on the map.</param>        
        /// <returns><code>true</code> if the coordinates are at a castle; <code>false</code> otherise.</returns>
        public bool IsAtCastle(int mapX, int mapY)
        {
            return mapX >= GetCastleStart();
        }

        /// <summary>
        /// Return X coordinate where the castle start on the final map.
        /// </summary>        
        /// <returns>X coordinate of the castle on the map.</returns>
        private int GetCastleStart()
        {
            if (fileName.Contains("king"))
            {
                for (int i = 0; i < this.EntireMapHeight; ++i)
                {
                    for (int j = 0; j < this.EntireMapWidth; ++j)
                    {
                        if (this.GetMapTerrain(j, i) == 8)
                        {
                            return j * this.TileWidth;
                        }
                    }
                }
            }
            return (this.EntireMapWidth + 5) * this.TileWidth;
        }

        /// <summary>
        /// Draws the map.
        /// </summary>
        /// <param name="gameTime">Game time.</param>
        public void Draw(GameTime gameTime)
        {
        	// Begin sprite batch
            Renderer.spriteBatch.Begin(SpriteBlendMode.None);

            // Draw the base layer of the map
            if (drawBase)
            {
                for (int y = 0; y < DisplayedMapHeight; y++)
                {
                    for (int x = 0; x < DisplayedMapWidth; x++)
                    {
                        tileXLoc = x + currentMapTileX;
                        tileYLoc = y + currentMapTileY;

                        // Account for map wrap-arounds
                        if (tileXLoc >= entireMapHeightInTiles)
                        {
                            tileXLoc -= entireMapWidthInTiles;                            
                        }

                        if (tileXLoc < 0)
                        {
                            tileXLoc += entireMapWidthInTiles;                            
                        }

                        if (tileYLoc >= entireMapHeightInTiles)
                        {
                            tileYLoc -= entireMapHeightInTiles;                            
                        }

                        if (tileYLoc < 0)
                        {
                            tileYLoc += entireMapHeightInTiles;                            
                        }

                        currentTileToDraw = map[tileYLoc, tileXLoc];

                        if (currentTileToDraw >= 0)
                        {
                            // Draw the tile.  We divide the tile number by 10000 to
                            // determine what tileset the tile is on (0-9999=tileset 0,
                            // 10000-19999=Tileset 2, etc)
                            Renderer.spriteBatch.Draw(tileSets[(currentTileToDraw / 10000)].t2dTexture,
                                             new Rectangle(((x * tileWidth) + DisplayedMapLeft) - displayedMapTileSubX,
                                             ((y * tileHeight) + DisplayedMapTop) - displayedMapSubTileY,
                                             tileSets[(currentTileToDraw / 10000)].tileWidth,
                                             tileSets[(currentTileToDraw / 10000)].tileHeight),
                                             GetTileRectangle(currentTileToDraw),
                                             Color.White);
                        }
                    }
                }
            }
            Renderer.spriteBatch.End();

            Renderer.spriteBatch.Begin(SpriteBlendMode.AlphaBlend);

            // Draw transitions and Objects layers of the map
            for (int y = 0; y < DisplayedMapHeight; y++)
            {
                for (int x = 0; x < DisplayedMapWidth; x++)
                {
                    Rectangle recDest = new Rectangle(((x * tileWidth) + DisplayedMapLeft) - displayedMapTileSubX,
                                         ((y * tileHeight) + DisplayedMapTop) - displayedMapSubTileY,
                                         tileSets[currentTileToDraw / 10000].tileWidth,
                                         tileSets[currentTileToDraw / 10000].tileHeight);

                    tileXLoc = x + currentMapTileX;
                    tileYLoc = y + currentMapTileY;
                    if (tileXLoc >= entireMapHeightInTiles)
                    {
                        tileXLoc -= entireMapWidthInTiles;                        
                    }

                    if (tileXLoc < 0)
                    {
                        tileXLoc += entireMapWidthInTiles;                        
                    }

                    if (tileYLoc >= entireMapHeightInTiles)
                    {
                        tileYLoc -= entireMapHeightInTiles;                        
                    }

                    if (tileYLoc < 0)
                    {
                        tileYLoc += entireMapHeightInTiles;                        
                    }

                    if (drawTrans)
                    {
                        currentTileToDraw = mapTrans[tileYLoc, tileXLoc];

                        if (currentTileToDraw >= 0 && ((currentTileToDraw >
                            tileSets[currentTileToDraw / 10000].tilesPerRow) || drawFirstRowTiles))
                        {
                            Renderer.spriteBatch.Draw(tileSets[currentTileToDraw / 10000].t2dTexture,
                                               recDest, GetTileRectangle(currentTileToDraw),
                                               Color.White);
                        }
                    }   

                   
                }
            }
            Renderer.spriteBatch.End();            
        }

        

        /// <summary>
        /// Class is resposible for loading data from map definition files. 
        /// </summary>        
        private class MapLoader
        {
            public static void LoadMap(string mapPath, WorldMap map)
            {
            	// Read data from the map definition file
                using (StreamReader sr = new StreamReader(mapPath))
                {
                    string line;
                    map.entireMapWidthInTiles = Convert.ToInt32(sr.ReadLine().Split('=')[1]);
                    map.entireMapHeightInTiles = Convert.ToInt32(sr.ReadLine().Split('=')[1]);
                    line = sr.ReadLine().Trim().Split('=')[1];
                    map.humanPosition = new TileCoordinates(Convert.ToInt32(line.Split(',')[0]), Convert.ToInt32(line.Split(',')[1]));
                    line = sr.ReadLine().Trim().Split('=')[1];
                    map.aiPositions.Add(new TileCoordinates(Convert.ToInt32(line.Split(',')[0]), Convert.ToInt32(line.Split(',')[1])));
                    line = sr.ReadLine().Trim().Split('=')[1];
                    map.aiPositions.Add(new TileCoordinates(Convert.ToInt32(line.Split(',')[0]), Convert.ToInt32(line.Split(',')[1])));
                    line = sr.ReadLine().Trim().Split('=')[1];
                    map.aiPositions.Add(new TileCoordinates(Convert.ToInt32(line.Split(',')[0]), Convert.ToInt32(line.Split(',')[1])));
                  
                    map.map = new int[map.entireMapHeightInTiles, map.entireMapWidthInTiles];
                    map.mapTrans = new int[map.entireMapHeightInTiles, map.entireMapWidthInTiles];
                    map.mapObj = new int[map.entireMapHeightInTiles, map.entireMapWidthInTiles];
                    map.mapData = new int[map.entireMapHeightInTiles, map.entireMapWidthInTiles];


                    int arrayNumber = -1;
                    int rowNumber = 0;
                    
                    while ((line = sr.ReadLine()) != null)
                    {
                        line = line.Trim();
                        if (line.Length == 0 || line.StartsWith("//"))
                        {
                            if (line.IndexOf("// Terrain layer") >= 0)
                            {
                                arrayNumber = 0;
                            }
                            else if (line.IndexOf("// Transition layer") >= 0)
                            {
                                arrayNumber = 1;
                            }
                            else if (line.IndexOf("// Object layer") >= 0)
                            {
                                arrayNumber = 2;
                            }
                            else if (line.IndexOf("// Is map walkable") >= 0)
                            {
                                arrayNumber = 3;
                            }
                            else
                            {
                                arrayNumber = -1;
                            }

                            if (rowNumber != 0 && rowNumber != map.entireMapHeightInTiles)
                            {
                                throw new Exception("Invalid definition file. Too many or too little rows in the file.");
                            }
                            rowNumber = 0;

                            continue;
                        }

                        if (arrayNumber == 0)
                        {
                            LoadArray(map.map, rowNumber, line, map);
                            ++rowNumber;
                        }
                        else if (arrayNumber == 1)
                        {
                            LoadArray(map.mapTrans, rowNumber, line, map);
                            ++rowNumber;
                        }
                        else if (arrayNumber == 2)
                        {
                            LoadArray(map.mapObj, rowNumber, line, map);
                            ++rowNumber;
                        }
                        else if (arrayNumber == 3)
                        {
                            LoadArray(map.mapData, rowNumber, line, map);
                            ++rowNumber;
                        }
                    }
                    sr.Close();
                }

     
                }
            

            /// <summary>
            /// Loads the 2D array with values form a comma separated list of values in 
            /// a string.
            /// </summary>
            /// <param name="array">2D array to load.</param>        
            /// <param name="rowNumber">Row number in which to store the values.</param>        	        
            /// <param name="line">LIne of text containing comma separated values.</param> 
            /// <param name="screen">Screen object.</param> 
            private static void LoadArray(int[, ] array, int rowNumber, string line, WorldMap screen)
            {
            	// Split into comma separated values
                string[] values = line.Split(new char[] { ',' });
                
                // Check the appropriate length
                if (values.Length != screen.entireMapWidthInTiles)
                {
                    throw new Exception("Invalid definition file. Too many or too little values on the line)");
                }

                // Load the row
                for (int j = 0; j < values.Length; ++j)
                {
                    array[rowNumber, j] = int.Parse(values[j]);
                    
                }
            }
        }       
        
        #region Properties
        /// <summary>
        /// Resolution width.
        /// </summary>
        public int ResolutionWidth
        {
            get { return resolutionWidth; }
            set
            {
                resolutionWidth = (int)(value * (1.0f - 2 * Statics.XBOX_CUT));                
            }
        }

        /// <summary>
        /// Resolution height.
        /// </summary>
        public int ResolutionHeight
        {
            get { return resolutionHeight; }
            set { resolutionHeight = (int)(value * (1.0f - 2 * Statics.XBOX_CUT)); }
        }


        /// <summary>
        /// Left pixel position of the tile engine drawing area on the display.
        /// </summary>
        public int DisplayedMapLeft
        {
            get { return (int)(ResolutionWidth * Statics.XBOX_CUT); }
        }

        /// <summary>
        /// Top pixel position of the tile engine drawing area on the display.
        /// </summary>
        public int DisplayedMapTop
        {
            get { return (int)(ResolutionHeight * Statics.XBOX_CUT); }            
        }

        /// <summary>
        /// Width of the display in tiles.
        /// </summary>
        public int DisplayedMapWidth
        {
            get { return ResolutionWidth / TileWidth + 2; }            
        }

        /// <summary>
        /// Height of the display in tiles.
        /// </summary>
        public int DisplayedMapHeight
        {
            get { return ResolutionHeight / TileHeight + 2; }           
        }

        /// <summary>
        /// Width of an individual tile in pixels.
        /// </summary>
        public int TileWidth
        {
            get { return this.tileWidth; }
            set { this.tileWidth = value; }
        }

        /// <summary>
        /// Height of an individual tile in pixels.
        /// </summary>
        public int TileHeight
        {
            // Determines the height of an individual tile in pixels.
            get { return this.tileHeight; }
            set { this.tileHeight = value; }
        }

        /// <summary>
        /// X value of the left-most displayed map tile.
        /// </summary>            
        public int DisplayedMapX
        {
            get { return this.currentMapTileX; }
            set { this.currentMapTileX = value; }
        }

        /// <summary>
        /// Sub-tile X value of the left-most displayed map tile.
        /// </summary>  
        public int DisplayedMapSubtileX
        {
            get { return displayedMapTileSubX; }
        }

        /// <summary>
        /// Y value of the left-most displayed map tile.
        /// </summary> 
        public int DisplayedMapY
        {
            get { return this.currentMapTileY; }
            set { this.currentMapTileY = value; }
        }

        /// <summary>
        /// Sub-tile Y value of the left-most displayed map tile.
        /// </summary>
        public int DisplayedMapSubtileY
        {
            get { return displayedMapSubTileY; }
        }

        /// <summary>
        /// Width of the entire map in tiles.
        /// </summary>
        public int EntireMapWidth
        {
            get { return this.entireMapWidthInTiles; }
        }

        /// <summary>
        /// Height of the entire map in tiles.
        /// </summary>
        public int EntireMapHeight
        {            
            get { return this.entireMapHeightInTiles; }
        }

        /// <summary>
        /// Determines if base layer is visible.
        /// </summary>
        public bool BaseVisible
        {
            get { return this.drawBase; }
            set { this.drawBase = value; }
        }

        /// <summary>
        /// Determines if transition layer is visible.
        /// </summary>
        public bool TransVisible
        {
            get { return this.drawTrans; }
            set { this.drawTrans = value; }
        }

        /// <summary>
        /// Determines if object layer is visible.
        /// </summary>
        public bool ObjVisible
        {
            get { return this.drawObj; }
            set { this.drawObj = value; }
        }

        /// <summary>
        /// Determines wether to draw first row of tiles on a transition layer.
        /// </summary>
        public bool DrawFirstRowTilesOnTransLayers
        {
            get { return this.drawFirstRowTiles; }
            set { this.drawFirstRowTiles = value; }
        }
        #endregion        
    }

}