be_interface.c File Reference

#include "../game/q_shared.h"
#include "l_memory.h"
#include "l_log.h"
#include "l_libvar.h"
#include "l_script.h"
#include "l_precomp.h"
#include "l_struct.h"
#include "aasfile.h"
#include "../game/botlib.h"
#include "../game/be_aas.h"
#include "be_aas_funcs.h"
#include "be_aas_def.h"
#include "be_interface.h"
#include "../game/be_ea.h"
#include "be_ai_weight.h"
#include "../game/be_ai_goal.h"
#include "../game/be_ai_move.h"
#include "../game/be_ai_weap.h"
#include "../game/be_ai_chat.h"
#include "../game/be_ai_char.h"
#include "../game/be_ai_gen.h"

Include dependency graph for be_interface.c:

Go to the source code of this file.

Functions
void	AAS_FloodAreas (vec3_t origin)
int	AAS_PointLight (vec3_t origin, int *red, int *green, int *blue)
int	AAS_Reachability_WeaponJump (int area1num, int area2num)
void	AAS_TestMovementPrediction (int entnum, vec3_t origin, vec3_t dir)
int	AAS_TraceAreas (vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas)
int	BotExportTest (int parm0, char *parm1, vec3_t parm2, vec3_t parm3)
int	BotFuzzyPointReachabilityArea (vec3_t origin)
float	BotGapDistance (vec3_t origin, vec3_t hordir, int entnum)
int	BotGetReachabilityToGoal (vec3_t origin, int areanum, int lastgoalareanum, int lastareanum, int *avoidreach, float *avoidreachtimes, int *avoidreachtries, bot_goal_t *goal, int travelflags, int movetravelflags, struct bot_avoidspot_s *avoidspots, int numavoidspots, int *flags)
qboolean	BotLibSetup (char *str)
void	ElevatorBottomCenter (aas_reachability_t *reach, vec3_t bottomcenter)
int	Export_BotLibLoadMap (const char *mapname)
int	Export_BotLibSetup (void)
int	Export_BotLibShutdown (void)
int	Export_BotLibStartFrame (float time)
int	Export_BotLibUpdateEntity (int ent, bot_entitystate_t *state)
int	Export_BotLibVarGet (char *var_name, char *value, int size)
int	Export_BotLibVarSet (char *var_name, char *value)
botlib_export_t *	GetBotLibAPI (int apiVersion, botlib_import_t *import)
void	Init_AAS_Export (aas_export_t *aas)
void	Init_AI_Export (ai_export_t *ai)
void	Init_EA_Export (ea_export_t *ea)
int	Sys_MilliSeconds (void)
qboolean	ValidClientNumber (int num, char *str)
qboolean	ValidEntityNumber (int num, char *str)
Variables
botlib_export_t	be_botlib_export
int	bot_developer
botlib_import_t	botimport
botlib_globals_t	botlibglobals
int	botlibsetup = qfalse

---

Function Documentation

void AAS_FloodAreas (  vec3_t  origin  )

Definition at line 769 of file be_aas_debug.c. References AAS_AreaCluster(), AAS_FloodAreas_r(), AAS_PointAreaNum(), aasworld, GetClearedMemory(), and aas_s::numareas. Referenced by BotExportTest(). { int areanum, cluster, *done; done = (int *) GetClearedMemory(aasworld.numareas * sizeof(int)); areanum = AAS_PointAreaNum(origin); cluster = AAS_AreaCluster(areanum); AAS_FloodAreas_r(areanum, cluster, done); }

Here is the call graph for this function:

int AAS_PointLight (  vec3_t  origin, int *  red, int *  green, int *  blue )

int AAS_Reachability_WeaponJump (  int  area1num, int  area2num )

