include library.space_utils;
include library.objvar_mangle;
include library.space_quest;
include library.space_create;
include library.ship_ai;
include library.utils;
include library.space_battlefield;
include java.lang.Math;
include library.hue;

// basic spawner





//Burninated

messageHandler getSpawnerData()
{
	if(hasObjVar(self, "strAsteroidType"))
	{
		//LOG("space", "Spawning us some asteroids!");
		if(utils.checkConfigFlag("ScriptFlags", "spawnersOn"))
		{
			messageTo(self, "startSpawning",null, 3, false);
			
		}
		return SCRIPT_CONTINUE;
	}

	if(!hasObjVar(self, "strDefaultBehavior"))
	{
		//LOG("space", "Stopping because no default behavior exists! and I am at "+getLocation(self));
		return SCRIPT_CONTINUE;

	}

	string strDefaultBehavior = getStringObjVar(self, "strDefaultBehavior");
	if((strDefaultBehavior=="patrol")||(strDefaultBehavior=="patrolNoRecycle"))
	{
		///LOG("space", "We're doing our thang!");
		// we need to get our patrol points(transforms in fact)
		string[] strPatrolPoints = objvar_mangle.getMangledStringArrayObjVar(self, "strPatrolPoints");
		if(strPatrolPoints==null)
		{
			//LOG("space", "HUGE PROBLEM WITH "+self+" NO PATROL POINTS and I am at "+getLocation(self));
			return SCRIPT_CONTINUE;
		}
		
		resizeable transform[]  trPatrolPoints = new transform[0];
		obj_id[] objTestObjects = getAllObjectsWithTemplate(getLocation(self), 320000, "object/tangible/space/content_infrastructure/basic_patrol_point.iff");

		//LOG("space", "length is "+objTestObjects.length);
		if(objTestObjects==null)
		{
			//LOG("space", "HUGE PROBLEM WITH OBJECT "+self+"and I am at "+getLocation(self));
			return SCRIPT_CONTINUE;
		}
		
		for(int intI =0; intI<strPatrolPoints.length; intI++)
		{


			for(int intJ = 0; intJ<objTestObjects.length; intJ++)
			{

				if(isIdValid(objTestObjects[intJ]) && hasObjVar(objTestObjects[intJ], "strName"))
				{
					string strName = getStringObjVar(objTestObjects[intJ], "strName");
					string strTest = strPatrolPoints[intI];
					if(strName==strTest)
					{

						// that's our spawner
						trPatrolPoints = utils.addElement(trPatrolPoints, getTransform_o2w(objTestObjects[intJ])); // add the transform so we can store these
						// end the loop thingie
						intJ = objTestObjects.length+10;
					}
				}
			}
		}
		//LOG("space", "patrol points length is "+trPatrolPoints.length);
		utils.setScriptVar(self, "trPatrolPoints", trPatrolPoints); // cuz
	}

	if(utils.checkConfigFlag("ScriptFlags", "spawnersOn"))
	{
		messageTo(self, "startSpawning",null, 3, false);
		return SCRIPT_CONTINUE;
	}
	return SCRIPT_CONTINUE;


}

trigger OnInitialize()
{

	// We want to get a preloading notification.
	//LOG("space", "ONINITIALIZE");
	requestPreloadCompleteTrigger( self );

	return SCRIPT_CONTINUE;
}

trigger OnAttach()
{
	//LOG("space", "ONATTACH");
	return SCRIPT_CONTINUE;
}

trigger OnPreloadComplete()
{
	//LOG("space", "ONPRELOAD");
	// We should register with the quest_manager now.
	obj_id questManager = getNamedObject( space_quest.QUEST_MANAGER );
	if ( questManager == null )
		return SCRIPT_CONTINUE;

	dictionary outparams = new dictionary();
	outparams.put( "point", self );
	outparams.put( "type", "spawner" );
	space_utils.notifyObject( questManager, "registerQuestLocation", outparams );
	space_utils.notifyObject( self, "getSpawnerData", null);


	// let's find our "SPACE STATION!";
	if(hasObjVar(self, "strDockingStation"))
	{
		string strDockingStation = getStringObjVar(self, "strDockingStation");
		obj_id[] objStations = getAllObjectsWithObjVar(getLocation(self), 320000, "intDockable");
		if(objStations!=null)
		{
			for(int intI = 0; intI< objStations.length; intI++)
			{
				if(hasObjVar(objStations[intI], "strStationName"))
				{
					string strStationName = getStringObjVar(objStations[intI], "strStationName");
					if(strStationName.equals(strDockingStation))
					{
						utils.setLocalVar(self, "objDockingStation", objStations[intI]);
						intI = objStations.length+1;
					}
				}
			}
		}
	}
	return SCRIPT_CONTINUE;
}

