be_aas_reach.c

Go to the documentation of this file.

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.

This file is part of Quake III Arena source code.

Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.

Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Foobar; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
===========================================================================
*/

/*****************************************************************************
 * name:        be_aas_reach.c
 *
 * desc:        reachability calculations
 *
 * $Archive: /MissionPack/code/botlib/be_aas_reach.c $
 *
 *****************************************************************************/

#include "../game/q_shared.h"
#include "l_log.h"
#include "l_memory.h"
#include "l_script.h"
#include "l_libvar.h"
#include "l_precomp.h"
#include "l_struct.h"
#include "aasfile.h"
#include "../game/botlib.h"
#include "../game/be_aas.h"
#include "be_aas_funcs.h"
#include "be_aas_def.h"

extern int Sys_MilliSeconds(void);


extern botlib_import_t botimport;

//#define REACH_DEBUG

//NOTE: all travel times are in hundreth of a second
//maximum number of reachability links
#define AAS_MAX_REACHABILITYSIZE            65536
//number of areas reachability is calculated for each frame
#define REACHABILITYAREASPERCYCLE           15
//number of units reachability points are placed inside the areas
#define INSIDEUNITS                         2
#define INSIDEUNITS_WALKEND                 5
#define INSIDEUNITS_WALKSTART               0.1
#define INSIDEUNITS_WATERJUMP               15
//area flag used for weapon jumping
#define AREA_WEAPONJUMP                     8192    //valid area to weapon jump to
//number of reachabilities of each type
int reach_swim;         //swim
int reach_equalfloor;   //walk on floors with equal height
int reach_step;         //step up
int reach_walk;         //walk of step
int reach_barrier;      //jump up to a barrier
int reach_waterjump;    //jump out of water
int reach_walkoffledge; //walk of a ledge
int reach_jump;         //jump
int reach_ladder;       //climb or descent a ladder
int reach_teleport;     //teleport
int reach_elevator;     //use an elevator
int reach_funcbob;      //use a func bob
int reach_grapple;      //grapple hook
int reach_doublejump;   //double jump
int reach_rampjump;     //ramp jump
int reach_strafejump;   //strafe jump (just normal jump but further)
int reach_rocketjump;   //rocket jump
int reach_bfgjump;      //bfg jump
int reach_jumppad;      //jump pads
//if true grapple reachabilities are skipped
int calcgrapplereach;
//linked reachability
typedef struct aas_lreachability_s
{
    int areanum;                    //number of the reachable area
    int facenum;                    //number of the face towards the other area
    int edgenum;                    //number of the edge towards the other area
    vec3_t start;                   //start point of inter area movement
    vec3_t end;                     //end point of inter area movement
    int traveltype;                 //type of travel required to get to the area
    unsigned short int traveltime;  //travel time of the inter area movement
    //
    struct aas_lreachability_s *next;
} aas_lreachability_t;
//temporary reachabilities
aas_lreachability_t *reachabilityheap;  //heap with reachabilities
aas_lreachability_t *nextreachability;  //next free reachability from the heap
aas_lreachability_t **areareachability; //reachability links for every area
int numlreachabilities;

