DOOM-3-BFG

AASFile.cpp (33890B)

---

 /*
 ===========================================================================
 
 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 "../idlib/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 );
 }