/************************************************************************************************
 *
 *	Copyright (C) 2001-2002 Raven Software
 *
 *  RM_Path.cpp
 *
 ************************************************************************************************/
#include "../server/exe_headers.h"

#include "RM_Headers.h"

#define max(a,b)    (((a) > (b)) ? (a) : (b))

/************************************************************************************************
 * CRMNode::CRMNode
 *	constructor
 *
 * inputs:
 *  none
 *
 * return:
 *	none
 *
 ************************************************************************************************/
CRMNode::CRMNode ( )
{
	int i;

	mFlattenHeight = -1;

	mPos[0] = 0;
	mPos[1] = 0;
	mPos[2] = 0;

	// no paths
	for (i = 0; i < DIR_MAX; i++)
		mPathID[i] = -1;

	mAreaPointPlaced = false;
}


/************************************************************************************************
 * CRMPathManager::CRMPathManager
 *	constructor
 *
 * inputs:
 *  none
 *
 * return:
 *	none
 *
 ************************************************************************************************/
CRMPathManager::CRMPathManager ( CRandomTerrain* terrain )
: mXNodes(0), mYNodes(0), mPathCount(0), mRiverCount(0), mMaxDepth(0), mDepth(0),
  mPathPoints(10), mPathMinWidth(0.02f), mPathMaxWidth(0.04f), mPathDepth(0.3f), mPathDeviation(0.03f), mPathBreadth(5),
  mRiverDepth(5), mRiverPoints(10), mRiverMinWidth(0.01f), mRiverMaxWidth(0.02f), mRiverBedDepth(1), mRiverDeviation(0.01f), mRiverBreadth(7),
  mTerrain(terrain), mCrossed(false)
{
}

CRMPathManager::~CRMPathManager ( )
{
	int i,j;

	for ( i = mLocations.size() - 1; i >=0; i-- )
	{
		if (mLocations[i])
			delete mLocations[i];
	}
	mLocations.clear();

	for ( j = mNodes.size() - 1; j >=0; j-- )
	{
		if (mNodes[j])
			delete mNodes[j];
	}
	mNodes.clear();
}

void CRMPathManager::CreateLocation ( const char* name, const int min_depth, int max_depth, const int min_paths, int max_paths )
{
	int i;

	// sanity checks -- dmv
	if( max_paths < min_paths )
	{
		Com_Printf("[CreateLocation()] ERROR : max_paths < min_paths :: set max_paths = min_paths\n" );
		max_paths = min_paths;
	}
	if( max_depth < min_depth )
	{
		Com_Printf("[CreateLocation()] ERROR : max_depth < min_depth :: set max_depth = min_depth\n" );
		max_depth = min_depth;
	}

	for (i = mLocations.size()-1; i>=0; --i)
		if ( !Q_stricmp ( name, mLocations[i]->GetName ( ) ) )
		{
			mLocations[i]->SetMinDepth(min_depth);
			mLocations[i]->SetMaxDepth(max_depth);
			mLocations[i]->SetMinPaths(min_paths);
			mLocations[i]->SetMaxPaths(max_paths);
			return;
		}

	CRMLoc* pLoc= new CRMLoc(name, min_depth, max_depth, min_paths, max_paths); 
	mLocations.push_back(pLoc); 
	mMaxDepth =  max(mMaxDepth, max_depth);
}

void CRMPathManager::ClearCells(int x_nodes, int y_nodes)
{
	int x,y;

	// clear cell array - used for generating paths
	CRMCell empty;
	for (x=0; x < x_nodes * y_nodes; x++)
	{
		if (x >= mCells.size())
			mCells.push_back(empty);
		else
			mCells[x] = empty;
	}

	// set borders of world
	for (y = 0; y < y_nodes; y++)
	{
		mCells[y * x_nodes].SetBorder(DIR_W );
		mCells[y * x_nodes].SetBorder(DIR_SW );
		mCells[y * x_nodes].SetBorder(DIR_NW );
		mCells[y * x_nodes + x_nodes-1].SetBorder( DIR_E );
		mCells[y * x_nodes + x_nodes-1].SetBorder( DIR_NE );
		mCells[y * x_nodes + x_nodes-1].SetBorder( DIR_SE );
	}

	for (x = 0; x < x_nodes; x++)
	{
		mCells[x].SetBorder( DIR_N );
		mCells[x].SetBorder( DIR_NE );
		mCells[x].SetBorder( DIR_NW );
		mCells[(y_nodes-1) * x_nodes + x].SetBorder( DIR_S );
		mCells[(y_nodes-1) * x_nodes + x].SetBorder( DIR_SE );
		mCells[(y_nodes-1) * x_nodes + x].SetBorder( DIR_SW );
	}
}

