/**
		 * Just generates a basic map for now, replacing any planets that are too close.
		 * Dimensions are a vector of width and height
		 * numberOfPlanets is the total number of planets in the map
		 * players is an array of players that should be included on the map
		 * names is the array of names to be used 
		 * germanium is the germanium of all hw (if -1, gens random from between min_hw and max
		 */
		public function generateRectMap(dimensions:Vector, numberOfPlanets:uint, players:Array, names:Array, germanium:int = -1):void
		{
			_objects	=	[];
			
			//check to make sure all obs in races are actually races
			for(var i:int = 0; i < players.length; i++)
			{
				if(!(players[i] is Player)) 
					throw new Error("players must contain all player instances");
			}
			
			//check to make surea all obs in names are strings
			for(i = 0; i < names.length; i++)
			{
				if(!(names[i] is String)) 
					throw new Error("names must contain all strings");
			}
			
			//if germanium is -1, gen random
			if(germanium == -1)	germanium	=	Math.random() * (MineralConcentrations.$MAX_CONC - MineralConcentrations.$MIN_HW_CONC) + MineralConcentrations.$MIN_HW_CONC;
			
			if(germanium < MineralConcentrations.$MIN_HW_CONC || germanium > MineralConcentrations.$MAX_CONC)
				throw new Error("germanium value must fall inbetween the values specified by the MinConcentrations class.");
			
			var sqrtPlanets		:int	=	Math.ceil(Math.sqrt(numberOfPlanets));
			
			var plotSize		:Vector	=	new Vector(dimensions.x / sqrtPlanets, dimensions.y / sqrtPlanets);
			
			var excessPlots	:int	=	int(sqrtPlanets * sqrtPlanets - numberOfPlanets);
			
			//randomize player order
			var newPlayers		:Array	=	[];
			
			for(i = players.length - 1; i >= 0; i--)
			{
				newPlayers.push(players.splice(Math.floor(Math.random() * (players.length - 0.0001)), 1)[0]);
			}
			
			players						=	newPlayers;
			
			//randomize name order
			var newNames		:Array	=	[];
			
			for(i = names.length - 1; i >= 0; i--)
			{
				newNames.push(names.splice(Math.floor(Math.random() * (names.length - 0.0001)), 1)[0]);
			}
			
			names						=	newNames;
			
			//border so planets arn't quite so close to eachother
			var border			:Number	=	0.05 * Math.min(plotSize.x, plotSize.y);
			
			var curPlanet		:int	=	0;
			
			//generic planet var
			var p				:Planet;
			
			//counter
			var j				:int;
			
			var randomIntX		:int;
			var randomIntY		:int;
			//planets to remove:
			var remove			:Array	=	[];
			//setup array
			for(i = 0; i < sqrtPlanets; i++) 
			{
				remove[i]	=	[];
				for(j = 0; j < sqrtPlanets; j++)
				{
					remove[i][j]=	1;
				}
			}
			for(i = 0; i < excessPlots; i++)
			{
				do {
					randomIntX			=	int(Math.random() * (sqrtPlanets - 0.0001));
					randomIntY			=	int(Math.random() * (sqrtPlanets - 0.0001));
				} while (remove[randomIntX][randomIntY] == 0);
				remove[randomIntX][randomIntY] = 0;
			}
			
			
			//create all of the planets
			for(i = 0; i < sqrtPlanets; i++)
			{
				for(j = 0; j < sqrtPlanets; j++)
				{
					if(remove[i][j] == 0) continue;
					
					var xloc	:int	=	i * plotSize.x + border + Math.random() * (plotSize.x - border * 2);
					var yloc	:int	=	j * plotSize.y + borde

public function generateRectMap(dimensions:Vector, numberOfPlanets:uint, players:Array, names:Array, germanium:int = -1):void
		{
			_objects	=	[];
			//removed the checks because they're the same from above
			
			//randomize player and name order
			players						=	randomizeArray(players);
			names						=	randomizeArray(names);
					
			var planetPoints	:Array	=	createPoints(dimensions, numberOfPlanets, 0.05);
			
			for(i = 0; i < planetPoints.length; i ++)
				_objects.push(new Planet(planetPoints[i], names[i]));
			
			var hwPoints		:Array	=	createPoints(dimensions, players.length, 0.2);
			
			for(i = 0; i < hwPoints.length; i++)
			{
				//hw loc
				var point		:Vector	=	hwPoints[i] as Vector;
				
				//find closest planet
				var dist		:Number	=	_objects[0].Location.getDistance(point);
				var curDist		:Number	=	0;
				var planetNum	:int	=	0;
				
				for(var j:int = 0; j < _objects.length; j++)
				{
					curDist				=	_objects[j].Location.getDistance(point);
					if(curDist < dist)
					{
						dist			=	curDist;
						planetNum		=	j;
					}
				}
				
				//found the planet so now change it to HW
				var planet		:Planet	=	_objects[planetNum] as Planet;
				var player		:Player	=	players[i] as Player;
				
				//probably don't want to have this hardcoded.
				planet.IsHomeworld		=	true;
				planet.Owner			=	player;
				planet.Environment		=	player.PlayerRace.PerfectEnv;
				planet.MinConcentrations.Germanium	=	germanium;
				planet.Population		=	player.PlayerRace.GrowthRate * 5000 + 50000;
				planet.Factories		=	10;
				planet.Mines			=	10;
			}
		}
		
		private function createPoints(dimensions:Vector, numberOfPoints:int, borderPercent:Number):Array
		{
			var points		:Array	=	[];
			var sqrt		:int	=	Math.ceil(Math.sqrt(numberOfPoints));
			var plotSize	:Vector	=	new Vector(dimensions.x / sqrt, dimensions.y / sqrt);
			var excessPlots	:int	=	int(sqrt * sqrt - numberOfPoints);
			var border		:Number	=	borderPercent * Math.min(plotSize.x, plotSize.y);
			
			//remove excess
			var randomIntX		:int;
			var randomIntY		:int;
			var remove			:Array	=	[];
			//setup array
			for(var i:int = 0; i < sqrt; i++) 
			{
				remove[i]	=	[];
				for(var j:int = 0; j < sqrt; j++) remove[i][j]=	1;
			}
			
			//remove extra
			for(i = 0; i < excessPlots; i++)
			{
				do {
					randomIntX			=	int(Math.random() * (sqrt - 0.0001));
					randomIntY			=	int(Math.random() * (sqrt - 0.0001));
				} while (remove[randomIntX][randomIntY] == 0);
				remove[randomIntX][randomIntY] = 0;
			}
			
			//setup actual points
			for(i = 0; i < sqrt; i++)
			{
				for(j = 0; j < sqrt; j++)
				{
					if(remove[i][j] == 0) continue;
					
					var xloc	:int	=	i * plotSize.x + border + Math.random() * (plotSize.x - border * 2);
					var yloc	:int	=	j * plotSize.y + border + Math.random() * (plotSize.y - border * 2);
					
					points.push(new Vector(xloc, yloc));
				}
			}
			return points;
		}
		
		private function randomizeArray(a:Array):Array
		{
			var newA	:Array	=	[];
			for(var i:int = a.length - 1; i >= 0; i--) 
				newA.push(a.splice(Math.floor(Math.random() * (a.length - 0.0001)), 1)[0]);
				
			return newA;
		}