include library.regions;
include library.trial;

const float GOOD_LOCATION_SEARCH_SIZE = 200; // we search in a square double this size
const string[] PLANETS = {"tatooine", "naboo", "talus", "corellia", "yavin4", "dantooine", "dathomir", "lok", "rori", "endor"}; // all planets in the game

const string NO_AREA			= "no_area";
const string PLANET_LEVEL_TABLE		= "datatables/spawning/planetary_data/planet_level.iff";

// how big is the region? this returns biggest size
float getRegionExtents(region rgnTest)
{
	// lower left is 0 , upper right is 1
	// make sure to check for a circle
	location locLowerLeft = new location();
	location locUpperRight = new location();

	location[] locExtents = getRegionExtent(rgnTest);
	locLowerLeft = (location)locExtents[0].clone();
	locUpperRight = (location)locExtents[1].clone();

	LOG("mission", "Lower Left is "+locLowerLeft.toString());
	LOG("mission", "Upper Right is "+locUpperRight.toString());

	float fltXDistance =  locUpperRight.x - locLowerLeft.x; // assuming my understanding of coords is right
	float fltZDistance = locUpperRight.z - locLowerLeft.z; // see above

	if(fltXDistance>fltZDistance)
	{
		LOG("mission", "fltXDistance returning with a value of "+fltXDistance);
		return fltXDistance;
	}
	else
	{
		LOG("mission", "fltZDistance returning with a value of "+fltZDistance);
		return fltZDistance;


	}


}
region getSmallestRegion(region[] rgnRegions)
{
	if(rgnRegions==null)
	{

		return null;
	}
	if(rgnRegions.length==0)
	{
		return null;
	}
	region rgnSmallestRegion = rgnRegions[0];
	float fltExtents = 1000000000;
	for(int intI = 0; intI<rgnRegions.length; intI++)
	{
		//LOG("mission", "Old region name is "+rgnSmallestRegion.getName());
		//LOG("mission", "Current region name is "+ rgnRegions[intI].getName());
		//LOG("mission", "old extents is "+fltExtents);
		float fltRegionExtents = getRegionExtents(rgnRegions[intI]);
		//LOG("mission", "new extents is "+fltRegionExtents);
		if(fltRegionExtents<fltExtents)
		{
			//LOG("mission", "changing small region to "+rgnRegions[intI].getName());
			rgnSmallestRegion = rgnRegions[intI];
			fltExtents = fltRegionExtents;
		}

	}
	return rgnSmallestRegion;
}


// returns x size
float getRegionXSize(region rgnSearchRegion)
{


	location[] locExtents = getRegionExtent(rgnSearchRegion);
	location locLowerLeft = (location)locExtents[0].clone();
	location locUpperRight = (location)locExtents[1].clone();

	LOG("mission", "Lower Left is "+locLowerLeft.toString());
	LOG("mission", "Upper Right is "+locUpperRight.toString());

	float fltXDistance =  locUpperRight.x - locLowerLeft.x; // assuming my understanding of coords is right
	return fltXDistance;




}
// returns z size
float getRegionZSize(region rgnSearchRegion)
{


	location[] locExtents = getRegionExtent(rgnSearchRegion);
	location locLowerLeft = (location)locExtents[0].clone();
	location locUpperRight = (location)locExtents[1].clone();

	LOG("mission", "Lower Left is "+locLowerLeft.toString());
	LOG("mission", "Upper Right is "+locUpperRight.toString());




	float fltZDistance = locUpperRight.z - locLowerLeft.z; // see above
	return fltZDistance;


}
// returns array x, z size
float[] getRegionSize(region rgnSearchRegion)
{


	location[] locExtents = getRegionExtent(rgnSearchRegion);
	location locLowerLeft = (location)locExtents[0].clone();
	location locUpperRight = (location)locExtents[1].clone();

	LOG("mission", "Lower Left is "+locLowerLeft.toString());
	LOG("mission", "Upper Right is "+locUpperRight.toString());

	float fltXDistance =  locUpperRight.x - locLowerLeft.x; // assuming my understanding of coords is right
	float fltZDistance = locUpperRight.z - locLowerLeft.z; // see above
	float[] fltRegionSize = new float[2];
	fltRegionSize[0] = fltXDistance;
	fltRegionSize[1] = fltZDistance;
	return fltRegionSize;


}

// gets region center
location getRegionCenter(region rgnSearchRegion)
{
	location locLowerLeft = new location();
	location locUpperRight = new location();

	location[] locExtents = getRegionExtent(rgnSearchRegion);
	locLowerLeft = (location)locExtents[0].clone();
	locUpperRight = (location)locExtents[1].clone();


	location locRegionCenter = (location)locLowerLeft.clone();


	locRegionCenter.x = (locLowerLeft.x + locUpperRight.x)/2;
	locRegionCenter.z = (locLowerLeft.z + locUpperRight.z)/2;
	LOG("missions", "locRegionCenter is "+locRegionCenter.toString());

	return locRegionCenter;

}

