//////////////////////////////////////////////
// FS Combat Quest Phase 3 -- Counterstrike //
//////////////////////////////////////////////

// INCLUDES
include library.create;
include library.fs_dyn_village;
include library.trace;
include library.utils;
include library.locations;

// STRING constants
const string	MOUSE_DROID_NAME_ID		= "name_mdroid_";
const string	SHIELD_TR_VOLUME		= "fs_camp.tr_volume";
const string	CAMP_DOOR_TEMPLATE		= "object/installation/battlefield/destructible/bfield_base_gate_impl.iff";
const string	CAMP_ANTENNA_TEMPLATE	= "object/installation/battlefield/destructible/antenna_tatt_style_1.iff";
const string	CAMP_TURRET_TEMPLATE	= "object/installation/turret/generic_turret_block_sm.iff";
const string	CAMP_TENT_TEMPLATE	 	= "object/static/structure/corellia/corl_tent_hut_s01.iff";

// NUMERIC constants
const float 	SHIELD_RADIUS			= 50.0f;
const float		SHIELD_REMOTE_RANGE		= 75.0f; // 100 m
const int		MAX_DROIDS_FOR_CAMP		= 5;
const float		MIN_DROID_DISTANCE		= 75.0f;
const float		MAX_DROID_DISTANCE		= 100.0f;
const float		CAMP_SHIELD_REBOOT_TIME	= 7200.0f; // 2.0 hours after being powered down, the shield goes back up (camp resets)
const int		CAMP_BOSS_DEATH_TIME	= 3600; // 1 hour after being spawned
const int		CAMP_REINFORCEMENT_MIN	= 90;  // every 1.5 minutes
const int	 	CAMP_REINFORCEMENT_MAX	= 180;  // every 3 minutes minutes
const int		CAMP_LOOT_SPAWN_INTERVAL = 700;
const int		NUM_LOOT_SPAWNS_PER_CAMP = 2;
const float		MIN_LOOT_SPAWN_DISTANCE	= 200f;
const float		MAX_LOOT_SPAWN_DISTANCE	= 300f;


// DATATABLE constants
const string	DT_TABLE_NAME			= "datatables/fs_quests/fs_counterstrike.iff";
const string	DT_TABLE_POI_NAME		= "datatables/theater/fs_quest_combat3/fs_quest_combat3.iff";
const string	DT_COL_CAMP_NUM			= "camp_number";
const string 	DT_COL_CAMP_NAME		= "camp_name";
const string	DT_COL_LOC_X			= "loc_x";
const string 	DT_COL_LOC_Y			= "loc_y";
const string	DT_COL_LOC_Z			= "loc_z";
const string 	DT_COL_CAMP_RADIUS		= "camp_radius";

// OBJVAR constants
const string	OBJVAR_CAMP_NAME			= "fs_cs.camp.name";
const string	OBJVAR_MY_CAMP_ID			= "fs_cs.camp.id";
const string 	OBJVAR_CREATED_CAMP_IDS 	= "fs_cs.camps.created.ids";
const string  	OBJVAR_CREATED_CAMP_LOCS	= "fs_cs.camps.created.locs";
const string 	OBJVAR_PHASE_CAMP_NAMES 	= "fs_cs.camps.hints.names";
const string  	OBJVAR_PHASE_CAMP_LOC_HINTS	= "fs_cs.camps.hints.locs";

const string	OBJVAR_CAMP_DOOR1			= "fs_cs.camp.door1";
const string	OBJVAR_CAMP_DOOR1_LOC		= "fs_cs.camp.door1Loc";
const string	OBJVAR_CAMP_DOOR1_YAW		= "fs_cs.camp.door1Yaw";

const string	OBJVAR_CAMP_DOOR2			= "fs_cs.camp.door2";
const string	OBJVAR_CAMP_DOOR2_LOC		= "fs_cs.camp.door2Loc";
const string	OBJVAR_CAMP_DOOR2_YAW		= "fs_cs.camp.door2Yaw";

const string	OBJVAR_CAMP_TURRET1			= "fs_cs.camp.turret1";
const string	OBJVAR_CAMP_TURRET1_LOC		= "fs_cs.camp.turret1Loc";
const string	OBJVAR_CAMP_TURRET1_YAW		= "fs_cs.camp.turret1Yaw";

const string	OBJVAR_CAMP_TURRET2			= "fs_cs.camp.turret2";
const string	OBJVAR_CAMP_TURRET2_LOC		= "fs_cs.camp.turret2Loc";
const string	OBJVAR_CAMP_TURRET2_YAW		= "fs_cs.camp.turret2Yaw";

const string	OBJVAR_CAMP_TURRET3			= "fs_cs.camp.turret3";
const string	OBJVAR_CAMP_TURRET3_LOC		= "fs_cs.camp.turret3Loc";
const string	OBJVAR_CAMP_TURRET3_YAW		= "fs_cs.camp.turret3Yaw";

const string	OBJVAR_CAMP_TENT_LOC		= "fs_cs.camp.tentLoc";

const string	OBJVAR_CAMP_COMMANDER		= "fs_cs.camp.commander";
const string	OBJVAR_CAMP_COMMANDER_TAKER	= "fs_cs.camp.commanderTakers";
const string	OBJVAR_CAMP_SHIELD_KILLER	= "fs_cs.camp.shieldKiller"; // person who powered down the shield
const string	OBJVAR_CAMP_ANTENNA			= "fs_cs.camp.antenna";
const string	OBJVAR_CAMP_ANTENNA_LOC		= "fs_cs.camp.antennaLoc";
const string 	OBJVAR_CAMP_OBJS			= "fs_cs.camp.allObjs";
const string	OBJVAR_CAMP_DROIDS			= "fs_cs.camp.droids";
const string	OBJVAR_IS_REMOTE_RECEIVER	= "fs_cs.camp.isReceiver"; // this is the object that counts as the remote receiver
const string	OBJVAR_STOP_DEFENSE_SPAWN	= "fs_cs.camp.stopDefenses";
const string	OBJVAR_CAMP_GUARDS_KILLED	= "fs_cs.campGuardKilled"; // integer of how many camp guards we were responsible for doing most damage to
const string	OBJVAR_BORN_ON				= "fs_cs.creationDate";


// NUMERIC constants
const int		MAX_NUM_CAMPS_PER_CYCLE	= 20; // maximum number of camps to generate per phase