boolean isSpawnerActivated(obj_id self)
{
	obj_id objManager = space_battlefield.getManagerObject();
	if(hasObjVar(objManager, "intSpawnersDeactivated"))
	{
		if(!hasObjVar(self, "intActivationPhase"))
		{	// If spawners are off, and there's no activation phase, assume it's -1. Ideally people will set them to -1
			// but to streamline content stuff, we'll do it here.
			return true;
		}
		else
		{
			int intPhase = getIntObjVar(objManager, "intPhase");
			int intActivationPhase = getIntObjVar(self, "intActivationPhase");
			//LOG("space", "intPhase is "+intPhase+" activation is "+intActivationPhase);
			if((intPhase!=intActivationPhase)&&(intActivationPhase!=-1))
			{
				return false;
			}
		}
	}
	return true;
}
messageHandler startSpawning()
{
	//LOG("space", "Arrived safely!");
	if (!hasObjVar(self, "strSpawnerType"))
	{
		debugServerConsoleMsg( self, "**********************************************************" );
		debugServerConsoleMsg( self, "BAD SPAWNER " + getName( self ) + " at " + getLocation( self ) );
		debugServerConsoleMsg( self, "**********************************************************" );
		//LOG("DESIGNER_FATAL", "BAD SPAWNER " + getName( self ) + " at " + getLocation( self ) );
		return SCRIPT_CONTINUE;
	}
	//LOG("space", "1");
	string strDefaultBehavior = getStringObjVar(self, "strDefaultBehavior");

	string strSpawnerType = getStringObjVar(self, "strSpawnerType");
	//LOG("space", "strSpawnerType is "+strSpawnerType);
	//LOG("space", "SPAWNING SPAWNING SPAWNING SPAWNING");

	if(!isSpawnerActivated(self))
	{
		return SCRIPT_CONTINUE;
	}

	if(strSpawnerType=="generic")
	{

		//LOG("space", "ENTERING GENERIC");
		// generic spawner, all we do is make spawns and stuff.. when one dies, we respawn after a duration.. tada
		string[] strSpawns = objvar_mangle.getMangledStringArrayObjVar(self, "strSpawns");
		if(strSpawns==null)
		{
			return SCRIPT_CONTINUE; // bad shit
		}

		int intSpawnCount = getIntObjVar(self, "intSpawnCount");
		float fltMinSpawnDistance = getFloatObjVar(self, "fltMinSpawnDistance");
		float fltMaxSpawnDistance = getFloatObjVar(self, "fltMaxSpawnDistance");
		float fltMinSpawnTime = getFloatObjVar(self, "fltMinSpawnTime");
		float fltMaxSpawnTime= getFloatObjVar(self, "fltMaxSpawnTime");


		//LOG("space", "intSpawnCount is "+intSpawnCount);
		transform trMyLocation = getTransform_o2w(self);
		for(int intI = 0; intI<intSpawnCount; intI++)
		{
			/// make our crap
			string strSpawn = strSpawns[rand(0, strSpawns.length-1)];
			// we do NOT Create these.
			//We instead message to ourselves a bunch of times
			// and that creates the stuff
			float fltDelay = 1.0f;
			fltDelay = rand(fltMinSpawnTime, fltMaxSpawnTime);

			string[] strLoopSpawns = new string[1];
			strLoopSpawns[0] = strSpawn;
			dictionary dctParams = new dictionary();
			dctParams.put("strSpawns", strLoopSpawns);
			messageTo(self, "createSpawns", dctParams, fltDelay * intI, false);
		}

	}
	else if(strSpawnerType=="asteroid")
	{
		//LOG("space", "ENTERING ASTEROID");
		//asteroid spawner---spawns asteroids!
		string strAsteroidType = getStringObjVar(self, "strAsteroidType");
		int intMinResourcePool = getIntObjVar(self, "intMinResourcePool");
		int intMaxResourcePool = getIntObjVar(self, "intMaxResourcePool");
		int intDangerLevel = getIntObjVar(self, "intDangerLevel");
		int intDangerPct = getIntObjVar(self, "intDangerPct");

		if(strAsteroidType == "")
			return SCRIPT_CONTINUE;

		transform trMyLocation = getTransform_o2w(self);

		float fltDelay = 1.0f;
		dictionary dctParams = new dictionary();
		dctParams.put("strAsteroidType", strAsteroidType);
		dctParams.put("intMinResourcePool", intMinResourcePool);
		dctParams.put("intMaxResourcePool", intMaxResourcePool);
		dctParams.put("intDangerLevel", intDangerLevel);
		dctParams.put("intDangerPct", intDangerPct);
		messageTo(self, "createAsteroidSpawn", dctParams, fltDelay, false);



	}
	else if(strSpawnerType=="wave")
	{
		// we start our wave spawning at wave 0, and go throughsequential waves
		// we track fast and dirty.. we spawn x things. when all x things are destroyed, we go to the next wave
		// we dont car ebout anything else.. so make sure our counts are good
		int intWave = 0;
		utils.setScriptVar(self, "intWave", 0);

		float fltMinSpawnDistance = getFloatObjVar(self, "fltMinSpawnDistance");
		float fltMaxSpawnDistance = getFloatObjVar(self, "fltMaxSpawnDistance");
		string[] strWaves = objvar_mangle.getMangledStringArrayObjVar(self, "strWaves");
		string strFileName = "datatables/space_content/spawners/waves.iff";
		string[] strSpawns = dataTableGetStringColumnNoDefaults(strFileName, strWaves[0]);
		float fltMinSpawnTime = getFloatObjVar(self, "fltMinSpawnTime");
		float fltMaxSpawnTime= getFloatObjVar(self, "fltMaxSpawnTime");

		if(strSpawns==null)
		{
			//LOG("DESIGNER_FATAL", "Bad entry of wave type "+strWaves[0]);
			return SCRIPT_CONTINUE;
		}
		string strSpawn = strSpawns[0];
		if(!isSquad(strSpawn))
		{
			obj_id objShip = createGenericSpawn(self, strSpawn, fltMinSpawnDistance, fltMaxSpawnDistance, false);
			if(isIdValid(objShip))
			{
				setupSpawnerSpawn(objShip, self);
			}
		}
		else
		{
			resizeable obj_id[]  objMembers = space_create.createSquadHyperspace(self, strSpawn, getTransform_o2p(self), 100, null);
			if(objMembers!=null)
			{
				setupSpawnerSpawn(objMembers, self);
			}

		}
		for(int intI = 1; intI<strSpawns.length; intI++)
		{
			// we do NOT Create these.
			//We instead message to ourselves a bunch of times
			// and that creates the stuff
			float fltDelay = 1.0f;
			fltDelay = rand(fltMinSpawnTime, fltMaxSpawnTime);
			string[] strLoopSpawns = new string[1];
			strLoopSpawns[0] = strSpawns[intI];
			dictionary dctParams = new dictionary();
			dctParams.put("strSpawns", strLoopSpawns);
			messageTo(self, "createSpawns", dctParams, fltDelay * intI, false);
		}
		utils.setScriptVar(self, "intWavePopulation", strSpawns.length);

	}
	else
	{
		//LOG("space", ""+strSpawnerType+"="+"generic");
	}


	return SCRIPT_CONTINUE;
}

