/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").

Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/

#pragma hdrstop
#include "precompiled.h"


#include "AASFile.h"
#include "AASFile_local.h"


/*
===============================================================================

	idReachability

===============================================================================
*/

/*
================
Reachability_Write
================
*/
bool Reachability_Write( idFile* fp, idReachability* reach )
{
	fp->WriteFloatString( "\t\t%d %d (%f %f %f) (%f %f %f) %d %d",
						  ( int ) reach->travelType, ( int ) reach->toAreaNum, reach->start.x, reach->start.y, reach->start.z,
						  reach->end.x, reach->end.y, reach->end.z, reach->edgeNum, ( int ) reach->travelTime );
	return true;
}

/*
================
Reachability_Read
================
*/
bool Reachability_Read( idLexer& src, idReachability* reach )
{
	reach->travelType = src.ParseInt();
	reach->toAreaNum = src.ParseInt();
	src.Parse1DMatrix( 3, reach->start.ToFloatPtr() );
	src.Parse1DMatrix( 3, reach->end.ToFloatPtr() );
	reach->edgeNum = src.ParseInt();
	reach->travelTime = src.ParseInt();
	return true;
}

/*
================
idReachability::CopyBase
================
*/
void idReachability::CopyBase( idReachability& reach )
{
	travelType = reach.travelType;
	toAreaNum = reach.toAreaNum;
	start = reach.start;
	end = reach.end;
	edgeNum = reach.edgeNum;
	travelTime = reach.travelTime;
}


/*
===============================================================================

	idReachability_Special

===============================================================================
*/

/*
================
Reachability_Special_Write
================
*/
bool Reachability_Special_Write( idFile* fp, idReachability_Special* reach )
{
	int i;
	const idKeyValue* keyValue;
	
	fp->WriteFloatString( "\n\t\t{\n" );
	for( i = 0; i < reach->dict.GetNumKeyVals(); i++ )
	{
		keyValue = reach->dict.GetKeyVal( i );
		fp->WriteFloatString( "\t\t\t\"%s\" \"%s\"\n", keyValue->GetKey().c_str(), keyValue->GetValue().c_str() );
	}
	fp->WriteFloatString( "\t\t}\n" );
	
	return true;
}

/*
================
Reachability_Special_Read
================
*/
bool Reachability_Special_Read( idLexer& src, idReachability_Special* reach )
{
	idToken key, value;
	
	src.ExpectTokenString( "{" );
	while( src.ReadToken( &key ) )
	{
		if( key == "}" )
		{
			return true;
		}
		src.ExpectTokenType( TT_STRING, 0, &value );
		reach->dict.Set( key, value );
	}
	return false;
}

/*
===============================================================================

	idAASSettings

===============================================================================
*/

/*
============
idAASSettings::idAASSettings
============
*/
idAASSettings::idAASSettings()
{
	numBoundingBoxes = 1;
	boundingBoxes[0] = idBounds( idVec3( -16, -16, 0 ), idVec3( 16, 16, 72 ) );
	usePatches = false;
	writeBrushMap = false;
	playerFlood = false;
	noOptimize = false;
	allowSwimReachabilities = false;
	allowFlyReachabilities = false;
	fileExtension = "aas48";
	// physics settings
	gravity = idVec3( 0, 0, -1066 );
	gravityDir = gravity;
	gravityValue = gravityDir.Normalize();
	invGravityDir = -gravityDir;
	maxStepHeight = 14.0f;
	maxBarrierHeight = 32.0f;
	maxWaterJumpHeight = 20.0f;
	maxFallHeight = 64.0f;
	minFloorCos = 0.7f;
	// fixed travel times
	tt_barrierJump = 100;
	tt_startCrouching = 100;
	tt_waterJump = 100;
	tt_startWalkOffLedge = 100;
}

/*
============
idAASSettings::ParseBool
============
*/
bool idAASSettings::ParseBool( idLexer& src, bool& b )
{
	if( !src.ExpectTokenString( "=" ) )
	{
		return false;
	}
	b = src.ParseBool();
	return true;
}

/*
============
idAASSettings::ParseInt
============
*/
bool idAASSettings::ParseInt( idLexer& src, int& i )
{
	if( !src.ExpectTokenString( "=" ) )
	{
		return false;
	}
	i = src.ParseInt();
	return true;
}

/*
============
idAASSettings::ParseFloat
============
*/
bool idAASSettings::ParseFloat( idLexer& src, float& f )
{
	if( !src.ExpectTokenString( "=" ) )
	{
		return false;
	}
	f = src.ParseFloat();
	return true;
}

/*
============
idAASSettings::ParseVector
============
*/
bool idAASSettings::ParseVector( idLexer& src, idVec3& vec )
{
	if( !src.ExpectTokenString( "=" ) )
	{
		return false;
	}
	return ( src.Parse1DMatrix( 3, vec.ToFloatPtr() ) != 0 );
}