void doCampLootSpawn(obj_id camp)
{
	location here = getLocation(camp);
	location where = utils.getRandomAwayLocation(here, MIN_LOOT_SPAWN_DISTANCE, MAX_LOOT_SPAWN_DISTANCE);
	obj_id spawner = null;
	long seed = 0;

	for(int i = 0; i < NUM_LOOT_SPAWNS_PER_CAMP; i++)
	{
		spawner = quests.createSpawner("fs_counterstrike_loot", where, fs_dyn_village.CITY_BAD_GUY_SPAWN_TABLE, camp);

		if(isIdValid(spawner))
		{
			setObjVar(camp, "fs_cs.lastLootSpawnCreated", where);
			seed = spawner.getValue();
			while(seed > Integer.MAX_VALUE)
			{
				seed /= 2;
			}
			trace.log(fs_dyn_village.LOG_CHAN, "Created camp loot spawner " + spawner + " at " + where.toString());
		}
		reseed((int)seed);
	}

	messageTo(camp, "msgDoLootSpawn", null, (float)CAMP_LOOT_SPAWN_INTERVAL, false);
}

void resetPlayer(obj_id player)
{
	string[] possibleSteps = new string[]
	{
		"fs_cs_intro",
		"fs_cs_kill5_guards",
		"fs_cs_ensure_capture",
		"fs_cs_last_chance",
		"fs_cs_escort_commander_pri",
		"fs_cs_escort_commander_sec",
		"fs_cs_quest_done",
		"fs_cs_quest_failed_escort"
	};

	obj_id questGiver = null;
	for(int i = 0; i < possibleSteps.length; i++)
	{
		if(quests.isActive(possibleSteps[i], player))
		{
			trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::resetPlayer: -> System removed player from quest and quest step " + possibleSteps[i] + ". Quest timed out.", player, trace.TL_CS_LOG);
			questGiver = getCurrentQuestGiver(player, possibleSteps[i]);
			quests.deactivate(possibleSteps[i], player);
		}
	}

	for (int x = 0; x < possibleSteps.length; x++)
	{
		if (quests.isComplete(possibleSteps[x], player))
		{
			clearCompletedQuest(player, quests.getQuestId(possibleSteps[x]));
		}
	}

	if(hasObjVar(player, "fs_cs.returnCommanderWaypoint"))
	{
		destroyWaypointInDatapad(getObjIdObjVar(player, "fs_cs.returnCommanderWaypoint"), player);
	}

	removeObjVar(player, "fs_cs");
	if(!hasScript(player, "systems.fs_quest.fs_cs_player"))
	{
		attachScript(player, "systems.fs_quest.fs_cs_player");
	}

	return;
}

//
// clears all possible steps the player may be on and resets them to the beginning quest.
//
void resetPlayerToStart(obj_id player, obj_id questGiver)
{
	string[] possibleSteps = new string[]
	{
		"fs_cs_intro",
		"fs_cs_kill5_guards",
		"fs_cs_ensure_capture",
		"fs_cs_last_chance",
		"fs_cs_escort_commander_pri",
		"fs_cs_escort_commander_sec",
		"fs_cs_quest_done",
		"fs_cs_quest_failed_escort"
	};

	for(int i = 0; i < possibleSteps.length; i++)
	{
		if(quests.isActive(possibleSteps[i], player))
		{
			trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::resetPlayerToStart: -> Player was still in active quest step " + possibleSteps[i], player, trace.TL_WARNING);
			questGiver = getCurrentQuestGiver(player, possibleSteps[i]);
			quests.complete(possibleSteps[i], player, false);
		}

		clearCompletedQuest(player, quests.getQuestId(possibleSteps[i]));
	}

	destroyCommanderRescueWaypoint(player);
	removeObjVar(player, "fs_cs");
	quests.activate("fs_cs_intro", player, questGiver);
	return;
}


void destroyCommanderRescueWaypoint(obj_id player)
{
	if(hasObjVar(player, "fs_cs.returnCommanderWaypoint"))
	{
		destroyWaypointInDatapad(getObjIdObjVar(player, "fs_cs.returnCommanderWaypoint"), player);
		removeObjVar(player, "fs_cs.returnCommanderWaypoint");
	}

	return;
}

boolean isShortCommanderRescue()
{
	string config = getConfigSetting("GameServer", "FS_P3_ShortCommanderRescue");
	if(config != null)
	{
		if(toLower(config).equals("true") || config.equals("1"))
		{
			return true;
		}
	}

	return false;
}

float getCampResetTime()
{
	string config = getConfigSetting("GameServer", "FS_P3_CampResetTime");
	if(config == null)
	{
		return CAMP_SHIELD_REBOOT_TIME;
	}

	int value = utils.stringToInt(config);
	if(value > 0)
	{
		return (float)value;
	}

	return CAMP_SHIELD_REBOOT_TIME;
}

float getCampBossDeathTime()
{
	string config = getConfigSetting("GameServer", "FS_P3_CampBossDeathTime");
	if(config == null)
	{
		return CAMP_BOSS_DEATH_TIME;
	}

	int value = utils.stringToInt(config);
	if(value > 0)
	{
		return (float)value;
	}

	return CAMP_BOSS_DEATH_TIME;
}


//
//  marks creation time on an item
//
void markPhaseItemCreated(obj_id item)
{
	setObjVar(item, OBJVAR_BORN_ON, getGameTime());
	return;
}

//
//  checks to see if the phase item needs to be disabled and then does so if it s
//
void checkPhaseItemDisable(obj_id item, int phase)
{
	if(getPhaseItemPercentDecay(item, phase) >= 100)
	{
		setCondition(item, CONDITION_DISABLED);
	}
	return;
}

//
//  returns a whole number indicating the % of decay on the item
//
int getPhaseItemPercentDecay(obj_id item, int phase)
{
	if(!hasObjVar(item, OBJVAR_BORN_ON))
	{
		return 0;
	}

	int bornOn = getIntObjVar(item, OBJVAR_BORN_ON);
	int now = getGameTime();
	float phaseDuration = fs_dyn_village.getPhaseDuration(phase);
	float itemAge = now - bornOn;
	int percentDecay = (int)((itemAge/phaseDuration) * 100);

	// sanity check
	if(percentDecay > 100)
	{
		percentDecay = 100;
	}

	return percentDecay;
}