messageHandler spawnNextWave()
{
	//LOG("space", "2");
	//LOG("space", "IN BATTLEFIELD");


	if(!isSpawnerActivated(self))
	{
		return SCRIPT_CONTINUE;
	}


	int intWave = utils.getIntScriptVar(self, "intWave");

	float fltMinSpawnDistance = getFloatObjVar(self, "fltMinSpawnDistance");
	float fltMaxSpawnDistance = getFloatObjVar(self, "fltMaxSpawnDistance");
	string[] strWaves = objvar_mangle.getMangledStringArrayObjVar(self, "strWaves");
	string strFileName = "datatables/space_content/spawners/waves.iff";
	string[] strSpawns = dataTableGetStringColumnNoDefaults(strFileName, strWaves[intWave]);
	if(strSpawns==null)
	{
		//LOG("DESIGNER_FATAL", "Bad entry of wave type "+strWaves[intWave]);
		return SCRIPT_CONTINUE;
	}
	string strSpawn = strSpawns[0]; // first spawn, then we messageto ourself to do queued spawning
	if(!isSquad(strSpawn))
	{
		obj_id objShip = createGenericSpawn(self, strSpawn, fltMinSpawnDistance, fltMaxSpawnDistance, false);
		if(isIdValid(objShip))
		{
			setupSpawnerSpawn(objShip, self);
		}
	}
	else
	{
		resizeable obj_id[]  objMembers = space_create.createSquadHyperspace(self, strSpawn, getTransform_o2p(self), 100, null);
		if(objMembers!=null)
		{
			setupSpawnerSpawn(objMembers, self);
		}

	}
	for(int intI = 1; intI<strSpawns.length; intI++)
	{
		//LOG("space", "looping, length is "+strSpawns.length+" and intI is "+intI);
		// we do NOT Create these.
		//We instead message to ourselves a bunch of times
		// and that creates the stuff
		string[] strLoopSpawns = new string[1];
		strLoopSpawns[0] = strSpawns[intI];
		dictionary dctParams = new dictionary();
		dctParams.put("strSpawns", strLoopSpawns);
		messageTo(self, "createSpawns", dctParams, intI, false);
	}
	utils.setScriptVar(self, "intWavePopulation", strSpawns.length);
	return SCRIPT_CONTINUE;
}