//===========================================================================
// returns the surface area of the given face
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
float AAS_FaceArea(aas_face_t *face)
{
    int i, edgenum, side;
    float total;
    vec_t *v;
    vec3_t d1, d2, cross;
    aas_edge_t *edge;

    edgenum = aasworld.edgeindex[face->firstedge];
    side = edgenum < 0;
    edge = &aasworld.edges[abs(edgenum)];
    v = aasworld.vertexes[edge->v[side]];

    total = 0;
    for (i = 1; i < face->numedges - 1; i++)
    {
        edgenum = aasworld.edgeindex[face->firstedge + i];
        side = edgenum < 0;
        edge = &aasworld.edges[abs(edgenum)];
        VectorSubtract(aasworld.vertexes[edge->v[side]], v, d1);
        VectorSubtract(aasworld.vertexes[edge->v[!side]], v, d2);
        CrossProduct(d1, d2, cross);
        total += 0.5 * VectorLength(cross);
    } //end for
    return total;
} //end of the function AAS_FaceArea
//===========================================================================
// returns the volume of an area
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
float AAS_AreaVolume(int areanum)
{
    int i, edgenum, facenum, side;
    vec_t d, a, volume;
    vec3_t corner;
    aas_plane_t *plane;
    aas_edge_t *edge;
    aas_face_t *face;
    aas_area_t *area;

    area = &aasworld.areas[areanum];
    facenum = aasworld.faceindex[area->firstface];
    face = &aasworld.faces[abs(facenum)];
    edgenum = aasworld.edgeindex[face->firstedge];
    edge = &aasworld.edges[abs(edgenum)];
    //
    VectorCopy(aasworld.vertexes[edge->v[0]], corner);

    //make tetrahedrons to all other faces
    volume = 0;
    for (i = 0; i < area->numfaces; i++)
    {
        facenum = abs(aasworld.faceindex[area->firstface + i]);
        face = &aasworld.faces[facenum];
        side = face->backarea != areanum;
        plane = &aasworld.planes[face->planenum ^ side];
        d = -(DotProduct (corner, plane->normal) - plane->dist);
        a = AAS_FaceArea(face);
        volume += d * a;
    } //end for

    volume /= 3;
    return volume;
} //end of the function AAS_AreaVolume
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_BestReachableLinkArea(aas_link_t *areas)
{
    aas_link_t *link;

    for (link = areas; link; link = link->next_area)
    {
        if (AAS_AreaGrounded(link->areanum) || AAS_AreaSwim(link->areanum))
        {
            return link->areanum;
        } //end if
    } //end for
    //
    for (link = areas; link; link = link->next_area)
    {
        if (link->areanum) return link->areanum;
        //FIXME: this is a bad idea when the reachability is not yet
        // calculated when the level items are loaded
        if (AAS_AreaReachability(link->areanum))
            return link->areanum;
    } //end for
    return 0;
} //end of the function AAS_BestReachableLinkArea
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int AAS_GetJumpPadInfo(int ent, vec3_t areastart, vec3_t absmins, vec3_t absmaxs, vec3_t velocity)
{
    int modelnum, ent2;
    float speed, height, gravity, time, dist, forward;
    vec3_t origin, angles, teststart, ent2origin;
    aas_trace_t trace;
    char model[MAX_EPAIRKEY];
    char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY];

    //
    AAS_FloatForBSPEpairKey(ent, "speed", &speed);
    if (!speed) speed = 1000;
    VectorClear(angles);
    //get the mins, maxs and origin of the model
    AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
    if (model[0]) modelnum = atoi(model+1);
    else modelnum = 0;
    AAS_BSPModelMinsMaxsOrigin(modelnum, angles, absmins, absmaxs, origin);
    VectorAdd(origin, absmins, absmins);
    VectorAdd(origin, absmaxs, absmaxs);
    VectorAdd(absmins, absmaxs, origin);
    VectorScale (origin, 0.5, origin);

    //get the start areas
    VectorCopy(origin, teststart);
    teststart[2] += 64;
    trace = AAS_TraceClientBBox(teststart, origin, PRESENCE_CROUCH, -1);
    if (trace.startsolid)
    {
        botimport.Print(PRT_MESSAGE, "trigger_push start solid\n");
        VectorCopy(origin, areastart);
    } //end if
    else
    {
        VectorCopy(trace.endpos, areastart);
    } //end else
    areastart[2] += 0.125;
    //
    //AAS_DrawPermanentCross(origin, 4, 4);
    //get the target entity
    AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY);
    for (ent2 = AAS_NextBSPEntity(0); ent2; ent2 = AAS_NextBSPEntity(ent2))
    {
        if (!AAS_ValueForBSPEpairKey(ent2, "targetname", targetname, MAX_EPAIRKEY)) continue;
        if (!strcmp(targetname, target)) break;
    } //end for
    if (!ent2)
    {
        botimport.Print(PRT_MESSAGE, "trigger_push without target entity %s\n", target);
        return qfalse;
    } //end if
    AAS_VectorForBSPEpairKey(ent2, "origin", ent2origin);
    //
    height = ent2origin[2] - origin[2];
    gravity = aassettings.phys_gravity;
    time = sqrt( height / ( 0.5 * gravity ) );
    if (!time)
    {
        botimport.Print(PRT_MESSAGE, "trigger_push without time\n");
        return qfalse;
    } //end if
    // set s.origin2 to the push velocity
    VectorSubtract ( ent2origin, origin, velocity);
    dist = VectorNormalize( velocity);
    forward = dist / time;
    //FIXME: why multiply by 1.1
    forward *= 1.1f;
    VectorScale(velocity, forward, velocity);
    velocity[2] = time * gravity;
    return qtrue;
} //end of the function AAS_GetJumpPadInfo
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int AAS_BestReachableFromJumpPadArea(vec3_t origin, vec3_t mins, vec3_t maxs)
{
    int area2num, ent, bot_visualizejumppads, bestareanum;
    float volume, bestareavolume;
    vec3_t areastart, cmdmove, bboxmins, bboxmaxs;
    vec3_t absmins, absmaxs, velocity;
    aas_clientmove_t move;
    aas_link_t *areas, *link;
    char classname[MAX_EPAIRKEY];

#ifdef BSPC
    bot_visualizejumppads = 0;
#else
    bot_visualizejumppads = LibVarValue("bot_visualizejumppads", "0");
#endif
    VectorAdd(origin, mins, bboxmins);
    VectorAdd(origin, maxs, bboxmaxs);
    for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
    {
        if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
        if (strcmp(classname, "trigger_push")) continue;
        //
        if (!AAS_GetJumpPadInfo(ent, areastart, absmins, absmaxs, velocity)) continue;
        //get the areas the jump pad brush is in
        areas = AAS_LinkEntityClientBBox(absmins, absmaxs, -1, PRESENCE_CROUCH);
        for (link = areas; link; link = link->next_area)
        {
            if (AAS_AreaJumpPad(link->areanum)) break;
        } //end for
        if (!link)
        {
            botimport.Print(PRT_MESSAGE, "trigger_push not in any jump pad area\n");
            AAS_UnlinkFromAreas(areas);
            continue;
        } //end if
        //
        //botimport.Print(PRT_MESSAGE, "found a trigger_push with velocity %f %f %f\n", velocity[0], velocity[1], velocity[2]);
        //
        VectorSet(cmdmove, 0, 0, 0);
        Com_Memset(&move, 0, sizeof(aas_clientmove_t));
        area2num = 0;
        AAS_ClientMovementHitBBox(&move, -1, areastart, PRESENCE_NORMAL, qfalse,
                                velocity, cmdmove, 0, 30, 0.1f, bboxmins, bboxmaxs, bot_visualizejumppads);
        if (move.frames < 30)
        {
            bestareanum = 0;
            bestareavolume = 0;
            for (link = areas; link; link = link->next_area)
            {
                if (!AAS_AreaJumpPad(link->areanum)) continue;
                volume = AAS_AreaVolume(link->areanum);
                if (volume >= bestareavolume)
                {
                    bestareanum = link->areanum;
                    bestareavolume = volume;
                } //end if
            } //end if
            AAS_UnlinkFromAreas(areas);
            return bestareanum;
        } //end if
        AAS_UnlinkFromAreas(areas);
    } //end for
    return 0;
} //end of the function AAS_BestReachableFromJumpPadArea
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_BestReachableArea(vec3_t origin, vec3_t mins, vec3_t maxs, vec3_t goalorigin)
{
    int areanum, i, j, k, l;
    aas_link_t *areas;
    vec3_t absmins, absmaxs;
    //vec3_t bbmins, bbmaxs;
    vec3_t start, end;
    aas_trace_t trace;

    if (!aasworld.loaded)
    {
        botimport.Print(PRT_ERROR, "AAS_BestReachableArea: aas not loaded\n");
        return 0;
    } //end if
    //find a point in an area
    VectorCopy(origin, start);
    areanum = AAS_PointAreaNum(start);
    //while no area found fudge around a little
    for (i = 0; i < 5 && !areanum; i++)
    {
        for (j = 0; j < 5 && !areanum; j++)
        {
            for (k = -1; k <= 1 && !areanum; k++)
            {
                for (l = -1; l <= 1 && !areanum; l++)
                {
                    VectorCopy(origin, start);
                    start[0] += (float) j * 4 * k;
                    start[1] += (float) j * 4 * l;
                    start[2] += (float) i * 4;
                    areanum = AAS_PointAreaNum(start);
                } //end for
            } //end for
        } //end for
    } //end for
    //if an area was found
    if (areanum)
    {
        //drop client bbox down and try again
        VectorCopy(start, end);
        start[2] += 0.25;
        end[2] -= 50;
        trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
        if (!trace.startsolid)
        {
            areanum = AAS_PointAreaNum(trace.endpos);
            VectorCopy(trace.endpos, goalorigin);
            //FIXME: cannot enable next line right now because the reachability
            // does not have to be calculated when the level items are loaded
            //if the origin is in an area with reachability
            //if (AAS_AreaReachability(areanum)) return areanum;
            if (areanum) return areanum;
        } //end if
        else
        {
            //it can very well happen that the AAS_PointAreaNum function tells that
            //a point is in an area and that starting a AAS_TraceClientBBox from that
            //point will return trace.startsolid qtrue
#if 0
            if (AAS_PointAreaNum(start))
            {
                Log_Write("point %f %f %f in area %d but trace startsolid", start[0], start[1], start[2], areanum);
                AAS_DrawPermanentCross(start, 4, LINECOLOR_RED);
            } //end if
            botimport.Print(PRT_MESSAGE, "AAS_BestReachableArea: start solid\n");
#endif
            VectorCopy(start, goalorigin);
            return areanum;
        } //end else
    } //end if
    //
    //AAS_PresenceTypeBoundingBox(PRESENCE_CROUCH, bbmins, bbmaxs);
    //NOTE: the goal origin does not have to be in the goal area
    // because the bot will have to move towards the item origin anyway
    VectorCopy(origin, goalorigin);
    //
    VectorAdd(origin, mins, absmins);
    VectorAdd(origin, maxs, absmaxs);
    //add bounding box size
    //VectorSubtract(absmins, bbmaxs, absmins);
    //VectorSubtract(absmaxs, bbmins, absmaxs);
    //link an invalid (-1) entity
    areas = AAS_LinkEntityClientBBox(absmins, absmaxs, -1, PRESENCE_CROUCH);
    //get the reachable link arae
    areanum = AAS_BestReachableLinkArea(areas);
    //unlink the invalid entity
    AAS_UnlinkFromAreas(areas);
    //
    return areanum;
} //end of the function AAS_BestReachableArea
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void AAS_SetupReachabilityHeap(void)
{
    int i;

    reachabilityheap = (aas_lreachability_t *) GetClearedMemory(
                        AAS_MAX_REACHABILITYSIZE * sizeof(aas_lreachability_t));
    for (i = 0; i < AAS_MAX_REACHABILITYSIZE-1; i++)
    {
        reachabilityheap[i].next = &reachabilityheap[i+1];
    } //end for
    reachabilityheap[AAS_MAX_REACHABILITYSIZE-1].next = NULL;
    nextreachability = reachabilityheap;
    numlreachabilities = 0;
} //end of the function AAS_InitReachabilityHeap
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void AAS_ShutDownReachabilityHeap(void)
{
    FreeMemory(reachabilityheap);
    numlreachabilities = 0;
} //end of the function AAS_ShutDownReachabilityHeap
//===========================================================================
// returns a reachability link
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
aas_lreachability_t *AAS_AllocReachability(void)
{
    aas_lreachability_t *r;

    if (!nextreachability) return NULL;
    //make sure the error message only shows up once
    if (!nextreachability->next) AAS_Error("AAS_MAX_REACHABILITYSIZE");
    //
    r = nextreachability;
    nextreachability = nextreachability->next;
    numlreachabilities++;
    return r;
} //end of the function AAS_AllocReachability
//===========================================================================
// frees a reachability link
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void AAS_FreeReachability(aas_lreachability_t *lreach)
{
    Com_Memset(lreach, 0, sizeof(aas_lreachability_t));

    lreach->next = nextreachability;
    nextreachability = lreach;
    numlreachabilities--;
} //end of the function AAS_FreeReachability
//===========================================================================
// returns qtrue if the area has reachability links
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_AreaReachability(int areanum)
{
    if (areanum < 0 || areanum >= aasworld.numareas)
    {
        AAS_Error("AAS_AreaReachability: areanum %d out of range", areanum);
        return 0;
    } //end if
    return aasworld.areasettings[areanum].numreachableareas;
} //end of the function AAS_AreaReachability
//===========================================================================
// returns the surface area of all ground faces together of the area
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
float AAS_AreaGroundFaceArea(int areanum)
{
    int i;
    float total;
    aas_area_t *area;
    aas_face_t *face;

    total = 0;
    area = &aasworld.areas[areanum];
    for (i = 0; i < area->numfaces; i++)
    {
        face = &aasworld.faces[abs(aasworld.faceindex[area->firstface + i])];
        if (!(face->faceflags & FACE_GROUND)) continue;
        //
        total += AAS_FaceArea(face);
    } //end for
    return total;
} //end of the function AAS_AreaGroundFaceArea
//===========================================================================
// returns the center of a face
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void AAS_FaceCenter(int facenum, vec3_t center)
{
    int i;
    float scale;
    aas_face_t *face;
    aas_edge_t *edge;

    face = &aasworld.faces[facenum];

    VectorClear(center);
    for (i = 0; i < face->numedges; i++)
    {
        edge = &aasworld.edges[abs(aasworld.edgeindex[face->firstedge + i])];
        VectorAdd(center, aasworld.vertexes[edge->v[0]], center);
        VectorAdd(center, aasworld.vertexes[edge->v[1]], center);
    } //end for
    scale = 0.5 / face->numedges;
    VectorScale(center, scale, center);
} //end of the function AAS_FaceCenter
//===========================================================================
// returns the maximum distance a player can fall before being damaged
// damage = deltavelocity*deltavelocity  * 0.0001
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_FallDamageDistance(void)
{
    float maxzvelocity, gravity, t;

    maxzvelocity = sqrt(30 * 10000);
    gravity = aassettings.phys_gravity;
    t = maxzvelocity / gravity;
    return 0.5 * gravity * t * t;
} //end of the function AAS_FallDamageDistance
//===========================================================================
// distance = 0.5 * gravity * t * t
// vel = t * gravity
// damage = vel * vel * 0.0001
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
float AAS_FallDelta(float distance)
{
    float t, delta, gravity;

    gravity = aassettings.phys_gravity;
    t = sqrt(fabs(distance) * 2 / gravity);
    delta = t * gravity;
    return delta * delta * 0.0001;
} //end of the function AAS_FallDelta
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
float AAS_MaxJumpHeight(float phys_jumpvel)
{
    float phys_gravity;

    phys_gravity = aassettings.phys_gravity;
    //maximum height a player can jump with the given initial z velocity
    return 0.5 * phys_gravity * (phys_jumpvel / phys_gravity) * (phys_jumpvel / phys_gravity);
} //end of the function MaxJumpHeight
//===========================================================================
// returns true if a player can only crouch in the area
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
float AAS_MaxJumpDistance(float phys_jumpvel)
{
    float phys_gravity, phys_maxvelocity, t;

    phys_gravity = aassettings.phys_gravity;
    phys_maxvelocity = aassettings.phys_maxvelocity;
    //time a player takes to fall the height
    t = sqrt(aassettings.rs_maxjumpfallheight / (0.5 * phys_gravity));
   //maximum distance
    return phys_maxvelocity * (t + phys_jumpvel / phys_gravity);
} //end of the function AAS_MaxJumpDistance
//===========================================================================
// returns true if a player can only crouch in the area
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_AreaCrouch(int areanum)
{
    if (!(aasworld.areasettings[areanum].presencetype & PRESENCE_NORMAL)) return qtrue;
    else return qfalse;
} //end of the function AAS_AreaCrouch
//===========================================================================
// returns qtrue if it is possible to swim in the area
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_AreaSwim(int areanum)
{
    if (aasworld.areasettings[areanum].areaflags & AREA_LIQUID) return qtrue;
    else return qfalse;
} //end of the function AAS_AreaSwim
//===========================================================================
// returns qtrue if the area contains a liquid
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_AreaLiquid(int areanum)
{
    if (aasworld.areasettings[areanum].areaflags & AREA_LIQUID) return qtrue;
    else return qfalse;
} //end of the function AAS_AreaLiquid
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int AAS_AreaLava(int areanum)
{
    return (aasworld.areasettings[areanum].contents & AREACONTENTS_LAVA);
} //end of the function AAS_AreaLava
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int AAS_AreaSlime(int areanum)
{
    return (aasworld.areasettings[areanum].contents & AREACONTENTS_SLIME);
} //end of the function AAS_AreaSlime
//===========================================================================
// returns qtrue if the area contains ground faces
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_AreaGrounded(int areanum)
{
    return (aasworld.areasettings[areanum].areaflags & AREA_GROUNDED);
} //end of the function AAS_AreaGround
//===========================================================================
// returns true if the area contains ladder faces
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_AreaLadder(int areanum)
{
    return (aasworld.areasettings[areanum].areaflags & AREA_LADDER);
} //end of the function AAS_AreaLadder
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_AreaJumpPad(int areanum)
{
    return (aasworld.areasettings[areanum].contents & AREACONTENTS_JUMPPAD);
} //end of the function AAS_AreaJumpPad
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_AreaTeleporter(int areanum)
{
    return (aasworld.areasettings[areanum].contents & AREACONTENTS_TELEPORTER);
} //end of the function AAS_AreaTeleporter
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_AreaClusterPortal(int areanum)
{
    return (aasworld.areasettings[areanum].contents & AREACONTENTS_CLUSTERPORTAL);
} //end of the function AAS_AreaClusterPortal
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_AreaDoNotEnter(int areanum)
{
    return (aasworld.areasettings[areanum].contents & AREACONTENTS_DONOTENTER);
} //end of the function AAS_AreaDoNotEnter
//===========================================================================
// returns the time it takes perform a barrier jump
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
unsigned short int AAS_BarrierJumpTravelTime(void)
{
    return aassettings.phys_jumpvel / (aassettings.phys_gravity * 0.1);
} //end op the function AAS_BarrierJumpTravelTime
//===========================================================================
// returns true if there already exists a reachability from area1 to area2
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
qboolean AAS_ReachabilityExists(int area1num, int area2num)
{
    aas_lreachability_t *r;

    for (r = areareachability[area1num]; r; r = r->next)
    {
        if (r->areanum == area2num) return qtrue;
    } //end for
    return qfalse;
} //end of the function AAS_ReachabilityExists
//===========================================================================
// returns true if there is a solid just after the end point when going
// from start to end
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_NearbySolidOrGap(vec3_t start, vec3_t end)
{
    vec3_t dir, testpoint;
    int areanum;

    VectorSubtract(end, start, dir);
    dir[2] = 0;
    VectorNormalize(dir);
    VectorMA(end, 48, dir, testpoint);

    areanum = AAS_PointAreaNum(testpoint);
    if (!areanum)
    {
        testpoint[2] += 16;
        areanum = AAS_PointAreaNum(testpoint);
        if (!areanum) return qtrue;
    } //end if
    VectorMA(end, 64, dir, testpoint);
    areanum = AAS_PointAreaNum(testpoint);
    if (areanum)
    {
        if (!AAS_AreaSwim(areanum) && !AAS_AreaGrounded(areanum)) return qtrue;
    } //end if
    return qfalse;
} //end of the function AAS_SolidGapTime
//===========================================================================
// searches for swim reachabilities between adjacent areas
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_Reachability_Swim(int area1num, int area2num)
{
    int i, j, face1num, face2num, side1;
    aas_area_t *area1, *area2;
    aas_areasettings_t *areasettings;
    aas_lreachability_t *lreach;
    aas_face_t *face1;
    aas_plane_t *plane;
    vec3_t start;

    if (!AAS_AreaSwim(area1num) || !AAS_AreaSwim(area2num)) return qfalse;
    //if the second area is crouch only
    if (!(aasworld.areasettings[area2num].presencetype & PRESENCE_NORMAL)) return qfalse;

    area1 = &aasworld.areas[area1num];
    area2 = &aasworld.areas[area2num];

    //if the areas are not near anough
    for (i = 0; i < 3; i++)
    {
        if (area1->mins[i] > area2->maxs[i] + 10) return qfalse;
        if (area1->maxs[i] < area2->mins[i] - 10) return qfalse;
    } //end for
    //find a shared face and create a reachability link
    for (i = 0; i < area1->numfaces; i++)
    {
        face1num = aasworld.faceindex[area1->firstface + i];
        side1 = face1num < 0;
        face1num = abs(face1num);
        //
        for (j = 0; j < area2->numfaces; j++)
        {
            face2num = abs(aasworld.faceindex[area2->firstface + j]);
            //
            if (face1num == face2num)
            {
                AAS_FaceCenter(face1num, start);
                //
                if (AAS_PointContents(start) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER))
                {
                    //
                    face1 = &aasworld.faces[face1num];
                    areasettings = &aasworld.areasettings[area1num];
                    //create a new reachability link
                    lreach = AAS_AllocReachability();
                    if (!lreach) return qfalse;
                    lreach->areanum = area2num;
                    lreach->facenum = face1num;
                    lreach->edgenum = 0;
                    VectorCopy(start, lreach->start);
                    plane = &aasworld.planes[face1->planenum ^ side1];
                    VectorMA(lreach->start, -INSIDEUNITS, plane->normal, lreach->end);
                    lreach->traveltype = TRAVEL_SWIM;
                    lreach->traveltime = 1;
                    //if the volume of the area is rather small
                    if (AAS_AreaVolume(area2num) < 800)
                        lreach->traveltime += 200;
                    //if (!(AAS_PointContents(start) & MASK_WATER)) lreach->traveltime += 500;
                    //link the reachability
                    lreach->next = areareachability[area1num];
                    areareachability[area1num] = lreach;
                    reach_swim++;
                    return qtrue;
                } //end if
            } //end if
        } //end for
    } //end for
    return qfalse;
} //end of the function AAS_Reachability_Swim
//===========================================================================
// searches for reachabilities between adjacent areas with equal floor
// heights
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_Reachability_EqualFloorHeight(int area1num, int area2num)
{
    int i, j, edgenum, edgenum1, edgenum2, foundreach, side;
    float height, bestheight, length, bestlength;
    vec3_t dir, start, end, normal, invgravity, gravitydirection = {0, 0, -1};
    vec3_t edgevec;
    aas_area_t *area1, *area2;
    aas_face_t *face1, *face2;
    aas_edge_t *edge;
    aas_plane_t *plane2;
    aas_lreachability_t lr, *lreach;

    if (!AAS_AreaGrounded(area1num) || !AAS_AreaGrounded(area2num)) return qfalse;

    area1 = &aasworld.areas[area1num];
    area2 = &aasworld.areas[area2num];
    //if the areas are not near anough in the x-y direction
    for (i = 0; i < 2; i++)
    {
        if (area1->mins[i] > area2->maxs[i] + 10) return qfalse;
        if (area1->maxs[i] < area2->mins[i] - 10) return qfalse;
    } //end for
    //if area 2 is too high above area 1
    if (area2->mins[2] > area1->maxs[2]) return qfalse;
    //
    VectorCopy(gravitydirection, invgravity);
    VectorInverse(invgravity);
    //
    bestheight = 99999;
    bestlength = 0;
    foundreach = qfalse;
    Com_Memset(&lr, 0, sizeof(aas_lreachability_t)); //make the compiler happy
    //
    //check if the areas have ground faces with a common edge
    //if existing use the lowest common edge for a reachability link
    for (i = 0; i < area1->numfaces; i++)
    {
        face1 = &aasworld.faces[abs(aasworld.faceindex[area1->firstface + i])];
        if (!(face1->faceflags & FACE_GROUND)) continue;
        //
        for (j = 0; j < area2->numfaces; j++)
        {
            face2 = &aasworld.faces[abs(aasworld.faceindex[area2->firstface + j])];
            if (!(face2->faceflags & FACE_GROUND)) continue;
            //if there is a common edge
            for (edgenum1 = 0; edgenum1 < face1->numedges; edgenum1++)
            {
                for (edgenum2 = 0; edgenum2 < face2->numedges; edgenum2++)
                {
                    if (abs(aasworld.edgeindex[face1->firstedge + edgenum1]) !=
                            abs(aasworld.edgeindex[face2->firstedge + edgenum2]))
                                    continue;
                    edgenum = aasworld.edgeindex[face1->firstedge + edgenum1];
                    side = edgenum < 0;
                    edge = &aasworld.edges[abs(edgenum)];
                    //get the length of the edge
                    VectorSubtract(aasworld.vertexes[edge->v[1]],
                                aasworld.vertexes[edge->v[0]], dir);
                    length = VectorLength(dir);
                    //get the start point
                    VectorAdd(aasworld.vertexes[edge->v[0]],
                                aasworld.vertexes[edge->v[1]], start);
                    VectorScale(start, 0.5, start);
                    VectorCopy(start, end);
                    //get the end point several units inside area2
                    //and the start point several units inside area1
                    //NOTE: normal is pointing into area2 because the
                    //face edges are stored counter clockwise
                    VectorSubtract(aasworld.vertexes[edge->v[side]],
                                aasworld.vertexes[edge->v[!side]], edgevec);
                    plane2 = &aasworld.planes[face2->planenum];
                    CrossProduct(edgevec, plane2->normal, normal);
                    VectorNormalize(normal);
                    //
                    //VectorMA(start, -1, normal, start);
                    VectorMA(end, INSIDEUNITS_WALKEND, normal, end);
                    VectorMA(start, INSIDEUNITS_WALKSTART, normal, start);
                    end[2] += 0.125;
                    //
                    height = DotProduct(invgravity, start);
                    //NOTE: if there's nearby solid or a gap area after this area
                    //disabled this crap
                    //if (AAS_NearbySolidOrGap(start, end)) height += 200;
                    //NOTE: disabled because it disables reachabilities to very small areas
                    //if (AAS_PointAreaNum(end) != area2num) continue;
                    //get the longest lowest edge
                    if (height < bestheight ||
                            (height < bestheight + 1 && length > bestlength))
                    {
                        bestheight = height;
                        bestlength = length;
                        //create a new reachability link
                        lr.areanum = area2num;
                        lr.facenum = 0;
                        lr.edgenum = edgenum;
                        VectorCopy(start, lr.start);
                        VectorCopy(end, lr.end);
                        lr.traveltype = TRAVEL_WALK;
                        lr.traveltime = 1;
                        foundreach = qtrue;
                    } //end if
                } //end for
            } //end for
        } //end for
    } //end for
    if (foundreach)
    {
        //create a new reachability link
        lreach = AAS_AllocReachability();
        if (!lreach) return qfalse;
        lreach->areanum = lr.areanum;
        lreach->facenum = lr.facenum;
        lreach->edgenum = lr.edgenum;
        VectorCopy(lr.start, lreach->start);
        VectorCopy(lr.end, lreach->end);
        lreach->traveltype = lr.traveltype;
        lreach->traveltime = lr.traveltime;
        lreach->next = areareachability[area1num];
        areareachability[area1num] = lreach;
        //if going into a crouch area
        if (!AAS_AreaCrouch(area1num) && AAS_AreaCrouch(area2num))
        {
            lreach->traveltime += aassettings.rs_startcrouch;
        } //end if
        /*
        //NOTE: if there's nearby solid or a gap area after this area
        if (!AAS_NearbySolidOrGap(lreach->start, lreach->end))
        {
            lreach->traveltime += 100;
        } //end if
        */
        //avoid rather small areas
        //if (AAS_AreaGroundFaceArea(lreach->areanum) < 500) lreach->traveltime += 100;
        //
        reach_equalfloor++;
        return qtrue;
    } //end if
    return qfalse;
} //end of the function AAS_Reachability_EqualFloorHeight
//===========================================================================
// searches step, barrier, waterjump and walk off ledge reachabilities
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(int area1num, int area2num)
{
    int i, j, k, l, edge1num, edge2num, areas[10], numareas;
    int ground_bestarea2groundedgenum, ground_foundreach;
    int water_bestarea2groundedgenum, water_foundreach;
    int side1, area1swim, faceside1, groundface1num;
    float dist, dist1, dist2, diff, invgravitydot, ortdot;
    float x1, x2, x3, x4, y1, y2, y3, y4, tmp, y;
    float length, ground_bestlength, water_bestlength, ground_bestdist, water_bestdist;
    vec3_t v1, v2, v3, v4, tmpv, p1area1, p1area2, p2area1, p2area2;
    vec3_t normal, ort, edgevec, start, end, dir;
    vec3_t ground_beststart, ground_bestend, ground_bestnormal;
    vec3_t water_beststart, water_bestend, water_bestnormal;
    vec3_t invgravity = {0, 0, 1};
    vec3_t testpoint;
    aas_plane_t *plane;
    aas_area_t *area1, *area2;
    aas_face_t *groundface1, *groundface2, *ground_bestface1, *water_bestface1;
    aas_edge_t *edge1, *edge2;
    aas_lreachability_t *lreach;
    aas_trace_t trace;

    //must be able to walk or swim in the first area
    if (!AAS_AreaGrounded(area1num) && !AAS_AreaSwim(area1num)) return qfalse;
    //
    if (!AAS_AreaGrounded(area2num) && !AAS_AreaSwim(area2num)) return qfalse;
    //
    area1 = &aasworld.areas[area1num];
    area2 = &aasworld.areas[area2num];
    //if the first area contains a liquid
    area1swim = AAS_AreaSwim(area1num);
    //if the areas are not near anough in the x-y direction
    for (i = 0; i < 2; i++)
    {
        if (area1->mins[i] > area2->maxs[i] + 10) return qfalse;
        if (area1->maxs[i] < area2->mins[i] - 10) return qfalse;
    } //end for
    //
    ground_foundreach = qfalse;
    ground_bestdist = 99999;
    ground_bestlength = 0;
    ground_bestarea2groundedgenum = 0;
    //
    water_foundreach = qfalse;
    water_bestdist = 99999;
    water_bestlength = 0;
    water_bestarea2groundedgenum = 0;
    //
    for (i = 0; i < area1->numfaces; i++)
    {
        groundface1num = aasworld.faceindex[area1->firstface + i];
        faceside1 = groundface1num < 0;
        groundface1 = &aasworld.faces[abs(groundface1num)];
        //if this isn't a ground face
        if (!(groundface1->faceflags & FACE_GROUND))
        {
            //if we can swim in the first area
            if (area1swim)
            {
                //face plane must be more or less horizontal
                plane = &aasworld.planes[groundface1->planenum ^ (!faceside1)];
                if (DotProduct(plane->normal, invgravity) < 0.7) continue;
            } //end if
            else
            {
                //if we can't swim in the area it must be a ground face
                continue;
            } //end else
        } //end if
        //
        for (k = 0; k < groundface1->numedges; k++)
        {
            edge1num = aasworld.edgeindex[groundface1->firstedge + k];
            side1 = (edge1num < 0);
            //NOTE: for water faces we must take the side area 1 is
            // on into account because the face is shared and doesn't
            // have to be oriented correctly
            if (!(groundface1->faceflags & FACE_GROUND)) side1 = (side1 == faceside1);
            edge1num = abs(edge1num);
            edge1 = &aasworld.edges[edge1num];
            //vertexes of the edge
            VectorCopy(aasworld.vertexes[edge1->v[!side1]], v1);
            VectorCopy(aasworld.vertexes[edge1->v[side1]], v2);
            //get a vertical plane through the edge
            //NOTE: normal is pointing into area 2 because the
            //face edges are stored counter clockwise
            VectorSubtract(v2, v1, edgevec);
            CrossProduct(edgevec, invgravity, normal);
            VectorNormalize(normal);
            dist = DotProduct(normal, v1);
            //check the faces from the second area
            for (j = 0; j < area2->numfaces; j++)
            {
                groundface2 = &aasworld.faces[abs(aasworld.faceindex[area2->firstface + j])];
                //must be a ground face
                if (!(groundface2->faceflags & FACE_GROUND)) continue;
                //check the edges of this ground face
                for (l = 0; l < groundface2->numedges; l++)
                {
                    edge2num = abs(aasworld.edgeindex[groundface2->firstedge + l]);
                    edge2 = &aasworld.edges[edge2num];
                    //vertexes of the edge
                    VectorCopy(aasworld.vertexes[edge2->v[0]], v3);
                    VectorCopy(aasworld.vertexes[edge2->v[1]], v4);
                    //check the distance between the two points and the vertical plane
                    //through the edge of area1
                    diff = DotProduct(normal, v3) - dist;
                    if (diff < -0.1 || diff > 0.1) continue;
                    diff = DotProduct(normal, v4) - dist;
                    if (diff < -0.1 || diff > 0.1) continue;
                    //
                    //project the two ground edges into the step side plane
                    //and calculate the shortest distance between the two
                    //edges if they overlap in the direction orthogonal to
                    //the gravity direction
                    CrossProduct(invgravity, normal, ort);
                    invgravitydot = DotProduct(invgravity, invgravity);
                    ortdot = DotProduct(ort, ort);
                    //projection into the step plane
                    //NOTE: since gravity is vertical this is just the z coordinate
                    y1 = v1[2];//DotProduct(v1, invgravity) / invgravitydot;
                    y2 = v2[2];//DotProduct(v2, invgravity) / invgravitydot;
                    y3 = v3[2];//DotProduct(v3, invgravity) / invgravitydot;
                    y4 = v4[2];//DotProduct(v4, invgravity) / invgravitydot;
                    //
                    x1 = DotProduct(v1, ort) / ortdot;
                    x2 = DotProduct(v2, ort) / ortdot;
                    x3 = DotProduct(v3, ort) / ortdot;
                    x4 = DotProduct(v4, ort) / ortdot;
                    //
                    if (x1 > x2)
                    {
                        tmp = x1; x1 = x2; x2 = tmp;
                        tmp = y1; y1 = y2; y2 = tmp;
                        VectorCopy(v1, tmpv); VectorCopy(v2, v1); VectorCopy(tmpv, v2);
                    } //end if
                    if (x3 > x4)
                    {
                        tmp = x3; x3 = x4; x4 = tmp;
                        tmp = y3; y3 = y4; y4 = tmp;
                        VectorCopy(v3, tmpv); VectorCopy(v4, v3); VectorCopy(tmpv, v4);
                    } //end if
                    //if the two projected edge lines have no overlap
                    if (x2 <= x3 || x4 <= x1)
                    {
//                      Log_Write("lines no overlap: from area %d to %d\r\n", area1num, area2num);
                        continue;
                    } //end if
                    //if the two lines fully overlap
                    if ((x1 - 0.5 < x3 && x4 < x2 + 0.5) &&
                            (x3 - 0.5 < x1 && x2 < x4 + 0.5))
                    {
                        dist1 = y3 - y1;
                        dist2 = y4 - y2;
                        VectorCopy(v1, p1area1);
                        VectorCopy(v2, p2area1);
                        VectorCopy(v3, p1area2);
                        VectorCopy(v4, p2area2);
                    } //end if
                    else
                    {
                        //if the points are equal
                        if (x1 > x3 - 0.1 && x1 < x3 + 0.1)
                        {
                            dist1 = y3 - y1;
                            VectorCopy(v1, p1area1);
                            VectorCopy(v3, p1area2);
                        } //end if
                        else if (x1 < x3)
                        {
                            y = y1 + (x3 - x1) * (y2 - y1) / (x2 - x1);
                            dist1 = y3 - y;
                            VectorCopy(v3, p1area1);
                            p1area1[2] = y;
                            VectorCopy(v3, p1area2);
                        } //end if
                        else
                        {
                            y = y3 + (x1 - x3) * (y4 - y3) / (x4 - x3);
                            dist1 = y - y1;
                            VectorCopy(v1, p1area1);
                            VectorCopy(v1, p1area2);
                            p1area2[2] = y;
                        } //end if
                        //if the points are equal
                        if (x2 > x4 - 0.1 && x2 < x4 + 0.1)
                        {
                            dist2 = y4 - y2;
                            VectorCopy(v2, p2area1);
                            VectorCopy(v4, p2area2);
                        } //end if
                        else if (x2 < x4)
                        {
                            y = y3 + (x2 - x3) * (y4 - y3) / (x4 - x3);
                            dist2 = y - y2;
                            VectorCopy(v2, p2area1);
                            VectorCopy(v2, p2area2);
                            p2area2[2] = y;
                        } //end if
                        else
                        {
                            y = y1 + (x4 - x1) * (y2 - y1) / (x2 - x1);
                            dist2 = y4 - y;
                            VectorCopy(v4, p2area1);
                            p2area1[2] = y;
                            VectorCopy(v4, p2area2);
                        } //end else
                    } //end else
                    //if both distances are pretty much equal
                    //then we take the middle of the points
                    if (dist1 > dist2 - 1 && dist1 < dist2 + 1)
                    {
                        dist = dist1;
                        VectorAdd(p1area1, p2area1, start);
                        VectorScale(start, 0.5, start);
                        VectorAdd(p1area2, p2area2, end);
                        VectorScale(end, 0.5, end);
                    } //end if
                    else if (dist1 < dist2)
                    {
                        dist = dist1;
                        VectorCopy(p1area1, start);
                        VectorCopy(p1area2, end);
                    } //end else if
                    else
                    {
                        dist = dist2;
                        VectorCopy(p2area1, start);
                        VectorCopy(p2area2, end);
                    } //end else
                    //get the length of the overlapping part of the edges of the two areas
                    VectorSubtract(p2area2, p1area2, dir);
                    length = VectorLength(dir);
                    //
                    if (groundface1->faceflags & FACE_GROUND)
                    {
                        //if the vertical distance is smaller
                        if (dist < ground_bestdist ||
                                //or the vertical distance is pretty much the same
                                //but the overlapping part of the edges is longer
                                (dist < ground_bestdist + 1 && length > ground_bestlength))
                        {
                            ground_bestdist = dist;
                            ground_bestlength = length;
                            ground_foundreach = qtrue;
                            ground_bestarea2groundedgenum = edge1num;
                            ground_bestface1 = groundface1;
                            //best point towards area1
                            VectorCopy(start, ground_beststart);
                            //normal is pointing into area2
                            VectorCopy(normal, ground_bestnormal);
                            //best point towards area2
                            VectorCopy(end, ground_bestend);
                        } //end if
                    } //end if
                    else
                    {
                        //if the vertical distance is smaller
                        if (dist < water_bestdist ||
                                //or the vertical distance is pretty much the same
                                //but the overlapping part of the edges is longer
                                (dist < water_bestdist + 1 && length > water_bestlength))
                        {
                            water_bestdist = dist;
                            water_bestlength = length;
                            water_foundreach = qtrue;
                            water_bestarea2groundedgenum = edge1num;
                            water_bestface1 = groundface1;
                            //best point towards area1
                            VectorCopy(start, water_beststart);
                            //normal is pointing into area2
                            VectorCopy(normal, water_bestnormal);
                            //best point towards area2
                            VectorCopy(end, water_bestend);
                        } //end if
                    } //end else
                } //end for
            } //end for
        } //end for
    } //end for
    //
    // NOTE: swim reachabilities are already filtered out
    //
    // Steps
    //
    //        ---------
    //        |          step height -> TRAVEL_WALK
    //--------|
    //
    //        ---------
    //~~~~~~~~|          step height and low water -> TRAVEL_WALK
    //--------|
    //
    //~~~~~~~~~~~~~~~~~~
    //        ---------
    //        |          step height and low water up to the step -> TRAVEL_WALK
    //--------|
    //
    //check for a step reachability
    if (ground_foundreach)
    {
        //if area2 is higher but lower than the maximum step height
        //NOTE: ground_bestdist >= 0 also catches equal floor reachabilities
        if (ground_bestdist >= 0 && ground_bestdist < aassettings.phys_maxstep)
        {
            //create walk reachability from area1 to area2
            lreach = AAS_AllocReachability();
            if (!lreach) return qfalse;
            lreach->areanum = area2num;
            lreach->facenum = 0;
            lreach->edgenum = ground_bestarea2groundedgenum;
            VectorMA(ground_beststart, INSIDEUNITS_WALKSTART, ground_bestnormal, lreach->start);
            VectorMA(ground_bestend, INSIDEUNITS_WALKEND, ground_bestnormal, lreach->end);
            lreach->traveltype = TRAVEL_WALK;
            lreach->traveltime = 0;//1;
            //if going into a crouch area
            if (!AAS_AreaCrouch(area1num) && AAS_AreaCrouch(area2num))
            {
                lreach->traveltime += aassettings.rs_startcrouch;
            } //end if
            lreach->next = areareachability[area1num];
            areareachability[area1num] = lreach;
            //NOTE: if there's nearby solid or a gap area after this area
            /*
            if (!AAS_NearbySolidOrGap(lreach->start, lreach->end))
            {
                lreach->traveltime += 100;
            } //end if
            */
            //avoid rather small areas
            //if (AAS_AreaGroundFaceArea(lreach->areanum) < 500) lreach->traveltime += 100;
            //
            reach_step++;
            return qtrue;
        } //end if
    } //end if
    //
    // Water Jumps
    //
    //        ---------
    //        |
    //~~~~~~~~|
    //        |
    //        |          higher than step height and water up to waterjump height -> TRAVEL_WATERJUMP
    //--------|
    //
    //~~~~~~~~~~~~~~~~~~
    //        ---------
    //        |
    //        |
    //        |
    //        |          higher than step height and low water up to the step -> TRAVEL_WATERJUMP
    //--------|
    //
    //check for a waterjump reachability
    if (water_foundreach)
    {
        //get a test point a little bit towards area1
        VectorMA(water_bestend, -INSIDEUNITS, water_bestnormal, testpoint);
        //go down the maximum waterjump height
        testpoint[2] -= aassettings.phys_maxwaterjump;
        //if there IS water the sv_maxwaterjump height below the bestend point
        if (aasworld.areasettings[AAS_PointAreaNum(testpoint)].areaflags & AREA_LIQUID)
        {
            //don't create rediculous water jump reachabilities from areas very far below
            //the water surface
            if (water_bestdist < aassettings.phys_maxwaterjump + 24)
            {
                //waterjumping from or towards a crouch only area is not possible in Quake2
                if ((aasworld.areasettings[area1num].presencetype & PRESENCE_NORMAL) &&
                        (aasworld.areasettings[area2num].presencetype & PRESENCE_NORMAL))
                {
                    //create water jump reachability from area1 to area2
                    lreach = AAS_AllocReachability();
                    if (!lreach) return qfalse;
                    lreach->areanum = area2num;
                    lreach->facenum = 0;
                    lreach->edgenum = water_bestarea2groundedgenum;
                    VectorCopy(water_beststart, lreach->start);
                    VectorMA(water_bestend, INSIDEUNITS_WATERJUMP, water_bestnormal, lreach->end);
                    lreach->traveltype = TRAVEL_WATERJUMP;
                    lreach->traveltime = aassettings.rs_waterjump;
                    lreach->next = areareachability[area1num];
                    areareachability[area1num] = lreach;
                    //we've got another waterjump reachability
                    reach_waterjump++;
                    return qtrue;
                } //end if
            } //end if
        } //end if
    } //end if
    //
    // Barrier Jumps
    //
    //        ---------
    //        |
    //        |
    //        |
    //        |         higher than step height lower than barrier height -> TRAVEL_BARRIERJUMP
    //--------|
    //
    //        ---------
    //        |
    //        |
    //        |
    //~~~~~~~~|         higher than step height lower than barrier height
    //--------|         and a thin layer of water in the area to jump from -> TRAVEL_BARRIERJUMP
    //
    //check for a barrier jump reachability
    if (ground_foundreach)
    {
        //if area2 is higher but lower than the maximum barrier jump height
        if (ground_bestdist > 0 && ground_bestdist < aassettings.phys_maxbarrier)
        {
            //if no water in area1 or a very thin layer of water on the ground
            if (!water_foundreach || (ground_bestdist - water_bestdist < 16))
            {
                //cannot perform a barrier jump towards or from a crouch area in Quake2
                if (!AAS_AreaCrouch(area1num) && !AAS_AreaCrouch(area2num))
                {
                    //create barrier jump reachability from area1 to area2
                    lreach = AAS_AllocReachability();
                    if (!lreach) return qfalse;
                    lreach->areanum = area2num;
                    lreach->facenum = 0;
                    lreach->edgenum = ground_bestarea2groundedgenum;
                    VectorMA(ground_beststart, INSIDEUNITS_WALKSTART, ground_bestnormal, lreach->start);
                    VectorMA(ground_bestend, INSIDEUNITS_WALKEND, ground_bestnormal, lreach->end);
                    lreach->traveltype = TRAVEL_BARRIERJUMP;
                    lreach->traveltime = aassettings.rs_barrierjump;//AAS_BarrierJumpTravelTime();
                    lreach->next = areareachability[area1num];
                    areareachability[area1num] = lreach;
                    //we've got another barrierjump reachability
                    reach_barrier++;
                    return qtrue;
                } //end if
            } //end if
        } //end if
    } //end if
    //
    // Walk and Walk Off Ledge
    //
    //--------|
    //        |          can walk or step back -> TRAVEL_WALK
    //        ---------
    //
    //--------|
    //        |
    //        |
    //        |
    //        |          cannot walk/step back -> TRAVEL_WALKOFFLEDGE
    //        ---------
    //
    //--------|
    //        |
    //        |~~~~~~~~
    //        |
    //        |          cannot step back but can waterjump back -> TRAVEL_WALKOFFLEDGE
    //        ---------  FIXME: create TRAVEL_WALK reach??
    //
    //check for a walk or walk off ledge reachability
    if (ground_foundreach)
    {
        if (ground_bestdist < 0)
        {
            if (ground_bestdist > -aassettings.phys_maxstep)
            {
                //create walk reachability from area1 to area2
                lreach = AAS_AllocReachability();
                if (!lreach) return qfalse;
                lreach->areanum = area2num;
                lreach->facenum = 0;
                lreach->edgenum = ground_bestarea2groundedgenum;
                VectorMA(ground_beststart, INSIDEUNITS_WALKSTART, ground_bestnormal, lreach->start);
                VectorMA(ground_bestend, INSIDEUNITS_WALKEND, ground_bestnormal, lreach->end);
                lreach->traveltype = TRAVEL_WALK;
                lreach->traveltime = 1;
                lreach->next = areareachability[area1num];
                areareachability[area1num] = lreach;
                //we've got another walk reachability
                reach_walk++;
                return qtrue;
            } //end if
            // if no maximum fall height set or less than the max
            if (!aassettings.rs_maxfallheight || fabs(ground_bestdist) < aassettings.rs_maxfallheight) {
                //trace a bounding box vertically to check for solids
                VectorMA(ground_bestend, INSIDEUNITS, ground_bestnormal, ground_bestend);
                VectorCopy(ground_bestend, start);
                start[2] = ground_beststart[2];
                VectorCopy(ground_bestend, end);
                end[2] += 4;
                trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
                //if no solids were found
                if (!trace.startsolid && trace.fraction >= 1.0)
                {
                    //the trace end point must be in the goal area
                    trace.endpos[2] += 1;
                    if (AAS_PointAreaNum(trace.endpos) == area2num)
                    {
                        //if not going through a cluster portal
                        numareas = AAS_TraceAreas(start, end, areas, NULL, sizeof(areas) / sizeof(int));
                        for (i = 0; i < numareas; i++)
                            if (AAS_AreaClusterPortal(areas[i]))
                                break;
                        if (i >= numareas)
                        {
                            //create a walk off ledge reachability from area1 to area2
                            lreach = AAS_AllocReachability();
                            if (!lreach) return qfalse;
                            lreach->areanum = area2num;
                            lreach->facenum = 0;
                            lreach->edgenum = ground_bestarea2groundedgenum;
                            VectorCopy(ground_beststart, lreach->start);
                            VectorCopy(ground_bestend, lreach->end);
                            lreach->traveltype = TRAVEL_WALKOFFLEDGE;
                            lreach->traveltime = aassettings.rs_startwalkoffledge + fabs(ground_bestdist) * 50 / aassettings.phys_gravity;
                            //if falling from too high and not falling into water
                            if (!AAS_AreaSwim(area2num) && !AAS_AreaJumpPad(area2num))
                            {
                                if (AAS_FallDelta(ground_bestdist) > aassettings.phys_falldelta5)
                                {
                                    lreach->traveltime += aassettings.rs_falldamage5;
                                } //end if
                                if (AAS_FallDelta(ground_bestdist) > aassettings.phys_falldelta10)
                                {
                                    lreach->traveltime += aassettings.rs_falldamage10;
                                } //end if
                            } //end if
                            lreach->next = areareachability[area1num];
                            areareachability[area1num] = lreach;
                            //
                            reach_walkoffledge++;
                            //NOTE: don't create a weapon (rl, bfg) jump reachability here
                            //because it interferes with other reachabilities
                            //like the ladder reachability
                            return qtrue;
                        } //end if
                    } //end if
                } //end if
            } //end if
        } //end else
    } //end if
    return qfalse;
} //end of the function AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge
//===========================================================================
// returns the distance between the two vectors
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
float VectorDistance(vec3_t v1, vec3_t v2)
{
    vec3_t dir;

    VectorSubtract(v2, v1, dir);
    return VectorLength(dir);
} //end of the function VectorDistance
//===========================================================================
// returns true if the first vector is between the last two vectors
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int VectorBetweenVectors(vec3_t v, vec3_t v1, vec3_t v2)
{
    vec3_t dir1, dir2;

    VectorSubtract(v, v1, dir1);
    VectorSubtract(v, v2, dir2);
    return (DotProduct(dir1, dir2) <= 0);
} //end of the function VectorBetweenVectors
//===========================================================================
// returns the mid point between the two vectors
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void VectorMiddle(vec3_t v1, vec3_t v2, vec3_t middle)
{
    VectorAdd(v1, v2, middle);
    VectorScale(middle, 0.5, middle);
} //end of the function VectorMiddle
//===========================================================================
// calculate a range of points closest to each other on both edges
//
// Parameter:           beststart1      start of the range of points on edge v1-v2
//                      beststart2      end of the range of points  on edge v1-v2
//                      bestend1        start of the range of points on edge v3-v4
//                      bestend2        end of the range of points  on edge v3-v4
//                      bestdist        best distance so far
// Returns:             -
// Changes Globals:     -
//===========================================================================
/*
float AAS_ClosestEdgePoints(vec3_t v1, vec3_t v2, vec3_t v3, vec3_t v4,
                            aas_plane_t *plane1, aas_plane_t *plane2,
                            vec3_t beststart, vec3_t bestend, float bestdist)
{
    vec3_t dir1, dir2, p1, p2, p3, p4;
    float a1, a2, b1, b2, dist;
    int founddist;

    //edge vectors
    VectorSubtract(v2, v1, dir1);
    VectorSubtract(v4, v3, dir2);
    //get the horizontal directions
    dir1[2] = 0;
    dir2[2] = 0;
    //
    // p1 = point on an edge vector of area2 closest to v1
    // p2 = point on an edge vector of area2 closest to v2
    // p3 = point on an edge vector of area1 closest to v3
    // p4 = point on an edge vector of area1 closest to v4
    //
    if (dir2[0])
    {
        a2 = dir2[1] / dir2[0];
        b2 = v3[1] - a2 * v3[0];
        //point on the edge vector of area2 closest to v1
        p1[0] = (DotProduct(v1, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
        p1[1] = a2 * p1[0] + b2;
        //point on the edge vector of area2 closest to v2
        p2[0] = (DotProduct(v2, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
        p2[1] = a2 * p2[0] + b2;
    } //end if
    else
    {
        //point on the edge vector of area2 closest to v1
        p1[0] = v3[0];
        p1[1] = v1[1];
        //point on the edge vector of area2 closest to v2
        p2[0] = v3[0];
        p2[1] = v2[1];
    } //end else
    //
    if (dir1[0])
    {
        //
        a1 = dir1[1] / dir1[0];
        b1 = v1[1] - a1 * v1[0];
        //point on the edge vector of area1 closest to v3
        p3[0] = (DotProduct(v3, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
        p3[1] = a1 * p3[0] + b1;
        //point on the edge vector of area1 closest to v4
        p4[0] = (DotProduct(v4, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
        p4[1] = a1 * p4[0] + b1;
    } //end if
    else
    {
        //point on the edge vector of area1 closest to v3
        p3[0] = v1[0];
        p3[1] = v3[1];
        //point on the edge vector of area1 closest to v4
        p4[0] = v1[0];
        p4[1] = v4[1];
    } //end else
    //start with zero z-coordinates
    p1[2] = 0;
    p2[2] = 0;
    p3[2] = 0;
    p4[2] = 0;
    //calculate the z-coordinates from the ground planes
    p1[2] = (plane2->dist - DotProduct(plane2->normal, p1)) / plane2->normal[2];
    p2[2] = (plane2->dist - DotProduct(plane2->normal, p2)) / plane2->normal[2];
    p3[2] = (plane1->dist - DotProduct(plane1->normal, p3)) / plane1->normal[2];
    p4[2] = (plane1->dist - DotProduct(plane1->normal, p4)) / plane1->normal[2];
    //
    founddist = qfalse;
    //
    if (VectorBetweenVectors(p1, v3, v4))
    {
        dist = VectorDistance(v1, p1);
        if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
        {
            VectorMiddle(beststart, v1, beststart);
            VectorMiddle(bestend, p1, bestend);
        } //end if
        else if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v1, beststart);
            VectorCopy(p1, bestend);
        } //end if
        founddist = qtrue;
    } //end if
    if (VectorBetweenVectors(p2, v3, v4))
    {
        dist = VectorDistance(v2, p2);
        if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
        {
            VectorMiddle(beststart, v2, beststart);
            VectorMiddle(bestend, p2, bestend);
        } //end if
        else if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v2, beststart);
            VectorCopy(p2, bestend);
        } //end if
        founddist = qtrue;
    } //end else if
    if (VectorBetweenVectors(p3, v1, v2))
    {
        dist = VectorDistance(v3, p3);
        if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
        {
            VectorMiddle(beststart, p3, beststart);
            VectorMiddle(bestend, v3, bestend);
        } //end if
        else if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(p3, beststart);
            VectorCopy(v3, bestend);
        } //end if
        founddist = qtrue;
    } //end else if
    if (VectorBetweenVectors(p4, v1, v2))
    {
        dist = VectorDistance(v4, p4);
        if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
        {
            VectorMiddle(beststart, p4, beststart);
            VectorMiddle(bestend, v4, bestend);
        } //end if
        else if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(p4, beststart);
            VectorCopy(v4, bestend);
        } //end if
        founddist = qtrue;
    } //end else if
    //if no shortest distance was found the shortest distance
    //is between one of the vertexes of edge1 and one of edge2
    if (!founddist)
    {
        dist = VectorDistance(v1, v3);
        if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v1, beststart);
            VectorCopy(v3, bestend);
        } //end if
        dist = VectorDistance(v1, v4);
        if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v1, beststart);
            VectorCopy(v4, bestend);
        } //end if
        dist = VectorDistance(v2, v3);
        if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v2, beststart);
            VectorCopy(v3, bestend);
        } //end if
        dist = VectorDistance(v2, v4);
        if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v2, beststart);
            VectorCopy(v4, bestend);
        } //end if
    } //end if
    return bestdist;
} //end of the function AAS_ClosestEdgePoints*/