//
// returns a vector with 2 elements [0] = all locs; [1] = all names
// as the theatre construction may place the forts at a slightly different location
//
Vector getAllCampHintsFromDT()
{
	int numRows = dataTableGetNumRows(DT_TABLE_NAME);
	Vector locs = new Vector();
	Vector names = new Vector();

	dictionary curRow = null;
	location loc = null;

	for(int i = 0; i < numRows; i++)
	{
		// camp_names	locs_x	locs_y	locs_z
		curRow = dataTableGetRow(DT_TABLE_NAME, i);
		if(!curRow.containsKey("camp_names") || !curRow.containsKey("locs_x") || !curRow.containsKey("locs_y") || !curRow.containsKey("locs_z"))
		{
			trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::getAllFortHintsFromDT: -> Bad data table data. Skipping row " + i, null, trace.TL_ERROR_LOG);
			continue;
		}

		names.add(curRow.getString("camp_names"));
		loc = new location(curRow.getFloat("locs_x"), curRow.getFloat("locs_y"), curRow.getFloat("locs_z"));
		locs.add(loc);
	}


	Vector rslt = new Vector();
	rslt.add(locs);
	rslt.add(names);

	return rslt;
}

int getMaxCampsPerCycle()
{
	string config = getConfigSetting("GameServer", "FS_MaxPhase3EnemyCamps");
	int value = utils.stringToInt(config);
	if (value > 0)
	{
		return value;
	}

	return MAX_NUM_CAMPS_PER_CYCLE;
}

boolean isOnCsQuest(obj_id player)
{
	return quests.isActive("fs_cs_intro", player) ||
			quests.isActive("fs_cs_kill5_guards", player) ||
			quests.isActive("fs_cs_ensure_capture", player) ||
			quests.isActive("fs_cs_last_chance", player) ||
			quests.isActive("fs_cs_escort_commander_sec", player) ||
			quests.isActive("fs_cs_quest_done", player) ||
			quests.isActive("fs_cs_escort_commander_pri", player);

}


//
//  method reads a data table and picks MAX_NUM_CAMPS_PER_CYCLE from the list and writes them to the master
//
void pickAndWriteCycleNamesAndLocs(obj_id villageMaster)
{
	trace.log(fs_dyn_village.LOG_CHAN, "Updating location hints and names used for this cycle.");
	// get previously chosen camp names and loc hints that may or may not have been chosen previously
	Vector phaseNames = new Vector();
	Vector phaseLocs = new Vector();

	if(hasObjVar(villageMaster, OBJVAR_PHASE_CAMP_NAMES))
	{
		phaseNames = getResizeableStringArrayObjVar(villageMaster, OBJVAR_PHASE_CAMP_NAMES);
	}

	if(hasObjVar(villageMaster, OBJVAR_PHASE_CAMP_LOC_HINTS))
	{
		phaseLocs = getResizeableLocationArrayObjVar(villageMaster, OBJVAR_PHASE_CAMP_LOC_HINTS);
	}

	if(phaseNames == null || phaseLocs == null || phaseNames.size() != phaseLocs.size())
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::pickAndWriteCycleNamesAndLocs: created camp names.length=" + phaseNames.size() + ", locs=" + phaseLocs.size() +".",
			villageMaster, trace.TL_ERROR_LOG);
		return;
	}

	int maxCamps = getMaxCampsPerCycle();
	while(phaseNames.size() > maxCamps)
	{
		phaseNames.removeElementAt(0);
		phaseLocs.removeElementAt(0);
	}

	// get the complete set of names and location hints available from the datatable
	Vector campsDat = getAllCampHintsFromDT();
	if(campsDat.size() != 2)
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::pickAndWriteCycleNamesAndLocs: -> getAllCampHints returned badly structured data. Camps not determine camp info for this cycle.", null, trace.TL_ERROR_LOG);
		return;
	}

	// these are the data table hints of locs and names available for camps
	Vector locs = (Vector)campsDat.get(0);
	Vector names = (Vector)campsDat.get(1);


	trace.log(fs_dyn_village.LOG_CHAN, "DT has " + locs.size() + " locs and " + names.size() + " names.");
	// remove any previously chosen names and locs from the pool of availables
	int idx = -1;
	for(int i = 0; i < phaseNames.size(); i++)
	{
		// remove name
		idx = names.indexOf(phaseNames.get(i));
		if(idx > -1)
		{
			names.removeElementAt(idx);
		}

		// remove loc
		idx = locs.indexOf(phaseLocs.get(i));
		if(idx > -1)
		{
			locs.removeElementAt(idx);
		}
	}

	// pick any additional phase locs/names based on maxCamps
	for(int x = 0; phaseNames.size() < maxCamps && names.size() > 0; x++)
	{
		idx = rand(0, locs.size() -1);
		phaseLocs.add(locs.get(idx));
		trace.log(fs_dyn_village.LOG_CHAN, "Camp LOC " + phaseLocs.size() + " for this cycle is " + locs.get(idx).toString());
		locs.removeElementAt(idx);
		reseed(getGameTime() + idx + 222);

		idx = rand(0, names.size() - 1);
		phaseNames.add(names.get(idx));
		trace.log(fs_dyn_village.LOG_CHAN, "Camp NAME " + phaseNames.size() + " for this cycle is " + names.get(idx).toString());
		names.removeElementAt(idx);
		reseed(getGameTime() + idx + 777);
	}

	trace.log(fs_dyn_village.LOG_CHAN, "_picknames: phaseNames.size()=" + phaseNames.size() + ", phaseLocs.size()=" + phaseLocs.size());
	setObjVar(villageMaster, OBJVAR_PHASE_CAMP_NAMES, phaseNames);
	setObjVar(villageMaster, OBJVAR_PHASE_CAMP_LOC_HINTS, phaseLocs);

	return;
}

//
//  creates all of the theatres for this phase and starts the registration process with the village master
//
void initializeEnemyCamps(obj_id villageMaster)
{
	trace.log(fs_dyn_village.LOG_CHAN, "Init Enemy Camps.");
	// make sure we have our camp name and location hints written out
	pickAndWriteCycleNamesAndLocs(villageMaster);

	// create the camps and write the obj_ids of the theatre master objects to the village master
	_createEnemyCamps(villageMaster);
	return;
}