messageHandler createSpawns()
{


	//LOG("space", "IN BATTLEFIELD");
	if(!isSpawnerActivated(self))
	{
		return SCRIPT_CONTINUE;
	}

	float fltMinSpawnDistance = getFloatObjVar(self, "fltMinSpawnDistance");
	float fltMaxSpawnDistance = getFloatObjVar(self, "fltMaxSpawnDistance");
	//LOG("space", "createSpawns");
	// queued object creation so we dont fuck up the gameserver. it takes a set of arrays for creation
	string[] strSpawns = params.getStringArray("strSpawns");
	for(int intI = 0; intI<strSpawns.length; intI++)
	{
		string strSpawn = strSpawns[intI];
		if(!isSquad(strSpawn))
		{
			obj_id objShip = createGenericSpawn(self, strSpawn, fltMinSpawnDistance, fltMaxSpawnDistance, false);
			if(isIdValid(objShip))
			{
				setupSpawnerSpawn(objShip, self);
			}
		}
		else
		{
			resizeable obj_id[]  objMembers = space_create.createSquadHyperspace(self, strSpawn, getTransform_o2p(self), 100, null);
			if(objMembers!=null)
			{
				setupSpawnerSpawn(objMembers, self);
			}

		}
	}
	return SCRIPT_CONTINUE;
}

messageHandler createAsteroidSpawn()
{


	if (!isSpawnerActivated(self))
	{
		return SCRIPT_CONTINUE;
	}

	string strAsteroidType = params.getString("strAsteroidType");
	int intMinResourcePool = params.getInt("intMinResourcePool");
	int intMaxResourcePool = params.getInt("intMaxResourcePool");
	int intDangerLevel = params.getInt("intDangerLevel");
	int intDangerPct = params.getInt("intDangerPct");

	obj_id objAsteroid = createAsteroidSpawn(self, strAsteroidType, intMinResourcePool, intMaxResourcePool, intDangerLevel, intDangerPct);

	return SCRIPT_CONTINUE;



}