// duh!
location getGoodLocationOutsideOfRegion(region rgnSearchRegion, float fltXSize, float fltZSize, float fltDistance)
{
	if ( rgnSearchRegion == null )
	{
	LOG("mission", "getting good location outside of region returned NULL");
		return null;
	}

	debugServerConsoleMsg(null, "getting good locoutsideofregion");
	LOG("mission", "getting good location outside of region");

	float fltRegionExtent = getRegionExtents(rgnSearchRegion);
	location locRegionCenter = getRegionCenter(rgnSearchRegion);

	LOG("mission", "got centers and extents");

	location locDestination = utils.getRandomLocationInRing(locRegionCenter, fltRegionExtent, fltRegionExtent+fltDistance);

	location locLowerLeft = (location)locDestination.clone();
	locLowerLeft.x = locLowerLeft.x - GOOD_LOCATION_SEARCH_SIZE+fltXSize;
	locLowerLeft.z = locLowerLeft.z - GOOD_LOCATION_SEARCH_SIZE+fltZSize;

	location locUpperRight = (location)locDestination.clone();
	locUpperRight.x = locUpperRight.x + GOOD_LOCATION_SEARCH_SIZE+fltXSize;
	locUpperRight.z = locUpperRight.z + GOOD_LOCATION_SEARCH_SIZE+fltZSize;


	location locGoodLocation = getGoodLocation(fltXSize, fltZSize, locLowerLeft, locUpperRight, false, false);
	LOG("mission", "gotGoodLocation");
	return locGoodLocation;



}

location getGoodLocationOutsideOfRegion(region rgnSearchRegion, float fltXSize, float fltZSize, float fltDistance, boolean boolIgnoreWater, boolean boolIgnoreSlope)
{

	debugServerConsoleMsg(null, "getting good locoutsideofregion");
	LOG("mission", "getting good location outside of region");

	float fltRegionExtent = getRegionExtents(rgnSearchRegion);
	location locRegionCenter = getRegionCenter(rgnSearchRegion);

	LOG("mission", "got centers and extents");

	location locDestination = utils.getRandomLocationInRing(locRegionCenter, fltRegionExtent, fltRegionExtent+fltDistance);

	location locLowerLeft = (location)locDestination.clone();
	locLowerLeft.x = locLowerLeft.x - GOOD_LOCATION_SEARCH_SIZE+fltXSize;
	locLowerLeft.z = locLowerLeft.z - GOOD_LOCATION_SEARCH_SIZE+fltZSize;

	location locUpperRight = (location)locDestination.clone();
	locUpperRight.x = locUpperRight.x + GOOD_LOCATION_SEARCH_SIZE+fltXSize;
	locUpperRight.z = locUpperRight.z + GOOD_LOCATION_SEARCH_SIZE+fltZSize;


	location locGoodLocation = getGoodLocation(fltXSize, fltZSize, locLowerLeft, locUpperRight, boolIgnoreWater, boolIgnoreSlope);
	LOG("mission", "gotGoodLocation");
	return locGoodLocation;



}

// finds closest city region on planet
region getClosestCityRegion(region rgnStartRegion)
{


	string strName = rgnStartRegion.getName();
	LOG("mission", "in getclosestcityregion, name is "+strName);
	region[] rgnCities = getRegionsWithMunicipal(rgnStartRegion.getPlanetName(), regions.MUNI_TRUE);

	if(rgnCities==null)
	{
		return null;

	}
	region rgnClosestRegion = rgnCities[0];
	float fltDistance;
	float fltLowestDistance = 500000000;
	location locCenterPoint;
	location locCurrentCenter;

	locCurrentCenter = getRegionCenter(rgnStartRegion);




	int intI = 0;

	while(intI<rgnCities.length)
	{

		//////LOG("mission", "objRegion is "+objRegion);
		LOG("mission", "StartRegion is "+ rgnStartRegion);
		string strNewName = rgnCities[intI].getName();
		LOG("missions", "strNewName is "+strNewName);
		if(strNewName!=strName)
		{

			fltDistance = getDistance(locCurrentCenter, getRegionCenter(rgnCities[intI]));
			LOG("mission", "fltDistance is "+fltDistance);
			LOG("mission", "fltLowestDistance is "+fltLowestDistance);

			LOG("mission", "closest region is "+ rgnClosestRegion);
			if(fltDistance<fltLowestDistance)
			{
				fltLowestDistance = fltDistance;
				rgnClosestRegion = rgnCities[intI];


			}




		}


		intI = intI+1;

	}

	LOG("mission", "returned region is "+ rgnClosestRegion);

	return rgnClosestRegion;


}