//
// creates all village enemy camps for the current cycle.
//
void _createEnemyCamps(obj_id villageMaster)
{
	trace.log(fs_dyn_village.LOG_CHAN, "Creating Enemy Camps from hint data.");
	Vector phaseLocs = new Vector();
	Vector phaseNames = new Vector();

	if(hasObjVar(villageMaster, OBJVAR_PHASE_CAMP_NAMES))
	{
		phaseNames = getResizeableStringArrayObjVar(villageMaster, OBJVAR_PHASE_CAMP_NAMES);
	}

	if(hasObjVar(villageMaster, OBJVAR_PHASE_CAMP_LOC_HINTS))
	{
		phaseLocs = getResizeableLocationArrayObjVar(villageMaster, OBJVAR_PHASE_CAMP_LOC_HINTS);
	}

	trace.log(fs_dyn_village.LOG_CHAN, "_createEnemeyCamps: phaseNames null=" + (phaseNames == null));
	trace.log(fs_dyn_village.LOG_CHAN, "_createEnemeyCamps: phaseLocs null=" + (phaseLocs == null));
	if(phaseNames == null || phaseLocs == null || phaseNames.size() != phaseLocs.size())
	{
		trace.log(fs_dyn_village.LOG_CHAN,
			"fs_counterstrike::_createEnemyCamps: -> phaseNames.size != phaseLocs.size - cannot create enemy camp.  Data mismatch.", villageMaster, trace.TL_ERROR_LOG);
		return;
	}

	for(int i = 0; i < phaseLocs.size(); i++)
	{
		boolean rslt = createRemoteTheater(DT_TABLE_POI_NAME, (location)phaseLocs.get(i), "systems.fs_quest.fs_outpost_master", villageMaster, (string)phaseNames.get(i), TLT_none);
		trace.log(fs_dyn_village.LOG_CHAN, "Attempting (" + rslt + ") to create theatre " + (string)phaseNames.get(i) + " at idx " + i + " at location " + (location)phaseLocs.get(i));
	}

	return;
}

void theatreDestroyed(obj_id villageMaster, obj_id destroyedCamp)
{
	return;
}

//
//  writes a camp's location to the village master.  locations are kept in scriptvars
//  as the camp registers itself everytime it initializes.  camps with location
//  are considered "clean" and have been authorized to function
//  @returns the string name of the camp for which the location was set
//
string setLocForCamp(obj_id villageMaster, obj_id campId, location loc, string campName)
{
	string rslt = "";
	if(!isIdValid(villageMaster) || !exists(villageMaster))
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::setLocForCamp: -> villageMaster is invalid or doesn't exist. location not set for campId " + campId + ".",
			villageMaster, trace.TL_ERROR_LOG);
		return rslt;
	}

	Vector names   = new Vector();
	// grab the names for use during this phase
	if(hasObjVar(villageMaster, OBJVAR_PHASE_CAMP_NAMES))
	{
		names = getResizeableStringArrayObjVar(villageMaster, OBJVAR_PHASE_CAMP_NAMES);
	}

	int nameIdx = names.indexOf(campName);
	if(nameIdx < 0)
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::setLocForCamp: -> could not find camp name " + campName + ", not registering camp " + campId + ".",
			villageMaster, trace.TL_ERROR_LOG);
		return rslt;
	}

	location[] locs = new location[names.size()];
	obj_id[] campIds = new obj_id[names.size()];

	// grab any previously registered camp objIds
	if(utils.hasScriptVar(villageMaster, OBJVAR_CREATED_CAMP_IDS))
	{
		campIds = utils.getObjIdArrayScriptVar(villageMaster, OBJVAR_CREATED_CAMP_IDS);
		if(campIds == null || campIds.length != names.size())
		{
			utils.removeScriptVar(villageMaster, OBJVAR_CREATED_CAMP_IDS);
			campIds = new obj_id[names.size()];
		}
	}

	// grab any previously registered camp locations
	if(utils.hasScriptVar(villageMaster, OBJVAR_CREATED_CAMP_LOCS))
	{
		locs = utils.getLocationArrayScriptVar(villageMaster, OBJVAR_CREATED_CAMP_LOCS);
		if(locs == null || locs.length != names.size())
		{
			utils.removeScriptVar(villageMaster, OBJVAR_CREATED_CAMP_LOCS);
			locs = new location[names.size()];
		}
	}

	//if the name is already taken by another campm refuse this one
	if(isIdValid(campIds[nameIdx]))
	{
		return ""; // empy string is a failure
	}

	trace.log(fs_dyn_village.LOG_CHAN, "Registering " + campId + " as " + campName + " at location " + loc.toString());
	locs[nameIdx] = loc;
	campIds[nameIdx] = campId;

	utils.setScriptVar(villageMaster, OBJVAR_CREATED_CAMP_LOCS, locs);
	utils.setScriptVar(villageMaster, OBJVAR_CREATED_CAMP_IDS, campIds);
	rslt = (string)names.get(nameIdx);

	return rslt;
}

void failQuestForCampers(obj_id campId)
{
	// if there is a commander, the easiest thing to do is kill him.  doesnt break the story as much
	obj_id commander = null;
	if(hasObjVar(campId, OBJVAR_CAMP_COMMANDER))
	{
		commander = getObjIdObjVar(campId, OBJVAR_CAMP_COMMANDER);
		messageTo(commander, "msgLifeExpired", null, 0.0f, false);
		return;
	}

	// we need to check if the shield has been powered down.  if so fail them
	obj_id shieldKiller = null;
	if(hasObjVar(campId, OBJVAR_CAMP_SHIELD_KILLER))
	{
		shieldKiller = getObjIdObjVar(campId, OBJVAR_CAMP_SHIELD_KILLER);
		messageTo(shieldKiller, "msgShieldPowerup", null, 0.0f, false);
	}

	return;
}

///
///  resets a camp to new condition, like nothing ever happened.
///
void resetCamp(obj_id campId, boolean recreate)
{
	trace.log(fs_dyn_village.LOG_CHAN, "Resetting camp " + campId);
	failQuestForCampers(campId);
	// a bunch of objvars need to be here to recreate the camp, else we need to destroy it
	// ugly - need to rewrite this to be more generic for an arbitrary number of trackable objects...
	if(
		!hasObjVar(campId, OBJVAR_CAMP_DOOR1) ||
		!hasObjVar(campId, OBJVAR_CAMP_DOOR1_LOC) ||
		!hasObjVar(campId, OBJVAR_CAMP_DOOR1_YAW) ||

		!hasObjVar(campId, OBJVAR_CAMP_DOOR2) ||
		!hasObjVar(campId, OBJVAR_CAMP_DOOR2_LOC) ||
		!hasObjVar(campId, OBJVAR_CAMP_DOOR2_YAW) ||

		!hasObjVar(campId, OBJVAR_CAMP_TURRET1) ||
		!hasObjVar(campId, OBJVAR_CAMP_TURRET1_LOC) ||
		!hasObjVar(campId, OBJVAR_CAMP_TURRET1_YAW) ||

		!hasObjVar(campId, OBJVAR_CAMP_TURRET2) ||
		!hasObjVar(campId, OBJVAR_CAMP_TURRET2_LOC) ||
		!hasObjVar(campId, OBJVAR_CAMP_TURRET2_YAW) ||

		!hasObjVar(campId, OBJVAR_CAMP_TURRET3) ||
		!hasObjVar(campId, OBJVAR_CAMP_TURRET3_LOC) ||
		!hasObjVar(campId, OBJVAR_CAMP_TURRET3_YAW) ||

		!hasObjVar(campId, OBJVAR_CAMP_ANTENNA) ||
		!hasObjVar(campId, OBJVAR_CAMP_ANTENNA_LOC)
	  )
	  {
		  destroyObject(campId);
		  return;
	  }

	// put the shield back up
	erectShield();

	// recreate Turret1
	obj_id turret1 = getObjIdObjVar(campId, OBJVAR_CAMP_TURRET1);
	if(isIdValid(turret1) && exists(turret1))
	{
		destroyObject(turret1);
	}

	if(recreate)
	{
		turret1 = create.object(CAMP_TURRET_TEMPLATE, getLocationObjVar(campId, OBJVAR_CAMP_TURRET1_LOC));
		if(isIdValid(turret1))
		{
			setYaw(turret1, getFloatObjVar(campId, OBJVAR_CAMP_TURRET1_YAW));
			setObjVar(campId, OBJVAR_CAMP_TURRET1, turret1);
			setInvulnerable(turret1, false);
			setObjVar(turret1, turret.OBJVAR_CAN_ATTACK, "allPlayers");
		}
		else
		{
			destroyObject(campId);
		}
	}

	// recreate Turret2
	obj_id turret2 = getObjIdObjVar(campId, OBJVAR_CAMP_TURRET2);
	if(isIdValid(turret2) && exists(turret2))
	{
		destroyObject(turret2);
	}

	if(recreate)
	{
		turret2= create.object(CAMP_TURRET_TEMPLATE, getLocationObjVar(campId, OBJVAR_CAMP_TURRET2_LOC));
		if(isIdValid(turret2))
		{
			setYaw(turret2, getFloatObjVar(campId, OBJVAR_CAMP_TURRET2_YAW));
			setObjVar(campId, OBJVAR_CAMP_TURRET2, turret2);
			setInvulnerable(turret2, false);
			setObjVar(turret2, turret.OBJVAR_CAN_ATTACK, "allPlayers");
		}
		else
		{
			destroyObject(campId);
		}
	}

	// recreate Turret3
	obj_id turret3 = getObjIdObjVar(campId, OBJVAR_CAMP_TURRET3);
	if(isIdValid(turret3) && exists(turret3))
	{
		destroyObject(turret3);
	}

	if(recreate)
	{
		turret3= create.object(CAMP_TURRET_TEMPLATE, getLocationObjVar(campId, OBJVAR_CAMP_TURRET3_LOC));
		if(isIdValid(turret3))
		{
			setYaw(turret3, getFloatObjVar(campId, OBJVAR_CAMP_TURRET3_YAW));
			setObjVar(campId, OBJVAR_CAMP_TURRET3, turret3);
			setInvulnerable(turret3, false);
			setObjVar(turret3, turret.OBJVAR_CAN_ATTACK, "allPlayers");
		}
		else
		{
			destroyObject(campId);
		}
	}

	// recreate door 1
	obj_id door1 = getObjIdObjVar(campId, OBJVAR_CAMP_DOOR1);
	if(isIdValid(door1) && exists(door1))
	{
		destroyObject(door1);
	}

	if(recreate)
	{
		door1 = create.object(CAMP_DOOR_TEMPLATE, getLocationObjVar(campId, OBJVAR_CAMP_DOOR1_LOC));
		if(isIdValid(door1))
		{
			setYaw(door1, getFloatObjVar(campId, OBJVAR_CAMP_DOOR1_YAW));
			setObjVar(campId, OBJVAR_CAMP_DOOR1, door1);
			setInvulnerable(door1, true);
			detachScript(door1, "systems.battlefield.destructible_building");
			attachScript(door1, "systems.fs_quest.destructible_obj");
		}
		else
		{
			destroyObject(campId);
		}
	}

	// recreate door 2
	obj_id door2 = getObjIdObjVar(campId, OBJVAR_CAMP_DOOR2);
	if(isIdValid(door2) && exists(door2))
	{
		destroyObject(door2);
	}

	if(recreate)
	{
		door2 = create.object(CAMP_DOOR_TEMPLATE, getLocationObjVar(campId, OBJVAR_CAMP_DOOR2_LOC));
		if(isIdValid(door1))
		{
			setYaw(door2, getFloatObjVar(campId, OBJVAR_CAMP_DOOR2_YAW));
			setObjVar(campId, OBJVAR_CAMP_DOOR2, door2);
			setInvulnerable(door2, true);
			detachScript(door2, "systems.battlefield.destructible_building");
			attachScript(door2, "systems.fs_quest.destructible_obj");
		}
		else
		{
			destroyObject(campId);
		}
	}
	// recreate antenna
	obj_id antenna = getObjIdObjVar(campId, OBJVAR_CAMP_ANTENNA);
	if(isIdValid(antenna) && exists(antenna))
	{
		destroyObject(antenna);
	}

	if(recreate)
	{
		antenna = create.object(CAMP_ANTENNA_TEMPLATE, getLocationObjVar(campId, OBJVAR_CAMP_ANTENNA_LOC));
		if(isIdValid(antenna))
		{
			setObjVar(campId, OBJVAR_CAMP_ANTENNA, antenna);
			setInvulnerable(antenna, true);
			detachScript(antenna, "systems.battlefield.destructible_building");
			attachScript(antenna, "systems.fs_quest.destructible_obj");
		}
		else
		{
			destroyObject(campId);
		}
	}

	if(hasObjVar(campId, OBJVAR_CAMP_SHIELD_KILLER))
	{
		removeObjVar(campId, OBJVAR_CAMP_SHIELD_KILLER);
	}

	if(hasObjVar(campId, OBJVAR_STOP_DEFENSE_SPAWN))
	{
		removeObjVar(campId, OBJVAR_STOP_DEFENSE_SPAWN);
	}

	if(hasObjVar(campId, OBJVAR_CAMP_COMMANDER))
	{
		removeObjVar(campId, OBJVAR_CAMP_COMMANDER);
	}

	if(hasObjVar(campId, OBJVAR_CAMP_COMMANDER_TAKER))
	{
		removeObjVar(campId, OBJVAR_CAMP_COMMANDER_TAKER);
	}

	return;
}

//
// checks to see if the antenna has been destroyed or not
//
boolean antennaExists(obj_id campId)
{
	boolean rslt = false;
	if(hasObjVar(campId, OBJVAR_CAMP_ANTENNA))
	{
		obj_id antenna = getObjIdObjVar(campId, OBJVAR_CAMP_ANTENNA);
		if(isIdValid(antenna) && exists(antenna))
		{
			rslt = true;
		}
	}

	return rslt;
}