/*
============
idAASSettings::ParseBBoxes
============
*/
bool idAASSettings::ParseBBoxes( idLexer& src )
{
	idToken token;
	idBounds bounds;
	
	numBoundingBoxes = 0;
	
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	while( src.ReadToken( &token ) )
	{
		if( token == "}" )
		{
			return true;
		}
		src.UnreadToken( &token );
		src.Parse1DMatrix( 3, bounds[0].ToFloatPtr() );
		if( !src.ExpectTokenString( "-" ) )
		{
			return false;
		}
		src.Parse1DMatrix( 3, bounds[1].ToFloatPtr() );
		
		boundingBoxes[numBoundingBoxes++] = bounds;
	}
	return false;
}

/*
============
idAASSettings::FromParser
============
*/
bool idAASSettings::FromParser( idLexer& src )
{
	idToken token;
	
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	
	// parse the file
	while( 1 )
	{
		if( !src.ReadToken( &token ) )
		{
			break;
		}
		
		if( token == "}" )
		{
			break;
		}
		
		if( token == "bboxes" )
		{
			if( !ParseBBoxes( src ) )
			{
				return false;
			}
		}
		else if( token == "usePatches" )
		{
			if( !ParseBool( src, usePatches ) )
			{
				return false;
			}
		}
		else if( token == "writeBrushMap" )
		{
			if( !ParseBool( src, writeBrushMap ) )
			{
				return false;
			}
		}
		else if( token == "playerFlood" )
		{
			if( !ParseBool( src, playerFlood ) )
			{
				return false;
			}
		}
		else if( token == "allowSwimReachabilities" )
		{
			if( !ParseBool( src, allowSwimReachabilities ) )
			{
				return false;
			}
		}
		else if( token == "allowFlyReachabilities" )
		{
			if( !ParseBool( src, allowFlyReachabilities ) )
			{
				return false;
			}
		}
		else if( token == "fileExtension" )
		{
			src.ExpectTokenString( "=" );
			src.ExpectTokenType( TT_STRING, 0, &token );
			fileExtension = token;
		}
		else if( token == "gravity" )
		{
			ParseVector( src, gravity );
			gravityDir = gravity;
			gravityValue = gravityDir.Normalize();
			invGravityDir = -gravityDir;
		}
		else if( token == "maxStepHeight" )
		{
			if( !ParseFloat( src, maxStepHeight ) )
			{
				return false;
			}
		}
		else if( token == "maxBarrierHeight" )
		{
			if( !ParseFloat( src, maxBarrierHeight ) )
			{
				return false;
			}
		}
		else if( token == "maxWaterJumpHeight" )
		{
			if( !ParseFloat( src, maxWaterJumpHeight ) )
			{
				return false;
			}
		}
		else if( token == "maxFallHeight" )
		{
			if( !ParseFloat( src, maxFallHeight ) )
			{
				return false;
			}
		}
		else if( token == "minFloorCos" )
		{
			if( !ParseFloat( src, minFloorCos ) )
			{
				return false;
			}
		}
		else if( token == "tt_barrierJump" )
		{
			if( !ParseInt( src, tt_barrierJump ) )
			{
				return false;
			}
		}
		else if( token == "tt_startCrouching" )
		{
			if( !ParseInt( src, tt_startCrouching ) )
			{
				return false;
			}
		}
		else if( token == "tt_waterJump" )
		{
			if( !ParseInt( src, tt_waterJump ) )
			{
				return false;
			}
		}
		else if( token == "tt_startWalkOffLedge" )
		{
			if( !ParseInt( src, tt_startWalkOffLedge ) )
			{
				return false;
			}
		}
		else
		{
			src.Error( "invalid token '%s'", token.c_str() );
		}
	}
	
	if( numBoundingBoxes <= 0 )
	{
		src.Error( "no valid bounding box" );
	}
	
	return true;
}

/*
============
idAASSettings::FromFile
============
*/
bool idAASSettings::FromFile( const idStr& fileName )
{
	idLexer src( LEXFL_ALLOWPATHNAMES | LEXFL_NOSTRINGESCAPECHARS | LEXFL_NOSTRINGCONCAT );
	idStr name;
	
	name = fileName;
	
	common->Printf( "loading %s\n", name.c_str() );
	
	if( !src.LoadFile( name ) )
	{
		common->Error( "WARNING: couldn't load %s\n", name.c_str() );
		return false;
	}
	
	if( !src.ExpectTokenString( "settings" ) )
	{
		common->Error( "%s is not a settings file", name.c_str() );
		return false;
	}
	
	if( !FromParser( src ) )
	{
		common->Error( "failed to parse %s", name.c_str() );
		return false;
	}
	
	return true;
}