region getDeliverCityRegion(region rgnStartRegion)
{

	resizeable string[] strPlanets= new string[0];
	string strPlanet = rgnStartRegion.getPlanetName();

	region[] rgnCities = getRegionsWithMunicipal(strPlanet, regions.MUNI_TRUE);
	resizeable region[] rgnNewCities = new region[0];
	if(rgnCities==null)
	{
		return null;
	}
	if(rgnCities.length==0)
	{
		return null;
	}
	LOG("locations", "length is "+rgnCities.length);

	if(rgnCities.length<3)
	{
		// OOOOOH! OFFPLANET! WAHOO!
		for(int intI = 0; intI<PLANETS.length; intI++)
		{
			string strTestString = PLANETS[intI]; // to make sure we don't hit preprocessor bug;

			LOG("locations", "strTestString is "+strTestString);
			LOG("locations", "strPlanet is "+strPlanet);
			if(strTestString!=strPlanet)
			{
				strPlanets = utils.addElement(strPlanets, strTestString);
			}
		}
		// now we've got a planet!
		string strNewPlanet = strPlanets[rand(0, strPlanets.length-1)];
		LOG("locations", "new planet is "+strNewPlanet);
		rgnCities= getRegionsWithMunicipal(strNewPlanet, regions.MUNI_TRUE);
		if((rgnCities!=null)&&(rgnCities.length>0))
		{

			region rgnCity = rgnCities[rand(0, rgnCities.length-1)];
			LOG("locations", "rgnCity is "+rgnCity.getName());
			return rgnCity;

		}
		else
		{
			return null;

		}


	}
	else
	{

		int intI = 0;
		string strStartName = rgnStartRegion.getName();
		while(intI<rgnCities.length)
		{
			// we've gotta kick start region out of the array

			string strNewName = rgnCities[intI].getName();
			if(strStartName!=strNewName)
			{

				rgnNewCities= utils.addElement(rgnNewCities, rgnCities[intI]);


			}

			intI = intI+1;

		}

		region rgnCity = rgnNewCities[rand(0, rgnNewCities.length-1)];
		return rgnCity;
	}




}
// finds a city region on a planet that isn't the same as the passed region
region getCityRegion(region rgnStartRegion)
{

	region[] rgnCitiesArray = getRegionsWithMunicipal(rgnStartRegion.getPlanetName(), regions.MUNI_TRUE);
	resizeable region[] rgnCities = rgnCitiesArray;

	if(rgnCities==null)
	{
		return null;
	}
	if(rgnCitiesArray==null)
	{
		return null;
	}
	if(rgnCities.length==0)
	{
		return null;
	}
	if(rgnCitiesArray.length==0)
	{
		return null;
	}

	int intI = 0;

	string strStartName = rgnStartRegion.getName();
	while(intI<rgnCities.length)
	{
		// we've gotta kick start region out of the array

		string strNewName = rgnCities[intI].getName();
		if(strStartName==strNewName)
		{

			rgnCities = utils.removeElementAt(rgnCities, intI);
			intI = rgnCities.length+10;

		}

		intI = intI+1;

	}

	region rgnCity = rgnCities[rand(0, rgnCities.length-1)];

	return rgnCity;


}
region getCityRegion(location locCurrentLocation)
{

	region[] rgnCities = getRegionsWithMunicipalAtPoint(locCurrentLocation, regions.MUNI_TRUE);

	if(rgnCities==null)
	{
		return null;

	}

	region rgnCity = rgnCities[rand(0, rgnCities.length-1)];

	return rgnCity;


}
boolean isInCity(location locTestLocation)
{
	region[] rgnCities = getRegionsWithMunicipalAtPoint(locTestLocation, regions.MUNI_TRUE);
	if(rgnCities!=null)
	{

		return true; // in city
	}

	return false;



}
boolean isInMissionCity(location locTestLocation)
{
	// Check for player cities.
	if ( city.isInCity( locTestLocation ) )
		return true;

	region[] rgnCities = getRegionsWithMunicipalAtPoint(locTestLocation, regions.MUNI_TRUE);
	if(rgnCities!=null)
	{

		return true; // in city
	}
 	rgnCities = getRegionsWithGeographicalAtPoint(locTestLocation, regions.GEO_CITY);
 	if(rgnCities!=null)
 	{
 		return true;
 	}
	return false;



}

// gets good location of given size in a region
location getGoodLocationInRegion(region rgnSearchRegion, float fltXSize, float fltZSize)
{

	// make sure to check for a circle
	location locLowerLeft = new location();
	location locUpperRight = new location();

	location[] locExtents = getRegionExtent(rgnSearchRegion);
	locLowerLeft = (location)locExtents[0].clone();
	locUpperRight = (location)locExtents[1].clone();

	location locGoodLocation = getGoodLocation(fltXSize, fltZSize, locLowerLeft, locUpperRight, false, false);

	return locGoodLocation;

}

location getGoodLocationInRegion(region rgnSearchRegion, float fltXSize, float fltZSize, boolean boolIgnoreWater, boolean boolIgnoreSlope)
{

	// make sure to check for a circle
	location locLowerLeft = new location();
	location locUpperRight = new location();

	location[] locExtents = getRegionExtent(rgnSearchRegion);
	locLowerLeft = (location)locExtents[0].clone();
	locUpperRight = (location)locExtents[1].clone();

	location locGoodLocation = getGoodLocation(fltXSize, fltZSize, locLowerLeft, locUpperRight, boolIgnoreWater, boolIgnoreSlope);

	return locGoodLocation;

}