//
//  construct spawn wave definition based on number of players in the area
//
string[] getSpawnWaves(obj_id campId)
{
	int numPlayers = 1;
	obj_id[] players = getPlayerCreaturesInRange(campId, 100.0f);
	if(players != null)
	{
		numPlayers = players.length;
	}

	string[] spawnWaves = new string[]{"fs_counterstrike_small"};

	if(numPlayers > 10)
	{
		if(antennaExists(campId))
		{
			spawnWaves = new string[]{"fs_counterstrike_small", "fs_counterstrike_medium"};
		}
		else
		{
			spawnWaves = new string[]{"fs_counterstrike_medium"};
		}
	}

	if(numPlayers > 20)
	{
		if(antennaExists(campId))
		{
			spawnWaves = new string[]{"fs_counterstrike_small", "fs_counterstrike_small", "fs_counterstrike_medium"};
		}
		else
		{
			spawnWaves = new string[]{"fs_counterstrike_small", "fs_counterstrike_medium"};
		}
	}

	if(numPlayers > 30)
	{
		if(antennaExists(campId))
		{
			spawnWaves = new string[]{"fs_counterstrike_small", "fs_counterstrike_small", "fs_counterstrike_medium", "fs_counterstrike_medium"};
		}
		else
		{
			spawnWaves = new string[]{"fs_counterstrike_small", "fs_counterstrike_small", "fs_counterstrike_medium"};
		}
	}


	return spawnWaves;
}

//
//  generates a spawn wave to defend the camp
//
void doCampDefenseSpawn(obj_id campId, boolean scheduleNext)
{
	if(hasObjVar(campId, OBJVAR_STOP_DEFENSE_SPAWN) || !hasObjVar(campId, OBJVAR_CAMP_SHIELD_KILLER))
	{
		return;
	}

	if(!isIdValid(campId) || !exists(campId))
	{
		return;
	}

	long seed = campId.getValue();
	while(seed > Integer.MAX_VALUE)
	{
		seed /= 2;
	}

	reseed((int)seed);

	string wave = "";
	float heading = 0.0f;
	location spawnerLoc = null;
	location masterLoc = getLocation(campId);
	obj_id spawner = null;
	string[] spawnWaves = getSpawnWaves(campId);

	for(int i = 0; i < spawnWaves.length; i++)
	{
		wave = spawnWaves[i];
		spawnerLoc = utils.getRandomAwayLocation(masterLoc, 50.0f, 110.0f);
		spawner = quests.createSpawner(wave, spawnerLoc, fs_dyn_village.CITY_BAD_GUY_SPAWN_TABLE, campId);
		if(isIdValid(spawner))
		{
			seed = spawner.getValue();
			while(seed > Integer.MAX_VALUE)
			{
				seed /= 2;
			}

			setObjVar(spawner, OBJVAR_MY_CAMP_ID, campId);
		}
		reseed((int)seed);
	}

	if(scheduleNext)
	{
		messageTo(campId, "msgDoCampDefenseSpawn", null, (float)rand(CAMP_REINFORCEMENT_MIN, CAMP_REINFORCEMENT_MAX), false);
	}
}

//
//  erects the shield around the camp
//
void erectShield()
{
	obj_id me = getSelf();
	if(!hasScript(me, "systems.fs_quest.fs_outpost_master"))
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::erectShield: -> can only erect shields for enemy camps. " + me + " is not a camp master.",
			me, trace.TL_ERROR_LOG);
		return;
	}

	location here = getLocation(me);
	if(!hasTriggerVolume(me, SHIELD_TR_VOLUME))
	{
		createTriggerVolume(SHIELD_TR_VOLUME, SHIELD_RADIUS, true);
	}

	//trace.log(fs_dyn_village.LOG_CHAN, "Shield erected for " + me);

	obj_id[] intruders = getCreaturesInRange(here, SHIELD_RADIUS + 1);
	for(int i = 0; i < intruders.length; i++)
	{
		//trace.log(fs_dyn_village.LOG_CHAN, "Expelling " + intruders[i] + " , template " + getTemplateName(intruders[i]) + " from camp.");
		sendSystemMessage(intruders[i], new string_id("fs_quest_village","expel_shield"));
		if(!isGod(intruders[i]) && !hasScript(intruders[i], "systems.fs_quest.fs_camp_commander_ai"))
		{
			expelFromTriggerVolume(me, SHIELD_TR_VOLUME, intruders[i]);
		}
	}

	return;
}

//
//  checks to see if two players in groups
//
boolean arePlayersInSameGroup(obj_id player1, obj_id player2)
{
	obj_id group = getGroupObject(player1);
	if(!isIdValid(group))
	{
		return false;
	}

	obj_id[] members = getGroupMemberIds(group);
	if(utils.getElementPositionInArray(members, player2) > -1)
	{
		return true;
	}

	return false;
}

//
//  checks to see if the shield generator is nearby and wether or not the shield can be powered down
//
boolean attemptPowerDownShield(obj_id player, string remoteId)
{
	// cant do it in a city. too much garbage around
	if(locations.isInCity(getLocation(player)))
	{
		sendSystemMessage(player, new string_id("fs_quest_village","shield_remote_interference"));
		return false;
	}

	if(!allowedToPowerDownShield(player))
	{
		sendSystemMessage(player, new string_id("fs_quest_village","shield_remote_cant_use"));
		return false;
	}

	obj_id[] stuff = getNonCreaturesInRange(getLocation(player), SHIELD_REMOTE_RANGE);
	for(int t = 0; t < stuff.length; t++)
	{
		if(hasObjVar(stuff[t], OBJVAR_IS_REMOTE_RECEIVER))
		{
			obj_id campMaster = getMyOutpostId(stuff[t]);
			if(campMaster == null)
			{
				continue;
			}

			if(!hasTriggerVolume(campMaster, SHIELD_TR_VOLUME))
			{
				sendSystemMessage(player, new string_id("fs_quest_village","remote_shield_down_already"));
				return false;
			}

			if(hasObjVar(campMaster, OBJVAR_CAMP_NAME))
			{
				if(getStringObjVar(campMaster, OBJVAR_CAMP_NAME).equals(remoteId))
				{
					setObjVar(campMaster, OBJVAR_CAMP_SHIELD_KILLER, player);

					if(group.isGrouped(player))
					{
						obj_id[] gang = null;
						gang = getGroupMemberIds(getGroupObject(player));

						if((gang != null) && (gang.length > 0) )
						{
							for(int g = 0; g < gang.length; g++)
							{
								obj_id thisGuy = gang[g];
								if(isIdValid(thisGuy) && exists(thisGuy) && thisGuy != player)
								{
									sendSystemMessage(thisGuy, new string_id("fs_quest_village", "remote_powering_down"));
								}
							}
						}
					}
					
					// player gets his message here, just in case something wonky is going on with groups
					sendSystemMessage(player, new string_id("fs_quest_village","remote_powering_down"));
					
					messageTo(campMaster, "msgPowerDownShield", null, 0.0f, false);

					obj_id questGiver = getCurrentQuestGiver(player, "fs_cs_intro");
					quests.complete("fs_cs_intro", player, true);
					quests.activate("fs_cs_kill5_guards", player, questGiver);
					setObjVar(player, OBJVAR_MY_CAMP_ID, campMaster);
					sendSystemMessage(player, new string_id("fs_quest_village", "fs_cs_step_intro_complete"));

					return true;
				}
				else
				{
					sendSystemMessage(player, new string_id("fs_quest_village","shield_remote_wrong_camp"));
					return false;
				}
			}
		}
	}

	sendSystemMessage(player, new string_id("fs_quest_village","remote_nothing_happens"));
	return false;
}