Definition at line 4006 of file be_aas_reach.c. References AAS_AllocReachability(), aas_area_t, AAS_AreaGrounded(), AAS_AreaSwim(), AAS_BFGJumpZVelocity(), aas_clientmove_t, aas_face_t, AAS_FaceCenter(), AAS_HorizontalVelocityForJump(), aas_lreachability_t, AAS_PointAreaNum(), AAS_PredictClientMovement(), AAS_RocketJumpZVelocity(), aas_trace_t, AAS_TraceClientBBox(), aassettings, aasworld, abs(), aas_areasettings_s::areaflags, aas_lreachability_s::areanum, areareachability, aas_s::areas, aas_s::areasettings, aas_area_s::center, aas_lreachability_s::edgenum, aas_lreachability_s::end, aas_trace_s::endpos, f, aas_face_s::faceflags, aas_s::faceindex, aas_lreachability_s::facenum, aas_s::faces, aas_area_s::firstface, aas_clientmove_s::frames, i, Log_Write(), aas_area_s::maxs, aas_area_s::mins, move(), n, aas_lreachability_s::next, aas_area_s::numfaces, PRESENCE_CROUCH, PRESENCE_NORMAL, qtrue, reach_rocketjump, aas_settings_s::rs_bfgjump, aas_settings_s::rs_rocketjump, SE_ENTERLAVA, SE_ENTERSLIME, SE_ENTERWATER, SE_HITGROUND, SE_HITGROUNDAREA, SE_HITGROUNDDAMAGE, SE_TOUCHJUMPPAD, aas_lreachability_s::start, aas_trace_s::startsolid, aas_clientmove_s::stopevent, aas_lreachability_s::traveltime, aas_lreachability_s::traveltype, vec3_t, VectorCopy, VectorNormalize(), VectorScale, VectorSet, and VectorSubtract. Referenced by AAS_ContinueInitReachability(). { 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

Here is the call graph for this function:

void AAS_TestMovementPrediction (  int  entnum, vec3_t  origin, vec3_t  dir )

Definition at line 1033 of file be_aas_move.c. References AAS_ClearShownDebugLines(), aas_clientmove_t, AAS_PredictClientMovement(), AAS_Swimming(), botimport, f, move(), PRESENCE_NORMAL, PRT_MESSAGE, qtrue, SE_HITGROUND, aas_clientmove_s::stopevent, vec3_t, VectorClear, VectorNormalize(), and VectorScale. { vec3_t velocity, cmdmove; aas_clientmove_t move; VectorClear(velocity); if (!AAS_Swimming(origin)) dir[2] = 0; VectorNormalize(dir); VectorScale(dir, 400, cmdmove); cmdmove[2] = 224; AAS_ClearShownDebugLines(); AAS_PredictClientMovement(&move, entnum, origin, PRESENCE_NORMAL, qtrue, velocity, cmdmove, 13, 13, 0.1f, SE_HITGROUND, 0, qtrue);//SE_LEAVEGROUND); if (move.stopevent & SE_LEAVEGROUND) { botimport.Print(PRT_MESSAGE, "leave ground\n"); } //end if } //end of the function TestMovementPrediction

Here is the call graph for this function:

int AAS_TraceAreas (  vec3_t  start, vec3_t  end, int *  areas, vec3_t *  points, int  maxareas )

Definition at line 726 of file be_aas_sample.c. References aas_node_t, aas_plane_t, aas_tracestack_t, aasworld, botimport, aas_node_s::children, aas_plane_s::dist, DotProduct, aas_tracestack_s::end, aas_s::loaded, aas_tracestack_s::nodenum, aas_s::nodes, aas_plane_s::normal, numareas, aas_s::numareasettings, aas_s::numnodes, aas_node_s::planenum, aas_tracestack_s::planenum, aas_s::planes, points, PRT_ERROR, aas_tracestack_s::start, aas_plane_s::type, vec3_t, and VectorCopy. Referenced by AAS_ClientMovementPrediction(), AAS_InitReachabilityAreas(), AAS_Reachability_FuncBobbing(), AAS_Reachability_Grapple(), AAS_Reachability_Jump(), AAS_Reachability_Step_Barrier_WaterJump_WalkOffLedge(), AAS_Reachability_WalkOffLedge(), BotFuzzyPointReachabilityArea(), and BotMoveToGoal(). { int side, nodenum, tmpplanenum; int numareas; float front, back, frac; vec3_t cur_start, cur_end, cur_mid; aas_tracestack_t tracestack[127]; aas_tracestack_t *tstack_p; aas_node_t *aasnode; aas_plane_t *plane; numareas = 0; areas[0] = 0; if (!aasworld.loaded) return numareas; tstack_p = tracestack; //we start with the whole line on the stack VectorCopy(start, tstack_p->start); VectorCopy(end, tstack_p->end); tstack_p->planenum = 0; //start with node 1 because node zero is a dummy for a solid leaf tstack_p->nodenum = 1; //starting at the root of the tree tstack_p++; while (1) { //pop up the stack tstack_p--; //if the trace stack is empty (ended up with a piece of the //line to be traced in an area) if (tstack_p < tracestack) { return numareas; } //end if //number of the current node to test the line against nodenum = tstack_p->nodenum; //if it is an area if (nodenum < 0) { #ifdef AAS_SAMPLE_DEBUG if (-nodenum > aasworld.numareasettings) { botimport.Print(PRT_ERROR, "AAS_TraceAreas: -nodenum = %d out of range\n", -nodenum); return numareas; } //end if #endif //AAS_SAMPLE_DEBUG //botimport.Print(PRT_MESSAGE, "areanum = %d, must be %d\n", -nodenum, AAS_PointAreaNum(start)); areas[numareas] = -nodenum; if (points) VectorCopy(tstack_p->start, points[numareas]); numareas++; if (numareas >= maxareas) return numareas; continue; } //end if //if it is a solid leaf if (!nodenum) { continue; } //end if #ifdef AAS_SAMPLE_DEBUG if (nodenum > aasworld.numnodes) { botimport.Print(PRT_ERROR, "AAS_TraceAreas: nodenum out of range\n"); return numareas; } //end if #endif //AAS_SAMPLE_DEBUG //the node to test against aasnode = &aasworld.nodes[nodenum]; //start point of current line to test against node VectorCopy(tstack_p->start, cur_start); //end point of the current line to test against node VectorCopy(tstack_p->end, cur_end); //the current node plane plane = &aasworld.planes[aasnode->planenum]; switch(plane->type) {/*FIXME: wtf doesn't this work? obviously the node planes aren't always facing positive!!! //check for axial planes case PLANE_X: { front = cur_start[0] - plane->dist; back = cur_end[0] - plane->dist; break; } //end case case PLANE_Y: { front = cur_start[1] - plane->dist; back = cur_end[1] - plane->dist; break; } //end case case PLANE_Z: { front = cur_start[2] - plane->dist; back = cur_end[2] - plane->dist; break; } //end case*/ default: //gee it's not an axial plane { front = DotProduct(cur_start, plane->normal) - plane->dist; back = DotProduct(cur_end, plane->normal) - plane->dist; break; } //end default } //end switch //if the whole to be traced line is totally at the front of this node //only go down the tree with the front child if (front > 0 && back > 0) { //keep the current start and end point on the stack //and go down the tree with the front child tstack_p->nodenum = aasnode->children[0]; tstack_p++; if (tstack_p >= &tracestack[127]) { botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n"); return numareas; } //end if } //end if //if the whole to be traced line is totally at the back of this node //only go down the tree with the back child else if (front <= 0 && back <= 0) { //keep the current start and end point on the stack //and go down the tree with the back child tstack_p->nodenum = aasnode->children[1]; tstack_p++; if (tstack_p >= &tracestack[127]) { botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n"); return numareas; } //end if } //end if //go down the tree both at the front and back of the node else { tmpplanenum = tstack_p->planenum; //calculate the hitpoint with the node (split point of the line) //put the crosspoint TRACEPLANE_EPSILON pixels on the near side if (front < 0) frac = (front)/(front-back); else frac = (front)/(front-back); if (frac < 0) frac = 0; else if (frac > 1) frac = 1; //frac = front / (front-back); // cur_mid[0] = cur_start[0] + (cur_end[0] - cur_start[0]) * frac; cur_mid[1] = cur_start[1] + (cur_end[1] - cur_start[1]) * frac; cur_mid[2] = cur_start[2] + (cur_end[2] - cur_start[2]) * frac; // AAS_DrawPlaneCross(cur_mid, plane->normal, plane->dist, plane->type, LINECOLOR_RED); //side the front part of the line is on side = front < 0; //first put the end part of the line on the stack (back side) VectorCopy(cur_mid, tstack_p->start); //not necesary to store because still on stack //VectorCopy(cur_end, tstack_p->end); tstack_p->planenum = aasnode->planenum; tstack_p->nodenum = aasnode->children[!side]; tstack_p++; if (tstack_p >= &tracestack[127]) { botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n"); return numareas; } //end if //now put the part near the start of the line on the stack so we will //continue with thats part first. This way we'll find the first //hit of the bbox VectorCopy(cur_start, tstack_p->start); VectorCopy(cur_mid, tstack_p->end); tstack_p->planenum = tmpplanenum; tstack_p->nodenum = aasnode->children[side]; tstack_p++; if (tstack_p >= &tracestack[127]) { botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n"); return numareas; } //end if } //end else } //end while // return numareas; } //end of the function AAS_TraceAreas

int BotExportTest (  int  parm0, char *  parm1, vec3_t  parm2, vec3_t  parm3 )

Definition at line 318 of file be_interface.c. References AAS_AreaCluster(), AAS_AreaTravelTimeToGoalArea(), AAS_ClearShownDebugLines(), AAS_ClearShownPolygons(), AAS_DrawPlaneCross(), AAS_FloodAreas(), AAS_PointPresenceType(), aas_reachability_t, AAS_ReachabilityFromNum(), AAS_ShowAreaPolygons(), AAS_ShowBoundingBox(), AAS_ShowFace(), AAS_ShowReachability(), AAS_ShowReachableAreas(), AAS_Trace(), AAS_TraceEndFace(), aasworld, AngleVectors(), aas_reachability_s::areanum, bot_goal_s::areanum, aas_s::areasettings, bot_goal_t, BotFuzzyPointReachabilityArea(), BotGetReachabilityToGoal(), botimport, botlibglobals, aas_areasettings_s::contents, botlib_import_s::DebugLineCreate, botlib_import_s::DebugLineShow, aas_reachability_s::end, aas_s::entities, aas_s::faces, i, LibVarGetValue(), line, LINECOLOR_BLUE, LINECOLOR_GREEN, LINECOLOR_RED, LINECOLOR_YELLOW, aas_s::loaded, MASK_PLAYERSOLID, NULL, bot_goal_s::origin, PRT_MESSAGE, right, TFL_DEFAULT, TFL_FUNCBOB, TFL_ROCKETJUMP, vec3_t, VectorClear, VectorCopy, and VectorMA. { // return AAS_PointLight(parm2, NULL, NULL, NULL); #ifdef DEBUG static int area = -1; static int line[2]; int newarea, i, highlightarea, flood; // int reachnum; vec3_t eye, forward, right, end, origin; // vec3_t bottomcenter; // aas_trace_t trace; // aas_face_t *face; // aas_entity_t *ent; // bsp_trace_t bsptrace; // aas_reachability_t reach; // bot_goal_t goal; // clock_t start_time, end_time; vec3_t mins = {-16, -16, -24}; vec3_t maxs = {16, 16, 32}; // int areas[10], numareas; //return 0; if (!aasworld.loaded) return 0; /* if (parm0 & 1) { AAS_ClearShownPolygons(); AAS_FloodAreas(parm2); } //end if return 0; */ for (i = 0; i < 2; i++) if (!line[i]) line[i] = botimport.DebugLineCreate(); // AAS_ClearShownDebugLines(); //if (AAS_AgainstLadder(parm2)) botimport.Print(PRT_MESSAGE, "against ladder\n"); //BotOnGround(parm2, PRESENCE_NORMAL, 1, &newarea, &newarea); //botimport.Print(PRT_MESSAGE, "%f %f %f\n", parm2[0], parm2[1], parm2[2]); //* highlightarea = LibVarGetValue("bot_highlightarea"); if (highlightarea > 0) { newarea = highlightarea; } //end if else { VectorCopy(parm2, origin); origin[2] += 0.5; //newarea = AAS_PointAreaNum(origin); newarea = BotFuzzyPointReachabilityArea(origin); } //end else botimport.Print(PRT_MESSAGE, "\rtravel time to goal (%d) = %d ", botlibglobals.goalareanum, AAS_AreaTravelTimeToGoalArea(newarea, origin, botlibglobals.goalareanum, TFL_DEFAULT)); //newarea = BotReachabilityArea(origin, qtrue); if (newarea != area) { botimport.Print(PRT_MESSAGE, "origin = %f, %f, %f\n", origin[0], origin[1], origin[2]); area = newarea; botimport.Print(PRT_MESSAGE, "new area %d, cluster %d, presence type %d\n", area, AAS_AreaCluster(area), AAS_PointPresenceType(origin)); botimport.Print(PRT_MESSAGE, "area contents: "); if (aasworld.areasettings[area].contents & AREACONTENTS_WATER) { botimport.Print(PRT_MESSAGE, "water &"); } //end if if (aasworld.areasettings[area].contents & AREACONTENTS_LAVA) { botimport.Print(PRT_MESSAGE, "lava &"); } //end if if (aasworld.areasettings[area].contents & AREACONTENTS_SLIME) { botimport.Print(PRT_MESSAGE, "slime &"); } //end if if (aasworld.areasettings[area].contents & AREACONTENTS_JUMPPAD) { botimport.Print(PRT_MESSAGE, "jump pad &"); } //end if if (aasworld.areasettings[area].contents & AREACONTENTS_CLUSTERPORTAL) { botimport.Print(PRT_MESSAGE, "cluster portal &"); } //end if if (aasworld.areasettings[area].contents & AREACONTENTS_VIEWPORTAL) { botimport.Print(PRT_MESSAGE, "view portal &"); } //end if if (aasworld.areasettings[area].contents & AREACONTENTS_DONOTENTER) { botimport.Print(PRT_MESSAGE, "do not enter &"); } //end if if (aasworld.areasettings[area].contents & AREACONTENTS_MOVER) { botimport.Print(PRT_MESSAGE, "mover &"); } //end if if (!aasworld.areasettings[area].contents) { botimport.Print(PRT_MESSAGE, "empty"); } //end if botimport.Print(PRT_MESSAGE, "\n"); botimport.Print(PRT_MESSAGE, "travel time to goal (%d) = %d\n", botlibglobals.goalareanum, AAS_AreaTravelTimeToGoalArea(newarea, origin, botlibglobals.goalareanum, TFL_DEFAULT|TFL_ROCKETJUMP)); /* VectorCopy(origin, end); end[2] += 5; numareas = AAS_TraceAreas(origin, end, areas, NULL, 10); AAS_TraceClientBBox(origin, end, PRESENCE_CROUCH, -1); botimport.Print(PRT_MESSAGE, "num areas = %d, area = %d\n", numareas, areas[0]); */ /* botlibglobals.goalareanum = newarea; VectorCopy(parm2, botlibglobals.goalorigin); botimport.Print(PRT_MESSAGE, "new goal %2.1f %2.1f %2.1f area %d\n", origin[0], origin[1], origin[2], newarea); */ } //end if //* flood = LibVarGetValue("bot_flood"); if (parm0 & 1) { if (flood) { AAS_ClearShownPolygons(); AAS_ClearShownDebugLines(); AAS_FloodAreas(parm2); } else { botlibglobals.goalareanum = newarea; VectorCopy(parm2, botlibglobals.goalorigin); botimport.Print(PRT_MESSAGE, "new goal %2.1f %2.1f %2.1f area %d\n", origin[0], origin[1], origin[2], newarea); } } //end if*/ if (flood) return 0; // if (parm0 & BUTTON_USE) // { // botlibglobals.runai = !botlibglobals.runai; // if (botlibglobals.runai) botimport.Print(PRT_MESSAGE, "started AI\n"); // else botimport.Print(PRT_MESSAGE, "stopped AI\n"); //* / /* goal.areanum = botlibglobals.goalareanum; reachnum = BotGetReachabilityToGoal(parm2, newarea, 1, ms.avoidreach, ms.avoidreachtimes, &goal, TFL_DEFAULT); if (!reachnum) { botimport.Print(PRT_MESSAGE, "goal not reachable\n"); } //end if else { AAS_ReachabilityFromNum(reachnum, &reach); AAS_ClearShownDebugLines(); AAS_ShowArea(area, qtrue); AAS_ShowArea(reach.areanum, qtrue); AAS_DrawCross(reach.start, 6, LINECOLOR_BLUE); AAS_DrawCross(reach.end, 6, LINECOLOR_RED); // if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_ELEVATOR) { ElevatorBottomCenter(&reach, bottomcenter); AAS_DrawCross(bottomcenter, 10, LINECOLOR_GREEN); } //end if } //end else*/ // botimport.Print(PRT_MESSAGE, "travel time to goal = %d\n", // AAS_AreaTravelTimeToGoalArea(area, origin, botlibglobals.goalareanum, TFL_DEFAULT)); // botimport.Print(PRT_MESSAGE, "test rj from 703 to 716\n"); // AAS_Reachability_WeaponJump(703, 716); // } //end if*/ /* face = AAS_AreaGroundFace(newarea, parm2); if (face) { AAS_ShowFace(face - aasworld.faces); } //end if*/ /* AAS_ClearShownDebugLines(); AAS_ShowArea(newarea, parm0 & BUTTON_USE); AAS_ShowReachableAreas(area); */ AAS_ClearShownPolygons(); AAS_ClearShownDebugLines(); AAS_ShowAreaPolygons(newarea, 1, parm0 & 4); if (parm0 & 2) AAS_ShowReachableAreas(area); else { static int lastgoalareanum, lastareanum; static int avoidreach[MAX_AVOIDREACH]; static float avoidreachtimes[MAX_AVOIDREACH]; static int avoidreachtries[MAX_AVOIDREACH]; int reachnum, resultFlags; bot_goal_t goal; aas_reachability_t reach; /* goal.areanum = botlibglobals.goalareanum; VectorCopy(botlibglobals.goalorigin, goal.origin); reachnum = BotGetReachabilityToGoal(origin, newarea, lastgoalareanum, lastareanum, avoidreach, avoidreachtimes, avoidreachtries, &goal, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP, NULL, 0, &resultFlags); AAS_ReachabilityFromNum(reachnum, &reach); AAS_ShowReachability(&reach); */ int curarea; vec3_t curorigin; goal.areanum = botlibglobals.goalareanum; VectorCopy(botlibglobals.goalorigin, goal.origin); VectorCopy(origin, curorigin); curarea = newarea; for ( i = 0; i < 100; i++ ) { if ( curarea == goal.areanum ) { break; } reachnum = BotGetReachabilityToGoal(curorigin, curarea, lastgoalareanum, lastareanum, avoidreach, avoidreachtimes, avoidreachtries, &goal, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP, NULL, 0, &resultFlags); AAS_ReachabilityFromNum(reachnum, &reach); AAS_ShowReachability(&reach); VectorCopy(reach.end, origin); lastareanum = curarea; curarea = reach.areanum; } } //end else VectorClear(forward); //BotGapDistance(origin, forward, 0); /* if (parm0 & BUTTON_USE) { botimport.Print(PRT_MESSAGE, "test rj from 703 to 716\n"); AAS_Reachability_WeaponJump(703, 716); } //end if*/ AngleVectors(parm3, forward, right, NULL); //get the eye 16 units to the right of the origin VectorMA(parm2, 8, right, eye); //get the eye 24 units up eye[2] += 24; //get the end point for the line to be traced VectorMA(eye, 800, forward, end); // AAS_TestMovementPrediction(1, parm2, forward); /* //trace the line to find the hit point trace = AAS_TraceClientBBox(eye, end, PRESENCE_NORMAL, 1); if (!line[0]) line[0] = botimport.DebugLineCreate(); botimport.DebugLineShow(line[0], eye, trace.endpos, LINECOLOR_BLUE); // AAS_ClearShownDebugLines(); if (trace.ent) { ent = &aasworld.entities[trace.ent]; AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs); } //end if */ /* start_time = clock(); for (i = 0; i < 2000; i++) { AAS_Trace2(eye, mins, maxs, end, 1, MASK_PLAYERSOLID); // AAS_TraceClientBBox(eye, end, PRESENCE_NORMAL, 1); } //end for end_time = clock(); botimport.Print(PRT_MESSAGE, "me %lu clocks, %lu CLOCKS_PER_SEC\n", end_time - start_time, CLOCKS_PER_SEC); start_time = clock(); for (i = 0; i < 2000; i++) { AAS_Trace(eye, mins, maxs, end, 1, MASK_PLAYERSOLID); } //end for end_time = clock(); botimport.Print(PRT_MESSAGE, "id %lu clocks, %lu CLOCKS_PER_SEC\n", end_time - start_time, CLOCKS_PER_SEC); */ // TTimo: nested comments are BAD for gcc -Werror, use #if 0 instead.. #if 0 AAS_ClearShownDebugLines(); //bsptrace = AAS_Trace(eye, NULL, NULL, end, 1, MASK_PLAYERSOLID); bsptrace = AAS_Trace(eye, mins, maxs, end, 1, MASK_PLAYERSOLID); if (!line[0]) line[0] = botimport.DebugLineCreate(); botimport.DebugLineShow(line[0], eye, bsptrace.endpos, LINECOLOR_YELLOW); if (bsptrace.fraction < 1.0) { face = AAS_TraceEndFace(&trace); if (face) { AAS_ShowFace(face - aasworld.faces); } //end if AAS_DrawPlaneCross(bsptrace.endpos, bsptrace.plane.normal, bsptrace.plane.dist + bsptrace.exp_dist, bsptrace.plane.type, LINECOLOR_GREEN); if (trace.ent) { ent = &aasworld.entities[trace.ent]; AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs); } //end if } //end if //bsptrace = AAS_Trace2(eye, NULL, NULL, end, 1, MASK_PLAYERSOLID); bsptrace = AAS_Trace2(eye, mins, maxs, end, 1, MASK_PLAYERSOLID); botimport.DebugLineShow(line[1], eye, bsptrace.endpos, LINECOLOR_BLUE); if (bsptrace.fraction < 1.0) { AAS_DrawPlaneCross(bsptrace.endpos, bsptrace.plane.normal, bsptrace.plane.dist,// + bsptrace.exp_dist, bsptrace.plane.type, LINECOLOR_RED); if (bsptrace.ent) { ent = &aasworld.entities[bsptrace.ent]; AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs); } //end if } //end if #endif #endif return 0; } //end of the function BotExportTest

Here is the call graph for this function:

int BotFuzzyPointReachabilityArea (  vec3_t  origin  )

Definition at line 241 of file be_ai_move.c. References AAS_AreaReachability(), AAS_PointAreaNum(), AAS_TraceAreas(), j, numareas, points, v, vec3_t, VectorCopy, VectorLength(), VectorSubtract, x, y, and z. Referenced by BotExportTest(), BotMoveToGoal(), and BotReachabilityArea(). { int firstareanum, j, x, y, z; int areas[10], numareas, areanum, bestareanum; float dist, bestdist; vec3_t points[10], v, end; firstareanum = 0; areanum = AAS_PointAreaNum(origin); if (areanum) { firstareanum = areanum; if (AAS_AreaReachability(areanum)) return areanum; } //end if VectorCopy(origin, end); end[2] += 4; numareas = AAS_TraceAreas(origin, end, areas, points, 10); for (j = 0; j < numareas; j++) { if (AAS_AreaReachability(areas[j])) return areas[j]; } //end for bestdist = 999999; bestareanum = 0; for (z = 1; z >= -1; z -= 1) { for (x = 1; x >= -1; x -= 1) { for (y = 1; y >= -1; y -= 1) { VectorCopy(origin, end); end[0] += x * 8; end[1] += y * 8; end[2] += z * 12; numareas = AAS_TraceAreas(origin, end, areas, points, 10); for (j = 0; j < numareas; j++) { if (AAS_AreaReachability(areas[j])) { VectorSubtract(points[j], origin, v); dist = VectorLength(v); if (dist < bestdist) { bestareanum = areas[j]; bestdist = dist; } //end if } //end if if (!firstareanum) firstareanum = areas[j]; } //end for } //end for } //end for if (bestareanum) return bestareanum; } //end for return firstareanum; } //end of the function BotFuzzyPointReachabilityArea

Here is the call graph for this function:

float BotGapDistance (  vec3_t  origin, vec3_t  hordir, int  entnum )

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

Here is the call graph for this function:

int BotGetReachabilityToGoal (  vec3_t  origin, int  areanum, int  lastgoalareanum, int  lastareanum, int *  avoidreach, float *  avoidreachtimes, int *  avoidreachtries, bot_goal_t *  goal, int  travelflags, int  movetravelflags, struct bot_avoidspot_s *  avoidspots, int  numavoidspots, int *  flags )

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

Here is the call graph for this function: