Quake-III-Arena

be_aas_reach.c (152877B)

---

 /*
 ===========================================================================
 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_reach.c
  *
  * desc:		reachability calculations
  *
  * $Archive: /MissionPack/code/botlib/be_aas_reach.c $
  *
  *****************************************************************************/
 
 #include "../game/q_shared.h"
 #include "l_log.h"
 #include "l_memory.h"
 #include "l_script.h"
 #include "l_libvar.h"
 #include "l_precomp.h"
 #include "l_struct.h"
 #include "aasfile.h"
 #include "../game/botlib.h"
 #include "../game/be_aas.h"
 #include "be_aas_funcs.h"
 #include "be_aas_def.h"
 
 extern int Sys_MilliSeconds(void);
 
 
 extern botlib_import_t botimport;
 
 //#define REACH_DEBUG
 
 //NOTE: all travel times are in hundreth of a second
 //maximum number of reachability links
 #define AAS_MAX_REACHABILITYSIZE			65536
 //number of areas reachability is calculated for each frame
 #define REACHABILITYAREASPERCYCLE			15
 //number of units reachability points are placed inside the areas
 #define INSIDEUNITS							2
 #define INSIDEUNITS_WALKEND					5
 #define INSIDEUNITS_WALKSTART				0.1
 #define INSIDEUNITS_WATERJUMP				15
 //area flag used for weapon jumping
 #define AREA_WEAPONJUMP						8192	//valid area to weapon jump to
 //number of reachabilities of each type
 int reach_swim;			//swim
 int reach_equalfloor;	//walk on floors with equal height
 int reach_step;			//step up
 int reach_walk;			//walk of step
 int reach_barrier;		//jump up to a barrier
 int reach_waterjump;	//jump out of water
 int reach_walkoffledge;	//walk of a ledge
 int reach_jump;			//jump
 int reach_ladder;		//climb or descent a ladder
 int reach_teleport;		//teleport
 int reach_elevator;		//use an elevator
 int reach_funcbob;		//use a func bob
 int reach_grapple;		//grapple hook
 int reach_doublejump;	//double jump
 int reach_rampjump;		//ramp jump
 int reach_strafejump;	//strafe jump (just normal jump but further)
 int reach_rocketjump;	//rocket jump
 int reach_bfgjump;		//bfg jump
 int reach_jumppad;		//jump pads
 //if true grapple reachabilities are skipped
 int calcgrapplereach;
 //linked reachability
 typedef struct aas_lreachability_s
 {
 	int areanum;					//number of the reachable area
 	int facenum;					//number of the face towards the other area
 	int edgenum;					//number of the edge towards the other area
 	vec3_t start;					//start point of inter area movement
 	vec3_t end;						//end point of inter area movement
 	int traveltype;					//type of travel required to get to the area
 	unsigned short int traveltime;	//travel time of the inter area movement
 	//
 	struct aas_lreachability_s *next;
 } aas_lreachability_t;
 //temporary reachabilities
 aas_lreachability_t *reachabilityheap;	//heap with reachabilities
 aas_lreachability_t *nextreachability;	//next free reachability from the heap
 aas_lreachability_t **areareachability;	//reachability links for every area
 int numlreachabilities;
 
 //===========================================================================
 // returns the surface area of the given face
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 float AAS_FaceArea(aas_face_t *face)
 {
 	int i, edgenum, side;
 	float total;
 	vec_t *v;
 	vec3_t d1, d2, cross;
 	aas_edge_t *edge;
 
 	edgenum = aasworld.edgeindex[face->firstedge];
 	side = edgenum < 0;
 	edge = &aasworld.edges[abs(edgenum)];
 	v = aasworld.vertexes[edge->v[side]];
 
 	total = 0;
 	for (i = 1; i < face->numedges - 1; i++)
 	{
 		edgenum = aasworld.edgeindex[face->firstedge + i];
 		side = edgenum < 0;
 		edge = &aasworld.edges[abs(edgenum)];
 		VectorSubtract(aasworld.vertexes[edge->v[side]], v, d1);
 		VectorSubtract(aasworld.vertexes[edge->v[!side]], v, d2);
 		CrossProduct(d1, d2, cross);
 		total += 0.5 * VectorLength(cross);
 	} //end for
 	return total;
 } //end of the function AAS_FaceArea
 //===========================================================================
 // returns the volume of an area
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 float AAS_AreaVolume(int areanum)
 {
 	int i, edgenum, facenum, side;
 	vec_t d, a, volume;
 	vec3_t corner;
 	aas_plane_t *plane;
 	aas_edge_t *edge;
 	aas_face_t *face;
 	aas_area_t *area;
 
 	area = &aasworld.areas[areanum];
 	facenum = aasworld.faceindex[area->firstface];
 	face = &aasworld.faces[abs(facenum)];
 	edgenum = aasworld.edgeindex[face->firstedge];
 	edge = &aasworld.edges[abs(edgenum)];
 	//
 	VectorCopy(aasworld.vertexes[edge->v[0]], corner);
 
 	//make tetrahedrons to all other faces
 	volume = 0;
 	for (i = 0; i < area->numfaces; i++)
 	{
 		facenum = abs(aasworld.faceindex[area->firstface + i]);
 		face = &aasworld.faces[facenum];
 		side = face->backarea != areanum;
 		plane = &aasworld.planes[face->planenum ^ side];
 		d = -(DotProduct (corner, plane->normal) - plane->dist);
 		a = AAS_FaceArea(face);
 		volume += d * a;
 	} //end for
 
 	volume /= 3;
 	return volume;
 } //end of the function AAS_AreaVolume
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_BestReachableLinkArea(aas_link_t *areas)
 {
 	aas_link_t *link;
 
 	for (link = areas; link; link = link->next_area)
 	{
 		if (AAS_AreaGrounded(link->areanum) || AAS_AreaSwim(link->areanum))
 		{
 			return link->areanum;
 		} //end if
 	} //end for
 	//
 	for (link = areas; link; link = link->next_area)
 	{
 		if (link->areanum) return link->areanum;
 		//FIXME: this is a bad idea when the reachability is not yet
 		// calculated when the level items are loaded
 		if (AAS_AreaReachability(link->areanum))
 			return link->areanum;
 	} //end for
 	return 0;
 } //end of the function AAS_BestReachableLinkArea
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 int AAS_GetJumpPadInfo(int ent, vec3_t areastart, vec3_t absmins, vec3_t absmaxs, vec3_t velocity)
 {
 	int modelnum, ent2;
 	float speed, height, gravity, time, dist, forward;
 	vec3_t origin, angles, teststart, ent2origin;
 	aas_trace_t trace;
 	char model[MAX_EPAIRKEY];
 	char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY];
 
 	//
 	AAS_FloatForBSPEpairKey(ent, "speed", &speed);
 	if (!speed) speed = 1000;
 	VectorClear(angles);
 	//get the mins, maxs and origin of the model
 	AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
 	if (model[0]) modelnum = atoi(model+1);
 	else modelnum = 0;
 	AAS_BSPModelMinsMaxsOrigin(modelnum, angles, absmins, absmaxs, origin);
 	VectorAdd(origin, absmins, absmins);
 	VectorAdd(origin, absmaxs, absmaxs);
 	VectorAdd(absmins, absmaxs, origin);
 	VectorScale (origin, 0.5, origin);
 
 	//get the start areas
 	VectorCopy(origin, teststart);
 	teststart[2] += 64;
 	trace = AAS_TraceClientBBox(teststart, origin, PRESENCE_CROUCH, -1);
 	if (trace.startsolid)
 	{
 		botimport.Print(PRT_MESSAGE, "trigger_push start solid\n");
 		VectorCopy(origin, areastart);
 	} //end if
 	else
 	{
 		VectorCopy(trace.endpos, areastart);
 	} //end else
 	areastart[2] += 0.125;
 	//
 	//AAS_DrawPermanentCross(origin, 4, 4);
 	//get the target entity
 	AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY);
 	for (ent2 = AAS_NextBSPEntity(0); ent2; ent2 = AAS_NextBSPEntity(ent2))
 	{
 		if (!AAS_ValueForBSPEpairKey(ent2, "targetname", targetname, MAX_EPAIRKEY)) continue;
 		if (!strcmp(targetname, target)) break;
 	} //end for
 	if (!ent2)
 	{
 		botimport.Print(PRT_MESSAGE, "trigger_push without target entity %s\n", target);
 		return qfalse;
 	} //end if
 	AAS_VectorForBSPEpairKey(ent2, "origin", ent2origin);
 	//
 	height = ent2origin[2] - origin[2];
 	gravity = aassettings.phys_gravity;
 	time = sqrt( height / ( 0.5 * gravity ) );
 	if (!time)
 	{
 		botimport.Print(PRT_MESSAGE, "trigger_push without time\n");
 		return qfalse;
 	} //end if
 	// set s.origin2 to the push velocity
 	VectorSubtract ( ent2origin, origin, velocity);
 	dist = VectorNormalize( velocity);
 	forward = dist / time;
 	//FIXME: why multiply by 1.1
 	forward *= 1.1f;
 	VectorScale(velocity, forward, velocity);
 	velocity[2] = time * gravity;
 	return qtrue;
 } //end of the function AAS_GetJumpPadInfo
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 int AAS_BestReachableFromJumpPadArea(vec3_t origin, vec3_t mins, vec3_t maxs)
 {
 	int area2num, ent, bot_visualizejumppads, bestareanum;
 	float volume, bestareavolume;
 	vec3_t areastart, cmdmove, bboxmins, bboxmaxs;
 	vec3_t absmins, absmaxs, velocity;
 	aas_clientmove_t move;
 	aas_link_t *areas, *link;
 	char classname[MAX_EPAIRKEY];
 
 #ifdef BSPC
 	bot_visualizejumppads = 0;
 #else
 	bot_visualizejumppads = LibVarValue("bot_visualizejumppads", "0");
 #endif
 	VectorAdd(origin, mins, bboxmins);
 	VectorAdd(origin, maxs, bboxmaxs);
 	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
 	{
 		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
 		if (strcmp(classname, "trigger_push")) continue;
 		//
 		if (!AAS_GetJumpPadInfo(ent, areastart, absmins, absmaxs, velocity)) continue;
 		//get the areas the jump pad brush is in
 		areas = AAS_LinkEntityClientBBox(absmins, absmaxs, -1, PRESENCE_CROUCH);
 		for (link = areas; link; link = link->next_area)
 		{
 			if (AAS_AreaJumpPad(link->areanum)) break;
 		} //end for
 		if (!link)
 		{
 			botimport.Print(PRT_MESSAGE, "trigger_push not in any jump pad area\n");
 			AAS_UnlinkFromAreas(areas);
 			continue;
 		} //end if
 		//
 		//botimport.Print(PRT_MESSAGE, "found a trigger_push with velocity %f %f %f\n", velocity[0], velocity[1], velocity[2]);
 		//
 		VectorSet(cmdmove, 0, 0, 0);
 		Com_Memset(&move, 0, sizeof(aas_clientmove_t));
 		area2num = 0;
 		AAS_ClientMovementHitBBox(&move, -1, areastart, PRESENCE_NORMAL, qfalse,
 								velocity, cmdmove, 0, 30, 0.1f, bboxmins, bboxmaxs, bot_visualizejumppads);
 		if (move.frames < 30)
 		{
 			bestareanum = 0;
 			bestareavolume = 0;
 			for (link = areas; link; link = link->next_area)
 			{
 				if (!AAS_AreaJumpPad(link->areanum)) continue;
 				volume = AAS_AreaVolume(link->areanum);
 				if (volume >= bestareavolume)
 				{
 					bestareanum = link->areanum;
 					bestareavolume = volume;
 				} //end if
 			} //end if
 			AAS_UnlinkFromAreas(areas);
 			return bestareanum;
 		} //end if
 		AAS_UnlinkFromAreas(areas);
 	} //end for
 	return 0;
 } //end of the function AAS_BestReachableFromJumpPadArea
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_BestReachableArea(vec3_t origin, vec3_t mins, vec3_t maxs, vec3_t goalorigin)
 {
 	int areanum, i, j, k, l;
 	aas_link_t *areas;
 	vec3_t absmins, absmaxs;
 	//vec3_t bbmins, bbmaxs;
 	vec3_t start, end;
 	aas_trace_t trace;
 
 	if (!aasworld.loaded)
 	{
 		botimport.Print(PRT_ERROR, "AAS_BestReachableArea: aas not loaded\n");
 		return 0;
 	} //end if
 	//find a point in an area
 	VectorCopy(origin, start);
 	areanum = AAS_PointAreaNum(start);
 	//while no area found fudge around a little
 	for (i = 0; i < 5 && !areanum; i++)
 	{
 		for (j = 0; j < 5 && !areanum; j++)
 		{
 			for (k = -1; k <= 1 && !areanum; k++)
 			{
 				for (l = -1; l <= 1 && !areanum; l++)
 				{
 					VectorCopy(origin, start);
 					start[0] += (float) j * 4 * k;
 					start[1] += (float) j * 4 * l;
 					start[2] += (float) i * 4;
 					areanum = AAS_PointAreaNum(start);
 				} //end for
 			} //end for
 		} //end for
 	} //end for
 	//if an area was found
 	if (areanum)
 	{
 		//drop client bbox down and try again
 		VectorCopy(start, end);
 		start[2] += 0.25;
 		end[2] -= 50;
 		trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
 		if (!trace.startsolid)
 		{
 			areanum = AAS_PointAreaNum(trace.endpos);
 			VectorCopy(trace.endpos, goalorigin);
 			//FIXME: cannot enable next line right now because the reachability
 			// does not have to be calculated when the level items are loaded
 			//if the origin is in an area with reachability
 			//if (AAS_AreaReachability(areanum)) return areanum;
 			if (areanum) return areanum;
 		} //end if
 		else
 		{
 			//it can very well happen that the AAS_PointAreaNum function tells that
 			//a point is in an area and that starting a AAS_TraceClientBBox from that
 			//point will return trace.startsolid qtrue
 #if 0
 			if (AAS_PointAreaNum(start))
 			{
 				Log_Write("point %f %f %f in area %d but trace startsolid", start[0], start[1], start[2], areanum);
 				AAS_DrawPermanentCross(start, 4, LINECOLOR_RED);
 			} //end if
 			botimport.Print(PRT_MESSAGE, "AAS_BestReachableArea: start solid\n");
 #endif
 			VectorCopy(start, goalorigin);
 			return areanum;
 		} //end else
 	} //end if
 	//
 	//AAS_PresenceTypeBoundingBox(PRESENCE_CROUCH, bbmins, bbmaxs);
 	//NOTE: the goal origin does not have to be in the goal area
 	// because the bot will have to move towards the item origin anyway
 	VectorCopy(origin, goalorigin);
 	//
 	VectorAdd(origin, mins, absmins);
 	VectorAdd(origin, maxs, absmaxs);
 	//add bounding box size
 	//VectorSubtract(absmins, bbmaxs, absmins);
 	//VectorSubtract(absmaxs, bbmins, absmaxs);
 	//link an invalid (-1) entity
 	areas = AAS_LinkEntityClientBBox(absmins, absmaxs, -1, PRESENCE_CROUCH);
 	//get the reachable link arae
 	areanum = AAS_BestReachableLinkArea(areas);
 	//unlink the invalid entity
 	AAS_UnlinkFromAreas(areas);
 	//
 	return areanum;
 } //end of the function AAS_BestReachableArea
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_SetupReachabilityHeap(void)
 {
 	int i;
 
 	reachabilityheap = (aas_lreachability_t *) GetClearedMemory(
 						AAS_MAX_REACHABILITYSIZE * sizeof(aas_lreachability_t));
 	for (i = 0; i < AAS_MAX_REACHABILITYSIZE-1; i++)
 	{
 		reachabilityheap[i].next = &reachabilityheap[i+1];
 	} //end for
 	reachabilityheap[AAS_MAX_REACHABILITYSIZE-1].next = NULL;
 	nextreachability = reachabilityheap;
 	numlreachabilities = 0;
 } //end of the function AAS_InitReachabilityHeap
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_ShutDownReachabilityHeap(void)
 {
 	FreeMemory(reachabilityheap);
 	numlreachabilities = 0;
 } //end of the function AAS_ShutDownReachabilityHeap
 //===========================================================================
 // returns a reachability link
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 aas_lreachability_t *AAS_AllocReachability(void)
 {
 	aas_lreachability_t *r;
 
 	if (!nextreachability) return NULL;
 	//make sure the error message only shows up once
 	if (!nextreachability->next) AAS_Error("AAS_MAX_REACHABILITYSIZE");
 	//
 	r = nextreachability;
 	nextreachability = nextreachability->next;
 	numlreachabilities++;
 	return r;
 } //end of the function AAS_AllocReachability
 //===========================================================================
 // frees a reachability link
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_FreeReachability(aas_lreachability_t *lreach)
 {
 	Com_Memset(lreach, 0, sizeof(aas_lreachability_t));
 
 	lreach->next = nextreachability;
 	nextreachability = lreach;
 	numlreachabilities--;
 } //end of the function AAS_FreeReachability
 //===========================================================================
 // returns qtrue if the area has reachability links
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaReachability(int areanum)
 {
 	if (areanum < 0 || areanum >= aasworld.numareas)
 	{
 		AAS_Error("AAS_AreaReachability: areanum %d out of range", areanum);
 		return 0;
 	} //end if
 	return aasworld.areasettings[areanum].numreachableareas;
 } //end of the function AAS_AreaReachability
 //===========================================================================
 // returns the surface area of all ground faces together of the area
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 float AAS_AreaGroundFaceArea(int areanum)
 {
 	int i;
 	float total;
 	aas_area_t *area;
 	aas_face_t *face;
 
 	total = 0;
 	area = &aasworld.areas[areanum];
 	for (i = 0; i < area->numfaces; i++)
 	{
 		face = &aasworld.faces[abs(aasworld.faceindex[area->firstface + i])];
 		if (!(face->faceflags & FACE_GROUND)) continue;
 		//
 		total += AAS_FaceArea(face);
 	} //end for
 	return total;
 } //end of the function AAS_AreaGroundFaceArea
 //===========================================================================
 // returns the center of a face
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_FaceCenter(int facenum, vec3_t center)
 {
 	int i;
 	float scale;
 	aas_face_t *face;
 	aas_edge_t *edge;
 
 	face = &aasworld.faces[facenum];
 
 	VectorClear(center);
 	for (i = 0; i < face->numedges; i++)
 	{
 		edge = &aasworld.edges[abs(aasworld.edgeindex[face->firstedge + i])];
 		VectorAdd(center, aasworld.vertexes[edge->v[0]], center);
 		VectorAdd(center, aasworld.vertexes[edge->v[1]], center);
 	} //end for
 	scale = 0.5 / face->numedges;
 	VectorScale(center, scale, center);
 } //end of the function AAS_FaceCenter
 //===========================================================================
 // returns the maximum distance a player can fall before being damaged
 // damage = deltavelocity*deltavelocity  * 0.0001
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_FallDamageDistance(void)
 {
 	float maxzvelocity, gravity, t;
 
 	maxzvelocity = sqrt(30 * 10000);
 	gravity = aassettings.phys_gravity;
 	t = maxzvelocity / gravity;
 	return 0.5 * gravity * t * t;
 } //end of the function AAS_FallDamageDistance
 //===========================================================================
 // distance = 0.5 * gravity * t * t
 // vel = t * gravity
 // damage = vel * vel * 0.0001
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 float AAS_FallDelta(float distance)
 {
 	float t, delta, gravity;
 
 	gravity = aassettings.phys_gravity;
 	t = sqrt(fabs(distance) * 2 / gravity);
 	delta = t * gravity;
 	return delta * delta * 0.0001;
 } //end of the function AAS_FallDelta
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 float AAS_MaxJumpHeight(float phys_jumpvel)
 {
 	float phys_gravity;
 
 	phys_gravity = aassettings.phys_gravity;
 	//maximum height a player can jump with the given initial z velocity
 	return 0.5 * phys_gravity * (phys_jumpvel / phys_gravity) * (phys_jumpvel / phys_gravity);
 } //end of the function MaxJumpHeight
 //===========================================================================
 // returns true if a player can only crouch in the area
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 float AAS_MaxJumpDistance(float phys_jumpvel)
 {
 	float phys_gravity, phys_maxvelocity, t;
 
 	phys_gravity = aassettings.phys_gravity;
 	phys_maxvelocity = aassettings.phys_maxvelocity;
 	//time a player takes to fall the height
 	t = sqrt(aassettings.rs_maxjumpfallheight / (0.5 * phys_gravity));
    //maximum distance
 	return phys_maxvelocity * (t + phys_jumpvel / phys_gravity);
 } //end of the function AAS_MaxJumpDistance
 //===========================================================================
 // returns true if a player can only crouch in the area
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaCrouch(int areanum)
 {
 	if (!(aasworld.areasettings[areanum].presencetype & PRESENCE_NORMAL)) return qtrue;
 	else return qfalse;
 } //end of the function AAS_AreaCrouch
 //===========================================================================
 // returns qtrue if it is possible to swim in the area
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaSwim(int areanum)
 {
 	if (aasworld.areasettings[areanum].areaflags & AREA_LIQUID) return qtrue;
 	else return qfalse;
 } //end of the function AAS_AreaSwim
 //===========================================================================
 // returns qtrue if the area contains a liquid
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaLiquid(int areanum)
 {
 	if (aasworld.areasettings[areanum].areaflags & AREA_LIQUID) return qtrue;
 	else return qfalse;
 } //end of the function AAS_AreaLiquid
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaLava(int areanum)
 {
 	return (aasworld.areasettings[areanum].contents & AREACONTENTS_LAVA);
 } //end of the function AAS_AreaLava
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaSlime(int areanum)
 {
 	return (aasworld.areasettings[areanum].contents & AREACONTENTS_SLIME);
 } //end of the function AAS_AreaSlime
 //===========================================================================
 // returns qtrue if the area contains ground faces
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaGrounded(int areanum)
 {
 	return (aasworld.areasettings[areanum].areaflags & AREA_GROUNDED);
 } //end of the function AAS_AreaGround
 //===========================================================================
 // returns true if the area contains ladder faces
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaLadder(int areanum)
 {
 	return (aasworld.areasettings[areanum].areaflags & AREA_LADDER);
 } //end of the function AAS_AreaLadder
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaJumpPad(int areanum)
 {
 	return (aasworld.areasettings[areanum].contents & AREACONTENTS_JUMPPAD);
 } //end of the function AAS_AreaJumpPad
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaTeleporter(int areanum)
 {
 	return (aasworld.areasettings[areanum].contents & AREACONTENTS_TELEPORTER);
 } //end of the function AAS_AreaTeleporter
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaClusterPortal(int areanum)
 {
 	return (aasworld.areasettings[areanum].contents & AREACONTENTS_CLUSTERPORTAL);
 } //end of the function AAS_AreaClusterPortal
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_AreaDoNotEnter(int areanum)
 {
 	return (aasworld.areasettings[areanum].contents & AREACONTENTS_DONOTENTER);
 } //end of the function AAS_AreaDoNotEnter
 //===========================================================================
 // returns the time it takes perform a barrier jump
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 unsigned short int AAS_BarrierJumpTravelTime(void)
 {
 	return aassettings.phys_jumpvel / (aassettings.phys_gravity * 0.1);
 } //end op the function AAS_BarrierJumpTravelTime
 //===========================================================================
 // returns true if there already exists a reachability from area1 to area2
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 qboolean AAS_ReachabilityExists(int area1num, int area2num)
 {
 	aas_lreachability_t *r;
 
 	for (r = areareachability[area1num]; r; r = r->next)
 	{
 		if (r->areanum == area2num) return qtrue;
 	} //end for
 	return qfalse;
 } //end of the function AAS_ReachabilityExists
 //===========================================================================
 // returns true if there is a solid just after the end point when going
 // from start to end
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_NearbySolidOrGap(vec3_t start, vec3_t end)
 {
 	vec3_t dir, testpoint;
 	int areanum;
 
 	VectorSubtract(end, start, dir);
 	dir[2] = 0;
 	VectorNormalize(dir);
 	VectorMA(end, 48, dir, testpoint);
 
 	areanum = AAS_PointAreaNum(testpoint);
 	if (!areanum)
 	{
 		testpoint[2] += 16;
 		areanum = AAS_PointAreaNum(testpoint);
 		if (!areanum) return qtrue;
 	} //end if
 	VectorMA(end, 64, dir, testpoint);
 	areanum = AAS_PointAreaNum(testpoint);
 	if (areanum)
 	{
 		if (!AAS_AreaSwim(areanum) && !AAS_AreaGrounded(areanum)) return qtrue;
 	} //end if
 	return qfalse;
 } //end of the function AAS_SolidGapTime
 //===========================================================================
 // searches for swim reachabilities between adjacent areas
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_Reachability_Swim(int area1num, int area2num)
 {
 	int i, j, face1num, face2num, side1;
 	aas_area_t *area1, *area2;
 	aas_areasettings_t *areasettings;
 	aas_lreachability_t *lreach;
 	aas_face_t *face1;
 	aas_plane_t *plane;
 	vec3_t start;
 
 	if (!AAS_AreaSwim(area1num) || !AAS_AreaSwim(area2num)) return qfalse;
 	//if the second area is crouch only
 	if (!(aasworld.areasettings[area2num].presencetype & PRESENCE_NORMAL)) return qfalse;
 
 	area1 = &aasworld.areas[area1num];
 	area2 = &aasworld.areas[area2num];
 
 	//if the areas are not near anough
 	for (i = 0; i < 3; i++)
 	{
 		if (area1->mins[i] > area2->maxs[i] + 10) return qfalse;
 		if (area1->maxs[i] < area2->mins[i] - 10) return qfalse;
 	} //end for
 	//find a shared face and create a reachability link
 	for (i = 0; i < area1->numfaces; i++)
 	{
 		face1num = aasworld.faceindex[area1->firstface + i];
 		side1 = face1num < 0;
 		face1num = abs(face1num);
 		//
 		for (j = 0; j < area2->numfaces; j++)
 		{
 			face2num = abs(aasworld.faceindex[area2->firstface + j]);
 			//
 			if (face1num == face2num)
 			{
 				AAS_FaceCenter(face1num, start);
 				//
 				if (AAS_PointContents(start) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER))
 				{
 					//
 					face1 = &aasworld.faces[face1num];
 					areasettings = &aasworld.areasettings[area1num];
 					//create a new reachability link
 					lreach = AAS_AllocReachability();
 					if (!lreach) return qfalse;
 					lreach->areanum = area2num;
 					lreach->facenum = face1num;
 					lreach->edgenum = 0;
 					VectorCopy(start, lreach->start);
 					plane = &aasworld.planes[face1->planenum ^ side1];
 					VectorMA(lreach->start, -INSIDEUNITS, plane->normal, lreach->end);
 					lreach->traveltype = TRAVEL_SWIM;
 					lreach->traveltime = 1;
 					//if the volume of the area is rather small
 					if (AAS_AreaVolume(area2num) < 800)
 						lreach->traveltime += 200;
 					//if (!(AAS_PointContents(start) & MASK_WATER)) lreach->traveltime += 500;
 					//link the reachability
 					lreach->next = areareachability[area1num];
 					areareachability[area1num] = lreach;
 					reach_swim++;
 					return qtrue;
 				} //end if
 			} //end if
 		} //end for
 	} //end for
 	return qfalse;
 } //end of the function AAS_Reachability_Swim
 //===========================================================================
 // searches for reachabilities between adjacent areas with equal floor
 // heights
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_Reachability_EqualFloorHeight(int area1num, int area2num)
 {
 	int i, j, edgenum, edgenum1, edgenum2, foundreach, side;
 	float height, bestheight, length, bestlength;
 	vec3_t dir, start, end, normal, invgravity, gravitydirection = {0, 0, -1};
 	vec3_t edgevec;
 	aas_area_t *area1, *area2;
 	aas_face_t *face1, *face2;
 	aas_edge_t *edge;
 	aas_plane_t *plane2;
 	aas_lreachability_t lr, *lreach;
 
 	if (!AAS_AreaGrounded(area1num) || !AAS_AreaGrounded(area2num)) return qfalse;
 
 	area1 = &aasworld.areas[area1num];
 	area2 = &aasworld.areas[area2num];
 	//if the areas are not near anough in the x-y direction
 	for (i = 0; i < 2; i++)
 	{
 		if (area1->mins[i] > area2->maxs[i] + 10) return qfalse;
 		if (area1->maxs[i] < area2->mins[i] - 10) return qfalse;
 	} //end for
 	//if area 2 is too high above area 1
 	if (area2->mins[2] > area1->maxs[2]) return qfalse;
 	//
 	VectorCopy(gravitydirection, invgravity);
 	VectorInverse(invgravity);
 	//
 	bestheight = 99999;
 	bestlength = 0;
 	foundreach = qfalse;
 	Com_Memset(&lr, 0, sizeof(aas_lreachability_t)); //make the compiler happy
 	//
 	//check if the areas have ground faces with a common edge
 	//if existing use the lowest common edge for a reachability link
 	for (i = 0; i < area1->numfaces; i++)
 	{
 		face1 = &aasworld.faces[abs(aasworld.faceindex[area1->firstface + i])];
 		if (!(face1->faceflags & FACE_GROUND)) continue;
 		//
 		for (j = 0; j < area2->numfaces; j++)
 		{
 			face2 = &aasworld.faces[abs(aasworld.faceindex[area2->firstface + j])];
 			if (!(face2->faceflags & FACE_GROUND)) continue;
 			//if there is a common edge
 			for (edgenum1 = 0; edgenum1 < face1->numedges; edgenum1++)
 			{
 				for (edgenum2 = 0; edgenum2 < face2->numedges; edgenum2++)
 				{
 					if (abs(aasworld.edgeindex[face1->firstedge + edgenum1]) !=
 							abs(aasworld.edgeindex[face2->firstedge + edgenum2]))
 									continue;
 					edgenum = aasworld.edgeindex[face1->firstedge + edgenum1];
 					side = edgenum < 0;
 					edge = &aasworld.edges[abs(edgenum)];
 					//get the length of the edge
 					VectorSubtract(aasworld.vertexes[edge->v[1]],
 								aasworld.vertexes[edge->v[0]], dir);
 					length = VectorLength(dir);
 					//get the start point
 					VectorAdd(aasworld.vertexes[edge->v[0]],
 								aasworld.vertexes[edge->v[1]], start);
 					VectorScale(start, 0.5, start);
 					VectorCopy(start, end);
 					//get the end point several units inside area2
 					//and the start point several units inside area1
 					//NOTE: normal is pointing into area2 because the
 					//face edges are stored counter clockwise
 					VectorSubtract(aasworld.vertexes[edge->v[side]],
 								aasworld.vertexes[edge->v[!side]], edgevec);
 					plane2 = &aasworld.planes[face2->planenum];
 					CrossProduct(edgevec, plane2->normal, normal);
 					VectorNormalize(normal);
 					//
 					//VectorMA(start, -1, normal, start);
 					VectorMA(end, INSIDEUNITS_WALKEND, normal, end);
 					VectorMA(start, INSIDEUNITS_WALKSTART, normal, start);
 					end[2] += 0.125;
 					//
 					height = DotProduct(invgravity, start);
 					//NOTE: if there's nearby solid or a gap area after this area
 					//disabled this crap
 					//if (AAS_NearbySolidOrGap(start, end)) height += 200;
 					//NOTE: disabled because it disables reachabilities to very small areas
 					//if (AAS_PointAreaNum(end) != area2num) continue;
 					//get the longest lowest edge
 					if (height < bestheight ||
 							(height < bestheight + 1 && length > bestlength))
 					{
 						bestheight = height;
 						bestlength = length;
 						//create a new reachability link
 						lr.areanum = area2num;
 						lr.facenum = 0;
 						lr.edgenum = edgenum;
 						VectorCopy(start, lr.start);
 						VectorCopy(end, lr.end);
 						lr.traveltype = TRAVEL_WALK;
 						lr.traveltime = 1;
 						foundreach = qtrue;
 					} //end if
 				} //end for
 			} //end for
 		} //end for
 	} //end for
 	if (foundreach)
 	{
 		//create a new reachability link
 		lreach = AAS_AllocReachability();
 		if (!lreach) return qfalse;
 		lreach->areanum = lr.areanum;
 		lreach->facenum = lr.facenum;
 		lreach->edgenum = lr.edgenum;
 		VectorCopy(lr.start, lreach->start);
 		VectorCopy(lr.end, lreach->end);
 		lreach->traveltype = lr.traveltype;
 		lreach->traveltime = lr.traveltime;
 		lreach->next = areareachability[area1num];
 		areareachability[area1num] = lreach;
 		//if going into a crouch area
 		if (!AAS_AreaCrouch(area1num) && AAS_AreaCrouch(area2num))
 		{
 			lreach->traveltime += aassettings.rs_startcrouch;
 		} //end if
 		/*
 		//NOTE: if there's nearby solid or a gap area after this area
 		if (!AAS_NearbySolidOrGap(lreach->start, lreach->end))
 		{
 			lreach->traveltime += 100;
 		} //end if
 		*/
 		//avoid rather small areas
 		//if (AAS_AreaGroundFaceArea(lreach->areanum) < 500) lreach->traveltime += 100;
 		//
 		reach_equalfloor++;
 		return qtrue;
 	} //end if
 	return qfalse;
 } //end of the function AAS_Reachability_EqualFloorHeight
 //===========================================================================
 // searches step, barrier, waterjump and walk off ledge reachabilities
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, int area2num)
 {
 	int i, j, k, l, edge1num, edge2num, areas[10], numareas;
 	int ground_bestarea2groundedgenum, ground_foundreach;
 	int water_bestarea2groundedgenum, water_foundreach;
 	int side1, area1swim, faceside1, groundface1num;
 	float dist, dist1, dist2, diff, invgravitydot, ortdot;
 	float x1, x2, x3, x4, y1, y2, y3, y4, tmp, y;
 	float length, ground_bestlength, water_bestlength, ground_bestdist, water_bestdist;
 	vec3_t v1, v2, v3, v4, tmpv, p1area1, p1area2, p2area1, p2area2;
 	vec3_t normal, ort, edgevec, start, end, dir;
 	vec3_t ground_beststart, ground_bestend, ground_bestnormal;
 	vec3_t water_beststart, water_bestend, water_bestnormal;
 	vec3_t invgravity = {0, 0, 1};
 	vec3_t testpoint;
 	aas_plane_t *plane;
 	aas_area_t *area1, *area2;
 	aas_face_t *groundface1, *groundface2, *ground_bestface1, *water_bestface1;
 	aas_edge_t *edge1, *edge2;
 	aas_lreachability_t *lreach;
 	aas_trace_t trace;
 
 	//must be able to walk or swim in the first area
 	if (!AAS_AreaGrounded(area1num) && !AAS_AreaSwim(area1num)) return qfalse;
 	//
 	if (!AAS_AreaGrounded(area2num) && !AAS_AreaSwim(area2num)) return qfalse;
 	//
 	area1 = &aasworld.areas[area1num];
 	area2 = &aasworld.areas[area2num];
 	//if the first area contains a liquid
 	area1swim = AAS_AreaSwim(area1num);
 	//if the areas are not near anough in the x-y direction
 	for (i = 0; i < 2; i++)
 	{
 		if (area1->mins[i] > area2->maxs[i] + 10) return qfalse;
 		if (area1->maxs[i] < area2->mins[i] - 10) return qfalse;
 	} //end for
 	//
 	ground_foundreach = qfalse;
 	ground_bestdist = 99999;
 	ground_bestlength = 0;
 	ground_bestarea2groundedgenum = 0;
 	//
 	water_foundreach = qfalse;
 	water_bestdist = 99999;
 	water_bestlength = 0;
 	water_bestarea2groundedgenum = 0;
 	//
 	for (i = 0; i < area1->numfaces; i++)
 	{
 		groundface1num = aasworld.faceindex[area1->firstface + i];
 		faceside1 = groundface1num < 0;
 		groundface1 = &aasworld.faces[abs(groundface1num)];
 		//if this isn't a ground face
 		if (!(groundface1->faceflags & FACE_GROUND))
 		{
 			//if we can swim in the first area
 			if (area1swim)
 			{
 				//face plane must be more or less horizontal
 				plane = &aasworld.planes[groundface1->planenum ^ (!faceside1)];
 				if (DotProduct(plane->normal, invgravity) < 0.7) continue;
 			} //end if
 			else
 			{
 				//if we can't swim in the area it must be a ground face
 				continue;
 			} //end else
 		} //end if
 		//
 		for (k = 0; k < groundface1->numedges; k++)
 		{
 			edge1num = aasworld.edgeindex[groundface1->firstedge + k];
 			side1 = (edge1num < 0);
 			//NOTE: for water faces we must take the side area 1 is
 			// on into account because the face is shared and doesn't
 			// have to be oriented correctly
 			if (!(groundface1->faceflags & FACE_GROUND)) side1 = (side1 == faceside1);
 			edge1num = abs(edge1num);
 			edge1 = &aasworld.edges[edge1num];
 			//vertexes of the edge
 			VectorCopy(aasworld.vertexes[edge1->v[!side1]], v1);
 			VectorCopy(aasworld.vertexes[edge1->v[side1]], v2);
 			//get a vertical plane through the edge
 			//NOTE: normal is pointing into area 2 because the
 			//face edges are stored counter clockwise
 			VectorSubtract(v2, v1, edgevec);
 			CrossProduct(edgevec, invgravity, normal);
 			VectorNormalize(normal);
 			dist = DotProduct(normal, v1);
 			//check the faces from the second area
 			for (j = 0; j < area2->numfaces; j++)
 			{
 				groundface2 = &aasworld.faces[abs(aasworld.faceindex[area2->firstface + j])];
 				//must be a ground face
 				if (!(groundface2->faceflags & FACE_GROUND)) continue;
 				//check the edges of this ground face
 				for (l = 0; l < groundface2->numedges; l++)
 				{
 					edge2num = abs(aasworld.edgeindex[groundface2->firstedge + l]);
 					edge2 = &aasworld.edges[edge2num];
 					//vertexes of the edge
 					VectorCopy(aasworld.vertexes[edge2->v[0]], v3);
 					VectorCopy(aasworld.vertexes[edge2->v[1]], v4);
 					//check the distance between the two points and the vertical plane
 					//through the edge of area1
 					diff = DotProduct(normal, v3) - dist;
 					if (diff < -0.1 || diff > 0.1) continue;
 					diff = DotProduct(normal, v4) - dist;
 					if (diff < -0.1 || diff > 0.1) continue;
 					//
 					//project the two ground edges into the step side plane
 					//and calculate the shortest distance between the two
 					//edges if they overlap in the direction orthogonal to
 					//the gravity direction
 					CrossProduct(invgravity, normal, ort);
 					invgravitydot = DotProduct(invgravity, invgravity);
 					ortdot = DotProduct(ort, ort);
 					//projection into the step plane
 					//NOTE: since gravity is vertical this is just the z coordinate
 					y1 = v1[2];//DotProduct(v1, invgravity) / invgravitydot;
 					y2 = v2[2];//DotProduct(v2, invgravity) / invgravitydot;
 					y3 = v3[2];//DotProduct(v3, invgravity) / invgravitydot;
 					y4 = v4[2];//DotProduct(v4, invgravity) / invgravitydot;
 					//
 					x1 = DotProduct(v1, ort) / ortdot;
 					x2 = DotProduct(v2, ort) / ortdot;
 					x3 = DotProduct(v3, ort) / ortdot;
 					x4 = DotProduct(v4, ort) / ortdot;
 					//
 					if (x1 > x2)
 					{
 						tmp = x1; x1 = x2; x2 = tmp;
 						tmp = y1; y1 = y2; y2 = tmp;
 						VectorCopy(v1, tmpv); VectorCopy(v2, v1); VectorCopy(tmpv, v2);
 					} //end if
 					if (x3 > x4)
 					{
 						tmp = x3; x3 = x4; x4 = tmp;
 						tmp = y3; y3 = y4; y4 = tmp;
 						VectorCopy(v3, tmpv); VectorCopy(v4, v3); VectorCopy(tmpv, v4);
 					} //end if
 					//if the two projected edge lines have no overlap
 					if (x2 <= x3 || x4 <= x1)
 					{
 //						Log_Write("lines no overlap: from area %d to %d\r\n", area1num, area2num);
 						continue;
 					} //end if
 					//if the two lines fully overlap
 					if ((x1 - 0.5 < x3 && x4 < x2 + 0.5) &&
 							(x3 - 0.5 < x1 && x2 < x4 + 0.5))
 					{
 						dist1 = y3 - y1;
 						dist2 = y4 - y2;
 						VectorCopy(v1, p1area1);
 						VectorCopy(v2, p2area1);
 						VectorCopy(v3, p1area2);
 						VectorCopy(v4, p2area2);
 					} //end if
 					else
 					{
 						//if the points are equal
 						if (x1 > x3 - 0.1 && x1 < x3 + 0.1)
 						{
 							dist1 = y3 - y1;
 							VectorCopy(v1, p1area1);
 							VectorCopy(v3, p1area2);
 						} //end if
 						else if (x1 < x3)
 						{
 							y = y1 + (x3 - x1) * (y2 - y1) / (x2 - x1);
 							dist1 = y3 - y;
 							VectorCopy(v3, p1area1);
 							p1area1[2] = y;
 							VectorCopy(v3, p1area2);
 						} //end if
 						else
 						{
 							y = y3 + (x1 - x3) * (y4 - y3) / (x4 - x3);
 							dist1 = y - y1;
 							VectorCopy(v1, p1area1);
 							VectorCopy(v1, p1area2);
 							p1area2[2] = y;
 						} //end if
 						//if the points are equal
 						if (x2 > x4 - 0.1 && x2 < x4 + 0.1)
 						{
 							dist2 = y4 - y2;
 							VectorCopy(v2, p2area1);
 							VectorCopy(v4, p2area2);
 						} //end if
 						else if (x2 < x4)
 						{
 							y = y3 + (x2 - x3) * (y4 - y3) / (x4 - x3);
 							dist2 = y - y2;
 							VectorCopy(v2, p2area1);
 							VectorCopy(v2, p2area2);
 							p2area2[2] = y;
 						} //end if
 						else
 						{
 							y = y1 + (x4 - x1) * (y2 - y1) / (x2 - x1);
 							dist2 = y4 - y;
 							VectorCopy(v4, p2area1);
 							p2area1[2] = y;
 							VectorCopy(v4, p2area2);
 						} //end else
 					} //end else
 					//if both distances are pretty much equal
 					//then we take the middle of the points
 					if (dist1 > dist2 - 1 && dist1 < dist2 + 1)
 					{
 						dist = dist1;
 						VectorAdd(p1area1, p2area1, start);
 						VectorScale(start, 0.5, start);
 						VectorAdd(p1area2, p2area2, end);
 						VectorScale(end, 0.5, end);
 					} //end if
 					else if (dist1 < dist2)
 					{
 						dist = dist1;
 						VectorCopy(p1area1, start);
 						VectorCopy(p1area2, end);
 					} //end else if
 					else
 					{
 						dist = dist2;
 						VectorCopy(p2area1, start);
 						VectorCopy(p2area2, end);
 					} //end else
 					//get the length of the overlapping part of the edges of the two areas
 					VectorSubtract(p2area2, p1area2, dir);
 					length = VectorLength(dir);
 					//
 					if (groundface1->faceflags & FACE_GROUND)
 					{
 						//if the vertical distance is smaller
 						if (dist < ground_bestdist ||
 								//or the vertical distance is pretty much the same
 								//but the overlapping part of the edges is longer
 								(dist < ground_bestdist + 1 && length > ground_bestlength))
 						{
 							ground_bestdist = dist;
 							ground_bestlength = length;
 							ground_foundreach = qtrue;
 							ground_bestarea2groundedgenum = edge1num;
 							ground_bestface1 = groundface1;
 							//best point towards area1
 							VectorCopy(start, ground_beststart);
 							//normal is pointing into area2
 							VectorCopy(normal, ground_bestnormal);
 							//best point towards area2
 							VectorCopy(end, ground_bestend);
 						} //end if
 					} //end if
 					else
 					{
 						//if the vertical distance is smaller
 						if (dist < water_bestdist ||
 								//or the vertical distance is pretty much the same
 								//but the overlapping part of the edges is longer
 								(dist < water_bestdist + 1 && length > water_bestlength))
 						{
 							water_bestdist = dist;
 							water_bestlength = length;
 							water_foundreach = qtrue;
 							water_bestarea2groundedgenum = edge1num;
 							water_bestface1 = groundface1;
 							//best point towards area1
 							VectorCopy(start, water_beststart);
 							//normal is pointing into area2
 							VectorCopy(normal, water_bestnormal);
 							//best point towards area2
 							VectorCopy(end, water_bestend);
 						} //end if
 					} //end else
 				} //end for
 			} //end for
 		} //end for
 	} //end for
 	//
 	// NOTE: swim reachabilities are already filtered out
 	//
 	// Steps
 	//
 	//        ---------
 	//        |          step height -> TRAVEL_WALK
 	//--------|
 	//
 	//        ---------
 	//~~~~~~~~|          step height and low water -> TRAVEL_WALK
 	//--------|
 	//
 	//~~~~~~~~~~~~~~~~~~
 	//        ---------
 	//        |          step height and low water up to the step -> TRAVEL_WALK
 	//--------|
 	//
 	//check for a step reachability
 	if (ground_foundreach)
 	{
 		//if area2 is higher but lower than the maximum step height
 		//NOTE: ground_bestdist >= 0 also catches equal floor reachabilities
 		if (ground_bestdist >= 0 && ground_bestdist < aassettings.phys_maxstep)
 		{
 			//create walk reachability from area1 to area2
 			lreach = AAS_AllocReachability();
 			if (!lreach) return qfalse;
 			lreach->areanum = area2num;
 			lreach->facenum = 0;
 			lreach->edgenum = ground_bestarea2groundedgenum;
 			VectorMA(ground_beststart, INSIDEUNITS_WALKSTART, ground_bestnormal, lreach->start);
 			VectorMA(ground_bestend, INSIDEUNITS_WALKEND, ground_bestnormal, lreach->end);
 			lreach->traveltype = TRAVEL_WALK;
 			lreach->traveltime = 0;//1;
 			//if going into a crouch area
 			if (!AAS_AreaCrouch(area1num) && AAS_AreaCrouch(area2num))
 			{
 				lreach->traveltime += aassettings.rs_startcrouch;
 			} //end if
 			lreach->next = areareachability[area1num];
 			areareachability[area1num] = lreach;
 			//NOTE: if there's nearby solid or a gap area after this area
 			/*
 			if (!AAS_NearbySolidOrGap(lreach->start, lreach->end))
 			{
 				lreach->traveltime += 100;
 			} //end if
 			*/
 			//avoid rather small areas
 			//if (AAS_AreaGroundFaceArea(lreach->areanum) < 500) lreach->traveltime += 100;
 			//
 			reach_step++;
 			return qtrue;
 		} //end if
 	} //end if
 	//
 	// Water Jumps
 	//
 	//        ---------
 	//        |
 	//~~~~~~~~|
 	//        |
 	//        |          higher than step height and water up to waterjump height -> TRAVEL_WATERJUMP
 	//--------|
 	//
 	//~~~~~~~~~~~~~~~~~~
 	//        ---------
 	//        |
 	//        |
 	//        |
 	//        |          higher than step height and low water up to the step -> TRAVEL_WATERJUMP
 	//--------|
 	//
 	//check for a waterjump reachability
 	if (water_foundreach)
 	{
 		//get a test point a little bit towards area1
 		VectorMA(water_bestend, -INSIDEUNITS, water_bestnormal, testpoint);
 		//go down the maximum waterjump height
 		testpoint[2] -= aassettings.phys_maxwaterjump;
 		//if there IS water the sv_maxwaterjump height below the bestend point
 		if (aasworld.areasettings[AAS_PointAreaNum(testpoint)].areaflags & AREA_LIQUID)
 		{
 			//don't create rediculous water jump reachabilities from areas very far below
 			//the water surface
 			if (water_bestdist < aassettings.phys_maxwaterjump + 24)
 			{
 				//waterjumping from or towards a crouch only area is not possible in Quake2
 				if ((aasworld.areasettings[area1num].presencetype & PRESENCE_NORMAL) &&
 						(aasworld.areasettings[area2num].presencetype & PRESENCE_NORMAL))
 				{
 					//create water jump reachability from area1 to area2
 					lreach = AAS_AllocReachability();
 					if (!lreach) return qfalse;
 					lreach->areanum = area2num;
 					lreach->facenum = 0;
 					lreach->edgenum = water_bestarea2groundedgenum;
 					VectorCopy(water_beststart, lreach->start);
 					VectorMA(water_bestend, INSIDEUNITS_WATERJUMP, water_bestnormal, lreach->end);
 					lreach->traveltype = TRAVEL_WATERJUMP;
 					lreach->traveltime = aassettings.rs_waterjump;
 					lreach->next = areareachability[area1num];
 					areareachability[area1num] = lreach;
 					//we've got another waterjump reachability
 					reach_waterjump++;
 					return qtrue;
 				} //end if
 			} //end if
 		} //end if
 	} //end if
 	//
 	// Barrier Jumps
 	//
 	//        ---------
 	//        |
 	//        |
 	//        |
 	//        |         higher than step height lower than barrier height -> TRAVEL_BARRIERJUMP
 	//--------|
 	//
 	//        ---------
 	//        |
 	//        |
 	//        |
 	//~~~~~~~~|         higher than step height lower than barrier height
 	//--------|         and a thin layer of water in the area to jump from -> TRAVEL_BARRIERJUMP
 	//
 	//check for a barrier jump reachability
 	if (ground_foundreach)
 	{
 		//if area2 is higher but lower than the maximum barrier jump height
 		if (ground_bestdist > 0 && ground_bestdist < aassettings.phys_maxbarrier)
 		{
 			//if no water in area1 or a very thin layer of water on the ground
 			if (!water_foundreach || (ground_bestdist - water_bestdist < 16))
 			{
 				//cannot perform a barrier jump towards or from a crouch area in Quake2
 				if (!AAS_AreaCrouch(area1num) && !AAS_AreaCrouch(area2num))
 				{
 					//create barrier jump reachability from area1 to area2
 					lreach = AAS_AllocReachability();
 					if (!lreach) return qfalse;
 					lreach->areanum = area2num;
 					lreach->facenum = 0;
 					lreach->edgenum = ground_bestarea2groundedgenum;
 					VectorMA(ground_beststart, INSIDEUNITS_WALKSTART, ground_bestnormal, lreach->start);
 					VectorMA(ground_bestend, INSIDEUNITS_WALKEND, ground_bestnormal, lreach->end);
 					lreach->traveltype = TRAVEL_BARRIERJUMP;
 					lreach->traveltime = aassettings.rs_barrierjump;//AAS_BarrierJumpTravelTime();
 					lreach->next = areareachability[area1num];
 					areareachability[area1num] = lreach;
 					//we've got another barrierjump reachability
 					reach_barrier++;
 					return qtrue;
 				} //end if
 			} //end if
 		} //end if
 	} //end if
 	//
 	// Walk and Walk Off Ledge
 	//
 	//--------|
 	//        |          can walk or step back -> TRAVEL_WALK
 	//        ---------
 	//
 	//--------|
 	//        |
 	//        |
 	//        |
 	//        |          cannot walk/step back -> TRAVEL_WALKOFFLEDGE
 	//        ---------
 	//
 	//--------|
 	//        |
 	//        |~~~~~~~~
 	//        |
 	//        |          cannot step back but can waterjump back -> TRAVEL_WALKOFFLEDGE
 	//        ---------  FIXME: create TRAVEL_WALK reach??
 	//
 	//check for a walk or walk off ledge reachability
 	if (ground_foundreach)
 	{
 		if (ground_bestdist < 0)
 		{
 			if (ground_bestdist > -aassettings.phys_maxstep)
 			{
 				//create walk reachability from area1 to area2
 				lreach = AAS_AllocReachability();
 				if (!lreach) return qfalse;
 				lreach->areanum = area2num;
 				lreach->facenum = 0;
 				lreach->edgenum = ground_bestarea2groundedgenum;
 				VectorMA(ground_beststart, INSIDEUNITS_WALKSTART, ground_bestnormal, lreach->start);
 				VectorMA(ground_bestend, INSIDEUNITS_WALKEND, ground_bestnormal, lreach->end);
 				lreach->traveltype = TRAVEL_WALK;
 				lreach->traveltime = 1;
 				lreach->next = areareachability[area1num];
 				areareachability[area1num] = lreach;
 				//we've got another walk reachability
 				reach_walk++;
 				return qtrue;
 			} //end if
 			// if no maximum fall height set or less than the max
 			if (!aassettings.rs_maxfallheight || fabs(ground_bestdist) < aassettings.rs_maxfallheight) {
 				//trace a bounding box vertically to check for solids
 				VectorMA(ground_bestend, INSIDEUNITS, ground_bestnormal, ground_bestend);
 				VectorCopy(ground_bestend, start);
 				start[2] = ground_beststart[2];
 				VectorCopy(ground_bestend, end);
 				end[2] += 4;
 				trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
 				//if no solids were found
 				if (!trace.startsolid && trace.fraction >= 1.0)
 				{
 					//the trace end point must be in the goal area
 					trace.endpos[2] += 1;
 					if (AAS_PointAreaNum(trace.endpos) == area2num)
 					{
 						//if not going through a cluster portal
 						numareas = AAS_TraceAreas(start, end, areas, NULL, sizeof(areas) / sizeof(int));
 						for (i = 0; i < numareas; i++)
 							if (AAS_AreaClusterPortal(areas[i]))
 								break;
 						if (i >= numareas)
 						{
 							//create a walk off ledge reachability from area1 to area2
 							lreach = AAS_AllocReachability();
 							if (!lreach) return qfalse;
 							lreach->areanum = area2num;
 							lreach->facenum = 0;
 							lreach->edgenum = ground_bestarea2groundedgenum;
 							VectorCopy(ground_beststart, lreach->start);
 							VectorCopy(ground_bestend, lreach->end);
 							lreach->traveltype = TRAVEL_WALKOFFLEDGE;
 							lreach->traveltime = aassettings.rs_startwalkoffledge + fabs(ground_bestdist) * 50 / aassettings.phys_gravity;
 							//if falling from too high and not falling into water
 							if (!AAS_AreaSwim(area2num) && !AAS_AreaJumpPad(area2num))
 							{
 								if (AAS_FallDelta(ground_bestdist) > aassettings.phys_falldelta5)
 								{
 									lreach->traveltime += aassettings.rs_falldamage5;
 								} //end if
 								if (AAS_FallDelta(ground_bestdist) > aassettings.phys_falldelta10)
 								{
 									lreach->traveltime += aassettings.rs_falldamage10;
 								} //end if
 							} //end if
 							lreach->next = areareachability[area1num];
 							areareachability[area1num] = lreach;
 							//
 							reach_walkoffledge++;
 							//NOTE: don't create a weapon (rl, bfg) jump reachability here
 							//because it interferes with other reachabilities
 							//like the ladder reachability
 							return qtrue;
 						} //end if
 					} //end if
 				} //end if
 			} //end if
 		} //end else
 	} //end if
 	return qfalse;
 } //end of the function AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge
 //===========================================================================
 // returns the distance between the two vectors
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 float VectorDistance(vec3_t v1, vec3_t v2)
 {
 	vec3_t dir;
 
 	VectorSubtract(v2, v1, dir);
 	return VectorLength(dir);
 } //end of the function VectorDistance
 //===========================================================================
 // returns true if the first vector is between the last two vectors
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int VectorBetweenVectors(vec3_t v, vec3_t v1, vec3_t v2)
 {
 	vec3_t dir1, dir2;
 
 	VectorSubtract(v, v1, dir1);
 	VectorSubtract(v, v2, dir2);
 	return (DotProduct(dir1, dir2) <= 0);
 } //end of the function VectorBetweenVectors
 //===========================================================================
 // returns the mid point between the two vectors
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void VectorMiddle(vec3_t v1, vec3_t v2, vec3_t middle)
 {
 	VectorAdd(v1, v2, middle);
 	VectorScale(middle, 0.5, middle);
 } //end of the function VectorMiddle
 //===========================================================================
 // calculate a range of points closest to each other on both edges
 //
 // Parameter:			beststart1		start of the range of points on edge v1-v2
 //						beststart2		end of the range of points  on edge v1-v2
 //						bestend1		start of the range of points on edge v3-v4
 //						bestend2		end of the range of points  on edge v3-v4
 //						bestdist		best distance so far
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 /*
 float AAS_ClosestEdgePoints(vec3_t v1, vec3_t v2, vec3_t v3, vec3_t v4,
 							aas_plane_t *plane1, aas_plane_t *plane2,
 							vec3_t beststart, vec3_t bestend, float bestdist)
 {
 	vec3_t dir1, dir2, p1, p2, p3, p4;
 	float a1, a2, b1, b2, dist;
 	int founddist;
 
 	//edge vectors
 	VectorSubtract(v2, v1, dir1);
 	VectorSubtract(v4, v3, dir2);
 	//get the horizontal directions
 	dir1[2] = 0;
 	dir2[2] = 0;
 	//
 	// p1 = point on an edge vector of area2 closest to v1
 	// p2 = point on an edge vector of area2 closest to v2
 	// p3 = point on an edge vector of area1 closest to v3
 	// p4 = point on an edge vector of area1 closest to v4
 	//
 	if (dir2[0])
 	{
 		a2 = dir2[1] / dir2[0];
 		b2 = v3[1] - a2 * v3[0];
 		//point on the edge vector of area2 closest to v1
 		p1[0] = (DotProduct(v1, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
 		p1[1] = a2 * p1[0] + b2;
 		//point on the edge vector of area2 closest to v2
 		p2[0] = (DotProduct(v2, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
 		p2[1] = a2 * p2[0] + b2;
 	} //end if
 	else
 	{
 		//point on the edge vector of area2 closest to v1
 		p1[0] = v3[0];
 		p1[1] = v1[1];
 		//point on the edge vector of area2 closest to v2
 		p2[0] = v3[0];
 		p2[1] = v2[1];
 	} //end else
 	//
 	if (dir1[0])
 	{
 		//
 		a1 = dir1[1] / dir1[0];
 		b1 = v1[1] - a1 * v1[0];
 		//point on the edge vector of area1 closest to v3
 		p3[0] = (DotProduct(v3, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
 		p3[1] = a1 * p3[0] + b1;
 		//point on the edge vector of area1 closest to v4
 		p4[0] = (DotProduct(v4, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
 		p4[1] = a1 * p4[0] + b1;
 	} //end if
 	else
 	{
 		//point on the edge vector of area1 closest to v3
 		p3[0] = v1[0];
 		p3[1] = v3[1];
 		//point on the edge vector of area1 closest to v4
 		p4[0] = v1[0];
 		p4[1] = v4[1];
 	} //end else
 	//start with zero z-coordinates
 	p1[2] = 0;
 	p2[2] = 0;
 	p3[2] = 0;
 	p4[2] = 0;
 	//calculate the z-coordinates from the ground planes
 	p1[2] = (plane2->dist - DotProduct(plane2->normal, p1)) / plane2->normal[2];
 	p2[2] = (plane2->dist - DotProduct(plane2->normal, p2)) / plane2->normal[2];
 	p3[2] = (plane1->dist - DotProduct(plane1->normal, p3)) / plane1->normal[2];
 	p4[2] = (plane1->dist - DotProduct(plane1->normal, p4)) / plane1->normal[2];
 	//
 	founddist = qfalse;
 	//
 	if (VectorBetweenVectors(p1, v3, v4))
 	{
 		dist = VectorDistance(v1, p1);
 		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
 		{
 			VectorMiddle(beststart, v1, beststart);
 			VectorMiddle(bestend, p1, bestend);
 		} //end if
 		else if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v1, beststart);
 			VectorCopy(p1, bestend);
 		} //end if
 		founddist = qtrue;
 	} //end if
 	if (VectorBetweenVectors(p2, v3, v4))
 	{
 		dist = VectorDistance(v2, p2);
 		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
 		{
 			VectorMiddle(beststart, v2, beststart);
 			VectorMiddle(bestend, p2, bestend);
 		} //end if
 		else if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v2, beststart);
 			VectorCopy(p2, bestend);
 		} //end if
 		founddist = qtrue;
 	} //end else if
 	if (VectorBetweenVectors(p3, v1, v2))
 	{
 		dist = VectorDistance(v3, p3);
 		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
 		{
 			VectorMiddle(beststart, p3, beststart);
 			VectorMiddle(bestend, v3, bestend);
 		} //end if
 		else if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(p3, beststart);
 			VectorCopy(v3, bestend);
 		} //end if
 		founddist = qtrue;
 	} //end else if
 	if (VectorBetweenVectors(p4, v1, v2))
 	{
 		dist = VectorDistance(v4, p4);
 		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
 		{
 			VectorMiddle(beststart, p4, beststart);
 			VectorMiddle(bestend, v4, bestend);
 		} //end if
 		else if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(p4, beststart);
 			VectorCopy(v4, bestend);
 		} //end if
 		founddist = qtrue;
 	} //end else if
 	//if no shortest distance was found the shortest distance
 	//is between one of the vertexes of edge1 and one of edge2
 	if (!founddist)
 	{
 		dist = VectorDistance(v1, v3);
 		if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v1, beststart);
 			VectorCopy(v3, bestend);
 		} //end if
 		dist = VectorDistance(v1, v4);
 		if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v1, beststart);
 			VectorCopy(v4, bestend);
 		} //end if
 		dist = VectorDistance(v2, v3);
 		if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v2, beststart);
 			VectorCopy(v3, bestend);
 		} //end if
 		dist = VectorDistance(v2, v4);
 		if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v2, beststart);
 			VectorCopy(v4, bestend);
 		} //end if
 	} //end if
 	return bestdist;
 } //end of the function AAS_ClosestEdgePoints*/
 
 float AAS_ClosestEdgePoints(vec3_t v1, vec3_t v2, vec3_t v3, vec3_t v4,
 							aas_plane_t *plane1, aas_plane_t *plane2,
 							vec3_t beststart1, vec3_t bestend1,
 							vec3_t beststart2, vec3_t bestend2, float bestdist)
 {
 	vec3_t dir1, dir2, p1, p2, p3, p4;
 	float a1, a2, b1, b2, dist, dist1, dist2;
 	int founddist;
 
 	//edge vectors
 	VectorSubtract(v2, v1, dir1);
 	VectorSubtract(v4, v3, dir2);
 	//get the horizontal directions
 	dir1[2] = 0;
 	dir2[2] = 0;
 	//
 	// p1 = point on an edge vector of area2 closest to v1
 	// p2 = point on an edge vector of area2 closest to v2
 	// p3 = point on an edge vector of area1 closest to v3
 	// p4 = point on an edge vector of area1 closest to v4
 	//
 	if (dir2[0])
 	{
 		a2 = dir2[1] / dir2[0];
 		b2 = v3[1] - a2 * v3[0];
 		//point on the edge vector of area2 closest to v1
 		p1[0] = (DotProduct(v1, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
 		p1[1] = a2 * p1[0] + b2;
 		//point on the edge vector of area2 closest to v2
 		p2[0] = (DotProduct(v2, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
 		p2[1] = a2 * p2[0] + b2;
 	} //end if
 	else
 	{
 		//point on the edge vector of area2 closest to v1
 		p1[0] = v3[0];
 		p1[1] = v1[1];
 		//point on the edge vector of area2 closest to v2
 		p2[0] = v3[0];
 		p2[1] = v2[1];
 	} //end else
 	//
 	if (dir1[0])
 	{
 		//
 		a1 = dir1[1] / dir1[0];
 		b1 = v1[1] - a1 * v1[0];
 		//point on the edge vector of area1 closest to v3
 		p3[0] = (DotProduct(v3, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
 		p3[1] = a1 * p3[0] + b1;
 		//point on the edge vector of area1 closest to v4
 		p4[0] = (DotProduct(v4, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
 		p4[1] = a1 * p4[0] + b1;
 	} //end if
 	else
 	{
 		//point on the edge vector of area1 closest to v3
 		p3[0] = v1[0];
 		p3[1] = v3[1];
 		//point on the edge vector of area1 closest to v4
 		p4[0] = v1[0];
 		p4[1] = v4[1];
 	} //end else
 	//start with zero z-coordinates
 	p1[2] = 0;
 	p2[2] = 0;
 	p3[2] = 0;
 	p4[2] = 0;
 	//calculate the z-coordinates from the ground planes
 	p1[2] = (plane2->dist - DotProduct(plane2->normal, p1)) / plane2->normal[2];
 	p2[2] = (plane2->dist - DotProduct(plane2->normal, p2)) / plane2->normal[2];
 	p3[2] = (plane1->dist - DotProduct(plane1->normal, p3)) / plane1->normal[2];
 	p4[2] = (plane1->dist - DotProduct(plane1->normal, p4)) / plane1->normal[2];
 	//
 	founddist = qfalse;
 	//
 	if (VectorBetweenVectors(p1, v3, v4))
 	{
 		dist = VectorDistance(v1, p1);
 		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
 		{
 			dist1 = VectorDistance(beststart1, v1);
 			dist2 = VectorDistance(beststart2, v1);
 			if (dist1 > dist2)
 			{
 				if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(v1, beststart2);
 			} //end if
 			else
 			{
 				if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(v1, beststart1);
 			} //end else
 			dist1 = VectorDistance(bestend1, p1);
 			dist2 = VectorDistance(bestend2, p1);
 			if (dist1 > dist2)
 			{
 				if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(p1, bestend2);
 			} //end if
 			else
 			{
 				if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(p1, bestend1);
 			} //end else
 		} //end if
 		else if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v1, beststart1);
 			VectorCopy(v1, beststart2);
 			VectorCopy(p1, bestend1);
 			VectorCopy(p1, bestend2);
 		} //end if
 		founddist = qtrue;
 	} //end if
 	if (VectorBetweenVectors(p2, v3, v4))
 	{
 		dist = VectorDistance(v2, p2);
 		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
 		{
 			dist1 = VectorDistance(beststart1, v2);
 			dist2 = VectorDistance(beststart2, v2);
 			if (dist1 > dist2)
 			{
 				if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(v2, beststart2);
 			} //end if
 			else
 			{
 				if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(v2, beststart1);
 			} //end else
 			dist1 = VectorDistance(bestend1, p2);
 			dist2 = VectorDistance(bestend2, p2);
 			if (dist1 > dist2)
 			{
 				if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(p2, bestend2);
 			} //end if
 			else
 			{
 				if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(p2, bestend1);
 			} //end else
 		} //end if
 		else if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v2, beststart1);
 			VectorCopy(v2, beststart2);
 			VectorCopy(p2, bestend1);
 			VectorCopy(p2, bestend2);
 		} //end if
 		founddist = qtrue;
 	} //end else if
 	if (VectorBetweenVectors(p3, v1, v2))
 	{
 		dist = VectorDistance(v3, p3);
 		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
 		{
 			dist1 = VectorDistance(beststart1, p3);
 			dist2 = VectorDistance(beststart2, p3);
 			if (dist1 > dist2)
 			{
 				if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(p3, beststart2);
 			} //end if
 			else
 			{
 				if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(p3, beststart1);
 			} //end else
 			dist1 = VectorDistance(bestend1, v3);
 			dist2 = VectorDistance(bestend2, v3);
 			if (dist1 > dist2)
 			{
 				if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(v3, bestend2);
 			} //end if
 			else
 			{
 				if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(v3, bestend1);
 			} //end else
 		} //end if
 		else if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(p3, beststart1);
 			VectorCopy(p3, beststart2);
 			VectorCopy(v3, bestend1);
 			VectorCopy(v3, bestend2);
 		} //end if
 		founddist = qtrue;
 	} //end else if
 	if (VectorBetweenVectors(p4, v1, v2))
 	{
 		dist = VectorDistance(v4, p4);
 		if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
 		{
 			dist1 = VectorDistance(beststart1, p4);
 			dist2 = VectorDistance(beststart2, p4);
 			if (dist1 > dist2)
 			{
 				if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(p4, beststart2);
 			} //end if
 			else
 			{
 				if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(p4, beststart1);
 			} //end else
 			dist1 = VectorDistance(bestend1, v4);
 			dist2 = VectorDistance(bestend2, v4);
 			if (dist1 > dist2)
 			{
 				if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(v4, bestend2);
 			} //end if
 			else
 			{
 				if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(v4, bestend1);
 			} //end else
 		} //end if
 		else if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(p4, beststart1);
 			VectorCopy(p4, beststart2);
 			VectorCopy(v4, bestend1);
 			VectorCopy(v4, bestend2);
 		} //end if
 		founddist = qtrue;
 	} //end else if
 	//if no shortest distance was found the shortest distance
 	//is between one of the vertexes of edge1 and one of edge2
 	if (!founddist)
 	{
 		dist = VectorDistance(v1, v3);
 		if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v1, beststart1);
 			VectorCopy(v1, beststart2);
 			VectorCopy(v3, bestend1);
 			VectorCopy(v3, bestend2);
 		} //end if
 		dist = VectorDistance(v1, v4);
 		if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v1, beststart1);
 			VectorCopy(v1, beststart2);
 			VectorCopy(v4, bestend1);
 			VectorCopy(v4, bestend2);
 		} //end if
 		dist = VectorDistance(v2, v3);
 		if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v2, beststart1);
 			VectorCopy(v2, beststart2);
 			VectorCopy(v3, bestend1);
 			VectorCopy(v3, bestend2);
 		} //end if
 		dist = VectorDistance(v2, v4);
 		if (dist < bestdist)
 		{
 			bestdist = dist;
 			VectorCopy(v2, beststart1);
 			VectorCopy(v2, beststart2);
 			VectorCopy(v4, bestend1);
 			VectorCopy(v4, bestend2);
 		} //end if
 	} //end if
 	return bestdist;
 } //end of the function AAS_ClosestEdgePoints
 //===========================================================================
 // creates possible jump reachabilities between the areas
 //
 // The two closest points on the ground of the areas are calculated
 // One of the points will be on an edge of a ground face of area1 and
 // one on an edge of a ground face of area2.
 // If there is a range of closest points the point in the middle of this range
 // is selected.
 // Between these two points there must be one or more gaps.
 // If the gaps exist a potential jump is predicted.
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_Reachability_Jump(int area1num, int area2num)
 {
 	int i, j, k, l, face1num, face2num, edge1num, edge2num, traveltype;
 	int stopevent, areas[10], numareas;
 	float phys_jumpvel, maxjumpdistance, maxjumpheight, height, bestdist, speed;
 	vec_t *v1, *v2, *v3, *v4;
 	vec3_t beststart, beststart2, bestend, bestend2;
 	vec3_t teststart, testend, dir, velocity, cmdmove, up = {0, 0, 1}, sidewards;
 	aas_area_t *area1, *area2;
 	aas_face_t *face1, *face2;
 	aas_edge_t *edge1, *edge2;
 	aas_plane_t *plane1, *plane2, *plane;
 	aas_trace_t trace;
 	aas_clientmove_t move;
 	aas_lreachability_t *lreach;
 
 	if (!AAS_AreaGrounded(area1num) || !AAS_AreaGrounded(area2num)) return qfalse;
 	//cannot jump from or to a crouch area
 	if (AAS_AreaCrouch(area1num) || AAS_AreaCrouch(area2num)) return qfalse;
 	//
 	area1 = &aasworld.areas[area1num];
 	area2 = &aasworld.areas[area2num];
 	//
 	phys_jumpvel = aassettings.phys_jumpvel;
 	//maximum distance a player can jump
 	maxjumpdistance = 2 * AAS_MaxJumpDistance(phys_jumpvel);
 	//maximum height a player can jump with the given initial z velocity
 	maxjumpheight = AAS_MaxJumpHeight(phys_jumpvel);
 
 	//if the areas are not near anough in the x-y direction
 	for (i = 0; i < 2; i++)
 	{
 		if (area1->mins[i] > area2->maxs[i] + maxjumpdistance) return qfalse;
 		if (area1->maxs[i] < area2->mins[i] - maxjumpdistance) return qfalse;
 	} //end for
 	//if area2 is way to high to jump up to
 	if (area2->mins[2] > area1->maxs[2] + maxjumpheight) return qfalse;
 	//
 	bestdist = 999999;
 	//
 	for (i = 0; i < area1->numfaces; i++)
 	{
 		face1num = aasworld.faceindex[area1->firstface + i];
 		face1 = &aasworld.faces[abs(face1num)];
 		//if not a ground face
 		if (!(face1->faceflags & FACE_GROUND)) continue;
 		//
 		for (j = 0; j < area2->numfaces; j++)
 		{
 			face2num = aasworld.faceindex[area2->firstface + j];
 			face2 = &aasworld.faces[abs(face2num)];
 			//if not a ground face
 			if (!(face2->faceflags & FACE_GROUND)) continue;
 			//
 			for (k = 0; k < face1->numedges; k++)
 			{
 				edge1num = abs(aasworld.edgeindex[face1->firstedge + k]);
 				edge1 = &aasworld.edges[edge1num];
 				for (l = 0; l < face2->numedges; l++)
 				{
 					edge2num = abs(aasworld.edgeindex[face2->firstedge + l]);
 					edge2 = &aasworld.edges[edge2num];
 					//calculate the minimum distance between the two edges
 					v1 = aasworld.vertexes[edge1->v[0]];
 					v2 = aasworld.vertexes[edge1->v[1]];
 					v3 = aasworld.vertexes[edge2->v[0]];
 					v4 = aasworld.vertexes[edge2->v[1]];
 					//get the ground planes
 					plane1 = &aasworld.planes[face1->planenum];
 					plane2 = &aasworld.planes[face2->planenum];
 					//
 					bestdist = AAS_ClosestEdgePoints(v1, v2, v3, v4, plane1, plane2,
 														beststart, bestend,
 														beststart2, bestend2, bestdist);
 				} //end for
 			} //end for
 		} //end for
 	} //end for
 	VectorMiddle(beststart, beststart2, beststart);
 	VectorMiddle(bestend, bestend2, bestend);
 	if (bestdist > 4 && bestdist < maxjumpdistance)
 	{
 //		Log_Write("shortest distance between %d and %d is %f\r\n", area1num, area2num, bestdist);
 		// if very close and almost no height difference then the bot can walk
 		if (bestdist <= 48 && fabs(beststart[2] - bestend[2]) < 8)
 		{
 			speed = 400;
 			traveltype = TRAVEL_WALKOFFLEDGE;
 		} //end if
 		else if (AAS_HorizontalVelocityForJump(0, beststart, bestend, &speed))
 		{
 			//FIXME: why multiply with 1.2???
 			speed *= 1.2f;
 			traveltype = TRAVEL_WALKOFFLEDGE;
 		} //end else if
 		else
 		{
 			//get the horizontal speed for the jump, if it isn't possible to calculate this
 			//speed (the jump is not possible) then there's no jump reachability created
 			if (!AAS_HorizontalVelocityForJump(phys_jumpvel, beststart, bestend, &speed))
 				return qfalse;
 			speed *= 1.05f;
 			traveltype = TRAVEL_JUMP;
 			//
 			//NOTE: test if the horizontal distance isn't too small
 			VectorSubtract(bestend, beststart, dir);
 			dir[2] = 0;
 			if (VectorLength(dir) < 10)
 				return qfalse;
 		} //end if
 		//
 		VectorSubtract(bestend, beststart, dir);
 		VectorNormalize(dir);
 		VectorMA(beststart, 1, dir, teststart);
 		//
 		VectorCopy(teststart, testend);
 		testend[2] -= 100;
 		trace = AAS_TraceClientBBox(teststart, testend, PRESENCE_NORMAL, -1);
 		//
 		if (trace.startsolid)
 			return qfalse;
 		if (trace.fraction < 1)
 		{
 			plane = &aasworld.planes[trace.planenum];
 			// if the bot can stand on the surface
 			if (DotProduct(plane->normal, up) >= 0.7)
 			{
 				// if no lava or slime below
 				if (!(AAS_PointContents(trace.endpos) & (CONTENTS_LAVA|CONTENTS_SLIME)))
 				{
 					if (teststart[2] - trace.endpos[2] <= aassettings.phys_maxbarrier)
 						return qfalse;
 				} //end if
 			} //end if
 		} //end if
 		//
 		VectorMA(bestend, -1, dir, teststart);
 		//
 		VectorCopy(teststart, testend);
 		testend[2] -= 100;
 		trace = AAS_TraceClientBBox(teststart, testend, PRESENCE_NORMAL, -1);
 		//
 		if (trace.startsolid)
 			return qfalse;
 		if (trace.fraction < 1)
 		{
 			plane = &aasworld.planes[trace.planenum];
 			// if the bot can stand on the surface
 			if (DotProduct(plane->normal, up) >= 0.7)
 			{
 				// if no lava or slime below
 				if (!(AAS_PointContents(trace.endpos) & (CONTENTS_LAVA|CONTENTS_SLIME)))
 				{
 					if (teststart[2] - trace.endpos[2] <= aassettings.phys_maxbarrier)
 						return qfalse;
 				} //end if
 			} //end if
 		} //end if
 		//
 		// get command movement
 		VectorClear(cmdmove);
 		if ((traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMP)
 			cmdmove[2] = aassettings.phys_jumpvel;
 		else
 			cmdmove[2] = 0;
 		//
 		VectorSubtract(bestend, beststart, dir);
 		dir[2] = 0;
 		VectorNormalize(dir);
 		CrossProduct(dir, up, sidewards);
 		//
 		stopevent = SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE;
 		if (!AAS_AreaClusterPortal(area1num) && !AAS_AreaClusterPortal(area2num))
 			stopevent |= SE_TOUCHCLUSTERPORTAL;
 		//
 		for (i = 0; i < 3; i++)
 		{
 			//
 			if (i == 1)
 				VectorAdd(testend, sidewards, testend);
 			else if (i == 2)
 				VectorSubtract(bestend, sidewards, testend);
 			else
 				VectorCopy(bestend, testend);
 			VectorSubtract(testend, beststart, dir);
 			dir[2] = 0;
 			VectorNormalize(dir);
 			VectorScale(dir, speed, velocity);
 			//
 			AAS_PredictClientMovement(&move, -1, beststart, PRESENCE_NORMAL, qtrue,
 										velocity, cmdmove, 3, 30, 0.1f,
 										stopevent, 0, qfalse);
 			// if prediction time wasn't enough to fully predict the movement
 			if (move.frames >= 30)
 				return qfalse;
 			// don't enter slime or lava and don't fall from too high
 			if (move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA))
 				return qfalse;
 			// never jump or fall through a cluster portal
 			if (move.stopevent & SE_TOUCHCLUSTERPORTAL)
 				return qfalse;
 			//the end position should be in area2, also test a little bit back
 			//because the predicted jump could have rushed through the area
 			VectorMA(move.endpos, -64, dir, teststart);
 			teststart[2] += 1;
 			numareas = AAS_TraceAreas(move.endpos, teststart, areas, NULL, sizeof(areas) / sizeof(int));
 			for (j = 0; j < numareas; j++)
 			{
 				if (areas[j] == area2num)
 					break;
 			} //end for
 			if (j < numareas)
 				break;
 		}
 		if (i >= 3)
 			return qfalse;
 		//
 #ifdef REACH_DEBUG
 		//create the reachability
 		Log_Write("jump reachability between %d and %d\r\n", area1num, area2num);
 #endif //REACH_DEBUG
 		//create a new reachability link
 		lreach = AAS_AllocReachability();
 		if (!lreach) return qfalse;
 		lreach->areanum = area2num;
 		lreach->facenum = 0;
 		lreach->edgenum = 0;
 		VectorCopy(beststart, lreach->start);
 		VectorCopy(bestend, lreach->end);
 		lreach->traveltype = traveltype;
 
 		VectorSubtract(bestend, beststart, dir);
 		height = dir[2];
 		dir[2] = 0;
 		if ((traveltype & TRAVELTYPE_MASK) == TRAVEL_WALKOFFLEDGE && height > VectorLength(dir))
 		{
 			lreach->traveltime = aassettings.rs_startwalkoffledge + height * 50 / aassettings.phys_gravity;
 		}
 		else
 		{
 			lreach->traveltime = aassettings.rs_startjump + VectorDistance(bestend, beststart) * 240 / aassettings.phys_maxwalkvelocity;
 		} //end if
 		//
 		if (!AAS_AreaJumpPad(area2num))
 		{
 			if (AAS_FallDelta(beststart[2] - bestend[2]) > aassettings.phys_falldelta5)
 			{
 				lreach->traveltime += aassettings.rs_falldamage5;
 			} //end if
 			else if (AAS_FallDelta(beststart[2] - bestend[2]) > aassettings.phys_falldelta10)
 			{
 				lreach->traveltime += aassettings.rs_falldamage10;
 			} //end if
 		} //end if
 		lreach->next = areareachability[area1num];
 		areareachability[area1num] = lreach;
 		//
 		if ((traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMP)
 			reach_jump++;
 		else
 			reach_walkoffledge++;
 	} //end if
 	return qfalse;
 } //end of the function AAS_Reachability_Jump
 //===========================================================================
 // create a possible ladder reachability from area1 to area2
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_Reachability_Ladder(int area1num, int area2num)
 {
 	int i, j, k, l, edge1num, edge2num, sharededgenum, lowestedgenum;
 	int face1num, face2num, ladderface1num, ladderface2num;
 	int ladderface1vertical, ladderface2vertical, firstv;
 	float face1area, face2area, bestface1area, bestface2area;
 	float phys_jumpvel, maxjumpheight;
 	vec3_t area1point, area2point, v1, v2, up = {0, 0, 1};
 	vec3_t mid, lowestpoint, start, end, sharededgevec, dir;
 	aas_area_t *area1, *area2;
 	aas_face_t *face1, *face2, *ladderface1, *ladderface2;
 	aas_plane_t *plane1, *plane2;
 	aas_edge_t *sharededge, *edge1;
 	aas_lreachability_t *lreach;
 	aas_trace_t trace;
 
 	if (!AAS_AreaLadder(area1num) || !AAS_AreaLadder(area2num)) return qfalse;
 	//
 	phys_jumpvel = aassettings.phys_jumpvel;
 	//maximum height a player can jump with the given initial z velocity
 	maxjumpheight = AAS_MaxJumpHeight(phys_jumpvel);
 
 	area1 = &aasworld.areas[area1num];
 	area2 = &aasworld.areas[area2num];
 	//
 	ladderface1 = NULL;
 	ladderface2 = NULL;
 	ladderface1num = 0; //make compiler happy
 	ladderface2num = 0; //make compiler happy
 	bestface1area = -9999;
 	bestface2area = -9999;
 	sharededgenum = 0; //make compiler happy
 	lowestedgenum = 0; //make compiler happy
 	//
 	for (i = 0; i < area1->numfaces; i++)
 	{
 		face1num = aasworld.faceindex[area1->firstface + i];
 		face1 = &aasworld.faces[abs(face1num)];
 		//if not a ladder face
 		if (!(face1->faceflags & FACE_LADDER)) continue;
 		//
 		for (j = 0; j < area2->numfaces; j++)
 		{
 			face2num = aasworld.faceindex[area2->firstface + j];
 			face2 = &aasworld.faces[abs(face2num)];
 			//if not a ladder face
 			if (!(face2->faceflags & FACE_LADDER)) continue;
 			//check if the faces share an edge
 			for (k = 0; k < face1->numedges; k++)
 			{
 				edge1num = aasworld.edgeindex[face1->firstedge + k];
 				for (l = 0; l < face2->numedges; l++)
 				{
 					edge2num = aasworld.edgeindex[face2->firstedge + l];
 					if (abs(edge1num) == abs(edge2num))
 					{
 						//get the face with the largest area
 						face1area = AAS_FaceArea(face1);
 						face2area = AAS_FaceArea(face2);
 						if (face1area > bestface1area && face2area > bestface2area)
 						{
 							bestface1area = face1area;
 							bestface2area = face2area;
 							ladderface1 = face1;
 							ladderface2 = face2;
 							ladderface1num = face1num;
 							ladderface2num = face2num;
 							sharededgenum = edge1num;
 						} //end if
 						break;
 					} //end if
 				} //end for
 				if (l != face2->numedges) break;
 			} //end for
 		} //end for
 	} //end for
 	//
 	if (ladderface1 && ladderface2)
 	{
 		//get the middle of the shared edge
 		sharededge = &aasworld.edges[abs(sharededgenum)];
 		firstv = sharededgenum < 0;
 		//
 		VectorCopy(aasworld.vertexes[sharededge->v[firstv]], v1);
 		VectorCopy(aasworld.vertexes[sharededge->v[!firstv]], v2);
 		VectorAdd(v1, v2, area1point);
 		VectorScale(area1point, 0.5, area1point);
 		VectorCopy(area1point, area2point);
 		//
 		//if the face plane in area 1 is pretty much vertical
 		plane1 = &aasworld.planes[ladderface1->planenum ^ (ladderface1num < 0)];
 		plane2 = &aasworld.planes[ladderface2->planenum ^ (ladderface2num < 0)];
 		//
 		//get the points really into the areas
 		VectorSubtract(v2, v1, sharededgevec);
 		CrossProduct(plane1->normal, sharededgevec, dir);
 		VectorNormalize(dir);
 		//NOTE: 32 because that's larger than 16 (bot bbox x,y)
 		VectorMA(area1point, -32, dir, area1point);
 		VectorMA(area2point, 32, dir, area2point);
 		//
 		ladderface1vertical = abs(DotProduct(plane1->normal, up)) < 0.1;
 		ladderface2vertical = abs(DotProduct(plane2->normal, up)) < 0.1;
 		//there's only reachability between vertical ladder faces
 		if (!ladderface1vertical && !ladderface2vertical) return qfalse;
 		//if both vertical ladder faces
 		if (ladderface1vertical && ladderface2vertical
 					//and the ladder faces do not make a sharp corner
 					&& DotProduct(plane1->normal, plane2->normal) > 0.7
 					//and the shared edge is not too vertical
 					&& abs(DotProduct(sharededgevec, up)) < 0.7)
 		{
 			//create a new reachability link
 			lreach = AAS_AllocReachability();
 			if (!lreach) return qfalse;
 			lreach->areanum = area2num;
 			lreach->facenum = ladderface1num;
 			lreach->edgenum = abs(sharededgenum);
 			VectorCopy(area1point, lreach->start);
 			//VectorCopy(area2point, lreach->end);
 			VectorMA(area2point, -3, plane1->normal, lreach->end);
 			lreach->traveltype = TRAVEL_LADDER;
 			lreach->traveltime = 10;
 			lreach->next = areareachability[area1num];
 			areareachability[area1num] = lreach;
 			//
 			reach_ladder++;
 			//create a new reachability link
 			lreach = AAS_AllocReachability();
 			if (!lreach) return qfalse;
 			lreach->areanum = area1num;
 			lreach->facenum = ladderface2num;
 			lreach->edgenum = abs(sharededgenum);
 			VectorCopy(area2point, lreach->start);
 			//VectorCopy(area1point, lreach->end);
 			VectorMA(area1point, -3, plane1->normal, lreach->end);
 			lreach->traveltype = TRAVEL_LADDER;
 			lreach->traveltime = 10;
 			lreach->next = areareachability[area2num];
 			areareachability[area2num] = lreach;
 			//
 			reach_ladder++;
 			//
 			return qtrue;
 		} //end if
 		//if the second ladder face is also a ground face
 		//create ladder end (just ladder) reachability and
 		//walk off a ladder (ledge) reachability
 		if (ladderface1vertical && (ladderface2->faceflags & FACE_GROUND))
 		{
 			//create a new reachability link
 			lreach = AAS_AllocReachability();
 			if (!lreach) return qfalse;
 			lreach->areanum = area2num;
 			lreach->facenum = ladderface1num;
 			lreach->edgenum = abs(sharededgenum);
 			VectorCopy(area1point, lreach->start);
 			VectorCopy(area2point, lreach->end);
 			lreach->end[2] += 16;
 			VectorMA(lreach->end, -15, plane1->normal, lreach->end);
 			lreach->traveltype = TRAVEL_LADDER;
 			lreach->traveltime = 10;
 			lreach->next = areareachability[area1num];
 			areareachability[area1num] = lreach;
 			//
 			reach_ladder++;
 			//create a new reachability link
 			lreach = AAS_AllocReachability();
 			if (!lreach) return qfalse;
 			lreach->areanum = area1num;
 			lreach->facenum = ladderface2num;
 			lreach->edgenum = abs(sharededgenum);
 			VectorCopy(area2point, lreach->start);
 			VectorCopy(area1point, lreach->end);
 			lreach->traveltype = TRAVEL_WALKOFFLEDGE;
 			lreach->traveltime = 10;
 			lreach->next = areareachability[area2num];
 			areareachability[area2num] = lreach;
 			//
 			reach_walkoffledge++;
 			//
 			return qtrue;
 		} //end if
 		//
 		if (ladderface1vertical)
 		{
 			//find lowest edge of the ladder face
 			lowestpoint[2] = 99999;
 			for (i = 0; i < ladderface1->numedges; i++)
 			{
 				edge1num = abs(aasworld.edgeindex[ladderface1->firstedge + i]);
 				edge1 = &aasworld.edges[edge1num];
 				//
 				VectorCopy(aasworld.vertexes[edge1->v[0]], v1);
 				VectorCopy(aasworld.vertexes[edge1->v[1]], v2);
 				//
 				VectorAdd(v1, v2, mid);
 				VectorScale(mid, 0.5, mid);
 				//
 				if (mid[2] < lowestpoint[2])
 				{
 					VectorCopy(mid, lowestpoint);
 					lowestedgenum = edge1num;
 				} //end if
 			} //end for
 			//
 			plane1 = &aasworld.planes[ladderface1->planenum];
 			//trace down in the middle of this edge
 			VectorMA(lowestpoint, 5, plane1->normal, start);
 			VectorCopy(start, end);
 			start[2] += 5;
 			end[2] -= 100;
 			//trace without entity collision
 			trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
 			//
 			//
 #ifdef REACH_DEBUG
 			if (trace.startsolid)
 			{
 				Log_Write("trace from area %d started in solid\r\n", area1num);
 			} //end if
 #endif //REACH_DEBUG
 			//
 			trace.endpos[2] += 1;
 			area2num = AAS_PointAreaNum(trace.endpos);
 			//
 			area2 = &aasworld.areas[area2num];
 			for (i = 0; i < area2->numfaces; i++)
 			{
 				face2num = aasworld.faceindex[area2->firstface + i];
 				face2 = &aasworld.faces[abs(face2num)];
 				//
 				if (face2->faceflags & FACE_LADDER)
 				{
 					plane2 = &aasworld.planes[face2->planenum];
 					if (abs(DotProduct(plane2->normal, up)) < 0.1) break;
 				} //end if
 			} //end for
 			//if from another area without vertical ladder faces
 			if (i >= area2->numfaces && area2num != area1num &&
 						//the reachabilities shouldn't exist already
 						!AAS_ReachabilityExists(area1num, area2num) &&
 						!AAS_ReachabilityExists(area2num, area1num))
 			{
 				//if the height is jumpable
 				if (start[2] - trace.endpos[2] < maxjumpheight)
 				{
 					//create a new reachability link
 					lreach = AAS_AllocReachability();
 					if (!lreach) return qfalse;
 					lreach->areanum = area2num;
 					lreach->facenum = ladderface1num;
 					lreach->edgenum = lowestedgenum;
 					VectorCopy(lowestpoint, lreach->start);
 					VectorCopy(trace.endpos, lreach->end);
 					lreach->traveltype = TRAVEL_LADDER;
 					lreach->traveltime = 10;
 					lreach->next = areareachability[area1num];
 					areareachability[area1num] = lreach;
 					//
 					reach_ladder++;
 					//create a new reachability link
 					lreach = AAS_AllocReachability();
 					if (!lreach) return qfalse;
 					lreach->areanum = area1num;
 					lreach->facenum = ladderface1num;
 					lreach->edgenum = lowestedgenum;
 					VectorCopy(trace.endpos, lreach->start);
 					//get the end point a little bit into the ladder
 					VectorMA(lowestpoint, -5, plane1->normal, lreach->end);
 					//get the end point a little higher
 					lreach->end[2] += 10;
 					lreach->traveltype = TRAVEL_JUMP;
 					lreach->traveltime = 10;
 					lreach->next = areareachability[area2num];
 					areareachability[area2num] = lreach;
 					//
 					reach_jump++;	
 					//
 					return qtrue;
 #ifdef REACH_DEBUG
 					Log_Write("jump up to ladder reach between %d and %d\r\n", area2num, area1num);
 #endif //REACH_DEBUG
 				} //end if
 #ifdef REACH_DEBUG
 				else Log_Write("jump too high between area %d and %d\r\n", area2num, area1num);
 #endif //REACH_DEBUG
 			} //end if
 			/*//if slime or lava below the ladder
 			//try jump reachability from far towards the ladder
 			if (aasworld.areasettings[area2num].contents & (AREACONTENTS_SLIME
 													| AREACONTENTS_LAVA))
 			{
 				for (i = 20; i <= 120; i += 20)
 				{
 					//trace down in the middle of this edge
 					VectorMA(lowestpoint, i, plane1->normal, start);
 					VectorCopy(start, end);
 					start[2] += 5;
 					end[2] -= 100;
 					//trace without entity collision
 					trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
 					//
 					if (trace.startsolid) break;
 					trace.endpos[2] += 1;
 					area2num = AAS_PointAreaNum(trace.endpos);
 					if (area2num == area1num) continue;
 					//
 					if (start[2] - trace.endpos[2] > maxjumpheight) continue;
 					if (aasworld.areasettings[area2num].contents & (AREACONTENTS_SLIME
 												| AREACONTENTS_LAVA)) continue;
 					//
 					//create a new reachability link
 					lreach = AAS_AllocReachability();
 					if (!lreach) return qfalse;
 					lreach->areanum = area1num;
 					lreach->facenum = ladderface1num;
 					lreach->edgenum = lowestedgenum;
 					VectorCopy(trace.endpos, lreach->start);
 					VectorCopy(lowestpoint, lreach->end);
 					lreach->end[2] += 5;
 					lreach->traveltype = TRAVEL_JUMP;
 					lreach->traveltime = 10;
 					lreach->next = areareachability[area2num];
 					areareachability[area2num] = lreach;
 					//
 					reach_jump++;
 					//
 					Log_Write("jump far to ladder reach between %d and %d\r\n", area2num, area1num);
 					//
 					break;
 				} //end for
 			} //end if*/
 		} //end if
 	} //end if
 	return qfalse;
 } //end of the function AAS_Reachability_Ladder
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 int AAS_TravelFlagsForTeam(int ent)
 {
 	int notteam;
 
 	if (!AAS_IntForBSPEpairKey(ent, "bot_notteam", &notteam))
 		return 0;
 	if (notteam == 1)
 		return TRAVELFLAG_NOTTEAM1;
 	if (notteam == 2)
 		return TRAVELFLAG_NOTTEAM2;
 	return 0;
 } //end of the function AAS_TravelFlagsForTeam
 //===========================================================================
 // create possible teleporter reachabilities
 // this is very game dependent.... :(
 //
 // classname = trigger_multiple or trigger_teleport
 // target = "t1"
 //
 // classname = target_teleporter
 // targetname = "t1"
 // target = "t2"
 //
 // classname = misc_teleporter_dest
 // targetname = "t2"
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_Reachability_Teleport(void)
 {
 	int area1num, area2num;
 	char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY];
 	char classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
 	int ent, dest;
 	float angle;
 	vec3_t origin, destorigin, mins, maxs, end, angles;
 	vec3_t mid, velocity, cmdmove;
 	aas_lreachability_t *lreach;
 	aas_clientmove_t move;
 	aas_trace_t trace;
 	aas_link_t *areas, *link;
 
 	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
 	{
 		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
 		if (!strcmp(classname, "trigger_multiple"))
 		{
 			AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
 //#ifdef REACH_DEBUG
 			botimport.Print(PRT_MESSAGE, "trigger_multiple model = \"%s\"\n", model);
 //#endif REACH_DEBUG
 			VectorClear(angles);
 			AAS_BSPModelMinsMaxsOrigin(atoi(model+1), angles, mins, maxs, origin);
 			//
 			if (!AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY))
 			{
 				botimport.Print(PRT_ERROR, "trigger_multiple at %1.0f %1.0f %1.0f without target\n",
 									origin[0], origin[1], origin[2]);
 				continue;
 			} //end if
 			for (dest = AAS_NextBSPEntity(0); dest; dest = AAS_NextBSPEntity(dest))
 			{
 				if (!AAS_ValueForBSPEpairKey(dest, "classname", classname, MAX_EPAIRKEY)) continue;
 				if (!strcmp(classname, "target_teleporter"))
 				{
 					if (!AAS_ValueForBSPEpairKey(dest, "targetname", targetname, MAX_EPAIRKEY)) continue;
 					if (!strcmp(targetname, target))
 					{
 						break;
 					} //end if
 				} //end if
 			} //end for
 			if (!dest)
 			{
 				continue;
 			} //end if
 			if (!AAS_ValueForBSPEpairKey(dest, "target", target, MAX_EPAIRKEY))
 			{
 				botimport.Print(PRT_ERROR, "target_teleporter without target\n");
 				continue;
 			} //end if
 		} //end else
 		else if (!strcmp(classname, "trigger_teleport"))
 		{
 			AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
 //#ifdef REACH_DEBUG
 			botimport.Print(PRT_MESSAGE, "trigger_teleport model = \"%s\"\n", model);
 //#endif REACH_DEBUG
 			VectorClear(angles);
 			AAS_BSPModelMinsMaxsOrigin(atoi(model+1), angles, mins, maxs, origin);
 			//
 			if (!AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY))
 			{
 				botimport.Print(PRT_ERROR, "trigger_teleport at %1.0f %1.0f %1.0f without target\n",
 									origin[0], origin[1], origin[2]);
 				continue;
 			} //end if
 		} //end if
 		else
 		{
 			continue;
 		} //end else
 		//
 		for (dest = AAS_NextBSPEntity(0); dest; dest = AAS_NextBSPEntity(dest))
 		{
 			//classname should be misc_teleporter_dest
 			//but I've also seen target_position and actually any
 			//entity could be used... burp
 			if (AAS_ValueForBSPEpairKey(dest, "targetname", targetname, MAX_EPAIRKEY))
 			{
 				if (!strcmp(targetname, target))
 				{
 					break;
 				} //end if
 			} //end if
 		} //end for
 		if (!dest)
 		{
 			botimport.Print(PRT_ERROR, "teleporter without misc_teleporter_dest (%s)\n", target);
 			continue;
 		} //end if
 		if (!AAS_VectorForBSPEpairKey(dest, "origin", destorigin))
 		{
 			botimport.Print(PRT_ERROR, "teleporter destination (%s) without origin\n", target);
 			continue;
 		} //end if
 		//
 		area2num = AAS_PointAreaNum(destorigin);
 		//if not teleported into a teleporter or into a jumppad
 		if (!AAS_AreaTeleporter(area2num) && !AAS_AreaJumpPad(area2num))
 		{
 			VectorCopy(destorigin, end);
 			end[2] -= 64;
 			trace = AAS_TraceClientBBox(destorigin, end, PRESENCE_CROUCH, -1);
 			if (trace.startsolid)
 			{
 				botimport.Print(PRT_ERROR, "teleporter destination (%s) in solid\n", target);
 				continue;
 			} //end if
 			area2num = AAS_PointAreaNum(trace.endpos);
 			//
 			/*
 			if (!AAS_AreaTeleporter(area2num) &&
 				!AAS_AreaJumpPad(area2num) &&
 				!AAS_AreaGrounded(area2num))
 			{
 				VectorCopy(trace.endpos, destorigin);
 			}
 			else*/
 			{
 				//predict where you'll end up
 				AAS_FloatForBSPEpairKey(dest, "angle", &angle);
 				if (angle)
 				{
 					VectorSet(angles, 0, angle, 0);
 					AngleVectors(angles, velocity, NULL, NULL);
 					VectorScale(velocity, 400, velocity);
 				} //end if
 				else
 				{
 					VectorClear(velocity);
 				} //end else
 				VectorClear(cmdmove);
 				AAS_PredictClientMovement(&move, -1, destorigin, PRESENCE_NORMAL, qfalse,
 										velocity, cmdmove, 0, 30, 0.1f,
 										SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME|
 										SE_ENTERLAVA|SE_HITGROUNDDAMAGE|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER, 0, qfalse); //qtrue);
 				area2num = AAS_PointAreaNum(move.endpos);
 				if (move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA))
 				{
 					botimport.Print(PRT_WARNING, "teleported into slime or lava at dest %s\n", target);
 				} //end if
 				VectorCopy(move.endpos, destorigin);
 			} //end else
 		} //end if
 		//
 		//botimport.Print(PRT_MESSAGE, "teleporter brush origin at %f %f %f\n", origin[0], origin[1], origin[2]);
 		//botimport.Print(PRT_MESSAGE, "teleporter brush mins = %f %f %f\n", mins[0], mins[1], mins[2]);
 		//botimport.Print(PRT_MESSAGE, "teleporter brush maxs = %f %f %f\n", maxs[0], maxs[1], maxs[2]);
 		VectorAdd(origin, mins, mins);
 		VectorAdd(origin, maxs, maxs);
 		//
 		VectorAdd(mins, maxs, mid);
 		VectorScale(mid, 0.5, mid);
 		//link an invalid (-1) entity
 		areas = AAS_LinkEntityClientBBox(mins, maxs, -1, PRESENCE_CROUCH);
 		if (!areas) botimport.Print(PRT_MESSAGE, "trigger_multiple not in any area\n");
 		//
 		for (link = areas; link; link = link->next_area)
 		{
 			//if (!AAS_AreaGrounded(link->areanum)) continue;
 			if (!AAS_AreaTeleporter(link->areanum)) continue;
 			//
 			area1num = link->areanum;
 			//create a new reachability link
 			lreach = AAS_AllocReachability();
 			if (!lreach) break;
 			lreach->areanum = area2num;
 			lreach->facenum = 0;
 			lreach->edgenum = 0;
 			VectorCopy(mid, lreach->start);
 			VectorCopy(destorigin, lreach->end);
 			lreach->traveltype = TRAVEL_TELEPORT;
 			lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
 			lreach->traveltime = aassettings.rs_teleport;
 			lreach->next = areareachability[area1num];
 			areareachability[area1num] = lreach;
 			//
 			reach_teleport++;
 		} //end for
 		//unlink the invalid entity
 		AAS_UnlinkFromAreas(areas);
 	} //end for
 } //end of the function AAS_Reachability_Teleport
 //===========================================================================
 // create possible elevator (func_plat) reachabilities
 // this is very game dependent.... :(
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 void AAS_Reachability_Elevator(void)
 {
 	int area1num, area2num, modelnum, i, j, k, l, n, p;
 	float lip, height, speed;
 	char model[MAX_EPAIRKEY], classname[MAX_EPAIRKEY];
 	int ent;
 	vec3_t mins, maxs, origin, angles = {0, 0, 0};
 	vec3_t pos1, pos2, mids, platbottom, plattop;
 	vec3_t bottomorg, toporg, start, end, dir;
 	vec_t xvals[8], yvals[8], xvals_top[8], yvals_top[8];
 	aas_lreachability_t *lreach;
 	aas_trace_t trace;
 
 #ifdef REACH_DEBUG
 	Log_Write("AAS_Reachability_Elevator\r\n");
 #endif //REACH_DEBUG
 	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
 	{
 		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
 		if (!strcmp(classname, "func_plat"))
 		{
 #ifdef REACH_DEBUG
 			Log_Write("found func plat\r\n");
 #endif //REACH_DEBUG
 			if (!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY))
 			{
 				botimport.Print(PRT_ERROR, "func_plat without model\n");
 				continue;
 			} //end if
 			//get the model number, and skip the leading *
 			modelnum = atoi(model+1);
 			if (modelnum <= 0)
 			{
 				botimport.Print(PRT_ERROR, "func_plat with invalid model number\n");
 				continue;
 			} //end if
 			//get the mins, maxs and origin of the model
 			//NOTE: the origin is usually (0,0,0) and the mins and maxs
 			//      are the absolute mins and maxs
 			AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin);
 			//
 			AAS_VectorForBSPEpairKey(ent, "origin", origin);
 			//pos1 is the top position, pos2 is the bottom
 			VectorCopy(origin, pos1);
 			VectorCopy(origin, pos2);
 			//get the lip of the plat
 			AAS_FloatForBSPEpairKey(ent, "lip", &lip);
 			if (!lip) lip = 8;
 			//get the movement height of the plat
 			AAS_FloatForBSPEpairKey(ent, "height", &height);
 			if (!height) height = (maxs[2] - mins[2]) - lip;
 			//get the speed of the plat
 			AAS_FloatForBSPEpairKey(ent, "speed", &speed);
 			if (!speed) speed = 200;
 			//get bottom position below pos1
 			pos2[2] -= height;
 			//
 			//get a point just above the plat in the bottom position
 			VectorAdd(mins, maxs, mids);
 			VectorMA(pos2, 0.5, mids, platbottom);
 			platbottom[2] = maxs[2] - (pos1[2] - pos2[2]) + 2;
 			//get a point just above the plat in the top position
 			VectorAdd(mins, maxs, mids);
 			VectorMA(pos2, 0.5, mids, plattop);
 			plattop[2] = maxs[2] + 2;
 			//
 			/*if (!area1num)
 			{
 				Log_Write("no grounded area near plat bottom\r\n");
 				continue;
 			} //end if*/
 			//get the mins and maxs a little larger
 			for (i = 0; i < 3; i++)
 			{
 				mins[i] -= 1;
 				maxs[i] += 1;
 			} //end for
 			//
 			//botimport.Print(PRT_MESSAGE, "platbottom[2] = %1.1f plattop[2] = %1.1f\n", platbottom[2], plattop[2]);
 			//
 			VectorAdd(mins, maxs, mids);
 			VectorScale(mids, 0.5, mids);
 			//
 			xvals[0] = mins[0]; xvals[1] = mids[0]; xvals[2] = maxs[0]; xvals[3] = mids[0];
 			yvals[0] = mids[1]; yvals[1] = maxs[1]; yvals[2] = mids[1]; yvals[3] = mins[1];
 			//
 			xvals[4] = mins[0]; xvals[5] = maxs[0]; xvals[6] = maxs[0]; xvals[7] = mins[0];
 			yvals[4] = maxs[1]; yvals[5] = maxs[1]; yvals[6] = mins[1]; yvals[7] = mins[1];
 			//find adjacent areas around the bottom of the plat
 			for (i = 0; i < 9; i++)
 			{
 				if (i < 8) //check at the sides of the plat
 				{
 					bottomorg[0] = origin[0] + xvals[i];
 					bottomorg[1] = origin[1] + yvals[i];
 					bottomorg[2] = platbottom[2] + 16;
 					//get a grounded or swim area near the plat in the bottom position
 					area1num = AAS_PointAreaNum(bottomorg);
 					for (k = 0; k < 16; k++)
 					{
 						if (area1num)
 						{
 							if (AAS_AreaGrounded(area1num) || AAS_AreaSwim(area1num)) break;
 						} //end if
 						bottomorg[2] += 4;
 						area1num = AAS_PointAreaNum(bottomorg);
 					} //end if
 					//if in solid
 					if (k >= 16)
 					{
 						continue;
 					} //end if
 				} //end if
 				else //at the middle of the plat
 				{
 					VectorCopy(plattop, bottomorg);
 					bottomorg[2] += 24;
 					area1num = AAS_PointAreaNum(bottomorg);
 					if (!area1num) continue;
 					VectorCopy(platbottom, bottomorg);
 					bottomorg[2] += 24;
 				} //end else
 				//look at adjacent areas around the top of the plat
 				//make larger steps to outside the plat everytime
 				for (n = 0; n < 3; n++)
 				{
 					for (k = 0; k < 3; k++)
 					{
 						mins[k] -= 4;
 						maxs[k] += 4;
 					} //end for
 					xvals_top[0] = mins[0]; xvals_top[1] = mids[0]; xvals_top[2] = maxs[0]; xvals_top[3] = mids[0];
 					yvals_top[0] = mids[1]; yvals_top[1] = maxs[1]; yvals_top[2] = mids[1]; yvals_top[3] = mins[1];
 					//
 					xvals_top[4] = mins[0]; xvals_top[5] = maxs[0]; xvals_top[6] = maxs[0]; xvals_top[7] = mins[0];
 					yvals_top[4] = maxs[1]; yvals_top[5] = maxs[1]; yvals_top[6] = mins[1]; yvals_top[7] = mins[1];
 					//
 					for (j = 0; j < 8; j++)
 					{
 						toporg[0] = origin[0] + xvals_top[j];
 						toporg[1] = origin[1] + yvals_top[j];
 						toporg[2] = plattop[2] + 16;
 						//get a grounded or swim area near the plat in the top position
 						area2num = AAS_PointAreaNum(toporg);
 						for (l = 0; l < 16; l++)
 						{
 							if (area2num)
 							{
 								if (AAS_AreaGrounded(area2num) || AAS_AreaSwim(area2num))
 								{
 									VectorCopy(plattop, start);
 									start[2] += 32;
 									VectorCopy(toporg, end);
 									end[2] += 1;
 									trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
 									if (trace.fraction >= 1) break;
 								} //end if
 							} //end if
 							toporg[2] += 4;
 							area2num = AAS_PointAreaNum(toporg);
 						} //end if
 						//if in solid
 						if (l >= 16) continue;
 						//never create a reachability in the same area
 						if (area2num == area1num) continue;
 						//if the area isn't grounded
 						if (!AAS_AreaGrounded(area2num)) continue;
 						//if there already exists reachability between the areas
 						if (AAS_ReachabilityExists(area1num, area2num)) continue;
 						//if the reachability start is within the elevator bounding box
 						VectorSubtract(bottomorg, platbottom, dir);
 						VectorNormalize(dir);
 						dir[0] = bottomorg[0] + 24 * dir[0];
 						dir[1] = bottomorg[1] + 24 * dir[1];
 						dir[2] = bottomorg[2];
 						//
 						for (p = 0; p < 3; p++)
 							if (dir[p] < origin[p] + mins[p] || dir[p] > origin[p] + maxs[p]) break;
 						if (p >= 3) continue;
 						//create a new reachability link
 						lreach = AAS_AllocReachability();
 						if (!lreach) continue;
 						lreach->areanum = area2num;
 						//the facenum is the model number
 						lreach->facenum = modelnum;
 						//the edgenum is the height
 						lreach->edgenum = (int) height;
 						//
 						VectorCopy(dir, lreach->start);
 						VectorCopy(toporg, lreach->end);
 						lreach->traveltype = TRAVEL_ELEVATOR;
 						lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
 						lreach->traveltime = aassettings.rs_startelevator + height * 100 / speed;
 						lreach->next = areareachability[area1num];
 						areareachability[area1num] = lreach;
 						//don't go any further to the outside
 						n = 9999;
 						//
 #ifdef REACH_DEBUG
 						Log_Write("elevator reach from %d to %d\r\n", area1num, area2num);
 #endif //REACH_DEBUG
 						//
 						reach_elevator++;
 					} //end for
 				} //end for
 			} //end for
 		} //end if
 	} //end for
 } //end of the function AAS_Reachability_Elevator
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 aas_lreachability_t *AAS_FindFaceReachabilities(vec3_t *facepoints, int numpoints, aas_plane_t *plane, int towardsface)
 {
 	int i, j, k, l;
 	int facenum, edgenum, bestfacenum;
 	float *v1, *v2, *v3, *v4;
 	float bestdist, speed, hordist, dist;
 	vec3_t beststart, beststart2, bestend, bestend2, tmp, hordir, testpoint;
 	aas_lreachability_t *lreach, *lreachabilities;
 	aas_area_t *area;
 	aas_face_t *face;
 	aas_edge_t *edge;
 	aas_plane_t *faceplane, *bestfaceplane;
 
 	//
 	lreachabilities = NULL;
 	bestfacenum = 0;
 	bestfaceplane = NULL;
 	//
 	for (i = 1; i < aasworld.numareas; i++)
 	{
 		area = &aasworld.areas[i];
 		// get the shortest distance between one of the func_bob start edges and
 		// one of the face edges of area1
 		bestdist = 999999;
 		for (j = 0; j < area->numfaces; j++)
 		{
 			facenum = aasworld.faceindex[area->firstface + j];
 			face = &aasworld.faces[abs(facenum)];
 			//if not a ground face
 			if (!(face->faceflags & FACE_GROUND)) continue;
 			//get the ground planes
 			faceplane = &aasworld.planes[face->planenum];
 			//
 			for (k = 0; k < face->numedges; k++)
 			{
 				edgenum = abs(aasworld.edgeindex[face->firstedge + k]);
 				edge = &aasworld.edges[edgenum];
 				//calculate the minimum distance between the two edges
 				v1 = aasworld.vertexes[edge->v[0]];
 				v2 = aasworld.vertexes[edge->v[1]];
 				//
 				for (l = 0; l < numpoints; l++)
 				{
 					v3 = facepoints[l];
 					v4 = facepoints[(l+1) % numpoints];
 					dist = AAS_ClosestEdgePoints(v1, v2, v3, v4, faceplane, plane,
 													beststart, bestend,
 													beststart2, bestend2, bestdist);
 					if (dist < bestdist)
 					{
 						bestfacenum = facenum;
 						bestfaceplane = faceplane;
 						bestdist = dist;
 					} //end if
 				} //end for
 			} //end for
 		} //end for
 		//
 		if (bestdist > 192) continue;
 		//
 		VectorMiddle(beststart, beststart2, beststart);
 		VectorMiddle(bestend, bestend2, bestend);
 		//
 		if (!towardsface)
 		{
 			VectorCopy(beststart, tmp);
 			VectorCopy(bestend, beststart);
 			VectorCopy(tmp, bestend);
 		} //end if
 		//
 		VectorSubtract(bestend, beststart, hordir);
 		hordir[2] = 0;
 		hordist = VectorLength(hordir);
 		//
 		if (hordist > 2 * AAS_MaxJumpDistance(aassettings.phys_jumpvel)) continue;
 		//the end point should not be significantly higher than the start point
 		if (bestend[2] - 32 > beststart[2]) continue;
 		//don't fall down too far
 		if (bestend[2] < beststart[2] - 128) continue;
 		//the distance should not be too far
 		if (hordist > 32)
 		{
 			//check for walk off ledge
 			if (!AAS_HorizontalVelocityForJump(0, beststart, bestend, &speed)) continue;
 		} //end if
 		//
 		beststart[2] += 1;
 		bestend[2] += 1;
 		//
 		if (towardsface) VectorCopy(bestend, testpoint);
 		else VectorCopy(beststart, testpoint);
 		testpoint[2] = 0;
 		testpoint[2] = (bestfaceplane->dist - DotProduct(bestfaceplane->normal, testpoint)) / bestfaceplane->normal[2];
 		//
 		if (!AAS_PointInsideFace(bestfacenum, testpoint, 0.1f))
 		{
 			//if the faces are not overlapping then only go down
 			if (bestend[2] - 16 > beststart[2]) continue;
 		} //end if
 		lreach = AAS_AllocReachability();
 		if (!lreach) return lreachabilities;
 		lreach->areanum = i;
 		lreach->facenum = 0;
 		lreach->edgenum = 0;
 		VectorCopy(beststart, lreach->start);
 		VectorCopy(bestend, lreach->end);
 		lreach->traveltype = 0;
 		lreach->traveltime = 0;
 		lreach->next = lreachabilities;
 		lreachabilities = lreach;
 #ifndef BSPC
 		if (towardsface) AAS_PermanentLine(lreach->start, lreach->end, 1);
 		else AAS_PermanentLine(lreach->start, lreach->end, 2);
 #endif
 	} //end for
 	return lreachabilities;
 } //end of the function AAS_FindFaceReachabilities
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 void AAS_Reachability_FuncBobbing(void)
 {
 	int ent, spawnflags, modelnum, axis;
 	int i, numareas, areas[10];
 	char classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
 	vec3_t origin, move_end, move_start, move_start_top, move_end_top;
 	vec3_t mins, maxs, angles = {0, 0, 0};
 	vec3_t start_edgeverts[4], end_edgeverts[4], mid;
 	vec3_t org, start, end, dir, points[10];
 	float height;
 	aas_plane_t start_plane, end_plane;
 	aas_lreachability_t *startreach, *endreach, *nextstartreach, *nextendreach, *lreach;
 	aas_lreachability_t *firststartreach, *firstendreach;
 
 	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
 	{
 		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
 		if (strcmp(classname, "func_bobbing")) continue;
 		AAS_FloatForBSPEpairKey(ent, "height", &height);
 		if (!height) height = 32;
 		//
 		if (!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY))
 		{
 			botimport.Print(PRT_ERROR, "func_bobbing without model\n");
 			continue;
 		} //end if
 		//get the model number, and skip the leading *
 		modelnum = atoi(model+1);
 		if (modelnum <= 0)
 		{
 			botimport.Print(PRT_ERROR, "func_bobbing with invalid model number\n");
 			continue;
 		} //end if
 		//if the entity has an origin set then use it
 		if (!AAS_VectorForBSPEpairKey(ent, "origin", origin))
 			VectorSet(origin, 0, 0, 0);
 		//
 		AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, NULL);
 		//
 		VectorAdd(mins, origin, mins);
 		VectorAdd(maxs, origin, maxs);
 		//
 		VectorAdd(mins, maxs, mid);
 		VectorScale(mid, 0.5, mid);
 		VectorCopy(mid, origin);
 		//
 		VectorCopy(origin, move_end);
 		VectorCopy(origin, move_start);
 		//
 		AAS_IntForBSPEpairKey(ent, "spawnflags", &spawnflags);
 		// set the axis of bobbing
 		if (spawnflags & 1) axis = 0;
 		else if (spawnflags & 2) axis = 1;
 		else axis = 2;
 		//
 		move_start[axis] -= height;
 		move_end[axis] += height;
 		//
 		Log_Write("funcbob model %d, start = {%1.1f, %1.1f, %1.1f} end = {%1.1f, %1.1f, %1.1f}\n",
 					modelnum, move_start[0], move_start[1], move_start[2], move_end[0], move_end[1], move_end[2]);
 		//
 #ifndef BSPC
 		/*
 		AAS_DrawPermanentCross(move_start, 4, 1);
 		AAS_DrawPermanentCross(move_end, 4, 2);
 		*/
 #endif
 		//
 		for (i = 0; i < 4; i++)
 		{
 			VectorCopy(move_start, start_edgeverts[i]);
 			start_edgeverts[i][2] += maxs[2] - mid[2]; //+ bbox maxs z
 			start_edgeverts[i][2] += 24;	//+ player origin to ground dist
 		} //end for
 		start_edgeverts[0][0] += maxs[0] - mid[0];
 		start_edgeverts[0][1] += maxs[1] - mid[1];
 		start_edgeverts[1][0] += maxs[0] - mid[0];
 		start_edgeverts[1][1] += mins[1] - mid[1];
 		start_edgeverts[2][0] += mins[0] - mid[0];
 		start_edgeverts[2][1] += mins[1] - mid[1];
 		start_edgeverts[3][0] += mins[0] - mid[0];
 		start_edgeverts[3][1] += maxs[1] - mid[1];
 		//
 		start_plane.dist = start_edgeverts[0][2];
 		VectorSet(start_plane.normal, 0, 0, 1);
 		//
 		for (i = 0; i < 4; i++)
 		{
 			VectorCopy(move_end, end_edgeverts[i]);
 			end_edgeverts[i][2] += maxs[2] - mid[2]; //+ bbox maxs z
 			end_edgeverts[i][2] += 24;	//+ player origin to ground dist
 		} //end for
 		end_edgeverts[0][0] += maxs[0] - mid[0];
 		end_edgeverts[0][1] += maxs[1] - mid[1];
 		end_edgeverts[1][0] += maxs[0] - mid[0];
 		end_edgeverts[1][1] += mins[1] - mid[1];
 		end_edgeverts[2][0] += mins[0] - mid[0];
 		end_edgeverts[2][1] += mins[1] - mid[1];
 		end_edgeverts[3][0] += mins[0] - mid[0];
 		end_edgeverts[3][1] += maxs[1] - mid[1];
 		//
 		end_plane.dist = end_edgeverts[0][2];
 		VectorSet(end_plane.normal, 0, 0, 1);
 		//
 #ifndef BSPC
 #if 0
 		for (i = 0; i < 4; i++)
 		{
 			AAS_PermanentLine(start_edgeverts[i], start_edgeverts[(i+1)%4], 1);
 			AAS_PermanentLine(end_edgeverts[i], end_edgeverts[(i+1)%4], 1);
 		} //end for
 #endif
 #endif
 		VectorCopy(move_start, move_start_top);
 		move_start_top[2] += maxs[2] - mid[2] + 24; //+ bbox maxs z
 		VectorCopy(move_end, move_end_top);
 		move_end_top[2] += maxs[2] - mid[2] + 24; //+ bbox maxs z
 		//
 		if (!AAS_PointAreaNum(move_start_top)) continue;
 		if (!AAS_PointAreaNum(move_end_top)) continue;
 		//
 		for (i = 0; i < 2; i++)
 		{
 			firststartreach = firstendreach = NULL;
 			//
 			if (i == 0)
 			{
 				firststartreach = AAS_FindFaceReachabilities(start_edgeverts, 4, &start_plane, qtrue);
 				firstendreach = AAS_FindFaceReachabilities(end_edgeverts, 4, &end_plane, qfalse);
 			} //end if
 			else
 			{
 				firststartreach = AAS_FindFaceReachabilities(end_edgeverts, 4, &end_plane, qtrue);
 				firstendreach = AAS_FindFaceReachabilities(start_edgeverts, 4, &start_plane, qfalse);
 			} //end else
 			//
 			//create reachabilities from start to end
 			for (startreach = firststartreach; startreach; startreach = nextstartreach)
 			{
 				nextstartreach = startreach->next;
 				//
 				//trace = AAS_TraceClientBBox(startreach->start, move_start_top, PRESENCE_NORMAL, -1);
 				//if (trace.fraction < 1) continue;
 				//
 				for (endreach = firstendreach; endreach; endreach = nextendreach)
 				{
 					nextendreach = endreach->next;
 					//
 					//trace = AAS_TraceClientBBox(endreach->end, move_end_top, PRESENCE_NORMAL, -1);
 					//if (trace.fraction < 1) continue;
 					//
 					Log_Write("funcbob reach from area %d to %d\n", startreach->areanum, endreach->areanum);
 					//
 					//
 					if (i == 0) VectorCopy(move_start_top, org);
 					else VectorCopy(move_end_top, org);
 					VectorSubtract(startreach->start, org, dir);
 					dir[2] = 0;
 					VectorNormalize(dir);
 					VectorCopy(startreach->start, start);
 					VectorMA(startreach->start, 1, dir, start);
 					start[2] += 1;
 					VectorMA(startreach->start, 16, dir, end);
 					end[2] += 1;
 					//
 					numareas = AAS_TraceAreas(start, end, areas, points, 10);
 					if (numareas <= 0) continue;
 					if (numareas > 1) VectorCopy(points[1], startreach->start);
 					else VectorCopy(end, startreach->start);
 					//
 					if (!AAS_PointAreaNum(startreach->start)) continue;
 					if (!AAS_PointAreaNum(endreach->end)) continue;
 					//
 					lreach = AAS_AllocReachability();
 					lreach->areanum = endreach->areanum;
 					if (i == 0) lreach->edgenum = ((int)move_start[axis] << 16) | ((int) move_end[axis] & 0x0000ffff);
 					else lreach->edgenum = ((int)move_end[axis] << 16) | ((int) move_start[axis] & 0x0000ffff);
 					lreach->facenum = (spawnflags << 16) | modelnum;
 					VectorCopy(startreach->start, lreach->start);
 					VectorCopy(endreach->end, lreach->end);
 #ifndef BSPC
 //					AAS_DrawArrow(lreach->start, lreach->end, LINECOLOR_BLUE, LINECOLOR_YELLOW);
 //					AAS_PermanentLine(lreach->start, lreach->end, 1);
 #endif
 					lreach->traveltype = TRAVEL_FUNCBOB;
 					lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
 					lreach->traveltime = aassettings.rs_funcbob;
 					reach_funcbob++;
 					lreach->next = areareachability[startreach->areanum];
 					areareachability[startreach->areanum] = lreach;
 					//
 				} //end for
 			} //end for
 			for (startreach = firststartreach; startreach; startreach = nextstartreach)
 			{
 				nextstartreach = startreach->next;
 				AAS_FreeReachability(startreach);
 			} //end for
 			for (endreach = firstendreach; endreach; endreach = nextendreach)
 			{
 				nextendreach = endreach->next;
 				AAS_FreeReachability(endreach);
 			} //end for
 			//only go up with func_bobbing entities that go up and down
 			if (!(spawnflags & 1) && !(spawnflags & 2)) break;
 		} //end for
 	} //end for
 } //end of the function AAS_Reachability_FuncBobbing
 //===========================================================================
 //
 // Parameter:			-
 // Returns:				-
 // Changes Globals:		-
 //===========================================================================
 void AAS_Reachability_JumpPad(void)
 {
 	int face2num, i, ret, area2num, visualize, ent, bot_visualizejumppads;
 	//int modelnum, ent2;
 	//float dist, time, height, gravity, forward;
 	float speed, zvel, hordist;
 	aas_face_t *face2;
 	aas_area_t *area2;
 	aas_lreachability_t *lreach;
 	vec3_t areastart, facecenter, dir, cmdmove;
 	vec3_t velocity, absmins, absmaxs;
 	//vec3_t origin, ent2origin, angles, teststart;
 	aas_clientmove_t move;
 	//aas_trace_t trace;
 	aas_link_t *areas, *link;
 	//char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
 	char classname[MAX_EPAIRKEY];
 
 #ifdef BSPC
 	bot_visualizejumppads = 0;
 #else
 	bot_visualizejumppads = LibVarValue("bot_visualizejumppads", "0");
 #endif
 	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
 	{
 		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
 		if (strcmp(classname, "trigger_push")) continue;
 		//
 		if (!AAS_GetJumpPadInfo(ent, areastart, absmins, absmaxs, velocity)) continue;
 		/*
 		//
 		AAS_FloatForBSPEpairKey(ent, "speed", &speed);
 		if (!speed) speed = 1000;
 //		AAS_VectorForBSPEpairKey(ent, "angles", angles);
 //		AAS_SetMovedir(angles, velocity);
 //		VectorScale(velocity, speed, velocity);
 		VectorClear(angles);
 		//get the mins, maxs and origin of the model
 		AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
 		if (model[0]) modelnum = atoi(model+1);
 		else modelnum = 0;
 		AAS_BSPModelMinsMaxsOrigin(modelnum, angles, absmins, absmaxs, origin);
 		VectorAdd(origin, absmins, absmins);
 		VectorAdd(origin, absmaxs, absmaxs);
 		//
 #ifdef REACH_DEBUG
 		botimport.Print(PRT_MESSAGE, "absmins = %f %f %f\n", absmins[0], absmins[1], absmins[2]);
 		botimport.Print(PRT_MESSAGE, "absmaxs = %f %f %f\n", absmaxs[0], absmaxs[1], absmaxs[2]);
 #endif REACH_DEBUG
 		VectorAdd(absmins, absmaxs, origin);
 		VectorScale (origin, 0.5, origin);
 
 		//get the start areas
 		VectorCopy(origin, teststart);
 		teststart[2] += 64;
 		trace = AAS_TraceClientBBox(teststart, origin, PRESENCE_CROUCH, -1);
 		if (trace.startsolid)
 		{
 			botimport.Print(PRT_MESSAGE, "trigger_push start solid\n");
 			VectorCopy(origin, areastart);
 		} //end if
 		else
 		{
 			VectorCopy(trace.endpos, areastart);
 		} //end else
 		areastart[2] += 0.125;
 		//
 		//AAS_DrawPermanentCross(origin, 4, 4);
 		//get the target entity
 		AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY);
 		for (ent2 = AAS_NextBSPEntity(0); ent2; ent2 = AAS_NextBSPEntity(ent2))
 		{
 			if (!AAS_ValueForBSPEpairKey(ent2, "targetname", targetname, MAX_EPAIRKEY)) continue;
 			if (!strcmp(targetname, target)) break;
 		} //end for
 		if (!ent2)
 		{
 			botimport.Print(PRT_MESSAGE, "trigger_push without target entity %s\n", target);
 			continue;
 		} //end if
 		AAS_VectorForBSPEpairKey(ent2, "origin", ent2origin);
 		//
 		height = ent2origin[2] - origin[2];
 		gravity = aassettings.sv_gravity;
 		time = sqrt( height / ( 0.5 * gravity ) );
 		if (!time)
 		{
 			botimport.Print(PRT_MESSAGE, "trigger_push without time\n");
 			continue;
 		} //end if
 		// set s.origin2 to the push velocity
 		VectorSubtract ( ent2origin, origin, velocity);
 		dist = VectorNormalize( velocity);
 		forward = dist / time;
 		//FIXME: why multiply by 1.1
 		forward *= 1.1;
 		VectorScale(velocity, forward, velocity);
 		velocity[2] = time * gravity;
 		*/
 		//get the areas the jump pad brush is in
 		areas = AAS_LinkEntityClientBBox(absmins, absmaxs, -1, PRESENCE_CROUCH);
 		/*
 		for (link = areas; link; link = link->next_area)
 		{
 			if (link->areanum == 563)
 			{
 				ret = qfalse;
 			}
 		}
         */
 		for (link = areas; link; link = link->next_area)
 		{
 			if (AAS_AreaJumpPad(link->areanum)) break;
 		} //end for
 		if (!link)
 		{
 			botimport.Print(PRT_MESSAGE, "trigger_push not in any jump pad area\n");
 			AAS_UnlinkFromAreas(areas);
 			continue;
 		} //end if
 		//
 		botimport.Print(PRT_MESSAGE, "found a trigger_push with velocity %f %f %f\n", velocity[0], velocity[1], velocity[2]);
 		//if there is a horizontal velocity check for a reachability without air control
 		if (velocity[0] || velocity[1])
 		{
 			VectorSet(cmdmove, 0, 0, 0);
 			//VectorCopy(velocity, cmdmove);
 			//cmdmove[2] = 0;
 			Com_Memset(&move, 0, sizeof(aas_clientmove_t));
 			area2num = 0;
 			for (i = 0; i < 20; i++)
 			{
 				AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qfalse,
 										velocity, cmdmove, 0, 30, 0.1f,
 										SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME|
 										SE_ENTERLAVA|SE_HITGROUNDDAMAGE|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER, 0, bot_visualizejumppads);
 				area2num = move.endarea;
 				for (link = areas; link; link = link->next_area)
 				{
 					if (!AAS_AreaJumpPad(link->areanum)) continue;
 					if (link->areanum == area2num) break;
 				} //end if
 				if (!link) break;
 				VectorCopy(move.endpos, areastart);
 				VectorCopy(move.velocity, velocity);
 			} //end for
 			if (area2num && i < 20)
 			{
 				for (link = areas; link; link = link->next_area)
 				{
 					if (!AAS_AreaJumpPad(link->areanum)) continue;
 					if (AAS_ReachabilityExists(link->areanum, area2num)) continue;
 					//create a rocket or bfg jump reachability from area1 to area2
 					lreach = AAS_AllocReachability();
 					if (!lreach)
 					{
 						AAS_UnlinkFromAreas(areas);
 						return;
 					} //end if
 					lreach->areanum = area2num;
 					//NOTE: the facenum is the Z velocity
 					lreach->facenum = velocity[2];
 					//NOTE: the edgenum is the horizontal velocity
 					lreach->edgenum = sqrt(velocity[0] * velocity[0] + velocity[1] * velocity[1]);
 					VectorCopy(areastart, lreach->start);
 					VectorCopy(move.endpos, lreach->end);
 					lreach->traveltype = TRAVEL_JUMPPAD;
 					lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
 					lreach->traveltime = aassettings.rs_jumppad;
 					lreach->next = areareachability[link->areanum];
 					areareachability[link->areanum] = lreach;
 					//
 					reach_jumppad++;
 				} //end for
 			} //end if
 		} //end if
 		//
 		if (fabs(velocity[0]) > 100 || fabs(velocity[1]) > 100) continue;
 		//check for areas we can reach with air control
 		for (area2num = 1; area2num < aasworld.numareas; area2num++)
 		{
 			visualize = qfalse;
 			/*
 			if (area2num == 3568)
 			{
 				for (link = areas; link; link = link->next_area)
 				{
 					if (link->areanum == 3380)
 					{
 						visualize = qtrue;
 						botimport.Print(PRT_MESSAGE, "bah\n");
 					} //end if
 				} //end for
 			} //end if*/
 			//never try to go back to one of the original jumppad areas
 			//and don't create reachabilities if they already exist
 			for (link = areas; link; link = link->next_area)
 			{
 				if (AAS_ReachabilityExists(link->areanum, area2num)) break;
 				if (AAS_AreaJumpPad(link->areanum))
 				{
 					if (link->areanum == area2num) break;
 				} //end if
 			} //end if
 			if (link) continue;
 			//
 			area2 = &aasworld.areas[area2num];
 			for (i = 0; i < area2->numfaces; i++)
 			{
 				face2num = aasworld.faceindex[area2->firstface + i];
 				face2 = &aasworld.faces[abs(face2num)];
 				//if it is not a ground face
 				if (!(face2->faceflags & FACE_GROUND)) continue;
 				//get the center of the face
 				AAS_FaceCenter(face2num, facecenter);
 				//only go higher up
 				if (facecenter[2] < areastart[2]) continue;
 				//get the jumppad jump z velocity
 				zvel = velocity[2];
 				//get the horizontal speed for the jump, if it isn't possible to calculate this
 				//speed
 				ret = AAS_HorizontalVelocityForJump(zvel, areastart, facecenter, &speed);
 				if (ret && speed < 150)
 				{
 					//direction towards the face center
 					VectorSubtract(facecenter, areastart, dir);
 					dir[2] = 0;
 					hordist = VectorNormalize(dir);
 					//if (hordist < 1.6 * facecenter[2] - areastart[2])
 					{
 						//get command movement
 						VectorScale(dir, speed, cmdmove);
 						//
 						AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qfalse,
 													velocity, cmdmove, 30, 30, 0.1f,
 													SE_ENTERWATER|SE_ENTERSLIME|
 													SE_ENTERLAVA|SE_HITGROUNDDAMAGE|
 													SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER|SE_HITGROUNDAREA, area2num, visualize);
 						//if prediction time wasn't enough to fully predict the movement
 						//don't enter slime or lava and don't fall from too high
 						if (move.frames < 30 && 
 								!(move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE))
 								&& (move.stopevent & (SE_HITGROUNDAREA|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER)))
 						{
 							//never go back to the same jumppad
 							for (link = areas; link; link = link->next_area)
 							{
 								if (link->areanum == move.endarea) break;
 							}
 							if (!link)
 							{
 								for (link = areas; link; link = link->next_area)
 								{
 									if (!AAS_AreaJumpPad(link->areanum)) continue;
 									if (AAS_ReachabilityExists(link->areanum, area2num)) continue;
 									//create a jumppad reachability from area1 to area2
 									lreach = AAS_AllocReachability();
 									if (!lreach)
 									{
 										AAS_UnlinkFromAreas(areas);
 										return;
 									} //end if
 									lreach->areanum = move.endarea;
 									//NOTE: the facenum is the Z velocity
 									lreach->facenum = velocity[2];
 									//NOTE: the edgenum is the horizontal velocity
 									lreach->edgenum = sqrt(cmdmove[0] * cmdmove[0] + cmdmove[1] * cmdmove[1]);
 									VectorCopy(areastart, lreach->start);
 									VectorCopy(facecenter, lreach->end);
 									lreach->traveltype = TRAVEL_JUMPPAD;
 									lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
 									lreach->traveltime = aassettings.rs_aircontrolledjumppad;
 									lreach->next = areareachability[link->areanum];
 									areareachability[link->areanum] = lreach;
 									//
 									reach_jumppad++;
 								} //end for
 							}
 						} //end if
 					} //end if
 				} //end for
 			} //end for
 		} //end for
 		AAS_UnlinkFromAreas(areas);
 	} //end for
 } //end of the function AAS_Reachability_JumpPad
 //===========================================================================
 // never point at ground faces
 // always a higher and pretty far area
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_Reachability_Grapple(int area1num, int area2num)
 {
 	int face2num, i, j, areanum, numareas, areas[20];
 	float mingrappleangle, z, hordist;
 	bsp_trace_t bsptrace;
 	aas_trace_t trace;
 	aas_face_t *face2;
 	aas_area_t *area1, *area2;
 	aas_lreachability_t *lreach;
 	vec3_t areastart, facecenter, start, end, dir, down = {0, 0, -1};
 	vec_t *v;
 
 	//only grapple when on the ground or swimming
 	if (!AAS_AreaGrounded(area1num) && !AAS_AreaSwim(area1num)) return qfalse;
 	//don't grapple from a crouch area
 	if (!(AAS_AreaPresenceType(area1num) & PRESENCE_NORMAL)) return qfalse;
 	//NOTE: disabled area swim it doesn't work right
 	if (AAS_AreaSwim(area1num)) return qfalse;
 	//
 	area1 = &aasworld.areas[area1num];
 	area2 = &aasworld.areas[area2num];
 	//don't grapple towards way lower areas
 	if (area2->maxs[2] < area1->mins[2]) return qfalse;
 	//
 	VectorCopy(aasworld.areas[area1num].center, start);
 	//if not a swim area
 	if (!AAS_AreaSwim(area1num))
 	{
 		if (!AAS_PointAreaNum(start)) Log_Write("area %d center %f %f %f in solid?\r\n", area1num,
 								start[0], start[1], start[2]);
 		VectorCopy(start, end);
 		end[2] -= 1000;
 		trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
 		if (trace.startsolid) return qfalse;
 		VectorCopy(trace.endpos, areastart);
 	} //end if
 	else
 	{
 		if (!(AAS_PointContents(start) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER))) return qfalse;
 	} //end else
 	//
 	//start is now the start point
 	//
 	for (i = 0; i < area2->numfaces; i++)
 	{
 		face2num = aasworld.faceindex[area2->firstface + i];
 		face2 = &aasworld.faces[abs(face2num)];
 		//if it is not a solid face
 		if (!(face2->faceflags & FACE_SOLID)) continue;
 		//direction towards the first vertex of the face
 		v = aasworld.vertexes[aasworld.edges[abs(aasworld.edgeindex[face2->firstedge])].v[0]];
 		VectorSubtract(v, areastart, dir);
 		//if the face plane is facing away
 		if (DotProduct(aasworld.planes[face2->planenum].normal, dir) > 0) continue;
 		//get the center of the face
 		AAS_FaceCenter(face2num, facecenter);
 		//only go higher up with the grapple
 		if (facecenter[2] < areastart[2] + 64) continue;
 		//only use vertical faces or downward facing faces
 		if (DotProduct(aasworld.planes[face2->planenum].normal, down) < 0) continue;
 		//direction towards the face center
 		VectorSubtract(facecenter, areastart, dir);
 		//
 		z = dir[2];
 		dir[2] = 0;
 		hordist = VectorLength(dir);
 		if (!hordist) continue;
 		//if too far
 		if (hordist > 2000) continue;
 		//check the minimal angle of the movement
 		mingrappleangle = 15; //15 degrees
 		if (z / hordist < tan(2 * M_PI * mingrappleangle / 360)) continue;
 		//
 		VectorCopy(facecenter, start);
 		VectorMA(facecenter, -500, aasworld.planes[face2->planenum].normal, end);
 		//
 		bsptrace = AAS_Trace(start, NULL, NULL, end, 0, CONTENTS_SOLID);
 		//the grapple won't stick to the sky and the grapple point should be near the AAS wall
 		if ((bsptrace.surface.flags & SURF_SKY) || (bsptrace.fraction * 500 > 32)) continue;
 		//trace a full bounding box from the area center on the ground to
 		//the center of the face
 		VectorSubtract(facecenter, areastart, dir);
 		VectorNormalize(dir);
 		VectorMA(areastart, 4, dir, start);
 		VectorCopy(bsptrace.endpos, end);
 		trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
 		VectorSubtract(trace.endpos, facecenter, dir);
 		if (VectorLength(dir) > 24) continue;
 		//
 		VectorCopy(trace.endpos, start);
 		VectorCopy(trace.endpos, end);
 		end[2] -= AAS_FallDamageDistance();
 		trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
 		if (trace.fraction >= 1) continue;
 		//area to end in
 		areanum = AAS_PointAreaNum(trace.endpos);
 		//if not in lava or slime
 		if (aasworld.areasettings[areanum].contents & (AREACONTENTS_SLIME|AREACONTENTS_LAVA))
 		{
 			continue;
 		} //end if
 		//do not go the the source area
 		if (areanum == area1num) continue;
 		//don't create reachabilities if they already exist
 		if (AAS_ReachabilityExists(area1num, areanum)) continue;
 		//only end in areas we can stand
 		if (!AAS_AreaGrounded(areanum)) continue;
 		//never go through cluster portals!!
 		numareas = AAS_TraceAreas(areastart, bsptrace.endpos, areas, NULL, 20);
 		if (numareas >= 20) continue;
 		for (j = 0; j < numareas; j++)
 		{
 			if (aasworld.areasettings[areas[j]].contents & AREACONTENTS_CLUSTERPORTAL) break;
 		} //end for
 		if (j < numareas) continue;
 		//create a new reachability link
 		lreach = AAS_AllocReachability();
 		if (!lreach) return qfalse;
 		lreach->areanum = areanum;
 		lreach->facenum = face2num;
 		lreach->edgenum = 0;
 		VectorCopy(areastart, lreach->start);
 		//VectorCopy(facecenter, lreach->end);
 		VectorCopy(bsptrace.endpos, lreach->end);
 		lreach->traveltype = TRAVEL_GRAPPLEHOOK;
 		VectorSubtract(lreach->end, lreach->start, dir);
 		lreach->traveltime = aassettings.rs_startgrapple + VectorLength(dir) * 0.25;
 		lreach->next = areareachability[area1num];
 		areareachability[area1num] = lreach;
 		//
 		reach_grapple++;
 	} //end for
 	//
 	return qfalse;
 } //end of the function AAS_Reachability_Grapple
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_SetWeaponJumpAreaFlags(void)
 {
 	int ent, i;
 	vec3_t mins = {-15, -15, -15}, maxs = {15, 15, 15};
 	vec3_t origin;
 	int areanum, weaponjumpareas, spawnflags;
 	char classname[MAX_EPAIRKEY];
 
 	weaponjumpareas = 0;
 	for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
 	{
 		if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
 		if (
 			!strcmp(classname, "item_armor_body") ||
 			!strcmp(classname, "item_armor_combat") ||
 			!strcmp(classname, "item_health_mega") ||
 			!strcmp(classname, "weapon_grenadelauncher") ||
 			!strcmp(classname, "weapon_rocketlauncher") ||
 			!strcmp(classname, "weapon_lightning") ||
 			!strcmp(classname, "weapon_plasmagun") ||
 			!strcmp(classname, "weapon_railgun") ||
 			!strcmp(classname, "weapon_bfg") ||
 			!strcmp(classname, "item_quad") ||
 			!strcmp(classname, "item_regen") ||
 			!strcmp(classname, "item_invulnerability"))
 		{
 			if (AAS_VectorForBSPEpairKey(ent, "origin", origin))
 			{
 				spawnflags = 0;
 				AAS_IntForBSPEpairKey(ent, "spawnflags", &spawnflags);
 				//if not a stationary item
 				if (!(spawnflags & 1))
 				{
 					if (!AAS_DropToFloor(origin, mins, maxs))
 					{
 						botimport.Print(PRT_MESSAGE, "%s in solid at (%1.1f %1.1f %1.1f)\n",
 														classname, origin[0], origin[1], origin[2]);
 					} //end if
 				} //end if
 				//areanum = AAS_PointAreaNum(origin);
 				areanum = AAS_BestReachableArea(origin, mins, maxs, origin);
 				//the bot may rocket jump towards this area
 				aasworld.areasettings[areanum].areaflags |= AREA_WEAPONJUMP;
 				//
 				//if (!AAS_AreaGrounded(areanum))
 				//	botimport.Print(PRT_MESSAGE, "area not grounded\n");
 				//
 				weaponjumpareas++;
 			} //end if
 		} //end if
 	} //end for
 	for (i = 1; i < aasworld.numareas; i++)
 	{
 		if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD)
 		{
 			aasworld.areasettings[i].areaflags |= AREA_WEAPONJUMP;
 			weaponjumpareas++;
 		} //end if
 	} //end for
 	botimport.Print(PRT_MESSAGE, "%d weapon jump areas\n", weaponjumpareas);
 } //end of the function AAS_SetWeaponJumpAreaFlags
 //===========================================================================
 // create a possible weapon jump reachability from area1 to area2
 //
 // check if there's a cool item in the second area
 // check if area1 is lower than area2
 // check if the bot can rocketjump from area1 to area2
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 int AAS_Reachability_WeaponJump(int area1num, int area2num)
 {
 	int face2num, i, n, ret, visualize;
 	float speed, zvel, hordist;
 	aas_face_t *face2;
 	aas_area_t *area1, *area2;
 	aas_lreachability_t *lreach;
 	vec3_t areastart, facecenter, start, end, dir, cmdmove;// teststart;
 	vec3_t velocity;
 	aas_clientmove_t move;
 	aas_trace_t trace;
 
 	visualize = qfalse;
 //	if (area1num == 4436 && area2num == 4318)
 //	{
 //		visualize = qtrue;
 //	}
 	if (!AAS_AreaGrounded(area1num) || AAS_AreaSwim(area1num)) return qfalse;
 	if (!AAS_AreaGrounded(area2num)) return qfalse;
 	//NOTE: only weapon jump towards areas with an interesting item in it??
 	if (!(aasworld.areasettings[area2num].areaflags & AREA_WEAPONJUMP)) return qfalse;
 	//
 	area1 = &aasworld.areas[area1num];
 	area2 = &aasworld.areas[area2num];
 	//don't weapon jump towards way lower areas
 	if (area2->maxs[2] < area1->mins[2]) return qfalse;
 	//
 	VectorCopy(aasworld.areas[area1num].center, start);
 	//if not a swim area
 	if (!AAS_PointAreaNum(start)) Log_Write("area %d center %f %f %f in solid?\r\n", area1num,
 							start[0], start[1], start[2]);
 	VectorCopy(start, end);
 	end[2] -= 1000;
 	trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
 	if (trace.startsolid) return qfalse;
 	VectorCopy(trace.endpos, areastart);
 	//
 	//areastart is now the start point
 	//
 	for (i = 0; i < area2->numfaces; i++)
 	{
 		face2num = aasworld.faceindex[area2->firstface + i];
 		face2 = &aasworld.faces[abs(face2num)];
 		//if it is not a solid face
 		if (!(face2->faceflags & FACE_GROUND)) continue;
 		//get the center of the face
 		AAS_FaceCenter(face2num, facecenter);
 		//only go higher up with weapon jumps
 		if (facecenter[2] < areastart[2] + 64) continue;
 		//NOTE: set to 2 to allow bfg jump reachabilities
 		for (n = 0; n < 1/*2*/; n++)
 		{
 			//get the rocket jump z velocity
 			if (n) zvel = AAS_BFGJumpZVelocity(areastart);
 			else zvel = AAS_RocketJumpZVelocity(areastart);
 			//get the horizontal speed for the jump, if it isn't possible to calculate this
 			//speed (the jump is not possible) then there's no jump reachability created
 			ret = AAS_HorizontalVelocityForJump(zvel, areastart, facecenter, &speed);
 			if (ret && speed < 300)
 			{
 				//direction towards the face center
 				VectorSubtract(facecenter, areastart, dir);
 				dir[2] = 0;
 				hordist = VectorNormalize(dir);
 				//if (hordist < 1.6 * (facecenter[2] - areastart[2]))
 				{
 					//get command movement
 					VectorScale(dir, speed, cmdmove);
 					VectorSet(velocity, 0, 0, zvel);
 					/*
 					//get command movement
 					VectorScale(dir, speed, velocity);
 					velocity[2] = zvel;
 					VectorSet(cmdmove, 0, 0, 0);
 					*/
 					//
 					AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qtrue,
 												velocity, cmdmove, 30, 30, 0.1f,
 												SE_ENTERWATER|SE_ENTERSLIME|
 												SE_ENTERLAVA|SE_HITGROUNDDAMAGE|
 												SE_TOUCHJUMPPAD|SE_HITGROUND|SE_HITGROUNDAREA, area2num, visualize);
 					//if prediction time wasn't enough to fully predict the movement
 					//don't enter slime or lava and don't fall from too high
 					if (move.frames < 30 && 
 							!(move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE))
 								&& (move.stopevent & (SE_HITGROUNDAREA|SE_TOUCHJUMPPAD)))
 					{
 						//create a rocket or bfg jump reachability from area1 to area2
 						lreach = AAS_AllocReachability();
 						if (!lreach) return qfalse;
 						lreach->areanum = area2num;
 						lreach->facenum = 0;
 						lreach->edgenum = 0;
 						VectorCopy(areastart, lreach->start);
 						VectorCopy(facecenter, lreach->end);
 						if (n)
 						{
 							lreach->traveltype = TRAVEL_BFGJUMP;
 							lreach->traveltime = aassettings.rs_bfgjump;
 						} //end if
 						else
 						{
 							lreach->traveltype = TRAVEL_ROCKETJUMP;
 							lreach->traveltime = aassettings.rs_rocketjump;
 						} //end else
 						lreach->next = areareachability[area1num];
 						areareachability[area1num] = lreach;
 						//
 						reach_rocketjump++;
 						return qtrue;
 					} //end if
 				} //end if
 			} //end if
 		} //end for
 	} //end for
 	//
 	return qfalse;
 } //end of the function AAS_Reachability_WeaponJump
 //===========================================================================
 // calculates additional walk off ledge reachabilities for the given area
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_Reachability_WalkOffLedge(int areanum)
 {
 	int i, j, k, l, m, n, p, areas[10], numareas;
 	int face1num, face2num, face3num, edge1num, edge2num, edge3num;
 	int otherareanum, gap, reachareanum, side;
 	aas_area_t *area, *area2;
 	aas_face_t *face1, *face2, *face3;
 	aas_edge_t *edge;
 	aas_plane_t *plane;
 	vec_t *v1, *v2;
 	vec3_t sharededgevec, mid, dir, testend;
 	aas_lreachability_t *lreach;
 	aas_trace_t trace;
 
 	if (!AAS_AreaGrounded(areanum) || AAS_AreaSwim(areanum)) return;
 	//
 	area = &aasworld.areas[areanum];
 	//
 	for (i = 0; i < area->numfaces; i++)
 	{
 		face1num = aasworld.faceindex[area->firstface + i];
 		face1 = &aasworld.faces[abs(face1num)];
 		//face 1 must be a ground face
 		if (!(face1->faceflags & FACE_GROUND)) continue;
 		//go through all the edges of this ground face
 		for (k = 0; k < face1->numedges; k++)
 		{
 			edge1num = aasworld.edgeindex[face1->firstedge + k];
 			//find another not ground face using this same edge
 			for (j = 0; j < area->numfaces; j++)
 			{
 				face2num = aasworld.faceindex[area->firstface + j];
 				face2 = &aasworld.faces[abs(face2num)];
 				//face 2 may not be a ground face
 				if (face2->faceflags & FACE_GROUND) continue;
 				//compare all the edges
 				for (l = 0; l < face2->numedges; l++)
 				{
 					edge2num = aasworld.edgeindex[face2->firstedge + l];
 					if (abs(edge1num) == abs(edge2num))
 					{
 						//get the area at the other side of the face
 						if (face2->frontarea == areanum) otherareanum = face2->backarea;
 						else otherareanum = face2->frontarea;
 						//
 						area2 = &aasworld.areas[otherareanum];
 						//if the other area is grounded!
 						if (aasworld.areasettings[otherareanum].areaflags & AREA_GROUNDED)
 						{
 							//check for a possible gap
 							gap = qfalse;
 							for (n = 0; n < area2->numfaces; n++)
 							{
 								face3num = aasworld.faceindex[area2->firstface + n];
 								//may not be the shared face of the two areas
 								if (abs(face3num) == abs(face2num)) continue;
 								//
 								face3 = &aasworld.faces[abs(face3num)];
 								//find an edge shared by all three faces
 								for (m = 0; m < face3->numedges; m++)
 								{
 									edge3num = aasworld.edgeindex[face3->firstedge + m];
 									//but the edge should be shared by all three faces
 									if (abs(edge3num) == abs(edge1num))
 									{
 										if (!(face3->faceflags & FACE_SOLID))
 										{
 											gap = qtrue;
 											break;
 										} //end if
 										//
 										if (face3->faceflags & FACE_GROUND)
 										{
 											gap = qfalse;
 											break;
 										} //end if
 										//FIXME: there are more situations to be handled
 										gap = qtrue;
 										break;
 									} //end if
 								} //end for
 								if (m < face3->numedges) break;
 							} //end for
 							if (!gap) break;
 						} //end if
 						//check for a walk off ledge reachability
 						edge = &aasworld.edges[abs(edge1num)];
 						side = edge1num < 0;
 						//
 						v1 = aasworld.vertexes[edge->v[side]];
 						v2 = aasworld.vertexes[edge->v[!side]];
 						//
 						plane = &aasworld.planes[face1->planenum];
 						//get the points really into the areas
 						VectorSubtract(v2, v1, sharededgevec);
 						CrossProduct(plane->normal, sharededgevec, dir);
 						VectorNormalize(dir);
 						//
 						VectorAdd(v1, v2, mid);
 						VectorScale(mid, 0.5, mid);
 						VectorMA(mid, 8, dir, mid);
 						//
 						VectorCopy(mid, testend);
 						testend[2] -= 1000;
 						trace = AAS_TraceClientBBox(mid, testend, PRESENCE_CROUCH, -1);
 						//
 						if (trace.startsolid)
 						{
 							//Log_Write("area %d: trace.startsolid\r\n", areanum);
 							break;
 						} //end if
 						reachareanum = AAS_PointAreaNum(trace.endpos);
 						if (reachareanum == areanum)
 						{
 							//Log_Write("area %d: same area\r\n", areanum);
 							break;
 						} //end if
 						if (AAS_ReachabilityExists(areanum, reachareanum))
 						{
 							//Log_Write("area %d: reachability already exists\r\n", areanum);
 							break;
 						} //end if
 						if (!AAS_AreaGrounded(reachareanum) && !AAS_AreaSwim(reachareanum))
 						{
 							//Log_Write("area %d, reach area %d: not grounded and not swim\r\n", areanum, reachareanum);
 							break;
 						} //end if
 						//
 						if (aasworld.areasettings[reachareanum].contents & (AREACONTENTS_SLIME
 																						| AREACONTENTS_LAVA))
 						{
 							//Log_Write("area %d, reach area %d: lava or slime\r\n", areanum, reachareanum);
 							break;
 						} //end if
 						//if not going through a cluster portal
 						numareas = AAS_TraceAreas(mid, testend, areas, NULL, sizeof(areas) / sizeof(int));
 						for (p = 0; p < numareas; p++)
 							if (AAS_AreaClusterPortal(areas[p]))
 								break;
 						if (p < numareas)
 							break;
 						// if a maximum fall height is set and the bot would fall down further
 						if (aassettings.rs_maxfallheight && fabs(mid[2] - trace.endpos[2]) > aassettings.rs_maxfallheight)
 							break;
 						//
 						lreach = AAS_AllocReachability();
 						if (!lreach) break;
 						lreach->areanum = reachareanum;
 						lreach->facenum = 0;
 						lreach->edgenum = edge1num;
 						VectorCopy(mid, lreach->start);
 						VectorCopy(trace.endpos, lreach->end);
 						lreach->traveltype = TRAVEL_WALKOFFLEDGE;
 						lreach->traveltime = aassettings.rs_startwalkoffledge + fabs(mid[2] - trace.endpos[2]) * 50 / aassettings.phys_gravity;
 						if (!AAS_AreaSwim(reachareanum) && !AAS_AreaJumpPad(reachareanum))
 						{
 							if (AAS_FallDelta(mid[2] - trace.endpos[2]) > aassettings.phys_falldelta5)
 							{
 								lreach->traveltime += aassettings.rs_falldamage5;
 							} //end if
 							else if (AAS_FallDelta(mid[2] - trace.endpos[2]) > aassettings.phys_falldelta10)
 							{
 								lreach->traveltime += aassettings.rs_falldamage10;
 							} //end if
 						} //end if
 						lreach->next = areareachability[areanum];
 						areareachability[areanum] = lreach;
 						//we've got another walk off ledge reachability
 						reach_walkoffledge++;
 					} //end if
 				} //end for
 			} //end for
 		} //end for
 	} //end for
 } //end of the function AAS_Reachability_WalkOffLedge
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_StoreReachability(void)
 {
 	int i;
 	aas_areasettings_t *areasettings;
 	aas_lreachability_t *lreach;
 	aas_reachability_t *reach;
 
 	if (aasworld.reachability) FreeMemory(aasworld.reachability);
 	aasworld.reachability = (aas_reachability_t *) GetClearedMemory((numlreachabilities + 10) * sizeof(aas_reachability_t));
 	aasworld.reachabilitysize = 1;
 	for (i = 0; i < aasworld.numareas; i++)
 	{
 		areasettings = &aasworld.areasettings[i];
 		areasettings->firstreachablearea = aasworld.reachabilitysize;
 		areasettings->numreachableareas = 0;
 		for (lreach = areareachability[i]; lreach; lreach = lreach->next)
 		{
 			reach = &aasworld.reachability[areasettings->firstreachablearea +
 													areasettings->numreachableareas];
 			reach->areanum = lreach->areanum;
 			reach->facenum = lreach->facenum;
 			reach->edgenum = lreach->edgenum;
 			VectorCopy(lreach->start, reach->start);
 			VectorCopy(lreach->end, reach->end);
 			reach->traveltype = lreach->traveltype;
 			reach->traveltime = lreach->traveltime;
 			//
 			areasettings->numreachableareas++;
 		} //end for
 		aasworld.reachabilitysize += areasettings->numreachableareas;
 	} //end for
 } //end of the function AAS_StoreReachability
 //===========================================================================
 //
 // TRAVEL_WALK					100%	equal floor height + steps
 // TRAVEL_CROUCH				100%
 // TRAVEL_BARRIERJUMP			100%
 // TRAVEL_JUMP					 80%
 // TRAVEL_LADDER				100%	+ fall down from ladder + jump up to ladder
 // TRAVEL_WALKOFFLEDGE			 90%	walk off very steep walls?
 // TRAVEL_SWIM					100%
 // TRAVEL_WATERJUMP				100%
 // TRAVEL_TELEPORT				100%
 // TRAVEL_ELEVATOR				100%
 // TRAVEL_GRAPPLEHOOK			100%
 // TRAVEL_DOUBLEJUMP			  0%
 // TRAVEL_RAMPJUMP				  0%
 // TRAVEL_STRAFEJUMP			  0%
 // TRAVEL_ROCKETJUMP			100%	(currently limited towards areas with items)
 // TRAVEL_BFGJUMP				  0%	(currently disabled)
 // TRAVEL_JUMPPAD				100%
 // TRAVEL_FUNCBOB				100%
 //
 // Parameter:			-
 // Returns:				true if NOT finished
 // Changes Globals:		-
 //===========================================================================
 int AAS_ContinueInitReachability(float time)
 {
 	int i, j, todo, start_time;
 	static float framereachability, reachability_delay;
 	static int lastpercentage;
 
 	if (!aasworld.loaded) return qfalse;
 	//if reachability is calculated for all areas
 	if (aasworld.numreachabilityareas >= aasworld.numareas + 2) return qfalse;
 	//if starting with area 1 (area 0 is a dummy)
 	if (aasworld.numreachabilityareas == 1)
 	{
 		botimport.Print(PRT_MESSAGE, "calculating reachability...\n");
 		lastpercentage = 0;
 		framereachability = 2000;
 		reachability_delay = 1000;
 	} //end if
 	//number of areas to calculate reachability for this cycle
 	todo = aasworld.numreachabilityareas + (int) framereachability;
 	start_time = Sys_MilliSeconds();
 	//loop over the areas
 	for (i = aasworld.numreachabilityareas; i < aasworld.numareas && i < todo; i++)
 	{
 		aasworld.numreachabilityareas++;
 		//only create jumppad reachabilities from jumppad areas
 		if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD)
 		{
 			continue;
 		} //end if
 		//loop over the areas
 		for (j = 1; j < aasworld.numareas; j++)
 		{
 			if (i == j) continue;
 			//never create reachabilities from teleporter or jumppad areas to regular areas
 			if (aasworld.areasettings[i].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD))
 			{
 				if (!(aasworld.areasettings[j].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD)))
 				{
 					continue;
 				} //end if
 			} //end if
 			//if there already is a reachability link from area i to j
 			if (AAS_ReachabilityExists(i, j)) continue;
 			//check for a swim reachability
 			if (AAS_Reachability_Swim(i, j)) continue;
 			//check for a simple walk on equal floor height reachability
 			if (AAS_Reachability_EqualFloorHeight(i, j)) continue;
 			//check for step, barrier, waterjump and walk off ledge reachabilities
 			if (AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(i, j)) continue;
 			//check for ladder reachabilities
 			if (AAS_Reachability_Ladder(i, j)) continue;
 			//check for a jump reachability
 			if (AAS_Reachability_Jump(i, j)) continue;
 		} //end for
 		//never create these reachabilities from teleporter or jumppad areas
 		if (aasworld.areasettings[i].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD))
 		{
 			continue;
 		} //end if
 		//loop over the areas
 		for (j = 1; j < aasworld.numareas; j++)
 		{
 			if (i == j) continue;
 			//
 			if (AAS_ReachabilityExists(i, j)) continue;
 			//check for a grapple hook reachability
 			if (calcgrapplereach) AAS_Reachability_Grapple(i, j);
 			//check for a weapon jump reachability
 			AAS_Reachability_WeaponJump(i, j);
 		} //end for
 		//if the calculation took more time than the max reachability delay
 		if (Sys_MilliSeconds() - start_time > (int) reachability_delay) break;
 		//
 		if (aasworld.numreachabilityareas * 1000 / aasworld.numareas > lastpercentage) break;
 	} //end for
 	//
 	if (aasworld.numreachabilityareas == aasworld.numareas)
 	{
 		botimport.Print(PRT_MESSAGE, "\r%6.1f%%", (float) 100.0);
 		botimport.Print(PRT_MESSAGE, "\nplease wait while storing reachability...\n");
 		aasworld.numreachabilityareas++;
 	} //end if
 	//if this is the last step in the reachability calculations
 	else if (aasworld.numreachabilityareas == aasworld.numareas + 1)
 	{
 		//create additional walk off ledge reachabilities for every area
 		for (i = 1; i < aasworld.numareas; i++)
 		{
 			//only create jumppad reachabilities from jumppad areas
 			if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD)
 			{
 				continue;
 			} //end if
 			AAS_Reachability_WalkOffLedge(i);
 		} //end for
 		//create jump pad reachabilities
 		AAS_Reachability_JumpPad();
 		//create teleporter reachabilities
 		AAS_Reachability_Teleport();
 		//create elevator (func_plat) reachabilities
 		AAS_Reachability_Elevator();
 		//create func_bobbing reachabilities
 		AAS_Reachability_FuncBobbing();
 		//
 #ifdef DEBUG
 		botimport.Print(PRT_MESSAGE, "%6d reach swim\n", reach_swim);
 		botimport.Print(PRT_MESSAGE, "%6d reach equal floor\n", reach_equalfloor);
 		botimport.Print(PRT_MESSAGE, "%6d reach step\n", reach_step);
 		botimport.Print(PRT_MESSAGE, "%6d reach barrier\n", reach_barrier);
 		botimport.Print(PRT_MESSAGE, "%6d reach waterjump\n", reach_waterjump);
 		botimport.Print(PRT_MESSAGE, "%6d reach walkoffledge\n", reach_walkoffledge);
 		botimport.Print(PRT_MESSAGE, "%6d reach jump\n", reach_jump);
 		botimport.Print(PRT_MESSAGE, "%6d reach ladder\n", reach_ladder);
 		botimport.Print(PRT_MESSAGE, "%6d reach walk\n", reach_walk);
 		botimport.Print(PRT_MESSAGE, "%6d reach teleport\n", reach_teleport);
 		botimport.Print(PRT_MESSAGE, "%6d reach funcbob\n", reach_funcbob);
 		botimport.Print(PRT_MESSAGE, "%6d reach elevator\n", reach_elevator);
 		botimport.Print(PRT_MESSAGE, "%6d reach grapple\n", reach_grapple);
 		botimport.Print(PRT_MESSAGE, "%6d reach rocketjump\n", reach_rocketjump);
 		botimport.Print(PRT_MESSAGE, "%6d reach jumppad\n", reach_jumppad);
 #endif
 		//*/
 		//store all the reachabilities
 		AAS_StoreReachability();
 		//free the reachability link heap
 		AAS_ShutDownReachabilityHeap();
 		//
 		FreeMemory(areareachability);
 		//
 		aasworld.numreachabilityareas++;
 		//
 		botimport.Print(PRT_MESSAGE, "calculating clusters...\n");
 	} //end if
 	else
 	{
 		lastpercentage = aasworld.numreachabilityareas * 1000 / aasworld.numareas;
 		botimport.Print(PRT_MESSAGE, "\r%6.1f%%", (float) lastpercentage / 10);
 	} //end else
 	//not yet finished
 	return qtrue;
 } //end of the function AAS_ContinueInitReachability
 //===========================================================================
 //
 // Parameter:				-
 // Returns:					-
 // Changes Globals:		-
 //===========================================================================
 void AAS_InitReachability(void)
 {
 	if (!aasworld.loaded) return;
 
 	if (aasworld.reachabilitysize)
 	{
 #ifndef BSPC
 		if (!((int)LibVarGetValue("forcereachability")))
 		{
 			aasworld.numreachabilityareas = aasworld.numareas + 2;
 			return;
 		} //end if
 #else
 		aasworld.numreachabilityareas = aasworld.numareas + 2;
 		return;
 #endif //BSPC
 	} //end if
 #ifndef BSPC
 	calcgrapplereach = LibVarGetValue("grapplereach");
 #endif
 	aasworld.savefile = qtrue;
 	//start with area 1 because area zero is a dummy
 	aasworld.numreachabilityareas = 1;
 	////aasworld.numreachabilityareas = aasworld.numareas + 1;		//only calculate entity reachabilities
 	//setup the heap with reachability links
 	AAS_SetupReachabilityHeap();
 	//allocate area reachability link array
 	areareachability = (aas_lreachability_t **) GetClearedMemory(
 									aasworld.numareas * sizeof(aas_lreachability_t *));
 	//
 	AAS_SetWeaponJumpAreaFlags();
 } //end of the function AAS_InitReachable