void setupSpawnerSpawn(obj_id objShip, obj_id self)
{

	if(hasObjVar(self, "intSpawnsAllowed"))
	{
		int intSpawnsAllowed = getIntObjVar(self, "intSpawnsAllowed");
		intSpawnsAllowed = intSpawnsAllowed - 1;
		if(intSpawnsAllowed<=0)
		{
			removeObjVar(self, "intSpawnsAllowed");
			space_utils.notifyObject(self, "spawnCountReached", null);
		}
	}
	string strDefaultBehavior = getStringObjVar(self, "strDefaultBehavior");
	//LOG("space", "strDefaultBehavior is "+strDefaultBehavior);
	setObjVar(objShip, "objParent", self);
	transform trMyLocation = getTransform_o2w(self);
	if(strDefaultBehavior=="loiter")
	{

		float fltMinLoiterDistance = getFloatObjVar(self, "fltMinLoiterDistance");
		float fltMaxLoiterDistance= getFloatObjVar(self, "fltMaxLoiterDistance");
		ship_ai.spaceLoiter(objShip, trMyLocation, fltMinLoiterDistance, fltMaxLoiterDistance);

	}
	else if(strDefaultBehavior=="patrol")
	{
		transform[] trPatrolPoints = utils.getTransformArrayScriptVar(self, "trPatrolPoints");
		ship_ai.spacePatrol(objShip, trPatrolPoints);
	}
	else if (strDefaultBehavior =="patrolNoRecycle")
	{
		transform[] trPatrolPoints = utils.getTransformArrayScriptVar(self, "trPatrolPoints");
		transform trTest = trPatrolPoints[trPatrolPoints.length-1];
		location locTest = utils.getLocationFromTransform(trTest);
		addLocationTarget3d(objShip, "spawnerArrival", locTest, 64);
		if(utils.hasLocalVar(self, "objDockingStation"))
		{
			setObjVar(objShip, "objDockingStation", utils.getObjIdLocalVar(self, "objDockingStation"));
		}
		//LOG("space", "setup coords, going to location "+locTest+" trPatrolPoints length is "+trPatrolPoints.length);
		for(int intI = 0; intI < trPatrolPoints.length; intI++)
		{
			//LOG("space", "coord "+intI+" is "+trPatrolPoints[intI]);
		}
		ship_ai.spaceMoveTo(objShip, trPatrolPoints);
		//LOG("space", "Gave movbeto to "+objShip);
	}
	else if(strDefaultBehavior=="patrolFixedCircle")
	{
		float fltMinCircleDistance = getFloatObjVar(self, "fltMinCircleDistance");
		float fltMaxCircleDistance = getFloatObjVar(self, "fltMaxCircleDistance");
		float fltCircleDistance = rand(fltMinCircleDistance, fltMaxCircleDistance);
		transform trTest = getTransform_o2p(self);
		transform[] trPatrolPoints = ship_ai.createPatrolPathCircle( trTest.getPosition_p(), fltCircleDistance);
		ship_ai.spacePatrol(objShip, trPatrolPoints);
	}
	else if(strDefaultBehavior=="patrolRandomPath")
	{
		float fltMinCircleDistance = getFloatObjVar(self, "fltMinCircleDistance");
		float fltMaxCircleDistance = getFloatObjVar(self, "fltMaxCircleDistance");
		float fltCircleDistance = rand(fltMinCircleDistance, fltMaxCircleDistance);
		transform trTest = getTransform_o2p(self);

		//transform trFinalTransform = space_utils.randomizeTransformOrientation(trTest);
		transform[] trPatrolPoints = ship_ai.createPatrolPathLoiter(trTest, fltMinCircleDistance, fltMaxCircleDistance);
		ship_ai.spacePatrol(objShip, trPatrolPoints);
	}
	else
	{
		// NOTHING!
	}
	if(hasObjVar(self, "objAttackTarget"))
	{
		dictionary dctParams = new dictionary();
		dctParams.put("objShip", objShip);
		space_utils.notifyObject(self, "singleAttackerSpawned", dctParams);
	}


	return;
}
void setupSpawnerSpawn(resizeable obj_id[] objMembers, obj_id self)
{
	// ITS A SQUAD!@!@

	for ( int i=0; i<objMembers.length; i++ )
	{
		setObjVar( objMembers[i], "objParent", self );
	}

	if(hasObjVar(self, "intSpawnsAllowed"))
	{
		int intSpawnsAllowed = getIntObjVar(self, "intSpawnsAllowed");
		intSpawnsAllowed = intSpawnsAllowed - objMembers.length;
		if(intSpawnsAllowed<=0)
		{
			removeObjVar(self, "intSpawnsAllowed");
			space_utils.notifyObject(self, "spawnCountReached", null);
		}
	}

	string strDefaultBehavior = getStringObjVar(self, "strDefaultBehavior");
	//LOG("space", "strDefaultBehavior is "+strDefaultBehavior);

	transform trMyLocation = getTransform_o2w(self);
	int intSquadId = ship_ai.unitGetSquadId(objMembers[0]);
	if(strDefaultBehavior=="loiter")
	{
		float fltMinLoiterDistance = getFloatObjVar(self, "fltMinLoiterDistance");
		float fltMaxLoiterDistance= getFloatObjVar(self, "fltMaxLoiterDistance");
		ship_ai.squadLoiter(intSquadId, trMyLocation, fltMinLoiterDistance, fltMaxLoiterDistance);
	}
	else if(strDefaultBehavior=="patrol")
	{
		transform[] trPatrolPoints = utils.getTransformArrayScriptVar(self, "trPatrolPoints");
		ship_ai.squadAddPatrolPath(intSquadId, trPatrolPoints);
	}
	else if (strDefaultBehavior =="patrolNoRecycle")
	{
		transform[] trPatrolPoints = utils.getTransformArrayScriptVar(self, "trPatrolPoints");
		transform trTest = trPatrolPoints[trPatrolPoints.length-1];
		location locTest = utils.getLocationFromTransform(trTest);
		addLocationTarget3d(objMembers[0], "leaderSpawnerArrival", locTest, 16);
		//LOG("space", "setup coords, going to location "+locTest);
		ship_ai.squadMoveTo(intSquadId, trPatrolPoints);
	}
	else if(strDefaultBehavior=="patrolFixedCircle")
	{
		float fltMinCircleDistance = getFloatObjVar(self, "fltMinCircleDistance");
		float fltMaxCircleDistance = getFloatObjVar(self, "fltMaxCircleDistance");
		float fltCircleDistance = rand(fltMinCircleDistance, fltMaxCircleDistance);
		transform trTest = getTransform_o2p(self);

		transform[] trPatrolPoints = ship_ai.createPatrolPathCircle( trTest.getPosition_p(), fltCircleDistance);
		ship_ai.squadAddPatrolPath(intSquadId , trPatrolPoints);
	}
	else if(strDefaultBehavior=="patrolRandomPath")
	{
		float fltMinCircleDistance = getFloatObjVar(self, "fltMinCircleDistance");
		float fltMaxCircleDistance = getFloatObjVar(self, "fltMaxCircleDistance");
		float fltCircleDistance = rand(fltMinCircleDistance, fltMaxCircleDistance);
		transform trTest = getTransform_o2p(self);

		//transform trFinalTransform = space_utils.randomizeTransformOrientation(trTest);
		transform[] trPatrolPoints = ship_ai.createPatrolPathLoiter(trTest, fltMinCircleDistance, fltMaxCircleDistance);
		ship_ai.squadAddPatrolPath(intSquadId , trPatrolPoints);
	}
	else
	{
		// NOTHING!
	}
	if(hasObjVar(self, "objAttackTarget"))
	{
		dictionary dctParams = new dictionary();
		dctParams.put("objMembers", objMembers);
		space_utils.notifyObject(self, "squadAttackerSpawned", dctParams);
	}

	return;
}