/************************************************************************************************
 * CRMPathManager::CreateArray
 *	Create array of nodes that are spaced over the landscape.
 *	Create array of cells, which is used to determine how nodes are connected.
 *
 * inputs:
 *  x_nodes, y_nodes - how many nodes in each dimension to layout
 *
 * return:
 *	true if the node array was created, false if we have a problem
 *
 ************************************************************************************************/
bool CRMPathManager::CreateArray(const int x_nodes, const int y_nodes)
{
	mXNodes = x_nodes;
	mYNodes = y_nodes;

	// fill node array with positions that are spaced over the landscape
	int x,y;

	// dump existing nodes
	for ( x = mNodes.size() - 1; x >=0; x-- )
	{
		if (mNodes[x])
			delete mNodes[x];
	}
	mNodes.clear();
	mNodes.resize(mXNodes * mYNodes, NULL);

	// add a small amount of random jitter to spots chosen
	float x_rnd = 0.2f / (mXNodes+1);
	float y_rnd = 0.2f / (mYNodes+1);

	for (x = 0; x < mXNodes; x++)
	{
		float cell_x = (x + 1.0f) / (mXNodes+1);
//		float cell_x = (x + 2.0f) / (mXNodes+3);

		for (y = 0; y < mYNodes; y++)
		{
			vec3_t pos;
			CRMNode * pnode = new CRMNode();
			mNodes[x + y*mXNodes] = pnode;

			float cell_y = (y + 1.0f) / (mYNodes+1);
//			float cell_y = (y + 2.0f) / (mYNodes+3);

			pos[0] = TheRandomMissionManager->GetLandScape()->flrand(cell_x - x_rnd, cell_x + x_rnd);
			pos[1] = TheRandomMissionManager->GetLandScape()->flrand(cell_y - y_rnd, cell_y + y_rnd);
			pos[2] = 0;
			 
			SetNodePos(x, y, pos);
		}
	}

	ClearCells(mXNodes, mYNodes);

	return true;
}

// neighbor offsets - easy way to turn a direction into the array position for a neighboring cell or node
int CRMPathManager::neighbor_x[DIR_MAX] = { 0, 1, 1, 1, 0,-1,-1,-1};
int CRMPathManager::neighbor_y[DIR_MAX] = {-1,-1, 0, 1, 1, 1, 0,-1};

/************************************************************************************************
 * CRMPathManager::PlaceLocation
 * This method is used to determine if a named location should be placed at this node.
 *
 * inputs:
 *  c_x, c_y - cell to examine
 *
 * return:
 *	none
 *
 ************************************************************************************************/
void CRMPathManager::PlaceLocation(const int c_x, const int c_y)
{
	if ( !Node(c_x,c_y)->IsLocation() )
	{	// not currently a location

		// how many paths lead to this cell?
		int count_paths = 0;
		int i;

		for (i = 0; i<DIR_MAX; i++)
			if (Node(c_x,c_y)->PathExist(i))
				count_paths++;

		int deepest_depth = -1;
		int deepest_loc = -1;
		for (i = mLocations.size()-1; i>=0; --i)
		{
			if (!mLocations[i]->Placed() &&					// node has not been placed
				 mLocations[i]->MinDepth() <= mDepth &&		// our current depth is in the proper range
				 mLocations[i]->MaxDepth() >= mDepth &&
				 mLocations[i]->MinPaths() <= count_paths && // our path count is in the proper range
				 mLocations[i]->MaxPaths() >= count_paths &&
				 mLocations[i]->MaxDepth() > deepest_depth)	// and this is the deepest location of the ones that match
			{
				deepest_loc = i;
				deepest_depth = mLocations[i]->MaxDepth();
			}
		}

		if (deepest_loc >= 0 && deepest_loc < mLocations.size())
		{	// found a location to place at this node / cell
			const char * name = mLocations[deepest_loc]->GetName();
			Node(c_x,c_y)->SetName(name);
			mLocations[deepest_loc]->SetPlaced(true);

			// need a new max depth
			int max_depth = -1;
			for (i = mLocations.size()-1; i>=0; --i)
			{
				// figure out new max depth based on the max depth of unplaced locations
				if (!mLocations[i]->Placed() &&	   			// node has not been placed
					 mLocations[i]->MaxDepth() > max_depth)	// and this is the deepest 
				{
					max_depth = mLocations[i]->MaxDepth();
				}
			}
			mMaxDepth = max_depth;
		}
	}
}