//
// checks to see if a person is on the quest or not
//
boolean allowedToPowerDownShield(obj_id player)
{
	// ToDo: perform check!
	if(quests.isActive("fs_cs_intro", player))
	{
		return true;
	}

	return false;
}

//
//  creates a camp's commander
//
obj_id createCommander(obj_id campId)
{
	obj_id commander = null;

	if(hasObjVar(campId, OBJVAR_CAMP_COMMANDER))
	{
		commander = getObjIdObjVar(campId, OBJVAR_CAMP_COMMANDER);
		messageTo(campId, "msgLifeExpired", null, 0.0f, false);
	}

	obj_id shieldKiller = null;
	if(hasObjVar(campId, OBJVAR_CAMP_SHIELD_KILLER))
	{
		shieldKiller = getObjIdObjVar(campId, OBJVAR_CAMP_SHIELD_KILLER);
	}

	if(!hasObjVar(campId, OBJVAR_CAMP_TENT_LOC))
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::createCommnader: -> Error creating camp commander (missing " + OBJVAR_CAMP_TENT_LOC + ") for camp " + campId +
			"Quest cannot complete.  Person who powered down shield was " + shieldKiller, shieldKiller, trace.TL_ERROR_LOG | trace.TL_CS_LOG);
		return null;
	}

	location here = getLocationObjVar(campId, OBJVAR_CAMP_TENT_LOC);

	commander = create.object("shadow_mercenary_nofaction", here);
	if(isIdValid(commander))
	{
		setInvulnerable(commander, true);
		setHomeLocation(commander, here);
		setMovementRun(commander);
		applySkillStatisticModifier(commander, "slope_move", 50);
		setObjVar(campId, OBJVAR_CAMP_COMMANDER, commander);
		setObjVar(commander, OBJVAR_CAMP_SHIELD_KILLER, shieldKiller);
		setObjVar(commander, OBJVAR_MY_CAMP_ID, campId);
		attachScript(commander, "systems.fs_quest.fs_camp_commander_ai");
	}
	else
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::createCommnader: -> Error creating camp commander for camp " + campId +
			"Quest cannot complete.  Person who powered down shield was " + shieldKiller, shieldKiller, trace.TL_ERROR_LOG | trace.TL_CS_LOG);
	}

	return commander;
}


//
//  reads quests.libbrary quest data to get the current quest giver, so we can pass it on to the next step
//
obj_id getCurrentQuestGiver(obj_id player, string questName)
{
	obj_id questGiver = null;
	string objvarname = "questlib." + questName + ".quest_giver";
	if(hasObjVar(player, objvarname))
	{
		questGiver = getObjIdObjVar(player, objvarname);
	}

	return questGiver;
}

//
//  removes the shield around the camp -- !! only to be called by camp master !!
//
void powerDownShield()
{
	obj_id me = getSelf();
	if(!hasScript(me, "systems.fs_quest.fs_outpost_master"))
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::powerDownShield: -> can only power down shields for enemy camps. " + me + " is not a camp master.",
			me, trace.TL_ERROR_LOG);
		return;
	}

	location here = getLocation(me);
	if(hasTriggerVolume(me, SHIELD_TR_VOLUME))
	{
		removeTriggerVolume(SHIELD_TR_VOLUME);
	}

	if(hasObjVar(me, OBJVAR_CAMP_DOOR1))
	{
		obj_id door1 = getObjIdObjVar(me, OBJVAR_CAMP_DOOR1);
		if(isIdValid(door1))
		{
			setInvulnerable(door1, false);
		}
	}

	if(hasObjVar(me, OBJVAR_CAMP_DOOR2))
	{
		obj_id door2 = getObjIdObjVar(me, OBJVAR_CAMP_DOOR2);
		if(isIdValid(door2))
		{
			setInvulnerable(door2, false);
		}
	}

	if(hasObjVar(me, OBJVAR_CAMP_ANTENNA))
	{
		obj_id antenna = getObjIdObjVar(me, OBJVAR_CAMP_ANTENNA);
		if(isIdValid(antenna))
		{
			setInvulnerable(antenna, false);
		}
	}

	return;
}

//
//  spawns some surveillance droid spawners that will kick off the
//  droid population around the outpost
//
void spawnSurveillanceDroids(obj_id campMaster)
{
	location here = getLocation(campMaster);

	Vector existingDroids = new Vector();
	if(hasObjVar(campMaster, OBJVAR_CAMP_DROIDS))
	{
		existingDroids = utils.getResizeableObjIdBatchObjVar(campMaster, OBJVAR_CAMP_DROIDS);
	}

	for(int x = 0; x < existingDroids.size(); x++)
	{
		messageTo((obj_id)existingDroids.get(x), "msgSilentSelfDestruct", null, 0.0f, false);
	}

	Vector newDroids = new Vector();
	obj_id curDroid = null;

	for(int i = 0; i < MAX_DROIDS_FOR_CAMP; i++)
	{
		curDroid = _createSingleDroid(campMaster, here);
		if(isIdValid(curDroid))
		{
			newDroids.add(curDroid);
		}
	}

	utils.setResizeableBatchObjVar(campMaster, OBJVAR_CAMP_DROIDS, newDroids);

	return;
}

//
//  creates a single droid for a camp
//
obj_id _createSingleDroid(obj_id campMaster, location here)
{
	location where = utils.getRandomAwayLocation(here, MIN_DROID_DISTANCE, MAX_DROID_DISTANCE);
	obj_id curDroid = create.object("mouse_droid", where);

	if(isIdValid(curDroid))
	{
		setObjVar(curDroid, OBJVAR_MY_CAMP_ID, campMaster);
		string name = "test";
		if(hasObjVar(campMaster, OBJVAR_CAMP_NAME))
		{
			name = getStringObjVar(campMaster, OBJVAR_CAMP_NAME);
		}
		setName(curDroid, new string_id("fs_quest_village", MOUSE_DROID_NAME_ID + name ));
		attachScript(curDroid, "systems.fs_quest.fs_surveillance_droid");
	}

	//trace.log(fs_dyn_village.LOG_CHAN, "Created droid " + curDroid + " at " + where.toString());
	return curDroid;
}

