/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
Copyright (C) 2006 Robert Beckebans <trebor_7@users.sourceforge.net>

This file is part of XreaL source code.

XreaL 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.

XreaL 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 XreaL source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

/*****************************************************************************
 * name:		be_ai_move.c
 *
 * desc:		bot movement AI
 *
 * $Archive: /MissionPack/code/botlib/be_ai_move.c $
 *
 *****************************************************************************/

#include "../common/shared.h"
#include "l_memory.h"
#include "l_libvar.h"
#include "l_utils.h"
#include "l_script.h"
#include "l_precomp.h"
#include "l_struct.h"
#include "aasfile.h"
#include "../../mod/game/botlib.h"
#include "../../mod/game/be_aas.h"
#include "be_aas_funcs.h"
#include "be_interface.h"

#include "../../mod/game/be_ea.h"
#include "../../mod/game/be_ai_goal.h"
#include "../../mod/game/be_ai_move.h"


//#define DEBUG_AI_MOVE
//#define DEBUG_ELEVATOR
//#define DEBUG_GRAPPLE

// bk001204 - redundant bot_avoidspot_t, see ../game/be_ai_move.h

//movement state
//NOTE: the moveflags MFL_ONGROUND, MFL_TELEPORTED, MFL_WATERJUMP and
//      MFL_GRAPPLEPULL must be set outside the movement code
typedef struct bot_movestate_s
{
	//input vars (all set outside the movement code)
	vec3_t          origin;		//origin of the bot
	vec3_t          velocity;	//velocity of the bot
	vec3_t          viewoffset;	//view offset
	int             entitynum;	//entity number of the bot
	int             client;		//client number of the bot
	float           thinktime;	//time the bot thinks
	int             presencetype;	//presencetype of the bot
	vec3_t          viewangles;	//view angles of the bot
	//state vars
	int             areanum;	//area the bot is in
	int             lastareanum;	//last area the bot was in
	int             lastgoalareanum;	//last goal area number
	int             lastreachnum;	//last reachability number
	vec3_t          lastorigin;	//origin previous cycle
	int             reachareanum;	//area number of the reachabilty
	int             moveflags;	//movement flags
	int             jumpreach;	//set when jumped
	float           grapplevisible_time;	//last time the grapple was visible
	float           lastgrappledist;	//last distance to the grapple end
	float           reachability_time;	//time to use current reachability
	int             avoidreach[MAX_AVOIDREACH];	//reachabilities to avoid
	float           avoidreachtimes[MAX_AVOIDREACH];	//times to avoid the reachabilities
	int             avoidreachtries[MAX_AVOIDREACH];	//number of tries before avoiding
	//
	bot_avoidspot_t avoidspots[MAX_AVOIDSPOTS];	//spots to avoid
	int             numavoidspots;
} bot_movestate_t;

//used to avoid reachability links for some time after being used
#define AVOIDREACH
#define AVOIDREACH_TIME			6	//avoid links for 6 seconds after use
#define AVOIDREACH_TRIES		4
//prediction times
#define PREDICTIONTIME_JUMP	3	//in seconds
#define PREDICTIONTIME_MOVE	2	//in seconds
//weapon indexes for weapon jumping
#define WEAPONINDEX_ROCKET_LAUNCHER		5
#define WEAPONINDEX_BFG					9

#define MODELTYPE_FUNC_PLAT		1
#define MODELTYPE_FUNC_BOB		2
#define MODELTYPE_FUNC_DOOR		3
#define MODELTYPE_FUNC_STATIC	4

libvar_t       *sv_maxstep;
libvar_t       *sv_maxbarrier;
libvar_t       *sv_gravity;
libvar_t       *weapindex_rocketlauncher;
libvar_t       *weapindex_bfg10k;
libvar_t       *weapindex_grapple;
libvar_t       *entitytypemissile;
libvar_t       *offhandgrapple;
libvar_t       *cmd_grappleoff;
libvar_t       *cmd_grappleon;

//type of model, func_plat or func_bobbing
int             modeltypes[MAX_MODELS];

bot_movestate_t *botmovestates[MAX_CLIENTS + 1];

//========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//========================================================================
int BotAllocMoveState(void)
{
	int             i;

	for(i = 1; i <= MAX_CLIENTS; i++)
	{
		if(!botmovestates[i])
		{
			botmovestates[i] = GetClearedMemory(sizeof(bot_movestate_t));
			return i;
		}						//end if
	}							//end for
	return 0;
}								//end of the function BotAllocMoveState

//========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//========================================================================
void BotFreeMoveState(int handle)
{
	if(handle <= 0 || handle > MAX_CLIENTS)
	{
		botimport.Print(PRT_FATAL, "move state handle %d out of range\n", handle);
		return;
	}							//end if
	if(!botmovestates[handle])
	{
		botimport.Print(PRT_FATAL, "invalid move state %d\n", handle);
		return;
	}							//end if
	FreeMemory(botmovestates[handle]);
	botmovestates[handle] = NULL;
}								//end of the function BotFreeMoveState

//========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//========================================================================
bot_movestate_t *BotMoveStateFromHandle(int handle)
{
	if(handle <= 0 || handle > MAX_CLIENTS)
	{
		botimport.Print(PRT_FATAL, "move state handle %d out of range\n", handle);
		return NULL;
	}							//end if
	if(!botmovestates[handle])
	{
		botimport.Print(PRT_FATAL, "invalid move state %d\n", handle);
		return NULL;
	}							//end if
	return botmovestates[handle];
}								//end of the function BotMoveStateFromHandle

//========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//========================================================================
void BotInitMoveState(int handle, bot_initmove_t * initmove)
{
	bot_movestate_t *ms;

	ms = BotMoveStateFromHandle(handle);
	if(!ms)
		return;
	VectorCopy(initmove->origin, ms->origin);
	VectorCopy(initmove->velocity, ms->velocity);
	VectorCopy(initmove->viewoffset, ms->viewoffset);
	ms->entitynum = initmove->entitynum;
	ms->client = initmove->client;
	ms->thinktime = initmove->thinktime;
	ms->presencetype = initmove->presencetype;
	VectorCopy(initmove->viewangles, ms->viewangles);
	//
	ms->moveflags &= ~MFL_ONGROUND;
	if(initmove->or_moveflags & MFL_ONGROUND)
		ms->moveflags |= MFL_ONGROUND;
	ms->moveflags &= ~MFL_TELEPORTED;
	if(initmove->or_moveflags & MFL_TELEPORTED)
		ms->moveflags |= MFL_TELEPORTED;
	ms->moveflags &= ~MFL_WATERJUMP;
	if(initmove->or_moveflags & MFL_WATERJUMP)
		ms->moveflags |= MFL_WATERJUMP;
	ms->moveflags &= ~MFL_WALK;
	if(initmove->or_moveflags & MFL_WALK)
		ms->moveflags |= MFL_WALK;
	ms->moveflags &= ~MFL_GRAPPLEPULL;
	if(initmove->or_moveflags & MFL_GRAPPLEPULL)
		ms->moveflags |= MFL_GRAPPLEPULL;
}								//end of the function BotInitMoveState

//========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//========================================================================
float AngleDiff(float ang1, float ang2)
{
	float           diff;

	diff = ang1 - ang2;
	if(ang1 > ang2)
	{
		if(diff > 180.0)
			diff -= 360.0;
	}							//end if
	else
	{
		if(diff < -180.0)
			diff += 360.0;
	}							//end else
	return diff;
}								//end of the function AngleDiff

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotFuzzyPointReachabilityArea(vec3_t origin)
{
	int             firstareanum, j, x, y, z;
	int             areas[10], numareas, areanum, bestareanum;
	float           dist, bestdist;
	vec3_t          points[10], v, end;

	firstareanum = 0;
	areanum = AAS_PointAreaNum(origin);
	if(areanum)
	{
		firstareanum = areanum;
		if(AAS_AreaReachability(areanum))
			return areanum;
	}							//end if
	VectorCopy(origin, end);
	end[2] += 4;
	numareas = AAS_TraceAreas(origin, end, areas, points, 10);
	for(j = 0; j < numareas; j++)
	{
		if(AAS_AreaReachability(areas[j]))
			return areas[j];
	}							//end for
	bestdist = 999999;
	bestareanum = 0;
	for(z = 1; z >= -1; z -= 1)
	{
		for(x = 1; x >= -1; x -= 1)
		{
			for(y = 1; y >= -1; y -= 1)
			{
				VectorCopy(origin, end);
				end[0] += x * 8;
				end[1] += y * 8;
				end[2] += z * 12;
				numareas = AAS_TraceAreas(origin, end, areas, points, 10);
				for(j = 0; j < numareas; j++)
				{
					if(AAS_AreaReachability(areas[j]))
					{
						VectorSubtract(points[j], origin, v);
						dist = VectorLength(v);
						if(dist < bestdist)
						{
							bestareanum = areas[j];
							bestdist = dist;
						}		//end if
					}			//end if
					if(!firstareanum)
						firstareanum = areas[j];
				}				//end for
			}					//end for
		}						//end for
		if(bestareanum)
			return bestareanum;
	}							//end for
	return firstareanum;
}								//end of the function BotFuzzyPointReachabilityArea

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotReachabilityArea(vec3_t origin, int client)
{
	int             modelnum, modeltype, reachnum, areanum;
	aas_reachability_t reach;
	vec3_t          org, end, mins, maxs, up = { 0, 0, 1 };
	bsp_trace_t     bsptrace;
	aas_trace_t     trace;

	//check if the bot is standing on something
	AAS_PresenceTypeBoundingBox(PRESENCE_CROUCH, mins, maxs);
	VectorMA(origin, -3, up, end);
	bsptrace = AAS_Trace(origin, mins, maxs, end, client, CONTENTS_SOLID | CONTENTS_PLAYERCLIP);
	if(!bsptrace.startsolid && bsptrace.fraction < 1 && bsptrace.ent != ENTITYNUM_NONE)
	{
		//if standing on the world the bot should be in a valid area
		if(bsptrace.ent == ENTITYNUM_WORLD)
		{
			return BotFuzzyPointReachabilityArea(origin);
		}						//end if

		modelnum = AAS_EntityModelindex(bsptrace.ent);
		modeltype = modeltypes[modelnum];

		//if standing on a func_plat or func_bobbing then the bot is assumed to be
		//in the area the reachability points to
		if(modeltype == MODELTYPE_FUNC_PLAT || modeltype == MODELTYPE_FUNC_BOB)
		{
			reachnum = AAS_NextModelReachability(0, modelnum);
			if(reachnum)
			{
				AAS_ReachabilityFromNum(reachnum, &reach);
				return reach.areanum;
			}					//end if
		}						//end else if

		//if the bot is swimming the bot should be in a valid area
		if(AAS_Swimming(origin))
		{
			return BotFuzzyPointReachabilityArea(origin);
		}						//end if
		//
		areanum = BotFuzzyPointReachabilityArea(origin);
		//if the bot is in an area with reachabilities
		if(areanum && AAS_AreaReachability(areanum))
			return areanum;
		//trace down till the ground is hit because the bot is standing on some other entity
		VectorCopy(origin, org);
		VectorCopy(org, end);
		end[2] -= 800;
		trace = AAS_TraceClientBBox(org, end, PRESENCE_CROUCH, -1);
		if(!trace.startsolid)
		{
			VectorCopy(trace.endpos, org);
		}						//end if
		//
		return BotFuzzyPointReachabilityArea(org);
	}							//end if
	//
	return BotFuzzyPointReachabilityArea(origin);
}								//end of the function BotReachabilityArea

//===========================================================================
// returns the reachability area the bot is in
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
/*
int BotReachabilityArea(vec3_t origin, int testground)
{
	int firstareanum, i, j, x, y, z;
	int areas[10], numareas, areanum, bestareanum;
	float dist, bestdist;
	vec3_t org, end, points[10], v;
	aas_trace_t trace;

	firstareanum = 0;
	for (i = 0; i < 2; i++)
	{
		VectorCopy(origin, org);
		//if test at the ground (used when bot is standing on an entity)
		if (i > 0)
		{
			VectorCopy(origin, end);
			end[2] -= 800;
			trace = AAS_TraceClientBBox(origin, end, PRESENCE_CROUCH, -1);
			if (!trace.startsolid)
			{
				VectorCopy(trace.endpos, org);
			} //end if
		} //end if

		firstareanum = 0;
		areanum = AAS_PointAreaNum(org);
		if (areanum)
		{
			firstareanum = areanum;
			if (AAS_AreaReachability(areanum)) return areanum;
		} //end if
		bestdist = 999999;
		bestareanum = 0;
		for (z = 1; z >= -1; z -= 1)
		{
			for (x = 1; x >= -1; x -= 1)
			{
				for (y = 1; y >= -1; y -= 1)
				{
					VectorCopy(org, end);
					end[0] += x * 8;
					end[1] += y * 8;
					end[2] += z * 12;
					numareas = AAS_TraceAreas(org, end, areas, points, 10);
					for (j = 0; j < numareas; j++)
					{
						if (AAS_AreaReachability(areas[j]))
						{
							VectorSubtract(points[j], org, v);
							dist = VectorLength(v);
							if (dist < bestdist)
							{
								bestareanum = areas[j];
								bestdist = dist;
							} //end if
						} //end if
					} //end for
				} //end for
			} //end for
			if (bestareanum) return bestareanum;
		} //end for
		if (!testground) break;
	} //end for
//#ifdef _DEBUG
	//botimport.Print(PRT_MESSAGE, "no reachability area\n");
//#endif //DEBUG
	return firstareanum;
} //end of the function BotReachabilityArea*/
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotOnMover(vec3_t origin, int entnum, aas_reachability_t * reach)
{
	int             i, modelnum;
	vec3_t          mins, maxs, modelorigin, org, end;
	vec3_t          angles = { 0, 0, 0 };
	vec3_t          boxmins = { -16, -16, -8 }, boxmaxs =
	{
	16, 16, 8};
	bsp_trace_t     trace;

	modelnum = reach->facenum & 0x0000FFFF;
	//get some bsp model info
	AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, NULL);
	//
	if(!AAS_OriginOfMoverWithModelNum(modelnum, modelorigin))
	{
		botimport.Print(PRT_MESSAGE, "no entity with model %d\n", modelnum);
		return qfalse;
	}							//end if
	//
	for(i = 0; i < 2; i++)
	{
		if(origin[i] > modelorigin[i] + maxs[i] + 16)
			return qfalse;
		if(origin[i] < modelorigin[i] + mins[i] - 16)
			return qfalse;
	}							//end for
	//
	VectorCopy(origin, org);
	org[2] += 24;
	VectorCopy(origin, end);
	end[2] -= 48;
	//
	trace = AAS_Trace(org, boxmins, boxmaxs, end, entnum, CONTENTS_SOLID | CONTENTS_PLAYERCLIP);
	if(!trace.startsolid && !trace.allsolid)
	{
		//NOTE: the reachability face number is the model number of the elevator
		if(trace.ent != ENTITYNUM_NONE && AAS_EntityModelNum(trace.ent) == modelnum)
		{
			return qtrue;
		}						//end if
	}							//end if
	return qfalse;
}								//end of the function BotOnMover

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int MoverDown(aas_reachability_t * reach)
{
	int             modelnum;
	vec3_t          mins, maxs, origin;
	vec3_t          angles = { 0, 0, 0 };

	modelnum = reach->facenum & 0x0000FFFF;
	//get some bsp model info
	AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin);
	//
	if(!AAS_OriginOfMoverWithModelNum(modelnum, origin))
	{
		botimport.Print(PRT_MESSAGE, "no entity with model %d\n", modelnum);
		return qfalse;
	}							//end if
	//if the top of the plat is below the reachability start point
	if(origin[2] + maxs[2] < reach->start[2])
		return qtrue;
	return qfalse;
}								//end of the function MoverDown