/*
============
idAASSettings::FromDict
============
*/
bool idAASSettings::FromDict( const char* name, const idDict* dict )
{
	idBounds bounds;
	
	if( !dict->GetVector( "mins", "0 0 0", bounds[ 0 ] ) )
	{
		common->Error( "Missing 'mins' in entityDef '%s'", name );
	}
	if( !dict->GetVector( "maxs", "0 0 0", bounds[ 1 ] ) )
	{
		common->Error( "Missing 'maxs' in entityDef '%s'", name );
	}
	
	numBoundingBoxes = 1;
	boundingBoxes[0] = bounds;
	
	if( !dict->GetBool( "usePatches", "0", usePatches ) )
	{
		common->Error( "Missing 'usePatches' in entityDef '%s'", name );
	}
	
	if( !dict->GetBool( "writeBrushMap", "0", writeBrushMap ) )
	{
		common->Error( "Missing 'writeBrushMap' in entityDef '%s'", name );
	}
	
	if( !dict->GetBool( "playerFlood", "0", playerFlood ) )
	{
		common->Error( "Missing 'playerFlood' in entityDef '%s'", name );
	}
	
	if( !dict->GetBool( "allowSwimReachabilities", "0", allowSwimReachabilities ) )
	{
		common->Error( "Missing 'allowSwimReachabilities' in entityDef '%s'", name );
	}
	
	if( !dict->GetBool( "allowFlyReachabilities", "0", allowFlyReachabilities ) )
	{
		common->Error( "Missing 'allowFlyReachabilities' in entityDef '%s'", name );
	}
	
	if( !dict->GetString( "fileExtension", "", fileExtension ) )
	{
		common->Error( "Missing 'fileExtension' in entityDef '%s'", name );
	}
	
	if( !dict->GetVector( "gravity", "0 0 -1066", gravity ) )
	{
		common->Error( "Missing 'gravity' in entityDef '%s'", name );
	}
	gravityDir = gravity;
	gravityValue = gravityDir.Normalize();
	invGravityDir = -gravityDir;
	
	if( !dict->GetFloat( "maxStepHeight", "0", maxStepHeight ) )
	{
		common->Error( "Missing 'maxStepHeight' in entityDef '%s'", name );
	}
	
	if( !dict->GetFloat( "maxBarrierHeight", "0", maxBarrierHeight ) )
	{
		common->Error( "Missing 'maxBarrierHeight' in entityDef '%s'", name );
	}
	
	if( !dict->GetFloat( "maxWaterJumpHeight", "0", maxWaterJumpHeight ) )
	{
		common->Error( "Missing 'maxWaterJumpHeight' in entityDef '%s'", name );
	}
	
	if( !dict->GetFloat( "maxFallHeight", "0", maxFallHeight ) )
	{
		common->Error( "Missing 'maxFallHeight' in entityDef '%s'", name );
	}
	
	if( !dict->GetFloat( "minFloorCos", "0", minFloorCos ) )
	{
		common->Error( "Missing 'minFloorCos' in entityDef '%s'", name );
	}
	
	if( !dict->GetInt( "tt_barrierJump", "0", tt_barrierJump ) )
	{
		common->Error( "Missing 'tt_barrierJump' in entityDef '%s'", name );
	}
	
	if( !dict->GetInt( "tt_startCrouching", "0", tt_startCrouching ) )
	{
		common->Error( "Missing 'tt_startCrouching' in entityDef '%s'", name );
	}
	
	if( !dict->GetInt( "tt_waterJump", "0", tt_waterJump ) )
	{
		common->Error( "Missing 'tt_waterJump' in entityDef '%s'", name );
	}
	
	if( !dict->GetInt( "tt_startWalkOffLedge", "0", tt_startWalkOffLedge ) )
	{
		common->Error( "Missing 'tt_startWalkOffLedge' in entityDef '%s'", name );
	}
	
	return true;
}


/*
============
idAASSettings::WriteToFile
============
*/
bool idAASSettings::WriteToFile( idFile* fp ) const
{
	int i;
	
	fp->WriteFloatString( "{\n" );
	fp->WriteFloatString( "\tbboxes\n\t{\n" );
	for( i = 0; i < numBoundingBoxes; i++ )
	{
		fp->WriteFloatString( "\t\t(%f %f %f)-(%f %f %f)\n", boundingBoxes[i][0].x, boundingBoxes[i][0].y,
							  boundingBoxes[i][0].z, boundingBoxes[i][1].x, boundingBoxes[i][1].y, boundingBoxes[i][1].z );
	}
	fp->WriteFloatString( "\t}\n" );
	fp->WriteFloatString( "\tusePatches = %d\n", usePatches );
	fp->WriteFloatString( "\twriteBrushMap = %d\n", writeBrushMap );
	fp->WriteFloatString( "\tplayerFlood = %d\n", playerFlood );
	fp->WriteFloatString( "\tallowSwimReachabilities = %d\n", allowSwimReachabilities );
	fp->WriteFloatString( "\tallowFlyReachabilities = %d\n", allowFlyReachabilities );
	fp->WriteFloatString( "\tfileExtension = \"%s\"\n", fileExtension.c_str() );
	fp->WriteFloatString( "\tgravity = (%f %f %f)\n", gravity.x, gravity.y, gravity.z );
	fp->WriteFloatString( "\tmaxStepHeight = %f\n", maxStepHeight );
	fp->WriteFloatString( "\tmaxBarrierHeight = %f\n", maxBarrierHeight );
	fp->WriteFloatString( "\tmaxWaterJumpHeight = %f\n", maxWaterJumpHeight );
	fp->WriteFloatString( "\tmaxFallHeight = %f\n", maxFallHeight );
	fp->WriteFloatString( "\tminFloorCos = %f\n", minFloorCos );
	fp->WriteFloatString( "\ttt_barrierJump = %d\n", tt_barrierJump );
	fp->WriteFloatString( "\ttt_startCrouching = %d\n", tt_startCrouching );
	fp->WriteFloatString( "\ttt_waterJump = %d\n", tt_waterJump );
	fp->WriteFloatString( "\ttt_startWalkOffLedge = %d\n", tt_startWalkOffLedge );
	fp->WriteFloatString( "}\n" );
	return true;
}