// find a good location near the x, z coordinates specified, with a minimum size of
// locationSize, searching for a distance spefied by searchRadius
location getRandomGoodLocation(location start, float searchMin, float searchMax, float bestSize)
{
	location result = null;

	location l = utils.getRandomLocationInRing(start, searchMin, searchMax);
	
	location lowerLeft = new location();
	location upperRight = new location();
	lowerLeft.x = l.x - bestSize;
	lowerLeft.z = l.z - bestSize;
	upperRight.x = l.x + bestSize;
	upperRight.z = l.z + bestSize;

	float radius = bestSize;
	while(result == null && radius > 2.0f)
	{
		result = getGoodLocation(radius, radius, lowerLeft, upperRight, false, false);
		radius = radius * 0.5f;
	}
	return result;
}

// gets a good location wrapped
location getGoodLocationAroundLocation(location locSearchLocation, float fltXSize, float fltZSize, float fltXSearchSize, float fltZSearchSize)
{
	location locLowerLeft = (location)locSearchLocation.clone();
	locLowerLeft.x = locLowerLeft.x - fltXSearchSize;
	locLowerLeft.z = locLowerLeft.z - fltZSearchSize;
	LOG("mission", "locLowerLeft is "+locLowerLeft.toString());


	location locUpperRight = (location)locSearchLocation.clone();
	locUpperRight.x = locUpperRight.x + fltXSearchSize;
	locUpperRight.z = locUpperRight.z + fltZSearchSize;
	LOG("mission", "locUpperRight is "+locUpperRight.toString());


	// this might spawn too close to the player.. we'll fix it later.

	location locGoodLocation = getGoodLocation( fltXSize, fltZSize, locLowerLeft, locUpperRight, false, false);
	return locGoodLocation;



}

location getGoodLocationAroundLocation(location locSearchLocation, float fltXSize, float fltZSize, float fltXSearchSize, float fltZSearchSize, boolean boolIgnoreWater, boolean boolIgnoreSlope)
{
	location locLowerLeft = (location)locSearchLocation.clone();
	locLowerLeft.x = locLowerLeft.x - fltXSearchSize;
	locLowerLeft.z = locLowerLeft.z - fltZSearchSize;
	LOG("mission", "locLowerLeft is "+locLowerLeft.toString());


	location locUpperRight = (location)locSearchLocation.clone();
	locUpperRight.x = locUpperRight.x + fltXSearchSize;
	locUpperRight.z = locUpperRight.z + fltZSearchSize;
	LOG("mission", "locUpperRight is "+locUpperRight.toString());


	// this might spawn too close to the player.. we'll fix it later.

	location locGoodLocation = getGoodLocation( fltXSize, fltZSize, locLowerLeft, locUpperRight, boolIgnoreWater, boolIgnoreSlope);
	if(locGoodLocation==null)
	{
		LOG("DESIGNER_FATAL", "X search size is "+fltXSearchSize);
		LOG("DESIGNER_FATAL", "Z search size is "+fltZSearchSize);
		LOG("DESIGNER_FATAL", "size of thing is "+fltZSize);
		LOG("DESIGNER_FATAL", "Lower left is "+locLowerLeft);
		LOG("DESIGNER_FATAL", "Upper Right is "+locUpperRight);
		LOG("DESIGNER_FATAL", "Start location is "+locSearchLocation);

	}
	return locGoodLocation;



}

location getGoodLocationAroundLocationAvoidCollidables(location locSearchLocation, float fltXSize, float fltZSize, float fltXSearchSize, float fltZSearchSize, boolean boolIgnoreWater, boolean boolIgnoreSlope, float staticObjDistance)
{
	location locLowerLeft = (location)locSearchLocation.clone();
	locLowerLeft.x = locLowerLeft.x - fltXSearchSize;
	locLowerLeft.z = locLowerLeft.z - fltZSearchSize;
	LOG("mission", "locLowerLeft is "+locLowerLeft.toString());


	location locUpperRight = (location)locSearchLocation.clone();
	locUpperRight.x = locUpperRight.x + fltXSearchSize;
	locUpperRight.z = locUpperRight.z + fltZSearchSize;
	LOG("mission", "locUpperRight is "+locUpperRight.toString());


	// this might spawn too close to the player.. we'll fix it later.

	location locGoodLocation = getGoodLocationAvoidCollidables( fltXSize, fltZSize, locLowerLeft, locUpperRight, boolIgnoreWater, boolIgnoreSlope, staticObjDistance);
	if(locGoodLocation==null)
	{
		LOG("DESIGNER_FATAL", "X search size is "+fltXSearchSize);
		LOG("DESIGNER_FATAL", "Z search size is "+fltZSearchSize);
		LOG("DESIGNER_FATAL", "size of thing is "+fltZSize);
		LOG("DESIGNER_FATAL", "Lower left is "+locLowerLeft);
		LOG("DESIGNER_FATAL", "Upper Right is "+locUpperRight);
		LOG("DESIGNER_FATAL", "Start location is "+locSearchLocation);

	}
	return locGoodLocation;



}