float AAS_ClosestEdgePoints(vec3_t v1, vec3_t v2, vec3_t v3, vec3_t v4,
                            aas_plane_t *plane1, aas_plane_t *plane2,
                            vec3_t beststart1, vec3_t bestend1,
                            vec3_t beststart2, vec3_t bestend2, float bestdist)
{
    vec3_t dir1, dir2, p1, p2, p3, p4;
    float a1, a2, b1, b2, dist, dist1, dist2;
    int founddist;

    //edge vectors
    VectorSubtract(v2, v1, dir1);
    VectorSubtract(v4, v3, dir2);
    //get the horizontal directions
    dir1[2] = 0;
    dir2[2] = 0;
    //
    // p1 = point on an edge vector of area2 closest to v1
    // p2 = point on an edge vector of area2 closest to v2
    // p3 = point on an edge vector of area1 closest to v3
    // p4 = point on an edge vector of area1 closest to v4
    //
    if (dir2[0])
    {
        a2 = dir2[1] / dir2[0];
        b2 = v3[1] - a2 * v3[0];
        //point on the edge vector of area2 closest to v1
        p1[0] = (DotProduct(v1, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
        p1[1] = a2 * p1[0] + b2;
        //point on the edge vector of area2 closest to v2
        p2[0] = (DotProduct(v2, dir2) - (a2 * dir2[0] + b2 * dir2[1])) / dir2[0];
        p2[1] = a2 * p2[0] + b2;
    } //end if
    else
    {
        //point on the edge vector of area2 closest to v1
        p1[0] = v3[0];
        p1[1] = v1[1];
        //point on the edge vector of area2 closest to v2
        p2[0] = v3[0];
        p2[1] = v2[1];
    } //end else
    //
    if (dir1[0])
    {
        //
        a1 = dir1[1] / dir1[0];
        b1 = v1[1] - a1 * v1[0];
        //point on the edge vector of area1 closest to v3
        p3[0] = (DotProduct(v3, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
        p3[1] = a1 * p3[0] + b1;
        //point on the edge vector of area1 closest to v4
        p4[0] = (DotProduct(v4, dir1) - (a1 * dir1[0] + b1 * dir1[1])) / dir1[0];
        p4[1] = a1 * p4[0] + b1;
    } //end if
    else
    {
        //point on the edge vector of area1 closest to v3
        p3[0] = v1[0];
        p3[1] = v3[1];
        //point on the edge vector of area1 closest to v4
        p4[0] = v1[0];
        p4[1] = v4[1];
    } //end else
    //start with zero z-coordinates
    p1[2] = 0;
    p2[2] = 0;
    p3[2] = 0;
    p4[2] = 0;
    //calculate the z-coordinates from the ground planes
    p1[2] = (plane2->dist - DotProduct(plane2->normal, p1)) / plane2->normal[2];
    p2[2] = (plane2->dist - DotProduct(plane2->normal, p2)) / plane2->normal[2];
    p3[2] = (plane1->dist - DotProduct(plane1->normal, p3)) / plane1->normal[2];
    p4[2] = (plane1->dist - DotProduct(plane1->normal, p4)) / plane1->normal[2];
    //
    founddist = qfalse;
    //
    if (VectorBetweenVectors(p1, v3, v4))
    {
        dist = VectorDistance(v1, p1);
        if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
        {
            dist1 = VectorDistance(beststart1, v1);
            dist2 = VectorDistance(beststart2, v1);
            if (dist1 > dist2)
            {
                if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(v1, beststart2);
            } //end if
            else
            {
                if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(v1, beststart1);
            } //end else
            dist1 = VectorDistance(bestend1, p1);
            dist2 = VectorDistance(bestend2, p1);
            if (dist1 > dist2)
            {
                if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(p1, bestend2);
            } //end if
            else
            {
                if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(p1, bestend1);
            } //end else
        } //end if
        else if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v1, beststart1);
            VectorCopy(v1, beststart2);
            VectorCopy(p1, bestend1);
            VectorCopy(p1, bestend2);
        } //end if
        founddist = qtrue;
    } //end if
    if (VectorBetweenVectors(p2, v3, v4))
    {
        dist = VectorDistance(v2, p2);
        if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
        {
            dist1 = VectorDistance(beststart1, v2);
            dist2 = VectorDistance(beststart2, v2);
            if (dist1 > dist2)
            {
                if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(v2, beststart2);
            } //end if
            else
            {
                if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(v2, beststart1);
            } //end else
            dist1 = VectorDistance(bestend1, p2);
            dist2 = VectorDistance(bestend2, p2);
            if (dist1 > dist2)
            {
                if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(p2, bestend2);
            } //end if
            else
            {
                if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(p2, bestend1);
            } //end else
        } //end if
        else if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v2, beststart1);
            VectorCopy(v2, beststart2);
            VectorCopy(p2, bestend1);
            VectorCopy(p2, bestend2);
        } //end if
        founddist = qtrue;
    } //end else if
    if (VectorBetweenVectors(p3, v1, v2))
    {
        dist = VectorDistance(v3, p3);
        if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
        {
            dist1 = VectorDistance(beststart1, p3);
            dist2 = VectorDistance(beststart2, p3);
            if (dist1 > dist2)
            {
                if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(p3, beststart2);
            } //end if
            else
            {
                if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(p3, beststart1);
            } //end else
            dist1 = VectorDistance(bestend1, v3);
            dist2 = VectorDistance(bestend2, v3);
            if (dist1 > dist2)
            {
                if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(v3, bestend2);
            } //end if
            else
            {
                if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(v3, bestend1);
            } //end else
        } //end if
        else if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(p3, beststart1);
            VectorCopy(p3, beststart2);
            VectorCopy(v3, bestend1);
            VectorCopy(v3, bestend2);
        } //end if
        founddist = qtrue;
    } //end else if
    if (VectorBetweenVectors(p4, v1, v2))
    {
        dist = VectorDistance(v4, p4);
        if (dist > bestdist - 0.5 && dist < bestdist + 0.5)
        {
            dist1 = VectorDistance(beststart1, p4);
            dist2 = VectorDistance(beststart2, p4);
            if (dist1 > dist2)
            {
                if (dist1 > VectorDistance(beststart1, beststart2)) VectorCopy(p4, beststart2);
            } //end if
            else
            {
                if (dist2 > VectorDistance(beststart1, beststart2)) VectorCopy(p4, beststart1);
            } //end else
            dist1 = VectorDistance(bestend1, v4);
            dist2 = VectorDistance(bestend2, v4);
            if (dist1 > dist2)
            {
                if (dist1 > VectorDistance(bestend1, bestend2)) VectorCopy(v4, bestend2);
            } //end if
            else
            {
                if (dist2 > VectorDistance(bestend1, bestend2)) VectorCopy(v4, bestend1);
            } //end else
        } //end if
        else if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(p4, beststart1);
            VectorCopy(p4, beststart2);
            VectorCopy(v4, bestend1);
            VectorCopy(v4, bestend2);
        } //end if
        founddist = qtrue;
    } //end else if
    //if no shortest distance was found the shortest distance
    //is between one of the vertexes of edge1 and one of edge2
    if (!founddist)
    {
        dist = VectorDistance(v1, v3);
        if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v1, beststart1);
            VectorCopy(v1, beststart2);
            VectorCopy(v3, bestend1);
            VectorCopy(v3, bestend2);
        } //end if
        dist = VectorDistance(v1, v4);
        if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v1, beststart1);
            VectorCopy(v1, beststart2);
            VectorCopy(v4, bestend1);
            VectorCopy(v4, bestend2);
        } //end if
        dist = VectorDistance(v2, v3);
        if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v2, beststart1);
            VectorCopy(v2, beststart2);
            VectorCopy(v3, bestend1);
            VectorCopy(v3, bestend2);
        } //end if
        dist = VectorDistance(v2, v4);
        if (dist < bestdist)
        {
            bestdist = dist;
            VectorCopy(v2, beststart1);
            VectorCopy(v2, beststart2);
            VectorCopy(v4, bestend1);
            VectorCopy(v4, bestend2);
        } //end if
    } //end if
    return bestdist;
} //end of the function AAS_ClosestEdgePoints
//===========================================================================
// creates possible jump reachabilities between the areas
//
// The two closest points on the ground of the areas are calculated
// One of the points will be on an edge of a ground face of area1 and
// one on an edge of a ground face of area2.
// If there is a range of closest points the point in the middle of this range
// is selected.
// Between these two points there must be one or more gaps.
// If the gaps exist a potential jump is predicted.
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_Reachability_Jump(int area1num, int area2num)
{
    int i, j, k, l, face1num, face2num, edge1num, edge2num, traveltype;
    int stopevent, areas[10], numareas;
    float phys_jumpvel, maxjumpdistance, maxjumpheight, height, bestdist, speed;
    vec_t *v1, *v2, *v3, *v4;
    vec3_t beststart, beststart2, bestend, bestend2;
    vec3_t teststart, testend, dir, velocity, cmdmove, up = {0, 0, 1}, sidewards;
    aas_area_t *area1, *area2;
    aas_face_t *face1, *face2;
    aas_edge_t *edge1, *edge2;
    aas_plane_t *plane1, *plane2, *plane;
    aas_trace_t trace;
    aas_clientmove_t move;
    aas_lreachability_t *lreach;

    if (!AAS_AreaGrounded(area1num) || !AAS_AreaGrounded(area2num)) return qfalse;
    //cannot jump from or to a crouch area
    if (AAS_AreaCrouch(area1num) || AAS_AreaCrouch(area2num)) return qfalse;
    //
    area1 = &aasworld.areas[area1num];
    area2 = &aasworld.areas[area2num];
    //
    phys_jumpvel = aassettings.phys_jumpvel;
    //maximum distance a player can jump
    maxjumpdistance = 2 * AAS_MaxJumpDistance(phys_jumpvel);
    //maximum height a player can jump with the given initial z velocity
    maxjumpheight = AAS_MaxJumpHeight(phys_jumpvel);

    //if the areas are not near anough in the x-y direction
    for (i = 0; i < 2; i++)
    {
        if (area1->mins[i] > area2->maxs[i] + maxjumpdistance) return qfalse;
        if (area1->maxs[i] < area2->mins[i] - maxjumpdistance) return qfalse;
    } //end for
    //if area2 is way to high to jump up to
    if (area2->mins[2] > area1->maxs[2] + maxjumpheight) return qfalse;
    //
    bestdist = 999999;
    //
    for (i = 0; i < area1->numfaces; i++)
    {
        face1num = aasworld.faceindex[area1->firstface + i];
        face1 = &aasworld.faces[abs(face1num)];
        //if not a ground face
        if (!(face1->faceflags & FACE_GROUND)) continue;
        //
        for (j = 0; j < area2->numfaces; j++)
        {
            face2num = aasworld.faceindex[area2->firstface + j];
            face2 = &aasworld.faces[abs(face2num)];
            //if not a ground face
            if (!(face2->faceflags & FACE_GROUND)) continue;
            //
            for (k = 0; k < face1->numedges; k++)
            {
                edge1num = abs(aasworld.edgeindex[face1->firstedge + k]);
                edge1 = &aasworld.edges[edge1num];
                for (l = 0; l < face2->numedges; l++)
                {
                    edge2num = abs(aasworld.edgeindex[face2->firstedge + l]);
                    edge2 = &aasworld.edges[edge2num];
                    //calculate the minimum distance between the two edges
                    v1 = aasworld.vertexes[edge1->v[0]];
                    v2 = aasworld.vertexes[edge1->v[1]];
                    v3 = aasworld.vertexes[edge2->v[0]];
                    v4 = aasworld.vertexes[edge2->v[1]];
                    //get the ground planes
                    plane1 = &aasworld.planes[face1->planenum];
                    plane2 = &aasworld.planes[face2->planenum];
                    //
                    bestdist = AAS_ClosestEdgePoints(v1, v2, v3, v4, plane1, plane2,
                                                        beststart, bestend,
                                                        beststart2, bestend2, bestdist);
                } //end for
            } //end for
        } //end for
    } //end for
    VectorMiddle(beststart, beststart2, beststart);
    VectorMiddle(bestend, bestend2, bestend);
    if (bestdist > 4 && bestdist < maxjumpdistance)
    {
//      Log_Write("shortest distance between %d and %d is %f\r\n", area1num, area2num, bestdist);
        // if very close and almost no height difference then the bot can walk
        if (bestdist <= 48 && fabs(beststart[2] - bestend[2]) < 8)
        {
            speed = 400;
            traveltype = TRAVEL_WALKOFFLEDGE;
        } //end if
        else if (AAS_HorizontalVelocityForJump(0, beststart, bestend, &speed))
        {
            //FIXME: why multiply with 1.2???
            speed *= 1.2f;
            traveltype = TRAVEL_WALKOFFLEDGE;
        } //end else if
        else
        {
            //get the horizontal speed for the jump, if it isn't possible to calculate this
            //speed (the jump is not possible) then there's no jump reachability created
            if (!AAS_HorizontalVelocityForJump(phys_jumpvel, beststart, bestend, &speed))
                return qfalse;
            speed *= 1.05f;
            traveltype = TRAVEL_JUMP;
            //
            //NOTE: test if the horizontal distance isn't too small
            VectorSubtract(bestend, beststart, dir);
            dir[2] = 0;
            if (VectorLength(dir) < 10)
                return qfalse;
        } //end if
        //
        VectorSubtract(bestend, beststart, dir);
        VectorNormalize(dir);
        VectorMA(beststart, 1, dir, teststart);
        //
        VectorCopy(teststart, testend);
        testend[2] -= 100;
        trace = AAS_TraceClientBBox(teststart, testend, PRESENCE_NORMAL, -1);
        //
        if (trace.startsolid)
            return qfalse;
        if (trace.fraction < 1)
        {
            plane = &aasworld.planes[trace.planenum];
            // if the bot can stand on the surface
            if (DotProduct(plane->normal, up) >= 0.7)
            {
                // if no lava or slime below
                if (!(AAS_PointContents(trace.endpos) & (CONTENTS_LAVA|CONTENTS_SLIME)))
                {
                    if (teststart[2] - trace.endpos[2] <= aassettings.phys_maxbarrier)
                        return qfalse;
                } //end if
            } //end if
        } //end if
        //
        VectorMA(bestend, -1, dir, teststart);
        //
        VectorCopy(teststart, testend);
        testend[2] -= 100;
        trace = AAS_TraceClientBBox(teststart, testend, PRESENCE_NORMAL, -1);
        //
        if (trace.startsolid)
            return qfalse;
        if (trace.fraction < 1)
        {
            plane = &aasworld.planes[trace.planenum];
            // if the bot can stand on the surface
            if (DotProduct(plane->normal, up) >= 0.7)
            {
                // if no lava or slime below
                if (!(AAS_PointContents(trace.endpos) & (CONTENTS_LAVA|CONTENTS_SLIME)))
                {
                    if (teststart[2] - trace.endpos[2] <= aassettings.phys_maxbarrier)
                        return qfalse;
                } //end if
            } //end if
        } //end if
        //
        // get command movement
        VectorClear(cmdmove);
        if ((traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMP)
            cmdmove[2] = aassettings.phys_jumpvel;
        else
            cmdmove[2] = 0;
        //
        VectorSubtract(bestend, beststart, dir);
        dir[2] = 0;
        VectorNormalize(dir);
        CrossProduct(dir, up, sidewards);
        //
        stopevent = SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE;
        if (!AAS_AreaClusterPortal(area1num) && !AAS_AreaClusterPortal(area2num))
            stopevent |= SE_TOUCHCLUSTERPORTAL;
        //
        for (i = 0; i < 3; i++)
        {
            //
            if (i == 1)
                VectorAdd(testend, sidewards, testend);
            else if (i == 2)
                VectorSubtract(bestend, sidewards, testend);
            else
                VectorCopy(bestend, testend);
            VectorSubtract(testend, beststart, dir);
            dir[2] = 0;
            VectorNormalize(dir);
            VectorScale(dir, speed, velocity);
            //
            AAS_PredictClientMovement(&move, -1, beststart, PRESENCE_NORMAL, qtrue,
                                        velocity, cmdmove, 3, 30, 0.1f,
                                        stopevent, 0, qfalse);
            // if prediction time wasn't enough to fully predict the movement
            if (move.frames >= 30)
                return qfalse;
            // don't enter slime or lava and don't fall from too high
            if (move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA))
                return qfalse;
            // never jump or fall through a cluster portal
            if (move.stopevent & SE_TOUCHCLUSTERPORTAL)
                return qfalse;
            //the end position should be in area2, also test a little bit back
            //because the predicted jump could have rushed through the area
            VectorMA(move.endpos, -64, dir, teststart);
            teststart[2] += 1;
            numareas = AAS_TraceAreas(move.endpos, teststart, areas, NULL, sizeof(areas) / sizeof(int));
            for (j = 0; j < numareas; j++)
            {
                if (areas[j] == area2num)
                    break;
            } //end for
            if (j < numareas)
                break;
        }
        if (i >= 3)
            return qfalse;
        //
#ifdef REACH_DEBUG
        //create the reachability
        Log_Write("jump reachability between %d and %d\r\n", area1num, area2num);
#endif //REACH_DEBUG
        //create a new reachability link
        lreach = AAS_AllocReachability();
        if (!lreach) return qfalse;
        lreach->areanum = area2num;
        lreach->facenum = 0;
        lreach->edgenum = 0;
        VectorCopy(beststart, lreach->start);
        VectorCopy(bestend, lreach->end);
        lreach->traveltype = traveltype;

        VectorSubtract(bestend, beststart, dir);
        height = dir[2];
        dir[2] = 0;
        if ((traveltype & TRAVELTYPE_MASK) == TRAVEL_WALKOFFLEDGE && height > VectorLength(dir))
        {
            lreach->traveltime = aassettings.rs_startwalkoffledge + height * 50 / aassettings.phys_gravity;
        }
        else
        {
            lreach->traveltime = aassettings.rs_startjump + VectorDistance(bestend, beststart) * 240 / aassettings.phys_maxwalkvelocity;
        } //end if
        //
        if (!AAS_AreaJumpPad(area2num))
        {
            if (AAS_FallDelta(beststart[2] - bestend[2]) > aassettings.phys_falldelta5)
            {
                lreach->traveltime += aassettings.rs_falldamage5;
            } //end if
            else if (AAS_FallDelta(beststart[2] - bestend[2]) > aassettings.phys_falldelta10)
            {
                lreach->traveltime += aassettings.rs_falldamage10;
            } //end if
        } //end if
        lreach->next = areareachability[area1num];
        areareachability[area1num] = lreach;
        //
        if ((traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMP)
            reach_jump++;
        else
            reach_walkoffledge++;
    } //end if
    return qfalse;
} //end of the function AAS_Reachability_Jump
//===========================================================================
// create a possible ladder reachability from area1 to area2
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_Reachability_Ladder(int area1num, int area2num)
{
    int i, j, k, l, edge1num, edge2num, sharededgenum, lowestedgenum;
    int face1num, face2num, ladderface1num, ladderface2num;
    int ladderface1vertical, ladderface2vertical, firstv;
    float face1area, face2area, bestface1area, bestface2area;
    float phys_jumpvel, maxjumpheight;
    vec3_t area1point, area2point, v1, v2, up = {0, 0, 1};
    vec3_t mid, lowestpoint, start, end, sharededgevec, dir;
    aas_area_t *area1, *area2;
    aas_face_t *face1, *face2, *ladderface1, *ladderface2;
    aas_plane_t *plane1, *plane2;
    aas_edge_t *sharededge, *edge1;
    aas_lreachability_t *lreach;
    aas_trace_t trace;

    if (!AAS_AreaLadder(area1num) || !AAS_AreaLadder(area2num)) return qfalse;
    //
    phys_jumpvel = aassettings.phys_jumpvel;
    //maximum height a player can jump with the given initial z velocity
    maxjumpheight = AAS_MaxJumpHeight(phys_jumpvel);

    area1 = &aasworld.areas[area1num];
    area2 = &aasworld.areas[area2num];
    //
    ladderface1 = NULL;
    ladderface2 = NULL;
    ladderface1num = 0; //make compiler happy
    ladderface2num = 0; //make compiler happy
    bestface1area = -9999;
    bestface2area = -9999;
    sharededgenum = 0; //make compiler happy
    lowestedgenum = 0; //make compiler happy
    //
    for (i = 0; i < area1->numfaces; i++)
    {
        face1num = aasworld.faceindex[area1->firstface + i];
        face1 = &aasworld.faces[abs(face1num)];
        //if not a ladder face
        if (!(face1->faceflags & FACE_LADDER)) continue;
        //
        for (j = 0; j < area2->numfaces; j++)
        {
            face2num = aasworld.faceindex[area2->firstface + j];
            face2 = &aasworld.faces[abs(face2num)];
            //if not a ladder face
            if (!(face2->faceflags & FACE_LADDER)) continue;
            //check if the faces share an edge
            for (k = 0; k < face1->numedges; k++)
            {
                edge1num = aasworld.edgeindex[face1->firstedge + k];
                for (l = 0; l < face2->numedges; l++)
                {
                    edge2num = aasworld.edgeindex[face2->firstedge + l];
                    if (abs(edge1num) == abs(edge2num))
                    {
                        //get the face with the largest area
                        face1area = AAS_FaceArea(face1);
                        face2area = AAS_FaceArea(face2);
                        if (face1area > bestface1area && face2area > bestface2area)
                        {
                            bestface1area = face1area;
                            bestface2area = face2area;
                            ladderface1 = face1;
                            ladderface2 = face2;
                            ladderface1num = face1num;
                            ladderface2num = face2num;
                            sharededgenum = edge1num;
                        } //end if
                        break;
                    } //end if
                } //end for
                if (l != face2->numedges) break;
            } //end for
        } //end for
    } //end for
    //
    if (ladderface1 && ladderface2)
    {
        //get the middle of the shared edge
        sharededge = &aasworld.edges[abs(sharededgenum)];
        firstv = sharededgenum < 0;
        //
        VectorCopy(aasworld.vertexes[sharededge->v[firstv]], v1);
        VectorCopy(aasworld.vertexes[sharededge->v[!firstv]], v2);
        VectorAdd(v1, v2, area1point);
        VectorScale(area1point, 0.5, area1point);
        VectorCopy(area1point, area2point);
        //
        //if the face plane in area 1 is pretty much vertical
        plane1 = &aasworld.planes[ladderface1->planenum ^ (ladderface1num < 0)];
        plane2 = &aasworld.planes[ladderface2->planenum ^ (ladderface2num < 0)];
        //
        //get the points really into the areas
        VectorSubtract(v2, v1, sharededgevec);
        CrossProduct(plane1->normal, sharededgevec, dir);
        VectorNormalize(dir);
        //NOTE: 32 because that's larger than 16 (bot bbox x,y)
        VectorMA(area1point, -32, dir, area1point);
        VectorMA(area2point, 32, dir, area2point);
        //
        ladderface1vertical = abs(DotProduct(plane1->normal, up)) < 0.1;
        ladderface2vertical = abs(DotProduct(plane2->normal, up)) < 0.1;
        //there's only reachability between vertical ladder faces
        if (!ladderface1vertical && !ladderface2vertical) return qfalse;
        //if both vertical ladder faces
        if (ladderface1vertical && ladderface2vertical
                    //and the ladder faces do not make a sharp corner
                    && DotProduct(plane1->normal, plane2->normal) > 0.7
                    //and the shared edge is not too vertical
                    && abs(DotProduct(sharededgevec, up)) < 0.7)
        {
            //create a new reachability link
            lreach = AAS_AllocReachability();
            if (!lreach) return qfalse;
            lreach->areanum = area2num;
            lreach->facenum = ladderface1num;
            lreach->edgenum = abs(sharededgenum);
            VectorCopy(area1point, lreach->start);
            //VectorCopy(area2point, lreach->end);
            VectorMA(area2point, -3, plane1->normal, lreach->end);
            lreach->traveltype = TRAVEL_LADDER;
            lreach->traveltime = 10;
            lreach->next = areareachability[area1num];
            areareachability[area1num] = lreach;
            //
            reach_ladder++;
            //create a new reachability link
            lreach = AAS_AllocReachability();
            if (!lreach) return qfalse;
            lreach->areanum = area1num;
            lreach->facenum = ladderface2num;
            lreach->edgenum = abs(sharededgenum);
            VectorCopy(area2point, lreach->start);
            //VectorCopy(area1point, lreach->end);
            VectorMA(area1point, -3, plane1->normal, lreach->end);
            lreach->traveltype = TRAVEL_LADDER;
            lreach->traveltime = 10;
            lreach->next = areareachability[area2num];
            areareachability[area2num] = lreach;
            //
            reach_ladder++;
            //
            return qtrue;
        } //end if
        //if the second ladder face is also a ground face
        //create ladder end (just ladder) reachability and
        //walk off a ladder (ledge) reachability
        if (ladderface1vertical && (ladderface2->faceflags & FACE_GROUND))
        {
            //create a new reachability link
            lreach = AAS_AllocReachability();
            if (!lreach) return qfalse;
            lreach->areanum = area2num;
            lreach->facenum = ladderface1num;
            lreach->edgenum = abs(sharededgenum);
            VectorCopy(area1point, lreach->start);
            VectorCopy(area2point, lreach->end);
            lreach->end[2] += 16;
            VectorMA(lreach->end, -15, plane1->normal, lreach->end);
            lreach->traveltype = TRAVEL_LADDER;
            lreach->traveltime = 10;
            lreach->next = areareachability[area1num];
            areareachability[area1num] = lreach;
            //
            reach_ladder++;
            //create a new reachability link
            lreach = AAS_AllocReachability();
            if (!lreach) return qfalse;
            lreach->areanum = area1num;
            lreach->facenum = ladderface2num;
            lreach->edgenum = abs(sharededgenum);
            VectorCopy(area2point, lreach->start);
            VectorCopy(area1point, lreach->end);
            lreach->traveltype = TRAVEL_WALKOFFLEDGE;
            lreach->traveltime = 10;
            lreach->next = areareachability[area2num];
            areareachability[area2num] = lreach;
            //
            reach_walkoffledge++;
            //
            return qtrue;
        } //end if
        //
        if (ladderface1vertical)
        {
            //find lowest edge of the ladder face
            lowestpoint[2] = 99999;
            for (i = 0; i < ladderface1->numedges; i++)
            {
                edge1num = abs(aasworld.edgeindex[ladderface1->firstedge + i]);
                edge1 = &aasworld.edges[edge1num];
                //
                VectorCopy(aasworld.vertexes[edge1->v[0]], v1);
                VectorCopy(aasworld.vertexes[edge1->v[1]], v2);
                //
                VectorAdd(v1, v2, mid);
                VectorScale(mid, 0.5, mid);
                //
                if (mid[2] < lowestpoint[2])
                {
                    VectorCopy(mid, lowestpoint);
                    lowestedgenum = edge1num;
                } //end if
            } //end for
            //
            plane1 = &aasworld.planes[ladderface1->planenum];
            //trace down in the middle of this edge
            VectorMA(lowestpoint, 5, plane1->normal, start);
            VectorCopy(start, end);
            start[2] += 5;
            end[2] -= 100;
            //trace without entity collision
            trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
            //
            //
#ifdef REACH_DEBUG
            if (trace.startsolid)
            {
                Log_Write("trace from area %d started in solid\r\n", area1num);
            } //end if
#endif //REACH_DEBUG
            //
            trace.endpos[2] += 1;
            area2num = AAS_PointAreaNum(trace.endpos);
            //
            area2 = &aasworld.areas[area2num];
            for (i = 0; i < area2->numfaces; i++)
            {
                face2num = aasworld.faceindex[area2->firstface + i];
                face2 = &aasworld.faces[abs(face2num)];
                //
                if (face2->faceflags & FACE_LADDER)
                {
                    plane2 = &aasworld.planes[face2->planenum];
                    if (abs(DotProduct(plane2->normal, up)) < 0.1) break;
                } //end if
            } //end for
            //if from another area without vertical ladder faces
            if (i >= area2->numfaces && area2num != area1num &&
                        //the reachabilities shouldn't exist already
                        !AAS_ReachabilityExists(area1num, area2num) &&
                        !AAS_ReachabilityExists(area2num, area1num))
            {
                //if the height is jumpable
                if (start[2] - trace.endpos[2] < maxjumpheight)
                {
                    //create a new reachability link
                    lreach = AAS_AllocReachability();
                    if (!lreach) return qfalse;
                    lreach->areanum = area2num;
                    lreach->facenum = ladderface1num;
                    lreach->edgenum = lowestedgenum;
                    VectorCopy(lowestpoint, lreach->start);
                    VectorCopy(trace.endpos, lreach->end);
                    lreach->traveltype = TRAVEL_LADDER;
                    lreach->traveltime = 10;
                    lreach->next = areareachability[area1num];
                    areareachability[area1num] = lreach;
                    //
                    reach_ladder++;
                    //create a new reachability link
                    lreach = AAS_AllocReachability();
                    if (!lreach) return qfalse;
                    lreach->areanum = area1num;
                    lreach->facenum = ladderface1num;
                    lreach->edgenum = lowestedgenum;
                    VectorCopy(trace.endpos, lreach->start);
                    //get the end point a little bit into the ladder
                    VectorMA(lowestpoint, -5, plane1->normal, lreach->end);
                    //get the end point a little higher
                    lreach->end[2] += 10;
                    lreach->traveltype = TRAVEL_JUMP;
                    lreach->traveltime = 10;
                    lreach->next = areareachability[area2num];
                    areareachability[area2num] = lreach;
                    //
                    reach_jump++;   
                    //
                    return qtrue;
#ifdef REACH_DEBUG
                    Log_Write("jump up to ladder reach between %d and %d\r\n", area2num, area1num);
#endif //REACH_DEBUG
                } //end if
#ifdef REACH_DEBUG
                else Log_Write("jump too high between area %d and %d\r\n", area2num, area1num);
#endif //REACH_DEBUG
            } //end if
            /*//if slime or lava below the ladder
            //try jump reachability from far towards the ladder
            if (aasworld.areasettings[area2num].contents & (AREACONTENTS_SLIME
                                                    | AREACONTENTS_LAVA))
            {
                for (i = 20; i <= 120; i += 20)
                {
                    //trace down in the middle of this edge
                    VectorMA(lowestpoint, i, plane1->normal, start);
                    VectorCopy(start, end);
                    start[2] += 5;
                    end[2] -= 100;
                    //trace without entity collision
                    trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
                    //
                    if (trace.startsolid) break;
                    trace.endpos[2] += 1;
                    area2num = AAS_PointAreaNum(trace.endpos);
                    if (area2num == area1num) continue;
                    //
                    if (start[2] - trace.endpos[2] > maxjumpheight) continue;
                    if (aasworld.areasettings[area2num].contents & (AREACONTENTS_SLIME
                                                | AREACONTENTS_LAVA)) continue;
                    //
                    //create a new reachability link
                    lreach = AAS_AllocReachability();
                    if (!lreach) return qfalse;
                    lreach->areanum = area1num;
                    lreach->facenum = ladderface1num;
                    lreach->edgenum = lowestedgenum;
                    VectorCopy(trace.endpos, lreach->start);
                    VectorCopy(lowestpoint, lreach->end);
                    lreach->end[2] += 5;
                    lreach->traveltype = TRAVEL_JUMP;
                    lreach->traveltime = 10;
                    lreach->next = areareachability[area2num];
                    areareachability[area2num] = lreach;
                    //
                    reach_jump++;
                    //
                    Log_Write("jump far to ladder reach between %d and %d\r\n", area2num, area1num);
                    //
                    break;
                } //end for
            } //end if*/
        } //end if
    } //end if
    return qfalse;
} //end of the function AAS_Reachability_Ladder
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
int AAS_TravelFlagsForTeam(int ent)
{
    int notteam;

    if (!AAS_IntForBSPEpairKey(ent, "bot_notteam", &notteam))
        return 0;
    if (notteam == 1)
        return TRAVELFLAG_NOTTEAM1;
    if (notteam == 2)
        return TRAVELFLAG_NOTTEAM2;
    return 0;
} //end of the function AAS_TravelFlagsForTeam
//===========================================================================
// create possible teleporter reachabilities
// this is very game dependent.... :(
//
// classname = trigger_multiple or trigger_teleport
// target = "t1"
//
// classname = target_teleporter
// targetname = "t1"
// target = "t2"
//
// classname = misc_teleporter_dest
// targetname = "t2"
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void AAS_Reachability_Teleport(void)
{
    int area1num, area2num;
    char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY];
    char classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
    int ent, dest;
    float angle;
    vec3_t origin, destorigin, mins, maxs, end, angles;
    vec3_t mid, velocity, cmdmove;
    aas_lreachability_t *lreach;
    aas_clientmove_t move;
    aas_trace_t trace;
    aas_link_t *areas, *link;

    for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
    {
        if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
        if (!strcmp(classname, "trigger_multiple"))
        {
            AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
//#ifdef REACH_DEBUG
            botimport.Print(PRT_MESSAGE, "trigger_multiple model = \"%s\"\n", model);
//#endif REACH_DEBUG
            VectorClear(angles);
            AAS_BSPModelMinsMaxsOrigin(atoi(model+1), angles, mins, maxs, origin);
            //
            if (!AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY))
            {
                botimport.Print(PRT_ERROR, "trigger_multiple at %1.0f %1.0f %1.0f without target\n",
                                    origin[0], origin[1], origin[2]);
                continue;
            } //end if
            for (dest = AAS_NextBSPEntity(0); dest; dest = AAS_NextBSPEntity(dest))
            {
                if (!AAS_ValueForBSPEpairKey(dest, "classname", classname, MAX_EPAIRKEY)) continue;
                if (!strcmp(classname, "target_teleporter"))
                {
                    if (!AAS_ValueForBSPEpairKey(dest, "targetname", targetname, MAX_EPAIRKEY)) continue;
                    if (!strcmp(targetname, target))
                    {
                        break;
                    } //end if
                } //end if
            } //end for
            if (!dest)
            {
                continue;
            } //end if
            if (!AAS_ValueForBSPEpairKey(dest, "target", target, MAX_EPAIRKEY))
            {
                botimport.Print(PRT_ERROR, "target_teleporter without target\n");
                continue;
            } //end if
        } //end else
        else if (!strcmp(classname, "trigger_teleport"))
        {
            AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
//#ifdef REACH_DEBUG
            botimport.Print(PRT_MESSAGE, "trigger_teleport model = \"%s\"\n", model);
//#endif REACH_DEBUG
            VectorClear(angles);
            AAS_BSPModelMinsMaxsOrigin(atoi(model+1), angles, mins, maxs, origin);
            //
            if (!AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY))
            {
                botimport.Print(PRT_ERROR, "trigger_teleport at %1.0f %1.0f %1.0f without target\n",
                                    origin[0], origin[1], origin[2]);
                continue;
            } //end if
        } //end if
        else
        {
            continue;
        } //end else
        //
        for (dest = AAS_NextBSPEntity(0); dest; dest = AAS_NextBSPEntity(dest))
        {
            //classname should be misc_teleporter_dest
            //but I've also seen target_position and actually any
            //entity could be used... burp
            if (AAS_ValueForBSPEpairKey(dest, "targetname", targetname, MAX_EPAIRKEY))
            {
                if (!strcmp(targetname, target))
                {
                    break;
                } //end if
            } //end if
        } //end for
        if (!dest)
        {
            botimport.Print(PRT_ERROR, "teleporter without misc_teleporter_dest (%s)\n", target);
            continue;
        } //end if
        if (!AAS_VectorForBSPEpairKey(dest, "origin", destorigin))
        {
            botimport.Print(PRT_ERROR, "teleporter destination (%s) without origin\n", target);
            continue;
        } //end if
        //
        area2num = AAS_PointAreaNum(destorigin);
        //if not teleported into a teleporter or into a jumppad
        if (!AAS_AreaTeleporter(area2num) && !AAS_AreaJumpPad(area2num))
        {
            VectorCopy(destorigin, end);
            end[2] -= 64;
            trace = AAS_TraceClientBBox(destorigin, end, PRESENCE_CROUCH, -1);
            if (trace.startsolid)
            {
                botimport.Print(PRT_ERROR, "teleporter destination (%s) in solid\n", target);
                continue;
            } //end if
            area2num = AAS_PointAreaNum(trace.endpos);
            //
            /*
            if (!AAS_AreaTeleporter(area2num) &&
                !AAS_AreaJumpPad(area2num) &&
                !AAS_AreaGrounded(area2num))
            {
                VectorCopy(trace.endpos, destorigin);
            }
            else*/
            {
                //predict where you'll end up
                AAS_FloatForBSPEpairKey(dest, "angle", &angle);
                if (angle)
                {
                    VectorSet(angles, 0, angle, 0);
                    AngleVectors(angles, velocity, NULL, NULL);
                    VectorScale(velocity, 400, velocity);
                } //end if
                else
                {
                    VectorClear(velocity);
                } //end else
                VectorClear(cmdmove);
                AAS_PredictClientMovement(&move, -1, destorigin, PRESENCE_NORMAL, qfalse,
                                        velocity, cmdmove, 0, 30, 0.1f,
                                        SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME|
                                        SE_ENTERLAVA|SE_HITGROUNDDAMAGE|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER, 0, qfalse); //qtrue);
                area2num = AAS_PointAreaNum(move.endpos);
                if (move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA))
                {
                    botimport.Print(PRT_WARNING, "teleported into slime or lava at dest %s\n", target);
                } //end if
                VectorCopy(move.endpos, destorigin);
            } //end else
        } //end if
        //
        //botimport.Print(PRT_MESSAGE, "teleporter brush origin at %f %f %f\n", origin[0], origin[1], origin[2]);
        //botimport.Print(PRT_MESSAGE, "teleporter brush mins = %f %f %f\n", mins[0], mins[1], mins[2]);
        //botimport.Print(PRT_MESSAGE, "teleporter brush maxs = %f %f %f\n", maxs[0], maxs[1], maxs[2]);
        VectorAdd(origin, mins, mins);
        VectorAdd(origin, maxs, maxs);
        //
        VectorAdd(mins, maxs, mid);
        VectorScale(mid, 0.5, mid);
        //link an invalid (-1) entity
        areas = AAS_LinkEntityClientBBox(mins, maxs, -1, PRESENCE_CROUCH);
        if (!areas) botimport.Print(PRT_MESSAGE, "trigger_multiple not in any area\n");
        //
        for (link = areas; link; link = link->next_area)
        {
            //if (!AAS_AreaGrounded(link->areanum)) continue;
            if (!AAS_AreaTeleporter(link->areanum)) continue;
            //
            area1num = link->areanum;
            //create a new reachability link
            lreach = AAS_AllocReachability();
            if (!lreach) break;
            lreach->areanum = area2num;
            lreach->facenum = 0;
            lreach->edgenum = 0;
            VectorCopy(mid, lreach->start);
            VectorCopy(destorigin, lreach->end);
            lreach->traveltype = TRAVEL_TELEPORT;
            lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
            lreach->traveltime = aassettings.rs_teleport;
            lreach->next = areareachability[area1num];
            areareachability[area1num] = lreach;
            //
            reach_teleport++;
        } //end for
        //unlink the invalid entity
        AAS_UnlinkFromAreas(areas);
    } //end for
} //end of the function AAS_Reachability_Teleport
//===========================================================================
// create possible elevator (func_plat) reachabilities
// this is very game dependent.... :(
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void AAS_Reachability_Elevator(void)
{
    int area1num, area2num, modelnum, i, j, k, l, n, p;
    float lip, height, speed;
    char model[MAX_EPAIRKEY], classname[MAX_EPAIRKEY];
    int ent;
    vec3_t mins, maxs, origin, angles = {0, 0, 0};
    vec3_t pos1, pos2, mids, platbottom, plattop;
    vec3_t bottomorg, toporg, start, end, dir;
    vec_t xvals[8], yvals[8], xvals_top[8], yvals_top[8];
    aas_lreachability_t *lreach;
    aas_trace_t trace;

#ifdef REACH_DEBUG
    Log_Write("AAS_Reachability_Elevator\r\n");
#endif //REACH_DEBUG
    for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
    {
        if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
        if (!strcmp(classname, "func_plat"))
        {
#ifdef REACH_DEBUG
            Log_Write("found func plat\r\n");
#endif //REACH_DEBUG
            if (!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY))
            {
                botimport.Print(PRT_ERROR, "func_plat without model\n");
                continue;
            } //end if
            //get the model number, and skip the leading *
            modelnum = atoi(model+1);
            if (modelnum <= 0)
            {
                botimport.Print(PRT_ERROR, "func_plat with invalid model number\n");
                continue;
            } //end if
            //get the mins, maxs and origin of the model
            //NOTE: the origin is usually (0,0,0) and the mins and maxs
            //      are the absolute mins and maxs
            AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin);
            //
            AAS_VectorForBSPEpairKey(ent, "origin", origin);
            //pos1 is the top position, pos2 is the bottom
            VectorCopy(origin, pos1);
            VectorCopy(origin, pos2);
            //get the lip of the plat
            AAS_FloatForBSPEpairKey(ent, "lip", &lip);
            if (!lip) lip = 8;
            //get the movement height of the plat
            AAS_FloatForBSPEpairKey(ent, "height", &height);
            if (!height) height = (maxs[2] - mins[2]) - lip;
            //get the speed of the plat
            AAS_FloatForBSPEpairKey(ent, "speed", &speed);
            if (!speed) speed = 200;
            //get bottom position below pos1
            pos2[2] -= height;
            //
            //get a point just above the plat in the bottom position
            VectorAdd(mins, maxs, mids);
            VectorMA(pos2, 0.5, mids, platbottom);
            platbottom[2] = maxs[2] - (pos1[2] - pos2[2]) + 2;
            //get a point just above the plat in the top position
            VectorAdd(mins, maxs, mids);
            VectorMA(pos2, 0.5, mids, plattop);
            plattop[2] = maxs[2] + 2;
            //
            /*if (!area1num)
            {
                Log_Write("no grounded area near plat bottom\r\n");
                continue;
            } //end if*/
            //get the mins and maxs a little larger
            for (i = 0; i < 3; i++)
            {
                mins[i] -= 1;
                maxs[i] += 1;
            } //end for
            //
            //botimport.Print(PRT_MESSAGE, "platbottom[2] = %1.1f plattop[2] = %1.1f\n", platbottom[2], plattop[2]);
            //
            VectorAdd(mins, maxs, mids);
            VectorScale(mids, 0.5, mids);
            //
            xvals[0] = mins[0]; xvals[1] = mids[0]; xvals[2] = maxs[0]; xvals[3] = mids[0];
            yvals[0] = mids[1]; yvals[1] = maxs[1]; yvals[2] = mids[1]; yvals[3] = mins[1];
            //
            xvals[4] = mins[0]; xvals[5] = maxs[0]; xvals[6] = maxs[0]; xvals[7] = mins[0];
            yvals[4] = maxs[1]; yvals[5] = maxs[1]; yvals[6] = mins[1]; yvals[7] = mins[1];
            //find adjacent areas around the bottom of the plat
            for (i = 0; i < 9; i++)
            {
                if (i < 8) //check at the sides of the plat
                {
                    bottomorg[0] = origin[0] + xvals[i];
                    bottomorg[1] = origin[1] + yvals[i];
                    bottomorg[2] = platbottom[2] + 16;
                    //get a grounded or swim area near the plat in the bottom position
                    area1num = AAS_PointAreaNum(bottomorg);
                    for (k = 0; k < 16; k++)
                    {
                        if (area1num)
                        {
                            if (AAS_AreaGrounded(area1num) || AAS_AreaSwim(area1num)) break;
                        } //end if
                        bottomorg[2] += 4;
                        area1num = AAS_PointAreaNum(bottomorg);
                    } //end if
                    //if in solid
                    if (k >= 16)
                    {
                        continue;
                    } //end if
                } //end if
                else //at the middle of the plat
                {
                    VectorCopy(plattop, bottomorg);
                    bottomorg[2] += 24;
                    area1num = AAS_PointAreaNum(bottomorg);
                    if (!area1num) continue;
                    VectorCopy(platbottom, bottomorg);
                    bottomorg[2] += 24;
                } //end else
                //look at adjacent areas around the top of the plat
                //make larger steps to outside the plat everytime
                for (n = 0; n < 3; n++)
                {
                    for (k = 0; k < 3; k++)
                    {
                        mins[k] -= 4;
                        maxs[k] += 4;
                    } //end for
                    xvals_top[0] = mins[0]; xvals_top[1] = mids[0]; xvals_top[2] = maxs[0]; xvals_top[3] = mids[0];
                    yvals_top[0] = mids[1]; yvals_top[1] = maxs[1]; yvals_top[2] = mids[1]; yvals_top[3] = mins[1];
                    //
                    xvals_top[4] = mins[0]; xvals_top[5] = maxs[0]; xvals_top[6] = maxs[0]; xvals_top[7] = mins[0];
                    yvals_top[4] = maxs[1]; yvals_top[5] = maxs[1]; yvals_top[6] = mins[1]; yvals_top[7] = mins[1];
                    //
                    for (j = 0; j < 8; j++)
                    {
                        toporg[0] = origin[0] + xvals_top[j];
                        toporg[1] = origin[1] + yvals_top[j];
                        toporg[2] = plattop[2] + 16;
                        //get a grounded or swim area near the plat in the top position
                        area2num = AAS_PointAreaNum(toporg);
                        for (l = 0; l < 16; l++)
                        {
                            if (area2num)
                            {
                                if (AAS_AreaGrounded(area2num) || AAS_AreaSwim(area2num))
                                {
                                    VectorCopy(plattop, start);
                                    start[2] += 32;
                                    VectorCopy(toporg, end);
                                    end[2] += 1;
                                    trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
                                    if (trace.fraction >= 1) break;
                                } //end if
                            } //end if
                            toporg[2] += 4;
                            area2num = AAS_PointAreaNum(toporg);
                        } //end if
                        //if in solid
                        if (l >= 16) continue;
                        //never create a reachability in the same area
                        if (area2num == area1num) continue;
                        //if the area isn't grounded
                        if (!AAS_AreaGrounded(area2num)) continue;
                        //if there already exists reachability between the areas
                        if (AAS_ReachabilityExists(area1num, area2num)) continue;
                        //if the reachability start is within the elevator bounding box
                        VectorSubtract(bottomorg, platbottom, dir);
                        VectorNormalize(dir);
                        dir[0] = bottomorg[0] + 24 * dir[0];
                        dir[1] = bottomorg[1] + 24 * dir[1];
                        dir[2] = bottomorg[2];
                        //
                        for (p = 0; p < 3; p++)
                            if (dir[p] < origin[p] + mins[p] || dir[p] > origin[p] + maxs[p]) break;
                        if (p >= 3) continue;
                        //create a new reachability link
                        lreach = AAS_AllocReachability();
                        if (!lreach) continue;
                        lreach->areanum = area2num;
                        //the facenum is the model number
                        lreach->facenum = modelnum;
                        //the edgenum is the height
                        lreach->edgenum = (int) height;
                        //
                        VectorCopy(dir, lreach->start);
                        VectorCopy(toporg, lreach->end);
                        lreach->traveltype = TRAVEL_ELEVATOR;
                        lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
                        lreach->traveltime = aassettings.rs_startelevator + height * 100 / speed;
                        lreach->next = areareachability[area1num];
                        areareachability[area1num] = lreach;
                        //don't go any further to the outside
                        n = 9999;
                        //
#ifdef REACH_DEBUG
                        Log_Write("elevator reach from %d to %d\r\n", area1num, area2num);
#endif //REACH_DEBUG
                        //
                        reach_elevator++;
                    } //end for
                } //end for
            } //end for
        } //end if
    } //end for
} //end of the function AAS_Reachability_Elevator
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
aas_lreachability_t *AAS_FindFaceReachabilities(vec3_t *facepoints, int numpoints, aas_plane_t *plane, int towardsface)
{
    int i, j, k, l;
    int facenum, edgenum, bestfacenum;
    float *v1, *v2, *v3, *v4;
    float bestdist, speed, hordist, dist;
    vec3_t beststart, beststart2, bestend, bestend2, tmp, hordir, testpoint;
    aas_lreachability_t *lreach, *lreachabilities;
    aas_area_t *area;
    aas_face_t *face;
    aas_edge_t *edge;
    aas_plane_t *faceplane, *bestfaceplane;

    //
    lreachabilities = NULL;
    bestfacenum = 0;
    bestfaceplane = NULL;
    //
    for (i = 1; i < aasworld.numareas; i++)
    {
        area = &aasworld.areas[i];
        // get the shortest distance between one of the func_bob start edges and
        // one of the face edges of area1
        bestdist = 999999;
        for (j = 0; j < area->numfaces; j++)
        {
            facenum = aasworld.faceindex[area->firstface + j];
            face = &aasworld.faces[abs(facenum)];
            //if not a ground face
            if (!(face->faceflags & FACE_GROUND)) continue;
            //get the ground planes
            faceplane = &aasworld.planes[face->planenum];
            //
            for (k = 0; k < face->numedges; k++)
            {
                edgenum = abs(aasworld.edgeindex[face->firstedge + k]);
                edge = &aasworld.edges[edgenum];
                //calculate the minimum distance between the two edges
                v1 = aasworld.vertexes[edge->v[0]];
                v2 = aasworld.vertexes[edge->v[1]];
                //
                for (l = 0; l < numpoints; l++)
                {
                    v3 = facepoints[l];
                    v4 = facepoints[(l+1) % numpoints];
                    dist = AAS_ClosestEdgePoints(v1, v2, v3, v4, faceplane, plane,
                                                    beststart, bestend,
                                                    beststart2, bestend2, bestdist);
                    if (dist < bestdist)
                    {
                        bestfacenum = facenum;
                        bestfaceplane = faceplane;
                        bestdist = dist;
                    } //end if
                } //end for
            } //end for
        } //end for
        //
        if (bestdist > 192) continue;
        //
        VectorMiddle(beststart, beststart2, beststart);
        VectorMiddle(bestend, bestend2, bestend);
        //
        if (!towardsface)
        {
            VectorCopy(beststart, tmp);
            VectorCopy(bestend, beststart);
            VectorCopy(tmp, bestend);
        } //end if
        //
        VectorSubtract(bestend, beststart, hordir);
        hordir[2] = 0;
        hordist = VectorLength(hordir);
        //
        if (hordist > 2 * AAS_MaxJumpDistance(aassettings.phys_jumpvel)) continue;
        //the end point should not be significantly higher than the start point
        if (bestend[2] - 32 > beststart[2]) continue;
        //don't fall down too far
        if (bestend[2] < beststart[2] - 128) continue;
        //the distance should not be too far
        if (hordist > 32)
        {
            //check for walk off ledge
            if (!AAS_HorizontalVelocityForJump(0, beststart, bestend, &speed)) continue;
        } //end if
        //
        beststart[2] += 1;
        bestend[2] += 1;
        //
        if (towardsface) VectorCopy(bestend, testpoint);
        else VectorCopy(beststart, testpoint);
        testpoint[2] = 0;
        testpoint[2] = (bestfaceplane->dist - DotProduct(bestfaceplane->normal, testpoint)) / bestfaceplane->normal[2];
        //
        if (!AAS_PointInsideFace(bestfacenum, testpoint, 0.1f))
        {
            //if the faces are not overlapping then only go down
            if (bestend[2] - 16 > beststart[2]) continue;
        } //end if
        lreach = AAS_AllocReachability();
        if (!lreach) return lreachabilities;
        lreach->areanum = i;
        lreach->facenum = 0;
        lreach->edgenum = 0;
        VectorCopy(beststart, lreach->start);
        VectorCopy(bestend, lreach->end);
        lreach->traveltype = 0;
        lreach->traveltime = 0;
        lreach->next = lreachabilities;
        lreachabilities = lreach;
#ifndef BSPC
        if (towardsface) AAS_PermanentLine(lreach->start, lreach->end, 1);
        else AAS_PermanentLine(lreach->start, lreach->end, 2);
#endif
    } //end for
    return lreachabilities;
} //end of the function AAS_FindFaceReachabilities
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void AAS_Reachability_FuncBobbing(void)
{
    int ent, spawnflags, modelnum, axis;
    int i, numareas, areas[10];
    char classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
    vec3_t origin, move_end, move_start, move_start_top, move_end_top;
    vec3_t mins, maxs, angles = {0, 0, 0};
    vec3_t start_edgeverts[4], end_edgeverts[4], mid;
    vec3_t org, start, end, dir, points[10];
    float height;
    aas_plane_t start_plane, end_plane;
    aas_lreachability_t *startreach, *endreach, *nextstartreach, *nextendreach, *lreach;
    aas_lreachability_t *firststartreach, *firstendreach;

    for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
    {
        if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
        if (strcmp(classname, "func_bobbing")) continue;
        AAS_FloatForBSPEpairKey(ent, "height", &height);
        if (!height) height = 32;
        //
        if (!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY))
        {
            botimport.Print(PRT_ERROR, "func_bobbing without model\n");
            continue;
        } //end if
        //get the model number, and skip the leading *
        modelnum = atoi(model+1);
        if (modelnum <= 0)
        {
            botimport.Print(PRT_ERROR, "func_bobbing with invalid model number\n");
            continue;
        } //end if
        //if the entity has an origin set then use it
        if (!AAS_VectorForBSPEpairKey(ent, "origin", origin))
            VectorSet(origin, 0, 0, 0);
        //
        AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, NULL);
        //
        VectorAdd(mins, origin, mins);
        VectorAdd(maxs, origin, maxs);
        //
        VectorAdd(mins, maxs, mid);
        VectorScale(mid, 0.5, mid);
        VectorCopy(mid, origin);
        //
        VectorCopy(origin, move_end);
        VectorCopy(origin, move_start);
        //
        AAS_IntForBSPEpairKey(ent, "spawnflags", &spawnflags);
        // set the axis of bobbing
        if (spawnflags & 1) axis = 0;
        else if (spawnflags & 2) axis = 1;
        else axis = 2;
        //
        move_start[axis] -= height;
        move_end[axis] += height;
        //
        Log_Write("funcbob model %d, start = {%1.1f, %1.1f, %1.1f} end = {%1.1f, %1.1f, %1.1f}\n",
                    modelnum, move_start[0], move_start[1], move_start[2], move_end[0], move_end[1], move_end[2]);
        //
