/*
 * Grid.cs
 * Authors: Mike Dapiran
 * Copyright (c) 2007-2008 Cornell University

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

using System;
using System.Collections.Generic;
using ColonySim.Structures;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Util;
using tAC_Engine.Graphics.Entities;

namespace ColonySim
{
	/// <summary>
	/// Represents a Grid that maps structures to two dimensional coordinates
	/// in space.
	/// </summary>
	class Grid
	{ 
		#region Constants

		// The base chance for a carrier to spawn from a structure
		private const double CHANCE_CARRIER_SPAWN = 1;

		#endregion

		#region Pools

		// The maximum number of road carriers
		private const int MAX_ROAD_CARRIERS = 100;

		// The maximum number of tube carriers
		private const int MAX_TUBE_CARRIERS = 100;

		// The number of road carriers to add per residential structure
		private const int ROAD_CARRIERS_PER_RES = 2;

		// The number of tube carriers to add per commercial structure
		private const int TUBE_CARRIERS_PER_COM = 2;

		/// <summary>
        /// The pool of road carriers to have access to
		/// </summary>
		private readonly Stack<RoadCarrier> mRoadCarrierPool = new Stack<RoadCarrier>();

		/// <summary>
		/// The pool of tube carriers to have access to
		/// </summary>
		private readonly Stack<TubeCarrier> mTubeCarrierPool = new Stack<TubeCarrier>();

		#endregion

		#region Fields

		// Structure array for the grid
		private readonly Structure[,] mReferenceGrid;
		private Resource[,] mResourceGrid;
		private readonly bool[,] mBuildAreaGrid;

		// List of the carriers that the grid has
		private readonly List<Carrier> mCarrierList;
		private readonly List<Carrier> mNewCarriers;

		// The internal status value for the Colony, used by the Grid
		private ColonySimStatusInformation mGridStatus = new ColonySimStatusInformation();

        // The content manager used for loading in content
		private readonly ContentManager mContent;
        
        // The model used for representing the grid
		private EntityModel mGridModel;

        // Whether or not the build area should be drawn
        private bool mDrawBuildArea;

        /// <summary>
        /// The number of polygons being drawn
        /// </summary>
        internal int numPolygons;

		/// <summary>
		/// The lists of structures by type in the grid.
		/// </summary>
		List<Structure> mMiningPlants = new List<Structure>();
		List<Structure> mResidentials = new List<Structure>();
		List<Structure> mFactories = new List<Structure>();
		List<Structure> mCommercials = new List<Structure>();
		List<Structure> mEntertainments = new List<Structure>();
		List<Structure> mCommandCenters = new List<Structure>();
		
		#endregion

		#region Properties

        /// <summary>
        /// Gets/Sets the grid model
        /// </summary>
        public EntityModel GridModel
        {
            get { return mGridModel; }
            set
            {
                mGridModel = value;
                mGridModel.Model.Meshes[0].Effects[0].Parameters["GridDimensions"].SetValue(new Vector2(mReferenceGrid.GetLength(0), mReferenceGrid.GetLength(1)));
            }
        }

        /// <summary>
        /// Gets/Sets the draw build area
        /// </summary>
        public bool DrawBuildArea
        {
            get { return mDrawBuildArea; }
            set { mDrawBuildArea = value; }
        }

		/// <summary>
		/// Gets/Sets the status information for the grid, which is
		/// exposed to be exploited by the ColonySim.
		/// </summary>
		public ColonySimStatusInformation StatusInfo
		{
			get { return mGridStatus; }
			set { mGridStatus = value; }
		}

		/// <summary>
		/// Gets the bounds of the grid.
		/// </summary>
		public Rectangle GridBounds { get { return new Rectangle( 0, 0, mReferenceGrid.GetLength(0), mReferenceGrid.GetLength(1)); } }

		/// <summary>
		/// Gets the Vector position at the grid's center.
		/// </summary>
		public Vector2 GridCenter { get { return new Vector2(mReferenceGrid.GetLength(0) / 2f, mReferenceGrid.GetLength(1) / 2f); } }

		/// <summary>
		/// Gets a list of the current structures in the Grid.
		/// </summary>
		public List<Structure> GridStructures
		{
			get
			{
				List<Structure> returnList = new List<Structure>();
				foreach (Structure s in mReferenceGrid)
				{
					if (s != null && !returnList.Contains(s))
						returnList.Add(s);
				}
				return returnList;
			}
		}

		
		/// <summary>
		/// Gets a copy of the list of carriers that the Grid has.
		/// </summary>
		public List<Carrier> GridCarriers { get { return mCarrierList; } }

		/// <summary>
		/// Gets only the carriers which are the new list. When it returns,
		/// it clears the list of the current carriers available.
		/// </summary>
		public Carrier[] NewCarriers { get { Carrier[] retVal = mNewCarriers.ToArray(); mNewCarriers.Clear(); return retVal; } }

		/// <summary>
		/// Gets the number of player placed structures.
		/// </summary>
		public int PlayerStructures
		{
			get
			{
				// Set the return value
				int retVal = 0;
				// Go through all of the structures
				foreach (Structure s in mReferenceGrid)
				{
					// If it's a tube or hub
					if (s is Tube /*|| s is Hub*/)
					{
						// Increment the counter
						retVal++;
					}
				}
				// Return
				return retVal;
			}
        }

        /// <summary>
        /// Access to the grid at the given grid location.
        /// </summary>
        public Structure this[Point p]
        {
            get { return GridContents(p); }
            set
            {
                if (value != null)
                {
                    AddStructure(value, p);
                }
                else
                {
                    RemoveStructure(p);
                }
            }
        }

        /// <summary>
        /// Access to the grid at the given grid location.
        /// </summary>
        public Structure this[int x, int y]
        {
            get { return GridContents(new Point(x, y)); }
            set
            {
                if (value != null)
                {
                    AddStructure(value, new Point(x, y));
                }
                else
                {
                    RemoveStructure(new Point(x, y));
                }
            }
        }

        #endregion

        #region Lighting Modifiers

        /// <summary>
        /// Raises the specular lighting intensity
        /// </summary>
        public void RaiseSpecularIntensity()
		{
			foreach (Structure s in mReferenceGrid)
			{
				if (s is TransportStructure)
				{
					s.SpecularIntensity += .05f;
					s.ReloadModel();
				}
			}
		}

        /// <summary>
        /// Lowers the specular lighting intensity
        /// </summary>
		public void LowerSpecularIntensity()
		{
			foreach (Structure s in mReferenceGrid)
			{
				if (s is TransportStructure)
				{
					s.SpecularIntensity -= .05f;
					s.ReloadModel();
				}
			}
		}

        /// <summary>
        /// Raises the specular lighting power
        /// </summary>
		public void RaiseSpecularPower()
		{
			foreach (Structure s in mReferenceGrid)
			{
				if (s is TransportStructure)
				{
					s.SpecularPower += .05f;
					s.ReloadModel();
				}
			}
		}

        /// <summary>
        /// Lowers the specular lighting power
        /// </summary>
		public void LowerSpecularPower()
		{
			foreach (Structure s in mReferenceGrid)
			{
				if (s is TransportStructure)
				{
					s.SpecularPower -= .05f;
					s.ReloadModel();
				}
			}
        }

        #endregion

        #region Constructs

        /// <summary>
        /// Base constructor
        /// </summary>
        /// <param name="pWidth">The width of the grid.</param>
        /// <param name="pHeight">The height of the grid.</param>
        /// <param name="pContent">The content manager to use.</param>
        /// <param name="pResSpawnNumbers">The respource grid spawner</param>
		public Grid(int pWidth, int pHeight, ContentManager pContent, ResourceSpawnNumbers pResSpawnNumbers)
		{
			// Initialize the grid and list
			mReferenceGrid = new Structure[pWidth, pHeight];
			mResourceGrid = pResSpawnNumbers.GenerateResourceGrid(pWidth, pHeight);
			mBuildAreaGrid = new bool[pWidth, pHeight];
			mCarrierList = new List<Carrier>();
			mNewCarriers = new List<Carrier>();
			mContent = pContent;
			//// Generate the carrier pools
			//for (int i = 0; i < MAX_ROAD_CARRIERS; i++)
			//{
			//    mRoadCarrierPool.Push(new RoadCarrier(false, mContent,
			//        @"Models\Vehicle_No_Guns_Mod", @"Textures\BluePixel", this));
			//}
			//for (int i = 0; i < MAX_TUBE_CARRIERS; i++)
			//{
			//    mTubeCarrierPool.Push(new TubeCarrier(false, ResourceCode.A0,
			//        mContent, @"Models\Vehicle_No_Guns_Mod", @"Textures\GreenPixel", this));
			//}
		}

		/// <summary>
		/// Base constructor
		/// </summary>
		/// <param name="pWidth">The width of the grid.</param>
		/// <param name="pHeight">The height of the grid.</param>
		/// <param name="pContent">The content manager to use.</param>
		public Grid(int pWidth, int pHeight, ContentManager pContent)
			: this(pWidth, pHeight, pContent, new ResourceSpawnNumbers()) { }

		#endregion

        #region Getters

        /// <summary>
        /// Gets the list of resource models
        /// </summary>
        /// <param name="pContent">Reference to the current content manager</param>
        /// <returns>The list of resource models</returns>
        public List<DrawableGameScreenComponent> GetResourceModels(ContentManager pContent)
        {
            List<DrawableGameScreenComponent> returnList = new List<DrawableGameScreenComponent>();
            for (int i = 0; i < mResourceGrid.GetLength(0); i++)
            {
                for (int j = 0; j < mResourceGrid.GetLength(1); j++)
                {
                    if (mResourceGrid[i, j] != null)
                    {
                        switch (mResourceGrid[i, j].ResourceCode)
                        {
                            case ResourceCode.A1:
                                {
                                    Asteroid tempAst = new Asteroid(new Vector2(i + .5f, j + .5f), pContent);
                                    tempAst.ColorToAdd = Color.Red;
                                    returnList.Add(tempAst);
                                }
                                break;
                            case ResourceCode.B1:
                                returnList.Add(new Asteroid(new Vector2(i + .5f, j + .5f), pContent));
                                break;
                            case ResourceCode.B0:
                                {
                                    Asteroid tempAst = new Asteroid(new Vector2(i + .5f, j + .5f), pContent);
                                    tempAst.ColorToAdd = Color.Blue;
                                    returnList.Add(tempAst);
                                }
                                break;
                            case ResourceCode.C0:
                                {
                                    Asteroid tempAst = new Asteroid(new Vector2(i + .5f, j + .5f), pContent);
                                    tempAst.ColorToAdd = Color.Green;
                                    returnList.Add(tempAst);
                                }
                                break;
                            case ResourceCode.A0:
                                {
                                    Asteroid tempAst = new Asteroid(new Vector2(i + .5f, j + .5f), pContent);
                                    tempAst.ColorToAdd = Color.Yellow;
                                    returnList.Add(tempAst);
                                }
                                break;
                        }
                    }
                }
            }
            return returnList;
        }

        /// <summary>
        /// Gets all the structures within the current game grid
        /// </summary>
        /// <returns>The list of structures within the current game grid</returns>
        public List<Structure> GetAllStructures()
        {
            List<Structure> returnList = new List<Structure>();
            foreach (Structure s in mReferenceGrid)
            {
				if (s != null && !returnList.Contains(s))
				{
					returnList.Add(s);
				}
            }
            return returnList;
        }

		///// <summary>
		///// Get a list of all structures directly adjacent to the given structure.
		///// </summary>
		//[Obsolete("Only correct for 1x1 buildings")]
		//private List<Structure> Neighbors(GridComponent pStruct)
		//{
		//    Point pLocation = pStruct.GridPosition;
		//    Point newPoint;
		//    Structure neighbor;
		//    List<Structure> ret = new List<Structure>();
		//    newPoint = new Point(pLocation.X + 1, pLocation.Y);
		//    neighbor = this[newPoint];
		//    if (neighbor != null)
		//    {
		//        ret.Add(neighbor);
		//    }
		//    newPoint = new Point(pLocation.X - 1, pLocation.Y);
		//    neighbor = this[newPoint];
		//    if (neighbor != null)
		//    {
		//        ret.Add(neighbor);
		//    }
		//    newPoint = new Point(pLocation.X, pLocation.Y + 1);
		//    neighbor = this[newPoint];
		//    if (neighbor != null)
		//    {
		//        ret.Add(neighbor);
		//    }
		//    newPoint = new Point(pLocation.X, pLocation.Y - 1);
		//    neighbor = this[newPoint];
		//    if (neighbor != null)
		//    {
		//        ret.Add(neighbor);
		//    }
		//    return ret;
		//}

        /// <summary>
        /// Returns a list of the specific type of structures.
        /// </summary>
        /// <param name="pType">The type of structure we want.</param>
        public List<Structure> GetSpecificStructures(Type pType)
        {
			// The return value
			List<Structure> retVal = new List<Structure>();

			// Switch on the type
			if (pType == typeof(MiningPlant))
			{
				retVal = mMiningPlants;
			}
			else if (pType == typeof(Residential))
			{
				retVal = mResidentials;
			}
			else if (pType == typeof(Commercial))
			{
				retVal = mCommercials;
			}
			else if (pType == typeof(Factory))
			{
				retVal = mFactories;
			}
			else if (pType == typeof(Entertainment))
			{
				retVal = mEntertainments;
			}
			else if (pType == typeof(CommandPost))
			{
				retVal = mCommandCenters;
			}	
            // Return the list
            return retVal;
        }

        /// <summary>
        /// Gets the neighbors of the specified point that are of the given structure type
        /// </summary>
        /// <param name="position">The specified point in the grid</param>
        /// <param name="structureType">The type of stucture to look for</param>
        /// <returns>The neighbors of the specified point that are of the given structure type</returns>
        public Dictionary<Carrier.Directions, Structure> GetNeighborsForRoad(Point position, Type structureType)
        {
            Dictionary<Carrier.Directions, Structure> neighborList = new Dictionary<Carrier.Directions, Structure>();
            if (position.X + 1 < mReferenceGrid.GetLength(0) && structureType.IsInstanceOfType(mReferenceGrid[position.X + 1, position.Y]))
                neighborList.Add(Carrier.Directions.Positive_X, mReferenceGrid[position.X + 1, position.Y]);
            if (position.Y + 1 < mReferenceGrid.GetLength(1) && structureType.IsInstanceOfType(mReferenceGrid[position.X, position.Y + 1]))
                neighborList.Add(Carrier.Directions.Positive_Y, mReferenceGrid[position.X, position.Y + 1]);
            if (position.X - 1 >= 0 && structureType.IsInstanceOfType(mReferenceGrid[position.X - 1, position.Y]))
                neighborList.Add(Carrier.Directions.Negative_X, mReferenceGrid[position.X - 1, position.Y]);
            if (position.Y - 1 >= 0 && structureType.IsInstanceOfType(mReferenceGrid[position.X, position.Y - 1]))
                neighborList.Add(Carrier.Directions.Negative_Y, mReferenceGrid[position.X, position.Y - 1]);
            return neighborList;
        }

		public Dictionary<Carrier.Directions, Structure> GetNeighborsForIntersection(Point position, Type structureType)
		{
			RoadTubeCrossing current = mReferenceGrid[position.X, position.Y] as RoadTubeCrossing;
			
			if (current == null)
				return null;

			Dictionary<Carrier.Directions, Structure> returnDic = new Dictionary<Carrier.Directions, Structure>();
			if (structureType == typeof(Road))
			{
				if (current.RoadAlongX)
				{
					if (position.X + 1 < mReferenceGrid.GetLength(0) && mReferenceGrid[position.X + 1, position.Y] is Road)
					{
						returnDic.Add(Carrier.Directions.Positive_X, mReferenceGrid[position.X + 1, position.Y]);
					}
					if (position.X - 1 >= 0 && mReferenceGrid[position.X - 1, position.Y] is Road)
					{
						returnDic.Add(Carrier.Directions.Negative_X, mReferenceGrid[position.X - 1, position.Y]);
					}
				}
				else
				{
					if (position.Y + 1 < mReferenceGrid.GetLength(1) && mReferenceGrid[position.X, position.Y + 1] is Road)
					{
						returnDic.Add(Carrier.Directions.Positive_Y, mReferenceGrid[position.X, position.Y + 1]);
					}
					if (position.Y - 1 >= 0 && mReferenceGrid[position.X, position.Y - 1] is Road)
					{
						returnDic.Add(Carrier.Directions.Negative_Y, mReferenceGrid[position.X, position.Y - 1]);
					}
				}
			}
			else if (structureType == typeof(Tube))
			{
				if (!current.RoadAlongX)
				{
					if (position.X + 1 < mReferenceGrid.GetLength(0) && mReferenceGrid[position.X + 1, position.Y] is Tube)
					{
						returnDic.Add(Carrier.Directions.Positive_X, mReferenceGrid[position.X + 1, position.Y]);
					}
					if (position.X - 1 >= 0 && mReferenceGrid[position.X - 1, position.Y] is Tube)
					{
						returnDic.Add(Carrier.Directions.Negative_X, mReferenceGrid[position.X - 1, position.Y]);
					}
				}
				else
				{
					if (position.Y + 1 < mReferenceGrid.GetLength(1) && mReferenceGrid[position.X, position.Y + 1] is Tube)
					{
						returnDic.Add(Carrier.Directions.Positive_Y, mReferenceGrid[position.X, position.Y + 1]);
					}
					if (position.Y - 1 >= 0 && mReferenceGrid[position.X, position.Y - 1] is Tube)
					{
						returnDic.Add(Carrier.Directions.Negative_Y, mReferenceGrid[position.X, position.Y - 1]);
					}
				}
			}

			return returnDic;
		}

        /// <summary>
        /// Gets the neighbors of the specified point
        /// </summary>
        /// <param name="position">The specified point in the grid</param>
        /// <returns>The neighbors of the specified point</returns>
        public Dictionary<Carrier.Directions, Structure> GetNeighborsForRoad(Point position)
        {
            Dictionary<Carrier.Directions, Structure> neighborList = new Dictionary<Carrier.Directions, Structure>();
            if (position.X + 1 < mReferenceGrid.GetLength(0) && mReferenceGrid[position.X + 1, position.Y] != null)
                neighborList.Add(Carrier.Directions.Positive_X, mReferenceGrid[position.X + 1, position.Y]);
            if (position.Y + 1 < mReferenceGrid.GetLength(1) && mReferenceGrid[position.X, position.Y + 1] != null)
                neighborList.Add(Carrier.Directions.Positive_Y, mReferenceGrid[position.X, position.Y + 1]);
            if (position.X - 1 >= 0 && mReferenceGrid[position.X - 1, position.Y] != null)
                neighborList.Add(Carrier.Directions.Negative_X, mReferenceGrid[position.X - 1, position.Y]);
            if (position.Y - 1 >= 0 && mReferenceGrid[position.X, position.Y - 1] != null)
                neighborList.Add(Carrier.Directions.Negative_Y, mReferenceGrid[position.X, position.Y - 1]);
            return neighborList;
        }

		public List<Structure> GetNeighbors(Structure structure)
		{
			List<Structure> returnList = new List<Structure>();

			int structureWidth = (int)structure.FootPrintSize.X;
			int structureHeight = (int)structure.FootPrintSize.Y;
			int gridWidth = mReferenceGrid.GetLength(0);
			int gridHeight = mReferenceGrid.GetLength(1);
			for (int i = structure.GridPosition.X; i < structure.GridPosition.X + structureWidth && i < gridWidth; i++)
			{
				if (structure.GridPosition.Y - 1 >= 0)
				{
					int yPosition = structure.GridPosition.Y - 1;
					if (mReferenceGrid[i, yPosition] != null)
					{
						returnList.Add(mReferenceGrid[i, yPosition]);
					}
				}
				if (structure.GridPosition.Y + structureHeight < gridHeight)
				{
					int yPosition = structure.GridPosition.Y + structureHeight;
					if (mReferenceGrid[i, yPosition] != null)
					{
						returnList.Add(mReferenceGrid[i, yPosition]);
					}
				}
			}
			for (int i = structure.GridPosition.Y; i < structure.GridPosition.Y + structureHeight && i < gridHeight; i++)
			{
				if (structure.GridPosition.X - 1 >= 0)
				{
					int xPosition = structure.GridPosition.X - 1;
					if (mReferenceGrid[xPosition, i] != null)
					{
						returnList.Add(mReferenceGrid[xPosition, i]);
					}
				}
				if (structure.GridPosition.X + structureWidth < gridWidth)
				{
					int xPosition = structure.GridPosition.X + structureWidth;
					if (mReferenceGrid[xPosition, i] != null)
					{
						returnList.Add(mReferenceGrid[xPosition, i]);
					}
				}
			}

			return returnList;
		}

		public List<Structure> GetNeighbors(Structure structure, Type structureToLookFor)
		{
			List<Structure> returnList = new List<Structure>();

			int structureWidth = (int)structure.FootPrintSize.X;
			int structureHeight = (int)structure.FootPrintSize.Y;
			int gridWidth = mReferenceGrid.GetLength(0);
			int gridHeight = mReferenceGrid.GetLength(1);
			for (int i = structure.GridPosition.X; i < structure.GridPosition.X + structureWidth && i < gridWidth; i++)
			{
				if (structure.GridPosition.Y - 1 >= 0)
				{
					int yPosition = structure.GridPosition.Y - 1;
					if (mReferenceGrid[i, yPosition] != null && structureToLookFor.IsInstanceOfType(mReferenceGrid[i, yPosition]))
					{
						returnList.Add(mReferenceGrid[i, yPosition]);
					}
				}
				if(structure.GridPosition.Y + structureHeight < gridHeight)
				{
					int yPosition = structure.GridPosition.Y + structureHeight;
					if(mReferenceGrid[i, yPosition] != null && structureToLookFor.IsInstanceOfType(mReferenceGrid[i, yPosition]))
					{
						returnList.Add(mReferenceGrid[i, yPosition]);
					}
				}
			}
			for (int i = structure.GridPosition.Y; i < structure.GridPosition.Y + structureHeight && i < gridHeight; i++)
			{
				if (structure.GridPosition.X - 1 >= 0)
				{
					int xPosition = structure.GridPosition.X - 1;
					if (mReferenceGrid[xPosition, i] != null && structureToLookFor.IsInstanceOfType(mReferenceGrid[xPosition, i]))
					{
						returnList.Add(mReferenceGrid[xPosition, i]);
					}
				}
				if(structure.GridPosition.X + structureWidth < gridWidth)
				{
					int xPosition = structure.GridPosition.X + structureWidth;
					if (mReferenceGrid[xPosition, i] != null && structureToLookFor.IsInstanceOfType(mReferenceGrid[xPosition, i]))
					{
						returnList.Add(mReferenceGrid[xPosition,i]);
					}
				}
			}

			return returnList;
		}

		/// <summary>
		/// Gets the worldspace coordinates of the center of the grid square.
		/// </summary>
		/// <param name="mWorldSpace">The ray striking position on the plane.</param>
		/// <returns>The center of the grid square.</returns>
		public Vector3 CenterOfGridSquare(Vector3 mWorldSpace)
        {
            return new Vector3(
                (float)Math.Floor(mWorldSpace.X) + .5f,
                0,
                (float)Math.Floor(mWorldSpace.Z) + .5f);
        }

        /// <summary>
        /// Gets the center of the model, based on a given position in
        /// worldspace and a given structure.
        /// </summary>
        /// <param name="mWorldSpace">The position in worldspace</param>
        /// <param name="pStructure">The structure</param>
        /// <returns>The location of the model's center in worldspace</returns>
        public Vector3 CenterOfModel(Vector3 mWorldSpace, Structure pStructure)
        {
			Vector3 returnVect = Vector3.Zero;
			//if (pStructure.FootPrintSize.X % 2 == 0)
			//{
				returnVect.X = (float)Math.Floor(mWorldSpace.X) + (pStructure.FootPrintSize.X/2);
			//}
			//else
			//{
			//	returnVect.X = (float)(Math.Floor(mWorldSpace.X) + (pStructure.FootPrintSize.X/2.0));
			//}

			//if (pStructure.FootPrintSize.Y % 2 == 0)
			//{
				returnVect.Z = (float)(Math.Floor(mWorldSpace.Z) + (pStructure.FootPrintSize.Y/2));
			//}
			//else
			//{
			//	returnVect.Z = (float)(Math.Floor(mWorldSpace.Z) + (pStructure.FootPrintSize.Y/2) +  0.5f);
			//}

			returnVect.Y = 0;
			return returnVect;
        }

        /// <summary>
        /// Returns the contents of the grid at the given grid location.
        /// </summary>
        /// <param name="pLocation">The current location on the grid.</param>
        public Structure GridContents(Point pLocation)
        {
            try
            {
                return mReferenceGrid[pLocation.X, pLocation.Y];
            }
            catch
            {
#if DEBUG
                Console.WriteLine("Outside of Grid");
#endif
                return null;
            }
        }

        /// <summary>
        /// Returns the direction in which the transport structure running
        /// </summary>
        /// <param name="position">Position in the current game grid</param>
        /// <param name="transportStructure">Reference to teh transport structure</param>
        /// <returns>The direction in which the transport structure running</returns>
        internal TransportStructure.Runnings getProperRunningForTransportStructure(Point position, Type transportStructure)
        {
			List<Type> connectableBuildings = new List<Type>();
			if(transportStructure == typeof(Road))
			{
				connectableBuildings.Add(typeof(Residential));
				connectableBuildings.Add(typeof(Commercial));
				connectableBuildings.Add(typeof(Entertainment));
			}
			else if (transportStructure == typeof(Tube))
			{
				connectableBuildings.Add(typeof(MiningPlant));
			}
			connectableBuildings.Add(typeof(Factory));

			Structure posXRef = null;
			Structure negXRef = null;
			Structure posYRef = null;
			Structure negYRef = null;

			if(position.X + 1 < mReferenceGrid.GetLength(0))
			{
				posXRef = mReferenceGrid[position.X + 1, position.Y];
			}
			if(position.X - 1 > 0)
			{
				negXRef = mReferenceGrid[position.X - 1, position.Y];
			}
			if(position.Y + 1 < mReferenceGrid.GetLength(1))
			{
				posYRef = mReferenceGrid[position.X, position.Y + 1];
			}
			if(position.Y - 1 > 0)
			{
				negYRef = mReferenceGrid[position.X, position.Y - 1];
			}

			if (position.X + 1 < mReferenceGrid.GetLength(0) && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X + 1, position.Y]) || ( posXRef != null && connectableBuildings.Contains(posXRef.GetType())) || 
				(mReferenceGrid[position.X + 1, position.Y] is RoadTubeCrossing &&
				((transportStructure == typeof(Road) && (mReferenceGrid[position.X + 1, position.Y] as RoadTubeCrossing).RoadAlongX)
				|| (transportStructure == typeof(Tube) && !(mReferenceGrid[position.X + 1, position.Y] as RoadTubeCrossing).RoadAlongX)))))
            {
                if (position.Y + 1 < mReferenceGrid.GetLength(1) && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X, position.Y + 1]) || ( posYRef != null &&connectableBuildings.Contains(posYRef.GetType())) ||
					(mReferenceGrid[position.X, position.Y + 1] is RoadTubeCrossing &&
					((transportStructure == typeof(Road) && !(mReferenceGrid[position.X, position.Y + 1] as RoadTubeCrossing).RoadAlongX)
					|| (transportStructure == typeof(Tube) && (mReferenceGrid[position.X, position.Y + 1] as RoadTubeCrossing).RoadAlongX)))))
                {
                    if (position.X - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X - 1, position.Y]) || ( negXRef != null && connectableBuildings.Contains(negXRef.GetType())) ||
						(mReferenceGrid[position.X - 1, position.Y] is RoadTubeCrossing &&
						((transportStructure == typeof(Road) && (mReferenceGrid[position.X - 1, position.Y] as RoadTubeCrossing).RoadAlongX)
						|| (transportStructure == typeof(Tube) && !(mReferenceGrid[position.X -1, position.Y] as RoadTubeCrossing).RoadAlongX)))))
                    {
                        if (position.Y - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X, position.Y - 1]) || ( negYRef != null && connectableBuildings.Contains(negYRef.GetType())) ||
							mReferenceGrid[position.X, position.Y - 1] is RoadTubeCrossing &&
							((transportStructure == typeof(Road) && !(mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX)
							|| (transportStructure == typeof(Tube) && (mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX))))
                        {
                            return TransportStructure.Runnings.Four_Way;
                        }
                        return TransportStructure.Runnings.Positive_Y;
                    }
                    if (position.Y - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X, position.Y - 1]) || ( negYRef != null && connectableBuildings.Contains(negYRef.GetType())) ||
						mReferenceGrid[position.X, position.Y - 1] is RoadTubeCrossing &&
						((transportStructure == typeof(Road) && !(mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX)
						|| (transportStructure == typeof(Tube) && (mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX))))
                    {
                        return TransportStructure.Runnings.Positive_X;
                    }
                    return TransportStructure.Runnings.PXPY;
                }
                if (position.X - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X - 1, position.Y]) || ( negXRef != null && connectableBuildings.Contains(negXRef.GetType())) ||
					mReferenceGrid[position.X - 1, position.Y] is RoadTubeCrossing &&
					((transportStructure == typeof(Road) && (mReferenceGrid[position.X - 1, position.Y] as RoadTubeCrossing).RoadAlongX)
					|| (transportStructure == typeof(Tube) && !(mReferenceGrid[position.X - 1, position.Y] as RoadTubeCrossing).RoadAlongX))))
                {
                    if (position.Y - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X, position.Y - 1]) || ( negYRef != null && connectableBuildings.Contains(negYRef.GetType())) ||
						mReferenceGrid[position.X, position.Y - 1] is RoadTubeCrossing &&
						((transportStructure == typeof(Road) && !(mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX)
						|| (transportStructure == typeof(Tube) && (mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX))))
                    {
                        return TransportStructure.Runnings.Negative_Y;
                    }
                    return TransportStructure.Runnings.X;
                }
                if (position.Y - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X, position.Y - 1]) || ( negYRef != null && connectableBuildings.Contains(negYRef.GetType())) ||
					mReferenceGrid[position.X, position.Y - 1] is RoadTubeCrossing &&
					((transportStructure == typeof(Road) && !(mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX)
					|| (transportStructure == typeof(Tube) && (mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX))))
                {
                    return TransportStructure.Runnings.PXNY;
                }
                // only one connection
                return TransportStructure.Runnings.X;
            }
            if (position.Y + 1 < mReferenceGrid.GetLength(1) && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X, position.Y + 1]) || ( posYRef != null && connectableBuildings.Contains(posYRef.GetType())) ||
				mReferenceGrid[position.X, position.Y + 1] is RoadTubeCrossing &&
				((transportStructure == typeof(Road) && !(mReferenceGrid[position.X, position.Y + 1] as RoadTubeCrossing).RoadAlongX
				|| (transportStructure == typeof(Tube) && (mReferenceGrid[position.X, position.Y + 1] as RoadTubeCrossing).RoadAlongX)))))
            {
                if (position.X - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X - 1, position.Y]) || ( negXRef != null && connectableBuildings.Contains(negXRef.GetType())) ||
					mReferenceGrid[position.X - 1, position.Y] is RoadTubeCrossing &&
					((transportStructure == typeof(Road) && (mReferenceGrid[position.X - 1, position.Y]as RoadTubeCrossing).RoadAlongX)
					|| (transportStructure == typeof(Tube) && !(mReferenceGrid[position.X - 1, position.Y] as RoadTubeCrossing).RoadAlongX))))
                {
                    if (position.Y - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X, position.Y - 1]) || ( negYRef != null && connectableBuildings.Contains(negYRef.GetType())) ||
						mReferenceGrid[position.X, position.Y - 1] is RoadTubeCrossing &&
						((transportStructure == typeof(Road) && !(mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX)
						|| (transportStructure == typeof(Tube) && (mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX))))
                    {
                        return TransportStructure.Runnings.Negative_X;
                    }
                    return TransportStructure.Runnings.NXPY;
                }
                if (position.Y - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X, position.Y - 1]) || ( negYRef != null && connectableBuildings.Contains(negYRef.GetType())) ||
					mReferenceGrid[position.X, position.Y - 1] is RoadTubeCrossing &&
					((transportStructure == typeof(Road) && !(mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX)
					|| (transportStructure == typeof(Tube) && (mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX))))
                {
                    return TransportStructure.Runnings.Y;
                }
                // only one connection
                return TransportStructure.Runnings.Y;
            }
            if (position.X - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X - 1, position.Y]) || ( negXRef != null && connectableBuildings.Contains(negXRef.GetType())) ||
				mReferenceGrid[position.X - 1, position.Y] is RoadTubeCrossing &&
				((transportStructure == typeof(Road) && (mReferenceGrid[position.X - 1, position.Y] as RoadTubeCrossing).RoadAlongX)
				|| (transportStructure == typeof(Tube) && !(mReferenceGrid[position.X - 1, position.Y] as RoadTubeCrossing).RoadAlongX))))
            {
                if (position.Y - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X, position.Y - 1]) || ( negYRef != null && connectableBuildings.Contains(negYRef.GetType())) ||
					mReferenceGrid[position.X, position.Y - 1] is RoadTubeCrossing &&
					((transportStructure == typeof(Road) && !(mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX)
					|| (transportStructure == typeof(Tube) && (mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX))))
                {
                    return TransportStructure.Runnings.NXNY;
                }
                // only on connection
                return TransportStructure.Runnings.X;
            }
            if (position.Y - 1 >= 0 && (transportStructure.IsInstanceOfType(mReferenceGrid[position.X, position.Y - 1]) || ( negYRef != null && connectableBuildings.Contains(negYRef.GetType())) ||
				mReferenceGrid[position.X, position.Y - 1] is RoadTubeCrossing &&
				((transportStructure == typeof(Road) && !(mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX)
				|| (transportStructure == typeof(Tube) && (mReferenceGrid[position.X, position.Y - 1] as RoadTubeCrossing).RoadAlongX))))
            {
                // only one connection
                return TransportStructure.Runnings.Y;
            }

            return TransportStructure.Runnings.Four_Way;
        }

        #endregion

        #region Setters

        /// <summary>
        /// Sets the build area's texture
        /// </summary>
        /// <param name="mDevice">Reference to the current graphics device</param>
        /// <returns>The build area's new texture</returns>
        public Texture2D SetBuildAreaTexture(GraphicsDevice mDevice)
        {
            Texture2D returnText = new Texture2D(mDevice, mReferenceGrid.GetLength(0), mReferenceGrid.GetLength(1), 0, TextureUsage.None, SurfaceFormat.Color);
            List<Color> temp = new List<Color>();
            for (int i = 0; i < mBuildAreaGrid.GetLength(0); i++)
            {
                for (int j = 0; j < mBuildAreaGrid.GetLength(1); j++)
                {
                    if (mBuildAreaGrid[j, i])
                        temp.Add(Color.White);
                    else
                        temp.Add(Color.TransparentBlack);
                }
            }
            returnText.SetData(temp.ToArray(), 0, temp.Count, SetDataOptions.Discard);
            mGridModel.Model.Meshes[0].Effects[0].Parameters["buildArea"].SetValue(returnText);
            return returnText;
        }

        #endregion

        #region Adders

        /// <summary>
        /// Place the carrier back into the carrier pools.
        /// </summary>
        /// <param name="pCarrier">The carrier to add back.</param>
        public void AddToCarrierPool(Carrier pCarrier)
        {
            // If it's not disposed
            if (!pCarrier.IsDisposed)
            {
                // Add the carrier
                if (pCarrier is RoadCarrier)
                {
                    // Add it back
                    mRoadCarrierPool.Push(pCarrier as RoadCarrier);
                }
                else if (pCarrier is TubeCarrier)
                {
                    // Add it back
                    mTubeCarrierPool.Push(pCarrier as TubeCarrier);
                }
            }
        }

        /// <summary>
        /// Adds the given structure to the given point on the grid
        /// </summary>
        /// <param name="pStructureToAdd">The stucture to add to the grid</param>
        /// <param name="pLocation">The point in the grid to add the structure to</param>
        /// <returns>Whether or not the structure could be added</returns>
		public bool AddStructure(Structure pStructureToAdd, Point pLocation)
		{
			// Get the return value
			bool retVal = AddStructure(pStructureToAdd, pLocation, mReferenceGrid, mResourceGrid);

			// If we did it
			if (retVal)
			{
				// Switch on the type
				if (pStructureToAdd is MiningPlant)
				{
					mMiningPlants.Add(pStructureToAdd);
				}
				else if (pStructureToAdd is Factory)
				{
					mFactories.Add(pStructureToAdd);
				}
				else if (pStructureToAdd is Residential)
				{
					mResidentials.Add(pStructureToAdd);
				}
				else if (pStructureToAdd is Commercial)
				{
					mCommercials.Add(pStructureToAdd);
				}
				else if (pStructureToAdd is Entertainment)
				{
					mEntertainments.Add(pStructureToAdd);
				}
				else if (pStructureToAdd is CommandPost)
				{
					mCommandCenters.Add(pStructureToAdd);
				}
			}

			// Return
			return retVal;
		}

        /// <summary>
        /// Add the given structure to the Grid
        /// </summary>
        /// <param name="pStructureToAdd">The structure to add</param>
        /// <param name="pLocation">The location to add the structure</param>
		/// <param name="pReferenceGrid">Reference to the current game grid</param>
		/// <param name="pResourceGrid">Reference to the resource grid</param>
        /// <returns>Whether or not the structure could be added</returns>
		public bool AddStructure(Structure pStructureToAdd, Point pLocation, Structure[,] pReferenceGrid, Resource[,] pResourceGrid)
		{
			// If we're not on the grid
			if (pLocation.X + pStructureToAdd.FootPrintSize.X >= pReferenceGrid.GetLength(0) || pLocation.X < 0 ||
			    pLocation.Y + pStructureToAdd.FootPrintSize.Y >= pReferenceGrid.GetLength(1) || pLocation.Y < 0)
			{
				// Abort
				return false;
			}
			// Check to see if we have enough space to be placed at the current location
			for (int i = pLocation.X; i < pLocation.X + pStructureToAdd.FootPrintSize.X; i++)
			{
				for (int j = pLocation.Y; j < pLocation.Y + pStructureToAdd.FootPrintSize.Y; j++)
				{
					// Something blocking a tile
					if (pReferenceGrid[i, j] != null || (pStructureToAdd.RequiresBuildArea && !mBuildAreaGrid[i, j]))
					{
						// So abort
						return false;
					}
				}
			}
			// Check to see if we're a mining plant
			MiningPlant miningPlant = pStructureToAdd as MiningPlant;
			if (miningPlant != null)
			{
				// If there's no resource here
				if (pResourceGrid[pLocation.X, pLocation.Y] == null)
				{
					// Mining planets can only be placed directly on resources.
					return false;
				}
				// Set our resource
				miningPlant.OutputResource = pResourceGrid[pLocation.X, pLocation.Y].ResourceCode;
			}
			// For each tile this building takes up.
			for (int i = pLocation.X ; i < pLocation.X + pStructureToAdd.FootPrintSize.X; i++)
			{
				for (int j = pLocation.Y; j < pLocation.Y + pStructureToAdd.FootPrintSize.Y; j++)
				{
					// Set it to be occupying those tiles.
					pReferenceGrid[i, j] = pStructureToAdd;	
				}
			}
			// Set its reference position
			pStructureToAdd.GridPosition = pLocation;
			pStructureToAdd.Register(this);
			// Set the build area flags in the radius around the building.
			int maxBuildAreaX = mBuildAreaGrid.GetLength(0);
			Point centerOfBuilding = new Point(pLocation.X + (int)(pStructureToAdd.FootPrintSize.X/2), pLocation.Y + (int)(pStructureToAdd.FootPrintSize.Y/2));
			for (int i = (centerOfBuilding.X - pStructureToAdd.BuildRadius < 0 ? 0 : centerOfBuilding.X - pStructureToAdd.BuildRadius);
			     i <= centerOfBuilding.X + pStructureToAdd.BuildRadius && i < maxBuildAreaX; i++)
			{
				int maxBuildAreaY = mBuildAreaGrid.GetLength(1);
				for (int j = (centerOfBuilding.Y - pStructureToAdd.BuildRadius < 0 ? 0 : centerOfBuilding.Y - pStructureToAdd.BuildRadius);
				     j <= centerOfBuilding.Y + pStructureToAdd.BuildRadius && j < maxBuildAreaY; j++)
				{
					mBuildAreaGrid[i, j] = true;
				}
			}
			pStructureToAdd.TransformationMatrix *= Matrix.CreateTranslation(new Vector3(pLocation.X + pStructureToAdd.FootPrintSize.X * 0.5f,
			                                                                             0, pLocation.Y + pStructureToAdd.FootPrintSize.Y * 0.5f));
			UpdateRoadmapFromNeighbors(pStructureToAdd);
			SetBuildAreaTexture(mGridModel.GraphicsDevice);

			// If it's residential or commercial
			if(pStructureToAdd is Residential)
			{
				// Generate the carrier pools
				for (int i = 0; i < ROAD_CARRIERS_PER_RES; i++)
				{
					mRoadCarrierPool.Push(new RoadCarrier(false, mContent,
						@"Models\transport02_FBX\transport02_FBX\transport_02", null, this));
					//mRoadCarrierPool.Peek().ColorToAdd = Color.LightBlue;
				}
			}
			else if (pStructureToAdd is MiningPlant)
			{
				// Generate the carrier pools
				for (int i = 0; i < TUBE_CARRIERS_PER_COM; i++)
				{
					mTubeCarrierPool.Push(new TubeCarrier(false, ResourceCode.A0,
						mContent, @"Models\transport02_FBX\transport02_FBX\transport_02", null, this));
					//mTubeCarrierPool.Peek().ColorToAdd = Color.Green;
				}
			}
			return true;
		}

		/// <summary>
		/// Adds the given Carrier to our list of carriers.
		/// </summary>
		/// <param name="pCarrier">The carrier to add</param>
		public void AddCarrier(Carrier pCarrier)
		{
			// Add the carrier to the list, if it doesn't contain it
			if (!mCarrierList.Contains(pCarrier))
			{
				// Add it to the list
				mCarrierList.Add(pCarrier);
				mNewCarriers.Add(pCarrier);
				pCarrier.Register(this);
			}

			// Set it's values
			pCarrier.Enabled = true;
			pCarrier.Visible = true;
			//pCarrier.UpdatePosition();
        }

        /// <summary>
        /// Adds a new random carrier somewhere in one of the legal spots in the current game grid
        /// </summary>
        /// <param name="Content">Reference to the current content manager</param>
        private void SpawnRandomCarriers(ContentManager Content)
        {
            foreach (Structure s in mReferenceGrid)
            {
                if (s is TransportStructure && Util.Random.NextDouble() <= CHANCE_CARRIER_SPAWN)
                {
                    if (s is Road && s.DistanceFromResidential == 1)
                    {
                        // If it's not null
                        if (mRoadCarrierPool.Count > 0)
                        {
                            RoadCarrier temp = mRoadCarrierPool.Pop();
                            temp.GridPosition = s.GridPosition;
                            temp.TowardsResidential = false;
                            temp.InitialTowardsResidential = false;
                            temp.TransformationMatrix = Matrix.CreateTranslation(s.TransformationMatrix.Translation);
                            temp.DrawOrder = s.DrawOrder - 1;
                            temp.RealignDirection();
                            temp.UpdateDirection();
                            AddCarrier(temp);
                        }
                    }
                    if (s is Tube)
                    {
                        Array resources = Enum.GetValues(typeof(ResourceCode));
                        for (int i = 0; i < resources.Length && mTubeCarrierPool.Count > 0; i++)
                        {
                            if (s.GetDistanceFromResource((int)resources.GetValue(i)) == 1)
                            {
                                TubeCarrier temp = mTubeCarrierPool.Pop();
                                temp.AssociatedResource = (ResourceCode)resources.GetValue(i);
                                temp.TowardsResource = false;
                                temp.InitialTowardsResource = false;
                                temp.GridPosition = s.GridPosition;
                                temp.TransformationMatrix = Matrix.CreateTranslation(s.TransformationMatrix.Translation);
                                temp.DrawOrder = s.DrawOrder - 1;
                                temp.RealignDirection();
                                temp.UpdateDirection();
                                AddCarrier(temp);
                            }
                        }
                    }
                }
            }
        }

        #endregion

        #region Removers

        /// <summary>
		/// Removes the structure at the given point.
		/// </summary>
		/// <param name="pLocation">The location to remove the structure</param>
		public void RemoveStructure(Point pLocation)
		{
			// Get the value
			Structure structure = mReferenceGrid[pLocation.X, pLocation.Y];
			
			// Go through the grid's rows
			for (int i = 0; i < mReferenceGrid.GetLength(0); i++)
			{
				// And columns
				for (int j = 0; j < mReferenceGrid.GetLength(1); j++)
				{
					// If the structure is this one
					if (mReferenceGrid[i, j] == structure)
					{
						// Then remove it from the grid
						mReferenceGrid[i, j] = null;
					}
				}
			}

			// Update the structure for removal
			UpdateForRemoval(structure);

			// If the structure is a residential
			if (structure is Residential)
			{
				// If we can
				if (mRoadCarrierPool.Count > 0)
				{
					// Remove the value
					mRoadCarrierPool.Pop().Dispose();
				}
			}
			else if (structure is MiningPlant)
			{
				// If we can
				if (mTubeCarrierPool.Count > 0)
				{
					// Remove the value
					mTubeCarrierPool.Pop().Dispose();
				}
			}

			// Switch on the type
			if (structure is MiningPlant)
			{
				mMiningPlants.Remove(structure);
			}
			else if (structure is Factory)
			{
				mFactories.Remove(structure);
			}
			else if (structure is Residential)
			{
				mResidentials.Remove(structure);
			}
			else if (structure is Commercial)
			{
				mCommercials.Remove(structure);
			}
			else if (structure is Entertainment)
			{
				mEntertainments.Remove(structure);
			}
			else if (structure is CommandPost)
			{
				mCommandCenters.Remove(structure);
			}

			// Dispose of the structure
			structure.Dispose();
			// Update the build areas
			UpdateBuildArea();
        }

        #endregion

        #region Update

        /// <summary>
        /// Tick the Grid along.
        /// </summary>
		/// <param name="Content">Reference to the current content manager</param>
		public void Tick(ContentManager Content)
		{
			// Reset the current money and population
			mGridStatus.Population = 0;
			mGridStatus.Happiness = 0.0f;

			// For loop approach
			for (int i = mCarrierList.Count - 1; i >= 0; i--)
			{
				// Get the carrier
				Carrier carrier = mCarrierList[i];
				// If the carrier is disposed
				if (carrier.IsDisposed)
				{
					// Remove it
					mCarrierList.RemoveAt(i);
				}
			}

			// Get the mean happiness of the colony
			List<Structure> ress = GetSpecificStructures(typeof(Residential));

			// If the count is greater than or equal to one
			if (ress.Count >= 1)
			{
				// Go through each of the residential structures
				foreach (Residential res in ress)
				{
					// Get the happiness
					StatusInfo.Happiness += res.Happiness;
					StatusInfo.Population += res.CurrentPopulation;
				}
				// Divide up by the number of structures
				mGridStatus.Happiness /= ress.Count;
			}

			// Now adjust that happiness
			int industryCount =
				GetSpecificStructures(typeof(MiningPlant)).Count +
				GetSpecificStructures(typeof(Factory)).Count;
			mGridStatus.Happiness -= industryCount * 0.01f;
			mGridStatus.Happiness = MathHelper.Max(0.0f, mGridStatus.Happiness);

			// Now tick all of the structures
			foreach (Structure structure in GridStructures)
			{
				// If the structure is not null
				if (structure != null)
				{
					// Tick the structure
					structure.Tick();
				}
			}
			SpawnRandomCarriers(Content);
			// Tell us we ticked
#if DEBUG
			Console.WriteLine("Tick");
			Console.WriteLine("Total Number of Carriers: " + mCarrierList.Count);
#endif
        }

        /// <summary>
        /// Updates the building area
        /// </summary>
        internal void UpdateBuildArea()
        {
            int maxBuildAreaX = mBuildAreaGrid.GetLength(0);
            int maxBuildAreaY = mBuildAreaGrid.GetLength(1);
            for (int i = 0; i < maxBuildAreaX; i++)
            {
                for (int j = 0; j < maxBuildAreaY; j++)
                {
                    mBuildAreaGrid[i, j] = false;
                }
            }
            for (int k = 0; k < maxBuildAreaX; k++)
            {
                for (int l = 0; l < maxBuildAreaY; l++)
                {
                    if (mReferenceGrid[k, l] != null)
                    {
                        Point centerOfBuilding = new Point(mReferenceGrid[k, l].GridPosition.X + (int)(mReferenceGrid[k, l].FootPrintSize.X / 2), mReferenceGrid[k, l].GridPosition.Y + (int)(mReferenceGrid[k, l].FootPrintSize.Y / 2));
                        for (int i = (centerOfBuilding.X - mReferenceGrid[k, l].BuildRadius < 0 ? 0 : centerOfBuilding.X - mReferenceGrid[k, l].BuildRadius);
                            i <= centerOfBuilding.X + mReferenceGrid[k, l].BuildRadius && i < maxBuildAreaX; i++)
                        {
                            for (int j = (centerOfBuilding.Y - mReferenceGrid[k, l].BuildRadius < 0 ? 0 : centerOfBuilding.Y - mReferenceGrid[k, l].BuildRadius);
                            j <= centerOfBuilding.Y + mReferenceGrid[k, l].BuildRadius && j < maxBuildAreaY; j++)
                            {
                                if (!mBuildAreaGrid[i, j])
                                {
                                    mBuildAreaGrid[i, j] = true;
                                }
                            }
                        }
                    }
                }
            }
            SetBuildAreaTexture(mGridModel.GraphicsDevice);
        }

        /// <summary>
        /// Update the road status of a newly-placed building based on it's surroundings.
        /// </summary>
		/// <param name="self">The newly added structure</param>
		private void UpdateRoadmapFromNeighbors(Structure self)
		{
			if (self is Residential)
			{
				UpdateRoadmapForAllNeighbors(self);
			}
			else if (self is MiningPlant)
			{
				UpdateResourceMapForAllNeighbors(self);
			}
			else
			{
				int dist = self.DistanceFromResidential;
				int[] dists = (int[])self.mDistanceFromResource.Clone();

				foreach (Structure neighbor in GetNeighbors(self))
				{
					if ((neighbor is Road || neighbor is RoadTubeCrossing) ||
						(neighbor is Residential && (self is Road || self is RoadTubeCrossing)))
					{
						dist = Math.Min(dist, neighbor.DistanceFromResidential);
					}
					if ((neighbor is Tube || neighbor is RoadTubeCrossing) ||
						(neighbor is MiningPlant && (self is Tube || self is RoadTubeCrossing)) ||
						(neighbor is Factory && (self is Tube || self is RoadTubeCrossing)))
					{
						for(int i = 0; i< dists.Length; ++i)
						{
							dists[i] = Math.Min(dists[i], neighbor.mDistanceFromResource[i]);
						}
					}
				}
				if (dist != int.MaxValue)
				{
					dist += 1;
				}
				for (int i = 0; i < dists.Length; ++i)
				{
					if (dists[i] != int.MaxValue)
					{
						dists[i] += 1;
					}
				}
				self.DistanceFromResidential = dist;
				self.SetDistanceFromResource(dists);
#if DEBUG
				// NOTE Debug:
				//Console.WriteLine(self + " distance is " + dist);
				//for (int i = 0; i < dists.Length; ++i)
				//{
				//    Console.WriteLine("Resource " + i + " " + self + " distance is " + dists[i]);
				//}
#endif
				if (self is Road || self is RoadTubeCrossing)
				{
					UpdateRoadmapForAllNeighbors(self);
				}
				if (self is Tube || self is RoadTubeCrossing)
				{
					UpdateResourceMapForAllNeighbors(self);
				}
			}
		}

        /// <summary>
        /// Update the road status of all surrounding buildings due to a change.
        /// </summary>
        /// <param name="self">The newly added structure</param>
		private void UpdateRoadmapForAllNeighbors(Structure self)
		{
			int dist = self.mDistanceFromResidential;
			if (dist != int.MaxValue)
			{
				dist += 1;
				foreach (Structure neighbor in GetNeighbors(self))
				{
					if (!(neighbor is Road || neighbor is RoadTubeCrossing) && !(self is Road || self is RoadTubeCrossing))
					{
						continue;
					}
					if (neighbor.mDistanceFromResidential <= dist)
					{
						continue;
					}
					neighbor.DistanceFromResidential = dist;
#if DEBUG
					// NOTE Debug:
					//Console.WriteLine(neighbor + " distance is " + neighbor.mDistanceFromResidential);
#endif
					if (neighbor is Road || neighbor is RoadTubeCrossing)
					{
						UpdateRoadmapForAllNeighbors(neighbor);
					}
				}
			}
		}

        /// <summary>
        /// Updates the resource status of all surrounding buildings due to a change.
        /// </summary>
        /// <param name="self">The newly added structure</param>
		private void UpdateResourceMapForAllNeighbors(Structure self)
		{
			int[] dists = (int[])self.mDistanceFromResource.Clone();
			for (int i = 0; i < dists.Length; ++i)
			{
				if (dists[i] != int.MaxValue)
				{
					dists[i] += 1;
				}
			}
			foreach (Structure neighbor in GetNeighbors(self))
			{
				if (!(neighbor is Tube || neighbor is RoadTubeCrossing) && !(self is Tube || self is RoadTubeCrossing))
				{
					continue;
				}
				bool change = false;
				for (int i = 0; i < dists.Length; ++i)
				{
					if (neighbor.mDistanceFromResource[i] > dists[i])
					{
						neighbor.SetDistanceFromResource(i,dists[i]);
						change = true;
					}
				}
				if (change)
				{
					if (neighbor is Tube || neighbor is RoadTubeCrossing)
					{
						UpdateResourceMapForAllNeighbors(neighbor);
					}
				}
			}
		}

        /// <summary>
        /// Updates grid information due to the removal of a structure
        /// </summary>
        /// <param name="self">The structure that has been removed</param>
		private void UpdateForRemoval(Structure self)
		{
			int dist = self.mDistanceFromResidential;
			if (dist != int.MaxValue)
			{
				dist += 1;
				self.DistanceFromResidential = int.MaxValue;
				foreach (Structure neighbor in GetNeighbors(self))
				{
					if (neighbor.mDistanceFromResidential == dist)
					{
						UpdateRoadmapRemovalChange(neighbor);
					}
				}
			}

			for (int i = 0; i < self.mDistanceFromResource.Length; i++)
			{
				if (self.mDistanceFromResource[i] != int.MaxValue)
				{
					dist = self.mDistanceFromResource[i];
					self.SetDistanceFromResource(i, int.MaxValue);
					List<Structure> neighbors = GetNeighbors(self);
					foreach (Structure neighbor in GetNeighbors(self))
					{
						if (neighbor.mDistanceFromResource[i] > dist)
						{
							UpdateResourceMapRemovalChange(neighbor, i);
						}
					}
				}
			}
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="self"></param>
		private void UpdateRoadmapRemovalChange(Structure self)
		{
			int dist = self.mDistanceFromResidential;
			if (dist == int.MaxValue)
			{
				return;
			}
			bool disconnected = true;
			foreach (Structure neighbor in GetNeighbors(self))
			{
				if (neighbor.mDistanceFromResidential <= dist)
				{
					disconnected = false;
					break;
				}
			}
			if (disconnected)
			{
				self.DistanceFromResidential = int.MaxValue;
				foreach (Structure neighbor in GetNeighbors(self))
				{
					UpdateRoadmapRemovalChange(neighbor);
				}
			}
			else
			{
				UpdateRoadmapFromNeighbors(self);
			}
        }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="self"></param>
		/// <param name="iResource"></param>
		private void UpdateResourceMapRemovalChange(Structure self, int iResource)
		{
			int dist = self.mDistanceFromResource[iResource];
			if (dist == int.MaxValue)
			{
				return;
			}
			bool disconnected = true;
			foreach (Structure neighbor in GetNeighbors(self))
			{
				if (neighbor.mDistanceFromResource[iResource] <= dist)
				{
					disconnected = false;
					break;
				}
			}
			if (disconnected)
			{
				self.SetDistanceFromResource(iResource, int.MaxValue);
				foreach (Structure neighbor in GetNeighbors(self))
				{
					if (neighbor.mDistanceFromResource[iResource] > dist)
					{
						UpdateResourceMapRemovalChange(neighbor, iResource);
					}
				}
			}
			else
			{
				UpdateRoadmapFromNeighbors(self);
			}
		}

        #endregion

        #region File I/O

        /// <summary>
        /// Saves the current game state to a file
        /// </summary>
        /// <param name="pSaveString">The name of the file to save to</param>
        /// <returns>Whether or not the game successfully saved</returns>
        public bool Save(string pSaveString)
		{
			GameState gameState = new GameState();
			gameState.ResourceGrid = mResourceGrid;
			gameState.StructureGrid = mReferenceGrid;
			gameState.PlayerStatusInfo = StatusInfo;
			return SaverLoader.Save(GameScreen.GlobalRootStorageDirectory + 
				UserProfileUtility.OutputDirectory + UserProfileUtility.SaveDirectory, pSaveString + ".csg", gameState);
		}

        /// <summary>
        /// Loads in the current game grid information from the given file
        /// </summary>
        /// <param name="Content">The current content manager</param>
        /// <param name="pGameName">The name of the file to load</param>
        /// <returns>All the need game information loaded from the file</returns>
		public ColonySimStatusInformation Load(ContentManager Content, string pGameName)
		{
			for (int i = 0; i < mReferenceGrid.GetLength(0); i++)
			{
				for (int j = 0; j < mReferenceGrid.GetLength(1); j++)
				{
					if (mReferenceGrid[i, j] != null)
					{
						mReferenceGrid[i, j].Dispose();
						mReferenceGrid[i, j] = null;
					}
				}
			}
			for (int i = 0; i < mResourceGrid.GetLength(0); i++)
			{
				for (int j = 0; j < mResourceGrid.GetLength(1); j++)
				{
					if (mResourceGrid[i, j] != null)
					{
						mResourceGrid[i, j] = null;
					}
				}
			}

            string path = GameScreen.GlobalRootStorageDirectory + UserProfileUtility.OutputDirectory + UserProfileUtility.SaveDirectory;
			GameState returnState = SaverLoader.Load(path + pGameName, AddStructure, mReferenceGrid, mContent);

            if (returnState == null)
            {
                // No save file found, so create one
                SaverLoader.Save(path, pGameName, new GameState());

                // And try to load it again
                returnState = SaverLoader.Load(path + pGameName, AddStructure, mReferenceGrid, mContent);
            }

			mResourceGrid = returnState.ResourceGrid;
			UpdateBuildArea();
			return returnState.PlayerStatusInfo;
        }

        #endregion

        #region Management

        /// <summary>
        /// Clears out the entire reference grid and resource grid
        /// </summary>
        /// <param name="pDevice">Reference to the current graphics device</param>
        public void Clear(GraphicsDevice pDevice)
		{
			for (int i = 0; i < mReferenceGrid.GetLength(0); i++)
			{
				for (int j = 0; j < mReferenceGrid.GetLength(1); j++)
				{
					if (mReferenceGrid[i, j] != null)
					{
						mReferenceGrid[i, j].Dispose();
						mReferenceGrid[i, j] = null;
					}
					if(mResourceGrid[i,j] != null)
						mResourceGrid[i, j] = null;
				}
			}
			UpdateBuildArea();
			SetBuildAreaTexture(pDevice);
        }

        #endregion
    }

	/// <summary>
	/// Represents the resource names and codes that are available in the
	/// Colony Simulation.
	/// </summary>
	public enum ResourceCode
	{
        /// <summary>
        /// Represents that there is no resource
        /// </summary>
		None = 0,
        /// <summary>
        /// Represents that there is a level 0 A resource
        /// </summary>
		A0 = 1,
        /// <summary>
        /// Represents that there is a level 0 B resource
        /// </summary>
		B0 = 2,
        /// <summary>
        /// Represents that there is a level 0 C resource
        /// </summary>
		C0 = 3,
        /// <summary>
        /// Represents that there is a level 1 A resource
        /// </summary>
		A1 = 4,
        /// <summary>
        /// Represents that there is a level 1 B resource
        /// </summary>
		B1 = 5,
        /// <summary>
        /// Represents that there is a level 1 C resource
        /// </summary>
		C1 = 6,
        /// <summary>
        /// Represents that there is a level 2 A resource
        /// </summary>
		A2 = 7,
        /// <summary>
        /// Represents that there is a level 2 B resource
        /// </summary>
		B2 = 8,
        /// <summary>
        /// Represents that there is a level 2 C resource
        /// </summary>
		C2 = 9,
        /// <summary>
        /// Represents that there is a level 3 A resource
        /// </summary>
		A3 = 10,
        /// <summary>
        /// Represents that there is a level 3 B resource
        /// </summary>
		B3 = 11,
        /// <summary>
        /// Represents that there is a level 3 C resource
        /// </summary>
		C3 = 12
	}

    /// <summary>
    /// Class that defines the amount of certain resources that exist in the grid
    /// </summary>
    class ResourceSpawnNumbers
    {
        #region Fields

        // The number of oxygen resources in the grid
        private int mOxygen = Util.Random.Next(5, 20);

        // The number of helium resources in the grid
        private int mHelium = Util.Random.Next(5, 20);

        // The number of hydrogen resources in the grid
        private int mHydrogen = Util.Random.Next(5, 20);

        // The number of iron resources in the grid
        private int mIron = Util.Random.Next(5, 20);

        // The number of carbon resources in the grid
        private int mCarbon = Util.Random.Next(5, 20);

        #endregion

        #region Properties

        /// <summary>
        /// Gets/Sets the number of oxygen resources in the grid
        /// </summary>
        public int Oxygen
        {
            get { return mOxygen; }
            set { mOxygen = value; }
        }

        /// <summary>
        /// Gets/Sets the number of helium resources in the grid
        /// </summary>
        public int Helium
        {
            get { return mHelium; }
            set { mHelium = value; }
        }

        /// <summary>
        /// Gets/Sets the number of hydrogen resources in the grid
        /// </summary>
        public int Hydrogen
        {
            get { return mHydrogen; }
            set { mHydrogen = value; }
        }

        /// <summary>
        /// Gets/Sets the number of iron resources in the grid
        /// </summary>
        public int Iron
        {
            get { return mIron; }
            set { mIron = value; }
        }

        /// <summary>
        /// Gets/Sets the number of carbon resources in the grid
        /// </summary>
        public int Carbon
        {
            get { return mCarbon; }
            set { mCarbon = value; }
        }

        #endregion

        #region Generate Resources

        /// <summary>
        /// Generates the grid of resources of specified height and width
        /// </summary>
        /// <param name="width">The width of the grid</param>
        /// <param name="height">The height of the grid</param>
        /// <returns>The grid of resources of specified height and width</returns>
        public Resource[,] GenerateResourceGrid(int width, int height)
        {
            Resource[,] returnGrid = new Resource[width, height];
            for (int i = 0; i < mOxygen; i++)
            {
                Point currentLocation = new Point(Util.Random.Next(0, width), Util.Random.Next(0, height));
                while (returnGrid[currentLocation.X, currentLocation.Y] != null)
                {
                    currentLocation = new Point(Util.Random.Next(0, width), Util.Random.Next(0, height));
                }
                returnGrid[currentLocation.X, currentLocation.Y] = new Resource();
                returnGrid[currentLocation.X, currentLocation.Y].ResourceCode = ResourceCode.A0;
            }
			//for (int i = 0; i < mCarbon; i++)
			//{
			//    Point currentLocation = new Point(Util.Random.Next(0, width), Util.Random.Next(0, height));
			//    while (returnGrid[currentLocation.X, currentLocation.Y] != null)
			//    {
			//        currentLocation = new Point(Util.Random.Next(0, width), Util.Random.Next(0, height));
			//    }
			//    returnGrid[currentLocation.X, currentLocation.Y] = new Resource();
			//    returnGrid[currentLocation.X, currentLocation.Y].ResourceCode = ResourceCode.B1;
			//}
            for (int i = 0; i < mHelium; i++)
            {
                Point currentLocation = new Point(Util.Random.Next(0, width), Util.Random.Next(0, height));
                while (returnGrid[currentLocation.X, currentLocation.Y] != null)
                {
                    currentLocation = new Point(Util.Random.Next(0, width), Util.Random.Next(0, height));
                }
                returnGrid[currentLocation.X, currentLocation.Y] = new Resource();
                returnGrid[currentLocation.X, currentLocation.Y].ResourceCode = ResourceCode.B0;
            }
            for (int i = 0; i < mHydrogen; i++)
            {
                Point currentLocation = new Point(Util.Random.Next(0, width), Util.Random.Next(0, height));
                while (returnGrid[currentLocation.X, currentLocation.Y] != null)
                {
                    currentLocation = new Point(Util.Random.Next(0, width), Util.Random.Next(0, height));
                }
                returnGrid[currentLocation.X, currentLocation.Y] = new Resource();
                returnGrid[currentLocation.X, currentLocation.Y].ResourceCode = ResourceCode.C0;
            }
			//for (int i = 0; i < mIron; i++)
			//{
			//    Point currentLocation = new Point(Util.Random.Next(0, width), Util.Random.Next(0, height));
			//    while (returnGrid[currentLocation.X, currentLocation.Y] != null)
			//    {
			//        currentLocation = new Point(Util.Random.Next(0, width), Util.Random.Next(0, height));
			//    }
			//    returnGrid[currentLocation.X, currentLocation.Y] = new Resource();
			//    returnGrid[currentLocation.X, currentLocation.Y].ResourceCode = ResourceCode.A1;
			//}
            return returnGrid;
        }

        #endregion
    }

    /// <summary>
    /// Class that defines the amount of certain buildings exist in the grid
    /// </summary>
	class BuildingSpawnNumbers
    {
        #region Fields

        // The number of obstacles in the grid
        private int mObstacles = Util.Random.Next(100, 500);

        // The number of planets in the grid
		private int mPlanets = Util.Random.Next(10, 30);

        // The number of outposts in the grid
        private int mOutposts = Util.Random.Next(20, 60);

        #endregion

        #region Properties

        /// <summary>
        /// Gets/Sets the number of obstacles in the grid
        /// </summary>
        public int Obstacles
        {
            get { return mObstacles; }
            set { mObstacles = value; }
        }

        /// <summary>
        /// Gets/Sets the number of planets in the grid
        /// </summary>
		public int Planets
		{
			get { return mPlanets; }
			set { mPlanets = value; }
		}

		/// <summary>
		/// Gets/Sets then number of outposts in the grid
		/// </summary>
		public int Outposts
		{
			get { return mOutposts; }
			set { mOutposts = value; }
        }

        #endregion

        #region Genereate Structures

        /// <summary>
        /// Generates the grid with the given number of each structure object
        /// </summary>
        /// <param name="pContent">Reference to the current content manager</param>
        /// <param name="pGridReference">Reference to the grid to fill</param>
        /// <returns>The list of structures in the grid</returns>
        public List<Structure> GenerateStructures(ContentManager pContent, Grid pGridReference)
		{
			List<Structure> returnList = new List<Structure>();
			for (int i = 0; i < mPlanets; i++)
			{
				Residential tempPlanet = new Residential(pContent, @"Models\Industrial Plant_JPx", null);
				tempPlanet.Register(pGridReference);
				tempPlanet.FootPrintSize = new Vector2(3, 3);
				returnList.Add(tempPlanet);
			}
			for (int i = 0; i < mOutposts; i++)
			{
				Factory tempOutpost = new Factory(pContent, @"Models\spacestation", null);
				tempOutpost.Register(pGridReference);
				tempOutpost.FootPrintSize = new Vector2(2, 2);
				returnList.Add(tempOutpost);
			}
			for (int i = 0; i < mObstacles; i++)
			{
				Obstacle tempObstacle = new Obstacle(pContent, @"Models\testcube", @"Textures\singlePixel");
				tempObstacle.Register(pGridReference);
				returnList.Add(tempObstacle);
			}
			return returnList;
        }

        #endregion
    }
}