db8ca37fa3
git-svn-id: https://svn.code.sf.net/p/q3cellshading/code/trunk@2 db09e94b-7117-0410-a7e6-85ae5ff6e0e9
3610 lines
114 KiB
C
3610 lines
114 KiB
C
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
Quake III Arena source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Foobar; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
|
|
/*****************************************************************************
|
|
* name: be_ai_move.c
|
|
*
|
|
* desc: bot movement AI
|
|
*
|
|
* $Archive: /MissionPack/code/botlib/be_ai_move.c $
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#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] = 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
|
|
|
|
|