#ifndef BSPC
        /*
        AAS_DrawPermanentCross(move_start, 4, 1);
        AAS_DrawPermanentCross(move_end, 4, 2);
        */
#endif
        //
        for (i = 0; i < 4; i++)
        {
            VectorCopy(move_start, start_edgeverts[i]);
            start_edgeverts[i][2] += maxs[2] - mid[2]; //+ bbox maxs z
            start_edgeverts[i][2] += 24;    //+ player origin to ground dist
        } //end for
        start_edgeverts[0][0] += maxs[0] - mid[0];
        start_edgeverts[0][1] += maxs[1] - mid[1];
        start_edgeverts[1][0] += maxs[0] - mid[0];
        start_edgeverts[1][1] += mins[1] - mid[1];
        start_edgeverts[2][0] += mins[0] - mid[0];
        start_edgeverts[2][1] += mins[1] - mid[1];
        start_edgeverts[3][0] += mins[0] - mid[0];
        start_edgeverts[3][1] += maxs[1] - mid[1];
        //
        start_plane.dist = start_edgeverts[0][2];
        VectorSet(start_plane.normal, 0, 0, 1);
        //
        for (i = 0; i < 4; i++)
        {
            VectorCopy(move_end, end_edgeverts[i]);
            end_edgeverts[i][2] += maxs[2] - mid[2]; //+ bbox maxs z
            end_edgeverts[i][2] += 24;  //+ player origin to ground dist
        } //end for
        end_edgeverts[0][0] += maxs[0] - mid[0];
        end_edgeverts[0][1] += maxs[1] - mid[1];
        end_edgeverts[1][0] += maxs[0] - mid[0];
        end_edgeverts[1][1] += mins[1] - mid[1];
        end_edgeverts[2][0] += mins[0] - mid[0];
        end_edgeverts[2][1] += mins[1] - mid[1];
        end_edgeverts[3][0] += mins[0] - mid[0];
        end_edgeverts[3][1] += maxs[1] - mid[1];
        //
        end_plane.dist = end_edgeverts[0][2];
        VectorSet(end_plane.normal, 0, 0, 1);
        //
