/* =========================================================================== 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 "../qcommon/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 "botlib.h" #include "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 = {0, 0, 0}, ground_bestend = {0, 0, 0}, ground_bestnormal = {0, 0, 0}; vec3_t water_beststart = {0, 0, 0}, water_bestend = {0, 0, 0}, water_bestnormal = {0, 0, 0}; 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 = 0, lowestedgenum = 0; int face1num, face2num, ladderface1num = 0, ladderface2num = 0; int ladderface1vertical, ladderface2vertical, firstv; float face1area, face2area, bestface1area = -9999, bestface2area = -9999; float phys_jumpvel, maxjumpheight; vec3_t area1point, area2point, v1, v2, up = {0, 0, 1}; vec3_t mid, lowestpoint = {0, 0}, start, end, sharededgevec, dir; aas_area_t *area1, *area2; aas_face_t *face1, *face2, *ladderface1 = NULL, *ladderface2 = NULL; 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]; 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", ¬team)) return 0; if (notteam == 1) return TRAVELFLAG_NOTTEAM1; if (notteam == 2) return TRAVELFLAG_NOTTEAM2; return 0; } //end of the function AAS_TravelFlagsForTeam //=========================================================================== // create possible teleporter reachabilities // this is very game dependent.... :( // // classname = trigger_multiple or trigger_teleport // target = "t1" // // classname = target_teleporter // targetname = "t1" // target = "t2" // // classname = misc_teleporter_dest // targetname = "t2" // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== void AAS_Reachability_Teleport(void) { int area1num, area2num; char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY]; char classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY]; int ent, dest; float angle; vec3_t origin, destorigin, mins, maxs, end, angles; vec3_t mid, velocity, cmdmove; aas_lreachability_t *lreach; aas_clientmove_t move; aas_trace_t trace; aas_link_t *areas, *link; for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent)) { if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue; if (!strcmp(classname, "trigger_multiple")) { AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY); //#ifdef REACH_DEBUG botimport.Print(PRT_MESSAGE, "trigger_multiple model = \"%s\"\n", model); //#endif REACH_DEBUG VectorClear(angles); AAS_BSPModelMinsMaxsOrigin(atoi(model+1), angles, mins, maxs, origin); // if (!AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY)) { botimport.Print(PRT_ERROR, "trigger_multiple at %1.0f %1.0f %1.0f without target\n", origin[0], origin[1], origin[2]); continue; } //end if for (dest = AAS_NextBSPEntity(0); dest; dest = AAS_NextBSPEntity(dest)) { if (!AAS_ValueForBSPEpairKey(dest, "classname", classname, MAX_EPAIRKEY)) continue; if (!strcmp(classname, "target_teleporter")) { if (!AAS_ValueForBSPEpairKey(dest, "targetname", targetname, MAX_EPAIRKEY)) continue; if (!strcmp(targetname, target)) { break; } //end if } //end if } //end for if (!dest) { continue; } //end if if (!AAS_ValueForBSPEpairKey(dest, "target", target, MAX_EPAIRKEY)) { botimport.Print(PRT_ERROR, "target_teleporter without target\n"); continue; } //end if } //end else else if (!strcmp(classname, "trigger_teleport")) { AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY); //#ifdef REACH_DEBUG botimport.Print(PRT_MESSAGE, "trigger_teleport model = \"%s\"\n", model); //#endif REACH_DEBUG VectorClear(angles); AAS_BSPModelMinsMaxsOrigin(atoi(model+1), angles, mins, maxs, origin); // if (!AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY)) { botimport.Print(PRT_ERROR, "trigger_teleport at %1.0f %1.0f %1.0f without target\n", origin[0], origin[1], origin[2]); continue; } //end if } //end if else { continue; } //end else // for (dest = AAS_NextBSPEntity(0); dest; dest = AAS_NextBSPEntity(dest)) { //classname should be misc_teleporter_dest //but I've also seen target_position and actually any //entity could be used... burp if (AAS_ValueForBSPEpairKey(dest, "targetname", targetname, MAX_EPAIRKEY)) { if (!strcmp(targetname, target)) { break; } //end if } //end if } //end for if (!dest) { botimport.Print(PRT_ERROR, "teleporter without misc_teleporter_dest (%s)\n", target); continue; } //end if if (!AAS_VectorForBSPEpairKey(dest, "origin", destorigin)) { botimport.Print(PRT_ERROR, "teleporter destination (%s) without origin\n", target); continue; } //end if // area2num = AAS_PointAreaNum(destorigin); //if not teleported into a teleporter or into a jumppad if (!AAS_AreaTeleporter(area2num) && !AAS_AreaJumpPad(area2num)) { VectorCopy(destorigin, end); end[2] -= 64; trace = AAS_TraceClientBBox(destorigin, end, PRESENCE_CROUCH, -1); if (trace.startsolid) { botimport.Print(PRT_ERROR, "teleporter destination (%s) in solid\n", target); continue; } //end if area2num = AAS_PointAreaNum(trace.endpos); // /* if (!AAS_AreaTeleporter(area2num) && !AAS_AreaJumpPad(area2num) && !AAS_AreaGrounded(area2num)) { VectorCopy(trace.endpos, destorigin); } else*/ { //predict where you'll end up AAS_FloatForBSPEpairKey(dest, "angle", &angle); if (angle) { VectorSet(angles, 0, angle, 0); AngleVectors(angles, velocity, NULL, NULL); VectorScale(velocity, 400, velocity); } //end if else { VectorClear(velocity); } //end else VectorClear(cmdmove); AAS_PredictClientMovement(&move, -1, destorigin, PRESENCE_NORMAL, qfalse, velocity, cmdmove, 0, 30, 0.1f, SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME| SE_ENTERLAVA|SE_HITGROUNDDAMAGE|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER, 0, qfalse); //qtrue); area2num = AAS_PointAreaNum(move.endpos); if (move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA)) { botimport.Print(PRT_WARNING, "teleported into slime or lava at dest %s\n", target); } //end if VectorCopy(move.endpos, destorigin); } //end else } //end if // //botimport.Print(PRT_MESSAGE, "teleporter brush origin at %f %f %f\n", origin[0], origin[1], origin[2]); //botimport.Print(PRT_MESSAGE, "teleporter brush mins = %f %f %f\n", mins[0], mins[1], mins[2]); //botimport.Print(PRT_MESSAGE, "teleporter brush maxs = %f %f %f\n", maxs[0], maxs[1], maxs[2]); VectorAdd(origin, mins, mins); VectorAdd(origin, maxs, maxs); // VectorAdd(mins, maxs, mid); VectorScale(mid, 0.5, mid); //link an invalid (-1) entity areas = AAS_LinkEntityClientBBox(mins, maxs, -1, PRESENCE_CROUCH); if (!areas) botimport.Print(PRT_MESSAGE, "trigger_multiple not in any area\n"); // for (link = areas; link; link = link->next_area) { //if (!AAS_AreaGrounded(link->areanum)) continue; if (!AAS_AreaTeleporter(link->areanum)) continue; // area1num = link->areanum; //create a new reachability link lreach = AAS_AllocReachability(); if (!lreach) break; lreach->areanum = area2num; lreach->facenum = 0; lreach->edgenum = 0; VectorCopy(mid, lreach->start); VectorCopy(destorigin, lreach->end); lreach->traveltype = TRAVEL_TELEPORT; lreach->traveltype |= AAS_TravelFlagsForTeam(ent); lreach->traveltime = aassettings.rs_teleport; lreach->next = areareachability[area1num]; areareachability[area1num] = lreach; // reach_teleport++; } //end for //unlink the invalid entity AAS_UnlinkFromAreas(areas); } //end for } //end of the function AAS_Reachability_Teleport //=========================================================================== // create possible elevator (func_plat) reachabilities // this is very game dependent.... :( // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== void AAS_Reachability_Elevator(void) { int area1num, area2num, modelnum, i, j, k, l, n, p; float lip, height, speed; char model[MAX_EPAIRKEY], classname[MAX_EPAIRKEY]; int ent; vec3_t mins, maxs, origin, angles = {0, 0, 0}; vec3_t pos1, pos2, mids, platbottom, plattop; vec3_t bottomorg, toporg, start, end, dir; vec_t xvals[8], yvals[8], xvals_top[8], yvals_top[8]; aas_lreachability_t *lreach; aas_trace_t trace; #ifdef REACH_DEBUG Log_Write("AAS_Reachability_Elevator\r\n"); #endif //REACH_DEBUG for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent)) { if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue; if (!strcmp(classname, "func_plat")) { #ifdef REACH_DEBUG Log_Write("found func plat\r\n"); #endif //REACH_DEBUG if (!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY)) { botimport.Print(PRT_ERROR, "func_plat without model\n"); continue; } //end if //get the model number, and skip the leading * modelnum = atoi(model+1); if (modelnum <= 0) { botimport.Print(PRT_ERROR, "func_plat with invalid model number\n"); continue; } //end if //get the mins, maxs and origin of the model //NOTE: the origin is usually (0,0,0) and the mins and maxs // are the absolute mins and maxs AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin); // AAS_VectorForBSPEpairKey(ent, "origin", origin); //pos1 is the top position, pos2 is the bottom VectorCopy(origin, pos1); VectorCopy(origin, pos2); //get the lip of the plat AAS_FloatForBSPEpairKey(ent, "lip", &lip); if (!lip) lip = 8; //get the movement height of the plat AAS_FloatForBSPEpairKey(ent, "height", &height); if (!height) height = (maxs[2] - mins[2]) - lip; //get the speed of the plat AAS_FloatForBSPEpairKey(ent, "speed", &speed); if (!speed) speed = 200; //get bottom position below pos1 pos2[2] -= height; // //get a point just above the plat in the bottom position VectorAdd(mins, maxs, mids); VectorMA(pos2, 0.5, mids, platbottom); platbottom[2] = maxs[2] - (pos1[2] - pos2[2]) + 2; //get a point just above the plat in the top position VectorAdd(mins, maxs, mids); VectorMA(pos2, 0.5, mids, plattop); plattop[2] = maxs[2] + 2; // /*if (!area1num) { Log_Write("no grounded area near plat bottom\r\n"); continue; } //end if*/ //get the mins and maxs a little larger for (i = 0; i < 3; i++) { mins[i] -= 1; maxs[i] += 1; } //end for // //botimport.Print(PRT_MESSAGE, "platbottom[2] = %1.1f plattop[2] = %1.1f\n", platbottom[2], plattop[2]); // VectorAdd(mins, maxs, mids); VectorScale(mids, 0.5, mids); // xvals[0] = mins[0]; xvals[1] = mids[0]; xvals[2] = maxs[0]; xvals[3] = mids[0]; yvals[0] = mids[1]; yvals[1] = maxs[1]; yvals[2] = mids[1]; yvals[3] = mins[1]; // xvals[4] = mins[0]; xvals[5] = maxs[0]; xvals[6] = maxs[0]; xvals[7] = mins[0]; yvals[4] = maxs[1]; yvals[5] = maxs[1]; yvals[6] = mins[1]; yvals[7] = mins[1]; //find adjacent areas around the bottom of the plat for (i = 0; i < 9; i++) { if (i < 8) //check at the sides of the plat { bottomorg[0] = origin[0] + xvals[i]; bottomorg[1] = origin[1] + yvals[i]; bottomorg[2] = platbottom[2] + 16; //get a grounded or swim area near the plat in the bottom position area1num = AAS_PointAreaNum(bottomorg); for (k = 0; k < 16; k++) { if (area1num) { if (AAS_AreaGrounded(area1num) || AAS_AreaSwim(area1num)) break; } //end if bottomorg[2] += 4; area1num = AAS_PointAreaNum(bottomorg); } //end if //if in solid if (k >= 16) { continue; } //end if } //end if else //at the middle of the plat { VectorCopy(plattop, bottomorg); bottomorg[2] += 24; area1num = AAS_PointAreaNum(bottomorg); if (!area1num) continue; VectorCopy(platbottom, bottomorg); bottomorg[2] += 24; } //end else //look at adjacent areas around the top of the plat //make larger steps to outside the plat everytime for (n = 0; n < 3; n++) { for (k = 0; k < 3; k++) { mins[k] -= 4; maxs[k] += 4; } //end for xvals_top[0] = mins[0]; xvals_top[1] = mids[0]; xvals_top[2] = maxs[0]; xvals_top[3] = mids[0]; yvals_top[0] = mids[1]; yvals_top[1] = maxs[1]; yvals_top[2] = mids[1]; yvals_top[3] = mins[1]; // xvals_top[4] = mins[0]; xvals_top[5] = maxs[0]; xvals_top[6] = maxs[0]; xvals_top[7] = mins[0]; yvals_top[4] = maxs[1]; yvals_top[5] = maxs[1]; yvals_top[6] = mins[1]; yvals_top[7] = mins[1]; // for (j = 0; j < 8; j++) { toporg[0] = origin[0] + xvals_top[j]; toporg[1] = origin[1] + yvals_top[j]; toporg[2] = plattop[2] + 16; //get a grounded or swim area near the plat in the top position area2num = AAS_PointAreaNum(toporg); for (l = 0; l < 16; l++) { if (area2num) { if (AAS_AreaGrounded(area2num) || AAS_AreaSwim(area2num)) { VectorCopy(plattop, start); start[2] += 32; VectorCopy(toporg, end); end[2] += 1; trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1); if (trace.fraction >= 1) break; } //end if } //end if toporg[2] += 4; area2num = AAS_PointAreaNum(toporg); } //end if //if in solid if (l >= 16) continue; //never create a reachability in the same area if (area2num == area1num) continue; //if the area isn't grounded if (!AAS_AreaGrounded(area2num)) continue; //if there already exists reachability between the areas if (AAS_ReachabilityExists(area1num, area2num)) continue; //if the reachability start is within the elevator bounding box VectorSubtract(bottomorg, platbottom, dir); VectorNormalize(dir); dir[0] = bottomorg[0] + 24 * dir[0]; dir[1] = bottomorg[1] + 24 * dir[1]; dir[2] = bottomorg[2]; // for (p = 0; p < 3; p++) if (dir[p] < origin[p] + mins[p] || dir[p] > origin[p] + maxs[p]) break; if (p >= 3) continue; //create a new reachability link lreach = AAS_AllocReachability(); if (!lreach) continue; lreach->areanum = area2num; //the facenum is the model number lreach->facenum = modelnum; //the edgenum is the height lreach->edgenum = (int) height; // VectorCopy(dir, lreach->start); VectorCopy(toporg, lreach->end); lreach->traveltype = TRAVEL_ELEVATOR; lreach->traveltype |= AAS_TravelFlagsForTeam(ent); lreach->traveltime = aassettings.rs_startelevator + height * 100 / speed; lreach->next = areareachability[area1num]; areareachability[area1num] = lreach; //don't go any further to the outside n = 9999; // #ifdef REACH_DEBUG Log_Write("elevator reach from %d to %d\r\n", area1num, area2num); #endif //REACH_DEBUG // reach_elevator++; } //end for } //end for } //end for } //end if } //end for } //end of the function AAS_Reachability_Elevator //=========================================================================== // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== aas_lreachability_t *AAS_FindFaceReachabilities(vec3_t *facepoints, int numpoints, aas_plane_t *plane, int towardsface) { int i, j, k, l; int facenum, edgenum, bestfacenum; float *v1, *v2, *v3, *v4; float bestdist, speed, hordist, dist; vec3_t beststart, beststart2, bestend, bestend2, tmp, hordir, testpoint; aas_lreachability_t *lreach, *lreachabilities; aas_area_t *area; aas_face_t *face; aas_edge_t *edge; aas_plane_t *faceplane, *bestfaceplane; // lreachabilities = NULL; bestfacenum = 0; bestfaceplane = NULL; // for (i = 1; i < aasworld.numareas; i++) { area = &aasworld.areas[i]; // get the shortest distance between one of the func_bob start edges and // one of the face edges of area1 bestdist = 999999; for (j = 0; j < area->numfaces; j++) { facenum = aasworld.faceindex[area->firstface + j]; face = &aasworld.faces[abs(facenum)]; //if not a ground face if (!(face->faceflags & FACE_GROUND)) continue; //get the ground planes faceplane = &aasworld.planes[face->planenum]; // for (k = 0; k < face->numedges; k++) { edgenum = abs(aasworld.edgeindex[face->firstedge + k]); edge = &aasworld.edges[edgenum]; //calculate the minimum distance between the two edges v1 = aasworld.vertexes[edge->v[0]]; v2 = aasworld.vertexes[edge->v[1]]; // for (l = 0; l < numpoints; l++) { v3 = facepoints[l]; v4 = facepoints[(l+1) % numpoints]; dist = AAS_ClosestEdgePoints(v1, v2, v3, v4, faceplane, plane, beststart, bestend, beststart2, bestend2, bestdist); if (dist < bestdist) { bestfacenum = facenum; bestfaceplane = faceplane; bestdist = dist; } //end if } //end for } //end for } //end for // if (bestdist > 192) continue; // VectorMiddle(beststart, beststart2, beststart); VectorMiddle(bestend, bestend2, bestend); // if (!towardsface) { VectorCopy(beststart, tmp); VectorCopy(bestend, beststart); VectorCopy(tmp, bestend); } //end if // VectorSubtract(bestend, beststart, hordir); hordir[2] = 0; hordist = VectorLength(hordir); // if (hordist > 2 * AAS_MaxJumpDistance(aassettings.phys_jumpvel)) continue; //the end point should not be significantly higher than the start point if (bestend[2] - 32 > beststart[2]) continue; //don't fall down too far if (bestend[2] < beststart[2] - 128) continue; //the distance should not be too far if (hordist > 32) { //check for walk off ledge if (!AAS_HorizontalVelocityForJump(0, beststart, bestend, &speed)) continue; } //end if // beststart[2] += 1; bestend[2] += 1; // if (towardsface) VectorCopy(bestend, testpoint); else VectorCopy(beststart, testpoint); testpoint[2] = 0; testpoint[2] = (bestfaceplane->dist - DotProduct(bestfaceplane->normal, testpoint)) / bestfaceplane->normal[2]; // if (!AAS_PointInsideFace(bestfacenum, testpoint, 0.1f)) { //if the faces are not overlapping then only go down if (bestend[2] - 16 > beststart[2]) continue; } //end if lreach = AAS_AllocReachability(); if (!lreach) return lreachabilities; lreach->areanum = i; lreach->facenum = 0; lreach->edgenum = 0; VectorCopy(beststart, lreach->start); VectorCopy(bestend, lreach->end); lreach->traveltype = 0; lreach->traveltime = 0; lreach->next = lreachabilities; lreachabilities = lreach; #ifndef BSPC if (towardsface) AAS_PermanentLine(lreach->start, lreach->end, 1); else AAS_PermanentLine(lreach->start, lreach->end, 2); #endif } //end for return lreachabilities; } //end of the function AAS_FindFaceReachabilities //=========================================================================== // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== void AAS_Reachability_FuncBobbing(void) { int ent, spawnflags, modelnum, axis; int i, numareas, areas[10]; char classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY]; vec3_t origin, move_end, move_start, move_start_top, move_end_top; vec3_t mins, maxs, angles = {0, 0, 0}; vec3_t start_edgeverts[4], end_edgeverts[4], mid; vec3_t org, start, end, dir, points[10]; float height; aas_plane_t start_plane, end_plane; aas_lreachability_t *startreach, *endreach, *nextstartreach, *nextendreach, *lreach; aas_lreachability_t *firststartreach, *firstendreach; for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent)) { if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue; if (strcmp(classname, "func_bobbing")) continue; AAS_FloatForBSPEpairKey(ent, "height", &height); if (!height) height = 32; // if (!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY)) { botimport.Print(PRT_ERROR, "func_bobbing without model\n"); continue; } //end if //get the model number, and skip the leading * modelnum = atoi(model+1); if (modelnum <= 0) { botimport.Print(PRT_ERROR, "func_bobbing with invalid model number\n"); continue; } //end if //if the entity has an origin set then use it if (!AAS_VectorForBSPEpairKey(ent, "origin", origin)) VectorSet(origin, 0, 0, 0); // AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, NULL); // VectorAdd(mins, origin, mins); VectorAdd(maxs, origin, maxs); // VectorAdd(mins, maxs, mid); VectorScale(mid, 0.5, mid); VectorCopy(mid, origin); // VectorCopy(origin, move_end); VectorCopy(origin, move_start); // AAS_IntForBSPEpairKey(ent, "spawnflags", &spawnflags); // set the axis of bobbing if (spawnflags & 1) axis = 0; else if (spawnflags & 2) axis = 1; else axis = 2; // move_start[axis] -= height; move_end[axis] += height; // Log_Write("funcbob model %d, start = {%1.1f, %1.1f, %1.1f} end = {%1.1f, %1.1f, %1.1f}\n", modelnum, move_start[0], move_start[1], move_start[2], move_end[0], move_end[1], move_end[2]); // #ifndef BSPC /* AAS_DrawPermanentCross(move_start, 4, 1); AAS_DrawPermanentCross(move_end, 4, 2); */ #endif // for (i = 0; i < 4; i++) { VectorCopy(move_start, start_edgeverts[i]); start_edgeverts[i][2] += maxs[2] - mid[2]; //+ bbox maxs z start_edgeverts[i][2] += 24; //+ player origin to ground dist } //end for start_edgeverts[0][0] += maxs[0] - mid[0]; start_edgeverts[0][1] += maxs[1] - mid[1]; start_edgeverts[1][0] += maxs[0] - mid[0]; start_edgeverts[1][1] += mins[1] - mid[1]; start_edgeverts[2][0] += mins[0] - mid[0]; start_edgeverts[2][1] += mins[1] - mid[1]; start_edgeverts[3][0] += mins[0] - mid[0]; start_edgeverts[3][1] += maxs[1] - mid[1]; // start_plane.dist = start_edgeverts[0][2]; VectorSet(start_plane.normal, 0, 0, 1); // for (i = 0; i < 4; i++) { VectorCopy(move_end, end_edgeverts[i]); end_edgeverts[i][2] += maxs[2] - mid[2]; //+ bbox maxs z end_edgeverts[i][2] += 24; //+ player origin to ground dist } //end for end_edgeverts[0][0] += maxs[0] - mid[0]; end_edgeverts[0][1] += maxs[1] - mid[1]; end_edgeverts[1][0] += maxs[0] - mid[0]; end_edgeverts[1][1] += mins[1] - mid[1]; end_edgeverts[2][0] += mins[0] - mid[0]; end_edgeverts[2][1] += mins[1] - mid[1]; end_edgeverts[3][0] += mins[0] - mid[0]; end_edgeverts[3][1] += maxs[1] - mid[1]; // end_plane.dist = end_edgeverts[0][2]; VectorSet(end_plane.normal, 0, 0, 1); // #ifndef BSPC #if 0 for (i = 0; i < 4; i++) { AAS_PermanentLine(start_edgeverts[i], start_edgeverts[(i+1)%4], 1); AAS_PermanentLine(end_edgeverts[i], end_edgeverts[(i+1)%4], 1); } //end for #endif #endif VectorCopy(move_start, move_start_top); move_start_top[2] += maxs[2] - mid[2] + 24; //+ bbox maxs z VectorCopy(move_end, move_end_top); move_end_top[2] += maxs[2] - mid[2] + 24; //+ bbox maxs z // if (!AAS_PointAreaNum(move_start_top)) continue; if (!AAS_PointAreaNum(move_end_top)) continue; // for (i = 0; i < 2; i++) { firststartreach = firstendreach = NULL; // if (i == 0) { firststartreach = AAS_FindFaceReachabilities(start_edgeverts, 4, &start_plane, qtrue); firstendreach = AAS_FindFaceReachabilities(end_edgeverts, 4, &end_plane, qfalse); } //end if else { firststartreach = AAS_FindFaceReachabilities(end_edgeverts, 4, &end_plane, qtrue); firstendreach = AAS_FindFaceReachabilities(start_edgeverts, 4, &start_plane, qfalse); } //end else // //create reachabilities from start to end for (startreach = firststartreach; startreach; startreach = nextstartreach) { nextstartreach = startreach->next; // //trace = AAS_TraceClientBBox(startreach->start, move_start_top, PRESENCE_NORMAL, -1); //if (trace.fraction < 1) continue; // for (endreach = firstendreach; endreach; endreach = nextendreach) { nextendreach = endreach->next; // //trace = AAS_TraceClientBBox(endreach->end, move_end_top, PRESENCE_NORMAL, -1); //if (trace.fraction < 1) continue; // Log_Write("funcbob reach from area %d to %d\n", startreach->areanum, endreach->areanum); // // if (i == 0) VectorCopy(move_start_top, org); else VectorCopy(move_end_top, org); VectorSubtract(startreach->start, org, dir); dir[2] = 0; VectorNormalize(dir); VectorCopy(startreach->start, start); VectorMA(startreach->start, 1, dir, start); start[2] += 1; VectorMA(startreach->start, 16, dir, end); end[2] += 1; // numareas = AAS_TraceAreas(start, end, areas, points, 10); if (numareas <= 0) continue; if (numareas > 1) VectorCopy(points[1], startreach->start); else VectorCopy(end, startreach->start); // if (!AAS_PointAreaNum(startreach->start)) continue; if (!AAS_PointAreaNum(endreach->end)) continue; // lreach = AAS_AllocReachability(); lreach->areanum = endreach->areanum; if (i == 0) lreach->edgenum = ((int)move_start[axis] << 16) | ((int) move_end[axis] & 0x0000ffff); else lreach->edgenum = ((int)move_end[axis] << 16) | ((int) move_start[axis] & 0x0000ffff); lreach->facenum = (spawnflags << 16) | modelnum; VectorCopy(startreach->start, lreach->start); VectorCopy(endreach->end, lreach->end); #ifndef BSPC // AAS_DrawArrow(lreach->start, lreach->end, LINECOLOR_BLUE, LINECOLOR_YELLOW); // AAS_PermanentLine(lreach->start, lreach->end, 1); #endif lreach->traveltype = TRAVEL_FUNCBOB; lreach->traveltype |= AAS_TravelFlagsForTeam(ent); lreach->traveltime = aassettings.rs_funcbob; reach_funcbob++; lreach->next = areareachability[startreach->areanum]; areareachability[startreach->areanum] = lreach; // } //end for } //end for for (startreach = firststartreach; startreach; startreach = nextstartreach) { nextstartreach = startreach->next; AAS_FreeReachability(startreach); } //end for for (endreach = firstendreach; endreach; endreach = nextendreach) { nextendreach = endreach->next; AAS_FreeReachability(endreach); } //end for //only go up with func_bobbing entities that go up and down if (!(spawnflags & 1) && !(spawnflags & 2)) break; } //end for } //end for } //end of the function AAS_Reachability_FuncBobbing //=========================================================================== // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== void AAS_Reachability_JumpPad(void) { int face2num, i, ret, area2num, visualize, ent, bot_visualizejumppads; //int modelnum, ent2; //float dist, time, height, gravity, forward; float speed, zvel, hordist; aas_face_t *face2; aas_area_t *area2; aas_lreachability_t *lreach; vec3_t areastart, facecenter, dir, cmdmove; vec3_t velocity, absmins, absmaxs; //vec3_t origin, ent2origin, angles, teststart; aas_clientmove_t move; //aas_trace_t trace; aas_link_t *areas, *link; //char target[MAX_EPAIRKEY], targetname[MAX_EPAIRKEY], model[MAX_EPAIRKEY]; char classname[MAX_EPAIRKEY]; #ifdef BSPC bot_visualizejumppads = 0; #else bot_visualizejumppads = LibVarValue("bot_visualizejumppads", "0"); #endif for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent)) { if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue; if (strcmp(classname, "trigger_push")) continue; // if (!AAS_GetJumpPadInfo(ent, areastart, absmins, absmaxs, velocity)) continue; /* // AAS_FloatForBSPEpairKey(ent, "speed", &speed); if (!speed) speed = 1000; // AAS_VectorForBSPEpairKey(ent, "angles", angles); // AAS_SetMovedir(angles, velocity); // VectorScale(velocity, speed, velocity); VectorClear(angles); //get the mins, maxs and origin of the model AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY); if (model[0]) modelnum = atoi(model+1); else modelnum = 0; AAS_BSPModelMinsMaxsOrigin(modelnum, angles, absmins, absmaxs, origin); VectorAdd(origin, absmins, absmins); VectorAdd(origin, absmaxs, absmaxs); // #ifdef REACH_DEBUG botimport.Print(PRT_MESSAGE, "absmins = %f %f %f\n", absmins[0], absmins[1], absmins[2]); botimport.Print(PRT_MESSAGE, "absmaxs = %f %f %f\n", absmaxs[0], absmaxs[1], absmaxs[2]); #endif REACH_DEBUG VectorAdd(absmins, absmaxs, origin); VectorScale (origin, 0.5, origin); //get the start areas VectorCopy(origin, teststart); teststart[2] += 64; trace = AAS_TraceClientBBox(teststart, origin, PRESENCE_CROUCH, -1); if (trace.startsolid) { botimport.Print(PRT_MESSAGE, "trigger_push start solid\n"); VectorCopy(origin, areastart); } //end if else { VectorCopy(trace.endpos, areastart); } //end else areastart[2] += 0.125; // //AAS_DrawPermanentCross(origin, 4, 4); //get the target entity AAS_ValueForBSPEpairKey(ent, "target", target, MAX_EPAIRKEY); for (ent2 = AAS_NextBSPEntity(0); ent2; ent2 = AAS_NextBSPEntity(ent2)) { if (!AAS_ValueForBSPEpairKey(ent2, "targetname", targetname, MAX_EPAIRKEY)) continue; if (!strcmp(targetname, target)) break; } //end for if (!ent2) { botimport.Print(PRT_MESSAGE, "trigger_push without target entity %s\n", target); continue; } //end if AAS_VectorForBSPEpairKey(ent2, "origin", ent2origin); // height = ent2origin[2] - origin[2]; gravity = aassettings.sv_gravity; time = sqrt( height / ( 0.5 * gravity ) ); if (!time) { botimport.Print(PRT_MESSAGE, "trigger_push without time\n"); continue; } //end if // set s.origin2 to the push velocity VectorSubtract ( ent2origin, origin, velocity); dist = VectorNormalize( velocity); forward = dist / time; //FIXME: why multiply by 1.1 forward *= 1.1; VectorScale(velocity, forward, velocity); velocity[2] = time * gravity; */ //get the areas the jump pad brush is in areas = AAS_LinkEntityClientBBox(absmins, absmaxs, -1, PRESENCE_CROUCH); /* for (link = areas; link; link = link->next_area) { if (link->areanum == 563) { ret = qfalse; } } */ for (link = areas; link; link = link->next_area) { if (AAS_AreaJumpPad(link->areanum)) break; } //end for if (!link) { botimport.Print(PRT_MESSAGE, "trigger_push not in any jump pad area\n"); AAS_UnlinkFromAreas(areas); continue; } //end if // botimport.Print(PRT_MESSAGE, "found a trigger_push with velocity %f %f %f\n", velocity[0], velocity[1], velocity[2]); //if there is a horizontal velocity check for a reachability without air control if (velocity[0] || velocity[1]) { VectorSet(cmdmove, 0, 0, 0); //VectorCopy(velocity, cmdmove); //cmdmove[2] = 0; Com_Memset(&move, 0, sizeof(aas_clientmove_t)); area2num = 0; for (i = 0; i < 20; i++) { AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qfalse, velocity, cmdmove, 0, 30, 0.1f, SE_HITGROUND|SE_ENTERWATER|SE_ENTERSLIME| SE_ENTERLAVA|SE_HITGROUNDDAMAGE|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER, 0, bot_visualizejumppads); area2num = move.endarea; for (link = areas; link; link = link->next_area) { if (!AAS_AreaJumpPad(link->areanum)) continue; if (link->areanum == area2num) break; } //end if if (!link) break; VectorCopy(move.endpos, areastart); VectorCopy(move.velocity, velocity); } //end for if (area2num && i < 20) { for (link = areas; link; link = link->next_area) { if (!AAS_AreaJumpPad(link->areanum)) continue; if (AAS_ReachabilityExists(link->areanum, area2num)) continue; //create a rocket or bfg jump reachability from area1 to area2 lreach = AAS_AllocReachability(); if (!lreach) { AAS_UnlinkFromAreas(areas); return; } //end if lreach->areanum = area2num; //NOTE: the facenum is the Z velocity lreach->facenum = velocity[2]; //NOTE: the edgenum is the horizontal velocity lreach->edgenum = sqrt(velocity[0] * velocity[0] + velocity[1] * velocity[1]); VectorCopy(areastart, lreach->start); VectorCopy(move.endpos, lreach->end); lreach->traveltype = TRAVEL_JUMPPAD; lreach->traveltype |= AAS_TravelFlagsForTeam(ent); lreach->traveltime = aassettings.rs_jumppad; lreach->next = areareachability[link->areanum]; areareachability[link->areanum] = lreach; // reach_jumppad++; } //end for } //end if } //end if // if (fabs(velocity[0]) > 100 || fabs(velocity[1]) > 100) continue; //check for areas we can reach with air control for (area2num = 1; area2num < aasworld.numareas; area2num++) { visualize = qfalse; /* if (area2num == 3568) { for (link = areas; link; link = link->next_area) { if (link->areanum == 3380) { visualize = qtrue; botimport.Print(PRT_MESSAGE, "bah\n"); } //end if } //end for } //end if*/ //never try to go back to one of the original jumppad areas //and don't create reachabilities if they already exist for (link = areas; link; link = link->next_area) { if (AAS_ReachabilityExists(link->areanum, area2num)) break; if (AAS_AreaJumpPad(link->areanum)) { if (link->areanum == area2num) break; } //end if } //end if if (link) continue; // area2 = &aasworld.areas[area2num]; for (i = 0; i < area2->numfaces; i++) { face2num = aasworld.faceindex[area2->firstface + i]; face2 = &aasworld.faces[abs(face2num)]; //if it is not a ground face if (!(face2->faceflags & FACE_GROUND)) continue; //get the center of the face AAS_FaceCenter(face2num, facecenter); //only go higher up if (facecenter[2] < areastart[2]) continue; //get the jumppad jump z velocity zvel = velocity[2]; //get the horizontal speed for the jump, if it isn't possible to calculate this //speed ret = AAS_HorizontalVelocityForJump(zvel, areastart, facecenter, &speed); if (ret && speed < 150) { //direction towards the face center VectorSubtract(facecenter, areastart, dir); dir[2] = 0; hordist = VectorNormalize(dir); //if (hordist < 1.6 * facecenter[2] - areastart[2]) { //get command movement VectorScale(dir, speed, cmdmove); // AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qfalse, velocity, cmdmove, 30, 30, 0.1f, SE_ENTERWATER|SE_ENTERSLIME| SE_ENTERLAVA|SE_HITGROUNDDAMAGE| SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER|SE_HITGROUNDAREA, area2num, visualize); //if prediction time wasn't enough to fully predict the movement //don't enter slime or lava and don't fall from too high if (move.frames < 30 && !(move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE)) && (move.stopevent & (SE_HITGROUNDAREA|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER))) { //never go back to the same jumppad for (link = areas; link; link = link->next_area) { if (link->areanum == move.endarea) break; } if (!link) { for (link = areas; link; link = link->next_area) { if (!AAS_AreaJumpPad(link->areanum)) continue; if (AAS_ReachabilityExists(link->areanum, area2num)) continue; //create a jumppad reachability from area1 to area2 lreach = AAS_AllocReachability(); if (!lreach) { AAS_UnlinkFromAreas(areas); return; } //end if lreach->areanum = move.endarea; //NOTE: the facenum is the Z velocity lreach->facenum = velocity[2]; //NOTE: the edgenum is the horizontal velocity lreach->edgenum = sqrt(cmdmove[0] * cmdmove[0] + cmdmove[1] * cmdmove[1]); VectorCopy(areastart, lreach->start); VectorCopy(facecenter, lreach->end); lreach->traveltype = TRAVEL_JUMPPAD; lreach->traveltype |= AAS_TravelFlagsForTeam(ent); lreach->traveltime = aassettings.rs_aircontrolledjumppad; lreach->next = areareachability[link->areanum]; areareachability[link->areanum] = lreach; // reach_jumppad++; } //end for } } //end if } //end if } //end for } //end for } //end for AAS_UnlinkFromAreas(areas); } //end for } //end of the function AAS_Reachability_JumpPad //=========================================================================== // never point at ground faces // always a higher and pretty far area // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== int AAS_Reachability_Grapple(int area1num, int area2num) { int face2num, i, j, areanum, numareas, areas[20]; float mingrappleangle, z, hordist; bsp_trace_t bsptrace; aas_trace_t trace; aas_face_t *face2; aas_area_t *area1, *area2; aas_lreachability_t *lreach; vec3_t areastart, facecenter, start, end, dir, down = {0, 0, -1}; vec_t *v; //only grapple when on the ground or swimming if (!AAS_AreaGrounded(area1num) && !AAS_AreaSwim(area1num)) return qfalse; //don't grapple from a crouch area if (!(AAS_AreaPresenceType(area1num) & PRESENCE_NORMAL)) return qfalse; //NOTE: disabled area swim it doesn't work right if (AAS_AreaSwim(area1num)) return qfalse; // area1 = &aasworld.areas[area1num]; area2 = &aasworld.areas[area2num]; //don't grapple towards way lower areas if (area2->maxs[2] < area1->mins[2]) return qfalse; // VectorCopy(aasworld.areas[area1num].center, start); //if not a swim area if (!AAS_AreaSwim(area1num)) { if (!AAS_PointAreaNum(start)) Log_Write("area %d center %f %f %f in solid?\r\n", area1num, start[0], start[1], start[2]); VectorCopy(start, end); end[2] -= 1000; trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1); if (trace.startsolid) return qfalse; VectorCopy(trace.endpos, areastart); } //end if else { if (!(AAS_PointContents(start) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER))) return qfalse; } //end else // //start is now the start point // for (i = 0; i < area2->numfaces; i++) { face2num = aasworld.faceindex[area2->firstface + i]; face2 = &aasworld.faces[abs(face2num)]; //if it is not a solid face if (!(face2->faceflags & FACE_SOLID)) continue; //direction towards the first vertex of the face v = aasworld.vertexes[aasworld.edges[abs(aasworld.edgeindex[face2->firstedge])].v[0]]; VectorSubtract(v, areastart, dir); //if the face plane is facing away if (DotProduct(aasworld.planes[face2->planenum].normal, dir) > 0) continue; //get the center of the face AAS_FaceCenter(face2num, facecenter); //only go higher up with the grapple if (facecenter[2] < areastart[2] + 64) continue; //only use vertical faces or downward facing faces if (DotProduct(aasworld.planes[face2->planenum].normal, down) < 0) continue; //direction towards the face center VectorSubtract(facecenter, areastart, dir); // z = dir[2]; dir[2] = 0; hordist = VectorLength(dir); if (!hordist) continue; //if too far if (hordist > 2000) continue; //check the minimal angle of the movement mingrappleangle = 15; //15 degrees if (z / hordist < tan(2 * M_PI * mingrappleangle / 360)) continue; // VectorCopy(facecenter, start); VectorMA(facecenter, -500, aasworld.planes[face2->planenum].normal, end); // bsptrace = AAS_Trace(start, NULL, NULL, end, 0, CONTENTS_SOLID); //the grapple won't stick to the sky and the grapple point should be near the AAS wall if ((bsptrace.surface.flags & SURF_SKY) || (bsptrace.fraction * 500 > 32)) continue; //trace a full bounding box from the area center on the ground to //the center of the face VectorSubtract(facecenter, areastart, dir); VectorNormalize(dir); VectorMA(areastart, 4, dir, start); VectorCopy(bsptrace.endpos, end); trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1); VectorSubtract(trace.endpos, facecenter, dir); if (VectorLength(dir) > 24) continue; // VectorCopy(trace.endpos, start); VectorCopy(trace.endpos, end); end[2] -= AAS_FallDamageDistance(); trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, -1); if (trace.fraction >= 1) continue; //area to end in areanum = AAS_PointAreaNum(trace.endpos); //if not in lava or slime if (aasworld.areasettings[areanum].contents & (AREACONTENTS_SLIME|AREACONTENTS_LAVA)) { continue; } //end if //do not go the the source area if (areanum == area1num) continue; //don't create reachabilities if they already exist if (AAS_ReachabilityExists(area1num, areanum)) continue; //only end in areas we can stand if (!AAS_AreaGrounded(areanum)) continue; //never go through cluster portals!! numareas = AAS_TraceAreas(areastart, bsptrace.endpos, areas, NULL, 20); if (numareas >= 20) continue; for (j = 0; j < numareas; j++) { if (aasworld.areasettings[areas[j]].contents & AREACONTENTS_CLUSTERPORTAL) break; } //end for if (j < numareas) continue; //create a new reachability link lreach = AAS_AllocReachability(); if (!lreach) return qfalse; lreach->areanum = areanum; lreach->facenum = face2num; lreach->edgenum = 0; VectorCopy(areastart, lreach->start); //VectorCopy(facecenter, lreach->end); VectorCopy(bsptrace.endpos, lreach->end); lreach->traveltype = TRAVEL_GRAPPLEHOOK; VectorSubtract(lreach->end, lreach->start, dir); lreach->traveltime = aassettings.rs_startgrapple + VectorLength(dir) * 0.25; lreach->next = areareachability[area1num]; areareachability[area1num] = lreach; // reach_grapple++; } //end for // return qfalse; } //end of the function AAS_Reachability_Grapple //=========================================================================== // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== void AAS_SetWeaponJumpAreaFlags(void) { int ent, i; vec3_t mins = {-15, -15, -15}, maxs = {15, 15, 15}; vec3_t origin; int areanum, weaponjumpareas, spawnflags; char classname[MAX_EPAIRKEY]; weaponjumpareas = 0; for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent)) { if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue; if ( !strcmp(classname, "item_armor_body") || !strcmp(classname, "item_armor_combat") || !strcmp(classname, "item_health_mega") || !strcmp(classname, "weapon_grenadelauncher") || !strcmp(classname, "weapon_rocketlauncher") || !strcmp(classname, "weapon_lightning") || !strcmp(classname, "weapon_plasmagun") || !strcmp(classname, "weapon_railgun") || !strcmp(classname, "weapon_bfg") || !strcmp(classname, "item_quad") || !strcmp(classname, "item_regen") || !strcmp(classname, "item_invulnerability")) { if (AAS_VectorForBSPEpairKey(ent, "origin", origin)) { spawnflags = 0; AAS_IntForBSPEpairKey(ent, "spawnflags", &spawnflags); //if not a stationary item if (!(spawnflags & 1)) { if (!AAS_DropToFloor(origin, mins, maxs)) { botimport.Print(PRT_MESSAGE, "%s in solid at (%1.1f %1.1f %1.1f)\n", classname, origin[0], origin[1], origin[2]); } //end if } //end if //areanum = AAS_PointAreaNum(origin); areanum = AAS_BestReachableArea(origin, mins, maxs, origin); //the bot may rocket jump towards this area aasworld.areasettings[areanum].areaflags |= AREA_WEAPONJUMP; // //if (!AAS_AreaGrounded(areanum)) // botimport.Print(PRT_MESSAGE, "area not grounded\n"); // weaponjumpareas++; } //end if } //end if } //end for for (i = 1; i < aasworld.numareas; i++) { if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD) { aasworld.areasettings[i].areaflags |= AREA_WEAPONJUMP; weaponjumpareas++; } //end if } //end for botimport.Print(PRT_MESSAGE, "%d weapon jump areas\n", weaponjumpareas); } //end of the function AAS_SetWeaponJumpAreaFlags //=========================================================================== // create a possible weapon jump reachability from area1 to area2 // // check if there's a cool item in the second area // check if area1 is lower than area2 // check if the bot can rocketjump from area1 to area2 // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== int AAS_Reachability_WeaponJump(int area1num, int area2num) { int face2num, i, n, ret, visualize; float speed, zvel, hordist; aas_face_t *face2; aas_area_t *area1, *area2; aas_lreachability_t *lreach; vec3_t areastart, facecenter, start, end, dir, cmdmove;// teststart; vec3_t velocity; aas_clientmove_t move; aas_trace_t trace; visualize = qfalse; // if (area1num == 4436 && area2num == 4318) // { // visualize = qtrue; // } if (!AAS_AreaGrounded(area1num) || AAS_AreaSwim(area1num)) return qfalse; if (!AAS_AreaGrounded(area2num)) return qfalse; //NOTE: only weapon jump towards areas with an interesting item in it?? if (!(aasworld.areasettings[area2num].areaflags & AREA_WEAPONJUMP)) return qfalse; // area1 = &aasworld.areas[area1num]; area2 = &aasworld.areas[area2num]; //don't weapon jump towards way lower areas if (area2->maxs[2] < area1->mins[2]) return qfalse; // VectorCopy(aasworld.areas[area1num].center, start); //if not a swim area if (!AAS_PointAreaNum(start)) Log_Write("area %d center %f %f %f in solid?\r\n", area1num, start[0], start[1], start[2]); VectorCopy(start, end); end[2] -= 1000; trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1); if (trace.startsolid) return qfalse; VectorCopy(trace.endpos, areastart); // //areastart is now the start point // for (i = 0; i < area2->numfaces; i++) { face2num = aasworld.faceindex[area2->firstface + i]; face2 = &aasworld.faces[abs(face2num)]; //if it is not a solid face if (!(face2->faceflags & FACE_GROUND)) continue; //get the center of the face AAS_FaceCenter(face2num, facecenter); //only go higher up with weapon jumps if (facecenter[2] < areastart[2] + 64) continue; //NOTE: set to 2 to allow bfg jump reachabilities for (n = 0; n < 1/*2*/; n++) { //get the rocket jump z velocity if (n) zvel = AAS_BFGJumpZVelocity(areastart); else zvel = AAS_RocketJumpZVelocity(areastart); //get the horizontal speed for the jump, if it isn't possible to calculate this //speed (the jump is not possible) then there's no jump reachability created ret = AAS_HorizontalVelocityForJump(zvel, areastart, facecenter, &speed); if (ret && speed < 300) { //direction towards the face center VectorSubtract(facecenter, areastart, dir); dir[2] = 0; hordist = VectorNormalize(dir); //if (hordist < 1.6 * (facecenter[2] - areastart[2])) { //get command movement VectorScale(dir, speed, cmdmove); VectorSet(velocity, 0, 0, zvel); /* //get command movement VectorScale(dir, speed, velocity); velocity[2] = zvel; VectorSet(cmdmove, 0, 0, 0); */ // AAS_PredictClientMovement(&move, -1, areastart, PRESENCE_NORMAL, qtrue, velocity, cmdmove, 30, 30, 0.1f, SE_ENTERWATER|SE_ENTERSLIME| SE_ENTERLAVA|SE_HITGROUNDDAMAGE| SE_TOUCHJUMPPAD|SE_HITGROUND|SE_HITGROUNDAREA, area2num, visualize); //if prediction time wasn't enough to fully predict the movement //don't enter slime or lava and don't fall from too high if (move.frames < 30 && !(move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE)) && (move.stopevent & (SE_HITGROUNDAREA|SE_TOUCHJUMPPAD))) { //create a rocket or bfg jump reachability from area1 to area2 lreach = AAS_AllocReachability(); if (!lreach) return qfalse; lreach->areanum = area2num; lreach->facenum = 0; lreach->edgenum = 0; VectorCopy(areastart, lreach->start); VectorCopy(facecenter, lreach->end); if (n) { lreach->traveltype = TRAVEL_BFGJUMP; lreach->traveltime = aassettings.rs_bfgjump; } //end if else { lreach->traveltype = TRAVEL_ROCKETJUMP; lreach->traveltime = aassettings.rs_rocketjump; } //end else lreach->next = areareachability[area1num]; areareachability[area1num] = lreach; // reach_rocketjump++; return qtrue; } //end if } //end if } //end if } //end for } //end for // return qfalse; } //end of the function AAS_Reachability_WeaponJump //=========================================================================== // calculates additional walk off ledge reachabilities for the given area // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== void AAS_Reachability_WalkOffLedge(int areanum) { int i, j, k, l, m, n, p, areas[10], numareas; int face1num, face2num, face3num, edge1num, edge2num, edge3num; int otherareanum, gap, reachareanum, side; aas_area_t *area, *area2; aas_face_t *face1, *face2, *face3; aas_edge_t *edge; aas_plane_t *plane; vec_t *v1, *v2; vec3_t sharededgevec, mid, dir, testend; aas_lreachability_t *lreach; aas_trace_t trace; if (!AAS_AreaGrounded(areanum) || AAS_AreaSwim(areanum)) return; // area = &aasworld.areas[areanum]; // for (i = 0; i < area->numfaces; i++) { face1num = aasworld.faceindex[area->firstface + i]; face1 = &aasworld.faces[abs(face1num)]; //face 1 must be a ground face if (!(face1->faceflags & FACE_GROUND)) continue; //go through all the edges of this ground face for (k = 0; k < face1->numedges; k++) { edge1num = aasworld.edgeindex[face1->firstedge + k]; //find another not ground face using this same edge for (j = 0; j < area->numfaces; j++) { face2num = aasworld.faceindex[area->firstface + j]; face2 = &aasworld.faces[abs(face2num)]; //face 2 may not be a ground face if (face2->faceflags & FACE_GROUND) continue; //compare all the edges for (l = 0; l < face2->numedges; l++) { edge2num = aasworld.edgeindex[face2->firstedge + l]; if (abs(edge1num) == abs(edge2num)) { //get the area at the other side of the face if (face2->frontarea == areanum) otherareanum = face2->backarea; else otherareanum = face2->frontarea; // area2 = &aasworld.areas[otherareanum]; //if the other area is grounded! if (aasworld.areasettings[otherareanum].areaflags & AREA_GROUNDED) { //check for a possible gap gap = qfalse; for (n = 0; n < area2->numfaces; n++) { face3num = aasworld.faceindex[area2->firstface + n]; //may not be the shared face of the two areas if (abs(face3num) == abs(face2num)) continue; // face3 = &aasworld.faces[abs(face3num)]; //find an edge shared by all three faces for (m = 0; m < face3->numedges; m++) { edge3num = aasworld.edgeindex[face3->firstedge + m]; //but the edge should be shared by all three faces if (abs(edge3num) == abs(edge1num)) { if (!(face3->faceflags & FACE_SOLID)) { gap = qtrue; break; } //end if // if (face3->faceflags & FACE_GROUND) { gap = qfalse; break; } //end if //FIXME: there are more situations to be handled gap = qtrue; break; } //end if } //end for if (m < face3->numedges) break; } //end for if (!gap) break; } //end if //check for a walk off ledge reachability edge = &aasworld.edges[abs(edge1num)]; side = edge1num < 0; // v1 = aasworld.vertexes[edge->v[side]]; v2 = aasworld.vertexes[edge->v[!side]]; // plane = &aasworld.planes[face1->planenum]; //get the points really into the areas VectorSubtract(v2, v1, sharededgevec); CrossProduct(plane->normal, sharededgevec, dir); VectorNormalize(dir); // VectorAdd(v1, v2, mid); VectorScale(mid, 0.5, mid); VectorMA(mid, 8, dir, mid); // VectorCopy(mid, testend); testend[2] -= 1000; trace = AAS_TraceClientBBox(mid, testend, PRESENCE_CROUCH, -1); // if (trace.startsolid) { //Log_Write("area %d: trace.startsolid\r\n", areanum); break; } //end if reachareanum = AAS_PointAreaNum(trace.endpos); if (reachareanum == areanum) { //Log_Write("area %d: same area\r\n", areanum); break; } //end if if (AAS_ReachabilityExists(areanum, reachareanum)) { //Log_Write("area %d: reachability already exists\r\n", areanum); break; } //end if if (!AAS_AreaGrounded(reachareanum) && !AAS_AreaSwim(reachareanum)) { //Log_Write("area %d, reach area %d: not grounded and not swim\r\n", areanum, reachareanum); break; } //end if // if (aasworld.areasettings[reachareanum].contents & (AREACONTENTS_SLIME | AREACONTENTS_LAVA)) { //Log_Write("area %d, reach area %d: lava or slime\r\n", areanum, reachareanum); break; } //end if //if not going through a cluster portal numareas = AAS_TraceAreas(mid, testend, areas, NULL, sizeof(areas) / sizeof(int)); for (p = 0; p < numareas; p++) if (AAS_AreaClusterPortal(areas[p])) break; if (p < numareas) break; // if a maximum fall height is set and the bot would fall down further if (aassettings.rs_maxfallheight && fabs(mid[2] - trace.endpos[2]) > aassettings.rs_maxfallheight) break; // lreach = AAS_AllocReachability(); if (!lreach) break; lreach->areanum = reachareanum; lreach->facenum = 0; lreach->edgenum = edge1num; VectorCopy(mid, lreach->start); VectorCopy(trace.endpos, lreach->end); lreach->traveltype = TRAVEL_WALKOFFLEDGE; lreach->traveltime = aassettings.rs_startwalkoffledge + fabs(mid[2] - trace.endpos[2]) * 50 / aassettings.phys_gravity; if (!AAS_AreaSwim(reachareanum) && !AAS_AreaJumpPad(reachareanum)) { if (AAS_FallDelta(mid[2] - trace.endpos[2]) > aassettings.phys_falldelta5) { lreach->traveltime += aassettings.rs_falldamage5; } //end if else if (AAS_FallDelta(mid[2] - trace.endpos[2]) > aassettings.phys_falldelta10) { lreach->traveltime += aassettings.rs_falldamage10; } //end if } //end if lreach->next = areareachability[areanum]; areareachability[areanum] = lreach; //we've got another walk off ledge reachability reach_walkoffledge++; } //end if } //end for } //end for } //end for } //end for } //end of the function AAS_Reachability_WalkOffLedge //=========================================================================== // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== void AAS_StoreReachability(void) { int i; aas_areasettings_t *areasettings; aas_lreachability_t *lreach; aas_reachability_t *reach; if (aasworld.reachability) FreeMemory(aasworld.reachability); aasworld.reachability = (aas_reachability_t *) GetClearedMemory((numlreachabilities + 10) * sizeof(aas_reachability_t)); aasworld.reachabilitysize = 1; for (i = 0; i < aasworld.numareas; i++) { areasettings = &aasworld.areasettings[i]; areasettings->firstreachablearea = aasworld.reachabilitysize; areasettings->numreachableareas = 0; for (lreach = areareachability[i]; lreach; lreach = lreach->next) { reach = &aasworld.reachability[areasettings->firstreachablearea + areasettings->numreachableareas]; reach->areanum = lreach->areanum; reach->facenum = lreach->facenum; reach->edgenum = lreach->edgenum; VectorCopy(lreach->start, reach->start); VectorCopy(lreach->end, reach->end); reach->traveltype = lreach->traveltype; reach->traveltime = lreach->traveltime; // areasettings->numreachableareas++; } //end for aasworld.reachabilitysize += areasettings->numreachableareas; } //end for } //end of the function AAS_StoreReachability //=========================================================================== // // TRAVEL_WALK 100% equal floor height + steps // TRAVEL_CROUCH 100% // TRAVEL_BARRIERJUMP 100% // TRAVEL_JUMP 80% // TRAVEL_LADDER 100% + fall down from ladder + jump up to ladder // TRAVEL_WALKOFFLEDGE 90% walk off very steep walls? // TRAVEL_SWIM 100% // TRAVEL_WATERJUMP 100% // TRAVEL_TELEPORT 100% // TRAVEL_ELEVATOR 100% // TRAVEL_GRAPPLEHOOK 100% // TRAVEL_DOUBLEJUMP 0% // TRAVEL_RAMPJUMP 0% // TRAVEL_STRAFEJUMP 0% // TRAVEL_ROCKETJUMP 100% (currently limited towards areas with items) // TRAVEL_BFGJUMP 0% (currently disabled) // TRAVEL_JUMPPAD 100% // TRAVEL_FUNCBOB 100% // // Parameter: - // Returns: true if NOT finished // Changes Globals: - //=========================================================================== int AAS_ContinueInitReachability(float time) { int i, j, todo, start_time; static float framereachability, reachability_delay; static int lastpercentage; if (!aasworld.loaded) return qfalse; //if reachability is calculated for all areas if (aasworld.numreachabilityareas >= aasworld.numareas + 2) return qfalse; //if starting with area 1 (area 0 is a dummy) if (aasworld.numreachabilityareas == 1) { botimport.Print(PRT_MESSAGE, "calculating reachability...\n"); lastpercentage = 0; framereachability = 2000; reachability_delay = 1000; } //end if //number of areas to calculate reachability for this cycle todo = aasworld.numreachabilityareas + (int) framereachability; start_time = Sys_MilliSeconds(); //loop over the areas for (i = aasworld.numreachabilityareas; i < aasworld.numareas && i < todo; i++) { aasworld.numreachabilityareas++; //only create jumppad reachabilities from jumppad areas if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD) { continue; } //end if //loop over the areas for (j = 1; j < aasworld.numareas; j++) { if (i == j) continue; //never create reachabilities from teleporter or jumppad areas to regular areas if (aasworld.areasettings[i].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD)) { if (!(aasworld.areasettings[j].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD))) { continue; } //end if } //end if //if there already is a reachability link from area i to j if (AAS_ReachabilityExists(i, j)) continue; //check for a swim reachability if (AAS_Reachability_Swim(i, j)) continue; //check for a simple walk on equal floor height reachability if (AAS_Reachability_EqualFloorHeight(i, j)) continue; //check for step, barrier, waterjump and walk off ledge reachabilities if (AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(i, j)) continue; //check for ladder reachabilities if (AAS_Reachability_Ladder(i, j)) continue; //check for a jump reachability if (AAS_Reachability_Jump(i, j)) continue; } //end for //never create these reachabilities from teleporter or jumppad areas if (aasworld.areasettings[i].contents & (AREACONTENTS_TELEPORTER|AREACONTENTS_JUMPPAD)) { continue; } //end if //loop over the areas for (j = 1; j < aasworld.numareas; j++) { if (i == j) continue; // if (AAS_ReachabilityExists(i, j)) continue; //check for a grapple hook reachability if (calcgrapplereach) AAS_Reachability_Grapple(i, j); //check for a weapon jump reachability AAS_Reachability_WeaponJump(i, j); } //end for //if the calculation took more time than the max reachability delay if (Sys_MilliSeconds() - start_time > (int) reachability_delay) break; // if (aasworld.numreachabilityareas * 1000 / aasworld.numareas > lastpercentage) break; } //end for // if (aasworld.numreachabilityareas == aasworld.numareas) { botimport.Print(PRT_MESSAGE, "\r%6.1f%%", (float) 100.0); botimport.Print(PRT_MESSAGE, "\nplease wait while storing reachability...\n"); aasworld.numreachabilityareas++; } //end if //if this is the last step in the reachability calculations else if (aasworld.numreachabilityareas == aasworld.numareas + 1) { //create additional walk off ledge reachabilities for every area for (i = 1; i < aasworld.numareas; i++) { //only create jumppad reachabilities from jumppad areas if (aasworld.areasettings[i].contents & AREACONTENTS_JUMPPAD) { continue; } //end if AAS_Reachability_WalkOffLedge(i); } //end for //create jump pad reachabilities AAS_Reachability_JumpPad(); //create teleporter reachabilities AAS_Reachability_Teleport(); //create elevator (func_plat) reachabilities AAS_Reachability_Elevator(); //create func_bobbing reachabilities AAS_Reachability_FuncBobbing(); // #ifdef DEBUG botimport.Print(PRT_MESSAGE, "%6d reach swim\n", reach_swim); botimport.Print(PRT_MESSAGE, "%6d reach equal floor\n", reach_equalfloor); botimport.Print(PRT_MESSAGE, "%6d reach step\n", reach_step); botimport.Print(PRT_MESSAGE, "%6d reach barrier\n", reach_barrier); botimport.Print(PRT_MESSAGE, "%6d reach waterjump\n", reach_waterjump); botimport.Print(PRT_MESSAGE, "%6d reach walkoffledge\n", reach_walkoffledge); botimport.Print(PRT_MESSAGE, "%6d reach jump\n", reach_jump); botimport.Print(PRT_MESSAGE, "%6d reach ladder\n", reach_ladder); botimport.Print(PRT_MESSAGE, "%6d reach walk\n", reach_walk); botimport.Print(PRT_MESSAGE, "%6d reach teleport\n", reach_teleport); botimport.Print(PRT_MESSAGE, "%6d reach funcbob\n", reach_funcbob); botimport.Print(PRT_MESSAGE, "%6d reach elevator\n", reach_elevator); botimport.Print(PRT_MESSAGE, "%6d reach grapple\n", reach_grapple); botimport.Print(PRT_MESSAGE, "%6d reach rocketjump\n", reach_rocketjump); botimport.Print(PRT_MESSAGE, "%6d reach jumppad\n", reach_jumppad); #endif //*/ //store all the reachabilities AAS_StoreReachability(); //free the reachability link heap AAS_ShutDownReachabilityHeap(); // FreeMemory(areareachability); // aasworld.numreachabilityareas++; // botimport.Print(PRT_MESSAGE, "calculating clusters...\n"); } //end if else { lastpercentage = aasworld.numreachabilityareas * 1000 / aasworld.numareas; botimport.Print(PRT_MESSAGE, "\r%6.1f%%", (float) lastpercentage / 10); } //end else //not yet finished return qtrue; } //end of the function AAS_ContinueInitReachability //=========================================================================== // // Parameter: - // Returns: - // Changes Globals: - //=========================================================================== void AAS_InitReachability(void) { if (!aasworld.loaded) return; if (aasworld.reachabilitysize) { #ifndef BSPC if (!((int)LibVarGetValue("forcereachability"))) { aasworld.numreachabilityareas = aasworld.numareas + 2; return; } //end if #else aasworld.numreachabilityareas = aasworld.numareas + 2; return; #endif //BSPC } //end if #ifndef BSPC calcgrapplereach = LibVarGetValue("grapplereach"); #endif aasworld.savefile = qtrue; //start with area 1 because area zero is a dummy aasworld.numreachabilityareas = 1; ////aasworld.numreachabilityareas = aasworld.numareas + 1; //only calculate entity reachabilities //setup the heap with reachability links AAS_SetupReachabilityHeap(); //allocate area reachability link array areareachability = (aas_lreachability_t **) GetClearedMemory( aasworld.numareas * sizeof(aas_lreachability_t *)); // AAS_SetWeaponJumpAreaFlags(); } //end of the function AAS_InitReachable