/************************************************************************************************
 * CRMPathManager::PathVisit
 * This method is called recursively to create a network of nodes connected with paths.
 *
 * inputs:
 *  c_x, c_y - cell to visit
 *
 * return:
 *	none
 *
 ************************************************************************************************/
void CRMPathManager::PathVisit(const int c_x, const int c_y)
{
	// does this cell have any neighbors with all walls intact?
	int i,off;
	
	// look at neighbors in random order
	off = TheRandomMissionManager->GetLandScape()->irand(DIR_FIRST, DIR_MAX-1);

	++mDepth;	// track our depth of recursion

	for (i = DIR_FIRST; i<DIR_MAX && mDepth <= mMaxDepth; i++)
	{
		int d = (i + off) % DIR_MAX;
		if ( !Cell(c_x, c_y).Border(d) )
		{	// we can move this way, since no border
			int new_c_x = c_x + neighbor_x[d];
			int new_c_y = c_y + neighbor_y[d];
			if (Cell(new_c_x,new_c_y).Wall() == DIR_ALL)
			{	// we have a new cell that has not been visited!
				int new_dir;
				// d is the direction relative to the current cell
				// new_dir is the direction relative to the next cell (N becomes S, NE becomes SW, etc...)
				if( d < HALF_DIR_MAX )
				{
					new_dir = d + HALF_DIR_MAX;
				}
				else
				{
					new_dir = d - HALF_DIR_MAX;
				}
	
				// knock down walls
				Cell(c_x,c_y).RemoveWall(d);
				Cell(new_c_x,new_c_y).RemoveWall(new_dir); //DIR_MAX - d);

				// set path id
				Node(c_x, c_y)->SetPath(d, mPathCount);
				Node(new_c_x, new_c_y)->SetPath(new_dir, mPathCount); //DIR_MAX - d, mPathCount);

				// create path between cells
				mTerrain->CreatePath( mPathCount++,
									-1,
									0,
									mPathPoints,
									GetNodePos(c_x,c_y)[0],
									GetNodePos(c_x,c_y)[1],
									GetNodePos(new_c_x,new_c_y)[0],
									GetNodePos(new_c_x,new_c_y)[1],
									mPathMinWidth,
									mPathMaxWidth,
									mPathDepth,
									mPathDeviation,
									mPathBreadth );

				// flatten a small spot
				CArea		area;
				float flat_radius = mPathMaxWidth * 
					fabs(TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - TheRandomMissionManager->GetLandScape()->GetBounds()[0][0]);
				area.Init( GetNodePos(c_x,c_y), flat_radius, 0.0f, AT_NONE, 0, 0 );
				TheRandomMissionManager->GetLandScape()->FlattenArea(&area, 255 * mPathDepth, false, true, true );

				// recurse
				PathVisit(new_c_x, new_c_y);
			}
		}
	}
	
	--mDepth;

	// NOTE: *whoop* hack alert, the first time this is reached, it should be the very last placed node.
	if( !mCrossed && TheRandomMissionManager->GetMission()->GetSymmetric() &&
		TheRandomMissionManager->GetMission()->GetBackUpPath() )
	{	
		mCrossed = true; 
	
		int directionSet[3][3] = {DIR_NW,DIR_W,DIR_SW,DIR_N,-1,DIR_S,DIR_NE,DIR_E,DIR_SE};
		int	ncx	= (mXNodes-1)-c_x;
		int	ncy	= (mYNodes-1)-c_y;

		int x_delta = ncx - c_x;
		int y_delta = ncy - c_y;

		if( x_delta < -1 )
		{
			x_delta = -1;
		}
		else if( x_delta > 1 )
		{
			x_delta = 1;
		}

		if( y_delta < -1 )
		{
			y_delta = -1;
		}
		else if( y_delta > 1 )
		{
			y_delta = 1;
		}
		
		// make sure the mirror is actually in a different position than then un-mirrored node
		if( x_delta || y_delta )
		{

			int d = directionSet[x_delta][y_delta];
			int new_dir;
			// d is the direction relative to the current cell
			// new_dir is the direction relative to the next cell (N becomes S, NE becomes SW, etc...)
			if( d < HALF_DIR_MAX )
			{
				new_dir = d + HALF_DIR_MAX;
			}
			else
			{
				new_dir = d - HALF_DIR_MAX;
			}

			//NOTE: Knocking down these walls will cause instances to be created on this new artificial path
			// Since this path could span more than just the normal 1 cell, these walls being knocked down are not exactly correct... but get the job done

			// knock down walls
			Cell(c_x,c_y).RemoveWall(d);
			Cell(ncx,ncy).RemoveWall(new_dir); //DIR_MAX - d);

			// set path id
			Node(c_x, c_y)->SetPath(d, mPathCount);
			Node(ncx, ncy)->SetPath(new_dir, mPathCount); //DIR_MAX - d, mPathCount);
		
			// create an artificial path that crosses over to connect the symmetric and non-symmetric map parts
			mTerrain->CreatePath( mPathCount++,
								-1,
								0,
								mPathPoints,
								GetNodePos(c_x,c_y)[0],
								GetNodePos(c_x,c_y)[1],
								GetNodePos(ncx,ncy)[0],
								GetNodePos(ncx,ncy)[1],
								mPathMinWidth,
								mPathMaxWidth,
								mPathDepth,
								mPathDeviation,
								mPathBreadth );
		
		}
	}

	PlaceLocation(c_x, c_y);
}


