Quake-III-Arena

be_aas_sample.c (44151B)

---

 /*
 ===========================================================================
 Copyright (C) 1999-2005 Id Software, Inc.
 
 This file is part of Quake III Arena source code.
 
 Quake III Arena 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 2 of the License,
 or (at your option) any later version.
 
 Quake III Arena 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 Foobar; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 ===========================================================================
 */
 
 /*****************************************************************************
  * name:		be_aas_sample.c
  *
  * desc:		AAS environment sampling
  *
  * $Archive: /MissionPack/code/botlib/be_aas_sample.c $
  *
  *****************************************************************************/
 
 #include "../game/q_shared.h"
 #include "l_memory.h"
 #include "l_script.h"
 #include "l_precomp.h"
 #include "l_struct.h"
 #ifndef BSPC
 #include "l_libvar.h"
 #endif
 #include "aasfile.h"
 #include "../game/botlib.h"
 #include "../game/be_aas.h"
 #include "be_interface.h"
 #include "be_aas_funcs.h"
 #include "be_aas_def.h"
 
 extern botlib_import_t botimport;
 
 //#define AAS_SAMPLE_DEBUG
 
 #define BBOX_NORMAL_EPSILON		0.001
 
 #define ON_EPSILON					0 //0.0005
 
 #define TRACEPLANE_EPSILON			0.125
 
 typedef struct aas_tracestack_s
 {
 	vec3_t start;		//start point of the piece of line to trace
 	vec3_t end;			//end point of the piece of line to trace
 	int planenum;		//last plane used as splitter
 	int nodenum;		//node found after splitting with planenum
 } aas_tracestack_t;
 
 int numaaslinks;
 
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs)
 {
 	int index;
 	//bounding box size for each presence type
 	vec3_t boxmins[3] = {{0, 0, 0}, {-15, -15, -24}, {-15, -15, -24}};
 	vec3_t boxmaxs[3] = {{0, 0, 0}, { 15,  15,  32}, { 15,  15,   8}};
 
 	if (presencetype == PRESENCE_NORMAL) index = 1;
 	else if (presencetype == PRESENCE_CROUCH) index = 2;
 	else
 	{
 		botimport.Print(PRT_FATAL, "AAS_PresenceTypeBoundingBox: unknown presence type\n");
 		index = 2;
 	} //end if
 	VectorCopy(boxmins[index], mins);
 	VectorCopy(boxmaxs[index], maxs);
 } //end of the function AAS_PresenceTypeBoundingBox
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_InitAASLinkHeap(void)
 {
 	int i, max_aaslinks;
 
 	max_aaslinks = aasworld.linkheapsize;
 	//if there's no link heap present
 	if (!aasworld.linkheap)
 	{
 #ifdef BSPC
 		max_aaslinks = 6144;
 #else
 		max_aaslinks = (int) LibVarValue("max_aaslinks", "6144");
 #endif
 		if (max_aaslinks < 0) max_aaslinks = 0;
 		aasworld.linkheapsize = max_aaslinks;
 		aasworld.linkheap = (aas_link_t *) GetHunkMemory(max_aaslinks * sizeof(aas_link_t));
 	} //end if
 	//link the links on the heap
 	aasworld.linkheap[0].prev_ent = NULL;
 	aasworld.linkheap[0].next_ent = &aasworld.linkheap[1];
 	for (i = 1; i < max_aaslinks-1; i++)
 	{
 		aasworld.linkheap[i].prev_ent = &aasworld.linkheap[i - 1];
 		aasworld.linkheap[i].next_ent = &aasworld.linkheap[i + 1];
 	} //end for
 	aasworld.linkheap[max_aaslinks-1].prev_ent = &aasworld.linkheap[max_aaslinks-2];
 	aasworld.linkheap[max_aaslinks-1].next_ent = NULL;
 	//pointer to the first free link
 	aasworld.freelinks = &aasworld.linkheap[0];
 	//
 	numaaslinks = max_aaslinks;
 } //end of the function AAS_InitAASLinkHeap
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_FreeAASLinkHeap(void)
 {
 	if (aasworld.linkheap) FreeMemory(aasworld.linkheap);
 	aasworld.linkheap = NULL;
 	aasworld.linkheapsize = 0;
 } //end of the function AAS_FreeAASLinkHeap
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 aas_link_t *AAS_AllocAASLink(void)
 {
 	aas_link_t *link;
 
 	link = aasworld.freelinks;
 	if (!link)
 	{
 #ifndef BSPC
 		if (bot_developer)
 #endif
 		{
 			botimport.Print(PRT_FATAL, "empty aas link heap\n");
 		} //end if
 		return NULL;
 	} //end if
 	if (aasworld.freelinks) aasworld.freelinks = aasworld.freelinks->next_ent;
 	if (aasworld.freelinks) aasworld.freelinks->prev_ent = NULL;
 	numaaslinks--;
 	return link;
 } //end of the function AAS_AllocAASLink
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_DeAllocAASLink(aas_link_t *link)
 {
 	if (aasworld.freelinks) aasworld.freelinks->prev_ent = link;
 	link->prev_ent = NULL;
 	link->next_ent = aasworld.freelinks;
 	link->prev_area = NULL;
 	link->next_area = NULL;
 	aasworld.freelinks = link;
 	numaaslinks++;
 } //end of the function AAS_DeAllocAASLink
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_InitAASLinkedEntities(void)
 {
 	if (!aasworld.loaded) return;
 	if (aasworld.arealinkedentities) FreeMemory(aasworld.arealinkedentities);
 	aasworld.arealinkedentities = (aas_link_t **) GetClearedHunkMemory(
 						aasworld.numareas * sizeof(aas_link_t *));
 } //end of the function AAS_InitAASLinkedEntities
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_FreeAASLinkedEntities(void)
 {
 	if (aasworld.arealinkedentities) FreeMemory(aasworld.arealinkedentities);
 	aasworld.arealinkedentities = NULL;
 } //end of the function AAS_InitAASLinkedEntities
 //===========================================================================
 // returns the AAS area the point is in
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_PointAreaNum(vec3_t point)
 {
 	int nodenum;
 	vec_t	dist;
 	aas_node_t *node;
 	aas_plane_t *plane;
 
 	if (!aasworld.loaded)
 	{
 		botimport.Print(PRT_ERROR, "AAS_PointAreaNum: aas not loaded\n");
 		return 0;
 	} //end if
 
 	//start with node 1 because node zero is a dummy used for solid leafs
 	nodenum = 1;
 	while (nodenum > 0)
 	{
 //		botimport.Print(PRT_MESSAGE, "[%d]", nodenum);
 #ifdef AAS_SAMPLE_DEBUG
 		if (nodenum >= aasworld.numnodes)
 		{
 			botimport.Print(PRT_ERROR, "nodenum = %d >= aasworld.numnodes = %d\n", nodenum, aasworld.numnodes);
 			return 0;
 		} //end if
 #endif //AAS_SAMPLE_DEBUG
 		node = &aasworld.nodes[nodenum];
 #ifdef AAS_SAMPLE_DEBUG
 		if (node->planenum < 0 || node->planenum >= aasworld.numplanes)
 		{
 			botimport.Print(PRT_ERROR, "node->planenum = %d >= aasworld.numplanes = %d\n", node->planenum, aasworld.numplanes);
 			return 0;
 		} //end if
 #endif //AAS_SAMPLE_DEBUG
 		plane = &aasworld.planes[node->planenum];
 		dist = DotProduct(point, plane->normal) - plane->dist;
 		if (dist > 0) nodenum = node->children[0];
 		else nodenum = node->children[1];
 	} //end while
 	if (!nodenum)
 	{
 #ifdef AAS_SAMPLE_DEBUG
 		botimport.Print(PRT_MESSAGE, "in solid\n");
 #endif //AAS_SAMPLE_DEBUG
 		return 0;
 	} //end if
 	return -nodenum;
 } //end of the function AAS_PointAreaNum
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 int AAS_PointReachabilityAreaIndex( vec3_t origin )
 {
 	int areanum, cluster, i, index;
 
 	if (!aasworld.initialized)
 		return 0;
 
 	if ( !origin )
 	{
 		index = 0;
 		for (i = 0; i < aasworld.numclusters; i++)
 		{
 			index += aasworld.clusters[i].numreachabilityareas;
 		} //end for
 		return index;
 	} //end if
 
 	areanum = AAS_PointAreaNum( origin );
 	if ( !areanum || !AAS_AreaReachability(areanum) )
 		return 0;
 	cluster = aasworld.areasettings[areanum].cluster;
 	areanum = aasworld.areasettings[areanum].clusterareanum;
 	if (cluster < 0)
 	{
 		cluster = aasworld.portals[-cluster].frontcluster;
 		areanum = aasworld.portals[-cluster].clusterareanum[0];
 	} //end if
 
 	index = 0;
 	for (i = 0; i < cluster; i++)
 	{
 		index += aasworld.clusters[i].numreachabilityareas;
 	} //end for
 	index += areanum;
 	return index;
 } //end of the function AAS_PointReachabilityAreaIndex
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaCluster(int areanum)
 {
 	if (areanum <= 0 || areanum >= aasworld.numareas)
 	{
 		botimport.Print(PRT_ERROR, "AAS_AreaCluster: invalid area number\n");
 		return 0;
 	} //end if
 	return aasworld.areasettings[areanum].cluster;
 } //end of the function AAS_AreaCluster
 //===========================================================================
 // returns the presence types of the given area
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaPresenceType(int areanum)
 {
 	if (!aasworld.loaded) return 0;
 	if (areanum <= 0 || areanum >= aasworld.numareas)
 	{
 		botimport.Print(PRT_ERROR, "AAS_AreaPresenceType: invalid area number\n");
 		return 0;
 	} //end if
 	return aasworld.areasettings[areanum].presencetype;
 } //end of the function AAS_AreaPresenceType
 //===========================================================================
 // returns the presence type at the given point
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_PointPresenceType(vec3_t point)
 {
 	int areanum;
 
 	if (!aasworld.loaded) return 0;
 
 	areanum = AAS_PointAreaNum(point);
 	if (!areanum) return PRESENCE_NONE;
 	return aasworld.areasettings[areanum].presencetype;
 } //end of the function AAS_PointPresenceType
 //===========================================================================
 // calculates the minimum distance between the origin of the box and the
 // given plane when both will collide on the given side of the plane
 //
 // normal	=	normal vector of plane to calculate distance from
 // mins		=	minimums of box relative to origin
 // maxs		=	maximums of box relative to origin
 // side		=	side of the plane we want to calculate the distance from
 //					0 normal vector side
 //					1 not normal vector side
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 vec_t AAS_BoxOriginDistanceFromPlane(vec3_t normal, vec3_t mins, vec3_t maxs, int side)
 {
 	vec3_t v1, v2;
 	int i;
 
 	//swap maxs and mins when on the other side of the plane
 	if (side)
 	{
 		//get a point of the box that would be one of the first
 		//to collide with the plane
 		for (i = 0; i < 3; i++)
 		{
 			if (normal[i] > BBOX_NORMAL_EPSILON) v1[i] = maxs[i];
 			else if (normal[i] < -BBOX_NORMAL_EPSILON) v1[i] = mins[i];
 			else v1[i] = 0;
 		} //end for
 	} //end if
 	else
 	{
 		//get a point of the box that would be one of the first
 		//to collide with the plane
 		for (i = 0; i < 3; i++)
 		{
 			if (normal[i] > BBOX_NORMAL_EPSILON) v1[i] = mins[i];
 			else if (normal[i] < -BBOX_NORMAL_EPSILON) v1[i] = maxs[i];
 			else v1[i] = 0;
 		} //end for
 	} //end else
 	//
 	VectorCopy(normal, v2);
 	VectorInverse(v2);
 //	VectorNegate(normal, v2);
 	return DotProduct(v1, v2);
 } //end of the function AAS_BoxOriginDistanceFromPlane
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 qboolean AAS_AreaEntityCollision(int areanum, vec3_t start, vec3_t end,
 										int presencetype, int passent, aas_trace_t *trace)
 {
 	int collision;
 	vec3_t boxmins, boxmaxs;
 	aas_link_t *link;
 	bsp_trace_t bsptrace;
 
 	AAS_PresenceTypeBoundingBox(presencetype, boxmins, boxmaxs);
 
 	Com_Memset(&bsptrace, 0, sizeof(bsp_trace_t)); //make compiler happy
 	//assume no collision
 	bsptrace.fraction = 1;
 	collision = qfalse;
 	for (link = aasworld.arealinkedentities[areanum]; link; link = link->next_ent)
 	{
 		//ignore the pass entity
 		if (link->entnum == passent) continue;
 		//
 		if (AAS_EntityCollision(link->entnum, start, boxmins, boxmaxs, end,
 												CONTENTS_SOLID|CONTENTS_PLAYERCLIP, &bsptrace))
 		{
 			collision = qtrue;
 		} //end if
 	} //end for
 	if (collision)
 	{
 		trace->startsolid = bsptrace.startsolid;
 		trace->ent = bsptrace.ent;
 		VectorCopy(bsptrace.endpos, trace->endpos);
 		trace->area = 0;
 		trace->planenum = 0;
 		return qtrue;
 	} //end if
 	return qfalse;
 } //end of the function AAS_AreaEntityCollision
 //===========================================================================
 // recursive subdivision of the line by the BSP tree.
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 aas_trace_t AAS_TraceClientBBox(vec3_t start, vec3_t end, int presencetype,
 																				int passent)
 {
 	int side, nodenum, tmpplanenum;
 	float front, back, frac;
 	vec3_t cur_start, cur_end, cur_mid, v1, v2;
 	aas_tracestack_t tracestack[127];
 	aas_tracestack_t *tstack_p;
 	aas_node_t *aasnode;
 	aas_plane_t *plane;
 	aas_trace_t trace;
 
 	//clear the trace structure
 	Com_Memset(&trace, 0, sizeof(aas_trace_t));
 
 	if (!aasworld.loaded) return trace;
 	
 	tstack_p = tracestack;
 	//we start with the whole line on the stack
 	VectorCopy(start, tstack_p->start);
 	VectorCopy(end, tstack_p->end);
 	tstack_p->planenum = 0;
 	//start with node 1 because node zero is a dummy for a solid leaf
 	tstack_p->nodenum = 1;		//starting at the root of the tree
 	tstack_p++;
 	
 	while (1)
 	{
 		//pop up the stack
 		tstack_p--;
 		//if the trace stack is empty (ended up with a piece of the
 		//line to be traced in an area)
 		if (tstack_p < tracestack)
 		{
 			tstack_p++;
 			//nothing was hit
 			trace.startsolid = qfalse;
 			trace.fraction = 1.0;
 			//endpos is the end of the line
 			VectorCopy(end, trace.endpos);
 			//nothing hit
 			trace.ent = 0;
 			trace.area = 0;
 			trace.planenum = 0;
 			return trace;
 		} //end if
 		//number of the current node to test the line against
 		nodenum = tstack_p->nodenum;
 		//if it is an area
 		if (nodenum < 0)
 		{
 #ifdef AAS_SAMPLE_DEBUG
 			if (-nodenum > aasworld.numareasettings)
 			{
 				botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: -nodenum out of range\n");
 				return trace;
 			} //end if
 #endif //AAS_SAMPLE_DEBUG
 			//botimport.Print(PRT_MESSAGE, "areanum = %d, must be %d\n", -nodenum, AAS_PointAreaNum(start));
 			//if can't enter the area because it hasn't got the right presence type
 			if (!(aasworld.areasettings[-nodenum].presencetype & presencetype))
 			{
 				//if the start point is still the initial start point
 				//NOTE: no need for epsilons because the points will be
 				//exactly the same when they're both the start point
 				if (tstack_p->start[0] == start[0] &&
 						tstack_p->start[1] == start[1] &&
 						tstack_p->start[2] == start[2])
 				{
 					trace.startsolid = qtrue;
 					trace.fraction = 0.0;
 					VectorClear(v1);
 				} //end if
 				else
 				{
 					trace.startsolid = qfalse;
 					VectorSubtract(end, start, v1);
 					VectorSubtract(tstack_p->start, start, v2);
 					trace.fraction = VectorLength(v2) / VectorNormalize(v1);
 					VectorMA(tstack_p->start, -0.125, v1, tstack_p->start);
 				} //end else
 				VectorCopy(tstack_p->start, trace.endpos);
 				trace.ent = 0;
 				trace.area = -nodenum;
 //				VectorSubtract(end, start, v1);
 				trace.planenum = tstack_p->planenum;
 				//always take the plane with normal facing towards the trace start
 				plane = &aasworld.planes[trace.planenum];
 				if (DotProduct(v1, plane->normal) > 0) trace.planenum ^= 1;
 				return trace;
 			} //end if
 			else
 			{
 				if (passent >= 0)
 				{
 					if (AAS_AreaEntityCollision(-nodenum, tstack_p->start,
 													tstack_p->end, presencetype, passent,
 													&trace))
 					{
 						if (!trace.startsolid)
 						{
 							VectorSubtract(end, start, v1);
 							VectorSubtract(trace.endpos, start, v2);
 							trace.fraction = VectorLength(v2) / VectorLength(v1);
 						} //end if
 						return trace;
 					} //end if
 				} //end if
 			} //end else
 			trace.lastarea = -nodenum;
 			continue;
 		} //end if
 		//if it is a solid leaf
 		if (!nodenum)
 		{
 			//if the start point is still the initial start point
 			//NOTE: no need for epsilons because the points will be
 			//exactly the same when they're both the start point
 			if (tstack_p->start[0] == start[0] &&
 					tstack_p->start[1] == start[1] &&
 					tstack_p->start[2] == start[2])
 			{
 				trace.startsolid = qtrue;
 				trace.fraction = 0.0;
 				VectorClear(v1);
 			} //end if
 			else
 			{
 				trace.startsolid = qfalse;
 				VectorSubtract(end, start, v1);
 				VectorSubtract(tstack_p->start, start, v2);
 				trace.fraction = VectorLength(v2) / VectorNormalize(v1);
 				VectorMA(tstack_p->start, -0.125, v1, tstack_p->start);
 			} //end else
 			VectorCopy(tstack_p->start, trace.endpos);
 			trace.ent = 0;
 			trace.area = 0;	//hit solid leaf
 //			VectorSubtract(end, start, v1);
 			trace.planenum = tstack_p->planenum;
 			//always take the plane with normal facing towards the trace start
 			plane = &aasworld.planes[trace.planenum];
 			if (DotProduct(v1, plane->normal) > 0) trace.planenum ^= 1;
 			return trace;
 		} //end if
 #ifdef AAS_SAMPLE_DEBUG
 		if (nodenum > aasworld.numnodes)
 		{
 			botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: nodenum out of range\n");
 			return trace;
 		} //end if
 #endif //AAS_SAMPLE_DEBUG
 		//the node to test against
 		aasnode = &aasworld.nodes[nodenum];
 		//start point of current line to test against node
 		VectorCopy(tstack_p->start, cur_start);
 		//end point of the current line to test against node
 		VectorCopy(tstack_p->end, cur_end);
 		//the current node plane
 		plane = &aasworld.planes[aasnode->planenum];
 
 		switch(plane->type)
 		{/*FIXME: wtf doesn't this work? obviously the axial node planes aren't always facing positive!!!
 			//check for axial planes
 			case PLANE_X:
 			{
 				front = cur_start[0] - plane->dist;
 				back = cur_end[0] - plane->dist;
 				break;
 			} //end case
 			case PLANE_Y:
 			{
 				front = cur_start[1] - plane->dist;
 				back = cur_end[1] - plane->dist;
 				break;
 			} //end case
 			case PLANE_Z:
 			{
 				front = cur_start[2] - plane->dist;
 				back = cur_end[2] - plane->dist;
 				break;
 			} //end case*/
 			default: //gee it's not an axial plane
 			{
 				front = DotProduct(cur_start, plane->normal) - plane->dist;
 				back = DotProduct(cur_end, plane->normal) - plane->dist;
 				break;
 			} //end default
 		} //end switch
 		// bk010221 - old location of FPE hack and divide by zero expression
 		//if the whole to be traced line is totally at the front of this node
 		//only go down the tree with the front child
 		if ((front >= -ON_EPSILON && back >= -ON_EPSILON))
 		{
 			//keep the current start and end point on the stack
 			//and go down the tree with the front child
 			tstack_p->nodenum = aasnode->children[0];
 			tstack_p++;
 			if (tstack_p >= &tracestack[127])
 			{
 				botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
 				return trace;
 			} //end if
 		} //end if
 		//if the whole to be traced line is totally at the back of this node
 		//only go down the tree with the back child
 		else if ((front < ON_EPSILON && back < ON_EPSILON))
 		{
 			//keep the current start and end point on the stack
 			//and go down the tree with the back child
 			tstack_p->nodenum = aasnode->children[1];
 			tstack_p++;
 			if (tstack_p >= &tracestack[127])
 			{
 				botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
 				return trace;
 			} //end if
 		} //end if
 		//go down the tree both at the front and back of the node
 		else
 		{
 			tmpplanenum = tstack_p->planenum;
 			// bk010221 - new location of divide by zero (see above)
 			if ( front == back ) front -= 0.001f; // bk0101022 - hack/FPE 
                 	//calculate the hitpoint with the node (split point of the line)
 			//put the crosspoint TRACEPLANE_EPSILON pixels on the near side
 			if (front < 0) frac = (front + TRACEPLANE_EPSILON)/(front-back);
 			else frac = (front - TRACEPLANE_EPSILON)/(front-back); // bk010221
 			//
 			if (frac < 0)
 				frac = 0.001f; //0
 			else if (frac > 1)
 				frac = 0.999f; //1
 			//frac = front / (front-back);
 			//
 			cur_mid[0] = cur_start[0] + (cur_end[0] - cur_start[0]) * frac;
 			cur_mid[1] = cur_start[1] + (cur_end[1] - cur_start[1]) * frac;
 			cur_mid[2] = cur_start[2] + (cur_end[2] - cur_start[2]) * frac;
 
 //			AAS_DrawPlaneCross(cur_mid, plane->normal, plane->dist, plane->type, LINECOLOR_RED);
 			//side the front part of the line is on
 			side = front < 0;
 			//first put the end part of the line on the stack (back side)
 			VectorCopy(cur_mid, tstack_p->start);
 			//not necesary to store because still on stack
 			//VectorCopy(cur_end, tstack_p->end);
 			tstack_p->planenum = aasnode->planenum;
 			tstack_p->nodenum = aasnode->children[!side];
 			tstack_p++;
 			if (tstack_p >= &tracestack[127])
 			{
 				botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
 				return trace;
 			} //end if
 			//now put the part near the start of the line on the stack so we will
 			//continue with thats part first. This way we'll find the first
 			//hit of the bbox
 			VectorCopy(cur_start, tstack_p->start);
 			VectorCopy(cur_mid, tstack_p->end);
 			tstack_p->planenum = tmpplanenum;
 			tstack_p->nodenum = aasnode->children[side];
 			tstack_p++;
 			if (tstack_p >= &tracestack[127])
 			{
 				botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
 				return trace;
 			} //end if
 		} //end else
 	} //end while
 //	return trace;
 } //end of the function AAS_TraceClientBBox
 //===========================================================================
 // recursive subdivision of the line by the BSP tree.
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas)
 {
 	int side, nodenum, tmpplanenum;
 	int numareas;
 	float front, back, frac;
 	vec3_t cur_start, cur_end, cur_mid;
 	aas_tracestack_t tracestack[127];
 	aas_tracestack_t *tstack_p;
 	aas_node_t *aasnode;
 	aas_plane_t *plane;
 
 	numareas = 0;
 	areas[0] = 0;
 	if (!aasworld.loaded) return numareas;
 
 	tstack_p = tracestack;
 	//we start with the whole line on the stack
 	VectorCopy(start, tstack_p->start);
 	VectorCopy(end, tstack_p->end);
 	tstack_p->planenum = 0;
 	//start with node 1 because node zero is a dummy for a solid leaf
 	tstack_p->nodenum = 1;		//starting at the root of the tree
 	tstack_p++;
 
 	while (1)
 	{
 		//pop up the stack
 		tstack_p--;
 		//if the trace stack is empty (ended up with a piece of the
 		//line to be traced in an area)
 		if (tstack_p < tracestack)
 		{
 			return numareas;
 		} //end if
 		//number of the current node to test the line against
 		nodenum = tstack_p->nodenum;
 		//if it is an area
 		if (nodenum < 0)
 		{
 #ifdef AAS_SAMPLE_DEBUG
 			if (-nodenum > aasworld.numareasettings)
 			{
 				botimport.Print(PRT_ERROR, "AAS_TraceAreas: -nodenum = %d out of range\n", -nodenum);
 				return numareas;
 			} //end if
 #endif //AAS_SAMPLE_DEBUG
 			//botimport.Print(PRT_MESSAGE, "areanum = %d, must be %d\n", -nodenum, AAS_PointAreaNum(start));
 			areas[numareas] = -nodenum;
 			if (points) VectorCopy(tstack_p->start, points[numareas]);
 			numareas++;
 			if (numareas >= maxareas) return numareas;
 			continue;
 		} //end if
 		//if it is a solid leaf
 		if (!nodenum)
 		{
 			continue;
 		} //end if
 #ifdef AAS_SAMPLE_DEBUG
 		if (nodenum > aasworld.numnodes)
 		{
 			botimport.Print(PRT_ERROR, "AAS_TraceAreas: nodenum out of range\n");
 			return numareas;
 		} //end if
 #endif //AAS_SAMPLE_DEBUG
 		//the node to test against
 		aasnode = &aasworld.nodes[nodenum];
 		//start point of current line to test against node
 		VectorCopy(tstack_p->start, cur_start);
 		//end point of the current line to test against node
 		VectorCopy(tstack_p->end, cur_end);
 		//the current node plane
 		plane = &aasworld.planes[aasnode->planenum];
 
 		switch(plane->type)
 		{/*FIXME: wtf doesn't this work? obviously the node planes aren't always facing positive!!!
 			//check for axial planes
 			case PLANE_X:
 			{
 				front = cur_start[0] - plane->dist;
 				back = cur_end[0] - plane->dist;
 				break;
 			} //end case
 			case PLANE_Y:
 			{
 				front = cur_start[1] - plane->dist;
 				back = cur_end[1] - plane->dist;
 				break;
 			} //end case
 			case PLANE_Z:
 			{
 				front = cur_start[2] - plane->dist;
 				back = cur_end[2] - plane->dist;
 				break;
 			} //end case*/
 			default: //gee it's not an axial plane
 			{
 				front = DotProduct(cur_start, plane->normal) - plane->dist;
 				back = DotProduct(cur_end, plane->normal) - plane->dist;
 				break;
 			} //end default
 		} //end switch
 
 		//if the whole to be traced line is totally at the front of this node
 		//only go down the tree with the front child
 		if (front > 0 && back > 0)
 		{
 			//keep the current start and end point on the stack
 			//and go down the tree with the front child
 			tstack_p->nodenum = aasnode->children[0];
 			tstack_p++;
 			if (tstack_p >= &tracestack[127])
 			{
 				botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
 				return numareas;
 			} //end if
 		} //end if
 		//if the whole to be traced line is totally at the back of this node
 		//only go down the tree with the back child
 		else if (front <= 0 && back <= 0)
 		{
 			//keep the current start and end point on the stack
 			//and go down the tree with the back child
 			tstack_p->nodenum = aasnode->children[1];
 			tstack_p++;
 			if (tstack_p >= &tracestack[127])
 			{
 				botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
 				return numareas;
 			} //end if
 		} //end if
 		//go down the tree both at the front and back of the node
 		else
 		{
 			tmpplanenum = tstack_p->planenum;
 			//calculate the hitpoint with the node (split point of the line)
 			//put the crosspoint TRACEPLANE_EPSILON pixels on the near side
 			if (front < 0) frac = (front)/(front-back);
 			else frac = (front)/(front-back);
 			if (frac < 0) frac = 0;
 			else if (frac > 1) frac = 1;
 			//frac = front / (front-back);
 			//
 			cur_mid[0] = cur_start[0] + (cur_end[0] - cur_start[0]) * frac;
 			cur_mid[1] = cur_start[1] + (cur_end[1] - cur_start[1]) * frac;
 			cur_mid[2] = cur_start[2] + (cur_end[2] - cur_start[2]) * frac;
 
 //			AAS_DrawPlaneCross(cur_mid, plane->normal, plane->dist, plane->type, LINECOLOR_RED);
 			//side the front part of the line is on
 			side = front < 0;
 			//first put the end part of the line on the stack (back side)
 			VectorCopy(cur_mid, tstack_p->start);
 			//not necesary to store because still on stack
 			//VectorCopy(cur_end, tstack_p->end);
 			tstack_p->planenum = aasnode->planenum;
 			tstack_p->nodenum = aasnode->children[!side];
 			tstack_p++;
 			if (tstack_p >= &tracestack[127])
 			{
 				botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
 				return numareas;
 			} //end if
 			//now put the part near the start of the line on the stack so we will
 			//continue with thats part first. This way we'll find the first
 			//hit of the bbox
 			VectorCopy(cur_start, tstack_p->start);
 			VectorCopy(cur_mid, tstack_p->end);
 			tstack_p->planenum = tmpplanenum;
 			tstack_p->nodenum = aasnode->children[side];
 			tstack_p++;
 			if (tstack_p >= &tracestack[127])
 			{
 				botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
 				return numareas;
 			} //end if
 		} //end else
 	} //end while
 //	return numareas;
 } //end of the function AAS_TraceAreas
 //===========================================================================
 // a simple cross product
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 // void AAS_OrthogonalToVectors(vec3_t v1, vec3_t v2, vec3_t res)
 #define AAS_OrthogonalToVectors(v1, v2, res) \
 	(res)[0] = ((v1)[1] * (v2)[2]) - ((v1)[2] * (v2)[1]);\
 	(res)[1] = ((v1)[2] * (v2)[0]) - ((v1)[0] * (v2)[2]);\
 	(res)[2] = ((v1)[0] * (v2)[1]) - ((v1)[1] * (v2)[0]);
 //===========================================================================
 // tests if the given point is within the face boundaries
 //
 // Parameter:				face		: face to test if the point is in it
 //								pnormal	: normal of the plane to use for the face
 //								point		: point to test if inside face boundaries
 // Returns:					qtrue if the point is within the face boundaries
 // Changes Globals:		-
 //===========================================================================
 qboolean AAS_InsideFace(aas_face_t *face, vec3_t pnormal, vec3_t point, float epsilon)
 {
 	int i, firstvertex, edgenum;
 	vec3_t v0;
 	vec3_t edgevec, pointvec, sepnormal;
 	aas_edge_t *edge;
 #ifdef AAS_SAMPLE_DEBUG
 	int lastvertex = 0;
 #endif //AAS_SAMPLE_DEBUG
 
 	if (!aasworld.loaded) return qfalse;
 
 	for (i = 0; i < face->numedges; i++)
 	{
 		edgenum = aasworld.edgeindex[face->firstedge + i];
 		edge = &aasworld.edges[abs(edgenum)];
 		//get the first vertex of the edge
 		firstvertex = edgenum < 0;
 		VectorCopy(aasworld.vertexes[edge->v[firstvertex]], v0);
 		//edge vector
 		VectorSubtract(aasworld.vertexes[edge->v[!firstvertex]], v0, edgevec);
 		//
 #ifdef AAS_SAMPLE_DEBUG
 		if (lastvertex && lastvertex != edge->v[firstvertex])
 		{
 			botimport.Print(PRT_MESSAGE, "winding not counter clockwise\n");
 		} //end if
 		lastvertex = edge->v[!firstvertex];
 #endif //AAS_SAMPLE_DEBUG
 		//vector from first edge point to point possible in face
 		VectorSubtract(point, v0, pointvec);
 		//get a vector pointing inside the face orthogonal to both the
 		//edge vector and the normal vector of the plane the face is in
 		//this vector defines a plane through the origin (first vertex of
 		//edge) and through both the edge vector and the normal vector
 		//of the plane
 		AAS_OrthogonalToVectors(edgevec, pnormal, sepnormal);
 		//check on wich side of the above plane the point is
 		//this is done by checking the sign of the dot product of the
 		//vector orthogonal vector from above and the vector from the
 		//origin (first vertex of edge) to the point 
 		//if the dotproduct is smaller than zero the point is outside the face
 		if (DotProduct(pointvec, sepnormal) < -epsilon) return qfalse;
 	} //end for
 	return qtrue;
 } //end of the function AAS_InsideFace
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 qboolean AAS_PointInsideFace(int facenum, vec3_t point, float epsilon)
 {
 	int i, firstvertex, edgenum;
 	vec_t *v1, *v2;
 	vec3_t edgevec, pointvec, sepnormal;
 	aas_edge_t *edge;
 	aas_plane_t *plane;
 	aas_face_t *face;
 
 	if (!aasworld.loaded) return qfalse;
 
 	face = &aasworld.faces[facenum];
 	plane = &aasworld.planes[face->planenum];
 	//
 	for (i = 0; i < face->numedges; i++)
 	{
 		edgenum = aasworld.edgeindex[face->firstedge + i];
 		edge = &aasworld.edges[abs(edgenum)];
 		//get the first vertex of the edge
 		firstvertex = edgenum < 0;
 		v1 = aasworld.vertexes[edge->v[firstvertex]];
 		v2 = aasworld.vertexes[edge->v[!firstvertex]];
 		//edge vector
 		VectorSubtract(v2, v1, edgevec);
 		//vector from first edge point to point possible in face
 		VectorSubtract(point, v1, pointvec);
 		//
 		CrossProduct(edgevec, plane->normal, sepnormal);
 		//
 		if (DotProduct(pointvec, sepnormal) < -epsilon) return qfalse;
 	} //end for
 	return qtrue;
 } //end of the function AAS_PointInsideFace
 //===========================================================================
 // returns the ground face the given point is above in the given area
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 aas_face_t *AAS_AreaGroundFace(int areanum, vec3_t point)
 {
 	int i, facenum;
 	vec3_t up = {0, 0, 1};
 	vec3_t normal;
 	aas_area_t *area;
 	aas_face_t *face;
 
 	if (!aasworld.loaded) return NULL;
 
 	area = &aasworld.areas[areanum];
 	for (i = 0; i < area->numfaces; i++)
 	{
 		facenum = aasworld.faceindex[area->firstface + i];
 		face = &aasworld.faces[abs(facenum)];
 		//if this is a ground face
 		if (face->faceflags & FACE_GROUND)
 		{
 			//get the up or down normal
 			if (aasworld.planes[face->planenum].normal[2] < 0) VectorNegate(up, normal);
 			else VectorCopy(up, normal);
 			//check if the point is in the face
 			if (AAS_InsideFace(face, normal, point, 0.01f)) return face;
 		} //end if
 	} //end for
 	return NULL;
 } //end of the function AAS_AreaGroundFace
 //===========================================================================
 // returns the face the trace end position is situated in
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_FacePlane(int facenum, vec3_t normal, float *dist)
 {
 	aas_plane_t *plane;
 
 	plane = &aasworld.planes[aasworld.faces[facenum].planenum];
 	VectorCopy(plane->normal, normal);
 	*dist = plane->dist;
 } //end of the function AAS_FacePlane
 //===========================================================================
 // returns the face the trace end position is situated in
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 aas_face_t *AAS_TraceEndFace(aas_trace_t *trace)
 {
 	int i, facenum;
 	aas_area_t *area;
 	aas_face_t *face, *firstface = NULL;
 
 	if (!aasworld.loaded) return NULL;
 
 	//if started in solid no face was hit
 	if (trace->startsolid) return NULL;
 	//trace->lastarea is the last area the trace was in
 	area = &aasworld.areas[trace->lastarea];
 	//check which face the trace.endpos was in
 	for (i = 0; i < area->numfaces; i++)
 	{
 		facenum = aasworld.faceindex[area->firstface + i];
 		face = &aasworld.faces[abs(facenum)];
 		//if the face is in the same plane as the trace end point
 		if ((face->planenum & ~1) == (trace->planenum & ~1))
 		{
 			//firstface is used for optimization, if theres only one
 			//face in the plane then it has to be the good one
 			//if there are more faces in the same plane then always
 			//check the one with the fewest edges first
 /*			if (firstface)
 			{
 				if (firstface->numedges < face->numedges)
 				{
 					if (AAS_InsideFace(firstface,
 						aasworld.planes[face->planenum].normal, trace->endpos))
 					{
 						return firstface;
 					} //end if
 					firstface = face;
 				} //end if
 				else
 				{
 					if (AAS_InsideFace(face,
 						aasworld.planes[face->planenum].normal, trace->endpos))
 					{
 						return face;
 					} //end if
 				} //end else
 			} //end if
 			else
 			{
 				firstface = face;
 			} //end else*/
 			if (AAS_InsideFace(face,
 						aasworld.planes[face->planenum].normal, trace->endpos, 0.01f)) return face;
 		} //end if
 	} //end for
 	return firstface;
 } //end of the function AAS_TraceEndFace
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_BoxOnPlaneSide2(vec3_t absmins, vec3_t absmaxs, aas_plane_t *p)
 {
 	int i, sides;
 	float dist1, dist2;
 	vec3_t corners[2];
 
 	for (i = 0; i < 3; i++)
 	{
 		if (p->normal[i] < 0)
 		{
 			corners[0][i] = absmins[i];
 			corners[1][i] = absmaxs[i];
 		} //end if
 		else
 		{
 			corners[1][i] = absmins[i];
 			corners[0][i] = absmaxs[i];
 		} //end else
 	} //end for
 	dist1 = DotProduct(p->normal, corners[0]) - p->dist;
 	dist2 = DotProduct(p->normal, corners[1]) - p->dist;
 	sides = 0;
 	if (dist1 >= 0) sides = 1;
 	if (dist2 < 0) sides |= 2;
 
 	return sides;
 } //end of the function AAS_BoxOnPlaneSide2
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 //int AAS_BoxOnPlaneSide(vec3_t absmins, vec3_t absmaxs, aas_plane_t *p)
 #define AAS_BoxOnPlaneSide(absmins, absmaxs, p) (\
 	( (p)->type < 3) ?\
 	(\
 		( (p)->dist <= (absmins)[(p)->type]) ?\
 		(\
 			1\
 		)\
 		:\
 		(\
 			( (p)->dist >= (absmaxs)[(p)->type]) ?\
 			(\
 				2\
 			)\
 			:\
 			(\
 				3\
 			)\
 		)\
 	)\
 	:\
 	(\
 		AAS_BoxOnPlaneSide2((absmins), (absmaxs), (p))\
 	)\
 ) //end of the function AAS_BoxOnPlaneSide
 //===========================================================================
 // remove the links to this entity from all areas
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_UnlinkFromAreas(aas_link_t *areas)
 {
 	aas_link_t *link, *nextlink;
 
 	for (link = areas; link; link = nextlink)
 	{
 		//next area the entity is linked in
 		nextlink = link->next_area;
 		//remove the entity from the linked list of this area
 		if (link->prev_ent) link->prev_ent->next_ent = link->next_ent;
 		else aasworld.arealinkedentities[link->areanum] = link->next_ent;
 		if (link->next_ent) link->next_ent->prev_ent = link->prev_ent;
 		//deallocate the link structure
 		AAS_DeAllocAASLink(link);
 	} //end for
 } //end of the function AAS_UnlinkFromAreas
 //===========================================================================
 // link the entity to the areas the bounding box is totally or partly
 // situated in. This is done with recursion down the tree using the
 // bounding box to test for plane sides
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 
 typedef struct
 {
 	int nodenum;		//node found after splitting
 } aas_linkstack_t;
 
 aas_link_t *AAS_AASLinkEntity(vec3_t absmins, vec3_t absmaxs, int entnum)
 {
 	int side, nodenum;
 	aas_linkstack_t linkstack[128];
 	aas_linkstack_t *lstack_p;
 	aas_node_t *aasnode;
 	aas_plane_t *plane;
 	aas_link_t *link, *areas;
 
 	if (!aasworld.loaded)
 	{
 		botimport.Print(PRT_ERROR, "AAS_LinkEntity: aas not loaded\n");
 		return NULL;
 	} //end if
 
 	areas = NULL;
 	//
 	lstack_p = linkstack;
 	//we start with the whole line on the stack
 	//start with node 1 because node zero is a dummy used for solid leafs
 	lstack_p->nodenum = 1;		//starting at the root of the tree
 	lstack_p++;
 	
 	while (1)
 	{
 		//pop up the stack
 		lstack_p--;
 		//if the trace stack is empty (ended up with a piece of the
 		//line to be traced in an area)
 		if (lstack_p < linkstack) break;
 		//number of the current node to test the line against
 		nodenum = lstack_p->nodenum;
 		//if it is an area
 		if (nodenum < 0)
 		{
 			//NOTE: the entity might have already been linked into this area
 			// because several node children can point to the same area
 			for (link = aasworld.arealinkedentities[-nodenum]; link; link = link->next_ent)
 			{
 				if (link->entnum == entnum) break;
 			} //end for
 			if (link) continue;
 			//
 			link = AAS_AllocAASLink();
 			if (!link) return areas;
 			link->entnum = entnum;
 			link->areanum = -nodenum;
 			//put the link into the double linked area list of the entity
 			link->prev_area = NULL;
 			link->next_area = areas;
 			if (areas) areas->prev_area = link;
 			areas = link;
 			//put the link into the double linked entity list of the area
 			link->prev_ent = NULL;
 			link->next_ent = aasworld.arealinkedentities[-nodenum];
 			if (aasworld.arealinkedentities[-nodenum])
 					aasworld.arealinkedentities[-nodenum]->prev_ent = link;
 			aasworld.arealinkedentities[-nodenum] = link;
 			//
 			continue;
 		} //end if
 		//if solid leaf
 		if (!nodenum) continue;
 		//the node to test against
 		aasnode = &aasworld.nodes[nodenum];
 		//the current node plane
 		plane = &aasworld.planes[aasnode->planenum];
 		//get the side(s) the box is situated relative to the plane
 		side = AAS_BoxOnPlaneSide2(absmins, absmaxs, plane);
 		//if on the front side of the node
 		if (side & 1)
 		{
 			lstack_p->nodenum = aasnode->children[0];
 			lstack_p++;
 		} //end if
 		if (lstack_p >= &linkstack[127])
 		{
 			botimport.Print(PRT_ERROR, "AAS_LinkEntity: stack overflow\n");
 			break;
 		} //end if
 		//if on the back side of the node
 		if (side & 2)
 		{
 			lstack_p->nodenum = aasnode->children[1];
 			lstack_p++;
 		} //end if
 		if (lstack_p >= &linkstack[127])
 		{
 			botimport.Print(PRT_ERROR, "AAS_LinkEntity: stack overflow\n");
 			break;
 		} //end if
 	} //end while
 	return areas;
 } //end of the function AAS_AASLinkEntity
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 aas_link_t *AAS_LinkEntityClientBBox(vec3_t absmins, vec3_t absmaxs, int entnum, int presencetype)
 {
 	vec3_t mins, maxs;
 	vec3_t newabsmins, newabsmaxs;
 
 	AAS_PresenceTypeBoundingBox(presencetype, mins, maxs);
 	VectorSubtract(absmins, maxs, newabsmins);
 	VectorSubtract(absmaxs, mins, newabsmaxs);
 	//relink the entity
 	return AAS_AASLinkEntity(newabsmins, newabsmaxs, entnum);
 } //end of the function AAS_LinkEntityClientBBox
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_BBoxAreas(vec3_t absmins, vec3_t absmaxs, int *areas, int maxareas)
 {
 	aas_link_t *linkedareas, *link;
 	int num;
 
 	linkedareas = AAS_AASLinkEntity(absmins, absmaxs, -1);
 	num = 0;
 	for (link = linkedareas; link; link = link->next_area)
 	{
 		areas[num] = link->areanum;
 		num++;
 		if (num >= maxareas)
 			break;
 	} //end for
 	AAS_UnlinkFromAreas(linkedareas);
 	return num;
 } //end of the function AAS_BBoxAreas
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaInfo( int areanum, aas_areainfo_t *info )
 {
 	aas_areasettings_t *settings;
 	if (!info)
 		return 0;
 	if (areanum <= 0 || areanum >= aasworld.numareas)
 	{
 		botimport.Print(PRT_ERROR, "AAS_AreaInfo: areanum %d out of range\n", areanum);
 		return 0;
 	} //end if
 	settings = &aasworld.areasettings[areanum];
 	info->cluster = settings->cluster;
 	info->contents = settings->contents;
 	info->flags = settings->areaflags;
 	info->presencetype = settings->presencetype;
 	VectorCopy(aasworld.areas[areanum].mins, info->mins);
 	VectorCopy(aasworld.areas[areanum].maxs, info->maxs);
 	VectorCopy(aasworld.areas[areanum].center, info->center);
 	return sizeof(aas_areainfo_t);
 } //end of the function AAS_AreaInfo
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 aas_plane_t *AAS_PlaneFromNum(int planenum)
 {
 	if (!aasworld.loaded) return 0;
 
 	return &aasworld.planes[planenum];
 } //end of the function AAS_PlaneFromNum