messageHandler childDestroyed()
{
	//LOG("space", "childDestroyed!");
	// we do our recycle stuff
	//LOG("space", "3");
	//LOG("space", "IN BATTLEFIELD");
	if(!isSpawnerActivated(self))
	{
		return SCRIPT_CONTINUE;
	}


	string strSpawnerType = getStringObjVar(self, "strSpawnerType");
	if(strSpawnerType=="generic")
	{
		float fltMinSpawnTime = getFloatObjVar(self, "fltMinSpawnTime");
		float fltMaxSpawnTime= getFloatObjVar(self, "fltMaxSpawnTime");
		float fltRespawnTime = rand(fltMinSpawnTime, fltMaxSpawnTime);
		messageTo(self, "respawnShip", null, fltRespawnTime, false);
	}
	if(strSpawnerType=="asteroid")
	{
		messageTo(self, "respawnAsteroid", null, 3, false);
	}
	if(strSpawnerType=="wave")
	{
		int intWavePopulation = utils.getIntScriptVar(self, "intWavePopulation");
		intWavePopulation = intWavePopulation -1;
		if(intWavePopulation<=0)
		{
			// WAVE IS DONE
			int intWave = utils.getIntScriptVar(self, "intWave");
			string[] strWaves = objvar_mangle.getMangledStringArrayObjVar(self, "strWaves");
			intWave = intWave+1;

			if(intWave>=strWaves.length)
			{
				intWave = 0;
				utils.setScriptVar(self, "intWave", intWave);
				float fltMinResetTime = getFloatObjVar(self, "fltMinResetTime");
				float fltMaxResetTime = getFloatObjVar(self, "fltMaxResetTime");
				float fltTime = rand(fltMinResetTime, fltMaxResetTime);
				// time is the spawner reset time
				//LOG("space", "respawn time for global spawner is "+fltTime);
				messageTo(self, "spawnNextWave", null, fltTime, false);

			}
			else
			{
				// time is the  wave reset time
				utils.setScriptVar(self, "intWave", intWave);
				float fltMinWaveSpawnTime = getFloatObjVar(self, "fltMinWaveSpawnTime");
				float fltMaxWaveSpawnTime = getFloatObjVar(self, "fltMaxWaveSpawnTime");
				float fltTime = rand(fltMinWaveSpawnTime, fltMaxWaveSpawnTime);
				//LOG("space", "respawn time for individual wave is "+fltTime);

				messageTo(self, "spawnNextWave", null, fltTime, false);
			}

		}
		else
		{
			utils.setScriptVar(self, "intWavePopulation", intWavePopulation);
		}

	}
	return SCRIPT_CONTINUE;

}

messageHandler respawnAsteroid()
{
	if(!isSpawnerActivated(self))
	{
		return SCRIPT_CONTINUE;
	}

	string strAsteroidType = getStringObjVar(self, "strAsteroidType");
	int intMinResourcePool = getIntObjVar(self, "intMinResourcePool");
	int intMaxResourcePool = getIntObjVar(self, "intMaxResourcePool");
	int intDangerLevel = getIntObjVar(self, "intDangerLevel");
	int intDangerPct = getIntObjVar(self, "intDangerPct");


	obj_id objAsteroid = createAsteroidSpawn(self, strAsteroidType, intMinResourcePool, intMaxResourcePool, intDangerLevel, intDangerPct);

	return SCRIPT_CONTINUE;
}