/************************************************************************************************
 * CRMPathManager::FindNodeByName
 *	Finds the managed node with the matching case-insensivity name
 *
 * inputs:
 *  name - name of the node to find
 *
 * return:
 *	a pointer to the found node or NULL if the node couldn't be found
 *
 ************************************************************************************************/
CRMNode* CRMPathManager::FindNodeByName ( const char* name )
{
	int		 j;

	for ( j = mNodes.size() - 1; j >=0; j-- )
	{
		if ( !Q_stricmp ( name, mNodes[j]->GetName ( ) ) )
			return mNodes[j];
	}
	return NULL;
}


/************************************************************************************************
 * CRMPathManager::SetPathStyle
 *	sets style for all paths
 *
 * inputs:
 *  settings for paths that are created
 *
 * return:
 *	none
 *
 ************************************************************************************************/
void CRMPathManager::SetPathStyle ( 
	const int	points,
	const float	minwidth,
	const float	maxwidth,
	const float	depth,
	const float	deviation,
	const float	breadth
	)
{
	// save path style
	mPathPoints   = points  ;
	mPathMinWidth = minwidth;
	mPathMaxWidth = maxwidth;
	mPathDepth    = depth   ;
	mPathDeviation= deviation;
	mPathBreadth  = breadth ;
}

/************************************************************************************************
 * CRMPathManager::SetRiverStyle
 *	sets style for all rivers
 *
 * inputs:
 *  settings for river paths that are created
 *
 * return:
 *	none
 *
 ************************************************************************************************/
void CRMPathManager::SetRiverStyle (const int   depth,
									const int	points,
									const float minwidth,
									const float maxwidth,
									const float beddepth, 
									const float deviation, 
									const float breadth,
									string bridge_name)
{
	// save river style
	mRiverDepth    = depth;
	mRiverPoints   = points  ;
	mRiverMinWidth = minwidth;
	mRiverMaxWidth = maxwidth;
	mRiverBedDepth = beddepth   ;
	mRiverDeviation= deviation;
	mRiverBreadth  = breadth ;
	mRiverBridge   = bridge_name;
}

vec3_t&	CRMPathManager::GetRiverPos( const int x, const int y ) 
{ 
	mRiverPos[0] = (float)(x + 1.0f) / (float)(mXNodes+2);
	mRiverPos[1] = (float)(y + 1.0f) / (float)(mYNodes+2);
	return mRiverPos; 
}