string getCityName(location locCurrentLocation)
{



	region[] rgnCities = getRegionsWithMunicipalAtPoint(locCurrentLocation, regions.MUNI_TRUE);
	if(rgnCities==null)
	{

		return null; // in city
	}
	region rgnCity = rgnCities[0];


	string_id strFictionalName = utils.unpackString(rgnCity.getName());
	string strAsciiId = strFictionalName.getAsciiId();
	return strAsciiId;
}

string getGuardSpawnerRegionName(location locCurrentLocation)
{
	if(locCurrentLocation==null)
	{
		return null;

	}
	region[] rgnCities = getRegionsWithGeographicalAtPoint(locCurrentLocation, regions.GEO_CITY);
	if(rgnCities==null)
	{

		return null; // not in city
	}
	region rgnCity = rgnCities[0];
	string strName = rgnCity.getName();
	return strName;

}



location getBountyLocation(string strPlanet)
{

	region[] rgnCities = getRegionsWithMunicipal(strPlanet, regions.MUNI_TRUE);
	if(rgnCities==null)
	{
		return null;

	}

	if(rgnCities.length>0)
	{
		int intRoll = rand(0, rgnCities.length-1);
		region rgnCity = rgnCities[intRoll];
		location locDestination = getGoodCityLocation(rgnCity, strPlanet);

		location locCenter = getRegionCenter(rgnCities[intRoll]);
		return locCenter;


	}
	else
	{
		// we need to get a randomer location

		location locDestination = new location();
		locDestination.x = rand(-6500, 6500);
		locDestination.z = rand(-6500, 6500);
		locDestination.area = strPlanet;
		locDestination = locations.getGoodLocationAroundLocation(locDestination, 1, 1, 400, 400, false, true);
		if(locDestination ==null)
		{
			LOG("DESIGNER_FATAL", "No good location found for planet "+strPlanet);
			locDestination = new location();
			locDestination.area = strPlanet;
			locDestination.x = 0;
			locDestination.y = 0;
			locDestination.z = 0;

		}
		return locDestination;

	}


}

location moveLocationTowardsLocation(location locStartLocation, location locEndLocation, float fltDistance)
{

	// moves a point from one point to another a certain distance.

	location locNewLocation = (location)locStartLocation.clone();
	float fltTotalDistance = getDistance(locStartLocation, locEndLocation);
	if(fltTotalDistance<=0)
	{
		return locEndLocation;
	}

	float fltNewX = ((locEndLocation.x - locStartLocation.x) / fltTotalDistance);
	fltNewX = fltNewX * fltDistance;
	locNewLocation.x = locNewLocation.x + fltNewX;

	float fltNewZ = ((locEndLocation.z - locStartLocation.z)/fltTotalDistance);
	fltNewZ = fltNewZ * fltDistance;
	locNewLocation.z = locNewLocation.z + fltNewZ;

	return locNewLocation;


}

boolean isCityRegion(region rgnTest)
{
	if(rgnTest.getMunicipalType()==regions.MUNI_TRUE)
	{

		return true;
	}
	return false;


}
// this function gets a different region/location in the passed in city. It requires a city to have multiple delivery regions

location getDifferentGoodCityLocation(location locStartLocation)
{

	LOG("missions", "getting different city location");
	region[] rgnCities = getRegionsWithMunicipalAtPoint(locStartLocation, regions.MUNI_TRUE);
	if(rgnCities==null)
	{
		LOG("missions", "no cities found at locStartLocation ");
		return null;

	}
	region rgnCity = rgnCities[0];

	location locGoodLocation = new location();

	string_id strFictionalName = utils.unpackString(rgnCity.getName());


	string strAsciiId = strFictionalName.getAsciiId();
	LOG("mission_spam", "strAsciiId is "+strAsciiId);
	int regionType = regions.getDeliverMissionRegionType(strAsciiId);
	LOG("mission_spam", "Intregion type is "+ regionType);
	rgnCities = getRegionsWithMissionAtPoint(locStartLocation, regionType);

	if(rgnCities==null)
	{
		LOG("missions", "at start location of "+locStartLocation+", we found no mission types of bestine. ");
		return null;
	}

	string strOldName = rgnCities[0].getName(); // old name

	region[] rgnGoodLocationsArray = getRegionsWithMission(locStartLocation.area, regionType);
	resizeable region[] rgnGoodLocations = rgnGoodLocationsArray;

	LOG("missions", "strOldName is "+strOldName);

	/////LOG("mission_spam", "strPlanet is "+strPlanet);
	if(rgnGoodLocations==null)
	{
		LOG("missions", "no regions found with mission type on planet "+locStartLocation.area);
		LOG("mission_spam", "No regions were foind of type "+ regionType);
		return null;
	}

	int intI = 0;
	while(intI<rgnGoodLocations.length)
	{
		string strNewName = rgnGoodLocations[intI].getName();
		if(strNewName==strOldName)
		{
			rgnGoodLocations = utils.removeElementAt(rgnGoodLocations, intI);
			intI = rgnGoodLocations.length +19;
		}
		intI = intI+1;
	}

	region rgnSpawnRegion = rgnGoodLocations[rand(0, rgnGoodLocations.length-1)];
	locGoodLocation = findPointInRegion(rgnSpawnRegion);
	LOG("mission_spam", "Got good location of "+locGoodLocation.toString() + " in locations.getGoodCityLocation");
	return locGoodLocation;
}