#ifndef BSPC
#if 0
        for (i = 0; i < 4; i++)
        {
            AAS_PermanentLine(start_edgeverts[i], start_edgeverts[(i+1)%4], 1);
            AAS_PermanentLine(end_edgeverts[i], end_edgeverts[(i+1)%4], 1);
        } //end for
#endif
#endif
        VectorCopy(move_start, move_start_top);
        move_start_top[2] += maxs[2] - mid[2] + 24; //+ bbox maxs z
        VectorCopy(move_end, move_end_top);
        move_end_top[2] += maxs[2] - mid[2] + 24; //+ bbox maxs z
        //
        if (!AAS_PointAreaNum(move_start_top)) continue;
        if (!AAS_PointAreaNum(move_end_top)) continue;
        //
        for (i = 0; i < 2; i++)
        {
            firststartreach = firstendreach = NULL;
            //
            if (i == 0)
            {
                firststartreach = AAS_FindFaceReachabilities(start_edgeverts, 4, &start_plane, qtrue);
                firstendreach = AAS_FindFaceReachabilities(end_edgeverts, 4, &end_plane, qfalse);
            } //end if
            else
            {
                firststartreach = AAS_FindFaceReachabilities(end_edgeverts, 4, &end_plane, qtrue);
                firstendreach = AAS_FindFaceReachabilities(start_edgeverts, 4, &start_plane, qfalse);
            } //end else
            //
            //create reachabilities from start to end
            for (startreach = firststartreach; startreach; startreach = nextstartreach)
            {
                nextstartreach = startreach->next;
                //
                //trace = AAS_TraceClientBBox(startreach->start, move_start_top, PRESENCE_NORMAL, -1);
                //if (trace.fraction < 1) continue;
                //
                for (endreach = firstendreach; endreach; endreach = nextendreach)
                {
                    nextendreach = endreach->next;
                    //
                    //trace = AAS_TraceClientBBox(endreach->end, move_end_top, PRESENCE_NORMAL, -1);
                    //if (trace.fraction < 1) continue;
                    //
                    Log_Write("funcbob reach from area %d to %d\n", startreach->areanum, endreach->areanum);
                    //
                    //
                    if (i == 0) VectorCopy(move_start_top, org);
                    else VectorCopy(move_end_top, org);
                    VectorSubtract(startreach->start, org, dir);
                    dir[2] = 0;
                    VectorNormalize(dir);
                    VectorCopy(startreach->start, start);
                    VectorMA(startreach->start, 1, dir, start);
                    start[2] += 1;
                    VectorMA(startreach->start, 16, dir, end);
                    end[2] += 1;
                    //
                    numareas = AAS_TraceAreas(start, end, areas, points, 10);
                    if (numareas <= 0) continue;
                    if (numareas > 1) VectorCopy(points[1], startreach->start);
                    else VectorCopy(end, startreach->start);
                    //
                    if (!AAS_PointAreaNum(startreach->start)) continue;
                    if (!AAS_PointAreaNum(endreach->end)) continue;
                    //
                    lreach = AAS_AllocReachability();
                    lreach->areanum = endreach->areanum;
                    if (i == 0) lreach->edgenum = ((int)move_start[axis] << 16) | ((int) move_end[axis] & 0x0000ffff);
                    else lreach->edgenum = ((int)move_end[axis] << 16) | ((int) move_start[axis] & 0x0000ffff);
                    lreach->facenum = (spawnflags << 16) | modelnum;
                    VectorCopy(startreach->start, lreach->start);
                    VectorCopy(endreach->end, lreach->end);
#ifndef BSPC
//                  AAS_DrawArrow(lreach->start, lreach->end, LINECOLOR_BLUE, LINECOLOR_YELLOW);
//                  AAS_PermanentLine(lreach->start, lreach->end, 1);
#endif
                    lreach->traveltype = TRAVEL_FUNCBOB;
                    lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
                    lreach->traveltime = aassettings.rs_funcbob;
                    reach_funcbob++;
                    lreach->next = areareachability[startreach->areanum];
                    areareachability[startreach->areanum] = lreach;
                    //
                } //end for
            } //end for
            for (startreach = firststartreach; startreach; startreach = nextstartreach)
            {
                nextstartreach = startreach->next;
                AAS_FreeReachability(startreach);
            } //end for
            for (endreach = firstendreach; endreach; endreach = nextendreach)
            {
                nextendreach = endreach->next;
                AAS_FreeReachability(endreach);
            } //end for
            //only go up with func_bobbing entities that go up and down
            if (!(spawnflags & 1) && !(spawnflags & 2)) break;
        } //end for
    } //end for
} //end of the function AAS_Reachability_FuncBobbing
//===========================================================================
//
// Parameter:           -
// Returns:             -
// Changes Globals:     -
//===========================================================================
void AAS_Reachability_JumpPad(void)
{
    int face2num, i, ret, area2num, visualize, ent, bot_visualizejumppads;
    //int modelnum, ent2;
    //float dist, time, height, gravity, forward;
    float speed, zvel, hordist;
    aas_face_t *face2;
    aas_area_t *area2;
    aas_lreachability_t *lreach;
    vec3_t areastart, facecenter, dir, cmdmove;
    vec3_t velocity, absmins, absmaxs;
    //vec3_t origin, ent2origin, angles, teststart;
    aas_clientmove_t move;
    //aas_trace_t trace;
    aas_link_t *areas, *link;
    //char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
    char classname[MAX_EPAIRKEY];

#ifdef BSPC
    bot_visualizejumppads = 0;
#else
    bot_visualizejumppads = LibVarValue("bot_visualizejumppads", "0");
#endif
    for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
    {
        if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
        if (strcmp(classname, "trigger_push")) continue;
        //
        if (!AAS_GetJumpPadInfo(ent, areastart, absmins, absmaxs, velocity)) continue;
        /*
        //
        AAS_FloatForBSPEpairKey(ent, "speed", &speed);
        if (!speed) speed = 1000;
//      AAS_VectorForBSPEpairKey(ent, "angles", angles);
//      AAS_SetMovedir(angles, velocity);
//      VectorScale(velocity, speed, velocity);
        VectorClear(angles);
        //get the mins, maxs and origin of the model
        AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY);
        if (model[0]) modelnum = atoi(model+1);
        else modelnum = 0;
        AAS_BSPModelMinsMaxsOrigin(modelnum, angles, absmins, absmaxs, origin);
        VectorAdd(origin, absmins, absmins);
        VectorAdd(origin, absmaxs, absmaxs);
        //
#ifdef REACH_DEBUG
        botimport.Print(PRT_MESSAGE, "absmins = %f %f %f\n", absmins[0], absmins[1], absmins[2]);
        botimport.Print(PRT_MESSAGE, "absmaxs = %f %f %f\n", absmaxs[0], absmaxs[1], absmaxs[2]);
#endif REACH_DEBUG
        VectorAdd(absmins, absmaxs, origin);
        VectorScale (origin, 0.5, origin);

        //get the start areas
        VectorCopy(origin, teststart);
        teststart[2] += 64;
        trace = AAS_TraceClientBBox(teststart, origin, PRESENCE_CROUCH, -1);
        if (trace.startsolid)
        {
            botimport.Print(PRT_MESSAGE, "trigger_push start solid\n");
            VectorCopy(origin, areastart);
        } //end if
        else
        {
            VectorCopy(trace.endpos, areastart);
        } //end else
        areastart[2] += 0.125;
        //
        //AAS_DrawPermanentCross(origin, 4, 4);
        //get the target entity
        AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY);
        for (ent2 = AAS_NextBSPEntity(0); ent2; ent2 = AAS_NextBSPEntity(ent2))
        {
            if (!AAS_ValueForBSPEpairKey(ent2, "targetname", targetname, MAX_EPAIRKEY)) continue;
            if (!strcmp(targetname, target)) break;
        } //end for
        if (!ent2)
        {
            botimport.Print(PRT_MESSAGE, "trigger_push without target entity %s\n", target);
            continue;
        } //end if
        AAS_VectorForBSPEpairKey(ent2, "origin", ent2origin);
        //
        height = ent2origin[2] - origin[2];
        gravity = aassettings.sv_gravity;
        time = sqrt( height / ( 0.5 * gravity ) );
        if (!time)
        {
            botimport.Print(PRT_MESSAGE, "trigger_push without time\n");
            continue;
        } //end if
        // set s.origin2 to the push velocity
        VectorSubtract ( ent2origin, origin, velocity);
        dist = VectorNormalize( velocity);
        forward = dist / time;
        //FIXME: why multiply by 1.1
        forward *= 1.1;
        VectorScale(velocity, forward, velocity);
        velocity[2] = time * gravity;
        */
        //get the areas the jump pad brush is in
        areas = AAS_LinkEntityClientBBox(absmins, absmaxs, -1, PRESENCE_CROUCH);
        /*
        for (link = areas; link; link = link->next_area)
        {
            if (link->areanum == 563)
            {
                ret = qfalse;
            }
        }
        */
        for (link = areas; link; link = link->next_area)
        {
            if (AAS_AreaJumpPad(link->areanum)) break;
        } //end for
        if (!link)
        {
            botimport.Print(PRT_MESSAGE, "trigger_push not in any jump pad area\n");
            AAS_UnlinkFromAreas(areas);
            continue;
        } //end if
        //
        botimport.Print(PRT_MESSAGE, "found a trigger_push with velocity %f %f %f\n", velocity[0], velocity[1], velocity[2]);
        //if there is a horizontal velocity check for a reachability without air control
        if (velocity[0] || velocity[1])
        {
            VectorSet(cmdmove, 0, 0, 0);
            //VectorCopy(velocity, cmdmove);
            //cmdmove[2] = 0;
            Com_Memset(&move, 0, sizeof(aas_clientmove_t));
            area2num = 0;
            for (i = 0; i < 20; i++)
            {
                AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qfalse,
                                        velocity, cmdmove, 0, 30, 0.1f,
                                        SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME|
                                        SE_ENTERLAVA|SE_HITGROUNDDAMAGE|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER, 0, bot_visualizejumppads);
                area2num = move.endarea;
                for (link = areas; link; link = link->next_area)
                {
                    if (!AAS_AreaJumpPad(link->areanum)) continue;
                    if (link->areanum == area2num) break;
                } //end if
                if (!link) break;
                VectorCopy(move.endpos, areastart);
                VectorCopy(move.velocity, velocity);
            } //end for
            if (area2num && i < 20)
            {
                for (link = areas; link; link = link->next_area)
                {
                    if (!AAS_AreaJumpPad(link->areanum)) continue;
                    if (AAS_ReachabilityExists(link->areanum, area2num)) continue;
                    //create a rocket or bfg jump reachability from area1 to area2
                    lreach = AAS_AllocReachability();
                    if (!lreach)
                    {
                        AAS_UnlinkFromAreas(areas);
                        return;
                    } //end if
                    lreach->areanum = area2num;
                    //NOTE: the facenum is the Z velocity
                    lreach->facenum = velocity[2];
                    //NOTE: the edgenum is the horizontal velocity
                    lreach->edgenum = sqrt(velocity[0] * velocity[0] + velocity[1] * velocity[1]);
                    VectorCopy(areastart, lreach->start);
                    VectorCopy(move.endpos, lreach->end);
                    lreach->traveltype = TRAVEL_JUMPPAD;
                    lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
                    lreach->traveltime = aassettings.rs_jumppad;
                    lreach->next = areareachability[link->areanum];
                    areareachability[link->areanum] = lreach;
                    //
                    reach_jumppad++;
                } //end for
            } //end if
        } //end if
        //
        if (fabs(velocity[0]) > 100 || fabs(velocity[1]) > 100) continue;
        //check for areas we can reach with air control
        for (area2num = 1; area2num < aasworld.numareas; area2num++)
        {
            visualize = qfalse;
            /*
            if (area2num == 3568)
            {
                for (link = areas; link; link = link->next_area)
                {
                    if (link->areanum == 3380)
                    {
                        visualize = qtrue;
                        botimport.Print(PRT_MESSAGE, "bah\n");
                    } //end if
                } //end for
            } //end if*/
            //never try to go back to one of the original jumppad areas
            //and don't create reachabilities if they already exist
            for (link = areas; link; link = link->next_area)
            {
                if (AAS_ReachabilityExists(link->areanum, area2num)) break;
                if (AAS_AreaJumpPad(link->areanum))
                {
                    if (link->areanum == area2num) break;
                } //end if
            } //end if
            if (link) continue;
            //
            area2 = &aasworld.areas[area2num];
            for (i = 0; i < area2->numfaces; i++)
            {
                face2num = aasworld.faceindex[area2->firstface + i];
                face2 = &aasworld.faces[abs(face2num)];
                //if it is not a ground face
                if (!(face2->faceflags & FACE_GROUND)) continue;
                //get the center of the face
                AAS_FaceCenter(face2num, facecenter);
                //only go higher up
                if (facecenter[2] < areastart[2]) continue;
                //get the jumppad jump z velocity
                zvel = velocity[2];
                //get the horizontal speed for the jump, if it isn't possible to calculate this
                //speed
                ret = AAS_HorizontalVelocityForJump(zvel, areastart, facecenter, &speed);
                if (ret && speed < 150)
                {
                    //direction towards the face center
                    VectorSubtract(facecenter, areastart, dir);
                    dir[2] = 0;
                    hordist = VectorNormalize(dir);
                    //if (hordist < 1.6 * facecenter[2] - areastart[2])
                    {
                        //get command movement
                        VectorScale(dir, speed, cmdmove);
                        //
                        AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qfalse,
                                                    velocity, cmdmove, 30, 30, 0.1f,
                                                    SE_ENTERWATER|SE_ENTERSLIME|
                                                    SE_ENTERLAVA|SE_HITGROUNDDAMAGE|
                                                    SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER|SE_HITGROUNDAREA, area2num, visualize);
                        //if prediction time wasn't enough to fully predict the movement
                        //don't enter slime or lava and don't fall from too high
                        if (move.frames < 30 && 
                                !(move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE))
                                && (move.stopevent & (SE_HITGROUNDAREA|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER)))
                        {
                            //never go back to the same jumppad
                            for (link = areas; link; link = link->next_area)
                            {
                                if (link->areanum == move.endarea) break;
                            }
                            if (!link)
                            {
                                for (link = areas; link; link = link->next_area)
                                {
                                    if (!AAS_AreaJumpPad(link->areanum)) continue;
                                    if (AAS_ReachabilityExists(link->areanum, area2num)) continue;
                                    //create a jumppad reachability from area1 to area2
                                    lreach = AAS_AllocReachability();
                                    if (!lreach)
                                    {
                                        AAS_UnlinkFromAreas(areas);
                                        return;
                                    } //end if
                                    lreach->areanum = move.endarea;
                                    //NOTE: the facenum is the Z velocity
                                    lreach->facenum = velocity[2];
                                    //NOTE: the edgenum is the horizontal velocity
                                    lreach->edgenum = sqrt(cmdmove[0] * cmdmove[0] + cmdmove[1] * cmdmove[1]);
                                    VectorCopy(areastart, lreach->start);
                                    VectorCopy(facecenter, lreach->end);
                                    lreach->traveltype = TRAVEL_JUMPPAD;
                                    lreach->traveltype |= AAS_TravelFlagsForTeam(ent);
                                    lreach->traveltime = aassettings.rs_aircontrolledjumppad;
                                    lreach->next = areareachability[link->areanum];
                                    areareachability[link->areanum] = lreach;
                                    //
                                    reach_jumppad++;
                                } //end for
                            }
                        } //end if
                    } //end if
                } //end for
            } //end for
        } //end for
        AAS_UnlinkFromAreas(areas);
    } //end for
} //end of the function AAS_Reachability_JumpPad
//===========================================================================
// never point at ground faces
// always a higher and pretty far area
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_Reachability_Grapple(int area1num, int area2num)
{
    int face2num, i, j, areanum, numareas, areas[20];
    float mingrappleangle, z, hordist;
    bsp_trace_t bsptrace;
    aas_trace_t trace;
    aas_face_t *face2;
    aas_area_t *area1, *area2;
    aas_lreachability_t *lreach;
    vec3_t areastart, facecenter, start, end, dir, down = {0, 0, -1};
    vec_t *v;

    //only grapple when on the ground or swimming
    if (!AAS_AreaGrounded(area1num) && !AAS_AreaSwim(area1num)) return qfalse;
    //don't grapple from a crouch area
    if (!(AAS_AreaPresenceType(area1num) & PRESENCE_NORMAL)) return qfalse;
    //NOTE: disabled area swim it doesn't work right
    if (AAS_AreaSwim(area1num)) return qfalse;
    //
    area1 = &aasworld.areas[area1num];
    area2 = &aasworld.areas[area2num];
    //don't grapple towards way lower areas
    if (area2->maxs[2] < area1->mins[2]) return qfalse;
    //
    VectorCopy(aasworld.areas[area1num].center, start);
    //if not a swim area
    if (!AAS_AreaSwim(area1num))
    {
        if (!AAS_PointAreaNum(start)) Log_Write("area %d center %f %f %f in solid?\r\n", area1num,
                                start[0], start[1], start[2]);
        VectorCopy(start, end);
        end[2] -= 1000;
        trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
        if (trace.startsolid) return qfalse;
        VectorCopy(trace.endpos, areastart);
    } //end if
    else
    {
        if (!(AAS_PointContents(start) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER))) return qfalse;
    } //end else
    //
    //start is now the start point
    //
    for (i = 0; i < area2->numfaces; i++)
    {
        face2num = aasworld.faceindex[area2->firstface + i];
        face2 = &aasworld.faces[abs(face2num)];
        //if it is not a solid face
        if (!(face2->faceflags & FACE_SOLID)) continue;
        //direction towards the first vertex of the face
        v = aasworld.vertexes[aasworld.edges[abs(aasworld.edgeindex[face2->firstedge])].v[0]];
        VectorSubtract(v, areastart, dir);
        //if the face plane is facing away
        if (DotProduct(aasworld.planes[face2->planenum].normal, dir) > 0) continue;
        //get the center of the face
        AAS_FaceCenter(face2num, facecenter);
        //only go higher up with the grapple
        if (facecenter[2] < areastart[2] + 64) continue;
        //only use vertical faces or downward facing faces
        if (DotProduct(aasworld.planes[face2->planenum].normal, down) < 0) continue;
        //direction towards the face center
        VectorSubtract(facecenter, areastart, dir);
        //
        z = dir[2];
        dir[2] = 0;
        hordist = VectorLength(dir);
        if (!hordist) continue;
        //if too far
        if (hordist > 2000) continue;
        //check the minimal angle of the movement
        mingrappleangle = 15; //15 degrees
        if (z / hordist < tan(2 * M_PI * mingrappleangle / 360)) continue;
        //
        VectorCopy(facecenter, start);
        VectorMA(facecenter, -500, aasworld.planes[face2->planenum].normal, end);
        //
        bsptrace = AAS_Trace(start, NULL, NULL, end, 0, CONTENTS_SOLID);
        //the grapple won't stick to the sky and the grapple point should be near the AAS wall
        if ((bsptrace.surface.flags & SURF_SKY) || (bsptrace.fraction * 500 > 32)) continue;
        //trace a full bounding box from the area center on the ground to
        //the center of the face
        VectorSubtract(facecenter, areastart, dir);
        VectorNormalize(dir);
        VectorMA(areastart, 4, dir, start);
        VectorCopy(bsptrace.endpos, end);
        trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
        VectorSubtract(trace.endpos, facecenter, dir);
        if (VectorLength(dir) > 24) continue;
        //
        VectorCopy(trace.endpos, start);
        VectorCopy(trace.endpos, end);
        end[2] -= AAS_FallDamageDistance();
        trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1);
        if (trace.fraction >= 1) continue;
        //area to end in
        areanum = AAS_PointAreaNum(trace.endpos);
        //if not in lava or slime
        if (aasworld.areasettings[areanum].contents & (AREACONTENTS_SLIME|AREACONTENTS_LAVA))
        {
            continue;
        } //end if
        //do not go the the source area
        if (areanum == area1num) continue;
        //don't create reachabilities if they already exist
        if (AAS_ReachabilityExists(area1num, areanum)) continue;
        //only end in areas we can stand
        if (!AAS_AreaGrounded(areanum)) continue;
        //never go through cluster portals!!
        numareas = AAS_TraceAreas(areastart, bsptrace.endpos, areas, NULL, 20);
        if (numareas >= 20) continue;
        for (j = 0; j < numareas; j++)
        {
            if (aasworld.areasettings[areas[j]].contents & AREACONTENTS_CLUSTERPORTAL) break;
        } //end for
        if (j < numareas) continue;
        //create a new reachability link
        lreach = AAS_AllocReachability();
        if (!lreach) return qfalse;
        lreach->areanum = areanum;
        lreach->facenum = face2num;
        lreach->edgenum = 0;
        VectorCopy(areastart, lreach->start);
        //VectorCopy(facecenter, lreach->end);
        VectorCopy(bsptrace.endpos, lreach->end);
        lreach->traveltype = TRAVEL_GRAPPLEHOOK;
        VectorSubtract(lreach->end, lreach->start, dir);
        lreach->traveltime = aassettings.rs_startgrapple + VectorLength(dir) * 0.25;
        lreach->next = areareachability[area1num];
        areareachability[area1num] = lreach;
        //
        reach_grapple++;
    } //end for
    //
    return qfalse;
} //end of the function AAS_Reachability_Grapple
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void AAS_SetWeaponJumpAreaFlags(void)
{
    int ent, i;
    vec3_t mins = {-15, -15, -15}, maxs = {15, 15, 15};
    vec3_t origin;
    int areanum, weaponjumpareas, spawnflags;
    char classname[MAX_EPAIRKEY];

    weaponjumpareas = 0;
    for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
    {
        if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
        if (
            !strcmp(classname, "item_armor_body") ||
            !strcmp(classname, "item_armor_combat") ||
            !strcmp(classname, "item_health_mega") ||
            !strcmp(classname, "weapon_grenadelauncher") ||
            !strcmp(classname, "weapon_rocketlauncher") ||
            !strcmp(classname, "weapon_lightning") ||
            !strcmp(classname, "weapon_plasmagun") ||
            !strcmp(classname, "weapon_railgun") ||
            !strcmp(classname, "weapon_bfg") ||
            !strcmp(classname, "item_quad") ||
            !strcmp(classname, "item_regen") ||
            !strcmp(classname, "item_invulnerability"))
        {
            if (AAS_VectorForBSPEpairKey(ent, "origin", origin))
            {
                spawnflags = 0;
                AAS_IntForBSPEpairKey(ent, "spawnflags", &spawnflags);
                //if not a stationary item
                if (!(spawnflags & 1))
                {
                    if (!AAS_DropToFloor(origin, mins, maxs))
                    {
                        botimport.Print(PRT_MESSAGE, "%s in solid at (%1.1f %1.1f %1.1f)\n",
                                                        classname, origin[0], origin[1], origin[2]);
                    } //end if
                } //end if
                //areanum = AAS_PointAreaNum(origin);
                areanum = AAS_BestReachableArea(origin, mins, maxs, origin);
                //the bot may rocket jump towards this area
                aasworld.areasettings[areanum].areaflags |= AREA_WEAPONJUMP;
                //
                //if (!AAS_AreaGrounded(areanum))
                //  botimport.Print(PRT_MESSAGE, "area not grounded\n");
                //
                weaponjumpareas++;
            } //end if
        } //end if
    } //end for
    for (i = 1; i < aasworld.numareas; i++)
    {
        if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD)
        {
            aasworld.areasettings[i].areaflags |= AREA_WEAPONJUMP;
            weaponjumpareas++;
        } //end if
    } //end for
    botimport.Print(PRT_MESSAGE, "%d weapon jump areas\n", weaponjumpareas);
} //end of the function AAS_SetWeaponJumpAreaFlags
//===========================================================================
// create a possible weapon jump reachability from area1 to area2
//
// check if there's a cool item in the second area
// check if area1 is lower than area2
// check if the bot can rocketjump from area1 to area2
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
int AAS_Reachability_WeaponJump(int area1num, int area2num)
{
    int face2num, i, n, ret, visualize;
    float speed, zvel, hordist;
    aas_face_t *face2;
    aas_area_t *area1, *area2;
    aas_lreachability_t *lreach;
    vec3_t areastart, facecenter, start, end, dir, cmdmove;// teststart;
    vec3_t velocity;
    aas_clientmove_t move;
    aas_trace_t trace;

    visualize = qfalse;
//  if (area1num == 4436 && area2num == 4318)
//  {
//      visualize = qtrue;
//  }
    if (!AAS_AreaGrounded(area1num) || AAS_AreaSwim(area1num)) return qfalse;
    if (!AAS_AreaGrounded(area2num)) return qfalse;
    //NOTE: only weapon jump towards areas with an interesting item in it??
    if (!(aasworld.areasettings[area2num].areaflags & AREA_WEAPONJUMP)) return qfalse;
    //
    area1 = &aasworld.areas[area1num];
    area2 = &aasworld.areas[area2num];
    //don't weapon jump towards way lower areas
    if (area2->maxs[2] < area1->mins[2]) return qfalse;
    //
    VectorCopy(aasworld.areas[area1num].center, start);
    //if not a swim area
    if (!AAS_PointAreaNum(start)) Log_Write("area %d center %f %f %f in solid?\r\n", area1num,
                            start[0], start[1], start[2]);
    VectorCopy(start, end);
    end[2] -= 1000;
    trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
    if (trace.startsolid) return qfalse;
    VectorCopy(trace.endpos, areastart);
    //
    //areastart is now the start point
    //
    for (i = 0; i < area2->numfaces; i++)
    {
        face2num = aasworld.faceindex[area2->firstface + i];
        face2 = &aasworld.faces[abs(face2num)];
        //if it is not a solid face
        if (!(face2->faceflags & FACE_GROUND)) continue;
        //get the center of the face
        AAS_FaceCenter(face2num, facecenter);
        //only go higher up with weapon jumps
        if (facecenter[2] < areastart[2] + 64) continue;
        //NOTE: set to 2 to allow bfg jump reachabilities
        for (n = 0; n < 1/*2*/; n++)
        {
            //get the rocket jump z velocity
            if (n) zvel = AAS_BFGJumpZVelocity(areastart);
            else zvel = AAS_RocketJumpZVelocity(areastart);
            //get the horizontal speed for the jump, if it isn't possible to calculate this
            //speed (the jump is not possible) then there's no jump reachability created
            ret = AAS_HorizontalVelocityForJump(zvel, areastart, facecenter, &speed);
            if (ret && speed < 300)
            {
                //direction towards the face center
                VectorSubtract(facecenter, areastart, dir);
                dir[2] = 0;
                hordist = VectorNormalize(dir);
                //if (hordist < 1.6 * (facecenter[2] - areastart[2]))
                {
                    //get command movement
                    VectorScale(dir, speed, cmdmove);
                    VectorSet(velocity, 0, 0, zvel);
                    /*
                    //get command movement
                    VectorScale(dir, speed, velocity);
                    velocity[2] = zvel;
                    VectorSet(cmdmove, 0, 0, 0);
                    */
                    //
                    AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qtrue,
                                                velocity, cmdmove, 30, 30, 0.1f,
                                                SE_ENTERWATER|SE_ENTERSLIME|
                                                SE_ENTERLAVA|SE_HITGROUNDDAMAGE|
                                                SE_TOUCHJUMPPAD|SE_HITGROUND|SE_HITGROUNDAREA, area2num, visualize);
                    //if prediction time wasn't enough to fully predict the movement
                    //don't enter slime or lava and don't fall from too high
                    if (move.frames < 30 && 
                            !(move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE))
                                && (move.stopevent & (SE_HITGROUNDAREA|SE_TOUCHJUMPPAD)))
                    {
                        //create a rocket or bfg jump reachability from area1 to area2
                        lreach = AAS_AllocReachability();
                        if (!lreach) return qfalse;
                        lreach->areanum = area2num;
                        lreach->facenum = 0;
                        lreach->edgenum = 0;
                        VectorCopy(areastart, lreach->start);
                        VectorCopy(facecenter, lreach->end);
                        if (n)
                        {
                            lreach->traveltype = TRAVEL_BFGJUMP;
                            lreach->traveltime = aassettings.rs_bfgjump;
                        } //end if
                        else
                        {
                            lreach->traveltype = TRAVEL_ROCKETJUMP;
                            lreach->traveltime = aassettings.rs_rocketjump;
                        } //end else
                        lreach->next = areareachability[area1num];
                        areareachability[area1num] = lreach;
                        //
                        reach_rocketjump++;
                        return qtrue;
                    } //end if
                } //end if
            } //end if
        } //end for
    } //end for
    //
    return qfalse;
} //end of the function AAS_Reachability_WeaponJump
//===========================================================================
// calculates additional walk off ledge reachabilities for the given area
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void AAS_Reachability_WalkOffLedge(int areanum)
{
    int i, j, k, l, m, n, p, areas[10], numareas;
    int face1num, face2num, face3num, edge1num, edge2num, edge3num;
    int otherareanum, gap, reachareanum, side;
    aas_area_t *area, *area2;
    aas_face_t *face1, *face2, *face3;
    aas_edge_t *edge;
    aas_plane_t *plane;
    vec_t *v1, *v2;
    vec3_t sharededgevec, mid, dir, testend;
    aas_lreachability_t *lreach;
    aas_trace_t trace;

    if (!AAS_AreaGrounded(areanum) || AAS_AreaSwim(areanum)) return;
    //
    area = &aasworld.areas[areanum];
    //
    for (i = 0; i < area->numfaces; i++)
    {
        face1num = aasworld.faceindex[area->firstface + i];
        face1 = &aasworld.faces[abs(face1num)];
        //face 1 must be a ground face
        if (!(face1->faceflags & FACE_GROUND)) continue;
        //go through all the edges of this ground face
        for (k = 0; k < face1->numedges; k++)
        {
            edge1num = aasworld.edgeindex[face1->firstedge + k];
            //find another not ground face using this same edge
            for (j = 0; j < area->numfaces; j++)
            {
                face2num = aasworld.faceindex[area->firstface + j];
                face2 = &aasworld.faces[abs(face2num)];
                //face 2 may not be a ground face
                if (face2->faceflags & FACE_GROUND) continue;
                //compare all the edges
                for (l = 0; l < face2->numedges; l++)
                {
                    edge2num = aasworld.edgeindex[face2->firstedge + l];
                    if (abs(edge1num) == abs(edge2num))
                    {
                        //get the area at the other side of the face
                        if (face2->frontarea == areanum) otherareanum = face2->backarea;
                        else otherareanum = face2->frontarea;
                        //
                        area2 = &aasworld.areas[otherareanum];
                        //if the other area is grounded!
                        if (aasworld.areasettings[otherareanum].areaflags & AREA_GROUNDED)
                        {
                            //check for a possible gap
                            gap = qfalse;
                            for (n = 0; n < area2->numfaces; n++)
                            {
                                face3num = aasworld.faceindex[area2->firstface + n];
                                //may not be the shared face of the two areas
                                if (abs(face3num) == abs(face2num)) continue;
                                //
                                face3 = &aasworld.faces[abs(face3num)];
                                //find an edge shared by all three faces
                                for (m = 0; m < face3->numedges; m++)
                                {
                                    edge3num = aasworld.edgeindex[face3->firstedge + m];
                                    //but the edge should be shared by all three faces
                                    if (abs(edge3num) == abs(edge1num))
                                    {
                                        if (!(face3->faceflags & FACE_SOLID))
                                        {
                                            gap = qtrue;
                                            break;
                                        } //end if
                                        //
                                        if (face3->faceflags & FACE_GROUND)
                                        {
                                            gap = qfalse;
                                            break;
                                        } //end if
                                        //FIXME: there are more situations to be handled
                                        gap = qtrue;
                                        break;
                                    } //end if
                                } //end for
                                if (m < face3->numedges) break;
                            } //end for
                            if (!gap) break;
                        } //end if
                        //check for a walk off ledge reachability
                        edge = &aasworld.edges[abs(edge1num)];
                        side = edge1num < 0;
                        //
                        v1 = aasworld.vertexes[edge->v[side]];
                        v2 = aasworld.vertexes[edge->v[!side]];
                        //
                        plane = &aasworld.planes[face1->planenum];
                        //get the points really into the areas
                        VectorSubtract(v2, v1, sharededgevec);
                        CrossProduct(plane->normal, sharededgevec, dir);
                        VectorNormalize(dir);
                        //
                        VectorAdd(v1, v2, mid);
                        VectorScale(mid, 0.5, mid);
                        VectorMA(mid, 8, dir, mid);
                        //
                        VectorCopy(mid, testend);
                        testend[2] -= 1000;
                        trace = AAS_TraceClientBBox(mid, testend, PRESENCE_CROUCH, -1);
                        //
                        if (trace.startsolid)
                        {
                            //Log_Write("area %d: trace.startsolid\r\n", areanum);
                            break;
                        } //end if
                        reachareanum = AAS_PointAreaNum(trace.endpos);
                        if (reachareanum == areanum)
                        {
                            //Log_Write("area %d: same area\r\n", areanum);
                            break;
                        } //end if
                        if (AAS_ReachabilityExists(areanum, reachareanum))
                        {
                            //Log_Write("area %d: reachability already exists\r\n", areanum);
                            break;
                        } //end if
                        if (!AAS_AreaGrounded(reachareanum) && !AAS_AreaSwim(reachareanum))
                        {
                            //Log_Write("area %d, reach area %d: not grounded and not swim\r\n", areanum, reachareanum);
                            break;
                        } //end if
                        //
                        if (aasworld.areasettings[reachareanum].contents & (AREACONTENTS_SLIME
                                                                                        | AREACONTENTS_LAVA))
                        {
                            //Log_Write("area %d, reach area %d: lava or slime\r\n", areanum, reachareanum);
                            break;
                        } //end if
                        //if not going through a cluster portal
                        numareas = AAS_TraceAreas(mid, testend, areas, NULL, sizeof(areas) / sizeof(int));
                        for (p = 0; p < numareas; p++)
                            if (AAS_AreaClusterPortal(areas[p]))
                                break;
                        if (p < numareas)
                            break;
                        // if a maximum fall height is set and the bot would fall down further
                        if (aassettings.rs_maxfallheight && fabs(mid[2] - trace.endpos[2]) > aassettings.rs_maxfallheight)
                            break;
                        //
                        lreach = AAS_AllocReachability();
                        if (!lreach) break;
                        lreach->areanum = reachareanum;
                        lreach->facenum = 0;
                        lreach->edgenum = edge1num;
                        VectorCopy(mid, lreach->start);
                        VectorCopy(trace.endpos, lreach->end);
                        lreach->traveltype = TRAVEL_WALKOFFLEDGE;
                        lreach->traveltime = aassettings.rs_startwalkoffledge + fabs(mid[2] - trace.endpos[2]) * 50 / aassettings.phys_gravity;
                        if (!AAS_AreaSwim(reachareanum) && !AAS_AreaJumpPad(reachareanum))
                        {
                            if (AAS_FallDelta(mid[2] - trace.endpos[2]) > aassettings.phys_falldelta5)
                            {
                                lreach->traveltime += aassettings.rs_falldamage5;
                            } //end if
                            else if (AAS_FallDelta(mid[2] - trace.endpos[2]) > aassettings.phys_falldelta10)
                            {
                                lreach->traveltime += aassettings.rs_falldamage10;
                            } //end if
                        } //end if
                        lreach->next = areareachability[areanum];
                        areareachability[areanum] = lreach;
                        //we've got another walk off ledge reachability
                        reach_walkoffledge++;
                    } //end if
                } //end for
            } //end for
        } //end for
    } //end for
} //end of the function AAS_Reachability_WalkOffLedge
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void AAS_StoreReachability(void)
{
    int i;
    aas_areasettings_t *areasettings;
    aas_lreachability_t *lreach;
    aas_reachability_t *reach;

    if (aasworld.reachability) FreeMemory(aasworld.reachability);
    aasworld.reachability = (aas_reachability_t *) GetClearedMemory((numlreachabilities + 10) * sizeof(aas_reachability_t));
    aasworld.reachabilitysize = 1;
    for (i = 0; i < aasworld.numareas; i++)
    {
        areasettings = &aasworld.areasettings[i];
        areasettings->firstreachablearea = aasworld.reachabilitysize;
        areasettings->numreachableareas = 0;
        for (lreach = areareachability[i]; lreach; lreach = lreach->next)
        {
            reach = &aasworld.reachability[areasettings->firstreachablearea +
                                                    areasettings->numreachableareas];
            reach->areanum = lreach->areanum;
            reach->facenum = lreach->facenum;
            reach->edgenum = lreach->edgenum;
            VectorCopy(lreach->start, reach->start);
            VectorCopy(lreach->end, reach->end);
            reach->traveltype = lreach->traveltype;
            reach->traveltime = lreach->traveltime;
            //
            areasettings->numreachableareas++;
        } //end for
        aasworld.reachabilitysize += areasettings->numreachableareas;
    } //end for
} //end of the function AAS_StoreReachability
//===========================================================================
//
// TRAVEL_WALK                  100%    equal floor height + steps
// TRAVEL_CROUCH                100%
// TRAVEL_BARRIERJUMP           100%
// TRAVEL_JUMP                   80%
// TRAVEL_LADDER                100%    + fall down from ladder + jump up to ladder
// TRAVEL_WALKOFFLEDGE           90%    walk off very steep walls?
// TRAVEL_SWIM                  100%
// TRAVEL_WATERJUMP             100%
// TRAVEL_TELEPORT              100%
// TRAVEL_ELEVATOR              100%
// TRAVEL_GRAPPLEHOOK           100%
// TRAVEL_DOUBLEJUMP              0%
// TRAVEL_RAMPJUMP                0%
// TRAVEL_STRAFEJUMP              0%
// TRAVEL_ROCKETJUMP            100%    (currently limited towards areas with items)
// TRAVEL_BFGJUMP                 0%    (currently disabled)
// TRAVEL_JUMPPAD               100%
// TRAVEL_FUNCBOB               100%
//
// Parameter:           -
// Returns:             true if NOT finished
// Changes Globals:     -
//===========================================================================
int AAS_ContinueInitReachability(float time)
{
    int i, j, todo, start_time;
    static float framereachability, reachability_delay;
    static int lastpercentage;

    if (!aasworld.loaded) return qfalse;
    //if reachability is calculated for all areas
    if (aasworld.numreachabilityareas >= aasworld.numareas + 2) return qfalse;
    //if starting with area 1 (area 0 is a dummy)
    if (aasworld.numreachabilityareas == 1)
    {
        botimport.Print(PRT_MESSAGE, "calculating reachability...\n");
        lastpercentage = 0;
        framereachability = 2000;
        reachability_delay = 1000;
    } //end if
    //number of areas to calculate reachability for this cycle
    todo = aasworld.numreachabilityareas + (int) framereachability;
    start_time = Sys_MilliSeconds();
    //loop over the areas
    for (i = aasworld.numreachabilityareas; i < aasworld.numareas && i < todo; i++)
    {
        aasworld.numreachabilityareas++;
        //only create jumppad reachabilities from jumppad areas
        if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD)
        {
            continue;
        } //end if
        //loop over the areas
        for (j = 1; j < aasworld.numareas; j++)
        {
            if (i == j) continue;
            //never create reachabilities from teleporter or jumppad areas to regular areas
            if (aasworld.areasettings[i].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD))
            {
                if (!(aasworld.areasettings[j].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD)))
                {
                    continue;
                } //end if
            } //end if
            //if there already is a reachability link from area i to j
            if (AAS_ReachabilityExists(i, j)) continue;
            //check for a swim reachability
            if (AAS_Reachability_Swim(i, j)) continue;
            //check for a simple walk on equal floor height reachability
            if (AAS_Reachability_EqualFloorHeight(i, j)) continue;
            //check for step, barrier, waterjump and walk off ledge reachabilities
            if (AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(i, j)) continue;
            //check for ladder reachabilities
            if (AAS_Reachability_Ladder(i, j)) continue;
            //check for a jump reachability
            if (AAS_Reachability_Jump(i, j)) continue;
        } //end for
        //never create these reachabilities from teleporter or jumppad areas
        if (aasworld.areasettings[i].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD))
        {
            continue;
        } //end if
        //loop over the areas
        for (j = 1; j < aasworld.numareas; j++)
        {
            if (i == j) continue;
            //
            if (AAS_ReachabilityExists(i, j)) continue;
            //check for a grapple hook reachability
            if (calcgrapplereach) AAS_Reachability_Grapple(i, j);
            //check for a weapon jump reachability
            AAS_Reachability_WeaponJump(i, j);
        } //end for
        //if the calculation took more time than the max reachability delay
        if (Sys_MilliSeconds() - start_time > (int) reachability_delay) break;
        //
        if (aasworld.numreachabilityareas * 1000 / aasworld.numareas > lastpercentage) break;
    } //end for
    //
    if (aasworld.numreachabilityareas == aasworld.numareas)
    {
        botimport.Print(PRT_MESSAGE, "\r%6.1f%%", (float) 100.0);
        botimport.Print(PRT_MESSAGE, "\nplease wait while storing reachability...\n");
        aasworld.numreachabilityareas++;
    } //end if
    //if this is the last step in the reachability calculations
    else if (aasworld.numreachabilityareas == aasworld.numareas + 1)
    {
        //create additional walk off ledge reachabilities for every area
        for (i = 1; i < aasworld.numareas; i++)
        {
            //only create jumppad reachabilities from jumppad areas
            if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD)
            {
                continue;
            } //end if
            AAS_Reachability_WalkOffLedge(i);
        } //end for
        //create jump pad reachabilities
        AAS_Reachability_JumpPad();
        //create teleporter reachabilities
        AAS_Reachability_Teleport();
        //create elevator (func_plat) reachabilities
        AAS_Reachability_Elevator();
        //create func_bobbing reachabilities
        AAS_Reachability_FuncBobbing();
        //