void CRMPathManager::RiverVisit(const int c_x, const int c_y)
{
	// does this cell have any neighbors with all walls intact?
	int i,off;

	// look at neighbors in random order
	off = TheRandomMissionManager->GetLandScape()->irand(DIR_FIRST, DIR_MAX-1);

	++mDepth;	// track our depth of recursion

	for (i = DIR_FIRST; i<DIR_MAX && mDepth <= mMaxDepth; i+=2)
	{
		int d = (i + off) % DIR_MAX;
		if ( !Cell(c_x, c_y).Border(d) )
		{	// we can move this way, since no border
			int new_c_x = c_x + neighbor_x[d];
			int new_c_y = c_y + neighbor_y[d];
			if (RiverCell(new_c_x,new_c_y).Wall() == DIR_ALL)
			{	// we have a new cell that has not been visited!

				int new_dir;
				// d is the direction relative to the current cell
				// new_dir is the direction relative to the next cell (N becomes S, NE becomes SW, etc...)
				if( d < HALF_DIR_MAX )
				{
					new_dir = d + HALF_DIR_MAX;
				}
				else
				{
					new_dir = d - HALF_DIR_MAX;
				}
				// knock down walls
				RiverCell(c_x,c_y).RemoveWall(d);
				RiverCell(new_c_x,new_c_y).RemoveWall(new_dir); //DIR_MAX - d);

				// create river between cells
				mTerrain->CreatePath ( mPathCount++,
									-1,
									0,
									mRiverPoints,
									GetRiverPos(c_x,c_y)[0],
									GetRiverPos(c_x,c_y)[1],
									GetRiverPos(new_c_x,new_c_y)[0],
									GetRiverPos(new_c_x,new_c_y)[1],
									mRiverMinWidth,
									mRiverMaxWidth,
									mRiverBedDepth,
									mRiverDeviation,
									mRiverBreadth );

				// flatten a small spot
				CArea		area;
				float flat_radius = mRiverMinWidth * 
					fabs(TheRandomMissionManager->GetLandScape()->GetBounds()[1][0] - TheRandomMissionManager->GetLandScape()->GetBounds()[0][0]);
				area.Init( GetRiverPos(c_x,c_y), flat_radius, 0.0f, AT_NONE, 0, 0 );
				TheRandomMissionManager->GetLandScape()->FlattenArea (&area, 255 * mRiverBedDepth, false, true, true );

				// recurse
				RiverVisit(new_c_x, new_c_y);
			}
		}
	}
	
//	--mDepth;
}

/************************************************************************************************
 * CRMPathManager::GenerateRivers
 *	Creates a river which intersects the main path
 *
 * inputs:
 *  none
 *
 * return:
 *	none
 *
 ************************************************************************************************/
void CRMPathManager::GenerateRivers ()
{
	if (mRiverBedDepth == 1)
		// no rivers
		return;

	mMaxDepth = mRiverDepth;
	mDepth = 0;

	int cell_x = 0;
	int cell_y = 0;

	// choose starting cell along an edge
	int edge = TheRandomMissionManager->GetLandScape()->irand(0, 7);
	switch ( edge )
	{
		case 0:
			cell_x = mXNodes / 2; cell_y = 0;
			break;
		case 1:
			cell_x = mXNodes; cell_y = 0;
			break;
		case 2:
			cell_x = mXNodes; cell_y = mYNodes / 2;
			break;
		case 3:
			cell_x = mXNodes; cell_y = mYNodes;
			break;
		case 4:
			cell_x = mXNodes / 2; cell_y = mYNodes;
			break;
		case 5:
			cell_x = 0; cell_y = mYNodes;
			break;
		case 6:
			cell_x = 0; cell_y = mYNodes / 2;
			break;
		case 7:
			cell_x = 0; cell_y = 0;
			break;
	}

	ClearCells(mXNodes+1, mYNodes+1);

	mRiverCount = mPathCount;

	// visit the first cell
	RiverVisit(cell_x,cell_y);

	mRiverCount = mPathCount - mRiverCount;

	return;
}

/************************************************************************************************
 * CRMPathManager::GeneratePaths
 *	Creates all paths 
 *
 * inputs:
 *  none
 *
 * return:
 *	none
 *
 ************************************************************************************************/
void CRMPathManager::GeneratePaths ( symmetry_t symmetric )
{
	int cell_x = 0;
	int cell_y = 0;

	switch ( symmetric )
	{
		case SYMMETRY_TOPLEFT:
			cell_x = mXNodes-1;
			cell_y = 0;
			break;

		case SYMMETRY_BOTTOMRIGHT:
			cell_x = 0;
			cell_y = mYNodes-1;
			break;

		default:
		case SYMMETRY_NONE:
			// choose starting cell along an edge
			switch ( TheRandomMissionManager->GetLandScape()->irand(0, 7) )
			{
				case 0:
					cell_x = mXNodes / 2;
					break;
				case 1:
					cell_x = mXNodes-1;
					break;
				case 2:
					cell_x = mXNodes-1; cell_y = mYNodes / 2;
					break;
				case 3:
					cell_x = mXNodes-1; cell_y = mYNodes-1;
					break;
				case 4:
					cell_x = mXNodes / 2; cell_y = mYNodes-1;
					break;
				case 5:
					cell_y = mYNodes-1;
					break;
				case 6:
					cell_y = mYNodes / 2;
					break;
				default:
				case 7:
					break;
			}
			break;
	}

	// visit the first cell
	PathVisit(cell_x,cell_y);
}