//========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//========================================================================
void BotSetBrushModelTypes(void)
{
	int             ent, modelnum;
	char            classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];

	Com_Memset(modeltypes, 0, MAX_MODELS * sizeof(int));
	//
	for(ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
	{
		if(!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY))
			continue;
		if(!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY))
			continue;
		if(model[0])
			modelnum = atoi(model + 1);
		else
			modelnum = 0;

		if(modelnum < 0 || modelnum > MAX_MODELS)
		{
			botimport.Print(PRT_MESSAGE, "entity %s model number out of range\n", classname);
			continue;
		}						//end if

		if(!Q_stricmp(classname, "func_bobbing"))
			modeltypes[modelnum] = MODELTYPE_FUNC_BOB;
		else if(!Q_stricmp(classname, "func_plat"))
			modeltypes[modelnum] = MODELTYPE_FUNC_PLAT;
		else if(!Q_stricmp(classname, "func_door"))
			modeltypes[modelnum] = MODELTYPE_FUNC_DOOR;
		else if(!Q_stricmp(classname, "func_static"))
			modeltypes[modelnum] = MODELTYPE_FUNC_STATIC;
	}							//end for
}								//end of the function BotSetBrushModelTypes

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotOnTopOfEntity(bot_movestate_t * ms)
{
	vec3_t          mins, maxs, end, up = { 0, 0, 1 };
	bsp_trace_t     trace;

	AAS_PresenceTypeBoundingBox(ms->presencetype, mins, maxs);
	VectorMA(ms->origin, -3, up, end);
	trace = AAS_Trace(ms->origin, mins, maxs, end, ms->entitynum, CONTENTS_SOLID | CONTENTS_PLAYERCLIP);
	if(!trace.startsolid && (trace.ent != ENTITYNUM_WORLD && trace.ent != ENTITYNUM_NONE))
	{
		return trace.ent;
	}							//end if
	return -1;
}								//end of the function BotOnTopOfEntity

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotValidTravel(vec3_t origin, aas_reachability_t * reach, int travelflags)
{
	//if the reachability uses an unwanted travel type
	if(AAS_TravelFlagForType(reach->traveltype) & ~travelflags)
		return qfalse;
	//don't go into areas with bad travel types
	if(AAS_AreaContentsTravelFlags(reach->areanum) & ~travelflags)
		return qfalse;
	return qtrue;
}								//end of the function BotValidTravel

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotAddToAvoidReach(bot_movestate_t * ms, int number, float avoidtime)
{
	int             i;

	for(i = 0; i < MAX_AVOIDREACH; i++)
	{
		if(ms->avoidreach[i] == number)
		{
			if(ms->avoidreachtimes[i] > AAS_Time())
				ms->avoidreachtries[i]++;
			else
				ms->avoidreachtries[i] = 1;
			ms->avoidreachtimes[i] = AAS_Time() + avoidtime;
			return;
		}						//end if
	}							//end for
	//add the reachability to the reachabilities to avoid for a while
	for(i = 0; i < MAX_AVOIDREACH; i++)
	{
		if(ms->avoidreachtimes[i] < AAS_Time())
		{
			ms->avoidreach[i] = number;
			ms->avoidreachtimes[i] = AAS_Time() + avoidtime;
			ms->avoidreachtries[i] = 1;
			return;
		}						//end if
	}							//end for
}								//end of the function BotAddToAvoidReach

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
float DistanceFromLineSquared(vec3_t p, vec3_t lp1, vec3_t lp2)
{
	vec3_t          proj, dir;
	int             j;

	AAS_ProjectPointOntoVector(p, lp1, lp2, proj);
	for(j = 0; j < 3; j++)
		if((proj[j] > lp1[j] && proj[j] > lp2[j]) || (proj[j] < lp1[j] && proj[j] < lp2[j]))
			break;
	if(j < 3)
	{
		if(fabs(proj[j] - lp1[j]) < fabs(proj[j] - lp2[j]))
			VectorSubtract(p, lp1, dir);
		else
			VectorSubtract(p, lp2, dir);
		return VectorLengthSquared(dir);
	}
	VectorSubtract(p, proj, dir);
	return VectorLengthSquared(dir);
}								//end of the function DistanceFromLineSquared

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
float VectorDistanceSquared(vec3_t p1, vec3_t p2)
{
	vec3_t          dir;

	VectorSubtract(p2, p1, dir);
	return VectorLengthSquared(dir);
}								//end of the function VectorDistanceSquared

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotAvoidSpots(vec3_t origin, aas_reachability_t * reach, bot_avoidspot_t * avoidspots, int numavoidspots)
{
	int             checkbetween, i, type;
	float           squareddist, squaredradius;

	switch (reach->traveltype & TRAVELTYPE_MASK)
	{
		case TRAVEL_WALK:
			checkbetween = qtrue;
			break;
		case TRAVEL_CROUCH:
			checkbetween = qtrue;
			break;
		case TRAVEL_BARRIERJUMP:
			checkbetween = qtrue;
			break;
		case TRAVEL_LADDER:
			checkbetween = qtrue;
			break;
		case TRAVEL_WALKOFFLEDGE:
			checkbetween = qfalse;
			break;
		case TRAVEL_JUMP:
			checkbetween = qfalse;
			break;
		case TRAVEL_SWIM:
			checkbetween = qtrue;
			break;
		case TRAVEL_WATERJUMP:
			checkbetween = qtrue;
			break;
		case TRAVEL_TELEPORT:
			checkbetween = qfalse;
			break;
		case TRAVEL_ELEVATOR:
			checkbetween = qfalse;
			break;
		case TRAVEL_GRAPPLEHOOK:
			checkbetween = qfalse;
			break;
		case TRAVEL_ROCKETJUMP:
			checkbetween = qfalse;
			break;
		case TRAVEL_BFGJUMP:
			checkbetween = qfalse;
			break;
		case TRAVEL_JUMPPAD:
			checkbetween = qfalse;
			break;
		case TRAVEL_FUNCBOB:
			checkbetween = qfalse;
			break;
		default:
			checkbetween = qtrue;
			break;
	}							//end switch

	type = AVOID_CLEAR;
	for(i = 0; i < numavoidspots; i++)
	{
		squaredradius = Square(avoidspots[i].radius);
		squareddist = DistanceFromLineSquared(avoidspots[i].origin, origin, reach->start);
		// if moving towards the avoid spot
		if(squareddist < squaredradius && VectorDistanceSquared(avoidspots[i].origin, origin) > squareddist)
		{
			type = avoidspots[i].type;
		}						//end if
		else if(checkbetween)
		{
			squareddist = DistanceFromLineSquared(avoidspots[i].origin, reach->start, reach->end);
			// if moving towards the avoid spot
			if(squareddist < squaredradius && VectorDistanceSquared(avoidspots[i].origin, reach->start) > squareddist)
			{
				type = avoidspots[i].type;
			}					//end if
		}						//end if
		else
		{
			VectorDistanceSquared(avoidspots[i].origin, reach->end);
			// if the reachability leads closer to the avoid spot
			if(squareddist < squaredradius && VectorDistanceSquared(avoidspots[i].origin, reach->start) > squareddist)
			{
				type = avoidspots[i].type;
			}					//end if
		}						//end else
		if(type == AVOID_ALWAYS)
			return type;
	}							//end for
	return type;
}								//end of the function BotAvoidSpots

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type)
{
	bot_movestate_t *ms;

	ms = BotMoveStateFromHandle(movestate);
	if(!ms)
		return;
	if(type == AVOID_CLEAR)
	{
		ms->numavoidspots = 0;
		return;
	}							//end if

	if(ms->numavoidspots >= MAX_AVOIDSPOTS)
		return;
	VectorCopy(origin, ms->avoidspots[ms->numavoidspots].origin);
	ms->avoidspots[ms->numavoidspots].radius = radius;
	ms->avoidspots[ms->numavoidspots].type = type;
	ms->numavoidspots++;
}								//end of the function BotAddAvoidSpot

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotGetReachabilityToGoal(vec3_t origin, int areanum,
							 int lastgoalareanum, int lastareanum,
							 int *avoidreach, float *avoidreachtimes, int *avoidreachtries,
							 bot_goal_t * goal, int travelflags, int movetravelflags,
							 struct bot_avoidspot_s *avoidspots, int numavoidspots, int *flags)
{
	int             i, t, besttime, bestreachnum, reachnum;
	aas_reachability_t reach;

	//if not in a valid area
	if(!areanum)
		return 0;
	//
	if(AAS_AreaDoNotEnter(areanum) || AAS_AreaDoNotEnter(goal->areanum))
	{
		travelflags |= TFL_DONOTENTER;
		movetravelflags |= TFL_DONOTENTER;
	}							//end if
	//use the routing to find the next area to go to
	besttime = 0;
	bestreachnum = 0;
	//
	for(reachnum = AAS_NextAreaReachability(areanum, 0); reachnum; reachnum = AAS_NextAreaReachability(areanum, reachnum))
	{
#ifdef AVOIDREACH
		//check if it isn't an reachability to avoid
		for(i = 0; i < MAX_AVOIDREACH; i++)
		{
			if(avoidreach[i] == reachnum && avoidreachtimes[i] >= AAS_Time())
				break;
		}						//end for
		if(i != MAX_AVOIDREACH && avoidreachtries[i] > AVOIDREACH_TRIES)
		{
#ifdef _DEBUG
			if(bot_developer)
			{
				botimport.Print(PRT_MESSAGE, "avoiding reachability %d\n", avoidreach[i]);
			}					//end if
#endif							//DEBUG
			continue;
		}						//end if
#endif							//AVOIDREACH
		//get the reachability from the number
		AAS_ReachabilityFromNum(reachnum, &reach);
		//NOTE: do not go back to the previous area if the goal didn't change
		//NOTE: is this actually avoidance of local routing minima between two areas???
		if(lastgoalareanum == goal->areanum && reach.areanum == lastareanum)
			continue;
		//if (AAS_AreaContentsTravelFlags(reach.areanum) & ~travelflags) continue;
		//if the travel isn't valid
		if(!BotValidTravel(origin, &reach, movetravelflags))
			continue;
		//get the travel time
		t = AAS_AreaTravelTimeToGoalArea(reach.areanum, reach.end, goal->areanum, travelflags);
		//if the goal area isn't reachable from the reachable area
		if(!t)
			continue;
		//if the bot should not use this reachability to avoid bad spots
		if(BotAvoidSpots(origin, &reach, avoidspots, numavoidspots))
		{
			if(flags)
			{
				*flags |= MOVERESULT_BLOCKEDBYAVOIDSPOT;
			}
			continue;
		}
		//add the travel time towards the area
		t += reach.traveltime;	// + AAS_AreaTravelTime(areanum, origin, reach.start);
		//if the travel time is better than the ones already found
		if(!besttime || t < besttime)
		{
			besttime = t;
			bestreachnum = reachnum;
		}						//end if
	}							//end for
	//
	return bestreachnum;
}								//end of the function BotGetReachabilityToGoal

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int BotAddToTarget(vec3_t start, vec3_t end, float maxdist, float *dist, vec3_t target)
{
	vec3_t          dir;
	float           curdist;

	VectorSubtract(end, start, dir);
	curdist = VectorNormalize(dir);
	if(*dist + curdist < maxdist)
	{
		VectorCopy(end, target);
		*dist += curdist;
		return qfalse;
	}							//end if
	else
	{
		VectorMA(start, maxdist - *dist, dir, target);
		*dist = maxdist;
		return qtrue;
	}							//end else
}								//end of the function BotAddToTarget