#ifdef DEBUG
        botimport.Print(PRT_MESSAGE, "%6d reach swim\n", reach_swim);
        botimport.Print(PRT_MESSAGE, "%6d reach equal floor\n", reach_equalfloor);
        botimport.Print(PRT_MESSAGE, "%6d reach step\n", reach_step);
        botimport.Print(PRT_MESSAGE, "%6d reach barrier\n", reach_barrier);
        botimport.Print(PRT_MESSAGE, "%6d reach waterjump\n", reach_waterjump);
        botimport.Print(PRT_MESSAGE, "%6d reach walkoffledge\n", reach_walkoffledge);
        botimport.Print(PRT_MESSAGE, "%6d reach jump\n", reach_jump);
        botimport.Print(PRT_MESSAGE, "%6d reach ladder\n", reach_ladder);
        botimport.Print(PRT_MESSAGE, "%6d reach walk\n", reach_walk);
        botimport.Print(PRT_MESSAGE, "%6d reach teleport\n", reach_teleport);
        botimport.Print(PRT_MESSAGE, "%6d reach funcbob\n", reach_funcbob);
        botimport.Print(PRT_MESSAGE, "%6d reach elevator\n", reach_elevator);
        botimport.Print(PRT_MESSAGE, "%6d reach grapple\n", reach_grapple);
        botimport.Print(PRT_MESSAGE, "%6d reach rocketjump\n", reach_rocketjump);
        botimport.Print(PRT_MESSAGE, "%6d reach jumppad\n", reach_jumppad);
