raven/jedioutcast
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
jedioutcast/CODE-mp/botlib/be_ai_move.cpp

3594 lines
113 KiB
C++
Raw Permalink Normal View History

Jedi Outcast v054
2013-04-04 14:52:42 +00:00
/*****************************************************************************
* name: be_ai_move.c
*
* desc: bot movement AI
*
* $Archive: /MissionPack/code/botlib/be_ai_move.c $
* $Author: Ttimo $
* $Revision: 14 $
* $Modtime: 4/22/01 8:52a $
* $Date: 4/22/01 8:52a $
*
*****************************************************************************/
#include "../game/q_shared.h"
#include "l_memory.h"
#include "l_libvar.h"
#include "l_utils.h"
#include "l_script.h"
#include "l_precomp.h"
#include "l_struct.h"
#include "aasfile.h"
#include "../game/botlib.h"
#include "../game/be_aas.h"
#include "be_aas_funcs.h"
#include "be_interface.h"
#include "../game/be_ea.h"
#include "../game/be_ai_goal.h"
#include "../game/be_ai_move.h"
//#define DEBUG_AI_MOVE
//#define DEBUG_ELEVATOR
//#define DEBUG_GRAPPLE
// bk001204 - redundant bot_avoidspot_t, see ../game/be_ai_move.h
//movement state
//NOTE: the moveflags MFL_ONGROUND, MFL_TELEPORTED, MFL_WATERJUMP and
// MFL_GRAPPLEPULL must be set outside the movement code
typedef struct bot_movestate_s
{
//input vars (all set outside the movement code)
vec3_t origin; //origin of the bot
vec3_t velocity; //velocity of the bot
vec3_t viewoffset; //view offset
int entitynum; //entity number of the bot
int client; //client number of the bot
float thinktime; //time the bot thinks
int presencetype; //presencetype of the bot
vec3_t viewangles; //view angles of the bot
//state vars
int areanum; //area the bot is in
int lastareanum; //last area the bot was in
int lastgoalareanum; //last goal area number
int lastreachnum; //last reachability number
vec3_t lastorigin; //origin previous cycle
int reachareanum; //area number of the reachabilty
int moveflags; //movement flags
int jumpreach; //set when jumped
float grapplevisible_time; //last time the grapple was visible
float lastgrappledist; //last distance to the grapple end
float reachability_time; //time to use current reachability
int avoidreach[MAX_AVOIDREACH]; //reachabilities to avoid
float avoidreachtimes[MAX_AVOIDREACH]; //times to avoid the reachabilities
int avoidreachtries[MAX_AVOIDREACH]; //number of tries before avoiding
//
bot_avoidspot_t avoidspots[MAX_AVOIDSPOTS]; //spots to avoid
int numavoidspots;
} bot_movestate_t;
//used to avoid reachability links for some time after being used
#define AVOIDREACH
#define AVOIDREACH_TIME 6 //avoid links for 6 seconds after use
#define AVOIDREACH_TRIES 4
//prediction times
#define PREDICTIONTIME_JUMP 3 //in seconds
#define PREDICTIONTIME_MOVE 2 //in seconds
//weapon indexes for weapon jumping
#define WEAPONINDEX_ROCKET_LAUNCHER 5
#define WEAPONINDEX_BFG 9
#define MODELTYPE_FUNC_PLAT 1
#define MODELTYPE_FUNC_BOB 2
#define MODELTYPE_FUNC_DOOR 3
#define MODELTYPE_FUNC_STATIC 4
libvar_t *sv_maxstep;
libvar_t *sv_maxbarrier;
libvar_t *sv_gravity;
libvar_t *weapindex_rocketlauncher;
libvar_t *weapindex_bfg10k;
libvar_t *weapindex_grapple;
libvar_t *entitytypemissile;
libvar_t *offhandgrapple;
libvar_t *cmd_grappleoff;
libvar_t *cmd_grappleon;
//type of model, func_plat or func_bobbing
int modeltypes[MAX_MODELS];
bot_movestate_t *botmovestates[MAX_CLIENTS+1];
//========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//========================================================================
int BotAllocMoveState(void)
{
int i;
for (i = 1; i <= MAX_CLIENTS; i++)
{
if (!botmovestates[i])
{
botmovestates[i] = (struct bot_movestate_s *)GetClearedMemory(sizeof(bot_movestate_t));
return i;
} //end if
} //end for
return 0;
} //end of the function BotAllocMoveState
//========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//========================================================================
void BotFreeMoveState(int handle)
{
if (handle <= 0 || handle > MAX_CLIENTS)
{
botimport.Print(PRT_FATAL, "move state handle %d out of range\n", handle);
return;
} //end if
if (!botmovestates[handle])
{
botimport.Print(PRT_FATAL, "invalid move state %d\n", handle);
return;
} //end if
FreeMemory(botmovestates[handle]);
botmovestates[handle] = NULL;
} //end of the function BotFreeMoveState
//========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//========================================================================
bot_movestate_t *BotMoveStateFromHandle(int handle)
{
if (handle <= 0 || handle > MAX_CLIENTS)
{
botimport.Print(PRT_FATAL, "move state handle %d out of range\n", handle);
return NULL;
} //end if
if (!botmovestates[handle])
{
botimport.Print(PRT_FATAL, "invalid move state %d\n", handle);
return NULL;
} //end if
return botmovestates[handle];
} //end of the function BotMoveStateFromHandle
//========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//========================================================================
void BotInitMoveState(int handle, bot_initmove_t *initmove)
{
bot_movestate_t *ms;
ms = BotMoveStateFromHandle(handle);
if (!ms) return;
VectorCopy(initmove->origin, ms->origin);
VectorCopy(initmove->velocity, ms->velocity);
VectorCopy(initmove->viewoffset, ms->viewoffset);
ms->entitynum = initmove->entitynum;
ms->client = initmove->client;
ms->thinktime = initmove->thinktime;
ms->presencetype = initmove->presencetype;
VectorCopy(initmove->viewangles, ms->viewangles);
//
ms->moveflags &= ~MFL_ONGROUND;
if (initmove->or_moveflags & MFL_ONGROUND) ms->moveflags |= MFL_ONGROUND;
ms->moveflags &= ~MFL_TELEPORTED;
if (initmove->or_moveflags & MFL_TELEPORTED) ms->moveflags |= MFL_TELEPORTED;
ms->moveflags &= ~MFL_WATERJUMP;
if (initmove->or_moveflags & MFL_WATERJUMP) ms->moveflags |= MFL_WATERJUMP;
ms->moveflags &= ~MFL_WALK;
if (initmove->or_moveflags & MFL_WALK) ms->moveflags |= MFL_WALK;
ms->moveflags &= ~MFL_GRAPPLEPULL;
if (initmove->or_moveflags & MFL_GRAPPLEPULL) ms->moveflags |= MFL_GRAPPLEPULL;
} //end of the function BotInitMoveState
//========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//========================================================================
float AngleDiff(float ang1, float ang2)
{
float diff;
diff = ang1 - ang2;
if (ang1 > ang2)
{
if (diff > 180.0) diff -= 360.0;
} //end if
else
{
if (diff < -180.0) diff += 360.0;
} //end else
return diff;
} //end of the function AngleDiff
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotFuzzyPointReachabilityArea(vec3_t origin)
{
int firstareanum, j, x, y, z;
int areas[10], numareas, areanum, bestareanum;
float dist, bestdist;
vec3_t points[10], v, end;
firstareanum = 0;
areanum = AAS_PointAreaNum(origin);
if (areanum)
{
firstareanum = areanum;
if (AAS_AreaReachability(areanum)) return areanum;
} //end if
VectorCopy(origin, end);
end[2] += 4;
numareas = AAS_TraceAreas(origin, end, areas, points, 10);
for (j = 0; j < numareas; j++)
{
if (AAS_AreaReachability(areas[j])) return areas[j];
} //end for
bestdist = 999999;
bestareanum = 0;
for (z = 1; z >= -1; z -= 1)
{
for (x = 1; x >= -1; x -= 1)
{
for (y = 1; y >= -1; y -= 1)
{
VectorCopy(origin, end);
end[0] += x * 8;
end[1] += y * 8;
end[2] += z * 12;
numareas = AAS_TraceAreas(origin, end, areas, points, 10);
for (j = 0; j < numareas; j++)
{
if (AAS_AreaReachability(areas[j]))
{
VectorSubtract(points[j], origin, v);
dist = VectorLength(v);
if (dist < bestdist)
{
bestareanum = areas[j];
bestdist = dist;
} //end if
} //end if
if (!firstareanum) firstareanum = areas[j];
} //end for
} //end for
} //end for
if (bestareanum) return bestareanum;
} //end for
return firstareanum;
} //end of the function BotFuzzyPointReachabilityArea
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotReachabilityArea(vec3_t origin, int client)
{
int modelnum, modeltype, reachnum, areanum;
aas_reachability_t reach;
vec3_t org, end, mins, maxs, up = {0, 0, 1};
bsp_trace_t bsptrace;
aas_trace_t trace;
//check if the bot is standing on something
AAS_PresenceTypeBoundingBox(PRESENCE_CROUCH, mins, maxs);
VectorMA(origin, -3, up, end);
bsptrace = AAS_Trace(origin, mins, maxs, end, client, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
if (!bsptrace.startsolid && bsptrace.fraction < 1 && bsptrace.ent != ENTITYNUM_NONE)
{
//if standing on the world the bot should be in a valid area
if (bsptrace.ent == ENTITYNUM_WORLD)
{
return BotFuzzyPointReachabilityArea(origin);
} //end if
modelnum = AAS_EntityModelindex(bsptrace.ent);
modeltype = modeltypes[modelnum];
//if standing on a func_plat or func_bobbing then the bot is assumed to be
//in the area the reachability points to
if (modeltype == MODELTYPE_FUNC_PLAT || modeltype == MODELTYPE_FUNC_BOB)
{
reachnum = AAS_NextModelReachability(0, modelnum);
if (reachnum)
{
AAS_ReachabilityFromNum(reachnum, &reach);
return reach.areanum;
} //end if
} //end else if
//if the bot is swimming the bot should be in a valid area
if (AAS_Swimming(origin))
{
return BotFuzzyPointReachabilityArea(origin);
} //end if
//
areanum = BotFuzzyPointReachabilityArea(origin);
//if the bot is in an area with reachabilities
if (areanum && AAS_AreaReachability(areanum)) return areanum;
//trace down till the ground is hit because the bot is standing on some other entity
VectorCopy(origin, org);
VectorCopy(org, end);
end[2] -= 800;
trace = AAS_TraceClientBBox(org, end, PRESENCE_CROUCH, -1);
if (!trace.startsolid)
{
VectorCopy(trace.endpos, org);
} //end if
//
return BotFuzzyPointReachabilityArea(org);
} //end if
//
return BotFuzzyPointReachabilityArea(origin);
} //end of the function BotReachabilityArea
//===========================================================================
// returns the reachability area the bot is in
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
/*
int BotReachabilityArea(vec3_t origin, int testground)
{
int firstareanum, i, j, x, y, z;
int areas[10], numareas, areanum, bestareanum;
float dist, bestdist;
vec3_t org, end, points[10], v;
aas_trace_t trace;
firstareanum = 0;
for (i = 0; i < 2; i++)
{
VectorCopy(origin, org);
//if test at the ground (used when bot is standing on an entity)
if (i > 0)
{
VectorCopy(origin, end);
end[2] -= 800;
trace = AAS_TraceClientBBox(origin, end, PRESENCE_CROUCH, -1);
if (!trace.startsolid)
{
VectorCopy(trace.endpos, org);
} //end if
} //end if
firstareanum = 0;
areanum = AAS_PointAreaNum(org);
if (areanum)
{
firstareanum = areanum;
if (AAS_AreaReachability(areanum)) return areanum;
} //end if
bestdist = 999999;
bestareanum = 0;
for (z = 1; z >= -1; z -= 1)
{
for (x = 1; x >= -1; x -= 1)
{
for (y = 1; y >= -1; y -= 1)
{
VectorCopy(org, end);
end[0] += x * 8;
end[1] += y * 8;
end[2] += z * 12;
numareas = AAS_TraceAreas(org, end, areas, points, 10);
for (j = 0; j < numareas; j++)
{
if (AAS_AreaReachability(areas[j]))
{
VectorSubtract(points[j], org, v);
dist = VectorLength(v);
if (dist < bestdist)
{
bestareanum = areas[j];
bestdist = dist;
} //end if
} //end if
} //end for
} //end for
} //end for
if (bestareanum) return bestareanum;
} //end for
if (!testground) break;
} //end for
//#ifdef DEBUG
//botimport.Print(PRT_MESSAGE, "no reachability area\n");
//#endif //DEBUG
return firstareanum;
} //end of the function BotReachabilityArea*/
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotOnMover(vec3_t origin, int entnum, aas_reachability_t *reach)
{
int i, modelnum;
vec3_t mins, maxs, modelorigin, org, end;
vec3_t angles = {0, 0, 0};
vec3_t boxmins = {-16, -16, -8}, boxmaxs = {16, 16, 8};
bsp_trace_t trace;
modelnum = reach->facenum & 0x0000FFFF;
//get some bsp model info
AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, NULL);
//
if (!AAS_OriginOfMoverWithModelNum(modelnum, modelorigin))
{
botimport.Print(PRT_MESSAGE, "no entity with model %d\n", modelnum);
return qfalse;
} //end if
//
for (i = 0; i < 2; i++)
{
if (origin[i] > modelorigin[i] + maxs[i] + 16) return qfalse;
if (origin[i] < modelorigin[i] + mins[i] - 16) return qfalse;
} //end for
//
VectorCopy(origin, org);
org[2] += 24;
VectorCopy(origin, end);
end[2] -= 48;
//
trace = AAS_Trace(org, boxmins, boxmaxs, end, entnum, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
if (!trace.startsolid && !trace.allsolid)
{
//NOTE: the reachability face number is the model number of the elevator
if (trace.ent != ENTITYNUM_NONE && AAS_EntityModelNum(trace.ent) == modelnum)
{
return qtrue;
} //end if
} //end if
return qfalse;
} //end of the function BotOnMover
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int MoverDown(aas_reachability_t *reach)
{
int modelnum;
vec3_t mins, maxs, origin;
vec3_t angles = {0, 0, 0};
modelnum = reach->facenum & 0x0000FFFF;
//get some bsp model info
AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin);
//
if (!AAS_OriginOfMoverWithModelNum(modelnum, origin))
{
botimport.Print(PRT_MESSAGE, "no entity with model %d\n", modelnum);
return qfalse;
} //end if
//if the top of the plat is below the reachability start point
if (origin[2] + maxs[2] < reach->start[2]) return qtrue;
return qfalse;
} //end of the function MoverDown
//========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//========================================================================
void BotSetBrushModelTypes(void)
{
int ent, modelnum;
char classname[MAX_EPAIRKEY], model[MAX_EPAIRKEY];
Com_Memset(modeltypes, 0, MAX_MODELS * sizeof(int));
//
for (ent = AAS_NextBSPEntity(0); ent; ent = AAS_NextBSPEntity(ent))
{
if (!AAS_ValueForBSPEpairKey(ent, "classname", classname, MAX_EPAIRKEY)) continue;
if (!AAS_ValueForBSPEpairKey(ent, "model", model, MAX_EPAIRKEY)) continue;
if (model[0]) modelnum = atoi(model+1);
else modelnum = 0;
if (modelnum < 0 || modelnum > MAX_MODELS)
{
botimport.Print(PRT_MESSAGE, "entity %s model number out of range\n", classname);
continue;
} //end if
if (!Q_stricmp(classname, "func_bobbing"))
modeltypes[modelnum] = MODELTYPE_FUNC_BOB;
else if (!Q_stricmp(classname, "func_plat"))
modeltypes[modelnum] = MODELTYPE_FUNC_PLAT;
else if (!Q_stricmp(classname, "func_door"))
modeltypes[modelnum] = MODELTYPE_FUNC_DOOR;
else if (!Q_stricmp(classname, "func_static"))
modeltypes[modelnum] = MODELTYPE_FUNC_STATIC;
} //end for
} //end of the function BotSetBrushModelTypes
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotOnTopOfEntity(bot_movestate_t *ms)
{
vec3_t mins, maxs, end, up = {0, 0, 1};
bsp_trace_t trace;
AAS_PresenceTypeBoundingBox(ms->presencetype, mins, maxs);
VectorMA(ms->origin, -3, up, end);
trace = AAS_Trace(ms->origin, mins, maxs, end, ms->entitynum, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
if (!trace.startsolid && (trace.ent != ENTITYNUM_WORLD && trace.ent != ENTITYNUM_NONE) )
{
return trace.ent;
} //end if
return -1;
} //end of the function BotOnTopOfEntity
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotValidTravel(vec3_t origin, aas_reachability_t *reach, int travelflags)
{
//if the reachability uses an unwanted travel type
if (AAS_TravelFlagForType(reach->traveltype) & ~travelflags) return qfalse;
//don't go into areas with bad travel types
if (AAS_AreaContentsTravelFlags(reach->areanum) & ~travelflags) return qfalse;
return qtrue;
} //end of the function BotValidTravel
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotAddToAvoidReach(bot_movestate_t *ms, int number, float avoidtime)
{
int i;
for (i = 0; i < MAX_AVOIDREACH; i++)
{
if (ms->avoidreach[i] == number)
{
if (ms->avoidreachtimes[i] > AAS_Time()) ms->avoidreachtries[i]++;
else ms->avoidreachtries[i] = 1;
ms->avoidreachtimes[i] = AAS_Time() + avoidtime;
return;
} //end if
} //end for
//add the reachability to the reachabilities to avoid for a while
for (i = 0; i < MAX_AVOIDREACH; i++)
{
if (ms->avoidreachtimes[i] < AAS_Time())
{
ms->avoidreach[i] = number;
ms->avoidreachtimes[i] = AAS_Time() + avoidtime;
ms->avoidreachtries[i] = 1;
return;
} //end if
} //end for
} //end of the function BotAddToAvoidReach
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
float DistanceFromLineSquared(vec3_t p, vec3_t lp1, vec3_t lp2)
{
vec3_t proj, dir;
int j;
AAS_ProjectPointOntoVector(p, lp1, lp2, proj);
for (j = 0; j < 3; j++)
if ((proj[j] > lp1[j] && proj[j] > lp2[j]) ||
(proj[j] < lp1[j] && proj[j] < lp2[j]))
break;
if (j < 3) {
if (fabs(proj[j] - lp1[j]) < fabs(proj[j] - lp2[j]))
VectorSubtract(p, lp1, dir);
else
VectorSubtract(p, lp2, dir);
return VectorLengthSquared(dir);
}
VectorSubtract(p, proj, dir);
return VectorLengthSquared(dir);
} //end of the function DistanceFromLineSquared
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
float VectorDistanceSquared(vec3_t p1, vec3_t p2)
{
vec3_t dir;
VectorSubtract(p2, p1, dir);
return VectorLengthSquared(dir);
} //end of the function VectorDistanceSquared
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotAvoidSpots(vec3_t origin, aas_reachability_t *reach, bot_avoidspot_t *avoidspots, int numavoidspots)
{
int checkbetween, i, type;
float squareddist, squaredradius;
switch(reach->traveltype & TRAVELTYPE_MASK)
{
case TRAVEL_WALK: checkbetween = qtrue; break;
case TRAVEL_CROUCH: checkbetween = qtrue; break;
case TRAVEL_BARRIERJUMP: checkbetween = qtrue; break;
case TRAVEL_LADDER: checkbetween = qtrue; break;
case TRAVEL_WALKOFFLEDGE: checkbetween = qfalse; break;
case TRAVEL_JUMP: checkbetween = qfalse; break;
case TRAVEL_SWIM: checkbetween = qtrue; break;
case TRAVEL_WATERJUMP: checkbetween = qtrue; break;
case TRAVEL_TELEPORT: checkbetween = qfalse; break;
case TRAVEL_ELEVATOR: checkbetween = qfalse; break;
case TRAVEL_GRAPPLEHOOK: checkbetween = qfalse; break;
case TRAVEL_ROCKETJUMP: checkbetween = qfalse; break;
case TRAVEL_BFGJUMP: checkbetween = qfalse; break;
case TRAVEL_JUMPPAD: checkbetween = qfalse; break;
case TRAVEL_FUNCBOB: checkbetween = qfalse; break;
default: checkbetween = qtrue; break;
} //end switch
type = AVOID_CLEAR;
for (i = 0; i < numavoidspots; i++)
{
squaredradius = Square(avoidspots[i].radius);
squareddist = DistanceFromLineSquared(avoidspots[i].origin, origin, reach->start);
// if moving towards the avoid spot
if (squareddist < squaredradius &&
VectorDistanceSquared(avoidspots[i].origin, origin) > squareddist)
{
type = avoidspots[i].type;
} //end if
else if (checkbetween) {
squareddist = DistanceFromLineSquared(avoidspots[i].origin, reach->start, reach->end);
// if moving towards the avoid spot
if (squareddist < squaredradius &&
VectorDistanceSquared(avoidspots[i].origin, reach->start) > squareddist)
{
type = avoidspots[i].type;
} //end if
} //end if
else
{
VectorDistanceSquared(avoidspots[i].origin, reach->end);
// if the reachability leads closer to the avoid spot
if (squareddist < squaredradius &&
VectorDistanceSquared(avoidspots[i].origin, reach->start) > squareddist)
{
type = avoidspots[i].type;
} //end if
} //end else
if (type == AVOID_ALWAYS)
return type;
} //end for
return type;
} //end of the function BotAvoidSpots
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotAddAvoidSpot(int movestate, vec3_t origin, float radius, int type)
{
bot_movestate_t *ms;
ms = BotMoveStateFromHandle(movestate);
if (!ms) return;
if (type == AVOID_CLEAR)
{
ms->numavoidspots = 0;
return;
} //end if
if (ms->numavoidspots >= MAX_AVOIDSPOTS)
return;
VectorCopy(origin, ms->avoidspots[ms->numavoidspots].origin);
ms->avoidspots[ms->numavoidspots].radius = radius;
ms->avoidspots[ms->numavoidspots].type = type;
ms->numavoidspots++;
} //end of the function BotAddAvoidSpot
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotGetReachabilityToGoal(vec3_t origin, int areanum,
int lastgoalareanum, int lastareanum,
int *avoidreach, float *avoidreachtimes, int *avoidreachtries,
bot_goal_t *goal, int travelflags, int movetravelflags,
struct bot_avoidspot_s *avoidspots, int numavoidspots, int *flags)
{
int i, t, besttime, bestreachnum, reachnum;
aas_reachability_t reach;
//if not in a valid area
if (!areanum) return 0;
//
if (AAS_AreaDoNotEnter(areanum) || AAS_AreaDoNotEnter(goal->areanum))
{
travelflags |= TFL_DONOTENTER;
movetravelflags |= TFL_DONOTENTER;
} //end if
//use the routing to find the next area to go to
besttime = 0;
bestreachnum = 0;
//
for (reachnum = AAS_NextAreaReachability(areanum, 0); reachnum;
reachnum = AAS_NextAreaReachability(areanum, reachnum))
{
#ifdef AVOIDREACH
//check if it isn't an reachability to avoid
for (i = 0; i < MAX_AVOIDREACH; i++)
{
if (avoidreach[i] == reachnum && avoidreachtimes[i] >= AAS_Time()) break;
} //end for
if (i != MAX_AVOIDREACH && avoidreachtries[i] > AVOIDREACH_TRIES)
{
#ifdef DEBUG
if (bot_developer)
{
botimport.Print(PRT_MESSAGE, "avoiding reachability %d\n", avoidreach[i]);
} //end if
#endif //DEBUG
continue;
} //end if
#endif //AVOIDREACH
//get the reachability from the number
AAS_ReachabilityFromNum(reachnum, &reach);
//NOTE: do not go back to the previous area if the goal didn't change
//NOTE: is this actually avoidance of local routing minima between two areas???
if (lastgoalareanum == goal->areanum && reach.areanum == lastareanum) continue;
//if (AAS_AreaContentsTravelFlags(reach.areanum) & ~travelflags) continue;
//if the travel isn't valid
if (!BotValidTravel(origin, &reach, movetravelflags)) continue;
//get the travel time
t = AAS_AreaTravelTimeToGoalArea(reach.areanum, reach.end, goal->areanum, travelflags);
//if the goal area isn't reachable from the reachable area
if (!t) continue;
//if the bot should not use this reachability to avoid bad spots
if (BotAvoidSpots(origin, &reach, avoidspots, numavoidspots)) {
if (flags) {
*flags |= MOVERESULT_BLOCKEDBYAVOIDSPOT;
}
continue;
}
//add the travel time towards the area
t += reach.traveltime;// + AAS_AreaTravelTime(areanum, origin, reach.start);
//if the travel time is better than the ones already found
if (!besttime || t < besttime)
{
besttime = t;
bestreachnum = reachnum;
} //end if
} //end for
//
return bestreachnum;
} //end of the function BotGetReachabilityToGoal
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotAddToTarget(vec3_t start, vec3_t end, float maxdist, float *dist, vec3_t target)
{
vec3_t dir;
float curdist;
VectorSubtract(end, start, dir);
curdist = VectorNormalize(dir);
if (*dist + curdist < maxdist)
{
VectorCopy(end, target);
*dist += curdist;
return qfalse;
} //end if
else
{
VectorMA(start, maxdist - *dist, dir, target);
*dist = maxdist;
return qtrue;
} //end else
} //end of the function BotAddToTarget
int BotMovementViewTarget(int movestate, bot_goal_t *goal, int travelflags, float lookahead, vec3_t target)
{
aas_reachability_t reach;
int reachnum, lastareanum;
bot_movestate_t *ms;
vec3_t end;
float dist;
ms = BotMoveStateFromHandle(movestate);
if (!ms) return qfalse;
reachnum = 0;
//if the bot has no goal or no last reachability
if (!ms->lastreachnum || !goal) return qfalse;
reachnum = ms->lastreachnum;
VectorCopy(ms->origin, end);
lastareanum = ms->lastareanum;
dist = 0;
while(reachnum && dist < lookahead)
{
AAS_ReachabilityFromNum(reachnum, &reach);
if (BotAddToTarget(end, reach.start, lookahead, &dist, target)) return qtrue;
//never look beyond teleporters
if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_TELEPORT) return qtrue;
//never look beyond the weapon jump point
if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_ROCKETJUMP) return qtrue;
if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_BFGJUMP) return qtrue;
//don't add jump pad distances
if ((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_JUMPPAD &&
(reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_ELEVATOR &&
(reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_FUNCBOB)
{
if (BotAddToTarget(reach.start, reach.end, lookahead, &dist, target)) return qtrue;
} //end if
reachnum = BotGetReachabilityToGoal(reach.end, reach.areanum,
ms->lastgoalareanum, lastareanum,
ms->avoidreach, ms->avoidreachtimes, ms->avoidreachtries,
goal, travelflags, travelflags, NULL, 0, NULL);
VectorCopy(reach.end, end);
lastareanum = reach.areanum;
if (lastareanum == goal->areanum)
{
BotAddToTarget(reach.end, goal->origin, lookahead, &dist, target);
return qtrue;
} //end if
} //end while
//
return qfalse;
} //end of the function BotMovementViewTarget
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotVisible(int ent, vec3_t eye, vec3_t target)
{
bsp_trace_t trace;
trace = AAS_Trace(eye, NULL, NULL, target, ent, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
if (trace.fraction >= 1) return qtrue;
return qfalse;
} //end of the function BotVisible
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotPredictVisiblePosition(vec3_t origin, int areanum, bot_goal_t *goal, int travelflags, vec3_t target)
{
aas_reachability_t reach;
int reachnum, lastgoalareanum, lastareanum, i;
int avoidreach[MAX_AVOIDREACH];
float avoidreachtimes[MAX_AVOIDREACH];
int avoidreachtries[MAX_AVOIDREACH];
vec3_t end;
//if the bot has no goal or no last reachability
if (!goal) return qfalse;
//if the areanum is not valid
if (!areanum) return qfalse;
//if the goal areanum is not valid
if (!goal->areanum) return qfalse;
Com_Memset(avoidreach, 0, MAX_AVOIDREACH * sizeof(int));
lastgoalareanum = goal->areanum;
lastareanum = areanum;
VectorCopy(origin, end);
//only do 20 hops
for (i = 0; i < 20 && (areanum != goal->areanum); i++)
{
//
reachnum = BotGetReachabilityToGoal(end, areanum,
lastgoalareanum, lastareanum,
avoidreach, avoidreachtimes, avoidreachtries,
goal, travelflags, travelflags, NULL, 0, NULL);
if (!reachnum) return qfalse;
AAS_ReachabilityFromNum(reachnum, &reach);
//
if (BotVisible(goal->entitynum, goal->origin, reach.start))
{
VectorCopy(reach.start, target);
return qtrue;
} //end if
//
if (BotVisible(goal->entitynum, goal->origin, reach.end))
{
VectorCopy(reach.end, target);
return qtrue;
} //end if
//
if (reach.areanum == goal->areanum)
{
VectorCopy(reach.end, target);
return qtrue;
} //end if
//
lastareanum = areanum;
areanum = reach.areanum;
VectorCopy(reach.end, end);
//
} //end while
//
return qfalse;
} //end of the function BotPredictVisiblePosition
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void MoverBottomCenter(aas_reachability_t *reach, vec3_t bottomcenter)
{
int modelnum;
vec3_t mins, maxs, origin, mids;
vec3_t angles = {0, 0, 0};
modelnum = reach->facenum & 0x0000FFFF;
//get some bsp model info
AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, origin);
//
if (!AAS_OriginOfMoverWithModelNum(modelnum, origin))
{
botimport.Print(PRT_MESSAGE, "no entity with model %d\n", modelnum);
} //end if
//get a point just above the plat in the bottom position
VectorAdd(mins, maxs, mids);
VectorMA(origin, 0.5, mids, bottomcenter);
bottomcenter[2] = reach->start[2];
} //end of the function MoverBottomCenter
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
float BotGapDistance(vec3_t origin, vec3_t hordir, int entnum)
{
float dist, startz;
vec3_t start, end;
aas_trace_t trace;
//do gap checking
startz = origin[2];
//this enables walking down stairs more fluidly
{
VectorCopy(origin, start);
VectorCopy(origin, end);
end[2] -= 60;
trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, entnum);
if (trace.fraction >= 1) return 1;
startz = trace.endpos[2] + 1;
}
//
for (dist = 8; dist <= 100; dist += 8)
{
VectorMA(origin, dist, hordir, start);
start[2] = startz + 24;
VectorCopy(start, end);
end[2] -= 48 + sv_maxbarrier->value;
trace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, entnum);
//if solid is found the bot can't walk any further and fall into a gap
if (!trace.startsolid)
{
//if it is a gap
if (trace.endpos[2] < startz - sv_maxstep->value - 8)
{
VectorCopy(trace.endpos, end);
end[2] -= 20;
if (AAS_PointContents(end) & CONTENTS_WATER) break;
//if a gap is found slow down
//botimport.Print(PRT_MESSAGE, "gap at %f\n", dist);
return dist;
} //end if
startz = trace.endpos[2];
} //end if
} //end for
return 0;
} //end of the function BotGapDistance
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotCheckBarrierJump(bot_movestate_t *ms, vec3_t dir, float speed)
{
vec3_t start, hordir, end;
aas_trace_t trace;
VectorCopy(ms->origin, end);
end[2] += sv_maxbarrier->value;
//trace right up
trace = AAS_TraceClientBBox(ms->origin, end, PRESENCE_NORMAL, ms->entitynum);
//this shouldn't happen... but we check anyway
if (trace.startsolid) return qfalse;
//if very low ceiling it isn't possible to jump up to a barrier
if (trace.endpos[2] - ms->origin[2] < sv_maxstep->value) return qfalse;
//
hordir[0] = dir[0];
hordir[1] = dir[1];
hordir[2] = 0;
VectorNormalize(hordir);
VectorMA(ms->origin, ms->thinktime * speed * 0.5, hordir, end);
VectorCopy(trace.endpos, start);
end[2] = trace.endpos[2];
//trace from previous trace end pos horizontally in the move direction
trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, ms->entitynum);
//again this shouldn't happen
if (trace.startsolid) return qfalse;
//
VectorCopy(trace.endpos, start);
VectorCopy(trace.endpos, end);
end[2] = ms->origin[2];
//trace down from the previous trace end pos
trace = AAS_TraceClientBBox(start, end, PRESENCE_NORMAL, ms->entitynum);
//if solid
if (trace.startsolid) return qfalse;
//if no obstacle at all
if (trace.fraction >= 1.0) return qfalse;
//if less than the maximum step height
if (trace.endpos[2] - ms->origin[2] < sv_maxstep->value) return qfalse;
//
EA_Jump(ms->client);
EA_Move(ms->client, hordir, speed);
ms->moveflags |= MFL_BARRIERJUMP;
//there is a barrier
return qtrue;
} //end of the function BotCheckBarrierJump
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotSwimInDirection(bot_movestate_t *ms, vec3_t dir, float speed, int type)
{
vec3_t normdir;
VectorCopy(dir, normdir);
VectorNormalize(normdir);
EA_Move(ms->client, normdir, speed);
return qtrue;
} //end of the function BotSwimInDirection
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotWalkInDirection(bot_movestate_t *ms, vec3_t dir, float speed, int type)
{
vec3_t hordir, cmdmove, velocity, tmpdir, origin;
int presencetype, maxframes, cmdframes, stopevent;
aas_clientmove_t move;
float dist;
if (AAS_OnGround(ms->origin, ms->presencetype, ms->entitynum)) ms->moveflags |= MFL_ONGROUND;
//if the bot is on the ground
if (ms->moveflags & MFL_ONGROUND)
{
//if there is a barrier the bot can jump on
if (BotCheckBarrierJump(ms, dir, speed)) return qtrue;
//remove barrier jump flag
ms->moveflags &= ~MFL_BARRIERJUMP;
//get the presence type for the movement
if ((type & MOVE_CROUCH) && !(type & MOVE_JUMP)) presencetype = PRESENCE_CROUCH;
else presencetype = PRESENCE_NORMAL;
//horizontal direction
hordir[0] = dir[0];
hordir[1] = dir[1];
hordir[2] = 0;
VectorNormalize(hordir);
//if the bot is not supposed to jump
if (!(type & MOVE_JUMP))
{
//if there is a gap, try to jump over it
if (BotGapDistance(ms->origin, hordir, ms->entitynum) > 0) type |= MOVE_JUMP;
} //end if
//get command movement
VectorScale(hordir, speed, cmdmove);
VectorCopy(ms->velocity, velocity);
//
if (type & MOVE_JUMP)
{
//botimport.Print(PRT_MESSAGE, "trying jump\n");
cmdmove[2] = 400;
maxframes = PREDICTIONTIME_JUMP / 0.1;
cmdframes = 1;
stopevent = SE_HITGROUND|SE_HITGROUNDDAMAGE|
SE_ENTERWATER|SE_ENTERSLIME|SE_ENTERLAVA;
} //end if
else
{
maxframes = 2;
cmdframes = 2;
stopevent = SE_HITGROUNDDAMAGE|
SE_ENTERWATER|SE_ENTERSLIME|SE_ENTERLAVA;
} //end else
//AAS_ClearShownDebugLines();
//
VectorCopy(ms->origin, origin);
origin[2] += 0.5;
AAS_PredictClientMovement(&move, ms->entitynum, origin, presencetype, qtrue,
velocity, cmdmove, cmdframes, maxframes, 0.1f,
stopevent, 0, qfalse);//qtrue);
//if prediction time wasn't enough to fully predict the movement
if (move.frames >= maxframes && (type & MOVE_JUMP))
{
//botimport.Print(PRT_MESSAGE, "client %d: max prediction frames\n", ms->client);
return qfalse;
} //end if
//don't enter slime or lava and don't fall from too high
if (move.stopevent & (SE_ENTERSLIME|SE_ENTERLAVA|SE_HITGROUNDDAMAGE))
{
//botimport.Print(PRT_MESSAGE, "client %d: would be hurt ", ms->client);
//if (move.stopevent & SE_ENTERSLIME) botimport.Print(PRT_MESSAGE, "slime\n");
//if (move.stopevent & SE_ENTERLAVA) botimport.Print(PRT_MESSAGE, "lava\n");
//if (move.stopevent & SE_HITGROUNDDAMAGE) botimport.Print(PRT_MESSAGE, "hitground\n");
return qfalse;
} //end if
//if ground was hit
if (move.stopevent & SE_HITGROUND)
{
//check for nearby gap
VectorNormalize2(move.velocity, tmpdir);
dist = BotGapDistance(move.endpos, tmpdir, ms->entitynum);
if (dist > 0) return qfalse;
//
dist = BotGapDistance(move.endpos, hordir, ms->entitynum);
if (dist > 0) return qfalse;
} //end if
//get horizontal movement
tmpdir[0] = move.endpos[0] - ms->origin[0];
tmpdir[1] = move.endpos[1] - ms->origin[1];
tmpdir[2] = 0;
//
//AAS_DrawCross(move.endpos, 4, LINECOLOR_BLUE);
//the bot is blocked by something
if (VectorLength(tmpdir) < speed * ms->thinktime * 0.5) return qfalse;
//perform the movement
if (type & MOVE_JUMP) EA_Jump(ms->client);
if (type & MOVE_CROUCH) EA_Crouch(ms->client);
EA_Move(ms->client, hordir, speed);
//movement was succesfull
return qtrue;
} //end if
else
{
if (ms->moveflags & MFL_BARRIERJUMP)
{
//if near the top or going down
if (ms->velocity[2] < 50)
{
EA_Move(ms->client, dir, speed);
} //end if
} //end if
//FIXME: do air control to avoid hazards
return qtrue;
} //end else
} //end of the function BotWalkInDirection
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotMoveInDirection(int movestate, vec3_t dir, float speed, int type)
{
bot_movestate_t *ms;
ms = BotMoveStateFromHandle(movestate);
if (!ms) return qfalse;
//if swimming
if (AAS_Swimming(ms->origin))
{
return BotSwimInDirection(ms, dir, speed, type);
} //end if
else
{
return BotWalkInDirection(ms, dir, speed, type);
} //end else
} //end of the function BotMoveInDirection
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int Intersection(vec2_t p1, vec2_t p2, vec2_t p3, vec2_t p4, vec2_t out)
{
float x1, dx1, dy1, x2, dx2, dy2, d;
dx1 = p2[0] - p1[0];
dy1 = p2[1] - p1[1];
dx2 = p4[0] - p3[0];
dy2 = p4[1] - p3[1];
d = dy1 * dx2 - dx1 * dy2;
if (d != 0)
{
x1 = p1[1] * dx1 - p1[0] * dy1;
x2 = p3[1] * dx2 - p3[0] * dy2;
out[0] = (int) ((dx1 * x2 - dx2 * x1) / d);
out[1] = (int) ((dy1 * x2 - dy2 * x1) / d);
return qtrue;
} //end if
else
{
return qfalse;
} //end else
} //end of the function Intersection
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotCheckBlocked(bot_movestate_t *ms, vec3_t dir, int checkbottom, bot_moveresult_t *result)
{
vec3_t mins, maxs, end, up = {0, 0, 1};
bsp_trace_t trace;
//test for entities obstructing the bot's path
AAS_PresenceTypeBoundingBox(ms->presencetype, mins, maxs);
//
if (fabs(DotProduct(dir, up)) < 0.7)
{
mins[2] += sv_maxstep->value; //if the bot can step on
maxs[2] -= 10; //a little lower to avoid low ceiling
} //end if
VectorMA(ms->origin, 3, dir, end);
trace = AAS_Trace(ms->origin, mins, maxs, end, ms->entitynum, CONTENTS_SOLID|CONTENTS_PLAYERCLIP|CONTENTS_BODY);
//if not started in solid and not hitting the world entity
if (!trace.startsolid && (trace.ent != ENTITYNUM_WORLD && trace.ent != ENTITYNUM_NONE) )
{
result->blocked = qtrue;
result->blockentity = trace.ent;
#ifdef DEBUG
//botimport.Print(PRT_MESSAGE, "%d: BotCheckBlocked: I'm blocked\n", ms->client);
#endif //DEBUG
} //end if
//if not in an area with reachability
else if (checkbottom && !AAS_AreaReachability(ms->areanum))
{
//check if the bot is standing on something
AAS_PresenceTypeBoundingBox(ms->presencetype, mins, maxs);
VectorMA(ms->origin, -3, up, end);
trace = AAS_Trace(ms->origin, mins, maxs, end, ms->entitynum, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
if (!trace.startsolid && (trace.ent != ENTITYNUM_WORLD && trace.ent != ENTITYNUM_NONE) )
{
result->blocked = qtrue;
result->blockentity = trace.ent;
result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
#ifdef DEBUG
//botimport.Print(PRT_MESSAGE, "%d: BotCheckBlocked: I'm blocked\n", ms->client);
#endif //DEBUG
} //end if
} //end else
} //end of the function BotCheckBlocked
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotClearMoveResult(bot_moveresult_t *moveresult)
{
moveresult->failure = qfalse;
moveresult->type = 0;
moveresult->blocked = qfalse;
moveresult->blockentity = 0;
moveresult->traveltype = 0;
moveresult->flags = 0;
} //end of the function BotClearMoveResult
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_Walk(bot_movestate_t *ms, aas_reachability_t *reach)
{
float dist, speed;
vec3_t hordir;
bot_moveresult_t result;
BotClearMoveResult(&result);
//first walk straight to the reachability start
hordir[0] = reach->start[0] - ms->origin[0];
hordir[1] = reach->start[1] - ms->origin[1];
hordir[2] = 0;
dist = VectorNormalize(hordir);
//
BotCheckBlocked(ms, hordir, qtrue, &result);
//
if (dist < 10)
{
//walk straight to the reachability end
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
dist = VectorNormalize(hordir);
} //end if
//if going towards a crouch area
if (!(AAS_AreaPresenceType(reach->areanum) & PRESENCE_NORMAL))
{
//if pretty close to the reachable area
if (dist < 20) EA_Crouch(ms->client);
} //end if
//
dist = BotGapDistance(ms->origin, hordir, ms->entitynum);
//
if (ms->moveflags & MFL_WALK)
{
if (dist > 0) speed = 200 - (180 - 1 * dist);
else speed = 200;
EA_Walk(ms->client);
} //end if
else
{
if (dist > 0) speed = 400 - (360 - 2 * dist);
else speed = 400;
} //end else
//elemantary action move in direction
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotTravel_Walk
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotFinishTravel_Walk(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t hordir;
float dist, speed;
bot_moveresult_t result;
BotClearMoveResult(&result);
//if not on the ground and changed areas... don't walk back!!
//(doesn't seem to help)
/*
ms->areanum = BotFuzzyPointReachabilityArea(ms->origin);
if (ms->areanum == reach->areanum)
{
#ifdef DEBUG
botimport.Print(PRT_MESSAGE, "BotFinishTravel_Walk: already in reach area\n");
#endif //DEBUG
return result;
} //end if*/
//go straight to the reachability end
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
dist = VectorNormalize(hordir);
//
if (dist > 100) dist = 100;
speed = 400 - (400 - 3 * dist);
//
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotFinishTravel_Walk
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_Crouch(bot_movestate_t *ms, aas_reachability_t *reach)
{
float speed;
vec3_t hordir;
bot_moveresult_t result;
BotClearMoveResult(&result);
//
speed = 400;
//walk straight to reachability end
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
VectorNormalize(hordir);
//
BotCheckBlocked(ms, hordir, qtrue, &result);
//elemantary actions
EA_Crouch(ms->client);
EA_Move(ms->client, hordir, speed);
//
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotTravel_Crouch
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_BarrierJump(bot_movestate_t *ms, aas_reachability_t *reach)
{
float dist, speed;
vec3_t hordir;
bot_moveresult_t result;
BotClearMoveResult(&result);
//walk straight to reachability start
hordir[0] = reach->start[0] - ms->origin[0];
hordir[1] = reach->start[1] - ms->origin[1];
hordir[2] = 0;
dist = VectorNormalize(hordir);
//
BotCheckBlocked(ms, hordir, qtrue, &result);
//if pretty close to the barrier
if (dist < 9)
{
EA_Jump(ms->client);
} //end if
else
{
if (dist > 60) dist = 60;
speed = 360 - (360 - 6 * dist);
EA_Move(ms->client, hordir, speed);
} //end else
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotTravel_BarrierJump
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotFinishTravel_BarrierJump(bot_movestate_t *ms, aas_reachability_t *reach)
{
float dist;
vec3_t hordir;
bot_moveresult_t result;
BotClearMoveResult(&result);
//if near the top or going down
if (ms->velocity[2] < 250)
{
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
dist = VectorNormalize(hordir);
//
BotCheckBlocked(ms, hordir, qtrue, &result);
//
EA_Move(ms->client, hordir, 400);
VectorCopy(hordir, result.movedir);
} //end if
//
return result;
} //end of the function BotFinishTravel_BarrierJump
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_Swim(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t dir;
bot_moveresult_t result;
BotClearMoveResult(&result);
//swim straight to reachability end
VectorSubtract(reach->start, ms->origin, dir);
VectorNormalize(dir);
//
BotCheckBlocked(ms, dir, qtrue, &result);
//elemantary actions
EA_Move(ms->client, dir, 400);
//
VectorCopy(dir, result.movedir);
Vector2Angles(dir, result.ideal_viewangles);
result.flags |= MOVERESULT_SWIMVIEW;
//
return result;
} //end of the function BotTravel_Swim
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_WaterJump(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t dir, hordir;
float dist;
bot_moveresult_t result;
BotClearMoveResult(&result);
//swim straight to reachability end
VectorSubtract(reach->end, ms->origin, dir);
VectorCopy(dir, hordir);
hordir[2] = 0;
dir[2] += 15 + crandom() * 40;
//botimport.Print(PRT_MESSAGE, "BotTravel_WaterJump: dir[2] = %f\n", dir[2]);
VectorNormalize(dir);
dist = VectorNormalize(hordir);
//elemantary actions
//EA_Move(ms->client, dir, 400);
EA_MoveForward(ms->client);
//move up if close to the actual out of water jump spot
if (dist < 40) EA_MoveUp(ms->client);
//set the ideal view angles
Vector2Angles(dir, result.ideal_viewangles);
result.flags |= MOVERESULT_MOVEMENTVIEW;
//
VectorCopy(dir, result.movedir);
//
return result;
} //end of the function BotTravel_WaterJump
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotFinishTravel_WaterJump(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t dir, pnt;
float dist;
bot_moveresult_t result;
//botimport.Print(PRT_MESSAGE, "BotFinishTravel_WaterJump\n");
BotClearMoveResult(&result);
//if waterjumping there's nothing to do
if (ms->moveflags & MFL_WATERJUMP) return result;
//if not touching any water anymore don't do anything
//otherwise the bot sometimes keeps jumping?
VectorCopy(ms->origin, pnt);
pnt[2] -= 32; //extra for q2dm4 near red armor/mega health
if (!(AAS_PointContents(pnt) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER))) return result;
//swim straight to reachability end
VectorSubtract(reach->end, ms->origin, dir);
dir[0] += crandom() * 10;
dir[1] += crandom() * 10;
dir[2] += 70 + crandom() * 10;
dist = VectorNormalize(dir);
//elemantary actions
EA_Move(ms->client, dir, 400);
//set the ideal view angles
Vector2Angles(dir, result.ideal_viewangles);
result.flags |= MOVERESULT_MOVEMENTVIEW;
//
VectorCopy(dir, result.movedir);
//
return result;
} //end of the function BotFinishTravel_WaterJump
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_WalkOffLedge(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t hordir, dir;
float dist, speed, reachhordist;
bot_moveresult_t result;
BotClearMoveResult(&result);
//check if the bot is blocked by anything
VectorSubtract(reach->start, ms->origin, dir);
VectorNormalize(dir);
BotCheckBlocked(ms, dir, qtrue, &result);
//if the reachability start and end are practially above each other
VectorSubtract(reach->end, reach->start, dir);
dir[2] = 0;
reachhordist = VectorLength(dir);
//walk straight to the reachability start
hordir[0] = reach->start[0] - ms->origin[0];
hordir[1] = reach->start[1] - ms->origin[1];
hordir[2] = 0;
dist = VectorNormalize(hordir);
//if pretty close to the start focus on the reachability end
if (dist < 48)
{
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
VectorNormalize(hordir);
//
if (reachhordist < 20)
{
speed = 100;
} //end if
else if (!AAS_HorizontalVelocityForJump(0, reach->start, reach->end, &speed))
{
speed = 400;
} //end if
} //end if
else
{
if (reachhordist < 20)
{
if (dist > 64) dist = 64;
speed = 400 - (256 - 4 * dist);
} //end if
else
{
speed = 400;
} //end else
} //end else
//
BotCheckBlocked(ms, hordir, qtrue, &result);
//elemantary action
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotTravel_WalkOffLedge
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotAirControl(vec3_t origin, vec3_t velocity, vec3_t goal, vec3_t dir, float *speed)
{
vec3_t org, vel;
float dist;
int i;
VectorCopy(origin, org);
VectorScale(velocity, 0.1, vel);
for (i = 0; i < 50; i++)
{
vel[2] -= sv_gravity->value * 0.01;
//if going down and next position would be below the goal
if (vel[2] < 0 && org[2] + vel[2] < goal[2])
{
VectorScale(vel, (goal[2] - org[2]) / vel[2], vel);
VectorAdd(org, vel, org);
VectorSubtract(goal, org, dir);
dist = VectorNormalize(dir);
if (dist > 32) dist = 32;
*speed = 400 - (400 - 13 * dist);
return qtrue;
} //end if
else
{
VectorAdd(org, vel, org);
} //end else
} //end for
VectorSet(dir, 0, 0, 0);
*speed = 400;
return qfalse;
} //end of the function BotAirControl
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotFinishTravel_WalkOffLedge(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t dir, hordir, end, v;
float dist, speed;
bot_moveresult_t result;
BotClearMoveResult(&result);
//
VectorSubtract(reach->end, ms->origin, dir);
BotCheckBlocked(ms, dir, qtrue, &result);
//
VectorSubtract(reach->end, ms->origin, v);
v[2] = 0;
dist = VectorNormalize(v);
if (dist > 16) VectorMA(reach->end, 16, v, end);
else VectorCopy(reach->end, end);
//
if (!BotAirControl(ms->origin, ms->velocity, end, hordir, &speed))
{
//go straight to the reachability end
VectorCopy(dir, hordir);
hordir[2] = 0;
//
dist = VectorNormalize(hordir);
speed = 400;
} //end if
//
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotFinishTravel_WalkOffLedge
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
/*
bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t hordir;
float dist, gapdist, speed, horspeed, sv_jumpvel;
bot_moveresult_t result;
BotClearMoveResult(&result);
//
sv_jumpvel = botlibglobals.sv_jumpvel->value;
//walk straight to the reachability start
hordir[0] = reach->start[0] - ms->origin[0];
hordir[1] = reach->start[1] - ms->origin[1];
hordir[2] = 0;
dist = VectorNormalize(hordir);
//
speed = 350;
//
gapdist = BotGapDistance(ms, hordir, ms->entitynum);
//if pretty close to the start focus on the reachability end
if (dist < 50 || (gapdist && gapdist < 50))
{
//NOTE: using max speed (400) works best
//if (AAS_HorizontalVelocityForJump(sv_jumpvel, ms->origin, reach->end, &horspeed))
//{
// speed = horspeed * 400 / botlibglobals.sv_maxwalkvelocity->value;
//} //end if
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
VectorNormalize(hordir);
//elemantary action jump
EA_Jump(ms->client);
//
ms->jumpreach = ms->lastreachnum;
speed = 600;
} //end if
else
{
if (AAS_HorizontalVelocityForJump(sv_jumpvel, reach->start, reach->end, &horspeed))
{
speed = horspeed * 400 / botlibglobals.sv_maxwalkvelocity->value;
} //end if
} //end else
//elemantary action
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotTravel_Jump*/
/*
bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t hordir, dir1, dir2, mins, maxs, start, end;
float dist1, dist2, speed;
bot_moveresult_t result;
bsp_trace_t trace;
BotClearMoveResult(&result);
//
hordir[0] = reach->start[0] - reach->end[0];
hordir[1] = reach->start[1] - reach->end[1];
hordir[2] = 0;
VectorNormalize(hordir);
//
VectorCopy(reach->start, start);
start[2] += 1;
//minus back the bouding box size plus 16
VectorMA(reach->start, 80, hordir, end);
//
AAS_PresenceTypeBoundingBox(PRESENCE_NORMAL, mins, maxs);
//check for solids
trace = AAS_Trace(start, mins, maxs, end, ms->entitynum, MASK_PLAYERSOLID);
if (trace.startsolid) VectorCopy(start, trace.endpos);
//check for a gap
for (dist1 = 0; dist1 < 80; dist1 += 10)
{
VectorMA(start, dist1+10, hordir, end);
end[2] += 1;
if (AAS_PointAreaNum(end) != ms->reachareanum) break;
} //end for
if (dist1 < 80) VectorMA(reach->start, dist1, hordir, trace.endpos);
// dist1 = BotGapDistance(start, hordir, ms->entitynum);
// if (dist1 && dist1 <= trace.fraction * 80) VectorMA(reach->start, dist1-20, hordir, trace.endpos);
//
VectorSubtract(ms->origin, reach->start, dir1);
dir1[2] = 0;
dist1 = VectorNormalize(dir1);
VectorSubtract(ms->origin, trace.endpos, dir2);
dir2[2] = 0;
dist2 = VectorNormalize(dir2);
//if just before the reachability start
if (DotProduct(dir1, dir2) < -0.8 || dist2 < 5)
{
//botimport.Print(PRT_MESSAGE, "between jump start and run to point\n");
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
VectorNormalize(hordir);
//elemantary action jump
if (dist1 < 24) EA_Jump(ms->client);
else if (dist1 < 32) EA_DelayedJump(ms->client);
EA_Move(ms->client, hordir, 600);
//
ms->jumpreach = ms->lastreachnum;
} //end if
else
{
//botimport.Print(PRT_MESSAGE, "going towards run to point\n");
hordir[0] = trace.endpos[0] - ms->origin[0];
hordir[1] = trace.endpos[1] - ms->origin[1];
hordir[2] = 0;
VectorNormalize(hordir);
//
if (dist2 > 80) dist2 = 80;
speed = 400 - (400 - 5 * dist2);
EA_Move(ms->client, hordir, speed);
} //end else
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotTravel_Jump*/
//*
bot_moveresult_t BotTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t hordir, dir1, dir2, start, end, runstart;
// vec3_t runstart, dir1, dir2, hordir;
float dist1, dist2, speed;
bot_moveresult_t result;
BotClearMoveResult(&result);
//
AAS_JumpReachRunStart(reach, runstart);
//*
hordir[0] = runstart[0] - reach->start[0];
hordir[1] = runstart[1] - reach->start[1];
hordir[2] = 0;
VectorNormalize(hordir);
//
VectorCopy(reach->start, start);
start[2] += 1;
VectorMA(reach->start, 80, hordir, runstart);
//check for a gap
for (dist1 = 0; dist1 < 80; dist1 += 10)
{
VectorMA(start, dist1+10, hordir, end);
end[2] += 1;
if (AAS_PointAreaNum(end) != ms->reachareanum) break;
} //end for
if (dist1 < 80) VectorMA(reach->start, dist1, hordir, runstart);
//
VectorSubtract(ms->origin, reach->start, dir1);
dir1[2] = 0;
dist1 = VectorNormalize(dir1);
VectorSubtract(ms->origin, runstart, dir2);
dir2[2] = 0;
dist2 = VectorNormalize(dir2);
//if just before the reachability start
if (DotProduct(dir1, dir2) < -0.8 || dist2 < 5)
{
// botimport.Print(PRT_MESSAGE, "between jump start and run start point\n");
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
VectorNormalize(hordir);
//elemantary action jump
if (dist1 < 24) EA_Jump(ms->client);
else if (dist1 < 32) EA_DelayedJump(ms->client);
EA_Move(ms->client, hordir, 600);
//
ms->jumpreach = ms->lastreachnum;
} //end if
else
{
// botimport.Print(PRT_MESSAGE, "going towards run start point\n");
hordir[0] = runstart[0] - ms->origin[0];
hordir[1] = runstart[1] - ms->origin[1];
hordir[2] = 0;
VectorNormalize(hordir);
//
if (dist2 > 80) dist2 = 80;
speed = 400 - (400 - 5 * dist2);
EA_Move(ms->client, hordir, speed);
} //end else
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotTravel_Jump*/
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotFinishTravel_Jump(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t hordir, hordir2;
float speed, dist;
bot_moveresult_t result;
BotClearMoveResult(&result);
//if not jumped yet
if (!ms->jumpreach) return result;
//go straight to the reachability end
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
dist = VectorNormalize(hordir);
//
hordir2[0] = reach->end[0] - reach->start[0];
hordir2[1] = reach->end[1] - reach->start[1];
hordir2[2] = 0;
VectorNormalize(hordir2);
//
if (DotProduct(hordir, hordir2) < -0.5 && dist < 24) return result;
//always use max speed when traveling through the air
speed = 800;
//
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotFinishTravel_Jump
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_Ladder(bot_movestate_t *ms, aas_reachability_t *reach)
{
//float dist, speed;
vec3_t dir, viewdir;//, hordir;
vec3_t origin = {0, 0, 0};
// vec3_t up = {0, 0, 1};
bot_moveresult_t result;
BotClearMoveResult(&result);
//
// if ((ms->moveflags & MFL_AGAINSTLADDER))
//NOTE: not a good idea for ladders starting in water
// || !(ms->moveflags & MFL_ONGROUND))
{
//botimport.Print(PRT_MESSAGE, "against ladder or not on ground\n");
VectorSubtract(reach->end, ms->origin, dir);
VectorNormalize(dir);
//set the ideal view angles, facing the ladder up or down
viewdir[0] = dir[0];
viewdir[1] = dir[1];
viewdir[2] = 3 * dir[2];
Vector2Angles(viewdir, result.ideal_viewangles);
//elemantary action
EA_Move(ms->client, origin, 0);
EA_MoveForward(ms->client);
//set movement view flag so the AI can see the view is focussed
result.flags |= MOVERESULT_MOVEMENTVIEW;
} //end if
/* else
{
//botimport.Print(PRT_MESSAGE, "moving towards ladder\n");
VectorSubtract(reach->end, ms->origin, dir);
//make sure the horizontal movement is large anough
VectorCopy(dir, hordir);
hordir[2] = 0;
dist = VectorNormalize(hordir);
//
dir[0] = hordir[0];
dir[1] = hordir[1];
if (dir[2] > 0) dir[2] = 1;
else dir[2] = -1;
if (dist > 50) dist = 50;
speed = 400 - (200 - 4 * dist);
EA_Move(ms->client, dir, speed);
} //end else*/
//save the movement direction
VectorCopy(dir, result.movedir);
//
return result;
} //end of the function BotTravel_Ladder
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_Teleport(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t hordir;
float dist;
bot_moveresult_t result;
BotClearMoveResult(&result);
//if the bot is being teleported
if (ms->moveflags & MFL_TELEPORTED) return result;
//walk straight to center of the teleporter
VectorSubtract(reach->start, ms->origin, hordir);
if (!(ms->moveflags & MFL_SWIMMING)) hordir[2] = 0;
dist = VectorNormalize(hordir);
//
BotCheckBlocked(ms, hordir, qtrue, &result);
if (dist < 30) EA_Move(ms->client, hordir, 200);
else EA_Move(ms->client, hordir, 400);
if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
VectorCopy(hordir, result.movedir);
return result;
} //end of the function BotTravel_Teleport
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_Elevator(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t dir, dir1, dir2, hordir, bottomcenter;
float dist, dist1, dist2, speed;
bot_moveresult_t result;
BotClearMoveResult(&result);
//if standing on the plat
if (BotOnMover(ms->origin, ms->entitynum, reach))
{
#ifdef DEBUG_ELEVATOR
botimport.Print(PRT_MESSAGE, "bot on elevator\n");
#endif //DEBUG_ELEVATOR
//if vertically not too far from the end point
if (abs(ms->origin[2] - reach->end[2]) < sv_maxbarrier->value)
{
#ifdef DEBUG_ELEVATOR
botimport.Print(PRT_MESSAGE, "bot moving to end\n");
#endif //DEBUG_ELEVATOR
//move to the end point
VectorSubtract(reach->end, ms->origin, hordir);
hordir[2] = 0;
VectorNormalize(hordir);
if (!BotCheckBarrierJump(ms, hordir, 100))
{
EA_Move(ms->client, hordir, 400);
} //end if
VectorCopy(hordir, result.movedir);
} //end else
//if not really close to the center of the elevator
else
{
MoverBottomCenter(reach, bottomcenter);
VectorSubtract(bottomcenter, ms->origin, hordir);
hordir[2] = 0;
dist = VectorNormalize(hordir);
//
if (dist > 10)
{
#ifdef DEBUG_ELEVATOR
botimport.Print(PRT_MESSAGE, "bot moving to center\n");
#endif //DEBUG_ELEVATOR
//move to the center of the plat
if (dist > 100) dist = 100;
speed = 400 - (400 - 4 * dist);
//
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
} //end if
} //end else
} //end if
else
{
#ifdef DEBUG_ELEVATOR
botimport.Print(PRT_MESSAGE, "bot not on elevator\n");
#endif //DEBUG_ELEVATOR
//if very near the reachability end
VectorSubtract(reach->end, ms->origin, dir);
dist = VectorLength(dir);
if (dist < 64)
{
if (dist > 60) dist = 60;
speed = 360 - (360 - 6 * dist);
//
if ((ms->moveflags & MFL_SWIMMING) || !BotCheckBarrierJump(ms, dir, 50))
{
if (speed > 5) EA_Move(ms->client, dir, speed);
} //end if
VectorCopy(dir, result.movedir);
//
if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
//stop using this reachability
ms->reachability_time = 0;
return result;
} //end if
//get direction and distance to reachability start
VectorSubtract(reach->start, ms->origin, dir1);
if (!(ms->moveflags & MFL_SWIMMING)) dir1[2] = 0;
dist1 = VectorNormalize(dir1);
//if the elevator isn't down
if (!MoverDown(reach))
{
#ifdef DEBUG_ELEVATOR
botimport.Print(PRT_MESSAGE, "elevator not down\n");
#endif //DEBUG_ELEVATOR
dist = dist1;
VectorCopy(dir1, dir);
//
BotCheckBlocked(ms, dir, qfalse, &result);
//
if (dist > 60) dist = 60;
speed = 360 - (360 - 6 * dist);
//
if (!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
{
if (speed > 5) EA_Move(ms->client, dir, speed);
} //end if
VectorCopy(dir, result.movedir);
//
if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
//this isn't a failure... just wait till the elevator comes down
result.type = RESULTTYPE_ELEVATORUP;
result.flags |= MOVERESULT_WAITING;
return result;
} //end if
//get direction and distance to elevator bottom center
MoverBottomCenter(reach, bottomcenter);
VectorSubtract(bottomcenter, ms->origin, dir2);
if (!(ms->moveflags & MFL_SWIMMING)) dir2[2] = 0;
dist2 = VectorNormalize(dir2);
//if very close to the reachability start or
//closer to the elevator center or
//between reachability start and elevator center
if (dist1 < 20 || dist2 < dist1 || DotProduct(dir1, dir2) < 0)
{
#ifdef DEBUG_ELEVATOR
botimport.Print(PRT_MESSAGE, "bot moving to center\n");
#endif //DEBUG_ELEVATOR
dist = dist2;
VectorCopy(dir2, dir);
} //end if
else //closer to the reachability start
{
#ifdef DEBUG_ELEVATOR
botimport.Print(PRT_MESSAGE, "bot moving to start\n");
#endif //DEBUG_ELEVATOR
dist = dist1;
VectorCopy(dir1, dir);
} //end else
//
BotCheckBlocked(ms, dir, qfalse, &result);
//
if (dist > 60) dist = 60;
speed = 400 - (400 - 6 * dist);
//
if (!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
{
EA_Move(ms->client, dir, speed);
} //end if
VectorCopy(dir, result.movedir);
//
if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
} //end else
return result;
} //end of the function BotTravel_Elevator
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotFinishTravel_Elevator(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t bottomcenter, bottomdir, topdir;
bot_moveresult_t result;
BotClearMoveResult(&result);
//
MoverBottomCenter(reach, bottomcenter);
VectorSubtract(bottomcenter, ms->origin, bottomdir);
//
VectorSubtract(reach->end, ms->origin, topdir);
//
if (fabs(bottomdir[2]) < fabs(topdir[2]))
{
VectorNormalize(bottomdir);
EA_Move(ms->client, bottomdir, 300);
} //end if
else
{
VectorNormalize(topdir);
EA_Move(ms->client, topdir, 300);
} //end else
return result;
} //end of the function BotFinishTravel_Elevator
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotFuncBobStartEnd(aas_reachability_t *reach, vec3_t start, vec3_t end, vec3_t origin)
{
int spawnflags, modelnum;
vec3_t mins, maxs, mid, angles = {0, 0, 0};
int num0, num1;
modelnum = reach->facenum & 0x0000FFFF;
if (!AAS_OriginOfMoverWithModelNum(modelnum, origin))
{
botimport.Print(PRT_MESSAGE, "BotFuncBobStartEnd: no entity with model %d\n", modelnum);
VectorSet(start, 0, 0, 0);
VectorSet(end, 0, 0, 0);
return;
} //end if
AAS_BSPModelMinsMaxsOrigin(modelnum, angles, mins, maxs, NULL);
VectorAdd(mins, maxs, mid);
VectorScale(mid, 0.5, mid);
VectorCopy(mid, start);
VectorCopy(mid, end);
spawnflags = reach->facenum >> 16;
num0 = reach->edgenum >> 16;
if (num0 > 0x00007FFF) num0 |= 0xFFFF0000;
num1 = reach->edgenum & 0x0000FFFF;
if (num1 > 0x00007FFF) num1 |= 0xFFFF0000;
if (spawnflags & 1)
{
start[0] = num0;
end[0] = num1;
//
origin[0] += mid[0];
origin[1] = mid[1];
origin[2] = mid[2];
} //end if
else if (spawnflags & 2)
{
start[1] = num0;
end[1] = num1;
//
origin[0] = mid[0];
origin[1] += mid[1];
origin[2] = mid[2];
} //end else if
else
{
start[2] = num0;
end[2] = num1;
//
origin[0] = mid[0];
origin[1] = mid[1];
origin[2] += mid[2];
} //end else
} //end of the function BotFuncBobStartEnd
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_FuncBobbing(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t dir, dir1, dir2, hordir, bottomcenter, bob_start, bob_end, bob_origin;
float dist, dist1, dist2, speed;
bot_moveresult_t result;
BotClearMoveResult(&result);
//
BotFuncBobStartEnd(reach, bob_start, bob_end, bob_origin);
//if standing ontop of the func_bobbing
if (BotOnMover(ms->origin, ms->entitynum, reach))
{
#ifdef DEBUG_FUNCBOB
botimport.Print(PRT_MESSAGE, "bot on func_bobbing\n");
#endif
//if near end point of reachability
VectorSubtract(bob_origin, bob_end, dir);
if (VectorLength(dir) < 24)
{
#ifdef DEBUG_FUNCBOB
botimport.Print(PRT_MESSAGE, "bot moving to reachability end\n");
#endif
//move to the end point
VectorSubtract(reach->end, ms->origin, hordir);
hordir[2] = 0;
VectorNormalize(hordir);
if (!BotCheckBarrierJump(ms, hordir, 100))
{
EA_Move(ms->client, hordir, 400);
} //end if
VectorCopy(hordir, result.movedir);
} //end else
//if not really close to the center of the elevator
else
{
MoverBottomCenter(reach, bottomcenter);
VectorSubtract(bottomcenter, ms->origin, hordir);
hordir[2] = 0;
dist = VectorNormalize(hordir);
//
if (dist > 10)
{
#ifdef DEBUG_FUNCBOB
botimport.Print(PRT_MESSAGE, "bot moving to func_bobbing center\n");
#endif
//move to the center of the plat
if (dist > 100) dist = 100;
speed = 400 - (400 - 4 * dist);
//
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
} //end if
} //end else
} //end if
else
{
#ifdef DEBUG_FUNCBOB
botimport.Print(PRT_MESSAGE, "bot not ontop of func_bobbing\n");
#endif
//if very near the reachability end
VectorSubtract(reach->end, ms->origin, dir);
dist = VectorLength(dir);
if (dist < 64)
{
#ifdef DEBUG_FUNCBOB
botimport.Print(PRT_MESSAGE, "bot moving to end\n");
#endif
if (dist > 60) dist = 60;
speed = 360 - (360 - 6 * dist);
//if swimming or no barrier jump
if ((ms->moveflags & MFL_SWIMMING) || !BotCheckBarrierJump(ms, dir, 50))
{
if (speed > 5) EA_Move(ms->client, dir, speed);
} //end if
VectorCopy(dir, result.movedir);
//
if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
//stop using this reachability
ms->reachability_time = 0;
return result;
} //end if
//get direction and distance to reachability start
VectorSubtract(reach->start, ms->origin, dir1);
if (!(ms->moveflags & MFL_SWIMMING)) dir1[2] = 0;
dist1 = VectorNormalize(dir1);
//if func_bobbing is Not it's start position
VectorSubtract(bob_origin, bob_start, dir);
if (VectorLength(dir) > 16)
{
#ifdef DEBUG_FUNCBOB
botimport.Print(PRT_MESSAGE, "func_bobbing not at start\n");
#endif
dist = dist1;
VectorCopy(dir1, dir);
//
BotCheckBlocked(ms, dir, qfalse, &result);
//
if (dist > 60) dist = 60;
speed = 360 - (360 - 6 * dist);
//
if (!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
{
if (speed > 5) EA_Move(ms->client, dir, speed);
} //end if
VectorCopy(dir, result.movedir);
//
if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
//this isn't a failure... just wait till the func_bobbing arrives
result.type = RESULTTYPE_WAITFORFUNCBOBBING;
result.flags |= MOVERESULT_WAITING;
return result;
} //end if
//get direction and distance to func_bob bottom center
MoverBottomCenter(reach, bottomcenter);
VectorSubtract(bottomcenter, ms->origin, dir2);
if (!(ms->moveflags & MFL_SWIMMING)) dir2[2] = 0;
dist2 = VectorNormalize(dir2);
//if very close to the reachability start or
//closer to the elevator center or
//between reachability start and func_bobbing center
if (dist1 < 20 || dist2 < dist1 || DotProduct(dir1, dir2) < 0)
{
#ifdef DEBUG_FUNCBOB
botimport.Print(PRT_MESSAGE, "bot moving to func_bobbing center\n");
#endif
dist = dist2;
VectorCopy(dir2, dir);
} //end if
else //closer to the reachability start
{
#ifdef DEBUG_FUNCBOB
botimport.Print(PRT_MESSAGE, "bot moving to reachability start\n");
#endif
dist = dist1;
VectorCopy(dir1, dir);
} //end else
//
BotCheckBlocked(ms, dir, qfalse, &result);
//
if (dist > 60) dist = 60;
speed = 400 - (400 - 6 * dist);
//
if (!(ms->moveflags & MFL_SWIMMING) && !BotCheckBarrierJump(ms, dir, 50))
{
EA_Move(ms->client, dir, speed);
} //end if
VectorCopy(dir, result.movedir);
//
if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
} //end else
return result;
} //end of the function BotTravel_FuncBobbing
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotFinishTravel_FuncBobbing(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t bob_origin, bob_start, bob_end, dir, hordir, bottomcenter;
bot_moveresult_t result;
float dist, speed;
BotClearMoveResult(&result);
//
BotFuncBobStartEnd(reach, bob_start, bob_end, bob_origin);
//
VectorSubtract(bob_origin, bob_end, dir);
dist = VectorLength(dir);
//if the func_bobbing is near the end
if (dist < 16)
{
VectorSubtract(reach->end, ms->origin, hordir);
if (!(ms->moveflags & MFL_SWIMMING)) hordir[2] = 0;
dist = VectorNormalize(hordir);
//
if (dist > 60) dist = 60;
speed = 360 - (360 - 6 * dist);
//
if (speed > 5) EA_Move(ms->client, dir, speed);
VectorCopy(dir, result.movedir);
//
if (ms->moveflags & MFL_SWIMMING) result.flags |= MOVERESULT_SWIMVIEW;
} //end if
else
{
MoverBottomCenter(reach, bottomcenter);
VectorSubtract(bottomcenter, ms->origin, hordir);
if (!(ms->moveflags & MFL_SWIMMING)) hordir[2] = 0;
dist = VectorNormalize(hordir);
//
if (dist > 5)
{
//move to the center of the plat
if (dist > 100) dist = 100;
speed = 400 - (400 - 4 * dist);
//
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
} //end if
} //end else
return result;
} //end of the function BotFinishTravel_FuncBobbing
//===========================================================================
// 0 no valid grapple hook visible
// 1 the grapple hook is still flying
// 2 the grapple hooked into a wall
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int GrappleState(bot_movestate_t *ms, aas_reachability_t *reach)
{
int i;
aas_entityinfo_t entinfo;
//if the grapple hook is pulling
if (ms->moveflags & MFL_GRAPPLEPULL)
return 2;
//check for a visible grapple missile entity
//or visible grapple entity
for (i = AAS_NextEntity(0); i; i = AAS_NextEntity(i))
{
if (AAS_EntityType(i) == (int) entitytypemissile->value)
{
AAS_EntityInfo(i, &entinfo);
if (entinfo.weapon == (int) weapindex_grapple->value)
{
return 1;
} //end if
} //end if
} //end for
//no valid grapple at all
return 0;
} //end of the function GrappleState
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotResetGrapple(bot_movestate_t *ms)
{
aas_reachability_t reach;
AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
//if not using the grapple hook reachability anymore
if ((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_GRAPPLEHOOK)
{
if ((ms->moveflags & MFL_ACTIVEGRAPPLE) || ms->grapplevisible_time)
{
if (offhandgrapple->value)
EA_Command(ms->client, cmd_grappleoff->string);
ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
ms->grapplevisible_time = 0;
#ifdef DEBUG_GRAPPLE
botimport.Print(PRT_MESSAGE, "reset grapple\n");
#endif //DEBUG_GRAPPLE
} //end if
} //end if
} //end of the function BotResetGrapple
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_Grapple(bot_movestate_t *ms, aas_reachability_t *reach)
{
bot_moveresult_t result;
float dist, speed;
vec3_t dir, viewdir, org;
int state, areanum;
bsp_trace_t trace;
#ifdef DEBUG_GRAPPLE
static int debugline;
if (!debugline) debugline = botimport.DebugLineCreate();
botimport.DebugLineShow(debugline, reach->start, reach->end, LINECOLOR_BLUE);
#endif //DEBUG_GRAPPLE
BotClearMoveResult(&result);
//
if (ms->moveflags & MFL_GRAPPLERESET)
{
if (offhandgrapple->value)
EA_Command(ms->client, cmd_grappleoff->string);
ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
return result;
} //end if
//
if (!(int) offhandgrapple->value)
{
result.weapon = weapindex_grapple->value;
result.flags |= MOVERESULT_MOVEMENTWEAPON;
} //end if
//
if (ms->moveflags & MFL_ACTIVEGRAPPLE)
{
#ifdef DEBUG_GRAPPLE
botimport.Print(PRT_MESSAGE, "BotTravel_Grapple: active grapple\n");
#endif //DEBUG_GRAPPLE
//
state = GrappleState(ms, reach);
//
VectorSubtract(reach->end, ms->origin, dir);
dir[2] = 0;
dist = VectorLength(dir);
//if very close to the grapple end or the grappled is hooked and
//the bot doesn't get any closer
if (state && dist < 48)
{
if (ms->lastgrappledist - dist < 1)
{
#ifdef DEBUG_GRAPPLE
botimport.Print(PRT_ERROR, "grapple normal end\n");
#endif //DEBUG_GRAPPLE
if (offhandgrapple->value)
EA_Command(ms->client, cmd_grappleoff->string);
ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
ms->moveflags |= MFL_GRAPPLERESET;
ms->reachability_time = 0; //end the reachability
return result;
} //end if
} //end if
//if no valid grapple at all, or the grapple hooked and the bot
//isn't moving anymore
else if (!state || (state == 2 && dist > ms->lastgrappledist - 2))
{
if (ms->grapplevisible_time < AAS_Time() - 0.4)
{
#ifdef DEBUG_GRAPPLE
botimport.Print(PRT_ERROR, "grapple not visible\n");
#endif //DEBUG_GRAPPLE
if (offhandgrapple->value)
EA_Command(ms->client, cmd_grappleoff->string);
ms->moveflags &= ~MFL_ACTIVEGRAPPLE;
ms->moveflags |= MFL_GRAPPLERESET;
ms->reachability_time = 0; //end the reachability
return result;
} //end if
} //end if
else
{
ms->grapplevisible_time = AAS_Time();
} //end else
//
if (!(int) offhandgrapple->value)
{
EA_Attack(ms->client);
} //end if
//remember the current grapple distance
ms->lastgrappledist = dist;
} //end if
else
{
#ifdef DEBUG_GRAPPLE
botimport.Print(PRT_MESSAGE, "BotTravel_Grapple: inactive grapple\n");
#endif //DEBUG_GRAPPLE
//
ms->grapplevisible_time = AAS_Time();
//
VectorSubtract(reach->start, ms->origin, dir);
if (!(ms->moveflags & MFL_SWIMMING)) dir[2] = 0;
VectorAdd(ms->origin, ms->viewoffset, org);
VectorSubtract(reach->end, org, viewdir);
//
dist = VectorNormalize(dir);
Vector2Angles(viewdir, result.ideal_viewangles);
result.flags |= MOVERESULT_MOVEMENTVIEW;
//
if (dist < 5 &&
fabs(AngleDiff(result.ideal_viewangles[0], ms->viewangles[0])) < 2 &&
fabs(AngleDiff(result.ideal_viewangles[1], ms->viewangles[1])) < 2)
{
#ifdef DEBUG_GRAPPLE
botimport.Print(PRT_MESSAGE, "BotTravel_Grapple: activating grapple\n");
#endif //DEBUG_GRAPPLE
//check if the grapple missile path is clear
VectorAdd(ms->origin, ms->viewoffset, org);
trace = AAS_Trace(org, NULL, NULL, reach->end, ms->entitynum, CONTENTS_SOLID);
VectorSubtract(reach->end, trace.endpos, dir);
if (VectorLength(dir) > 16)
{
result.failure = qtrue;
return result;
} //end if
//activate the grapple
if (offhandgrapple->value)
{
EA_Command(ms->client, cmd_grappleon->string);
} //end if
else
{
EA_Attack(ms->client);
} //end else
ms->moveflags |= MFL_ACTIVEGRAPPLE;
ms->lastgrappledist = 999999;
} //end if
else
{
if (dist < 70) speed = 300 - (300 - 4 * dist);
else speed = 400;
//
BotCheckBlocked(ms, dir, qtrue, &result);
//elemantary action move in direction
EA_Move(ms->client, dir, speed);
VectorCopy(dir, result.movedir);
} //end else
//if in another area before actually grappling
areanum = AAS_PointAreaNum(ms->origin);
if (areanum && areanum != ms->reachareanum) ms->reachability_time = 0;
} //end else
return result;
} //end of the function BotTravel_Grapple
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_RocketJump(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t hordir;
float dist, speed;
bot_moveresult_t result;
//botimport.Print(PRT_MESSAGE, "BotTravel_RocketJump: bah\n");
BotClearMoveResult(&result);
//
hordir[0] = reach->start[0] - ms->origin[0];
hordir[1] = reach->start[1] - ms->origin[1];
hordir[2] = 0;
//
dist = VectorNormalize(hordir);
//look in the movement direction
Vector2Angles(hordir, result.ideal_viewangles);
//look straight down
result.ideal_viewangles[PITCH] = 90;
//
if (dist < 5 &&
fabs(AngleDiff(result.ideal_viewangles[0], ms->viewangles[0])) < 5 &&
fabs(AngleDiff(result.ideal_viewangles[1], ms->viewangles[1])) < 5)
{
//botimport.Print(PRT_MESSAGE, "between jump start and run start point\n");
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
VectorNormalize(hordir);
//elemantary action jump
EA_Jump(ms->client);
EA_Attack(ms->client);
EA_Move(ms->client, hordir, 800);
//
ms->jumpreach = ms->lastreachnum;
} //end if
else
{
if (dist > 80) dist = 80;
speed = 400 - (400 - 5 * dist);
EA_Move(ms->client, hordir, speed);
} //end else
//look in the movement direction
Vector2Angles(hordir, result.ideal_viewangles);
//look straight down
result.ideal_viewangles[PITCH] = 90;
//set the view angles directly
EA_View(ms->client, result.ideal_viewangles);
//view is important for the movment
result.flags |= MOVERESULT_MOVEMENTVIEWSET;
//select the rocket launcher
EA_SelectWeapon(ms->client, (int) weapindex_rocketlauncher->value);
//weapon is used for movement
result.weapon = (int) weapindex_rocketlauncher->value;
result.flags |= MOVERESULT_MOVEMENTWEAPON;
//
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotTravel_RocketJump
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_BFGJump(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t hordir;
float dist, speed;
bot_moveresult_t result;
//botimport.Print(PRT_MESSAGE, "BotTravel_BFGJump: bah\n");
BotClearMoveResult(&result);
//
hordir[0] = reach->start[0] - ms->origin[0];
hordir[1] = reach->start[1] - ms->origin[1];
hordir[2] = 0;
//
dist = VectorNormalize(hordir);
//
if (dist < 5 &&
fabs(AngleDiff(result.ideal_viewangles[0], ms->viewangles[0])) < 5 &&
fabs(AngleDiff(result.ideal_viewangles[1], ms->viewangles[1])) < 5)
{
//botimport.Print(PRT_MESSAGE, "between jump start and run start point\n");
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
VectorNormalize(hordir);
//elemantary action jump
EA_Jump(ms->client);
EA_Attack(ms->client);
EA_Move(ms->client, hordir, 800);
//
ms->jumpreach = ms->lastreachnum;
} //end if
else
{
if (dist > 80) dist = 80;
speed = 400 - (400 - 5 * dist);
EA_Move(ms->client, hordir, speed);
} //end else
//look in the movement direction
Vector2Angles(hordir, result.ideal_viewangles);
//look straight down
result.ideal_viewangles[PITCH] = 90;
//set the view angles directly
EA_View(ms->client, result.ideal_viewangles);
//view is important for the movment
result.flags |= MOVERESULT_MOVEMENTVIEWSET;
//select the rocket launcher
EA_SelectWeapon(ms->client, (int) weapindex_bfg10k->value);
//weapon is used for movement
result.weapon = (int) weapindex_bfg10k->value;
result.flags |= MOVERESULT_MOVEMENTWEAPON;
//
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotTravel_BFGJump
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotFinishTravel_WeaponJump(bot_movestate_t *ms, aas_reachability_t *reach)
{
vec3_t hordir;
float speed;
bot_moveresult_t result;
BotClearMoveResult(&result);
//if not jumped yet
if (!ms->jumpreach) return result;
/*
//go straight to the reachability end
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
VectorNormalize(hordir);
//always use max speed when traveling through the air
EA_Move(ms->client, hordir, 800);
VectorCopy(hordir, result.movedir);
*/
//
if (!BotAirControl(ms->origin, ms->velocity, reach->end, hordir, &speed))
{
//go straight to the reachability end
VectorSubtract(reach->end, ms->origin, hordir);
hordir[2] = 0;
VectorNormalize(hordir);
speed = 400;
} //end if
//
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotFinishTravel_WeaponJump
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotTravel_JumpPad(bot_movestate_t *ms, aas_reachability_t *reach)
{
float dist, speed;
vec3_t hordir;
bot_moveresult_t result;
BotClearMoveResult(&result);
//first walk straight to the reachability start
hordir[0] = reach->start[0] - ms->origin[0];
hordir[1] = reach->start[1] - ms->origin[1];
hordir[2] = 0;
dist = VectorNormalize(hordir);
//
BotCheckBlocked(ms, hordir, qtrue, &result);
speed = 400;
//elemantary action move in direction
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotTravel_JumpPad
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotFinishTravel_JumpPad(bot_movestate_t *ms, aas_reachability_t *reach)
{
float speed;
vec3_t hordir;
bot_moveresult_t result;
BotClearMoveResult(&result);
if (!BotAirControl(ms->origin, ms->velocity, reach->end, hordir, &speed))
{
hordir[0] = reach->end[0] - ms->origin[0];
hordir[1] = reach->end[1] - ms->origin[1];
hordir[2] = 0;
VectorNormalize(hordir);
speed = 400;
} //end if
BotCheckBlocked(ms, hordir, qtrue, &result);
//elemantary action move in direction
EA_Move(ms->client, hordir, speed);
VectorCopy(hordir, result.movedir);
//
return result;
} //end of the function BotFinishTravel_JumpPad
//===========================================================================
// time before the reachability times out
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotReachabilityTime(aas_reachability_t *reach)
{
switch(reach->traveltype & TRAVELTYPE_MASK)
{
case TRAVEL_WALK: return 5;
case TRAVEL_CROUCH: return 5;
case TRAVEL_BARRIERJUMP: return 5;
case TRAVEL_LADDER: return 6;
case TRAVEL_WALKOFFLEDGE: return 5;
case TRAVEL_JUMP: return 5;
case TRAVEL_SWIM: return 5;
case TRAVEL_WATERJUMP: return 5;
case TRAVEL_TELEPORT: return 5;
case TRAVEL_ELEVATOR: return 10;
case TRAVEL_GRAPPLEHOOK: return 8;
case TRAVEL_ROCKETJUMP: return 6;
case TRAVEL_BFGJUMP: return 6;
case TRAVEL_JUMPPAD: return 10;
case TRAVEL_FUNCBOB: return 10;
default:
{
botimport.Print(PRT_ERROR, "travel type %d not implemented yet\n", reach->traveltype);
return 8;
} //end case
} //end switch
} //end of the function BotReachabilityTime
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
bot_moveresult_t BotMoveInGoalArea(bot_movestate_t *ms, bot_goal_t *goal)
{
bot_moveresult_t result;
vec3_t dir;
float dist, speed;
#ifdef DEBUG
//botimport.Print(PRT_MESSAGE, "%s: moving straight to goal\n", ClientName(ms->entitynum-1));
//AAS_ClearShownDebugLines();
//AAS_DebugLine(ms->origin, goal->origin, LINECOLOR_RED);
#endif //DEBUG
BotClearMoveResult(&result);
//walk straight to the goal origin
dir[0] = goal->origin[0] - ms->origin[0];
dir[1] = goal->origin[1] - ms->origin[1];
if (ms->moveflags & MFL_SWIMMING)
{
dir[2] = goal->origin[2] - ms->origin[2];
result.traveltype = TRAVEL_SWIM;
} //end if
else
{
dir[2] = 0;
result.traveltype = TRAVEL_WALK;
} //endif
//
dist = VectorNormalize(dir);
if (dist > 100) dist = 100;
speed = 400 - (400 - 4 * dist);
if (speed < 10) speed = 0;
//
BotCheckBlocked(ms, dir, qtrue, &result);
//elemantary action move in direction
EA_Move(ms->client, dir, speed);
VectorCopy(dir, result.movedir);
//
if (ms->moveflags & MFL_SWIMMING)
{
Vector2Angles(dir, result.ideal_viewangles);
result.flags |= MOVERESULT_SWIMVIEW;
} //end if
//if (!debugline) debugline = botimport.DebugLineCreate();
//botimport.DebugLineShow(debugline, ms->origin, goal->origin, LINECOLOR_BLUE);
//
ms->lastreachnum = 0;
ms->lastareanum = 0;
ms->lastgoalareanum = goal->areanum;
VectorCopy(ms->origin, ms->lastorigin);
//
return result;
} //end of the function BotMoveInGoalArea
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotMoveToGoal(bot_moveresult_t *result, int movestate, bot_goal_t *goal, int travelflags)
{
int reachnum, lastreachnum, foundjumppad, ent, resultflags;
aas_reachability_t reach, lastreach;
bot_movestate_t *ms;
//vec3_t mins, maxs, up = {0, 0, 1};
//bsp_trace_t trace;
//static int debugline;
BotClearMoveResult(result);
//
ms = BotMoveStateFromHandle(movestate);
if (!ms) return;
//reset the grapple before testing if the bot has a valid goal
//because the bot could loose all it's goals when stuck to a wall
BotResetGrapple(ms);
//
if (!goal)
{
#ifdef DEBUG
botimport.Print(PRT_MESSAGE, "client %d: movetogoal -> no goal\n", ms->client);
#endif //DEBUG
result->failure = qtrue;
return;
} //end if
//botimport.Print(PRT_MESSAGE, "numavoidreach = %d\n", ms->numavoidreach);
//remove some of the move flags
ms->moveflags &= ~(MFL_SWIMMING|MFL_AGAINSTLADDER);
//set some of the move flags
//NOTE: the MFL_ONGROUND flag is also set in the higher AI
if (AAS_OnGround(ms->origin, ms->presencetype, ms->entitynum)) ms->moveflags |= MFL_ONGROUND;
//
if (ms->moveflags & MFL_ONGROUND)
{
int modeltype, modelnum;
ent = BotOnTopOfEntity(ms);
if (ent != -1)
{
modelnum = AAS_EntityModelindex(ent);
if (modelnum >= 0 && modelnum < MAX_MODELS)
{
modeltype = modeltypes[modelnum];
if (modeltype == MODELTYPE_FUNC_PLAT)
{
AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
//if the bot is Not using the elevator
if ((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_ELEVATOR ||
//NOTE: the face number is the plat model number
(reach.facenum & 0x0000FFFF) != modelnum)
{
reachnum = AAS_NextModelReachability(0, modelnum);
if (reachnum)
{
//botimport.Print(PRT_MESSAGE, "client %d: accidentally ended up on func_plat\n", ms->client);
AAS_ReachabilityFromNum(reachnum, &reach);
ms->lastreachnum = reachnum;
ms->reachability_time = AAS_Time() + BotReachabilityTime(&reach);
} //end if
else
{
if (bot_developer)
{
botimport.Print(PRT_MESSAGE, "client %d: on func_plat without reachability\n", ms->client);
} //end if
result->blocked = qtrue;
result->blockentity = ent;
result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
return;
} //end else
} //end if
result->flags |= MOVERESULT_ONTOPOF_ELEVATOR;
} //end if
else if (modeltype == MODELTYPE_FUNC_BOB)
{
AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
//if the bot is Not using the func bobbing
if ((reach.traveltype & TRAVELTYPE_MASK) != TRAVEL_FUNCBOB ||
//NOTE: the face number is the func_bobbing model number
(reach.facenum & 0x0000FFFF) != modelnum)
{
reachnum = AAS_NextModelReachability(0, modelnum);
if (reachnum)
{
//botimport.Print(PRT_MESSAGE, "client %d: accidentally ended up on func_bobbing\n", ms->client);
AAS_ReachabilityFromNum(reachnum, &reach);
ms->lastreachnum = reachnum;
ms->reachability_time = AAS_Time() + BotReachabilityTime(&reach);
} //end if
else
{
if (bot_developer)
{
botimport.Print(PRT_MESSAGE, "client %d: on func_bobbing without reachability\n", ms->client);
} //end if
result->blocked = qtrue;
result->blockentity = ent;
result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
return;
} //end else
} //end if
result->flags |= MOVERESULT_ONTOPOF_FUNCBOB;
} //end if
else if (modeltype == MODELTYPE_FUNC_STATIC || modeltype == MODELTYPE_FUNC_DOOR)
{
// check if ontop of a door bridge ?
ms->areanum = BotFuzzyPointReachabilityArea(ms->origin);
// if not in a reachability area
if (!AAS_AreaReachability(ms->areanum))
{
result->blocked = qtrue;
result->blockentity = ent;
result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
return;
} //end if
} //end else if
else
{
result->blocked = qtrue;
result->blockentity = ent;
result->flags |= MOVERESULT_ONTOPOFOBSTACLE;
return;
} //end else
} //end if
} //end if
} //end if
//if swimming
if (AAS_Swimming(ms->origin)) ms->moveflags |= MFL_SWIMMING;
//if against a ladder
if (AAS_AgainstLadder(ms->origin)) ms->moveflags |= MFL_AGAINSTLADDER;
//if the bot is on the ground, swimming or against a ladder
if (ms->moveflags & (MFL_ONGROUND|MFL_SWIMMING|MFL_AGAINSTLADDER))
{
//botimport.Print(PRT_MESSAGE, "%s: onground, swimming or against ladder\n", ClientName(ms->entitynum-1));
//
AAS_ReachabilityFromNum(ms->lastreachnum, &lastreach);
//reachability area the bot is in
//ms->areanum = BotReachabilityArea(ms->origin, ((lastreach.traveltype & TRAVELTYPE_MASK) != TRAVEL_ELEVATOR));
ms->areanum = BotFuzzyPointReachabilityArea(ms->origin);
//
if ( !ms->areanum )
{
result->failure = qtrue;
result->blocked = qtrue;
result->blockentity = 0;
result->type = RESULTTYPE_INSOLIDAREA;
return;
} //end if
//if the bot is in the goal area
if (ms->areanum == goal->areanum)
{
*result = BotMoveInGoalArea(ms, goal);
return;
} //end if
//assume we can use the reachability from the last frame
reachnum = ms->lastreachnum;
//if there is a last reachability
if (reachnum)
{
AAS_ReachabilityFromNum(reachnum, &reach);
//check if the reachability is still valid
if (!(AAS_TravelFlagForType(reach.traveltype) & travelflags))
{
reachnum = 0;
} //end if
//special grapple hook case
else if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_GRAPPLEHOOK)
{
if (ms->reachability_time < AAS_Time() ||
(ms->moveflags & MFL_GRAPPLERESET))
{
reachnum = 0;
} //end if
} //end if
//special elevator case
else if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_ELEVATOR ||
(reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_FUNCBOB)
{
if ((result->flags & MOVERESULT_ONTOPOF_FUNCBOB) ||
(result->flags & MOVERESULT_ONTOPOF_FUNCBOB))
{
ms->reachability_time = AAS_Time() + 5;
} //end if
//if the bot was going for an elevator and reached the reachability area
if (ms->areanum == reach.areanum ||
ms->reachability_time < AAS_Time())
{
reachnum = 0;
} //end if
} //end if
else
{
#ifdef DEBUG
if (bot_developer)
{
if (ms->reachability_time < AAS_Time())
{
botimport.Print(PRT_MESSAGE, "client %d: reachability timeout in ", ms->client);
AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
botimport.Print(PRT_MESSAGE, "\n");
} //end if
/*
if (ms->lastareanum != ms->areanum)
{
botimport.Print(PRT_MESSAGE, "changed from area %d to %d\n", ms->lastareanum, ms->areanum);
} //end if*/
} //end if
#endif //DEBUG
//if the goal area changed or the reachability timed out
//or the area changed
if (ms->lastgoalareanum != goal->areanum ||
ms->reachability_time < AAS_Time() ||
ms->lastareanum != ms->areanum)
{
reachnum = 0;
//botimport.Print(PRT_MESSAGE, "area change or timeout\n");
} //end else if
} //end else
} //end if
resultflags = 0;
//if the bot needs a new reachability
if (!reachnum)
{
//if the area has no reachability links
if (!AAS_AreaReachability(ms->areanum))
{
#ifdef DEBUG
if (bot_developer)
{
botimport.Print(PRT_MESSAGE, "area %d no reachability\n", ms->areanum);
} //end if
#endif //DEBUG
} //end if
//get a new reachability leading towards the goal
reachnum = BotGetReachabilityToGoal(ms->origin, ms->areanum,
ms->lastgoalareanum, ms->lastareanum,
ms->avoidreach, ms->avoidreachtimes, ms->avoidreachtries,
goal, travelflags, travelflags,
ms->avoidspots, ms->numavoidspots, &resultflags);
//the area number the reachability starts in
ms->reachareanum = ms->areanum;
//reset some state variables
ms->jumpreach = 0; //for TRAVEL_JUMP
ms->moveflags &= ~MFL_GRAPPLERESET; //for TRAVEL_GRAPPLEHOOK
//if there is a reachability to the goal
if (reachnum)
{
AAS_ReachabilityFromNum(reachnum, &reach);
//set a timeout for this reachability
ms->reachability_time = AAS_Time() + BotReachabilityTime(&reach);
//
#ifdef AVOIDREACH
//add the reachability to the reachabilities to avoid for a while
BotAddToAvoidReach(ms, reachnum, AVOIDREACH_TIME);
#endif //AVOIDREACH
} //end if
#ifdef DEBUG
else if (bot_developer)
{
botimport.Print(PRT_MESSAGE, "goal not reachable\n");
Com_Memset(&reach, 0, sizeof(aas_reachability_t)); //make compiler happy
} //end else
if (bot_developer)
{
//if still going for the same goal
if (ms->lastgoalareanum == goal->areanum)
{
if (ms->lastareanum == reach.areanum)
{
botimport.Print(PRT_MESSAGE, "same goal, going back to previous area\n");
} //end if
} //end if
} //end if
#endif //DEBUG
} //end else
//
ms->lastreachnum = reachnum;
ms->lastgoalareanum = goal->areanum;
ms->lastareanum = ms->areanum;
//if the bot has a reachability
if (reachnum)
{
//get the reachability from the number
AAS_ReachabilityFromNum(reachnum, &reach);
result->traveltype = reach.traveltype;
//
#ifdef DEBUG_AI_MOVE
AAS_ClearShownDebugLines();
AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
AAS_ShowReachability(&reach);
#endif //DEBUG_AI_MOVE
//
#ifdef DEBUG
//botimport.Print(PRT_MESSAGE, "client %d: ", ms->client);
//AAS_PrintTravelType(reach.traveltype);
//botimport.Print(PRT_MESSAGE, "\n");
#endif //DEBUG
switch(reach.traveltype & TRAVELTYPE_MASK)
{
case TRAVEL_WALK: *result = BotTravel_Walk(ms, &reach); break;
case TRAVEL_CROUCH: *result = BotTravel_Crouch(ms, &reach); break;
case TRAVEL_BARRIERJUMP: *result = BotTravel_BarrierJump(ms, &reach); break;
case TRAVEL_LADDER: *result = BotTravel_Ladder(ms, &reach); break;
case TRAVEL_WALKOFFLEDGE: *result = BotTravel_WalkOffLedge(ms, &reach); break;
case TRAVEL_JUMP: *result = BotTravel_Jump(ms, &reach); break;
case TRAVEL_SWIM: *result = BotTravel_Swim(ms, &reach); break;
case TRAVEL_WATERJUMP: *result = BotTravel_WaterJump(ms, &reach); break;
case TRAVEL_TELEPORT: *result = BotTravel_Teleport(ms, &reach); break;
case TRAVEL_ELEVATOR: *result = BotTravel_Elevator(ms, &reach); break;
case TRAVEL_GRAPPLEHOOK: *result = BotTravel_Grapple(ms, &reach); break;
case TRAVEL_ROCKETJUMP: *result = BotTravel_RocketJump(ms, &reach); break;
case TRAVEL_BFGJUMP: *result = BotTravel_BFGJump(ms, &reach); break;
case TRAVEL_JUMPPAD: *result = BotTravel_JumpPad(ms, &reach); break;
case TRAVEL_FUNCBOB: *result = BotTravel_FuncBobbing(ms, &reach); break;
default:
{
botimport.Print(PRT_FATAL, "travel type %d not implemented yet\n", (reach.traveltype & TRAVELTYPE_MASK));
break;
} //end case
} //end switch
result->traveltype = reach.traveltype;
result->flags |= resultflags;
} //end if
else
{
result->failure = qtrue;
result->flags |= resultflags;
Com_Memset(&reach, 0, sizeof(aas_reachability_t));
} //end else
#ifdef DEBUG
if (bot_developer)
{
if (result->failure)
{
botimport.Print(PRT_MESSAGE, "client %d: movement failure in ", ms->client);
AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
botimport.Print(PRT_MESSAGE, "\n");
} //end if
} //end if
#endif //DEBUG
} //end if
else
{
int i, numareas, areas[16];
vec3_t end;
//special handling of jump pads when the bot uses a jump pad without knowing it
foundjumppad = qfalse;
VectorMA(ms->origin, -2 * ms->thinktime, ms->velocity, end);
numareas = AAS_TraceAreas(ms->origin, end, areas, NULL, 16);
for (i = numareas-1; i >= 0; i--)
{
if (AAS_AreaJumpPad(areas[i]))
{
//botimport.Print(PRT_MESSAGE, "client %d used a jumppad without knowing, area %d\n", ms->client, areas[i]);
foundjumppad = qtrue;
lastreachnum = BotGetReachabilityToGoal(end, areas[i],
ms->lastgoalareanum, ms->lastareanum,
ms->avoidreach, ms->avoidreachtimes, ms->avoidreachtries,
goal, travelflags, TFL_JUMPPAD, ms->avoidspots, ms->numavoidspots, NULL);
if (lastreachnum)
{
ms->lastreachnum = lastreachnum;
ms->lastareanum = areas[i];
//botimport.Print(PRT_MESSAGE, "found jumppad reachability\n");
break;
} //end if
else
{
for (lastreachnum = AAS_NextAreaReachability(areas[i], 0); lastreachnum;
lastreachnum = AAS_NextAreaReachability(areas[i], lastreachnum))
{
//get the reachability from the number
AAS_ReachabilityFromNum(lastreachnum, &reach);
if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_JUMPPAD)
{
ms->lastreachnum = lastreachnum;
ms->lastareanum = areas[i];
//botimport.Print(PRT_MESSAGE, "found jumppad reachability hard!!\n");
break;
} //end if
} //end for
if (lastreachnum) break;
} //end else
} //end if
} //end for
if (bot_developer)
{
//if a jumppad is found with the trace but no reachability is found
if (foundjumppad && !ms->lastreachnum)
{
botimport.Print(PRT_MESSAGE, "client %d didn't find jumppad reachability\n", ms->client);
} //end if
} //end if
//
if (ms->lastreachnum)
{
//botimport.Print(PRT_MESSAGE, "%s: NOT onground, swimming or against ladder\n", ClientName(ms->entitynum-1));
AAS_ReachabilityFromNum(ms->lastreachnum, &reach);
result->traveltype = reach.traveltype;
#ifdef DEBUG
//botimport.Print(PRT_MESSAGE, "client %d finish: ", ms->client);
//AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
//botimport.Print(PRT_MESSAGE, "\n");
#endif //DEBUG
//
switch(reach.traveltype & TRAVELTYPE_MASK)
{
case TRAVEL_WALK: *result = BotTravel_Walk(ms, &reach); break;//BotFinishTravel_Walk(ms, &reach); break;
case TRAVEL_CROUCH: /*do nothing*/ break;
case TRAVEL_BARRIERJUMP: *result = BotFinishTravel_BarrierJump(ms, &reach); break;
case TRAVEL_LADDER: *result = BotTravel_Ladder(ms, &reach); break;
case TRAVEL_WALKOFFLEDGE: *result = BotFinishTravel_WalkOffLedge(ms, &reach); break;
case TRAVEL_JUMP: *result = BotFinishTravel_Jump(ms, &reach); break;
case TRAVEL_SWIM: *result = BotTravel_Swim(ms, &reach); break;
case TRAVEL_WATERJUMP: *result = BotFinishTravel_WaterJump(ms, &reach); break;
case TRAVEL_TELEPORT: /*do nothing*/ break;
case TRAVEL_ELEVATOR: *result = BotFinishTravel_Elevator(ms, &reach); break;
case TRAVEL_GRAPPLEHOOK: *result = BotTravel_Grapple(ms, &reach); break;
case TRAVEL_ROCKETJUMP:
case TRAVEL_BFGJUMP: *result = BotFinishTravel_WeaponJump(ms, &reach); break;
case TRAVEL_JUMPPAD: *result = BotFinishTravel_JumpPad(ms, &reach); break;
case TRAVEL_FUNCBOB: *result = BotFinishTravel_FuncBobbing(ms, &reach); break;
default:
{
botimport.Print(PRT_FATAL, "(last) travel type %d not implemented yet\n", (reach.traveltype & TRAVELTYPE_MASK));
break;
} //end case
} //end switch
result->traveltype = reach.traveltype;
#ifdef DEBUG
if (bot_developer)
{
if (result->failure)
{
botimport.Print(PRT_MESSAGE, "client %d: movement failure in finish ", ms->client);
AAS_PrintTravelType(reach.traveltype & TRAVELTYPE_MASK);
botimport.Print(PRT_MESSAGE, "\n");
} //end if
} //end if
#endif //DEBUG
} //end if
} //end else
//FIXME: is it right to do this here?
if (result->blocked) ms->reachability_time -= 10 * ms->thinktime;
//copy the last origin
VectorCopy(ms->origin, ms->lastorigin);
//return the movement result
return;
} //end of the function BotMoveToGoal
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotResetAvoidReach(int movestate)
{
bot_movestate_t *ms;
ms = BotMoveStateFromHandle(movestate);
if (!ms) return;
Com_Memset(ms->avoidreach, 0, MAX_AVOIDREACH * sizeof(int));
Com_Memset(ms->avoidreachtimes, 0, MAX_AVOIDREACH * sizeof(float));
Com_Memset(ms->avoidreachtries, 0, MAX_AVOIDREACH * sizeof(int));
} //end of the function BotResetAvoidReach
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotResetLastAvoidReach(int movestate)
{
int i, latest;
float latesttime;
bot_movestate_t *ms;
ms = BotMoveStateFromHandle(movestate);
if (!ms) return;
latesttime = 0;
latest = 0;
for (i = 0; i < MAX_AVOIDREACH; i++)
{
if (ms->avoidreachtimes[i] > latesttime)
{
latesttime = ms->avoidreachtimes[i];
latest = i;
} //end if
} //end for
if (latesttime)
{
ms->avoidreachtimes[latest] = 0;
if (ms->avoidreachtries[i] > 0) ms->avoidreachtries[latest]--;
} //end if
} //end of the function BotResetLastAvoidReach
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotResetMoveState(int movestate)
{
bot_movestate_t *ms;
ms = BotMoveStateFromHandle(movestate);
if (!ms) return;
Com_Memset(ms, 0, sizeof(bot_movestate_t));
} //end of the function BotResetMoveState
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int BotSetupMoveAI(void)
{
BotSetBrushModelTypes();
sv_maxstep = LibVar("sv_step", "18");
sv_maxbarrier = LibVar("sv_maxbarrier", "32");
sv_gravity = LibVar("sv_gravity", "800");
weapindex_rocketlauncher = LibVar("weapindex_rocketlauncher", "5");
weapindex_bfg10k = LibVar("weapindex_bfg10k", "9");
weapindex_grapple = LibVar("weapindex_grapple", "10");
entitytypemissile = LibVar("entitytypemissile", "3");
offhandgrapple = LibVar("offhandgrapple", "0");
cmd_grappleon = LibVar("cmd_grappleon", "grappleon");
cmd_grappleoff = LibVar("cmd_grappleoff", "grappleoff");
return BLERR_NOERROR;
} //end of the function BotSetupMoveAI
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void BotShutdownMoveAI(void)
{
int i;
for (i = 1; i <= MAX_CLIENTS; i++)
{
if (botmovestates[i])
{
FreeMemory(botmovestates[i]);
botmovestates[i] = NULL;
} //end if
} //end for
} //end of the function BotShutdownMoveAI
Reference in a new issue Copy permalink