/*
============
idAASSettings::ValidForBounds
============
*/
bool idAASSettings::ValidForBounds( const idBounds& bounds ) const
{
	int i;
	
	for( i = 0; i < 3; i++ )
	{
		if( bounds[0][i] < boundingBoxes[0][0][i] )
		{
			return false;
		}
		if( bounds[1][i] > boundingBoxes[0][1][i] )
		{
			return false;
		}
	}
	return true;
}

/*
============
idAASSettings::ValidEntity
============
*/
bool idAASSettings::ValidEntity( const char* classname ) const
{
	idStr			use_aas;
	idVec3			size;
	idBounds		bounds;
	
	if( playerFlood )
	{
		if( !strcmp( classname, "info_player_start" ) || !strcmp( classname , "info_player_deathmatch" ) || !strcmp( classname, "func_teleporter" ) )
		{
			return true;
		}
	}
	
	const idDeclEntityDef* decl = static_cast<const idDeclEntityDef*>( declManager->FindType( DECL_ENTITYDEF, classname, false ) );
	if( ( decl != NULL ) && decl->dict.GetString( "use_aas", NULL, use_aas ) && !fileExtension.Icmp( use_aas ) )
	{
		if( decl->dict.GetVector( "mins", NULL, bounds[0] ) )
		{
			decl->dict.GetVector( "maxs", NULL, bounds[1] );
		}
		else if( decl->dict.GetVector( "size", NULL, size ) )
		{
			bounds[ 0 ].Set( size.x * -0.5f, size.y * -0.5f, 0.0f );
			bounds[ 1 ].Set( size.x * 0.5f, size.y * 0.5f, size.z );
		}
		
		if( !ValidForBounds( bounds ) )
		{
			common->Error( "%s cannot use %s\n", classname, fileExtension.c_str() );
		}
		
		return true;
	}
	
	return false;
}


/*
===============================================================================

	idAASFileLocal

===============================================================================
*/

#define AAS_LIST_GRANULARITY	1024
#define AAS_INDEX_GRANULARITY	4096
#define AAS_PLANE_GRANULARITY	4096
#define AAS_VERTEX_GRANULARITY	4096
#define AAS_EDGE_GRANULARITY	4096

/*
================
idAASFileLocal::idAASFileLocal
================
*/
idAASFileLocal::idAASFileLocal()
{
	planeList.SetGranularity( AAS_PLANE_GRANULARITY );
	vertices.SetGranularity( AAS_VERTEX_GRANULARITY );
	edges.SetGranularity( AAS_EDGE_GRANULARITY );
	edgeIndex.SetGranularity( AAS_INDEX_GRANULARITY );
	faces.SetGranularity( AAS_LIST_GRANULARITY );
	faceIndex.SetGranularity( AAS_INDEX_GRANULARITY );
	areas.SetGranularity( AAS_LIST_GRANULARITY );
	nodes.SetGranularity( AAS_LIST_GRANULARITY );
	portals.SetGranularity( AAS_LIST_GRANULARITY );
	portalIndex.SetGranularity( AAS_INDEX_GRANULARITY );
	clusters.SetGranularity( AAS_LIST_GRANULARITY );
}

/*
================
idAASFileLocal::~idAASFileLocal
================
*/
idAASFileLocal::~idAASFileLocal()
{
	int i;
	idReachability* reach, *next;
	
	for( i = 0; i < areas.Num(); i++ )
	{
		for( reach = areas[i].reach; reach; reach = next )
		{
			next = reach->next;
			delete reach;
		}
	}
}

/*
================
idAASFileLocal::Clear
================
*/
void idAASFileLocal::Clear()
{
	planeList.Clear();
	vertices.Clear();
	edges.Clear();
	edgeIndex.Clear();
	faces.Clear();
	faceIndex.Clear();
	areas.Clear();
	nodes.Clear();
	portals.Clear();
	portalIndex.Clear();
	clusters.Clear();
}