#endif
        //*/
        //store all the reachabilities
        AAS_StoreReachability();
        //free the reachability link heap
        AAS_ShutDownReachabilityHeap();
        //
        FreeMemory(areareachability);
        //
        aasworld.numreachabilityareas++;
        //
        botimport.Print(PRT_MESSAGE, "calculating clusters...\n");
    } //end if
    else
    {
        lastpercentage = aasworld.numreachabilityareas * 1000 / aasworld.numareas;
        botimport.Print(PRT_MESSAGE, "\r%6.1f%%", (float) lastpercentage / 10);
    } //end else
    //not yet finished
    return qtrue;
} //end of the function AAS_ContinueInitReachability
//===========================================================================
//
// Parameter:               -
// Returns:                 -
// Changes Globals:     -
//===========================================================================
void AAS_InitReachability(void)
{
    if (!aasworld.loaded) return;

    if (aasworld.reachabilitysize)
    {
#ifndef BSPC
        if (!((int)LibVarGetValue("forcereachability")))
        {
            aasworld.numreachabilityareas = aasworld.numareas + 2;
            return;
        } //end if
#else
        aasworld.numreachabilityareas = aasworld.numareas + 2;
        return;
#endif //BSPC
    } //end if
#ifndef BSPC
    calcgrapplereach = LibVarGetValue("grapplereach");
#endif
    aasworld.savefile = qtrue;
    //start with area 1 because area zero is a dummy
    aasworld.numreachabilityareas = 1;
    //setup the heap with reachability links
    AAS_SetupReachabilityHeap();
    //allocate area reachability link array
    areareachability = (aas_lreachability_t **) GetClearedMemory(
                                    aasworld.numareas * sizeof(aas_lreachability_t *));
    //
    AAS_SetWeaponJumpAreaFlags();
} //end of the function AAS_InitReachable

---