int BotMovementViewTarget(int movestate, bot_goal_t * goal, int travelflags, float lookahead, vec3_t target)
{
	aas_reachability_t reach;
	int             reachnum, lastareanum;
	bot_movestate_t *ms;
	vec3_t          end;
	float           dist;

	ms = BotMoveStateFromHandle(movestate);
	if(!ms)
		return qfalse;
	reachnum = 0;
	//if the bot has no goal or no last reachability
	if(!ms->lastreachnum || !goal)
		return qfalse;

	reachnum = ms->lastreachnum;
	VectorCopy(ms->origin, end);
	lastareanum = ms->lastareanum;
	dist = 0;
	while(reachnum && dist < lookahead)
	{
		AAS_ReachabilityFromNum(reachnum, &reach);
		if(BotAddToTarget(end, reach.start, lookahead, &dist, target))
			return qtrue;
		//never look beyond teleporters
		if((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_TELEPORT)
			return qtrue;
		//never look beyond the weapon jump point
		if((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_ROCKETJUMP)
			return qtrue;
		if((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_BFGJUMP)
			return qtrue;
		//don't add jump pad distances
		if((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_JUMPPAD &&
		   (reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_ELEVATOR && (reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_FUNCBOB)
		{
			if(BotAddToTarget(reach.start, reach.end, lookahead, &dist, target))
				return qtrue;
		}						//end if
		reachnum = BotGetReachabilityToGoal(reach.end, reach.areanum,
											ms->lastgoalareanum, lastareanum,
											ms->avoidreach, ms->avoidreachtimes, ms->avoidreachtries,
											goal, travelflags, travelflags, NULL, 0, NULL);
		VectorCopy(reach.end, end);
		lastareanum = reach.areanum;
		if(lastareanum == goal->areanum)
		{
			BotAddToTarget(reach.end, goal->origin, lookahead, &dist, target);
			return qtrue;
		}						//end if
	}							//end while
	//
	return qfalse;
}								//end of the function BotMovementViewTarget

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotVisible(int ent, vec3_t eye, vec3_t target)
{
	bsp_trace_t     trace;

	trace = AAS_Trace(eye, NULL, NULL, target, ent, CONTENTS_SOLID | CONTENTS_PLAYERCLIP);
	if(trace.fraction >= 1)
		return qtrue;
	return qfalse;
}								//end of the function BotVisible

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotPredictVisiblePosition(vec3_t origin, int areanum, bot_goal_t * goal, int travelflags, vec3_t target)
{
	aas_reachability_t reach;
	int             reachnum, lastgoalareanum, lastareanum, i;
	int             avoidreach[MAX_AVOIDREACH];
	float           avoidreachtimes[MAX_AVOIDREACH];
	int             avoidreachtries[MAX_AVOIDREACH];
	vec3_t          end;

	//if the bot has no goal or no last reachability
	if(!goal)
		return qfalse;
	//if the areanum is not valid
	if(!areanum)
		return qfalse;
	//if the goal areanum is not valid
	if(!goal->areanum)
		return qfalse;

	Com_Memset(avoidreach, 0, MAX_AVOIDREACH * sizeof(int));
	lastgoalareanum = goal->areanum;
	lastareanum = areanum;
	VectorCopy(origin, end);
	//only do 20 hops
	for(i = 0; i < 20 && (areanum != goal->areanum); i++)
	{
		//
		reachnum = BotGetReachabilityToGoal(end, areanum,
											lastgoalareanum, lastareanum,
											avoidreach, avoidreachtimes, avoidreachtries,
											goal, travelflags, travelflags, NULL, 0, NULL);
		if(!reachnum)
			return qfalse;
		AAS_ReachabilityFromNum(reachnum, &reach);
		//
		if(BotVisible(goal->entitynum, goal->origin, reach.start))
		{
			VectorCopy(reach.start, target);
			return qtrue;
		}						//end if
		//
		if(BotVisible(goal->entitynum, goal->origin, reach.end))
		{
			VectorCopy(reach.end, target);
			return qtrue;
		}						//end if
		//
		if(reach.areanum == goal->areanum)
		{
			VectorCopy(reach.end, target);
			return qtrue;
		}						//end if
		//
		lastareanum = areanum;
		areanum = reach.areanum;
		VectorCopy(reach.end, end);
		//
	}							//end while
	//
	return qfalse;
}								//end of the function BotPredictVisiblePosition

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void MoverBottomCenter(aas_reachability_t * reach, vec3_t bottomcenter)
{
	int             modelnum;
	vec3_t          mins, maxs, origin, mids;
	vec3_t          angles = { 0, 0, 0 };

	modelnum = reach->facenum & 0x0000FFFF;
	//get some bsp model info
	AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin);
	//
	if(!AAS_OriginOfMoverWithModelNum(modelnum, origin))
	{
		botimport.Print(PRT_MESSAGE, "no entity with model %d\n", modelnum);
	}							//end if
	//get a point just above the plat in the bottom position
	VectorAdd(mins, maxs, mids);
	VectorMA(origin, 0.5, mids, bottomcenter);
	bottomcenter[2] = reach->start[2];
}								//end of the function MoverBottomCenter

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
float BotGapDistance(vec3_t origin, vec3_t hordir, int entnum)
{
	float           dist, startz;
	vec3_t          start, end;
	aas_trace_t     trace;

	//do gap checking
	startz = origin[2];
	//this enables walking down stairs more fluidly
	{
		VectorCopy(origin, start);
		VectorCopy(origin, end);
		end[2] -= 60;
		trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, entnum);
		if(trace.fraction >= 1)
			return 1;
		startz = trace.endpos[2] + 1;
	}
	//
	for(dist = 8; dist <= 100; dist += 8)
	{
		VectorMA(origin, dist, hordir, start);
		start[2] = startz + 24;
		VectorCopy(start, end);
		end[2] -= 48 + sv_maxbarrier->value;
		trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, entnum);
		//if solid is found the bot can't walk any further and fall into a gap
		if(!trace.startsolid)
		{
			//if it is a gap
			if(trace.endpos[2] < startz - sv_maxstep->value - 8)
			{
				VectorCopy(trace.endpos, end);
				end[2] -= 20;
				if(AAS_PointContents(end) & CONTENTS_WATER)
					break;
				//if a gap is found slow down
				//botimport.Print(PRT_MESSAGE, "gap at %f\n", dist);
				return dist;
			}					//end if
			startz = trace.endpos[2];
		}						//end if
	}							//end for
	return 0;
}								//end of the function BotGapDistance

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotCheckBarrierJump(bot_movestate_t * ms, vec3_t dir, float speed)
{
	vec3_t          start, hordir, end;
	aas_trace_t     trace;

	VectorCopy(ms->origin, end);
	end[2] += sv_maxbarrier->value;
	//trace right up
	trace = AAS_TraceClientBBox(ms->origin, end, PRESENCE_NORMAL, ms->entitynum);
	//this shouldn't happen... but we check anyway
	if(trace.startsolid)
		return qfalse;
	//if very low ceiling it isn't possible to jump up to a barrier
	if(trace.endpos[2] - ms->origin[2] < sv_maxstep->value)
		return qfalse;
	//
	hordir[0] = dir[0];
	hordir[1] = dir[1];
	hordir[2] = 0;
	VectorNormalize(hordir);
	VectorMA(ms->origin, ms->thinktime * speed * 0.5, hordir, end);
	VectorCopy(trace.endpos, start);
	end[2] = trace.endpos[2];
	//trace from previous trace end pos horizontally in the move direction
	trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, ms->entitynum);
	//again this shouldn't happen
	if(trace.startsolid)
		return qfalse;
	//
	VectorCopy(trace.endpos, start);
	VectorCopy(trace.endpos, end);
	end[2] = ms->origin[2];
	//trace down from the previous trace end pos
	trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, ms->entitynum);
	//if solid
	if(trace.startsolid)
		return qfalse;
	//if no obstacle at all
	if(trace.fraction >= 1.0)
		return qfalse;
	//if less than the maximum step height
	if(trace.endpos[2] - ms->origin[2] < sv_maxstep->value)
		return qfalse;
	//
	EA_Jump(ms->client);
	EA_Move(ms->client, hordir, speed);
	ms->moveflags |= MFL_BARRIERJUMP;
	//there is a barrier
	return qtrue;
}								//end of the function BotCheckBarrierJump

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotSwimInDirection(bot_movestate_t * ms, vec3_t dir, float speed, int type)
{
	vec3_t          normdir;

	VectorCopy(dir, normdir);
	VectorNormalize(normdir);
	EA_Move(ms->client, normdir, speed);
	return qtrue;
}								//end of the function BotSwimInDirection

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotWalkInDirection(bot_movestate_t * ms, vec3_t dir, float speed, int type)
{
	vec3_t          hordir, cmdmove, velocity, tmpdir, origin;
	int             presencetype, maxframes, cmdframes, stopevent;
	aas_clientmove_t move;
	float           dist;

	if(AAS_OnGround(ms->origin, ms->presencetype, ms->entitynum))
		ms->moveflags |= MFL_ONGROUND;
	//if the bot is on the ground
	if(ms->moveflags & MFL_ONGROUND)
	{
		//if there is a barrier the bot can jump on
		if(BotCheckBarrierJump(ms, dir, speed))
			return qtrue;
		//remove barrier jump flag
		ms->moveflags &= ~MFL_BARRIERJUMP;
		//get the presence type for the movement
		if((type & MOVE_CROUCH) && !(type & MOVE_JUMP))
			presencetype = PRESENCE_CROUCH;
		else
			presencetype = PRESENCE_NORMAL;
		//horizontal direction
		hordir[0] = dir[0];
		hordir[1] = dir[1];
		hordir[2] = 0;
		VectorNormalize(hordir);
		//if the bot is not supposed to jump
		if(!(type & MOVE_JUMP))
		{
			//if there is a gap, try to jump over it
			if(BotGapDistance(ms->origin, hordir, ms->entitynum) > 0)
				type |= MOVE_JUMP;
		}						//end if
		//get command movement
		VectorScale(hordir, speed, cmdmove);
		VectorCopy(ms->velocity, velocity);
		//
		if(type & MOVE_JUMP)
		{
			//botimport.Print(PRT_MESSAGE, "trying jump\n");
			cmdmove[2] = 400;
			maxframes = PREDICTIONTIME_JUMP / 0.1;
			cmdframes = 1;
			stopevent = SE_HITGROUND | SE_HITGROUNDDAMAGE | SE_ENTERWATER | SE_ENTERSLIME | SE_ENTERLAVA;
		}						//end if
		else
		{
			maxframes = 2;
			cmdframes = 2;
			stopevent = SE_HITGROUNDDAMAGE | SE_ENTERWATER | SE_ENTERSLIME | SE_ENTERLAVA;
		}						//end else
		//AAS_ClearShownDebugLines();
		//
		VectorCopy(ms->origin, origin);
		origin[2] += 0.5;
		AAS_PredictClientMovement(&move, ms->entitynum, origin, presencetype, qtrue, velocity, cmdmove, cmdframes, maxframes, 0.1f, stopevent, 0, qfalse);	//qtrue);
		//if prediction time wasn't enough to fully predict the movement
		if(move.frames >= maxframes && (type & MOVE_JUMP))
		{
			//botimport.Print(PRT_MESSAGE, "client %d: max prediction frames\n", ms->client);
			return qfalse;
		}						//end if
		//don't enter slime or lava and don't fall from too high
		if(move.stopevent & (SE_ENTERSLIME | SE_ENTERLAVA | SE_HITGROUNDDAMAGE))
		{
			//botimport.Print(PRT_MESSAGE, "client %d: would be hurt ", ms->client);
			//if (move.stopevent & SE_ENTERSLIME) botimport.Print(PRT_MESSAGE, "slime\n");
			//if (move.stopevent & SE_ENTERLAVA) botimport.Print(PRT_MESSAGE, "lava\n");
			//if (move.stopevent & SE_HITGROUNDDAMAGE) botimport.Print(PRT_MESSAGE, "hitground\n");
			return qfalse;
		}						//end if
		//if ground was hit
		if(move.stopevent & SE_HITGROUND)
		{
			//check for nearby gap
			VectorNormalize2(move.velocity, tmpdir);
			dist = BotGapDistance(move.endpos, tmpdir, ms->entitynum);
			if(dist > 0)
				return qfalse;
			//
			dist = BotGapDistance(move.endpos, hordir, ms->entitynum);
			if(dist > 0)
				return qfalse;
		}						//end if
		//get horizontal movement
		tmpdir[0] = move.endpos[0] - ms->origin[0];
		tmpdir[1] = move.endpos[1] - ms->origin[1];
		tmpdir[2] = 0;
		//
		//AAS_DrawCross(move.endpos, 4, LINECOLOR_BLUE);
		//the bot is blocked by something
		if(VectorLength(tmpdir) < speed * ms->thinktime * 0.5)
			return qfalse;
		//perform the movement
		if(type & MOVE_JUMP)
			EA_Jump(ms->client);
		if(type & MOVE_CROUCH)
			EA_Crouch(ms->client);
		EA_Move(ms->client, hordir, speed);
		//movement was succesfull
		return qtrue;
	}							//end if
	else
	{
		if(ms->moveflags & MFL_BARRIERJUMP)
		{
			//if near the top or going down
			if(ms->velocity[2] < 50)
			{
				EA_Move(ms->client, dir, speed);
			}					//end if
		}						//end if
		//FIXME: do air control to avoid hazards
		return qtrue;
	}							//end else
}								//end of the function BotWalkInDirection

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotMoveInDirection(int movestate, vec3_t dir, float speed, int type)
{
	bot_movestate_t *ms;

	ms = BotMoveStateFromHandle(movestate);
	if(!ms)
		return qfalse;
	//if swimming
	if(AAS_Swimming(ms->origin))
	{
		return BotSwimInDirection(ms, dir, speed, type);
	}							//end if
	else
	{
		return BotWalkInDirection(ms, dir, speed, type);
	}							//end else
}								//end of the function BotMoveInDirection

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int Intersection(vec2_t p1, vec2_t p2, vec2_t p3, vec2_t p4, vec2_t out)
{
	float           x1, dx1, dy1, x2, dx2, dy2, d;

	dx1 = p2[0] - p1[0];
	dy1 = p2[1] - p1[1];
	dx2 = p4[0] - p3[0];
	dy2 = p4[1] - p3[1];

	d = dy1 * dx2 - dx1 * dy2;
	if(d != 0)
	{
		x1 = p1[1] * dx1 - p1[0] * dy1;
		x2 = p3[1] * dx2 - p3[0] * dy2;
		out[0] = (int)((dx1 * x2 - dx2 * x1) / d);
		out[1] = (int)((dy1 * x2 - dy2 * x1) / d);
		return qtrue;
	}							//end if
	else
	{
		return qfalse;
	}							//end else
}								//end of the function Intersection

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotCheckBlocked(bot_movestate_t * ms, vec3_t dir, int checkbottom, bot_moveresult_t * result)
{
	vec3_t          mins, maxs, end, up = { 0, 0, 1 };
	bsp_trace_t     trace;

	//test for entities obstructing the bot's path
	AAS_PresenceTypeBoundingBox(ms->presencetype, mins, maxs);
	//
	if(fabs(DotProduct(dir, up)) < 0.7)
	{
		mins[2] += sv_maxstep->value;	//if the bot can step on
		maxs[2] -= 10;			//a little lower to avoid low ceiling
	}							//end if
	VectorMA(ms->origin, 3, dir, end);
	trace = AAS_Trace(ms->origin, mins, maxs, end, ms->entitynum, CONTENTS_SOLID | CONTENTS_PLAYERCLIP | CONTENTS_BODY);
	//if not started in solid and not hitting the world entity
	if(!trace.startsolid && (trace.ent != ENTITYNUM_WORLD && trace.ent != ENTITYNUM_NONE))
	{
		result->blocked = qtrue;
		result->blockentity = trace.ent;
#ifdef _DEBUG
		//botimport.Print(PRT_MESSAGE, "%d: BotCheckBlocked: I'm blocked\n", ms->client);
#endif							//DEBUG
	}							//end if
	//if not in an area with reachability
	else if(checkbottom && !AAS_AreaReachability(ms->areanum))
	{
		//check if the bot is standing on something
		AAS_PresenceTypeBoundingBox(ms->presencetype, mins, maxs);
		VectorMA(ms->origin, -3, up, end);
		trace = AAS_Trace(ms->origin, mins, maxs, end, ms->entitynum, CONTENTS_SOLID | CONTENTS_PLAYERCLIP);
		if(!trace.startsolid && (trace.ent != ENTITYNUM_WORLD && trace.ent != ENTITYNUM_NONE))
		{
			result->blocked = qtrue;
			result->blockentity = trace.ent;
			result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
#ifdef _DEBUG
			//botimport.Print(PRT_MESSAGE, "%d: BotCheckBlocked: I'm blocked\n", ms->client);
#endif							//DEBUG
		}						//end if
	}							//end else
}								//end of the function BotCheckBlocked

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotClearMoveResult(bot_moveresult_t * moveresult)
{
	moveresult->failure = qfalse;
	moveresult->type = 0;
	moveresult->blocked = qfalse;
	moveresult->blockentity = 0;
	moveresult->traveltype = 0;
	moveresult->flags = 0;
}								//end of the function BotClearMoveResult

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_Walk(bot_movestate_t * ms, aas_reachability_t * reach)
{
	float           dist, speed;
	vec3_t          hordir;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//first walk straight to the reachability start
	hordir[0] = reach->start[0] - ms->origin[0];
	hordir[1] = reach->start[1] - ms->origin[1];
	hordir[2] = 0;
	dist = VectorNormalize(hordir);
	//
	BotCheckBlocked(ms, hordir, qtrue, &result);
	//
	if(dist < 10)
	{
		//walk straight to the reachability end
		hordir[0] = reach->end[0] - ms->origin[0];
		hordir[1] = reach->end[1] - ms->origin[1];
		hordir[2] = 0;
		dist = VectorNormalize(hordir);
	}							//end if
	//if going towards a crouch area
	if(!(AAS_AreaPresenceType(reach->areanum) & PRESENCE_NORMAL))
	{
		//if pretty close to the reachable area
		if(dist < 20)
			EA_Crouch(ms->client);
	}							//end if
	//
	dist = BotGapDistance(ms->origin, hordir, ms->entitynum);
	//
	if(ms->moveflags & MFL_WALK)
	{
		if(dist > 0)
			speed = 200 - (180 - 1 * dist);
		else
			speed = 200;
		EA_Walk(ms->client);
	}							//end if
	else
	{
		if(dist > 0)
			speed = 400 - (360 - 2 * dist);
		else
			speed = 400;
	}							//end else
	//elemantary action move in direction
	EA_Move(ms->client, hordir, speed);
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotTravel_Walk

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotFinishTravel_Walk(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          hordir;
	float           dist, speed;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//if not on the ground and changed areas... don't walk back!!
	//(doesn't seem to help)
	/*
	   ms->areanum = BotFuzzyPointReachabilityArea(ms->origin);
	   if (ms->areanum == reach->areanum)
	   {
	   #ifdef _DEBUG
	   botimport.Print(PRT_MESSAGE, "BotFinishTravel_Walk: already in reach area\n");
	   #endif //DEBUG
	   return result;
	   } //end if */
	//go straight to the reachability end
	hordir[0] = reach->end[0] - ms->origin[0];
	hordir[1] = reach->end[1] - ms->origin[1];
	hordir[2] = 0;
	dist = VectorNormalize(hordir);
	//
	if(dist > 100)
		dist = 100;
	speed = 400 - (400 - 3 * dist);
	//
	EA_Move(ms->client, hordir, speed);
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotFinishTravel_Walk

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_Crouch(bot_movestate_t * ms, aas_reachability_t * reach)
{
	float           speed;
	vec3_t          hordir;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//
	speed = 400;
	//walk straight to reachability end
	hordir[0] = reach->end[0] - ms->origin[0];
	hordir[1] = reach->end[1] - ms->origin[1];
	hordir[2] = 0;
	VectorNormalize(hordir);
	//
	BotCheckBlocked(ms, hordir, qtrue, &result);
	//elemantary actions
	EA_Crouch(ms->client);
	EA_Move(ms->client, hordir, speed);
	//
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotTravel_Crouch

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_BarrierJump(bot_movestate_t * ms, aas_reachability_t * reach)
{
	float           dist, speed;
	vec3_t          hordir;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//walk straight to reachability start
	hordir[0] = reach->start[0] - ms->origin[0];
	hordir[1] = reach->start[1] - ms->origin[1];
	hordir[2] = 0;
	dist = VectorNormalize(hordir);
	//
	BotCheckBlocked(ms, hordir, qtrue, &result);
	//if pretty close to the barrier
	if(dist < 9)
	{
		EA_Jump(ms->client);
	}							//end if
	else
	{
		if(dist > 60)
			dist = 60;
		speed = 360 - (360 - 6 * dist);
		EA_Move(ms->client, hordir, speed);
	}							//end else
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotTravel_BarrierJump

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotFinishTravel_BarrierJump(bot_movestate_t * ms, aas_reachability_t * reach)
{
	float           dist;
	vec3_t          hordir;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//if near the top or going down
	if(ms->velocity[2] < 250)
	{
		hordir[0] = reach->end[0] - ms->origin[0];
		hordir[1] = reach->end[1] - ms->origin[1];
		hordir[2] = 0;
		dist = VectorNormalize(hordir);
		//
		BotCheckBlocked(ms, hordir, qtrue, &result);
		//
		EA_Move(ms->client, hordir, 400);
		VectorCopy(hordir, result.movedir);
	}							//end if
	//
	return result;
}								//end of the function BotFinishTravel_BarrierJump

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_Swim(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          dir;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//swim straight to reachability end
	VectorSubtract(reach->start, ms->origin, dir);
	VectorNormalize(dir);
	//
	BotCheckBlocked(ms, dir, qtrue, &result);
	//elemantary actions
	EA_Move(ms->client, dir, 400);
	//
	VectorCopy(dir, result.movedir);
	Vector2Angles(dir, result.ideal_viewangles);
	result.flags |= MOVERESULT_SWIMVIEW;
	//
	return result;
}								//end of the function BotTravel_Swim

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_WaterJump(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          dir, hordir;
	float           dist;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//swim straight to reachability end
	VectorSubtract(reach->end, ms->origin, dir);
	VectorCopy(dir, hordir);
	hordir[2] = 0;
	dir[2] += 15 + crandom() * 40;
	//botimport.Print(PRT_MESSAGE, "BotTravel_WaterJump: dir[2] = %f\n", dir[2]);
	VectorNormalize(dir);
	dist = VectorNormalize(hordir);
	//elemantary actions
	//EA_Move(ms->client, dir, 400);
	EA_MoveForward(ms->client);
	//move up if close to the actual out of water jump spot
	if(dist < 40)
		EA_MoveUp(ms->client);
	//set the ideal view angles
	Vector2Angles(dir, result.ideal_viewangles);
	result.flags |= MOVERESULT_MOVEMENTVIEW;
	//
	VectorCopy(dir, result.movedir);
	//
	return result;
}								//end of the function BotTravel_WaterJump

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotFinishTravel_WaterJump(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          dir, pnt;
	float           dist;
	bot_moveresult_t result;

	//botimport.Print(PRT_MESSAGE, "BotFinishTravel_WaterJump\n");
	BotClearMoveResult(&result);
	//if waterjumping there's nothing to do
	if(ms->moveflags & MFL_WATERJUMP)
		return result;
	//if not touching any water anymore don't do anything
	//otherwise the bot sometimes keeps jumping?
	VectorCopy(ms->origin, pnt);
	pnt[2] -= 32;				//extra for q2dm4 near red armor/mega health
	if(!(AAS_PointContents(pnt) & (CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_WATER)))
		return result;
	//swim straight to reachability end
	VectorSubtract(reach->end, ms->origin, dir);
	dir[0] += crandom() * 10;
	dir[1] += crandom() * 10;
	dir[2] += 70 + crandom() * 10;
	dist = VectorNormalize(dir);
	//elemantary actions
	EA_Move(ms->client, dir, 400);
	//set the ideal view angles
	Vector2Angles(dir, result.ideal_viewangles);
	result.flags |= MOVERESULT_MOVEMENTVIEW;
	//
	VectorCopy(dir, result.movedir);
	//
	return result;
}								//end of the function BotFinishTravel_WaterJump

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_WalkOffLedge(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          hordir, dir;
	float           dist, speed, reachhordist;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//check if the bot is blocked by anything
	VectorSubtract(reach->start, ms->origin, dir);
	VectorNormalize(dir);
	BotCheckBlocked(ms, dir, qtrue, &result);
	//if the reachability start and end are practially above each other
	VectorSubtract(reach->end, reach->start, dir);
	dir[2] = 0;
	reachhordist = VectorLength(dir);
	//walk straight to the reachability start
	hordir[0] = reach->start[0] - ms->origin[0];
	hordir[1] = reach->start[1] - ms->origin[1];
	hordir[2] = 0;
	dist = VectorNormalize(hordir);
	//if pretty close to the start focus on the reachability end
	if(dist < 48)
	{
		hordir[0] = reach->end[0] - ms->origin[0];
		hordir[1] = reach->end[1] - ms->origin[1];
		hordir[2] = 0;
		VectorNormalize(hordir);
		//
		if(reachhordist < 20)
		{
			speed = 100;
		}						//end if
		else if(!AAS_HorizontalVelocityForJump(0, reach->start, reach->end, &speed))
		{
			speed = 400;
		}						//end if
	}							//end if
	else
	{
		if(reachhordist < 20)
		{
			if(dist > 64)
				dist = 64;
			speed = 400 - (256 - 4 * dist);
		}						//end if
		else
		{
			speed = 400;
		}						//end else
	}							//end else
	//
	BotCheckBlocked(ms, hordir, qtrue, &result);
	//elemantary action
	EA_Move(ms->client, hordir, speed);
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotTravel_WalkOffLedge

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotAirControl(vec3_t origin, vec3_t velocity, vec3_t goal, vec3_t dir, float *speed)
{
	vec3_t          org, vel;
	float           dist;
	int             i;

	VectorCopy(origin, org);
	VectorScale(velocity, 0.1, vel);
	for(i = 0; i < 50; i++)
	{
		vel[2] -= sv_gravity->value * 0.01;
		//if going down and next position would be below the goal
		if(vel[2] < 0 && org[2] + vel[2] < goal[2])
		{
			VectorScale(vel, (goal[2] - org[2]) / vel[2], vel);
			VectorAdd(org, vel, org);
			VectorSubtract(goal, org, dir);
			dist = VectorNormalize(dir);
			if(dist > 32)
				dist = 32;
			*speed = 400 - (400 - 13 * dist);
			return qtrue;
		}						//end if
		else
		{
			VectorAdd(org, vel, org);
		}						//end else
	}							//end for
	VectorSet(dir, 0, 0, 0);
	*speed = 400;
	return qfalse;
}								//end of the function BotAirControl

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotFinishTravel_WalkOffLedge(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          dir, hordir, end, v;
	float           dist, speed;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//
	VectorSubtract(reach->end, ms->origin, dir);
	BotCheckBlocked(ms, dir, qtrue, &result);
	//
	VectorSubtract(reach->end, ms->origin, v);
	v[2] = 0;
	dist = VectorNormalize(v);
	if(dist > 16)
		VectorMA(reach->end, 16, v, end);
	else
		VectorCopy(reach->end, end);
	//
	if(!BotAirControl(ms->origin, ms->velocity, end, hordir, &speed))
	{
		//go straight to the reachability end
		VectorCopy(dir, hordir);
		hordir[2] = 0;
		//
		dist = VectorNormalize(hordir);
		speed = 400;
	}							//end if
	//
	EA_Move(ms->client, hordir, speed);
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotFinishTravel_WalkOffLedge

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
/*
bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
{
	vec3_t hordir;
	float dist, gapdist, speed, horspeed, sv_jumpvel;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//
	sv_jumpvel = botlibglobals.sv_jumpvel->value;
	//walk straight to the reachability start
	hordir[0] = reach->start[0] - ms->origin[0];
	hordir[1] = reach->start[1] - ms->origin[1];
	hordir[2] = 0;
	dist = VectorNormalize(hordir);
	//
	speed = 350;
	//
	gapdist = BotGapDistance(ms, hordir, ms->entitynum);
	//if pretty close to the start focus on the reachability end
	if (dist < 50 || (gapdist && gapdist < 50))
	{
		//NOTE: using max speed (400) works best
		//if (AAS_HorizontalVelocityForJump(sv_jumpvel, ms->origin, reach->end, &horspeed))
		//{
		//	speed = horspeed * 400 / botlibglobals.sv_maxwalkvelocity->value;
		//} //end if
		hordir[0] = reach->end[0] - ms->origin[0];
		hordir[1] = reach->end[1] - ms->origin[1];
		VectorNormalize(hordir);
		//elemantary action jump
		EA_Jump(ms->client);
		//
		ms->jumpreach = ms->lastreachnum;
		speed = 600;
	} //end if
	else
	{
		if (AAS_HorizontalVelocityForJump(sv_jumpvel, reach->start, reach->end, &horspeed))
		{
			speed = horspeed * 400 / botlibglobals.sv_maxwalkvelocity->value;
		} //end if
	} //end else
	//elemantary action
	EA_Move(ms->client, hordir, speed);
	VectorCopy(hordir, result.movedir);
	//
	return result;
} //end of the function BotTravel_Jump*/
/*
bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
{
	vec3_t hordir, dir1, dir2, mins, maxs, start, end;
	float dist1, dist2, speed;
	bot_moveresult_t result;
	bsp_trace_t trace;

	BotClearMoveResult(&result);
	//
	hordir[0] = reach->start[0] - reach->end[0];
	hordir[1] = reach->start[1] - reach->end[1];
	hordir[2] = 0;
	VectorNormalize(hordir);
	//
	VectorCopy(reach->start, start);
	start[2] += 1;
	//minus back the bouding box size plus 16
	VectorMA(reach->start, 80, hordir, end);
	//
	AAS_PresenceTypeBoundingBox(PRESENCE_NORMAL, mins, maxs);
	//check for solids
	trace = AAS_Trace(start, mins, maxs, end, ms->entitynum, MASK_PLAYERSOLID);
	if (trace.startsolid) VectorCopy(start, trace.endpos);
	//check for a gap
	for (dist1 = 0; dist1 < 80; dist1 += 10)
	{
		VectorMA(start, dist1+10, hordir, end);
		end[2] += 1;
		if (AAS_PointAreaNum(end) != ms->reachareanum) break;
	} //end for
	if (dist1 < 80) VectorMA(reach->start, dist1, hordir, trace.endpos);
//	dist1 = BotGapDistance(start, hordir, ms->entitynum);
//	if (dist1 && dist1 <= trace.fraction * 80) VectorMA(reach->start, dist1-20, hordir, trace.endpos);
	//
	VectorSubtract(ms->origin, reach->start, dir1);
	dir1[2] = 0;
	dist1 = VectorNormalize(dir1);
	VectorSubtract(ms->origin, trace.endpos, dir2);
	dir2[2] = 0;
	dist2 = VectorNormalize(dir2);
	//if just before the reachability start
	if (DotProduct(dir1, dir2) < -0.8 || dist2 < 5)
	{
		//botimport.Print(PRT_MESSAGE, "between jump start and run to point\n");
		hordir[0] = reach->end[0] - ms->origin[0];
		hordir[1] = reach->end[1] - ms->origin[1];
		hordir[2] = 0;
		VectorNormalize(hordir);
		//elemantary action jump
		if (dist1 < 24) EA_Jump(ms->client);
		else if (dist1 < 32) EA_DelayedJump(ms->client);
		EA_Move(ms->client, hordir, 600);
		//
		ms->jumpreach = ms->lastreachnum;
	} //end if
	else
	{
		//botimport.Print(PRT_MESSAGE, "going towards run to point\n");
		hordir[0] = trace.endpos[0] - ms->origin[0];
		hordir[1] = trace.endpos[1] - ms->origin[1];
		hordir[2] = 0;
		VectorNormalize(hordir);
		//
		if (dist2 > 80) dist2 = 80;
		speed = 400 - (400 - 5 * dist2);
		EA_Move(ms->client, hordir, speed);
	} //end else
	VectorCopy(hordir, result.movedir);
	//
	return result;
} //end of the function BotTravel_Jump*/
//*
bot_moveresult_t BotTravel_Jump(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          hordir, dir1, dir2, start, end, runstart;

//  vec3_t runstart, dir1, dir2, hordir;
	float           dist1, dist2, speed;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//
	AAS_JumpReachRunStart(reach, runstart);
	//*
	hordir[0] = runstart[0] - reach->start[0];
	hordir[1] = runstart[1] - reach->start[1];
	hordir[2] = 0;
	VectorNormalize(hordir);
	//
	VectorCopy(reach->start, start);
	start[2] += 1;
	VectorMA(reach->start, 80, hordir, runstart);
	//check for a gap
	for(dist1 = 0; dist1 < 80; dist1 += 10)
	{
		VectorMA(start, dist1 + 10, hordir, end);
		end[2] += 1;
		if(AAS_PointAreaNum(end) != ms->reachareanum)
			break;
	}							//end for
	if(dist1 < 80)
		VectorMA(reach->start, dist1, hordir, runstart);
	//
	VectorSubtract(ms->origin, reach->start, dir1);
	dir1[2] = 0;
	dist1 = VectorNormalize(dir1);
	VectorSubtract(ms->origin, runstart, dir2);
	dir2[2] = 0;
	dist2 = VectorNormalize(dir2);
	//if just before the reachability start
	if(DotProduct(dir1, dir2) < -0.8 || dist2 < 5)
	{
//      botimport.Print(PRT_MESSAGE, "between jump start and run start point\n");
		hordir[0] = reach->end[0] - ms->origin[0];
		hordir[1] = reach->end[1] - ms->origin[1];
		hordir[2] = 0;
		VectorNormalize(hordir);
		//elemantary action jump
		if(dist1 < 24)
			EA_Jump(ms->client);
		else if(dist1 < 32)
			EA_DelayedJump(ms->client);
		EA_Move(ms->client, hordir, 600);
		//
		ms->jumpreach = ms->lastreachnum;
	}							//end if
	else
	{
//      botimport.Print(PRT_MESSAGE, "going towards run start point\n");
		hordir[0] = runstart[0] - ms->origin[0];
		hordir[1] = runstart[1] - ms->origin[1];
		hordir[2] = 0;
		VectorNormalize(hordir);
		//
		if(dist2 > 80)
			dist2 = 80;
		speed = 400 - (400 - 5 * dist2);
		EA_Move(ms->client, hordir, speed);
	}							//end else
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotTravel_Jump*/

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotFinishTravel_Jump(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          hordir, hordir2;
	float           speed, dist;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//if not jumped yet
	if(!ms->jumpreach)
		return result;
	//go straight to the reachability end
	hordir[0] = reach->end[0] - ms->origin[0];
	hordir[1] = reach->end[1] - ms->origin[1];
	hordir[2] = 0;
	dist = VectorNormalize(hordir);
	//
	hordir2[0] = reach->end[0] - reach->start[0];
	hordir2[1] = reach->end[1] - reach->start[1];
	hordir2[2] = 0;
	VectorNormalize(hordir2);
	//
	if(DotProduct(hordir, hordir2) < -0.5 && dist < 24)
		return result;
	//always use max speed when traveling through the air
	speed = 800;
	//
	EA_Move(ms->client, hordir, speed);
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotFinishTravel_Jump

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_Ladder(bot_movestate_t * ms, aas_reachability_t * reach)
{
	//float dist, speed;
	vec3_t          dir, viewdir;	//, hordir;
	vec3_t          origin = { 0, 0, 0 };
//  vec3_t up = {0, 0, 1};
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//
//  if ((ms->moveflags & MFL_AGAINSTLADDER))
	//NOTE: not a good idea for ladders starting in water
	// || !(ms->moveflags & MFL_ONGROUND))
	{
		//botimport.Print(PRT_MESSAGE, "against ladder or not on ground\n");
		VectorSubtract(reach->end, ms->origin, dir);
		VectorNormalize(dir);
		//set the ideal view angles, facing the ladder up or down
		viewdir[0] = dir[0];
		viewdir[1] = dir[1];
		viewdir[2] = 3 * dir[2];
		Vector2Angles(viewdir, result.ideal_viewangles);
		//elemantary action
		EA_Move(ms->client, origin, 0);
		EA_MoveForward(ms->client);
		//set movement view flag so the AI can see the view is focussed
		result.flags |= MOVERESULT_MOVEMENTVIEW;
	}							//end if
/*	else
	{
		//botimport.Print(PRT_MESSAGE, "moving towards ladder\n");
		VectorSubtract(reach->end, ms->origin, dir);
		//make sure the horizontal movement is large anough
		VectorCopy(dir, hordir);
		hordir[2] = 0;
		dist = VectorNormalize(hordir);
		//
		dir[0] = hordir[0];
		dir[1] = hordir[1];
		if (dir[2] > 0) dir[2] = 1;
		else dir[2] = -1;
		if (dist > 50) dist = 50;
		speed = 400 - (200 - 4 * dist);
		EA_Move(ms->client, dir, speed);
	} //end else*/
	//save the movement direction
	VectorCopy(dir, result.movedir);
	//
	return result;
}								//end of the function BotTravel_Ladder

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_Teleport(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          hordir;
	float           dist;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//if the bot is being teleported
	if(ms->moveflags & MFL_TELEPORTED)
		return result;

	//walk straight to center of the teleporter
	VectorSubtract(reach->start, ms->origin, hordir);
	if(!(ms->moveflags & MFL_SWIMMING))
		hordir[2] = 0;
	dist = VectorNormalize(hordir);
	//
	BotCheckBlocked(ms, hordir, qtrue, &result);

	if(dist < 30)
		EA_Move(ms->client, hordir, 200);
	else
		EA_Move(ms->client, hordir, 400);

	if(ms->moveflags & MFL_SWIMMING)
		result.flags |= MOVERESULT_SWIMVIEW;

	VectorCopy(hordir, result.movedir);
	return result;
}								//end of the function BotTravel_Teleport

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_Elevator(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          dir, dir1, dir2, hordir, bottomcenter;
	float           dist, dist1, dist2, speed;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//if standing on the plat
	if(BotOnMover(ms->origin, ms->entitynum, reach))
	{
#ifdef DEBUG_ELEVATOR
		botimport.Print(PRT_MESSAGE, "bot on elevator\n");
#endif							//DEBUG_ELEVATOR
		//if vertically not too far from the end point
		if(abs(ms->origin[2] - reach->end[2]) < sv_maxbarrier->value)
		{
#ifdef DEBUG_ELEVATOR
			botimport.Print(PRT_MESSAGE, "bot moving to end\n");
#endif							//DEBUG_ELEVATOR
			//move to the end point
			VectorSubtract(reach->end, ms->origin, hordir);
			hordir[2] = 0;
			VectorNormalize(hordir);
			if(!BotCheckBarrierJump(ms, hordir, 100))
			{
				EA_Move(ms->client, hordir, 400);
			}					//end if
			VectorCopy(hordir, result.movedir);
		}						//end else
		//if not really close to the center of the elevator
		else
		{
			MoverBottomCenter(reach, bottomcenter);
			VectorSubtract(bottomcenter, ms->origin, hordir);
			hordir[2] = 0;
			dist = VectorNormalize(hordir);
			//
			if(dist > 10)
			{
#ifdef DEBUG_ELEVATOR
				botimport.Print(PRT_MESSAGE, "bot moving to center\n");
#endif							//DEBUG_ELEVATOR
				//move to the center of the plat
				if(dist > 100)
					dist = 100;
				speed = 400 - (400 - 4 * dist);
				//
				EA_Move(ms->client, hordir, speed);
				VectorCopy(hordir, result.movedir);
			}					//end if
		}						//end else
	}							//end if
	else
	{
#ifdef DEBUG_ELEVATOR
		botimport.Print(PRT_MESSAGE, "bot not on elevator\n");
#endif							//DEBUG_ELEVATOR
		//if very near the reachability end
		VectorSubtract(reach->end, ms->origin, dir);
		dist = VectorLength(dir);
		if(dist < 64)
		{
			if(dist > 60)
				dist = 60;
			speed = 360 - (360 - 6 * dist);
			//
			if((ms->moveflags & MFL_SWIMMING) || !BotCheckBarrierJump(ms, dir, 50))
			{
				if(speed > 5)
					EA_Move(ms->client, dir, speed);
			}					//end if
			VectorCopy(dir, result.movedir);
			//
			if(ms->moveflags & MFL_SWIMMING)
				result.flags |= MOVERESULT_SWIMVIEW;
			//stop using this reachability
			ms->reachability_time = 0;
			return result;
		}						//end if
		//get direction and distance to reachability start
		VectorSubtract(reach->start, ms->origin, dir1);
		if(!(ms->moveflags & MFL_SWIMMING))
			dir1[2] = 0;
		dist1 = VectorNormalize(dir1);
		//if the elevator isn't down
		if(!MoverDown(reach))
		{
#ifdef DEBUG_ELEVATOR
			botimport.Print(PRT_MESSAGE, "elevator not down\n");
#endif							//DEBUG_ELEVATOR
			dist = dist1;
			VectorCopy(dir1, dir);
			//
			BotCheckBlocked(ms, dir, qfalse, &result);
			//
			if(dist > 60)
				dist = 60;
			speed = 360 - (360 - 6 * dist);
			//
			if(!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
			{
				if(speed > 5)
					EA_Move(ms->client, dir, speed);
			}					//end if
			VectorCopy(dir, result.movedir);
			//
			if(ms->moveflags & MFL_SWIMMING)
				result.flags |= MOVERESULT_SWIMVIEW;
			//this isn't a failure... just wait till the elevator comes down
			result.type = RESULTTYPE_ELEVATORUP;
			result.flags |= MOVERESULT_WAITING;
			return result;
		}						//end if
		//get direction and distance to elevator bottom center
		MoverBottomCenter(reach, bottomcenter);
		VectorSubtract(bottomcenter, ms->origin, dir2);
		if(!(ms->moveflags & MFL_SWIMMING))
			dir2[2] = 0;
		dist2 = VectorNormalize(dir2);
		//if very close to the reachability start or
		//closer to the elevator center or
		//between reachability start and elevator center
		if(dist1 < 20 || dist2 < dist1 || DotProduct(dir1, dir2) < 0)
		{
#ifdef DEBUG_ELEVATOR
			botimport.Print(PRT_MESSAGE, "bot moving to center\n");
#endif							//DEBUG_ELEVATOR
			dist = dist2;
			VectorCopy(dir2, dir);
		}						//end if
		else					//closer to the reachability start
		{
#ifdef DEBUG_ELEVATOR
			botimport.Print(PRT_MESSAGE, "bot moving to start\n");
#endif							//DEBUG_ELEVATOR
			dist = dist1;
			VectorCopy(dir1, dir);
		}						//end else
		//
		BotCheckBlocked(ms, dir, qfalse, &result);
		//
		if(dist > 60)
			dist = 60;
		speed = 400 - (400 - 6 * dist);
		//
		if(!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
		{
			EA_Move(ms->client, dir, speed);
		}						//end if
		VectorCopy(dir, result.movedir);
		//
		if(ms->moveflags & MFL_SWIMMING)
			result.flags |= MOVERESULT_SWIMVIEW;
	}							//end else
	return result;
}								//end of the function BotTravel_Elevator

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotFinishTravel_Elevator(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          bottomcenter, bottomdir, topdir;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//
	MoverBottomCenter(reach, bottomcenter);
	VectorSubtract(bottomcenter, ms->origin, bottomdir);
	//
	VectorSubtract(reach->end, ms->origin, topdir);
	//
	if(fabs(bottomdir[2]) < fabs(topdir[2]))
	{
		VectorNormalize(bottomdir);
		EA_Move(ms->client, bottomdir, 300);
	}							//end if
	else
	{
		VectorNormalize(topdir);
		EA_Move(ms->client, topdir, 300);
	}							//end else
	return result;
}								//end of the function BotFinishTravel_Elevator

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotFuncBobStartEnd(aas_reachability_t * reach, vec3_t start, vec3_t end, vec3_t origin)
{
	int             spawnflags, modelnum;
	vec3_t          mins, maxs, mid, angles = { 0, 0, 0 };
	int             num0, num1;

	modelnum = reach->facenum & 0x0000FFFF;
	if(!AAS_OriginOfMoverWithModelNum(modelnum, origin))
	{
		botimport.Print(PRT_MESSAGE, "BotFuncBobStartEnd: no entity with model %d\n", modelnum);
		VectorSet(start, 0, 0, 0);
		VectorSet(end, 0, 0, 0);
		return;
	}							//end if
	AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, NULL);
	VectorAdd(mins, maxs, mid);
	VectorScale(mid, 0.5, mid);
	VectorCopy(mid, start);
	VectorCopy(mid, end);
	spawnflags = reach->facenum >> 16;
	num0 = reach->edgenum >> 16;
	if(num0 > 0x00007FFF)
		num0 |= 0xFFFF0000;
	num1 = reach->edgenum & 0x0000FFFF;
	if(num1 > 0x00007FFF)
		num1 |= 0xFFFF0000;
	if(spawnflags & 1)
	{
		start[0] = num0;
		end[0] = num1;
		//
		origin[0] += mid[0];
		origin[1] = mid[1];
		origin[2] = mid[2];
	}							//end if
	else if(spawnflags & 2)
	{
		start[1] = num0;
		end[1] = num1;
		//
		origin[0] = mid[0];
		origin[1] += mid[1];
		origin[2] = mid[2];
	}							//end else if
	else
	{
		start[2] = num0;
		end[2] = num1;
		//
		origin[0] = mid[0];
		origin[1] = mid[1];
		origin[2] += mid[2];
	}							//end else
}								//end of the function BotFuncBobStartEnd

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_FuncBobbing(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          dir, dir1, dir2, hordir, bottomcenter, bob_start, bob_end, bob_origin;
	float           dist, dist1, dist2, speed;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//
	BotFuncBobStartEnd(reach, bob_start, bob_end, bob_origin);
	//if standing ontop of the func_bobbing
	if(BotOnMover(ms->origin, ms->entitynum, reach))
	{
#ifdef DEBUG_FUNCBOB
		botimport.Print(PRT_MESSAGE, "bot on func_bobbing\n");
#endif
		//if near end point of reachability
		VectorSubtract(bob_origin, bob_end, dir);
		if(VectorLength(dir) < 24)
		{
#ifdef DEBUG_FUNCBOB
			botimport.Print(PRT_MESSAGE, "bot moving to reachability end\n");
#endif
			//move to the end point
			VectorSubtract(reach->end, ms->origin, hordir);
			hordir[2] = 0;
			VectorNormalize(hordir);
			if(!BotCheckBarrierJump(ms, hordir, 100))
			{
				EA_Move(ms->client, hordir, 400);
			}					//end if
			VectorCopy(hordir, result.movedir);
		}						//end else
		//if not really close to the center of the elevator
		else
		{
			MoverBottomCenter(reach, bottomcenter);
			VectorSubtract(bottomcenter, ms->origin, hordir);
			hordir[2] = 0;
			dist = VectorNormalize(hordir);
			//
			if(dist > 10)
			{
#ifdef DEBUG_FUNCBOB
				botimport.Print(PRT_MESSAGE, "bot moving to func_bobbing center\n");
#endif
				//move to the center of the plat
				if(dist > 100)
					dist = 100;
				speed = 400 - (400 - 4 * dist);
				//
				EA_Move(ms->client, hordir, speed);
				VectorCopy(hordir, result.movedir);
			}					//end if
		}						//end else
	}							//end if
	else
	{
#ifdef DEBUG_FUNCBOB
		botimport.Print(PRT_MESSAGE, "bot not ontop of func_bobbing\n");
#endif
		//if very near the reachability end
		VectorSubtract(reach->end, ms->origin, dir);
		dist = VectorLength(dir);
		if(dist < 64)
		{
#ifdef DEBUG_FUNCBOB
			botimport.Print(PRT_MESSAGE, "bot moving to end\n");
#endif
			if(dist > 60)
				dist = 60;
			speed = 360 - (360 - 6 * dist);
			//if swimming or no barrier jump
			if((ms->moveflags & MFL_SWIMMING) || !BotCheckBarrierJump(ms, dir, 50))
			{
				if(speed > 5)
					EA_Move(ms->client, dir, speed);
			}					//end if
			VectorCopy(dir, result.movedir);
			//
			if(ms->moveflags & MFL_SWIMMING)
				result.flags |= MOVERESULT_SWIMVIEW;
			//stop using this reachability
			ms->reachability_time = 0;
			return result;
		}						//end if
		//get direction and distance to reachability start
		VectorSubtract(reach->start, ms->origin, dir1);
		if(!(ms->moveflags & MFL_SWIMMING))
			dir1[2] = 0;
		dist1 = VectorNormalize(dir1);
		//if func_bobbing is Not it's start position
		VectorSubtract(bob_origin, bob_start, dir);
		if(VectorLength(dir) > 16)
		{
#ifdef DEBUG_FUNCBOB
			botimport.Print(PRT_MESSAGE, "func_bobbing not at start\n");
#endif
			dist = dist1;
			VectorCopy(dir1, dir);
			//
			BotCheckBlocked(ms, dir, qfalse, &result);
			//
			if(dist > 60)
				dist = 60;
			speed = 360 - (360 - 6 * dist);
			//
			if(!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
			{
				if(speed > 5)
					EA_Move(ms->client, dir, speed);
			}					//end if
			VectorCopy(dir, result.movedir);
			//
			if(ms->moveflags & MFL_SWIMMING)
				result.flags |= MOVERESULT_SWIMVIEW;
			//this isn't a failure... just wait till the func_bobbing arrives
			result.type = RESULTTYPE_WAITFORFUNCBOBBING;
			result.flags |= MOVERESULT_WAITING;
			return result;
		}						//end if
		//get direction and distance to func_bob bottom center
		MoverBottomCenter(reach, bottomcenter);
		VectorSubtract(bottomcenter, ms->origin, dir2);
		if(!(ms->moveflags & MFL_SWIMMING))
			dir2[2] = 0;
		dist2 = VectorNormalize(dir2);
		//if very close to the reachability start or
		//closer to the elevator center or
		//between reachability start and func_bobbing center
		if(dist1 < 20 || dist2 < dist1 || DotProduct(dir1, dir2) < 0)
		{
#ifdef DEBUG_FUNCBOB
			botimport.Print(PRT_MESSAGE, "bot moving to func_bobbing center\n");
#endif
			dist = dist2;
			VectorCopy(dir2, dir);
		}						//end if
		else					//closer to the reachability start
		{
#ifdef DEBUG_FUNCBOB
			botimport.Print(PRT_MESSAGE, "bot moving to reachability start\n");
#endif
			dist = dist1;
			VectorCopy(dir1, dir);
		}						//end else
		//
		BotCheckBlocked(ms, dir, qfalse, &result);
		//
		if(dist > 60)
			dist = 60;
		speed = 400 - (400 - 6 * dist);
		//
		if(!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
		{
			EA_Move(ms->client, dir, speed);
		}						//end if
		VectorCopy(dir, result.movedir);
		//
		if(ms->moveflags & MFL_SWIMMING)
			result.flags |= MOVERESULT_SWIMVIEW;
	}							//end else
	return result;
}								//end of the function BotTravel_FuncBobbing

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotFinishTravel_FuncBobbing(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          bob_origin, bob_start, bob_end, dir, hordir, bottomcenter;
	bot_moveresult_t result;
	float           dist, speed;

	BotClearMoveResult(&result);
	//
	BotFuncBobStartEnd(reach, bob_start, bob_end, bob_origin);
	//
	VectorSubtract(bob_origin, bob_end, dir);
	dist = VectorLength(dir);
	//if the func_bobbing is near the end
	if(dist < 16)
	{
		VectorSubtract(reach->end, ms->origin, hordir);
		if(!(ms->moveflags & MFL_SWIMMING))
			hordir[2] = 0;
		dist = VectorNormalize(hordir);
		//
		if(dist > 60)
			dist = 60;
		speed = 360 - (360 - 6 * dist);
		//
		if(speed > 5)
			EA_Move(ms->client, dir, speed);
		VectorCopy(dir, result.movedir);
		//
		if(ms->moveflags & MFL_SWIMMING)
			result.flags |= MOVERESULT_SWIMVIEW;
	}							//end if
	else
	{
		MoverBottomCenter(reach, bottomcenter);
		VectorSubtract(bottomcenter, ms->origin, hordir);
		if(!(ms->moveflags & MFL_SWIMMING))
			hordir[2] = 0;
		dist = VectorNormalize(hordir);
		//
		if(dist > 5)
		{
			//move to the center of the plat
			if(dist > 100)
				dist = 100;
			speed = 400 - (400 - 4 * dist);
			//
			EA_Move(ms->client, hordir, speed);
			VectorCopy(hordir, result.movedir);
		}						//end if
	}							//end else
	return result;
}								//end of the function BotFinishTravel_FuncBobbing

//===========================================================================
// 0  no valid grapple hook visible
// 1  the grapple hook is still flying
// 2  the grapple hooked into a wall
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int GrappleState(bot_movestate_t * ms, aas_reachability_t * reach)
{
	int             i;
	aas_entityinfo_t entinfo;

	//if the grapple hook is pulling
	if(ms->moveflags & MFL_GRAPPLEPULL)
		return 2;
	//check for a visible grapple missile entity
	//or visible grapple entity
	for(i = AAS_NextEntity(0); i; i = AAS_NextEntity(i))
	{
		if(AAS_EntityType(i) == (int)entitytypemissile->value)
		{
			AAS_EntityInfo(i, &entinfo);
			if(entinfo.weapon == (int)weapindex_grapple->value)
			{
				return 1;
			}					//end if
		}						//end if
	}							//end for
	//no valid grapple at all
	return 0;
}								//end of the function GrappleState

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotResetGrapple(bot_movestate_t * ms)
{
	aas_reachability_t reach;

	AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
	//if not using the grapple hook reachability anymore
	if((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_GRAPPLEHOOK)
	{
		if((ms->moveflags & MFL_ACTIVEGRAPPLE) || ms->grapplevisible_time)
		{
			if(offhandgrapple->value)
				EA_Command(ms->client, cmd_grappleoff->string);
			ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
			ms->grapplevisible_time = 0;
#ifdef DEBUG_GRAPPLE
			botimport.Print(PRT_MESSAGE, "reset grapple\n");
#endif							//DEBUG_GRAPPLE
		}						//end if
	}							//end if
}								//end of the function BotResetGrapple

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_Grapple(bot_movestate_t * ms, aas_reachability_t * reach)
{
	bot_moveresult_t result;
	float           dist, speed;
	vec3_t          dir, viewdir, org;
	int             state, areanum;
	bsp_trace_t     trace;

#ifdef DEBUG_GRAPPLE
	static int      debugline;

	if(!debugline)
		debugline = botimport.DebugLineCreate();
	botimport.DebugLineShow(debugline, reach->start, reach->end, LINECOLOR_BLUE);
#endif							//DEBUG_GRAPPLE

	BotClearMoveResult(&result);
	//
	if(ms->moveflags & MFL_GRAPPLERESET)
	{
		if(offhandgrapple->value)
			EA_Command(ms->client, cmd_grappleoff->string);
		ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
		return result;
	}							//end if
	//
	if(!(int)offhandgrapple->value)
	{
		result.weapon = weapindex_grapple->value;
		result.flags |= MOVERESULT_MOVEMENTWEAPON;
	}							//end if
	//
	if(ms->moveflags & MFL_ACTIVEGRAPPLE)
	{
#ifdef DEBUG_GRAPPLE
		botimport.Print(PRT_MESSAGE, "BotTravel_Grapple: active grapple\n");
#endif							//DEBUG_GRAPPLE
		//
		state = GrappleState(ms, reach);
		//
		VectorSubtract(reach->end, ms->origin, dir);
		dir[2] = 0;
		dist = VectorLength(dir);
		//if very close to the grapple end or the grappled is hooked and
		//the bot doesn't get any closer
		if(state && dist < 48)
		{
			if(ms->lastgrappledist - dist < 1)
			{
#ifdef DEBUG_GRAPPLE
				botimport.Print(PRT_ERROR, "grapple normal end\n");
#endif							//DEBUG_GRAPPLE
				if(offhandgrapple->value)
					EA_Command(ms->client, cmd_grappleoff->string);
				ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
				ms->moveflags |= MFL_GRAPPLERESET;
				ms->reachability_time = 0;	//end the reachability
				return result;
			}					//end if
		}						//end if
		//if no valid grapple at all, or the grapple hooked and the bot
		//isn't moving anymore
		else if(!state || (state == 2 && dist > ms->lastgrappledist - 2))
		{
			if(ms->grapplevisible_time < AAS_Time() - 0.4)
			{
#ifdef DEBUG_GRAPPLE
				botimport.Print(PRT_ERROR, "grapple not visible\n");
#endif							//DEBUG_GRAPPLE
				if(offhandgrapple->value)
					EA_Command(ms->client, cmd_grappleoff->string);
				ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
				ms->moveflags |= MFL_GRAPPLERESET;
				ms->reachability_time = 0;	//end the reachability
				return result;
			}					//end if
		}						//end if
		else
		{
			ms->grapplevisible_time = AAS_Time();
		}						//end else
		//
		if(!(int)offhandgrapple->value)
		{
			EA_Attack(ms->client);
		}						//end if
		//remember the current grapple distance
		ms->lastgrappledist = dist;
	}							//end if
	else
	{
#ifdef DEBUG_GRAPPLE
		botimport.Print(PRT_MESSAGE, "BotTravel_Grapple: inactive grapple\n");
#endif							//DEBUG_GRAPPLE
		//
		ms->grapplevisible_time = AAS_Time();
		//
		VectorSubtract(reach->start, ms->origin, dir);
		if(!(ms->moveflags & MFL_SWIMMING))
			dir[2] = 0;
		VectorAdd(ms->origin, ms->viewoffset, org);
		VectorSubtract(reach->end, org, viewdir);
		//
		dist = VectorNormalize(dir);
		Vector2Angles(viewdir, result.ideal_viewangles);
		result.flags |= MOVERESULT_MOVEMENTVIEW;
		//
		if(dist < 5 &&
		   fabs(AngleDiff(result.ideal_viewangles[0], ms->viewangles[0])) < 2 &&
		   fabs(AngleDiff(result.ideal_viewangles[1], ms->viewangles[1])) < 2)
		{
#ifdef DEBUG_GRAPPLE
			botimport.Print(PRT_MESSAGE, "BotTravel_Grapple: activating grapple\n");
#endif							//DEBUG_GRAPPLE
			//check if the grapple missile path is clear
			VectorAdd(ms->origin, ms->viewoffset, org);
			trace = AAS_Trace(org, NULL, NULL, reach->end, ms->entitynum, CONTENTS_SOLID);
			VectorSubtract(reach->end, trace.endpos, dir);
			if(VectorLength(dir) > 16)
			{
				result.failure = qtrue;
				return result;
			}					//end if
			//activate the grapple
			if(offhandgrapple->value)
			{
				EA_Command(ms->client, cmd_grappleon->string);
			}					//end if
			else
			{
				EA_Attack(ms->client);
			}					//end else
			ms->moveflags |= MFL_ACTIVEGRAPPLE;
			ms->lastgrappledist = 999999;
		}						//end if
		else
		{
			if(dist < 70)
				speed = 300 - (300 - 4 * dist);
			else
				speed = 400;
			//
			BotCheckBlocked(ms, dir, qtrue, &result);
			//elemantary action move in direction
			EA_Move(ms->client, dir, speed);
			VectorCopy(dir, result.movedir);
		}						//end else
		//if in another area before actually grappling
		areanum = AAS_PointAreaNum(ms->origin);
		if(areanum && areanum != ms->reachareanum)
			ms->reachability_time = 0;
	}							//end else
	return result;
}								//end of the function BotTravel_Grapple

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:         -
//===========================================================================
bot_moveresult_t BotTravel_RocketJump(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          hordir;
	float           dist, speed;
	bot_moveresult_t result;

	//botimport.Print(PRT_MESSAGE, "BotTravel_RocketJump: bah\n");
	BotClearMoveResult(&result);
	//
	hordir[0] = reach->start[0] - ms->origin[0];
	hordir[1] = reach->start[1] - ms->origin[1];
	hordir[2] = 0;
	//
	dist = VectorNormalize(hordir);
	//look in the movement direction
	Vector2Angles(hordir, result.ideal_viewangles);
	//look straight down
	result.ideal_viewangles[PITCH] = 90;
	//
	if(dist < 5 &&
	   fabs(AngleDiff(result.ideal_viewangles[0], ms->viewangles[0])) < 5 &&
	   fabs(AngleDiff(result.ideal_viewangles[1], ms->viewangles[1])) < 5)
	{
		//botimport.Print(PRT_MESSAGE, "between jump start and run start point\n");
		hordir[0] = reach->end[0] - ms->origin[0];
		hordir[1] = reach->end[1] - ms->origin[1];
		hordir[2] = 0;
		VectorNormalize(hordir);
		//elemantary action jump
		EA_Jump(ms->client);
		EA_Attack(ms->client);
		EA_Move(ms->client, hordir, 800);
		//
		ms->jumpreach = ms->lastreachnum;
	}							//end if
	else
	{
		if(dist > 80)
			dist = 80;
		speed = 400 - (400 - 5 * dist);
		EA_Move(ms->client, hordir, speed);
	}							//end else
	//look in the movement direction
	Vector2Angles(hordir, result.ideal_viewangles);
	//look straight down
	result.ideal_viewangles[PITCH] = 90;
	//set the view angles directly
	EA_View(ms->client, result.ideal_viewangles);
	//view is important for the movment
	result.flags |= MOVERESULT_MOVEMENTVIEWSET;
	//select the rocket launcher
	EA_SelectWeapon(ms->client, (int)weapindex_rocketlauncher->value);
	//weapon is used for movement
	result.weapon = (int)weapindex_rocketlauncher->value;
	result.flags |= MOVERESULT_MOVEMENTWEAPON;
	//
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotTravel_RocketJump

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_BFGJump(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          hordir;
	float           dist, speed;
	bot_moveresult_t result;

	//botimport.Print(PRT_MESSAGE, "BotTravel_BFGJump: bah\n");
	BotClearMoveResult(&result);
	//
	hordir[0] = reach->start[0] - ms->origin[0];
	hordir[1] = reach->start[1] - ms->origin[1];
	hordir[2] = 0;
	//
	dist = VectorNormalize(hordir);
	//
	if(dist < 5 &&
	   fabs(AngleDiff(result.ideal_viewangles[0], ms->viewangles[0])) < 5 &&
	   fabs(AngleDiff(result.ideal_viewangles[1], ms->viewangles[1])) < 5)
	{
		//botimport.Print(PRT_MESSAGE, "between jump start and run start point\n");
		hordir[0] = reach->end[0] - ms->origin[0];
		hordir[1] = reach->end[1] - ms->origin[1];
		hordir[2] = 0;
		VectorNormalize(hordir);
		//elemantary action jump
		EA_Jump(ms->client);
		EA_Attack(ms->client);
		EA_Move(ms->client, hordir, 800);
		//
		ms->jumpreach = ms->lastreachnum;
	}							//end if
	else
	{
		if(dist > 80)
			dist = 80;
		speed = 400 - (400 - 5 * dist);
		EA_Move(ms->client, hordir, speed);
	}							//end else
	//look in the movement direction
	Vector2Angles(hordir, result.ideal_viewangles);
	//look straight down
	result.ideal_viewangles[PITCH] = 90;
	//set the view angles directly
	EA_View(ms->client, result.ideal_viewangles);
	//view is important for the movment
	result.flags |= MOVERESULT_MOVEMENTVIEWSET;
	//select the rocket launcher
	EA_SelectWeapon(ms->client, (int)weapindex_bfg10k->value);
	//weapon is used for movement
	result.weapon = (int)weapindex_bfg10k->value;
	result.flags |= MOVERESULT_MOVEMENTWEAPON;
	//
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotTravel_BFGJump

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotFinishTravel_WeaponJump(bot_movestate_t * ms, aas_reachability_t * reach)
{
	vec3_t          hordir;
	float           speed;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//if not jumped yet
	if(!ms->jumpreach)
		return result;
	/*
	   //go straight to the reachability end
	   hordir[0] = reach->end[0] - ms->origin[0];
	   hordir[1] = reach->end[1] - ms->origin[1];
	   hordir[2] = 0;
	   VectorNormalize(hordir);
	   //always use max speed when traveling through the air
	   EA_Move(ms->client, hordir, 800);
	   VectorCopy(hordir, result.movedir);
	 */
	//
	if(!BotAirControl(ms->origin, ms->velocity, reach->end, hordir, &speed))
	{
		//go straight to the reachability end
		VectorSubtract(reach->end, ms->origin, hordir);
		hordir[2] = 0;
		VectorNormalize(hordir);
		speed = 400;
	}							//end if
	//
	EA_Move(ms->client, hordir, speed);
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotFinishTravel_WeaponJump

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotTravel_JumpPad(bot_movestate_t * ms, aas_reachability_t * reach)
{
	float           dist, speed;
	vec3_t          hordir;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	//first walk straight to the reachability start
	hordir[0] = reach->start[0] - ms->origin[0];
	hordir[1] = reach->start[1] - ms->origin[1];
	hordir[2] = 0;
	dist = VectorNormalize(hordir);
	//
	BotCheckBlocked(ms, hordir, qtrue, &result);
	speed = 400;
	//elemantary action move in direction
	EA_Move(ms->client, hordir, speed);
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotTravel_JumpPad

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotFinishTravel_JumpPad(bot_movestate_t * ms, aas_reachability_t * reach)
{
	float           speed;
	vec3_t          hordir;
	bot_moveresult_t result;

	BotClearMoveResult(&result);
	if(!BotAirControl(ms->origin, ms->velocity, reach->end, hordir, &speed))
	{
		hordir[0] = reach->end[0] - ms->origin[0];
		hordir[1] = reach->end[1] - ms->origin[1];
		hordir[2] = 0;
		VectorNormalize(hordir);
		speed = 400;
	}							//end if
	BotCheckBlocked(ms, hordir, qtrue, &result);
	//elemantary action move in direction
	EA_Move(ms->client, hordir, speed);
	VectorCopy(hordir, result.movedir);
	//
	return result;
}								//end of the function BotFinishTravel_JumpPad

//===========================================================================
// time before the reachability times out
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int BotReachabilityTime(aas_reachability_t * reach)
{
	switch (reach->traveltype & TRAVELTYPE_MASK)
	{
		case TRAVEL_WALK:
			return 5;
		case TRAVEL_CROUCH:
			return 5;
		case TRAVEL_BARRIERJUMP:
			return 5;
		case TRAVEL_LADDER:
			return 6;
		case TRAVEL_WALKOFFLEDGE:
			return 5;
		case TRAVEL_JUMP:
			return 5;
		case TRAVEL_SWIM:
			return 5;
		case TRAVEL_WATERJUMP:
			return 5;
		case TRAVEL_TELEPORT:
			return 5;
		case TRAVEL_ELEVATOR:
			return 10;
		case TRAVEL_GRAPPLEHOOK:
			return 8;
		case TRAVEL_ROCKETJUMP:
			return 6;
		case TRAVEL_BFGJUMP:
			return 6;
		case TRAVEL_JUMPPAD:
			return 10;
		case TRAVEL_FUNCBOB:
			return 10;
		default:
		{
			botimport.Print(PRT_ERROR, "travel type %d not implemented yet\n", reach->traveltype);
			return 8;
		}						//end case
	}							//end switch
}								//end of the function BotReachabilityTime

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
bot_moveresult_t BotMoveInGoalArea(bot_movestate_t * ms, bot_goal_t * goal)
{
	bot_moveresult_t result;
	vec3_t          dir;
	float           dist, speed;

#ifdef _DEBUG
	//botimport.Print(PRT_MESSAGE, "%s: moving straight to goal\n", ClientName(ms->entitynum-1));
	//AAS_ClearShownDebugLines();
	//AAS_DebugLine(ms->origin, goal->origin, LINECOLOR_RED);
#endif							//DEBUG
	BotClearMoveResult(&result);
	//walk straight to the goal origin
	dir[0] = goal->origin[0] - ms->origin[0];
	dir[1] = goal->origin[1] - ms->origin[1];
	if(ms->moveflags & MFL_SWIMMING)
	{
		dir[2] = goal->origin[2] - ms->origin[2];
		result.traveltype = TRAVEL_SWIM;
	}							//end if
	else
	{
		dir[2] = 0;
		result.traveltype = TRAVEL_WALK;
	}							//endif
	//
	dist = VectorNormalize(dir);
	if(dist > 100)
		dist = 100;
	speed = 400 - (400 - 4 * dist);
	if(speed < 10)
		speed = 0;
	//
	BotCheckBlocked(ms, dir, qtrue, &result);
	//elemantary action move in direction
	EA_Move(ms->client, dir, speed);
	VectorCopy(dir, result.movedir);
	//
	if(ms->moveflags & MFL_SWIMMING)
	{
		Vector2Angles(dir, result.ideal_viewangles);
		result.flags |= MOVERESULT_SWIMVIEW;
	}							//end if
	//if (!debugline) debugline = botimport.DebugLineCreate();
	//botimport.DebugLineShow(debugline, ms->origin, goal->origin, LINECOLOR_BLUE);
	//
	ms->lastreachnum = 0;
	ms->lastareanum = 0;
	ms->lastgoalareanum = goal->areanum;
	VectorCopy(ms->origin, ms->lastorigin);
	//
	return result;
}								//end of the function BotMoveInGoalArea

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotMoveToGoal(bot_moveresult_t * result, int movestate, bot_goal_t * goal, int travelflags)
{
	int             reachnum, lastreachnum, foundjumppad, ent, resultflags;
	aas_reachability_t reach, lastreach;
	bot_movestate_t *ms;

	//vec3_t mins, maxs, up = {0, 0, 1};
	//bsp_trace_t trace;
	//static int debugline;


	BotClearMoveResult(result);
	//
	ms = BotMoveStateFromHandle(movestate);
	if(!ms)
		return;
	//reset the grapple before testing if the bot has a valid goal
	//because the bot could loose all it's goals when stuck to a wall
	BotResetGrapple(ms);
	//
	if(!goal)
	{
#ifdef _DEBUG
		botimport.Print(PRT_MESSAGE, "client %d: movetogoal -> no goal\n", ms->client);
#endif							//DEBUG
		result->failure = qtrue;
		return;
	}							//end if
	//botimport.Print(PRT_MESSAGE, "numavoidreach = %d\n", ms->numavoidreach);
	//remove some of the move flags
	ms->moveflags &= ~(MFL_SWIMMING | MFL_AGAINSTLADDER);
	//set some of the move flags
	//NOTE: the MFL_ONGROUND flag is also set in the higher AI
	if(AAS_OnGround(ms->origin, ms->presencetype, ms->entitynum))
		ms->moveflags |= MFL_ONGROUND;
	//
	if(ms->moveflags & MFL_ONGROUND)
	{
		int             modeltype, modelnum;

		ent = BotOnTopOfEntity(ms);

		if(ent != -1)
		{
			modelnum = AAS_EntityModelindex(ent);
			if(modelnum >= 0 && modelnum < MAX_MODELS)
			{
				modeltype = modeltypes[modelnum];

				if(modeltype == MODELTYPE_FUNC_PLAT)
				{
					AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
					//if the bot is Not using the elevator
					if((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_ELEVATOR ||
					   //NOTE: the face number is the plat model number
					   (reach.facenum & 0x0000FFFF) != modelnum)
					{
						reachnum = AAS_NextModelReachability(0, modelnum);
						if(reachnum)
						{
							//botimport.Print(PRT_MESSAGE, "client %d: accidentally ended up on func_plat\n", ms->client);
							AAS_ReachabilityFromNum(reachnum, &reach);
							ms->lastreachnum = reachnum;
							ms->reachability_time = AAS_Time() + BotReachabilityTime(&reach);
						}		//end if
						else
						{
							if(bot_developer)
							{
								botimport.Print(PRT_MESSAGE, "client %d: on func_plat without reachability\n", ms->client);
							}	//end if
							result->blocked = qtrue;
							result->blockentity = ent;
							result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
							return;
						}		//end else
					}			//end if
					result->flags |= MOVERESULT_ONTOPOF_ELEVATOR;
				}				//end if
				else if(modeltype == MODELTYPE_FUNC_BOB)
				{
					AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
					//if the bot is Not using the func bobbing
					if((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_FUNCBOB ||
					   //NOTE: the face number is the func_bobbing model number
					   (reach.facenum & 0x0000FFFF) != modelnum)
					{
						reachnum = AAS_NextModelReachability(0, modelnum);
						if(reachnum)
						{
							//botimport.Print(PRT_MESSAGE, "client %d: accidentally ended up on func_bobbing\n", ms->client);
							AAS_ReachabilityFromNum(reachnum, &reach);
							ms->lastreachnum = reachnum;
							ms->reachability_time = AAS_Time() + BotReachabilityTime(&reach);
						}		//end if
						else
						{
							if(bot_developer)
							{
								botimport.Print(PRT_MESSAGE, "client %d: on func_bobbing without reachability\n", ms->client);
							}	//end if
							result->blocked = qtrue;
							result->blockentity = ent;
							result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
							return;
						}		//end else
					}			//end if
					result->flags |= MOVERESULT_ONTOPOF_FUNCBOB;
				}				//end if
				else if(modeltype == MODELTYPE_FUNC_STATIC || modeltype == MODELTYPE_FUNC_DOOR)
				{
					// check if ontop of a door bridge ?
					ms->areanum = BotFuzzyPointReachabilityArea(ms->origin);
					// if not in a reachability area
					if(!AAS_AreaReachability(ms->areanum))
					{
						result->blocked = qtrue;
						result->blockentity = ent;
						result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
						return;
					}			//end if
				}				//end else if
				else
				{
					result->blocked = qtrue;
					result->blockentity = ent;
					result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
					return;
				}				//end else
			}					//end if
		}						//end if
	}							//end if
	//if swimming
	if(AAS_Swimming(ms->origin))
		ms->moveflags |= MFL_SWIMMING;
	//if against a ladder
	if(AAS_AgainstLadder(ms->origin))
		ms->moveflags |= MFL_AGAINSTLADDER;
	//if the bot is on the ground, swimming or against a ladder
	if(ms->moveflags & (MFL_ONGROUND | MFL_SWIMMING | MFL_AGAINSTLADDER))
	{
		//botimport.Print(PRT_MESSAGE, "%s: onground, swimming or against ladder\n", ClientName(ms->entitynum-1));
		//
		AAS_ReachabilityFromNum(ms->lastreachnum, &lastreach);
		//reachability area the bot is in
		//ms->areanum = BotReachabilityArea(ms->origin, ((lastreach.traveltype & TRAVELTYPE_MASK) != TRAVEL_ELEVATOR));
		ms->areanum = BotFuzzyPointReachabilityArea(ms->origin);
		//
		if(!ms->areanum)
		{
			result->failure = qtrue;
			result->blocked = qtrue;
			result->blockentity = 0;
			result->type = RESULTTYPE_INSOLIDAREA;
			return;
		}						//end if
		//if the bot is in the goal area
		if(ms->areanum == goal->areanum)
		{
			*result = BotMoveInGoalArea(ms, goal);
			return;
		}						//end if
		//assume we can use the reachability from the last frame
		reachnum = ms->lastreachnum;
		//if there is a last reachability
		if(reachnum)
		{
			AAS_ReachabilityFromNum(reachnum, &reach);
			//check if the reachability is still valid
			if(!(AAS_TravelFlagForType(reach.traveltype) & travelflags))
			{
				reachnum = 0;
			}					//end if
			//special grapple hook case
			else if((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_GRAPPLEHOOK)
			{
				if(ms->reachability_time < AAS_Time() || (ms->moveflags & MFL_GRAPPLERESET))
				{
					reachnum = 0;
				}				//end if
			}					//end if
			//special elevator case
			else if((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_ELEVATOR ||
					(reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_FUNCBOB)
			{
				if((result->flags & MOVERESULT_ONTOPOF_FUNCBOB) || (result->flags & MOVERESULT_ONTOPOF_FUNCBOB))
				{
					ms->reachability_time = AAS_Time() + 5;
				}				//end if
				//if the bot was going for an elevator and reached the reachability area
				if(ms->areanum == reach.areanum || ms->reachability_time < AAS_Time())
				{
					reachnum = 0;
				}				//end if
			}					//end if
			else
			{
#ifdef _DEBUG
				if(bot_developer)
				{
					if(ms->reachability_time < AAS_Time())
					{
						botimport.Print(PRT_MESSAGE, "client %d: reachability timeout in ", ms->client);
						AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
						botimport.Print(PRT_MESSAGE, "\n");
					}			//end if
					/*
					   if (ms->lastareanum != ms->areanum)
					   {
					   botimport.Print(PRT_MESSAGE, "changed from area %d to %d\n", ms->lastareanum, ms->areanum);
					   } //end if */
				}				//end if
#endif							//DEBUG
				//if the goal area changed or the reachability timed out
				//or the area changed
				if(ms->lastgoalareanum != goal->areanum || ms->reachability_time < AAS_Time() || ms->lastareanum != ms->areanum)
				{
					reachnum = 0;
					//botimport.Print(PRT_MESSAGE, "area change or timeout\n");
				}				//end else if
			}					//end else
		}						//end if
		resultflags = 0;
		//if the bot needs a new reachability
		if(!reachnum)
		{
			//if the area has no reachability links
			if(!AAS_AreaReachability(ms->areanum))
			{
#ifdef _DEBUG
				if(bot_developer)
				{
					botimport.Print(PRT_MESSAGE, "area %d no reachability\n", ms->areanum);
				}				//end if
#endif							//DEBUG
			}					//end if
			//get a new reachability leading towards the goal
			reachnum = BotGetReachabilityToGoal(ms->origin, ms->areanum,
												ms->lastgoalareanum, ms->lastareanum,
												ms->avoidreach, ms->avoidreachtimes, ms->avoidreachtries,
												goal, travelflags, travelflags, ms->avoidspots, ms->numavoidspots, &resultflags);
			//the area number the reachability starts in
			ms->reachareanum = ms->areanum;
			//reset some state variables
			ms->jumpreach = 0;	//for TRAVEL_JUMP
			ms->moveflags &= ~MFL_GRAPPLERESET;	//for TRAVEL_GRAPPLEHOOK
			//if there is a reachability to the goal
			if(reachnum)
			{
				AAS_ReachabilityFromNum(reachnum, &reach);
				//set a timeout for this reachability
				ms->reachability_time = AAS_Time() + BotReachabilityTime(&reach);
				//
#ifdef AVOIDREACH
				//add the reachability to the reachabilities to avoid for a while
				BotAddToAvoidReach(ms, reachnum, AVOIDREACH_TIME);
#endif							//AVOIDREACH
			}					//end if
#ifdef _DEBUG

			else if(bot_developer)
			{
				botimport.Print(PRT_MESSAGE, "goal not reachable\n");
				Com_Memset(&reach, 0, sizeof(aas_reachability_t));	//make compiler happy
			}					//end else
			if(bot_developer)
			{
				//if still going for the same goal
				if(ms->lastgoalareanum == goal->areanum)
				{
					if(ms->lastareanum == reach.areanum)
					{
						botimport.Print(PRT_MESSAGE, "same goal, going back to previous area\n");
					}			//end if
				}				//end if
			}					//end if
#endif							//DEBUG
		}						//end else
		//
		ms->lastreachnum = reachnum;
		ms->lastgoalareanum = goal->areanum;
		ms->lastareanum = ms->areanum;
		//if the bot has a reachability
		if(reachnum)
		{
			//get the reachability from the number
			AAS_ReachabilityFromNum(reachnum, &reach);
			result->traveltype = reach.traveltype;
			//
#ifdef DEBUG_AI_MOVE
			AAS_ClearShownDebugLines();
			AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
			AAS_ShowReachability(&reach);
#endif							//DEBUG_AI_MOVE
			//
#ifdef _DEBUG
			//botimport.Print(PRT_MESSAGE, "client %d: ", ms->client);
			//AAS_PrintTravelType(reach.traveltype);
			//botimport.Print(PRT_MESSAGE, "\n");
#endif							//DEBUG
			switch (reach.traveltype & TRAVELTYPE_MASK)
			{
				case TRAVEL_WALK:
					*result = BotTravel_Walk(ms, &reach);
					break;
				case TRAVEL_CROUCH:
					*result = BotTravel_Crouch(ms, &reach);
					break;
				case TRAVEL_BARRIERJUMP:
					*result = BotTravel_BarrierJump(ms, &reach);
					break;
				case TRAVEL_LADDER:
					*result = BotTravel_Ladder(ms, &reach);
					break;
				case TRAVEL_WALKOFFLEDGE:
					*result = BotTravel_WalkOffLedge(ms, &reach);
					break;
				case TRAVEL_JUMP:
					*result = BotTravel_Jump(ms, &reach);
					break;
				case TRAVEL_SWIM:
					*result = BotTravel_Swim(ms, &reach);
					break;
				case TRAVEL_WATERJUMP:
					*result = BotTravel_WaterJump(ms, &reach);
					break;
				case TRAVEL_TELEPORT:
					*result = BotTravel_Teleport(ms, &reach);
					break;
				case TRAVEL_ELEVATOR:
					*result = BotTravel_Elevator(ms, &reach);
					break;
				case TRAVEL_GRAPPLEHOOK:
					*result = BotTravel_Grapple(ms, &reach);
					break;
				case TRAVEL_ROCKETJUMP:
					*result = BotTravel_RocketJump(ms, &reach);
					break;
				case TRAVEL_BFGJUMP:
					*result = BotTravel_BFGJump(ms, &reach);
					break;
				case TRAVEL_JUMPPAD:
					*result = BotTravel_JumpPad(ms, &reach);
					break;
				case TRAVEL_FUNCBOB:
					*result = BotTravel_FuncBobbing(ms, &reach);
					break;
				default:
				{
					botimport.Print(PRT_FATAL, "travel type %d not implemented yet\n", (reach.traveltype & TRAVELTYPE_MASK));
					break;
				}				//end case
			}					//end switch
			result->traveltype = reach.traveltype;
			result->flags |= resultflags;
		}						//end if
		else
		{
			result->failure = qtrue;
			result->flags |= resultflags;
			Com_Memset(&reach, 0, sizeof(aas_reachability_t));
		}						//end else
#ifdef _DEBUG
		if(bot_developer)
		{
			if(result->failure)
			{
				botimport.Print(PRT_MESSAGE, "client %d: movement failure in ", ms->client);
				AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
				botimport.Print(PRT_MESSAGE, "\n");
			}					//end if
		}						//end if
#endif							//DEBUG
	}							//end if
	else
	{
		int             i, numareas, areas[16];
		vec3_t          end;

		//special handling of jump pads when the bot uses a jump pad without knowing it
		foundjumppad = qfalse;
		VectorMA(ms->origin, -2 * ms->thinktime, ms->velocity, end);
		numareas = AAS_TraceAreas(ms->origin, end, areas, NULL, 16);
		for(i = numareas - 1; i >= 0; i--)
		{
			if(AAS_AreaJumpPad(areas[i]))
			{
				//botimport.Print(PRT_MESSAGE, "client %d used a jumppad without knowing, area %d\n", ms->client, areas[i]);
				foundjumppad = qtrue;
				lastreachnum = BotGetReachabilityToGoal(end, areas[i],
														ms->lastgoalareanum, ms->lastareanum,
														ms->avoidreach, ms->avoidreachtimes, ms->avoidreachtries,
														goal, travelflags, TFL_JUMPPAD, ms->avoidspots, ms->numavoidspots, NULL);
				if(lastreachnum)
				{
					ms->lastreachnum = lastreachnum;
					ms->lastareanum = areas[i];
					//botimport.Print(PRT_MESSAGE, "found jumppad reachability\n");
					break;
				}				//end if
				else
				{
					for(lastreachnum = AAS_NextAreaReachability(areas[i], 0); lastreachnum;
						lastreachnum = AAS_NextAreaReachability(areas[i], lastreachnum))
					{
						//get the reachability from the number
						AAS_ReachabilityFromNum(lastreachnum, &reach);
						if((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMPPAD)
						{
							ms->lastreachnum = lastreachnum;
							ms->lastareanum = areas[i];
							//botimport.Print(PRT_MESSAGE, "found jumppad reachability hard!!\n");
							break;
						}		//end if
					}			//end for
					if(lastreachnum)
						break;
				}				//end else
			}					//end if
		}						//end for
		if(bot_developer)
		{
			//if a jumppad is found with the trace but no reachability is found
			if(foundjumppad && !ms->lastreachnum)
			{
				botimport.Print(PRT_MESSAGE, "client %d didn't find jumppad reachability\n", ms->client);
			}					//end if
		}						//end if
		//
		if(ms->lastreachnum)
		{
			//botimport.Print(PRT_MESSAGE, "%s: NOT onground, swimming or against ladder\n", ClientName(ms->entitynum-1));
			AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
			result->traveltype = reach.traveltype;
#ifdef _DEBUG
			//botimport.Print(PRT_MESSAGE, "client %d finish: ", ms->client);
			//AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
			//botimport.Print(PRT_MESSAGE, "\n");
#endif							//DEBUG
			//
			switch (reach.traveltype & TRAVELTYPE_MASK)
			{
				case TRAVEL_WALK:
					*result = BotTravel_Walk(ms, &reach);
					break;		//BotFinishTravel_Walk(ms, &reach); break;
				case TRAVEL_CROUCH:	/*do nothing */
					break;
				case TRAVEL_BARRIERJUMP:
					*result = BotFinishTravel_BarrierJump(ms, &reach);
					break;
				case TRAVEL_LADDER:
					*result = BotTravel_Ladder(ms, &reach);
					break;
				case TRAVEL_WALKOFFLEDGE:
					*result = BotFinishTravel_WalkOffLedge(ms, &reach);
					break;
				case TRAVEL_JUMP:
					*result = BotFinishTravel_Jump(ms, &reach);
					break;
				case TRAVEL_SWIM:
					*result = BotTravel_Swim(ms, &reach);
					break;
				case TRAVEL_WATERJUMP:
					*result = BotFinishTravel_WaterJump(ms, &reach);
					break;
				case TRAVEL_TELEPORT:	/*do nothing */
					break;
				case TRAVEL_ELEVATOR:
					*result = BotFinishTravel_Elevator(ms, &reach);
					break;
				case TRAVEL_GRAPPLEHOOK:
					*result = BotTravel_Grapple(ms, &reach);
					break;
				case TRAVEL_ROCKETJUMP:
				case TRAVEL_BFGJUMP:
					*result = BotFinishTravel_WeaponJump(ms, &reach);
					break;
				case TRAVEL_JUMPPAD:
					*result = BotFinishTravel_JumpPad(ms, &reach);
					break;
				case TRAVEL_FUNCBOB:
					*result = BotFinishTravel_FuncBobbing(ms, &reach);
					break;
				default:
				{
					botimport.Print(PRT_FATAL, "(last) travel type %d not implemented yet\n",
									(reach.traveltype & TRAVELTYPE_MASK));
					break;
				}				//end case
			}					//end switch
			result->traveltype = reach.traveltype;
#ifdef _DEBUG
			if(bot_developer)
			{
				if(result->failure)
				{
					botimport.Print(PRT_MESSAGE, "client %d: movement failure in finish ", ms->client);
					AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
					botimport.Print(PRT_MESSAGE, "\n");
				}				//end if
			}					//end if
#endif							//DEBUG
		}						//end if
	}							//end else
	//FIXME: is it right to do this here?
	if(result->blocked)
		ms->reachability_time -= 10 * ms->thinktime;
	//copy the last origin
	VectorCopy(ms->origin, ms->lastorigin);
	//return the movement result
	return;
}								//end of the function BotMoveToGoal

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotResetAvoidReach(int movestate)
{
	bot_movestate_t *ms;

	ms = BotMoveStateFromHandle(movestate);
	if(!ms)
		return;
	Com_Memset(ms->avoidreach, 0, MAX_AVOIDREACH * sizeof(int));
	Com_Memset(ms->avoidreachtimes, 0, MAX_AVOIDREACH * sizeof(float));
	Com_Memset(ms->avoidreachtries, 0, MAX_AVOIDREACH * sizeof(int));
}								//end of the function BotResetAvoidReach

//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void BotResetLastAvoidReach(int movestate)
{
	int             i, latest;
	float           latesttime;
	bot_movestate_t *ms;

	ms = BotMoveStateFromHandle(movestate);
	if(!ms)
		return;
	latesttime = 0;
	latest = 0;
	for(i = 0; i < MAX_AVOIDREACH; i++)
	{
		if(ms->avoidreachtimes[i] > latesttime)
		{
			latesttime = ms->avoidreachtimes[i];
			latest = i;
		}						//end if
	}							//end for
	if(latesttime)
	{
		ms->avoidreachtimes[latest] = 0;
		if(ms->avoidreachtries[i] > 0)
			ms->avoidreachtries[latest]--;
	}							//end if
}								//end of the function BotResetLastAvoidReach

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotResetMoveState(int movestate)
{
	bot_movestate_t *ms;

	ms = BotMoveStateFromHandle(movestate);
	if(!ms)
		return;
	Com_Memset(ms, 0, sizeof(bot_movestate_t));
}								//end of the function BotResetMoveState

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int BotSetupMoveAI(void)
{
	BotSetBrushModelTypes();
	sv_maxstep = LibVar("sv_step", "18");
	sv_maxbarrier = LibVar("sv_maxbarrier", "32");
	sv_gravity = LibVar("sv_gravity", "800");
	weapindex_rocketlauncher = LibVar("weapindex_rocketlauncher", "5");
	weapindex_bfg10k = LibVar("weapindex_bfg10k", "9");
	weapindex_grapple = LibVar("weapindex_grapple", "10");
	entitytypemissile = LibVar("entitytypemissile", "3");
	offhandgrapple = LibVar("offhandgrapple", "0");
	cmd_grappleon = LibVar("cmd_grappleon", "grappleon");
	cmd_grappleoff = LibVar("cmd_grappleoff", "grappleoff");
	return BLERR_NOERROR;
}								//end of the function BotSetupMoveAI

//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void BotShutdownMoveAI(void)
{
	int             i;

	for(i = 1; i <= MAX_CLIENTS; i++)
	{
		if(botmovestates[i])
		{
			FreeMemory(botmovestates[i]);
			botmovestates[i] = NULL;
		}						//end if
	}							//end for
}								//end of the function BotShutdownMoveAI