location getDifferentGoodCityRegionLocation(location locStartLocation)
{

	LOG("missions", "getting different city location");
	region[] rgnCities = getRegionsWithMunicipalAtPoint(locStartLocation, regions.MUNI_TRUE);
	if(rgnCities==null)
	{
		////LOG("missions", "no cities found at locStartLocation ");
		return null;

	}
	region rgnCity = rgnCities[0];

	location locGoodLocation = new location();

	string_id strFictionalName = utils.unpackString(rgnCity.getName());


	string strAsciiId = strFictionalName.getAsciiId();
	LOG("mission_spam", "strAsciiId is "+strAsciiId);
	int regionType = regions.getDeliverMissionRegionType(strAsciiId);
	LOG("mission_spam", "Intregion type is "+ regionType);
	rgnCities = getRegionsWithMissionAtPoint(locStartLocation, regionType);

	if(rgnCities==null)
	{
		LOG("missions", "at start location of "+locStartLocation+", we found no mission types of bestine. ");
		return null;
	}

	string strOldName = rgnCities[0].getName(); // old name

	region[] rgnGoodLocationsArray = getRegionsWithMission(locStartLocation.area, regionType);
	resizeable region[] rgnGoodLocations = rgnGoodLocationsArray;

	LOG("missions", "strOldName is "+strOldName);

	//////////LOG("mission_spam", "strPlanet is "+strPlanet);
	if(rgnGoodLocations==null)
	{
		LOG("missions", "no regions found with mission type on planet "+locStartLocation.area);
		LOG("mission_spam", "No regions were foind of type "+ regionType);
		return null;
	}

	int intI = 0;
	while(intI<rgnGoodLocations.length)
	{
		string strNewName = rgnGoodLocations[intI].getName();
		if(strNewName==strOldName)
		{
			rgnGoodLocations = utils.removeElementAt(rgnGoodLocations, intI);
			intI = rgnGoodLocations.length +19;
		}
		intI = intI+1;
	}

	region rgnSpawnRegion = rgnGoodLocations[rand(0, rgnGoodLocations.length-1)];
	locGoodLocation = getRegionCenter(rgnSpawnRegion);
	LOG("mission_spam", "Got good location of "+locGoodLocation.toString() + " in locations.getGoodCityLocation");
	return locGoodLocation;
}
location getGoodCityLocation(region rgnCity, string strPlanet)
{
	if ( rgnCity == null || strPlanet == null)
	{
		LOG("mission_spam", "getGoodCityLocation(line 883) returned NULL");
		return null;
	}
	
	location locGoodLocation = new location();

	string_id strFictionalName = utils.unpackString(rgnCity.getName());


	string strAsciiId = strFictionalName.getAsciiId();
	LOG("mission_spam", "strAsciiId is "+strAsciiId);
	int regionType = regions.getDeliverMissionRegionType(strAsciiId);
	LOG("mission_spam", "Intregion type is "+ regionType);

	region[] rgnGoodLocations = getRegionsWithMission(strPlanet, regionType);
	LOG("mission_spam", "strPlanet is "+strPlanet);
	if(rgnGoodLocations==null)
	{

		LOG("mission_spam", "No regions were foind of type "+ regionType);
		return null;
	}
	region rgnSpawnRegion = rgnGoodLocations[rand(0, rgnGoodLocations.length-1)];
	int intI = 0;
	while(intI<rgnGoodLocations.length)
	{
		LOG("locations", "rgnGoodLocationsRegion[intI] Type is "+ rgnGoodLocations[intI].getMissionType());
		LOG("locations", "rgnGoodLocationsRegion[intI] planet is "+rgnGoodLocations[intI].getPlanetName());

		intI = intI+1;
	}
	locGoodLocation = findPointInRegion(rgnSpawnRegion);
	LOG("mission_spam", "Got good location of "+locGoodLocation.toString() + " in locations.getGoodCityLocation");
	return locGoodLocation;



}