messageHandler respawnShip()
{
	// when a ship dies, it'll respawn.
	//LOG("space", "4");
	//LOG("space", "IN BATTLEFIELD");


	if(!isSpawnerActivated(self))
	{
		return SCRIPT_CONTINUE;
	}


	string[] strSpawns = objvar_mangle.getMangledStringArrayObjVar(self, "strSpawns");

	float fltMinSpawnDistance = getFloatObjVar(self, "fltMinSpawnDistance");
	float fltMaxSpawnDistance = getFloatObjVar(self, "fltMaxSpawnDistance");
	string strDefaultBehavior = getStringObjVar(self, "strDefaultBehavior");

	transform trMyLocation = getTransform_o2w(self);
	string strSpawn = strSpawns[rand(0, strSpawns.length-1)];
	//LOG("space", "spawning "+strSpawn);

	if(!isSquad(strSpawn))
	{
		obj_id objShip = createGenericSpawn(self, strSpawn, fltMinSpawnDistance, fltMaxSpawnDistance, false);
		if(isIdValid(objShip))
		{
			setupSpawnerSpawn(objShip, self);
		}
	}
	else
	{
		resizeable obj_id[]  objMembers = space_create.createSquadHyperspace(self, strSpawn, getTransform_o2p(self), 100, null);
		if(objMembers!=null)
		{
			setupSpawnerSpawn(objMembers, self);
		}

	}



	return SCRIPT_CONTINUE;
}

obj_id createGenericSpawn(obj_id objSpawner, string strShipType, float fltMinDistance, float fltMaxDistance, boolean boolRandomizeOrientation)
{

	obj_id objShip = null;

	if(hasObjVar(objSpawner, "intLaunchFromDockingPoint"))
	{
		objShip = space_create.createShip(strShipType, getTransform_o2p(objSpawner), null);
		transform trTest = ship_ai.unitGetDockTransform(objSpawner, objShip);
		//LOG("space", "setting "+objShip+" to "+trTest);
		setTransform_o2p(objShip, trTest);
	}
	else
	{
		transform trSpawnLocation= space_utils.getRandomPositionInSphere(getTransform_o2w(objSpawner), fltMinDistance, fltMaxDistance, boolRandomizeOrientation);
		objShip = space_create.createShipHyperspace(strShipType, trSpawnLocation, null);
		//objShip = space_create.createShip(strShipType, trSpawnLocation, null);
	}
	if(isIdValid(objShip))
	{
		setObjVar(objShip, "intNoDump", 1);
		return objShip;

	}
	return null;

}

obj_id createAsteroidSpawn(obj_id objSpawner, string strAsteroidType, int intMinResourcePool, int intMaxResourcePool, int intDangerLevel, int intDangerPct)
{

	string strAsteroidTable = "datatables/space_mining/mining_asteroids.iff";
	transform trSpawnLocation= space_utils.getRandomPositionInSphere(getTransform_o2w(objSpawner), 0, 1, true);
	obj_id objAsteroid = null;
	if (strAsteroidType == "iron")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "iron", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "silicaceous")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "silicaceous", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "carbonaceous")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "carbonaceous", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "ice")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "ice", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "obsidian")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "obsidian", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "diamond")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "diamond", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "crystal")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "crystal", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "petrochem")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "petrochem", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "acid")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "acid", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "cyanomethanic")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "cyanomethanic", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "sulfuric")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "sulfuric", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "methane")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "methane", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else if (strAsteroidType == "organometallic")
	{
		int choice = rand(1, 2);
		string template = dataTableGetString(strAsteroidTable, "organometallic", choice);
		objAsteroid = createObject(template, trSpawnLocation, null);
	}
	else
	{
		objAsteroid = null;
	}

	setObjVar(objAsteroid, "objParent", objSpawner);
	setObjVar(objAsteroid, "strAsteroidType", strAsteroidType);
	setObjVar(objAsteroid, "intMinResourcePool", intMinResourcePool);
	setObjVar(objAsteroid, "intMaxResourcePool", intMaxResourcePool);
	setObjVar(objAsteroid, "intDangerLevel", intDangerLevel);
	setObjVar(objAsteroid, "intDangerPct", intDangerPct);
	setObjVar(objAsteroid, "intNoDump", 1);

	int resourcePool = rand(intMinResourcePool, intMaxResourcePool);
	setMaxHitpoints(objAsteroid, resourcePool);
	setHitpoints(objAsteroid, resourcePool);

	return objAsteroid;

}