//
//  removes dead droid from list and create a replacement
//
void droidDied(obj_id campMaster, obj_id deadDroid)
{
	Vector existingDroids = new Vector();
	if(hasObjVar(campMaster, OBJVAR_CAMP_DROIDS))
	{
		existingDroids = utils.getResizeableObjIdBatchObjVar(campMaster, OBJVAR_CAMP_DROIDS);
	}

	int idx = existingDroids.indexOf(deadDroid);
	if(idx > -1)
	{
		existingDroids.removeElementAt(idx);
	}

	obj_id newDroid = _createSingleDroid(campMaster, getLocation(campMaster));
	if(isIdValid(newDroid))
	{
		existingDroids.add(newDroid);
	}

	utils.setResizeableBatchObjVar(campMaster, OBJVAR_CAMP_DROIDS, existingDroids);
	return;
}

//
// scrubs the OBJVAR_CAMP_OBJS and sets the appropriate objvar/loc variables for easy lookup later
//
void registerCampObjIds(obj_id campMaster)
{
	if(!isIdValid(campMaster))
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::registerCampObjIds: -> Error scrubbing " + OBJVAR_CAMP_OBJS +
			" for camp objids.  Camp master is not valid.", campMaster, trace.TL_ERROR_LOG);
			return;
	}


	if(!exists(campMaster))
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::registerCampObjIds: -> Error scrubbing " + OBJVAR_CAMP_OBJS +
			" for camp objids.  Camp master does not exist on this server.", campMaster, trace.TL_ERROR_LOG);
			return;
	}


	if(!hasObjVar(campMaster, OBJVAR_CAMP_OBJS))
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::registerCampObjIds: -> Error scrubbing " + OBJVAR_CAMP_OBJS +
			" for camp objids.  Objvar missing.  Nuking camp.", campMaster, trace.TL_ERROR_LOG);
		destroyObject(campMaster);
	}

	obj_id[] objs = utils.getObjIdBatchObjVar(campMaster, OBJVAR_CAMP_OBJS);

	string tName = "";
	boolean foundFirstDoor = false;
	int turretNum = 1;
	for(int i = 0; i < objs.length; i++)
	{
		if(!isIdValid(objs[i]) || !exists(objs[i]))
		{
			continue;
		}

		tName = getTemplateName(objs[i]);
		setObjVar(objs[i], OBJVAR_IS_REMOTE_RECEIVER, true);
		setObjVar(objs[i], OBJVAR_MY_CAMP_ID, campMaster);

		if(tName == null)
		{
			trace.log("fs_quest", "fs_counterstrike::registerCampObjIds: -> " + objs[i] + " has no template.");
			continue;
		}

		if(tName.equals(CAMP_DOOR_TEMPLATE))
		{
			if(!foundFirstDoor)
			{
				setObjVar(campMaster, OBJVAR_CAMP_DOOR1, objs[i]);
				setObjVar(campMaster, OBJVAR_CAMP_DOOR1_LOC, getLocation(objs[i]));
				setObjVar(campMaster, OBJVAR_CAMP_DOOR1_YAW, getYaw(objs[i]));
				foundFirstDoor = true;
			}
			else
			{
				setObjVar(campMaster, OBJVAR_CAMP_DOOR2, objs[i]);
				setObjVar(campMaster, OBJVAR_CAMP_DOOR2_LOC, getLocation(objs[i]));
				setObjVar(campMaster, OBJVAR_CAMP_DOOR2_YAW, getYaw(objs[i]));
			}

			detachScript(objs[i], "systems.battlefield.destructible_building");
			attachScript(objs[i], "systems.fs_quest.destructible_obj");
			setInvulnerable(objs[i], true);
		}
		else if(tName.equals(CAMP_ANTENNA_TEMPLATE))
		{
			setObjVar(campMaster, OBJVAR_CAMP_ANTENNA, objs[i]);
			setObjVar(campMaster, OBJVAR_CAMP_ANTENNA_LOC, getLocation(objs[i]));
			detachScript(objs[i], "systems.battlefield.destructible_building");
			attachScript(objs[i], "systems.fs_quest.destructible_obj");
			setInvulnerable(objs[i], true);
		}
		else if(tName.equals(CAMP_TURRET_TEMPLATE))
		{
			setObjVar(campMaster, "fs_cs.camp.turret" + turretNum, objs[i]);
			setObjVar(campMaster, "fs_cs.camp.turret" + turretNum + "Loc", getLocation(objs[i]));
			setObjVar(campMaster, "fs_cs.camp.turret" + turretNum + "Yaw", getYaw(objs[i]));
			setObjVar(objs[i], turret.OBJVAR_CAN_ATTACK, "allPlayers"); // turrets attack anyone who's not a "friend" (turret.OBJVAR_TURRET_FRIEND)
			turretNum++;
		}
		else if(tName.equals(CAMP_TENT_TEMPLATE))
		{
			setObjVar(campMaster, OBJVAR_CAMP_TENT_LOC, getLocation(objs[i]));
		}
	}

	return;
}

//
// performs initial camp setup only called when the theatre is first created.
//
void setupCamp(obj_id campMaster, boolean registerLocs)
{
	if(!hasObjVar(campMaster, OBJVAR_CAMP_OBJS) || !hasObjVar(campMaster, OBJVAR_CAMP_NAME))
	{
		// camp is either not done being crated, or its not registered yet with the master object
		return;
	}

	if(campMaster != getSelf())
	{
		trace.log(fs_dyn_village.LOG_CHAN, "fs_counterstrike::setupCamp: -> only camps may call this method. caller (" + getSelf() + " is not a camp.",
			getSelf(), trace.TL_ERROR_LOG);
		return;
	}

	if(registerLocs)
	{
		registerCampObjIds(campMaster);
	}

	erectShield();
	spawnSurveillanceDroids(campMaster);

	return;
}


//
// checks the @outpostObject for a reference to the outpost master object
//
obj_id getMyOutpostId(obj_id outpostObject)
{
	if(hasObjVar(outpostObject, OBJVAR_MY_CAMP_ID))
	{
		return getObjIdObjVar(outpostObject, OBJVAR_MY_CAMP_ID);
	}

	return null;
}