location getGoodCityRegionLocation(region rgnCity, string strPlanet)
{
	if ( rgnCity == null || strPlanet == null)
		return null;
	
	location locGoodLocation = new location();

	string_id strFictionalName = utils.unpackString(rgnCity.getName());


	string strAsciiId = strFictionalName.getAsciiId();
	LOG("mission_spam", "strAsciiId is "+strAsciiId);
	int regionType = regions.getDeliverMissionRegionType(strAsciiId);
	LOG("mission_spam", "Intregion type is "+ regionType);

	region[] rgnGoodLocations = getRegionsWithMission(strPlanet, regionType);
	LOG("mission_spam", "strPlanet is "+strPlanet);
	if(rgnGoodLocations==null)
	{

		LOG("mission_spam", "No regions were foind of type "+ regionType);
		return null;
	}
	region rgnSpawnRegion = rgnGoodLocations[rand(0, rgnGoodLocations.length-1)];
	locGoodLocation = getRegionCenter(rgnSpawnRegion);	
	return locGoodLocation;
}

int normalizeDifficultyForRegion(int intDifficulty, location locTest)
{
	// this converts the passed difficulty into an appropriate min/max difficulty for the area
	region[] rgnRegionsAtPoint = getRegionsWithSpawnableAtPoint(locTest, regions.SPAWN_TRUE);

	if(rgnRegionsAtPoint == null || rgnRegionsAtPoint.length == 0)
	{
		rgnRegionsAtPoint = getRegionsWithSpawnableAtPoint(locTest, regions.SPAWN_DEFAULT);

		if(rgnRegionsAtPoint == null)
		{
			LOG("DESIGNER_FATAL", "No regions at location "+locTest);
			return intDifficulty;
		}
	}

	region rgnSmallestRegion = getSmallestRegion(rgnRegionsAtPoint);

	if(rgnSmallestRegion == null)
	{
		LOG("locations", "Smallest region was null");

		return intDifficulty;
	}

	int intMinRegionDifficulty = rgnSmallestRegion.getMinDifficultyType();
	int intMaxRegionDifficulty = rgnSmallestRegion.getMaxDifficultyType();

	LOG("locations", "intMinRegionDifficulty: " + intMinRegionDifficulty + " intMaxRegionDifficulty: " + intMaxRegionDifficulty + " intDifficulty: " + intDifficulty);

	return rand(intMinRegionDifficulty, intMaxRegionDifficulty);
}

region[] getDifficultyRegionsAtLocation(location locTest)
{
	region[] rgnRegionsAtPoint = getRegionsWithSpawnableAtPoint(locTest, regions.SPAWN_TRUE);

	if(rgnRegionsAtPoint == null || rgnRegionsAtPoint.length == 0)
	{
		rgnRegionsAtPoint = getRegionsWithSpawnableAtPoint(locTest, regions.SPAWN_DEFAULT);

		if (rgnRegionsAtPoint == null || rgnRegionsAtPoint.length == 0)
			return null;
	}

	return rgnRegionsAtPoint;
}

int getMinMissionDifficultyAtLocation(location locTest)
{
	region[] rgnRegionsAtPoint = getRegionsWithMissionAtPoint(locTest, regions.MISSION_OTHER);

	if(rgnRegionsAtPoint == null || rgnRegionsAtPoint.length == 0)
	{
		rgnRegionsAtPoint = getRegionsWithSpawnableAtPoint(locTest, regions.SPAWN_DEFAULT);

		if(rgnRegionsAtPoint == null || rgnRegionsAtPoint.length == 0)
		{
			return 10;
		}
	}

	int minDifficulty = 90;

	for(int i = 0; i < rgnRegionsAtPoint.length; i++)
	{
		int regionMinDifficulty = rgnRegionsAtPoint[i].getMinDifficultyType();

		if(minDifficulty > regionMinDifficulty)
		{
			minDifficulty = regionMinDifficulty;
		}
	}

	return minDifficulty;
}

int getMinDifficultyForPlanet(string planet)
{
	int difficulty = 1;

	if(planet == "" || planet.length() <= 0)
	{
		return difficulty;
	}

	dictionary planetLevels = utils.dataTableGetRow(PLANET_LEVEL_TABLE, planet);

	if(planetLevels != null)
	{
		difficulty = planetLevels.getInt("minLevel");
	}
	else
	{
		difficulty = -1;
	}
	
	if(difficulty < 1)
	{
		difficulty = 1;
	}

	return difficulty;
}

int getMaxDifficultyForPlanet(string planet)
{
	int difficulty = 90;

	if(planet == "" || planet.length() <= 0)
	{
		return difficulty;
	}

	dictionary planetLevels = utils.dataTableGetRow(PLANET_LEVEL_TABLE, planet);

	if(planetLevels != null)
	{
		difficulty = planetLevels.getInt("maxLevel");
	}
	else
	{
		difficulty = -1;
	}
	
	if(difficulty > 90)
	{
		difficulty = 90;
	}

	return difficulty;
}

