//Anything above this #include will be ignored by the compiler
#include "../qcommon/exe_headers.h"

/************************************************************************************************
 *
 * RM_Mission.cpp
 *
 * implements the CRMMission class.  The CRMMission class loads and manages an arioche mission
 *
 ************************************************************************************************/

#include "RM_Headers.h"

#define ARIOCHE_CLIPBRUSH_SIZE	300
#define	CVAR_OBJECTIVE	0

/************************************************************************************************
 * CRMMission::CRMMission
 *	constructor
 *
 * inputs:
 *  none
 *
 * return:
 *	none
 *
 ************************************************************************************************/
CRMMission::CRMMission ( CRandomTerrain* landscape )
{
	mCurrentObjective		= NULL;
	mValidPaths				= false;
	mValidRivers			= false;
	mValidNodes				= false;
	mValidWeapons			= false;
	mValidAmmo				= false;
	mValidObjectives		= false;
	mValidInstances			= false;
	mTimeLimit				= 0;
	mMaxInstancePosition	= 1;
	mAccuracyMultiplier		= 1.0f;
	mHealthMultiplier		= 1.0f;
	mPickupHealth			= 1.0f;
	mPickupArmor			= 1.0f;
	mPickupAmmo				= 1.0f;
	mPickupWeapon			= 1.0f;
	mPickupEquipment		= 1.0f;
	
	mDefaultPadding = 0;
	mSymmetric = SYMMETRY_NONE;

//	mCheckedEnts.clear();

	mLandScape = landscape;

	// cut down the possible area that is 'legal' for area manager to use by 20%
	vec3_t land_min, land_max;

	land_min[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * 0.1f;
	land_min[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * 0.1f;
	land_min[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * 0.1f;

	land_max[0] = mLandScape->GetBounds ( )[1][0] - (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * 0.1f;
	land_max[1] = mLandScape->GetBounds ( )[1][1] - (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * 0.1f;
	land_max[2] = mLandScape->GetBounds ( )[1][2] - (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * 0.1f;

	// Create a new area manager for the landscape
	mAreaManager = new CRMAreaManager ( land_min,
										land_max );

	// Create a new path manager
	mPathManager = new CRMPathManager ( mLandScape );
}

/************************************************************************************************
 * CRMMission::~CRMMission
 *	destructor
 *
 * inputs:
 *  none
 *
 * return:
 *	none
 *
 ************************************************************************************************/
CRMMission::~CRMMission ( )
{
	rmObjectiveIter_t	oit;
	rmInstanceIter_t	iit;

//	mCheckedEnts.clear();

	// Cleanup the objectives
	for (oit = mObjectives.begin(); oit != mObjectives.end(); oit++)
	{
		delete (*oit);
	}

	// Cleanup the instances
	for (iit = mInstances.begin(); iit != mInstances.end(); iit++)
	{
		delete (*iit);
	}

	if (mPathManager)
	{
		delete mPathManager;
		mPathManager = 0;
	}

	if (mAreaManager)
	{
		delete mAreaManager;
		mAreaManager = 0;
	}
}

/************************************************************************************************
 * CRMMission::FindObjective
 *	searches through the missions objectives for the one with the given name
 *
 * inputs:
 *  name: name of objective to find
 *
 * return:
 *	objective: objective matching the given name or NULL if it couldnt be found
 *
 ************************************************************************************************/
CRMObjective* CRMMission::FindObjective ( const char* name )
{
	rmObjectiveIter_t it;

	for (it = mObjectives.begin(); it != mObjectives.end(); it++)
	{
		// Does it match?
		if (!Q_stricmp ((*it)->GetName(), name ))
		{
			return (*it);
		}
	}

	// Not found
	return NULL;
}

void	CRMMission::MirrorPos(vec3_t pos)
{
	pos[0] = 1.0f - pos[0];
	pos[1] = 1.0f - pos[1];
}

/************************************************************************************************
 * CRMMission::ParseOrigin
 *	parses an origin block which includes linking to a node and absolute origins
 *
 * inputs:
 *  group: parser group containing the node or origin 
 *
 * return:
 *	true: parsed successfully
 *  false: failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseOrigin ( CGPGroup* originGroup, vec3_t origin, vec3_t lookat, int* flattenHeight )
{
	const char*	szNodeName;
	vec3_t		mins;
	vec3_t		maxs;

	if ( flattenHeight )
	{
		*flattenHeight = 66;
	}
	
	// If no group was given then use 0,0,0
	if ( NULL == originGroup )
	{
		VectorCopy ( vec3_origin, origin );
		return false;
	}

	// See if attaching to a named node
	szNodeName = originGroup->FindPairValue ( "node", "" );
	if ( *szNodeName )
	{
		CRMNode*	node;
		// Find the node being attached to
		node = mPathManager->FindNodeByName ( szNodeName );
		if ( node )
		{
			if ( flattenHeight )
			{
				if ( node->GetFlattenHeight ( ) == -1 )
				{
					node->SetFlattenHeight ( 40 + mLandScape->irand(0,40) );
				}

				*flattenHeight = node->GetFlattenHeight ( );
			}

			VectorCopy(node->GetPos(), origin);

			VectorCopy ( origin, lookat );

			int dir;
			int rnd_offset = mLandScape->irand(0, DIR_MAX-1);
			for (dir=0; dir<DIR_MAX; dir++)
			{
				int d = (dir + rnd_offset) % DIR_MAX;
				if (node->PathExist(d))
				{
					vec4_t tmp_pt, tmp_dir;
					int pathID = node->GetPath(d);
					mLandScape->GetPathInfo(pathID, .1, tmp_pt, tmp_dir );
					lookat[0] = tmp_pt[0];
					lookat[1] = tmp_pt[1];
					lookat[2] = 0;
					return true;
				}
			}
			return true;
		}
	}

	mins[0] = atof( originGroup->FindPairValue ( "left", ".1" ) );
	mins[1] = atof( originGroup->FindPairValue ( "top", ".1" ) );
	maxs[0] = atof( originGroup->FindPairValue ( "right", ".9" ) );
	maxs[1] = atof( originGroup->FindPairValue ( "bottom", ".9" ) );

	lookat[0] = origin[0] = mLandScape->flrand(mins[0],maxs[0]);
	lookat[1] = origin[1] = mLandScape->flrand(mins[1],maxs[1]);
	lookat[2] = origin[2] = 0;

	return true;
}

/************************************************************************************************
 * CRMMission::ParseNodes
 *	parses all the named nodes in the file
 *
 * inputs:
 *  group: parser group containing the named nodes
 *
 * return:
 *	true:  parsed successfully
 *  false: failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseNodes ( CGPGroup* group )
{
	// If NULL that means this particular difficulty level has no named nodes
	if ( NULL == group || mValidNodes)
	{
		return true;
	}

	// how many nodes spaced over map?
	int			x_cells;
	int			y_cells;

	x_cells = atoi ( group->FindPairValue ( "x_cells", "3" ) );
	y_cells = atoi ( group->FindPairValue ( "y_cells", "3" ) );

	mPathManager->CreateArray(x_cells, y_cells);

	// Loop through all the nodes and generate each as specified
	for ( group = group->GetSubGroups(); 
		  group; 
		  group=group->GetNext() )
	{
		int min_depth = atof( group->FindPairValue ( "min_depth", "0" ) );
		int max_depth = atof( group->FindPairValue ( "max_depth", "5" ) );
		int min_paths = atoi( group->FindPairValue ( "min_paths", "1" ) );
		int max_paths = atoi( group->FindPairValue ( "max_paths", "1" ) );		

		mPathManager->CreateLocation( group->GetName(), min_depth, max_depth, min_paths, max_paths );
	}

	mValidNodes = true;
	return true;
}

/************************************************************************************************
 * CRMMission::ParsePaths
 *	parses all path styles in the file and then generates paths
 *
 * inputs:
 *  group: parser group containing the list of path styles
 *
 * return:
 *	true:  parsed successfully
 *  false: failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParsePaths ( CGPGroup* group )
{
	// If NULL that means this particular difficulty level has no paths
	if ( NULL == group || mValidPaths)
	{
		return true;
	}

	// path style info
	float		depth;
	float		deviation;
	float		breadth;
	float		minwidth;
	float		maxwidth;
	int			points;

	points    = atoi ( group->FindPairValue ( "points", "10" ) );
	depth     = atof ( group->FindPairValue ( "depth", ".31" ) );
	deviation = atof ( group->FindPairValue ( "deviation", ".025" ) );
	breadth   = atof ( group->FindPairValue ( "breadth", "5" ) );
	minwidth  = atof ( group->FindPairValue ( "minwidth", ".03" ) );
	maxwidth  = atof ( group->FindPairValue ( "maxwidth", ".05" ) );

	mPathManager->SetPathStyle( points, minwidth, maxwidth, depth, deviation, breadth);

	if (!mValidPaths)
	{	// we must create paths
		mPathManager->GeneratePaths( mSymmetric );
		mValidPaths = true;
	}

	return true;
}

/************************************************************************************************
 * CRMMission::ParseRivers
 *	parses all river styles in the file and then generates rivers
 *
 * inputs:
 *  group: parser group containing the list of path styles
 *
 * return:
 *	true:  parsed successfully
 *  false: failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseRivers ( CGPGroup* group )
{
	// If NULL that means this particular difficulty level has no rivers
	if ( NULL == group || mValidRivers)
	{
		return true;
	}

	// river style info
	int			maxdepth;
	float		beddepth;
	float		deviation;
	float		breadth;
	float		minwidth;
	float		maxwidth;
	int			points;
	string		bridge_name;

	maxdepth  = atoi ( group->FindPairValue ( "maxpathdepth", "5" ) );
	points    = atoi ( group->FindPairValue ( "points", "10" ) );
	beddepth  = atof ( group->FindPairValue ( "depth", "1" ) );
	deviation = atof ( group->FindPairValue ( "deviation", ".03" ) );
	breadth   = atof ( group->FindPairValue ( "breadth", "7" ) );
	minwidth  = atof ( group->FindPairValue ( "minwidth", ".01" ) );
	maxwidth  = atof ( group->FindPairValue ( "maxwidth", ".03" ) );
	bridge_name= group->FindPairValue ( "bridge", "" ) ;

	mPathManager->SetRiverStyle( maxdepth, points, minwidth, maxwidth, beddepth, deviation, breadth, bridge_name);

	if (!mValidRivers && 
		beddepth < 1)						// use a depth of 1 if we don't want any rivers
	{	// we must create rivers
		mPathManager->GenerateRivers();
		mValidRivers = true;
	}

	return true;
}

void CRMMission::PlaceBridges()
{
	if (!mValidRivers || strlen(mPathManager->GetBridgeName()) < 1)
		return;

	int		max_bridges = 0;
	int		path;
	float	t;
	float	river_depth = mLandScape->GetLandScape()->GetWaterHeight();
	vec3_t	pos, lastpos;
	vec3pair_t bounds;
	VectorSet(bounds[0], 0,0,0);
	VectorSet(bounds[1], 0,0,0);

	// walk along paths looking for dips
	for (path = 0; path < mPathManager->GetPathCount(); path++)
	{
		vec4_t tmp_pt, tmp_dir;
		bool	new_water = true;

		mLandScape->GetPathInfo(path, 0, tmp_pt, tmp_dir );
		lastpos[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * tmp_pt[0];
		lastpos[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * tmp_pt[1];
		lastpos[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * tmp_pt[2];
		mLandScape->GetLandScape()->GetWorldHeight ( lastpos, bounds, true );

		const float delta = 0.05f;
		for (t= delta; t < 1.0f; t += delta)
		{
			mLandScape->GetPathInfo(path, t, tmp_pt, tmp_dir );
			pos[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * tmp_pt[0];
			pos[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * tmp_pt[1];
			pos[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * tmp_pt[2];
			mLandScape->GetLandScape()->GetWorldHeight ( pos, bounds, true );

			if (new_water && 
				lastpos[2] < river_depth && 
				pos[2] < river_depth && 
				pos[2] > lastpos[2])
			{	// add a bridge
				if (max_bridges < 3)
				{
					CRMArea*		area;
					CRMInstance*	instance;

					max_bridges++;

					// create a single bridge
					lastpos[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * mPathManager->GetPathDepth();
					instance = mInstanceFile.CreateInstance ( mPathManager->GetBridgeName() );

					if ( NULL != instance )
					{	// Set the area 
						area = mAreaManager->CreateArea ( lastpos, instance->GetSpacingRadius(), instance->GetSpacingLine(), GetDefaultPadding(), 0, vec3_origin, pos, instance->GetFlattenRadius()?true:false, false, instance->GetLockOrigin() );
						area->EnableLookAt(false);

						instance->SetArea ( mAreaManager, area );
						mInstances.push_back ( instance );
						new_water = false;
					}
				}
			}
			else if (pos[2] > river_depth)
			{	// hit land again
				new_water = true;
			}
			VectorCopy ( pos, lastpos );
		}
	}
}

void CRMMission::PlaceWallInstance(CRMInstance*	instance, float xpos, float ypos, float zpos, int x, int y, float angle)
{
	if (NULL == instance)
		return;

	float spacing = instance->GetSpacingRadius();
	CRMArea*		area;
	vec3_t			origin;

	origin[0] = xpos + spacing * x;
	origin[1] = ypos + spacing * y;
	origin[2] = zpos;

	// Set the area of position
	area = mAreaManager->CreateArea ( origin, (spacing / 2.1f), 0, GetDefaultPadding(), 0, vec3_origin, origin, instance->GetFlattenRadius()?true:false, false, instance->GetLockOrigin() );
	area->EnableLookAt(false);
	area->SetAngle(angle);
	instance->SetArea ( mAreaManager, area );

	mInstances.push_back ( instance );
}


/************************************************************************************************
 * CRMMission::ParseWallRect
 *	creates instances for walled rectangle at this node (fence)
 *
 * inputs:
 *  group: parser group containing the wall rect info
 *
 * return:
 *	true:  parsed successfully
 *  false: failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseWallRect(CGPGroup* group , int side)
{
#ifndef PRE_RELEASE_DEMO
	CGPGroup* wallGroup = group->FindSubGroup ( "wallrect" ) ;

	// If NULL that means this particular instance has no wall rect
	if ( NULL == group || NULL == wallGroup)
	{
		return true;
	}

	const char* wallName = wallGroup->FindPairValue ( "wall_instance", "" );
	const char* cornerName = wallGroup->FindPairValue ( "corner_instance", "" );
	const char* towerName = wallGroup->FindPairValue ( "tower_instance", "" );
	const char* gateName = wallGroup->FindPairValue ( "gate_instance", "" );
	const char* ripName = wallGroup->FindPairValue ( "rip_instance", "" );

	if ( NULL != wallName )
	{
		int xcount = atoi( wallGroup->FindPairValue ( "xcount", "0" ) );
		int ycount = atoi( wallGroup->FindPairValue ( "ycount", "0" ) );

		int gateCount = atoi( wallGroup->FindPairValue ( "gate_count", "1" ) );
		int gateMin = atoi( wallGroup->FindPairValue ( "gate_min", "0" ) );
		int gateMax = atoi( wallGroup->FindPairValue ( "gate_max", "0" ) );

		int ripCount = atoi( wallGroup->FindPairValue ( "rip_count", "0" ) );
		int ripMin = atoi( wallGroup->FindPairValue ( "rip_min", "0" ) );
		int ripMax = atoi( wallGroup->FindPairValue ( "rip_max", "0" ) );

		int towerCount = atoi( wallGroup->FindPairValue ( "tower_count", "0" ) );
		int towerMin = atoi( wallGroup->FindPairValue ( "tower_min", "0" ) );
		int towerMax = atoi( wallGroup->FindPairValue ( "tower_max", "0" ) );

		if (gateMin != gateMax)
			gateCount = mLandScape->irand(gateMin,gateMax);

		if (ripMin != ripMax)
			ripCount = mLandScape->irand(ripMin,ripMax);

		if (towerMin != towerMax)
			towerCount = mLandScape->irand(towerMin,towerMax);

		if (NULL == gateName)
			gateCount = 0;

		if (NULL == towerName)
			towerCount = 0;

		if (NULL == ripName)
			ripCount = 0;

		const char*		nodename;
		CGPGroup* originGroup = group->FindSubGroup ( "origin" );
		if (originGroup)
		{
			nodename = originGroup->FindPairValue ( "node", "" );
			if (*nodename)
			{
				CRMNode*	node;
				// Find the node being attached to
				node = mPathManager->FindNodeByName ( nodename );
				if ( node )
				{
					CRMInstance*	instance;
					int x,y;
					int halfx = xcount/2;
					int halfy = ycount/2;
					float xpos = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * node->GetPos()[0];
					float ypos = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * node->GetPos()[1];
					float zpos = mLandScape->GetBounds ( )[1][2] + 100;
					float angle = 0;
					int  lastGate = 0;
					int  lastRip = 0;

					// corners
					x = -halfx;
					y = -halfy;
					if (towerCount > 3 || 
  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
					{
						towerCount--;
						instance = mInstanceFile.CreateInstance ( towerName );
					}
					else
						instance = mInstanceFile.CreateInstance ( cornerName );
					angle = DEG2RAD(90);
					instance->SetSide(side);
					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);

					x = halfx;
					y = -halfy;
					if (towerCount > 3 || 
  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
					{
						towerCount--;
						instance = mInstanceFile.CreateInstance ( towerName );
					}
					else
						instance = mInstanceFile.CreateInstance ( cornerName );
					angle = DEG2RAD(180);
					instance->SetSide(side);
					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);

					x = halfx;
					y = halfy;
					if (towerCount > 3 || 
  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
					{
						towerCount--;
						instance = mInstanceFile.CreateInstance ( towerName );
					}
					else
						instance = mInstanceFile.CreateInstance ( cornerName );
					angle = DEG2RAD(270);
					instance->SetSide(side);
					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);

					x = -halfx;
					y = halfy;
					if (towerCount > 3 || 
  					    (towerCount > 0 && mLandScape->irand(1,2) == 1) )
					{
						towerCount--;
						instance = mInstanceFile.CreateInstance ( towerName );
					}
					else
						instance = mInstanceFile.CreateInstance ( cornerName );
					angle = DEG2RAD(0);
					instance->SetSide(side);
					PlaceWallInstance(instance, xpos, ypos, zpos, x, y, angle);

					// walls
					angle = DEG2RAD(0);
					for (x = -halfx+1; x <= halfx-1; x++)
					{
						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
						{	// gate
							gateCount--;
							lastGate = 3;
							instance = mInstanceFile.CreateInstance ( gateName );
						}
						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
						{	// damaged fence
							ripCount--;
							lastRip = 3;
							instance = mInstanceFile.CreateInstance ( ripName );
						}
						else
						{   // just a wall
							instance = mInstanceFile.CreateInstance ( wallName );
							lastRip--;
							lastGate--;
						}
						instance->SetSide(side);
						PlaceWallInstance(instance, xpos, ypos, zpos, x, -halfy, angle);
					}
					for (x = -halfx+1; x <= halfx-1; x++)
					{
						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
						{	// gate
							gateCount--;
							lastGate = 3;
							instance = mInstanceFile.CreateInstance ( gateName );
						}
						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
						{	// damaged fence
							ripCount--;
							lastRip = 3;
							instance = mInstanceFile.CreateInstance ( ripName );
						}
						else
						{   // just a wall
							instance = mInstanceFile.CreateInstance ( wallName );
							lastRip--;
							lastGate--;
						}
						instance->SetSide(side);
						PlaceWallInstance(instance, xpos, ypos, zpos, x, halfy, angle);
					}

					angle = DEG2RAD(90);
					for (y = -halfy+1; y <= halfy-1; y++)
					{
						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
						{	// gate
							gateCount--;
							lastGate = 3;
							instance = mInstanceFile.CreateInstance ( gateName );
						}
						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
						{	// damaged fence
							ripCount--;
							lastRip = 3;
							instance = mInstanceFile.CreateInstance ( ripName );
						}
						else
						{   // just a wall
							instance = mInstanceFile.CreateInstance ( wallName );
							lastRip--;
							lastGate--;
						}
						instance->SetSide(side);
						PlaceWallInstance(instance, xpos, ypos, zpos, -halfx, y, angle);
					}
					for (y = -halfy+1; y <= halfy-1; y++)
					{
						if (lastGate<1 && gateCount > 0 && mLandScape->irand(1,(halfx+halfy)/gateCount) == 1)
						{	// gate
							gateCount--;
							lastGate = 3;
							instance = mInstanceFile.CreateInstance ( gateName );
						}
						else if (lastRip<1 && ripCount > 0 && mLandScape->irand(1,(halfx+halfy)/ripCount) == 1)
						{	// damaged fence
							ripCount--;
							lastRip = 3;
							instance = mInstanceFile.CreateInstance ( ripName );
						}
						else
						{   // just a wall
							instance = mInstanceFile.CreateInstance ( wallName );
							lastRip--;
							lastGate--;
						}
						instance->SetSide(side);
						PlaceWallInstance(instance, xpos, ypos, zpos, halfx, y, angle);
					}
				}
			}
		}
	}			
	else
		return false;
#endif // #ifndef PRE_RELEASE_DEMO

	return true;
}


/************************************************************************************************
 * CRMMission::ParseInstancesOnPath
 *	creates instances on path between nodes
 *
 * inputs:
 *  group: parser group containing the defenses, other instances on the path between nodes
 *
 * return:
 *	true:  parsed successfully
 *  false: failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseInstancesOnPath ( CGPGroup* group )
{
#ifndef PRE_RELEASE_DEMO
	CGPGroup* defenseGroup;
	for ( defenseGroup = group->GetSubGroups(); 
		  defenseGroup; 
		  defenseGroup=defenseGroup->GetNext() )
	if (Q_stricmp ( defenseGroup->GetName ( ), "defenses" )==0 ||
		Q_stricmp ( defenseGroup->GetName(), "instanceonpath")==0)
	{
		const char* defName = defenseGroup->FindPairValue ( "instance", "" );
		if ( *defName )
		{
			float	minpos;
			float	maxpos;
			int		mincount;
			int		maxcount;

			// how far along path does this get placed?
			minpos = atof( defenseGroup->FindPairValue ( "minposition", "0.5" ) );
			maxpos = atof( defenseGroup->FindPairValue ( "maxposition", "0.5" ) );
			mincount = atoi( defenseGroup->FindPairValue ( "mincount", "1" ) );
			maxcount = atoi( defenseGroup->FindPairValue ( "maxcount", "1" ) );

			const char*		nodename;
			CGPGroup* originGroup = group->FindSubGroup ( "origin" );
			if (originGroup)
			{
				nodename = originGroup->FindPairValue ( "node", "" );
				if (*nodename)
				{
					CRMNode*	node;
					// Find the node being attached to
					node = mPathManager->FindNodeByName ( nodename );
					if ( node )
					{
						int dir;
						// look at each connection from this node to others, if there is a path, create a defense
						for (dir=0; dir<DIR_MAX; dir++)
						{
							if (node->PathExist(dir))
							{	// path leads out of this node
								CRMArea*		area;
								CRMInstance*	instance;
								float			spacing;
								vec3_t			origin;
								vec3_t			lookat;
								vec4_t			tmp_pt, tmp_dir;
								int				n,num_insts = mLandScape->irand(mincount,maxcount);
								int				pathID = node->GetPath(dir);

								if (0 == num_insts)
									continue;

								float posdelta = (maxpos - minpos) / num_insts;

								for (n=0; n<num_insts; n++)
								{

									instance = mInstanceFile.CreateInstance ( defName );
									// Failed to create, not good
									if ( NULL == instance )
									{
										continue; 
									}
									// If a spacing radius was specified then override the one thats
									// in the instance
									spacing = atof( defenseGroup->FindPairValue ( "spacing", "0" ) );
									if ( spacing )
									{
										instance->SetSpacingRadius ( spacing );
									}

									instance->SetFilter(group->FindPairValue("filter", ""));
									instance->SetTeamFilter(group->FindPairValue("teamfilter", ""));

									if (strstr(instance->GetTeamFilter(),"red"))
										instance->SetSide(SIDE_RED);
									else if (strstr(instance->GetTeamFilter(),"blue"))
										instance->SetSide(SIDE_BLUE);

									float pos_along_path = mLandScape->flrand(minpos + posdelta*n, minpos + posdelta*(n+1));
									float look_along_path = atof( defenseGroup->FindPairValue ( "pathalign", "1" ) ) ;
									mLandScape->GetPathInfo (pathID, pos_along_path, tmp_pt, tmp_dir );
									origin[0] = tmp_pt[0];
									origin[1] = tmp_pt[1];

									mLandScape->GetPathInfo (pathID, look_along_path, tmp_dir, tmp_pt );
									lookat[0] = tmp_pt[0];
									lookat[1] = tmp_pt[1];

									origin[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * origin[0];
									origin[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * origin[1];
									origin[2] = mLandScape->GetBounds ( )[0][2] ;

									// look at a point along the path at this location
									lookat[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * lookat[0];
									lookat[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * lookat[1];
									lookat[2] = 0;

									// Fixed height?  (used for bridges)
									if ( !atoi(group->FindPairValue ( "nodrop", "0" )) )
									{
										origin[2] = mLandScape->GetBounds ( )[1][2] + 100;
									}
					
									// Set the area of position
									area = mAreaManager->CreateArea ( origin, instance->GetSpacingRadius(), instance->GetSpacingLine(), GetDefaultPadding(), 0, origin, lookat, instance->GetFlattenRadius()?true:false, true, instance->GetLockOrigin(), mSymmetric );
									area->EnableLookAt(false);

									if ( node->GetFlattenHeight ( ) == -1 )
									{
										node->SetFlattenHeight ( 66 + mLandScape->irand(0,40) );
									}
									instance->SetFlattenHeight ( node->GetFlattenHeight ( ) );

									instance->SetArea ( mAreaManager, area );

									mInstances.push_back ( instance );
								}
							}
						}
					}
				}
			}
			else
				return false;
		}			
		else
			return false;

	}
#endif // #ifndef PRE_RELEASE_DEMO

	return true;
}

/************************************************************************************************
 * CRMMission::ParseInstance
 *	Parses an individual instance
 *
 * inputs:
 *  group: parser group containing the list of instances
 *
 * return:
 *	true: instances parsed successfully
 *  false: instances failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseInstance ( CGPGroup* group )
{
	CRMArea*		area;
	CRMInstance*	instance;
	float			spacing;
	vec3_t			origin;
	vec3_t			lookat;
	int				flattenHeight;

	// create fences / walls 

	// Create the instance using the instance file helper class
	instance = mInstanceFile.CreateInstance ( group->GetName ( ) );

	// Failed to create, not good
	if ( NULL == instance )
	{
		return false;
	}

	// If a spacing radius was specified then override the one thats
	// in the instance
	spacing = atof( group->FindPairValue ( "spacing", "0" ) );
	if ( spacing )
	{
		instance->SetSpacingRadius ( spacing );
	}

	instance->SetFilter(group->FindPairValue("filter", ""));
	instance->SetTeamFilter(group->FindPairValue("teamfilter", ""));

	if (strstr(instance->GetTeamFilter(),"red"))
		instance->SetSide( SIDE_RED);
	else if (strstr(instance->GetTeamFilter(),"blue"))
		instance->SetSide( SIDE_BLUE );

//	ParseWallRect(group, instance->GetSide());

	// Get its origin now
	ParseOrigin ( group->FindSubGroup ( "origin" ), origin, lookat, &flattenHeight );
	origin[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * origin[0];
	origin[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * origin[1];
	origin[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * origin[2];

	lookat[0] = mLandScape->GetBounds ( )[0][0] + (mLandScape->GetBounds ( )[1][0]-mLandScape->GetBounds ( )[0][0]) * lookat[0];
	lookat[1] = mLandScape->GetBounds ( )[0][1] + (mLandScape->GetBounds ( )[1][1]-mLandScape->GetBounds ( )[0][1]) * lookat[1];
	lookat[2] = mLandScape->GetBounds ( )[0][2] + (mLandScape->GetBounds ( )[1][2]-mLandScape->GetBounds ( )[0][2]) * lookat[2];

	// Fixed height?  (used for bridges)
	if ( !atoi(group->FindPairValue ( "nodrop", "0" )) )
	{
		origin[2] = mLandScape->GetBounds ( )[1][2] + 100;
	}

	// Set the area of position
	area = mAreaManager->CreateArea ( origin, instance->GetSpacingRadius(), instance->GetSpacingLine(), GetDefaultPadding(), 0, vec3_origin, lookat, instance->GetFlattenRadius()?true:false, true, instance->GetLockOrigin(), mSymmetric );
	instance->SetArea ( mAreaManager, area );
	instance->SetFlattenHeight ( flattenHeight );

	mInstances.push_back ( instance );

	// create defenses?
	ParseInstancesOnPath(group );

	return true;
}


/************************************************************************************************
 * CRMMission::ParseInstances
 *	parses all instances within the mission and populates the instance list
 *
 * inputs:
 *  group: parser group containing the list of instances
 *
 * return:
 *	true: instances parsed successfully
 *  false: instances failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseInstances ( CGPGroup* group )
{
#ifndef PRE_RELEASE_DEMO
	// If NULL that means this particular difficulty level has no instances
	if ( NULL == group )
	{
		return true;
	}

	// Loop through all the instances in the mission and add each 
	// to the master list of instances
	for ( group = group->GetSubGroups(); 
		  group; 
		  group=group->GetNext() )
	{
		ParseInstance ( group );
	}
#endif // #ifndef PRE_RELEASE_DEMO

	return true;
}

/************************************************************************************************
 * CRMMission::ParseObjectives
 *	parses all objectives within the mission and populates the objective list
 *
 * inputs:
 *  group: parser group containing the list of objectives
 *
 * return:
 *	true: objectives parsed successfully
 *  false: objectives failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseObjectives ( CGPGroup* group )
{
	// If NULL that means this particular difficulty level has no objectives
	if ( NULL == group )
	{
		return true;
	}

	// Loop through all the objectives in the mission and add each
	// to the master list of objectives
	for ( group = group->GetSubGroups(); 
		  group; 
		  group=group->GetNext() )
	{
		CRMObjective* objective;

		// Create the new objective
		objective = new CRMObjective ( group );

		mObjectives.push_back ( objective );
	}

	mValidObjectives = true;
	
	return true;
}

/************************************************************************************************
 * CRMMission::ParseAmmo
 *	parses the given ammo list and sets the necessary ammo cvars to grant those 
 *  weapons to the players
 *
 * inputs:
 *  ammos: parser group containing the ammo list
 *
 * return:
 *	true: ammo parsed successfully
 *  false: ammo failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseAmmo ( CGPGroup* ammos )
{
/*	CGPValue* ammo;

	// No weapons, no success
	if ( NULL == ammos )
	{
		return false;
	}

	if (0 == gi.Cvar_VariableIntegerValue("ar_wpnselect"))
	{
		// Make sure the ammo cvars are all reset so ammo from the last map or 
		// another difficulty level wont carry over
		CWeaponSystem::ClearAmmoCvars (TheWpnSysHelper());

		ammo = ammos->GetPairs ( );

		// Loop through the weapons listed and grant them to the player
		while ( ammo )
		{	
			// Grab the weapons ID
			AmmoID id = CWeaponSystem::GetAmmoID ( ammo->GetName ( ) );

			// Now set the weapon cvar with the given data
			TheWpnSysHelper().CvarSet ( CWeaponSystem::GetAmmoCvar ( id ), ammo->GetTopValue ( ), CVAR_AMMO );	

			// Move on to the next weapon
			ammo = (CGPValue*)ammo->GetNext();
		}
	}
*/
	mValidAmmo = true;

	return true;
}

/************************************************************************************************
 * CRMMission::ParseWeapons
 *	parses the given weapon list and sets the necessary weapon cvars to grant those 
 *  weapons to the players
 *
 * inputs:
 *  weapons: parser group containing the weapons list
 *
 * return:
 *	true: weapons parsed successfully
 *  false: weapons failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseWeapons ( CGPGroup* weapons )
{
/*	CGPValue*	weapon;
	WpnID		id;

	// No weapons, no success
	if ( NULL == weapons )
	{
		return false;
	}

	if (0 == gi.Cvar_VariableIntegerValue("ar_wpnselect"))
	{
		// Make sure the weapon cvars are all reset so weapons from the last map or 
		// another difficulty level wont carry over
		CWeaponSystem::ClearWpnCvars (TheWpnSysHelper());

		id     = NULL_WpnID;
		weapon = weapons->GetPairs ( );

		// Loop through the weapons listed and grant them to the player
		while ( weapon )
		{	
			// Grab the weapons ID
			id = CWeaponSystem::GetWpnID ( weapon->GetName ( ) );

			// Now set the weapon cvar with the given data
			TheWpnSysHelper().CvarSet ( CWeaponSystem::GetWpnCvar ( id ), weapon->GetTopValue ( ) );	

			// Move on to the next weapon
			weapon = (CGPValue*)weapon->GetNext();
		}

		// If we found at least one weapon then ready the last one in the list
		if ( NULL_WpnID != id )
		{
			TheWpnSysHelper().CvarSet("wp_righthand", va("%i/%i/0/0",id,CWeaponSystem::GetClipSize ( id )), CVAR_MISC );
		}
	}
*/
	mValidWeapons = true;

	return true;
}

/************************************************************************************************
 * CRMMission::ParseOutfit
 *	parses the outfit (weapons and ammo)
 *
 * inputs:
 *  outfit: parser group containing the outfit
 *
 * return:
 *	true: weapons and ammo parsed successfully
 *  false: failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseOutfit ( CGPGroup* outfit )
{
	if ( NULL == outfit )
	{
		return false;
	}

/*	// Its ok to fail parsing weapons as long as weapons have
	// already been parsed at some point
	if ( !ParseWeapons ( ParseRandom ( outfit->FindSubGroup ( "weapons" ) ) ) )
	{
		if ( !mValidWeapons )
		{
			return false;
		}
	}

	// Its ok to fail parsing ammo as long as ammo have
	// already been parsed at some point
	if ( !ParseAmmo ( ParseRandom ( outfit->FindSubGroup ( "ammo" ) ) ) )
	{
		if ( !mValidAmmo)
		{
			return false;
		}
	}
*/
	return true;
}

/************************************************************************************************
 * CRMMission::ParseRandom
 *	selects a random sub group with from all within this one
 *
 * inputs:
 *  random: parser group containing the various subgroups
 *
 * return:
 *	true:  parsed successfuly
 *  false: failed to parse
 *
 ************************************************************************************************/
CGPGroup* CRMMission::ParseRandom ( CGPGroup* randomGroup )
{
	if (NULL == randomGroup)
		return NULL;

	CGPGroup* group;
	CGPGroup* groups[MAX_RANDOM_CHOICES];
	int		  numGroups;

	// Build a list of the groups one can be chosen
	for ( numGroups = 0, group = randomGroup->GetSubGroups ( ); 
		  group; 
		  group = group->GetNext ( ) )
	{
		if ( Q_stricmp ( group->GetName ( ), "random_choice" ) )
		{
			continue;
		}

		int weight = atoi ( group->FindPairValue ( "random_weight", "1" ) );
		while (weight-- > 0)
			groups[numGroups++] = group;
		assert (numGroups <= MAX_RANDOM_CHOICES);
	}

	// No groups!
	if ( !numGroups )
	{
		return randomGroup;
	}

	// Now choose a group to parse
	return groups[mLandScape->irand(0,numGroups-1)];
}

/************************************************************************************************
 * CRMMission::ParseDifficulty
 *	parses the given difficulty and populates the mission with its data
 *
 * inputs:
 *  difficulty: parser group containing the difficulties info
 *
 * return:
 *	true: difficulty parsed successfully
 *  false: difficulty failed to parse
 *
 ************************************************************************************************/
bool CRMMission::ParseDifficulty ( CGPGroup* difficulty  )
{
	// If a null difficulty then stop the recursion.  Make sure to
	// return true here so the parsing doesnt fail
	if ( NULL == difficulty )
	{
		return true;
	}
	// is map supposed to be symmetric?
	mSymmetric = (symmetry_t)atoi(difficulty->GetParent()->FindPairValue ( "symmetric", "0" ));
	mBackUpPath = atoi(difficulty->GetParent()->FindPairValue ( "backuppath", "0" ));
	if( mSymmetric )
	{// pick between the 2 starting corners -- yes this is a hack
		mSymmetric = SYMMETRY_TOPLEFT;
		if( TheRandomMissionManager->GetLandScape()->irand(0, 1) )
		{
			mSymmetric = SYMMETRY_BOTTOMRIGHT;
		}
	}
	
	mDefaultPadding = atoi(difficulty->GetParent()->FindPairValue ( "padding", "0" ));
		
	// Parse the nodes
	if ( !ParseNodes (  ParseRandom ( difficulty->FindSubGroup ( "nodes" ) ) ) )
	{
		return false;
	}

	// Parse the paths
	if ( !ParsePaths (  ParseRandom ( difficulty->FindSubGroup ( "paths" ) ) ) )
	{
		return false;
	}

	// Parse the rivers 
	if ( !ParseRivers (  ParseRandom ( difficulty->FindSubGroup ( "rivers" ) ) ) )
	{
		return false;
	}

	// Handle inherited properties
	if ( !ParseDifficulty ( difficulty->GetParent ( )->FindSubGroup ( difficulty->FindPairValue ( "inherit", "" ) ) ) )
	{
		return false;
	}

/*
	// parse the player's outfit (weapons and ammo)
	if ( !ParseOutfit( ParseRandom ( difficulty->FindSubGroup ( "outfit" ) ) ) )
	{
		// Its ok to fail parsing weapons as long as weapons have
		// already been parsed at some point
		if ( !ParseWeapons ( ParseRandom ( difficulty->FindSubGroup ( "weapons" ) ) ) )
		{
			if ( !mValidWeapons )
			{
				return false;
			}
		}

		// Its ok to fail parsing ammo as long as ammo have
		// already been parsed at some point
		if ( !ParseAmmo ( ParseRandom ( difficulty->FindSubGroup ( "ammo" ) ) ) )
		{
			if ( !mValidAmmo)
			{
				return false;
			}
		}
	}

	// Its ok to fail parsing objectives as long as objectives have
	// already been parsed at some point
	if ( !ParseObjectives ( ParseRandom ( difficulty->FindSubGroup ( "objectives" ) ) ) )
	{
		if ( !mValidObjectives )
		{
			return false;
		}
	}
*/

	// Set the cvars with the available values
	Cvar_Set ( "mi_health", difficulty->FindPairValue ( "health", "100" ) );
	Cvar_Set ( "mi_armor", difficulty->FindPairValue ( "armor", "0" ) );

	// Parse out the timelimit
	mTimeLimit = atol(difficulty->FindPairValue("timelimit", "0"));

	// NPC multipliers
	mAccuracyMultiplier = atof(difficulty->FindPairValue("npcaccuracy", "1"));
	mHealthMultiplier = atof(difficulty->FindPairValue("npchealth", "1"));

	// keep only some of RMG pickups 1 = 100%
	mPickupHealth = atof(difficulty->FindPairValue("pickup_health", "1"));
	mPickupArmor = atof(difficulty->FindPairValue("pickup_armor", "1"));
	mPickupAmmo = atof(difficulty->FindPairValue("pickup_ammo", "1"));
	mPickupWeapon = atof(difficulty->FindPairValue("pickup_weapon", "1"));
	mPickupEquipment = atof(difficulty->FindPairValue("pickup_equipment", "1"));

	// Its ok to fail parsing instances as long as instances have
	// already been parsed at some point
	if ( !ParseInstances ( ParseRandom ( difficulty->FindSubGroup ( "instances" ) ) ) )
	{
		if ( !mValidInstances )
		{
			return false;
		}
	}

	return true;
}

/************************************************************************************************
 * CRMMission::Load
 *	Loads the given mission using the given difficulty level
 *
 * inputs:
 *  name: Name of the mission to load (should only be the name rather than the full path)
 *  difficulty: difficulty level to load
 *
 * return:
 *	true: mission successfully loaded
 *  false: mission failed to load
 *
 ************************************************************************************************/
bool CRMMission::Load ( const char* mission, const char* instances, const char* difficulty )
{
	CGenericParser2		parser;
	CGPGroup*			root;

	// Create the parser for the mission file
	if(!Com_ParseTextFile(va("ext_data/rmg/%s.mission", mission), parser))
	{
		if(!Com_ParseTextFile(va("ext_data/arioche/%s.mission", mission), parser))
		{
			Com_Printf("ERROR: Failed to open mission file '%s'\n", mission);
			return false;
		}
	}
	
	// Grab the root parser groop and make sure its mission, otherwise this
	// isnt a valid mission file
	root = parser.GetBaseParseGroup()->GetSubGroups();
	if(Q_stricmp(root->GetName(), "mission"))
	{
		Com_Printf("ERROR: '%s' is not a valid mission file\n", mission );
		parser.Clean();
		return false;
	}
	
	// Grab the mission description and set the cvar for it
	mDescription = root->FindPairValue ( "description", "<MISSION DESCRIPTION MISSING>" );
//	Cvar_Set("ar_obj_main0",mDescription.c_str(), CVAR_OBJECTIVE);
//	Cvar_Set("ar_obj_maincom0", "&OBJECTIVES_INPROGRESS&", CVAR_OBJECTIVE);
//	Cvar_SetValue ("ar_cur_objective", 0, CVAR_OBJECTIVE);

	string mInfo = root->FindPairValue ( "info", "<MISSION ADDITIONAL INFO MISSING>" );
//	Cvar_Set("ar_obj_info0",mInfo.c_str(), CVAR_OBJECTIVE);

	mExitScreen = root->FindPairValue ( "exitScreen", "<EXIT SCREEN MISSING>" );
	mTimeExpiredScreen = root->FindPairValue ( "TimeExpiredScreen", "<TIME EXPIRED SCREEN MISSING>" );
	
	// Open the instance file for the specified instances
	if ( !mInstanceFile.Open ( instances) )
	{
		Com_Printf ( "ERROR: Could not open instance file '%s'\n", instances );
		return false;
	}

	// Start at one and readjust each time we see and instance
	// with a higher value
	mMaxInstancePosition = 1;

	// Now parse the specified difficulty level
	if ( !ParseDifficulty ( root->FindSubGroup ( difficulty ) ) )
	{
		return false;
	}

	// Generate the terrain now
	mLandScape->Generate(mSymmetric);

	// Cleanup
	parser.Clean();

	return true;
}

/************************************************************************************************
 * CRMMission::Spawn
 *	Spawns all of the instances for the entire mission onto the given landscape
 *
 * inputs:
 *  landscape: landscape to spawn instances on
 *
 * return:
 *	true: instances spawned successfully
 *  false: instances failed to spawn
 *
 ***********************************************************************************************/

bool CRMMission::Spawn ( CRandomTerrain* terrain, qboolean IsServer )
{
#ifndef PRE_RELEASE_DEMO
	rmInstanceIter_t	it;
	int					areaIndex;
	CRMArea*			area;

	if ( IsServer )
	{
		// Prespawn all instances, this is mainly for flattening
		for(it = mInstances.begin(); it != mInstances.end(); it++)
		{
			CRMInstance* instance = *it;

			// Pre-Spawn
			instance->PreSpawn ( terrain, IsServer );

			if (mSymmetric)
			{
				instance->SetMirror(1);
				instance->PreSpawn ( terrain, IsServer );
				instance->SetMirror(0);
			}
		}

		mLandScape->Smooth ( );

		// place bridges
		PlaceBridges();
	}
#ifndef DEDICATED
	else
	{
		memcpy ( mLandScape->GetLandScape()->GetHeightMap ( ), clc.rmgHeightMap, mLandScape->GetLandScape()->GetRealArea ( ) );
		memcpy ( mLandScape->GetLandScape()->GetFlattenMap ( ), clc.rmgFlattenMap, mLandScape->GetLandScape()->GetRealArea ( ) );
		mLandScape->GetLandScape()->rand_seed ( clc.rmgSeed );
	}
#endif

	mLandScape->GetLandScape()->UpdatePatches();

	if ( IsServer )
	{
		// Spawn all instances
		for(it = mInstances.begin(); it != mInstances.end(); it++)
		{
			CRMInstance* instance = *it;

			// Spawn
			instance->Spawn ( terrain, IsServer );
			instance->PostSpawn ( terrain, IsServer );

			if (mSymmetric)
			{	// spawn the mirror version
				instance->SetMirror(1);
				instance->Spawn ( terrain, IsServer );
				instance->PostSpawn ( terrain, IsServer );
				instance->SetMirror(0);
			}
		}
	}

	// create automap
	if (!com_dedicated->integer)
	{		
#ifndef DEDICATED
		CM_TM_Create(mLandScape->GetLandScape());

		if ( IsServer )
		{
			CRMManager::ProcessAutomapSymbols ( TheRandomMissionManager->GetAutomapSymbolCount(), TheRandomMissionManager->GetAutomapSymbol(0) );
		}
		else
		{
			CRMManager::ProcessAutomapSymbols ( clc.rmgAutomapSymbolCount, clc.rmgAutomapSymbols );
		}
#endif
	}

#ifndef FINAL_BUILD
	// make sure to write out after the mirror happens so red side is displayed on map
	if (1 == Cvar_VariableIntegerValue("rmg_saveautomap"))
	{	// write out automap for test purposes
		char seed[MAX_QPATH];
		char terrainName[MAX_QPATH];
		char missionName[MAX_QPATH];
		Cvar_VariableStringBuffer("RMG_seed", seed, MAX_QPATH);
		Cvar_VariableStringBuffer("RMG_terrain", terrainName, MAX_QPATH);
		Cvar_VariableStringBuffer("RMG_mission", missionName, MAX_QPATH);

#ifndef DEDICATED
		for(it = mInstances.begin(); it != mInstances.end(); it++)
		{
			(*it)->DrawAutomapSymbol();
		}
		//gi.CM_TM_SaveImageToDisk(terrainName, missionName, seed);
		CM_TM_SaveImageToDisk(terrainName, missionName, seed);
#endif
		Com_Error (ERR_DROP, "RMG Automap written.");
		return false;
	}
#endif

//	// draw player start on automap
//	CEntity	*spot = NULL;
//	spot = entitySystem->GetEntityFromClassname( spot, "info_player_start");
//	if (spot)
//	{
//		gi.CM_TM_AddStart(spot->GetOrigin()[0], spot->GetOrigin()[1]);
//	}

	// Spawn NPC triggers now
//	SpawnNPCTriggers ( mLandScape );

	// Restory all the NPC's accuracies to the template accuracies times the
	// multiplier
//	INPCEnt::RestoreTemplate ( mAccuracyMultiplier, mHealthMultiplier );

	if ( IsServer )
	{
		// Little trick to set the current objective to the first in the list
		CompleteObjective ( NULL );

		// Iterate through the areas and add each to the landscapes list, this is sorta hacky
		// but bridges the game / common gap
		for ( areaIndex = 0; NULL != (area = mAreaManager->EnumArea ( areaIndex )); areaIndex ++ )
		{
			// Dont bother adding it to the list if collision isnt enabled
			if ( !area->IsCollisionEnabled() )
			{
				continue;
			}

			CArea* newarea = new CArea ( );
			newarea->Init ( area->GetOrigin(), area->GetSpacingRadius (), 0, area->IsFlattened()?AT_FLAT:AT_NONE );
			mLandScape->GetLandScape()->SaveArea( newarea );

			if (mSymmetric)
			{
				CArea* newarea = new CArea ( );
				newarea->Init ( area->GetOrigin(), area->GetSpacingRadius (), 0, area->IsFlattened()?AT_FLAT:AT_NONE );
				newarea->GetPosition()[0] = mLandScape->GetBounds ( )[0][0]+mLandScape->GetBounds ( )[1][0]-newarea->GetPosition()[0];
				newarea->GetPosition()[1] = mLandScape->GetBounds ( )[0][1]+mLandScape->GetBounds ( )[1][1]-newarea->GetPosition()[1];
				mLandScape->GetLandScape()->SaveArea( newarea );
			}
		}

		mInstanceFile.Close ( );
	}
#endif // PRE_RELEASE_DEMO

	return true;
}

/************************************************************************************************
 * CRMMission::CompleteMission
 *	Pauses the game, plays an end screen after a brief delay, which then returns the player to
 * the RMG menu.
 *                                                                             *
 * Input                                                                                        *
 *    <Variable>: <Description>                                                                 *
 * Output / Return                                                                              *
 *    <Variable>: <Description>                                                                 *
 ************************************************************************************************/
 void CRMMission::CompleteMission(void)
 {
	Cvar_Set ("cl_paused", "1");

//	AddText(va("killserver; menu %s\n", mExitScreen.c_str()));
	return;
 }

/************************************************************************************************
 * CRMMission::FailedMission
 *	Pauses the game, plays an end screen after a brief delay, which then returns the player to
 * the RMG menu.
 *                                                                             *
 * Input                                                                                        *
 *    TimeExpired: indicates if the reason failed was because of time
 * Output / Return                                                                              *
 *    <Variable>: <Description>                                                                 *
 ************************************************************************************************/
 void CRMMission::FailedMission(bool TimeExpired)
 {
	Cvar_Set ("cl_paused", "1");

	if (TimeExpired)
	{
//		AddText(va("killserver; menu %s\n", mTimeExpiredScreen.c_str()));
	}
	return;
 }

/************************************************************************************************
 * CRMMission::CompleteObjective
 *	Completes the given objective and advances the current objective accordingly
 *
 * inputs:
 *  objective: the objetive to mark complete
 *
 * return:
 *	none
 *
 ************************************************************************************************/
void CRMMission::CompleteObjective ( CRMObjective* objective )
{
	rmObjectiveIter_t it;

	// Set the object as completed
	if ( objective )
	{
		objective->Complete ( true );

		// Set the completed text for the objective
//		gi.Cvar_Set( va("ar_obj_subcom0_%i", objective->GetOrderIndex ( )), "&OBJECTIVES_COMPLETE&", CVAR_OBJECTIVE) ;

/*		CEntity *tent = G_TempEntity( vec3_origin, EV_SUB_PRINT );
		tent->s.time2 = gi.SP_GetStringID ( objective->GetMessage ( ) );	
		tent->r.svFlags |= SVF_BROADCAST;
		G_AddTempEntity(tent);

		if (objective->CompleteSoundID())
			G_SoundBroadcast( tent, objective->CompleteSoundID());
*/
	}

	mCurrentObjective = NULL;

	// Find the next objective
	for (it = mObjectives.begin(); it != mObjectives.end(); it++)
	{
		objective = (*it);

		// Skip completed objectives
		if ( objective->IsCompleted ( ) )
		{
			continue;
		}

		// Find the objective with the lowest priority
		if ( mCurrentObjective && objective->GetPriority ( ) > mCurrentObjective->GetPriority ( ) )
		{
			continue;
		}

		// Found one
		mCurrentObjective = objective;
	}	

	if ( NULL != mCurrentObjective )
	{
//		Cvar_SetValue ("ar_cur_objective", mCurrentObjective->GetOrderIndex ( ), CVAR_OBJECTIVE);

		mCurrentObjective->Activate ( );
	}
	else
	{
		// Set the completed text for the objective
//		Cvar_Set( "ar_obj_maincom0", "&OBJECTIVES_COMPLETE&", CVAR_OBJECTIVE) ;
	}
}

/************************************************************************************************
 * CRMMission::Preview
 *	Previews the instances within the mission
 *
 * inputs:
 *  from: the origin which the mission is being previewed from
 *
 * return:
 *	none
 *
 ************************************************************************************************/
void CRMMission::Preview ( const vec3_t from )
{
	rmInstanceIter_t	it;

	// Look for settlements close to the player and put up some debug stuff
	for(it = mInstances.begin(); it != mInstances.end(); it++)
	{
		CRMInstance* instance = *it;

		vec3_t a;
		vec3_t b;

		VectorCopy ( from, a );
		VectorCopy ( instance->GetOrigin(), b );

		a[2] = 0;
		b[2] = 0;

		// Skip stuff thats too far away
		if ( Distance ( a, b) > 2000 )
		{
			continue;
		}

		instance->Preview ( from );
	}
}

/************************************************************************************************
 * CRMMission::PurgeTrigger
 *	Purge the trigger and all its targets
 *
 * inputs:
 *  trigger: trigger to purge
 *
 * return:
 *	none
 *
 ************************************************************************************************/
/*void CRMMission::PurgeTrigger ( CEntity* trigger )
{
	CEntity* target;
	
	// Purge all targets
	target = entitySystem->GetEntityFromTargetName ( NULL, trigger->GetTarget ( ) );
	while ( target )
	{
		PurgeTrigger ( target );

		target = entitySystem->GetEntityFromTargetName ( target, trigger->GetTarget ( ) );
	}

	// Get rid of the purge trigger
	entitySystem->RemoveEntityWithServer ( trigger );
	entitySystem->RemoveEntity ( trigger );
}
*/
/************************************************************************************************
 * CRMMission::PurgeUnlinkedTriggers
 *	Searches the entitySystem form a random arioche trigger that matches the objective name
 *
 * inputs:
 *  none
 *
 * return:
 *	trigger: a random trigger or NULL if one couldnt be found
 *
 ************************************************************************************************/
/*void CRMMission::PurgeUnlinkedTriggers ( )
{
	CTriggerAriocheObjective*	search;

	// Start at the first match of the classname
	search = (CTriggerAriocheObjective*) entitySystem->GetEntityFromClassname ( NULL, "trigger_arioche_objective" );

	// Continue on as long as there are triggers
	while ( search ) 
	{
		CTriggerAriocheObjective* purge = search;

		// move on to the next trigger before deleting the entity 
		// just in case there are some state issues with the search
		search = (CTriggerAriocheObjective*) entitySystem->GetEntityFromClassname ( search, "trigger_arioche_objective" );

		// Dont purge linked triggers
		if ( purge->GetObjective ( ) )
		{
			continue;
		}

		// Purge the trigger and all its targets
		PurgeTrigger ( purge );
	}
}
*/
/************************************************************************************************
 * CRMMission::SpawnNPCTriggers
 *	Spawn triggers across the map which will activate sleeping NPCs
 *
 * inputs:
 *  landscape: landscape to spawn the triggers relative to
 *
 * return:
 *	trigger: a random trigger or NULL if one couldnt be found
 *
 ************************************************************************************************/
/*void CRMMission::SpawnNPCTriggers ( CCMLandScape* landscape )
{
	CEntity* ent;
	int		 i;
	int		 count;
	float	 section;

	// Determine how many NPC sections there are in the map
	count   = (landscape->GetBounds()[1][0] - landscape->GetBounds()[0][0]) / 5000.0f;
	section = (landscape->GetBounds()[1][0] - landscape->GetBounds()[0][0]) / count;

	// Drop a trigger down at each NPC section interval except for the first and last.
	for ( i = 1; i < count - 1; i ++ )
	{
		vec3_t mins;
		vec3_t maxs;
		vec3_t origin;

		VectorCopy ( landscape->GetBounds()[0], mins );
		VectorCopy ( landscape->GetBounds()[1], maxs );

		// Set up the mins and maxs for the trigger
		mins[0] = mins[0] + (section * i) - 100;
		maxs[0] = mins[0] + 100;
		maxs[2] = maxs[2] + 100;
		mins[2] = mins[2] - 100;

		origin[0] = (maxs[0]-mins[0])/2 + mins[0];
		origin[1] = (maxs[1]-mins[1])/2 + mins[1];
		origin[2] = (maxs[2]-mins[2])/2 + mins[2];

		spawnSystem->ClearSpawnFields();
		spawnSystem->AddSpawnField("classname", "trigger_arioche_npcspawner" );
		spawnSystem->AddSpawnField("origin", va("%f %f %f",origin[0],origin[1],origin[2]) );
		spawnSystem->AddSpawnField("target", va("rmg_npc_%i", i + 1) );

		// Spawn the inhabitant, if it fails then fail
		ent = entitySystem->SpawnItem("trigger_arioche_npcspawner");
		if ( !ent )
		{
			continue;
		}

		// Fail if we cant register the entity
		if ( -1 == entitySystem->RegisterEntityWithServer( ent ) )
		{
			entitySystem->RemoveEntity ( ent );
			continue;
		}

		// Normalize the mins and maxs for the X axis since they arent
		// absolute mins and maxs
		mins[0] = -100;
		maxs[0] = 100;

		// Adjust the absmin and absmax for the trigger now
		VectorCopy ( mins, ent->r.mins[0] );
		VectorCopy ( maxs, ent->r.maxs[0] );

		Com_DPrintf( "NPC Trigger spawned at '%f %f %f' for targets 'rmg_npc_%i'\n", origin[0], origin[1], origin[2], i + 1 );

		// Set the "ONLY_ONCE" spawn flag
		ent->AddSpawnflags ( 2 );

#ifdef _GAME
		// initial linking
		gi.SV_LinkEntity( ent ); 
#endif	
	}

	AttachNPCTriggers ( landscape );
}
*/

/************************************************************************************************
 * CRMMission::AttachNPCTriggers
 *	Attaches npc triggers to all unattached npcs
 *
 * inputs:
 *  landscape: landscape triggers were spawned on
 *
 * return:
 *	trigger: a random trigger or NULL if one couldnt be found
 *
 ************************************************************************************************/
/*void CRMMission::AttachNPCTriggers ( CCMLandScape* landscape )
{
	TNPCList	npcList;
	TNPCFinder	npcFinder;
	CNPC*		theNPC = 0;
	int			npcsegment;

	GetCharacterManager().GetCharacterList(npcList);

	// Loop through all npcs and reset their accuracy
	for( npcFinder = npcList.begin(); npcFinder != npcList.end(); npcFinder++)
	{		
		theNPC = (CNPC*) INPCEnt::GetEntity(*npcFinder);
		if(!theNPC)
		{
			continue;
		}

		npcsegment = (theNPC->r.currentOrigin[0] - landscape->GetMins()[0]) / 5000.0f;		

		// All npcs in segment 0 and 1 are immediately spawned, all others wait for the
		// trigger
		if ( npcsegment > 1 )
		{
			entitySystem->RemoveFromTargetNameMap(theNPC);	
			theNPC->SetTargetName ( va("rmg_npc_%i", npcsegment ) );
			entitySystem->AddToTargetNameMap(theNPC);

			// Start the NPC in the off position
			theNPC->SetSpawnflags(1);
			theNPC->r.contents	= 0;
			theNPC->r.svFlags	|= SVF_NOCLIENT;
			theNPC->s.eFlags	|= EF_NODRAW;				
		}
	}
}
*/