/*
================
idAASFileLocal::Write
================
*/
bool idAASFileLocal::Write( const idStr& fileName, unsigned int mapFileCRC )
{
	int i, num;
	idFile* aasFile;
	idReachability* reach;
	
	common->Printf( "[Write AAS]\n" );
	common->Printf( "writing %s\n", fileName.c_str() );
	
	name = fileName;
	crc = mapFileCRC;
	
	aasFile = fileSystem->OpenFileWrite( fileName, "fs_basepath" );
	if( !aasFile )
	{
		common->Error( "Error opening %s", fileName.c_str() );
		return false;
	}
	
	aasFile->WriteFloatString( "%s \"%s\"\n\n", AAS_FILEID, AAS_FILEVERSION );
	aasFile->WriteFloatString( "%u\n\n", mapFileCRC );
	
	// write out the settings
	aasFile->WriteFloatString( "settings\n" );
	settings.WriteToFile( aasFile );
	
	// write out planes
	aasFile->WriteFloatString( "planes %d {\n", planeList.Num() );
	for( i = 0; i < planeList.Num(); i++ )
	{
		aasFile->WriteFloatString( "\t%d ( %f %f %f %f )\n", i,
								   planeList[i].Normal().x, planeList[i].Normal().y, planeList[i].Normal().z, planeList[i].Dist() );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// write out vertices
	aasFile->WriteFloatString( "vertices %d {\n", vertices.Num() );
	for( i = 0; i < vertices.Num(); i++ )
	{
		aasFile->WriteFloatString( "\t%d ( %f %f %f )\n", i, vertices[i].x, vertices[i].y, vertices[i].z );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// write out edges
	aasFile->WriteFloatString( "edges %d {\n", edges.Num() );
	for( i = 0; i < edges.Num(); i++ )
	{
		aasFile->WriteFloatString( "\t%d ( %d %d )\n", i, edges[i].vertexNum[0], edges[i].vertexNum[1] );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// write out edgeIndex
	aasFile->WriteFloatString( "edgeIndex %d {\n", edgeIndex.Num() );
	for( i = 0; i < edgeIndex.Num(); i++ )
	{
		aasFile->WriteFloatString( "\t%d ( %d )\n", i, edgeIndex[i] );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// write out faces
	aasFile->WriteFloatString( "faces %d {\n", faces.Num() );
	for( i = 0; i < faces.Num(); i++ )
	{
		aasFile->WriteFloatString( "\t%d ( %d %d %d %d %d %d )\n", i, faces[i].planeNum, faces[i].flags,
								   faces[i].areas[0], faces[i].areas[1], faces[i].firstEdge, faces[i].numEdges );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// write out faceIndex
	aasFile->WriteFloatString( "faceIndex %d {\n", faceIndex.Num() );
	for( i = 0; i < faceIndex.Num(); i++ )
	{
		aasFile->WriteFloatString( "\t%d ( %d )\n", i, faceIndex[i] );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// write out areas
	aasFile->WriteFloatString( "areas %d {\n", areas.Num() );
	for( i = 0; i < areas.Num(); i++ )
	{
		for( num = 0, reach = areas[i].reach; reach; reach = reach->next )
		{
			num++;
		}
		aasFile->WriteFloatString( "\t%d ( %d %d %d %d %d %d ) %d {\n", i, areas[i].flags, areas[i].contents,
								   areas[i].firstFace, areas[i].numFaces, areas[i].cluster, areas[i].clusterAreaNum, num );
		for( reach = areas[i].reach; reach; reach = reach->next )
		{
			Reachability_Write( aasFile, reach );
			switch( reach->travelType )
			{
				case TFL_SPECIAL:
					Reachability_Special_Write( aasFile, static_cast<idReachability_Special*>( reach ) );
					break;
			}
			aasFile->WriteFloatString( "\n" );
		}
		aasFile->WriteFloatString( "\t}\n" );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// write out nodes
	aasFile->WriteFloatString( "nodes %d {\n", nodes.Num() );
	for( i = 0; i < nodes.Num(); i++ )
	{
		aasFile->WriteFloatString( "\t%d ( %d %d %d )\n", i, nodes[i].planeNum, nodes[i].children[0], nodes[i].children[1] );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// write out portals
	aasFile->WriteFloatString( "portals %d {\n", portals.Num() );
	for( i = 0; i < portals.Num(); i++ )
	{
		aasFile->WriteFloatString( "\t%d ( %d %d %d %d %d )\n", i, portals[i].areaNum, portals[i].clusters[0],
								   portals[i].clusters[1], portals[i].clusterAreaNum[0], portals[i].clusterAreaNum[1] );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// write out portalIndex
	aasFile->WriteFloatString( "portalIndex %d {\n", portalIndex.Num() );
	for( i = 0; i < portalIndex.Num(); i++ )
	{
		aasFile->WriteFloatString( "\t%d ( %d )\n", i, portalIndex[i] );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// write out clusters
	aasFile->WriteFloatString( "clusters %d {\n", clusters.Num() );
	for( i = 0; i < clusters.Num(); i++ )
	{
		aasFile->WriteFloatString( "\t%d ( %d %d %d %d )\n", i, clusters[i].numAreas, clusters[i].numReachableAreas,
								   clusters[i].firstPortal, clusters[i].numPortals );
	}
	aasFile->WriteFloatString( "}\n" );
	
	// close file
	fileSystem->CloseFile( aasFile );
	
	common->Printf( "done.\n" );
	
	return true;
}

/*
================
idAASFileLocal::ParseIndex
================
*/
bool idAASFileLocal::ParseIndex( idLexer& src, idList<aasIndex_t>& indexes )
{
	int numIndexes, i;
	aasIndex_t index;
	
	numIndexes = src.ParseInt();
	indexes.Resize( numIndexes );
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	for( i = 0; i < numIndexes; i++ )
	{
		src.ParseInt();
		src.ExpectTokenString( "(" );
		index = src.ParseInt();
		src.ExpectTokenString( ")" );
		indexes.Append( index );
	}
	if( !src.ExpectTokenString( "}" ) )
	{
		return false;
	}
	return true;
}

/*
================
idAASFileLocal::ParsePlanes
================
*/
bool idAASFileLocal::ParsePlanes( idLexer& src )
{
	int numPlanes, i;
	idPlane plane;
	idVec4 vec;
	
	numPlanes = src.ParseInt();
	planeList.Resize( numPlanes );
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	for( i = 0; i < numPlanes; i++ )
	{
		src.ParseInt();
		if( !src.Parse1DMatrix( 4, vec.ToFloatPtr() ) )
		{
			return false;
		}
		plane.SetNormal( vec.ToVec3() );
		plane.SetDist( vec[3] );
		planeList.Append( plane );
	}
	if( !src.ExpectTokenString( "}" ) )
	{
		return false;
	}
	return true;
}

/*
================
idAASFileLocal::ParseVertices
================
*/
bool idAASFileLocal::ParseVertices( idLexer& src )
{
	int numVertices, i;
	idVec3 vec;
	
	numVertices = src.ParseInt();
	vertices.Resize( numVertices );
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	for( i = 0; i < numVertices; i++ )
	{
		src.ParseInt();
		if( !src.Parse1DMatrix( 3, vec.ToFloatPtr() ) )
		{
			return false;
		}
		vertices.Append( vec );
	}
	if( !src.ExpectTokenString( "}" ) )
	{
		return false;
	}
	return true;
}

/*
================
idAASFileLocal::ParseEdges
================
*/
bool idAASFileLocal::ParseEdges( idLexer& src )
{
	int numEdges, i;
	aasEdge_t edge;
	
	numEdges = src.ParseInt();
	edges.Resize( numEdges );
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	for( i = 0; i < numEdges; i++ )
	{
		src.ParseInt();
		src.ExpectTokenString( "(" );
		edge.vertexNum[0] = src.ParseInt();
		edge.vertexNum[1] = src.ParseInt();
		src.ExpectTokenString( ")" );
		edges.Append( edge );
	}
	if( !src.ExpectTokenString( "}" ) )
	{
		return false;
	}
	return true;
}

/*
================
idAASFileLocal::ParseFaces
================
*/
bool idAASFileLocal::ParseFaces( idLexer& src )
{
	int numFaces, i;
	aasFace_t face;
	
	numFaces = src.ParseInt();
	faces.Resize( numFaces );
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	for( i = 0; i < numFaces; i++ )
	{
		src.ParseInt();
		src.ExpectTokenString( "(" );
		face.planeNum = src.ParseInt();
		face.flags = src.ParseInt();
		face.areas[0] = src.ParseInt();
		face.areas[1] = src.ParseInt();
		face.firstEdge = src.ParseInt();
		face.numEdges = src.ParseInt();
		src.ExpectTokenString( ")" );
		faces.Append( face );
	}
	if( !src.ExpectTokenString( "}" ) )
	{
		return false;
	}
	return true;
}

/*
================
idAASFileLocal::ParseReachabilities
================
*/
bool idAASFileLocal::ParseReachabilities( idLexer& src, int areaNum )
{
	int num, j;
	aasArea_t* area;
	idReachability reach, *newReach;
	idReachability_Special* special;
	
	area = &areas[areaNum];
	
	num = src.ParseInt();
	src.ExpectTokenString( "{" );
	area->reach = NULL;
	area->rev_reach = NULL;
	area->travelFlags = AreaContentsTravelFlags( areaNum );
	for( j = 0; j < num; j++ )
	{
		Reachability_Read( src, &reach );
		switch( reach.travelType )
		{
			case TFL_SPECIAL:
				newReach = special = new( TAG_AAS ) idReachability_Special();
				Reachability_Special_Read( src, special );
				break;
			default:
				newReach = new( TAG_AAS ) idReachability();
				break;
		}
		newReach->CopyBase( reach );
		newReach->fromAreaNum = areaNum;
		newReach->next = area->reach;
		area->reach = newReach;
	}
	src.ExpectTokenString( "}" );
	return true;
}

/*
================
idAASFileLocal::LinkReversedReachability
================
*/
void idAASFileLocal::LinkReversedReachability()
{
	int i;
	idReachability* reach;
	
	// link reversed reachabilities
	for( i = 0; i < areas.Num(); i++ )
	{
		for( reach = areas[i].reach; reach; reach = reach->next )
		{
			reach->rev_next = areas[reach->toAreaNum].rev_reach;
			areas[reach->toAreaNum].rev_reach = reach;
		}
	}
}

/*
================
idAASFileLocal::ParseAreas
================
*/
bool idAASFileLocal::ParseAreas( idLexer& src )
{
	int numAreas, i;
	aasArea_t area;
	
	numAreas = src.ParseInt();
	areas.Resize( numAreas );
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	for( i = 0; i < numAreas; i++ )
	{
		src.ParseInt();
		src.ExpectTokenString( "(" );
		area.flags = src.ParseInt();
		area.contents = src.ParseInt();
		area.firstFace = src.ParseInt();
		area.numFaces = src.ParseInt();
		area.cluster = src.ParseInt();
		area.clusterAreaNum = src.ParseInt();
		src.ExpectTokenString( ")" );
		areas.Append( area );
		ParseReachabilities( src, i );
	}
	if( !src.ExpectTokenString( "}" ) )
	{
		return false;
	}
	
	LinkReversedReachability();
	
	return true;
}

/*
================
idAASFileLocal::ParseNodes
================
*/
bool idAASFileLocal::ParseNodes( idLexer& src )
{
	int numNodes, i;
	aasNode_t node;
	
	numNodes = src.ParseInt();
	nodes.Resize( numNodes );
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	for( i = 0; i < numNodes; i++ )
	{
		src.ParseInt();
		src.ExpectTokenString( "(" );
		node.planeNum = src.ParseInt();
		node.children[0] = src.ParseInt();
		node.children[1] = src.ParseInt();
		src.ExpectTokenString( ")" );
		nodes.Append( node );
	}
	if( !src.ExpectTokenString( "}" ) )
	{
		return false;
	}
	return true;
}

/*
================
idAASFileLocal::ParsePortals
================
*/
bool idAASFileLocal::ParsePortals( idLexer& src )
{
	int numPortals, i;
	aasPortal_t portal;
	
	numPortals = src.ParseInt();
	portals.Resize( numPortals );
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	for( i = 0; i < numPortals; i++ )
	{
		src.ParseInt();
		src.ExpectTokenString( "(" );
		portal.areaNum = src.ParseInt();
		portal.clusters[0] = src.ParseInt();
		portal.clusters[1] = src.ParseInt();
		portal.clusterAreaNum[0] = src.ParseInt();
		portal.clusterAreaNum[1] = src.ParseInt();
		src.ExpectTokenString( ")" );
		portals.Append( portal );
	}
	if( !src.ExpectTokenString( "}" ) )
	{
		return false;
	}
	return true;
}

/*
================
idAASFileLocal::ParseClusters
================
*/
bool idAASFileLocal::ParseClusters( idLexer& src )
{
	int numClusters, i;
	aasCluster_t cluster;
	
	numClusters = src.ParseInt();
	clusters.Resize( numClusters );
	if( !src.ExpectTokenString( "{" ) )
	{
		return false;
	}
	for( i = 0; i < numClusters; i++ )
	{
		src.ParseInt();
		src.ExpectTokenString( "(" );
		cluster.numAreas = src.ParseInt();
		cluster.numReachableAreas = src.ParseInt();
		cluster.firstPortal = src.ParseInt();
		cluster.numPortals = src.ParseInt();
		src.ExpectTokenString( ")" );
		clusters.Append( cluster );
	}
	if( !src.ExpectTokenString( "}" ) )
	{
		return false;
	}
	return true;
}

/*
================
idAASFileLocal::FinishAreas
================
*/
void idAASFileLocal::FinishAreas()
{
	int i;
	
	for( i = 0; i < areas.Num(); i++ )
	{
		areas[i].center = AreaReachableGoal( i );
		areas[i].bounds = AreaBounds( i );
	}
}

/*
================
idAASFileLocal::Load
================
*/
bool idAASFileLocal::Load( const idStr& fileName, unsigned int mapFileCRC )
{
	idLexer src( LEXFL_NOFATALERRORS | LEXFL_NOSTRINGESCAPECHARS | LEXFL_NOSTRINGCONCAT | LEXFL_ALLOWPATHNAMES );
	idToken token;
	int depth;
	unsigned int c;
	
	name = fileName;
	crc = mapFileCRC;
	
	common->Printf( "[Load AAS]\n" );
	common->Printf( "loading %s\n", name.c_str() );
	
	if( !src.LoadFile( name ) )
	{
		return false;
	}
	
	if( !src.ExpectTokenString( AAS_FILEID ) )
	{
		common->Warning( "Not an AAS file: '%s'", name.c_str() );
		return false;
	}
	
	if( !src.ReadToken( &token ) || token != AAS_FILEVERSION )
	{
		common->Warning( "AAS file '%s' has version %s instead of %s", name.c_str(), token.c_str(), AAS_FILEVERSION );
		return false;
	}
	
	if( !src.ExpectTokenType( TT_NUMBER, TT_INTEGER, &token ) )
	{
		common->Warning( "AAS file '%s' has no map file CRC", name.c_str() );
		return false;
	}
	
	c = token.GetUnsignedLongValue();
	if( mapFileCRC && c != mapFileCRC )
	{
		common->Warning( "AAS file '%s' is out of date", name.c_str() );
		return false;
	}
	
	// clear the file in memory
	Clear();
	
	// parse the file
	while( 1 )
	{
		if( !src.ReadToken( &token ) )
		{
			break;
		}
		
		if( token == "settings" )
		{
			if( !settings.FromParser( src ) )
			{
				return false;
			}
		}
		else if( token == "planes" )
		{
			if( !ParsePlanes( src ) )
			{
				return false;
			}
		}
		else if( token == "vertices" )
		{
			if( !ParseVertices( src ) )
			{
				return false;
			}
		}
		else if( token == "edges" )
		{
			if( !ParseEdges( src ) )
			{
				return false;
			}
		}
		else if( token == "edgeIndex" )
		{
			if( !ParseIndex( src, edgeIndex ) )
			{
				return false;
			}
		}
		else if( token == "faces" )
		{
			if( !ParseFaces( src ) )
			{
				return false;
			}
		}
		else if( token == "faceIndex" )
		{
			if( !ParseIndex( src, faceIndex ) )
			{
				return false;
			}
		}
		else if( token == "areas" )
		{
			if( !ParseAreas( src ) )
			{
				return false;
			}
		}
		else if( token == "nodes" )
		{
			if( !ParseNodes( src ) )
			{
				return false;
			}
		}
		else if( token == "portals" )
		{
			if( !ParsePortals( src ) )
			{
				return false;
			}
		}
		else if( token == "portalIndex" )
		{
			if( !ParseIndex( src, portalIndex ) )
			{
				return false;
			}
		}
		else if( token == "clusters" )
		{
			if( !ParseClusters( src ) )
			{
				return false;
			}
		}
		else
		{
			src.Error( "idAASFileLocal::Load: bad token \"%s\"", token.c_str() );
			return false;
		}
	}
	
	FinishAreas();
	
	depth = MaxTreeDepth();
	if( depth > MAX_AAS_TREE_DEPTH )
	{
		src.Error( "idAASFileLocal::Load: tree depth = %d", depth );
	}
	
	common->UpdateLevelLoadPacifier();
	
	common->Printf( "done.\n" );
	
	return true;
}

/*
================
idAASFileLocal::MemorySize
================
*/
int idAASFileLocal::MemorySize() const
{
	int size;
	
	size = planeList.Size();
	size += vertices.Size();
	size += edges.Size();
	size += edgeIndex.Size();
	size += faces.Size();
	size += faceIndex.Size();
	size += areas.Size();
	size += nodes.Size();
	size += portals.Size();
	size += portalIndex.Size();
	size += clusters.Size();
	size += sizeof( idReachability_Walk ) * NumReachabilities();
	
	return size;
}

/*
================
idAASFileLocal::PrintInfo
================
*/
void idAASFileLocal::PrintInfo() const
{
	common->Printf( "%6d KB file size\n", MemorySize() >> 10 );
	common->Printf( "%6d areas\n", areas.Num() );
	common->Printf( "%6d max tree depth\n", MaxTreeDepth() );
	ReportRoutingEfficiency();
}

/*
================
idAASFileLocal::NumReachabilities
================
*/
int idAASFileLocal::NumReachabilities() const
{
	int i, num;
	idReachability* reach;
	
	num = 0;
	for( i = 0; i < areas.Num(); i++ )
	{
		for( reach = areas[i].reach; reach; reach = reach->next )
		{
			num++;
		}
	}
	return num;
}

/*
================
idAASFileLocal::ReportRoutingEfficiency
================
*/
void idAASFileLocal::ReportRoutingEfficiency() const
{
	int numReachableAreas, total, i, n;
	
	numReachableAreas = 0;
	total = 0;
	for( i = 0; i < clusters.Num(); i++ )
	{
		n = clusters[i].numReachableAreas;
		numReachableAreas += n;
		total += n * n;
	}
	total += numReachableAreas * portals.Num();
	
	common->Printf( "%6d reachable areas\n", numReachableAreas );
	common->Printf( "%6d reachabilities\n", NumReachabilities() );
	common->Printf( "%6d KB max routing cache\n", ( total * 3 ) >> 10 );
}

/*
================
idAASFileLocal::DeleteReachabilities
================
*/
void idAASFileLocal::DeleteReachabilities()
{
	int i;
	idReachability* reach, *nextReach;
	
	for( i = 0; i < areas.Num(); i++ )
	{
		for( reach = areas[i].reach; reach; reach = nextReach )
		{
			nextReach = reach->next;
			delete reach;
		}
		areas[i].reach = NULL;
		areas[i].rev_reach = NULL;
	}
}

/*
================
idAASFileLocal::DeleteClusters
================
*/
void idAASFileLocal::DeleteClusters()
{
	aasPortal_t portal;
	aasCluster_t cluster;
	
	portals.Clear();
	portalIndex.Clear();
	clusters.Clear();
	
	// first portal is a dummy
	memset( &portal, 0, sizeof( portal ) );
	portals.Append( portal );
	
	// first cluster is a dummy
	memset( &cluster, 0, sizeof( cluster ) );
	clusters.Append( cluster );
}