int getMinDifficultyForLocation(location locTest)
{
	region[] rgnRegionList = getDifficultyRegionsAtLocation(locTest);

	if (rgnRegionList == null || rgnRegionList.length == 0)
	{
		return 0;
	}

	int minDifficulty = Integer.MAX_VALUE;
	for (int i = 0; i < rgnRegionList.length; i++)
	{
		int regionMinDifficulty = rgnRegionList[i].getMinDifficultyType();

		if (minDifficulty > regionMinDifficulty )
			minDifficulty = regionMinDifficulty;
	}

	return minDifficulty;
}

int getMaxDifficultyForLocation(location locTest)
{
	region[] rgnRegionList = getDifficultyRegionsAtLocation(locTest);

	if (rgnRegionList == null || rgnRegionList.length == 0)
	{
		return Integer.MAX_VALUE;
	}

	int maxDifficulty = Integer.MIN_VALUE;
	for (int i = 0; i < rgnRegionList.length; i++)
	{
		int regionMaxDifficulty = rgnRegionList[i].getMaxDifficultyType();

		if (maxDifficulty < regionMaxDifficulty)
			maxDifficulty = regionMaxDifficulty;
	}

	return maxDifficulty;
}

int capMinDifficultyForLocation(location locTest, int intDifficulty)
{
	int intMinRegionDifficulty = getMinDifficultyForLocation(locTest);

	if (intDifficulty < intMinRegionDifficulty)
		intDifficulty = intMinRegionDifficulty;

	return intDifficulty;
}

int capMaxDifficultyForLocation(location locTest, int intDifficulty)
{
	int intMaxRegionDifficulty = getMaxDifficultyForLocation(locTest);

	if (intDifficulty > intMaxRegionDifficulty)
		intDifficulty = intMaxRegionDifficulty;

	return intDifficulty;
}

// Used to destroy the reservation object used by requestLocation()
// the obj_id needed is returned to trigger OnLocationReceived and is the obj_id of the reservation object. 
boolean destroyLocationObject(obj_id locationObject)
{
	if ( isIdValid(locationObject) )
	{
		messageTo(locationObject, "handlerDestroyLocationObject", null, 1, false);
		return true;
	}
	return false;
}

string getBuildoutAreaName(obj_id object)
{
	if (!isIdValid(object) || !exists(object))
		return NO_AREA;
		
	return getBuildoutAreaName(getLocation(trial.getTop(object)));
}

string getBuildoutAreaName(location loc)
{
	if (isIdValid(loc.cell))
	{
		obj_id topBuilding = trial.getTop(loc.cell);
		loc = getLocation(topBuilding);
	}	
	
	string buildout_table = "datatables/buildout/areas_"+loc.area+".iff";
	float locX = loc.x;
	float locZ = loc.z;

	if (!dataTableOpen(buildout_table))
	{
		return NO_AREA;
	}

	int rows = dataTableGetNumRows(buildout_table);

	string area_name = NO_AREA;
	for (int i=0;i<rows;i++)
	{
		dictionary dict = dataTableGetRow(buildout_table, i);
		float xMin = dict.getFloat("x1");
		float xMax = dict.getFloat("x2");
		float zMin = dict.getFloat("z1");
		float zMax = dict.getFloat("z2");

		if (locX >= xMin && locX <= xMax && locZ >= zMin && locZ <= zMax)
			area_name = dict.getString("area");
	}
	
	return area_name;	
}

int getBuildoutAreaRow(obj_id object)
{
	if (!isIdValid(object) || !exists(object))
		return -1;
		
	return getBuildoutAreaRow(getLocation(trial.getTop(object)));
}

int getBuildoutAreaRow(location loc)
{
	if (isIdValid(loc.cell))
	{
		obj_id topBuilding = trial.getTop(loc.cell);
		loc = getLocation(topBuilding);
	}	
	
	string buildout_table = "datatables/buildout/areas_"+loc.area+".iff";
	float locX = loc.x;
	float locZ = loc.z;

	if (!dataTableOpen(buildout_table))
	{
		return -1;
	}

	int rows = dataTableGetNumRows(buildout_table);

	int row = -1;
	for (int i=0;i<rows;i++)
	{
		dictionary dict = dataTableGetRow(buildout_table, i);
		float xMin = dict.getFloat("x1");
		float xMax = dict.getFloat("x2");
		float zMin = dict.getFloat("z1");
		float zMax = dict.getFloat("z2");

		if (locX >= xMin && locX <= xMax && locZ >= zMin && locZ <= zMax)
			row = i;
	}
	
	return row;	
}

boolean isInRegion(obj_id player, string regionName)
{
	region[] regionList = getRegionsAtPoint(getLocation(player));
	obj_id planetId = getPlanetByName(getLocation(player).area);

	if(regionList == null || regionList.length == 0)
		return false;

	for(int i = 0; i < regionList.length; i++)
	{
		if(regionList[i] == null || regionList[i].getName().length() <= 0)
			continue;
			
		if(regionName.equals(regionList[i].getName()))
		{
			return true;
		}
	}
	
	return false;
}