messageHandler destroyableCreated()
{
	obj_id objDestroyable = params.getObjId("objDestroyable");
	obj_id objParent = params.getObjId("objParent");
	deltadictionary dctScriptVars = self.getScriptVars();
	return SCRIPT_CONTINUE;
}


void  addDestroyable(obj_id objParent, obj_id objDestroyable)
{
	obj_id self = getSelf();
	obj_id objMom = getObjIdObjVar(objParent, "objParent");
	dictionary dctParams = new dictionary();
	dctParams.put("objParent", self);
	dctParams.put("objDestroyable", objDestroyable);
	messageTo(objMom, "destroyableCreated", dctParams, 1, false);
	return;
}
void RemoveDestroyable(obj_id objParent, obj_id objDestroyable)
{

	obj_id self = getSelf();
	obj_id objMom = getObjIdObjVar(objParent, "objParent");
	dictionary dctParams = new dictionary();
	dctParams.put("objParent", self);
	dctParams.put("objDestroyable", objDestroyable);
	messageTo(objMom, "destroyableDestroyed", dctParams, 1, false);
	return;
}


void writeSpawner(obj_id self)
{
	sendSystemMessageTestingOnly(self, "Writing spawner");

	obj_id objSpawner = createObject("object/tangible/space/content_infrastructure/basic_iff", getTransform_o2w(self), null);

	string strSpawnerType = utils.getStringScriptVar(self, "strSpawnerType");

	if(strSpawnerType=="generic")
	{
		string[] strSpawns = utils.getStringArrayScriptVar(self, "strSpawns");
		float fltMinSpawnDistance = utils.getFloatScriptVar(self, "fltMinSpawnDistance");
		float fltMaxSpawnDistance = utils.getFloatScriptVar(self, "fltMaxSpawnDistance");
		float fltMinSpawnTime = utils.getFloatScriptVar(self, "fltMinSpawnTime");
		float fltMaxSpawnTime = utils.getFloatScriptVar(self, "fltMaxSpawnTime");

		int intSpawnCount = utils.getIntScriptVar(self, "intSpawnCount");
		setObjVar(objSpawner, "strSpawnerType", strSpawnerType);
		setObjVar(objSpawner, "fltMinSpawnDistance",fltMinSpawnDistance);
		setObjVar(objSpawner, "fltMaxSpawnDistance", fltMaxSpawnDistance);
		setObjVar(objSpawner, "fltMinSpawnTime", fltMinSpawnTime);
		setObjVar(objSpawner, "fltMaxSpawnTime", fltMaxSpawnTime);
		setObjVar(objSpawner, "strSpawns", strSpawns);
	}




	string strDefaultBehavior = utils.getStringScriptVar(self, "strDefaultBehavior");
	setObjVar(objSpawner, "strDefaultBehavior", strDefaultBehavior);
	if(strDefaultBehavior=="loiter")
	{
		float fltMinLoiterDistance = utils.getFloatScriptVar(self, "fltMinLoiterDistance");
		float fltMaxLoiterDistance = utils.getFloatScriptVar(self, "fltMaxLoiterDistance");
		setObjVar(objSpawner, "fltMinLoiterDistance", fltMinLoiterDistance);
		setObjVar(objSpawner, "fltMaxLoiterDistance", fltMaxLoiterDistance);


	}
	else if(strDefaultBehavior=="patrol")
	{
		// patrol points? are tehse transfroms?
		string strPatrolPointName = utils.getStringScriptVar(self, "strPatrolPointName");

		resizeable string[] strPatrolPoints = new string[0];
		obj_id[] objPatrolPoints = utils.getObjIdArrayScriptVar(self, "objPatrolPoints");
		for(int intI = 0; intI<objPatrolPoints.length; intI++)
		{
			string strTest = strPatrolPointName+"_"+(intI+1); // path points start at 1. shutup
			strPatrolPoints = utils.addElement(strPatrolPoints, strTest);
			setObjVar(objPatrolPoints[intI], "strName", strTest);

		}
		if(strPatrolPoints.length>0)
		{
			setObjVar(objSpawner, "strPatrolPoints", strPatrolPoints);
		}
		utils.setScriptVar(objSpawner, "objPatrolPoints", objPatrolPoints);
		// NAME THE BASTICHES

	}





}

boolean isSquad(string strSpawn)
{
	int intIndex = strSpawn.indexOf("squad_");
	if(intIndex>-1)
	{
		return true;
	}
	return false;

}