//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_FindPossiblePortals(void)
{
int i, numpossibleportals;
numpossibleportals = 0;
for (i = 1; i < aasworld.numareas; i++)
{
numpossibleportals += AAS_CheckAreaForPossiblePortals(i);
} //end for
botimport.Print(PRT_MESSAGE, "\r%6d possible portal areas\n", numpossibleportals);
} //end of the function AAS_FindPossiblePortals
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
qboolean ValidClientNumber(int num, char *str)
{
if (num < 0 || num > botlibglobals.maxclients)
{
//weird: the disabled stuff results in a crash
botimport.Print(PRT_ERROR, "%s: invalid client number %d, [0, %d]\n",
str, num, botlibglobals.maxclients);
return qfalse;
} //end if
return qtrue;
} //end of the function BotValidateClientNumber
void PrintContents(int contents)
{
int i;
for(i = 0; contentnames[i].value; i++)
{
if(contents & contentnames[i].value)
{
botimport.Print(PRT_MESSAGE, "%s\n", contentnames[i].name);
} //end if
} //end for
} //end of the function PrintContents
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int Export_BotLibSetup(void)
{
int errnum;
botDeveloper = LibVarGetValue("bot_developer");
memset( &botlibglobals, 0, sizeof(botlibglobals) );
//initialize byte swapping (litte endian etc.)
// Swap_Init();
if(botDeveloper)
{
char *homedir, *gamedir;
char logfilename[MAX_OSPATH];
homedir = LibVarGetString("homedir");
gamedir = LibVarGetString("gamedir");
if (*homedir)
{
if(*gamedir)
Com_sprintf(logfilename, sizeof(logfilename), "%s%c%s%cbotlib.log", homedir, PATH_SEP, gamedir, PATH_SEP);
else
Com_sprintf(logfilename, sizeof(logfilename), "%s%c" BASEGAME "%cbotlib.log", homedir, PATH_SEP, PATH_SEP);
}
else
Com_sprintf(logfilename, sizeof(logfilename), "botlib.log");
Log_Open(logfilename);
}
botimport.Print(PRT_MESSAGE, "------- BotLib Initialization -------\n");
botlibglobals.maxclients = (int) LibVarValue("maxclients", "128");
botlibglobals.maxentities = (int) LibVarValue("maxentities", "1024");
errnum = AAS_Setup(); //be_aas_main.c
if (errnum != BLERR_NOERROR) return errnum;
errnum = EA_Setup(); //be_ea.c
if (errnum != BLERR_NOERROR) return errnum;
errnum = BotSetupWeaponAI(); //be_ai_weap.c
if (errnum != BLERR_NOERROR)return errnum;
errnum = BotSetupGoalAI(); //be_ai_goal.c
if (errnum != BLERR_NOERROR) return errnum;
errnum = BotSetupChatAI(); //be_ai_chat.c
if (errnum != BLERR_NOERROR) return errnum;
errnum = BotSetupMoveAI(); //be_ai_move.c
if (errnum != BLERR_NOERROR) return errnum;
botlibsetup = qtrue;
botlibglobals.botlibsetup = qtrue;
return BLERR_NOERROR;
} //end of the function Export_BotLibSetup
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_CountForcedClusterPortals(void)
{
int num, i;
num = 0;
for (i = 1; i < aasworld.numareas; i++)
{
if (aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)
{
Log_Write("area %d is a forced portal area\r\n", i);
num++;
} //end if
} //end for
botimport.Print(PRT_MESSAGE, "%6d forced portal areas\n", num);
} //end of the function AAS_CountForcedClusterPortals
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int Export_BotLibLoadMap(const char *mapname)
{
#ifdef DEBUG
int starttime = Sys_MilliSeconds();
#endif
int errnum;
if (!BotLibSetup("BotLoadMap")) return BLERR_LIBRARYNOTSETUP;
//
botimport.Print(PRT_MESSAGE, "------------ Map Loading ------------\n");
//startup AAS for the current map, model and sound index
errnum = AAS_LoadMap(mapname);
if (errnum != BLERR_NOERROR) return errnum;
//initialize the items in the level
BotInitLevelItems(); //be_ai_goal.h
BotSetBrushModelTypes(); //be_ai_move.h
//
botimport.Print(PRT_MESSAGE, "-------------------------------------\n");
#ifdef DEBUG
botimport.Print(PRT_MESSAGE, "map loaded in %d msec\n", Sys_MilliSeconds() - starttime);
#endif
//
return BLERR_NOERROR;
} //end of the function Export_BotLibLoadMap
//===========================================================================
// tests if the given point is within the face boundaries
//
// Parameter: face : face to test if the point is in it
// pnormal : normal of the plane to use for the face
// point : point to test if inside face boundaries
// Returns: qtrue if the point is within the face boundaries
// Changes Globals: -
//===========================================================================
qboolean AAS_InsideFace( aas_face_t *face, vec3_t pnormal, vec3_t point, float epsilon ) {
int i, firstvertex, edgenum;
vec3_t v0;
vec3_t edgevec, pointvec, sepnormal;
aas_edge_t *edge;
#ifdef AAS_SAMPLE_DEBUG
int lastvertex = 0;
#endif //AAS_SAMPLE_DEBUG
if ( !( *aasworld ).loaded ) {
return qfalse;
}
for ( i = 0; i < face->numedges; i++ )
{
edgenum = ( *aasworld ).edgeindex[face->firstedge + i];
edge = &( *aasworld ).edges[abs( edgenum )];
//get the first vertex of the edge
firstvertex = edgenum < 0;
VectorCopy( ( *aasworld ).vertexes[edge->v[firstvertex]], v0 );
//edge vector
VectorSubtract( ( *aasworld ).vertexes[edge->v[!firstvertex]], v0, edgevec );
//
#ifdef AAS_SAMPLE_DEBUG
if ( lastvertex && lastvertex != edge->v[firstvertex] ) {
botimport.Print( PRT_MESSAGE, "winding not counter clockwise\n" );
} //end if
lastvertex = edge->v[!firstvertex];
#endif //AAS_SAMPLE_DEBUG
//vector from first edge point to point possible in face
VectorSubtract( point, v0, pointvec );
//get a vector pointing inside the face orthogonal to both the
//edge vector and the normal vector of the plane the face is in
//this vector defines a plane through the origin (first vertex of
//edge) and through both the edge vector and the normal vector
//of the plane
AAS_OrthogonalToVectors( edgevec, pnormal, sepnormal );
//check on wich side of the above plane the point is
//this is done by checking the sign of the dot product of the
//vector orthogonal vector from above and the vector from the
//origin (first vertex of edge) to the point
//if the dotproduct is smaller than zero the point is outside the face
if ( DotProduct( pointvec, sepnormal ) < -epsilon ) {
return qfalse;
}
} //end for
return qtrue;
} //end of the function AAS_InsideFace
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
aas_link_t *AAS_AllocAASLink( void ) {
aas_link_t *link;
link = ( *aasworld ).freelinks;
if ( !link ) {
botimport.Print( PRT_FATAL, "empty aas link heap\n" );
return NULL;
} //end if
if ( ( *aasworld ).freelinks ) {
( *aasworld ).freelinks = ( *aasworld ).freelinks->next_ent;
}
if ( ( *aasworld ).freelinks ) {
( *aasworld ).freelinks->prev_ent = NULL;
}
return link;
} //end of the function AAS_AllocAASLink
void AAS_TestMovementPrediction(int entnum, vector3 *origin, vector3 *dir) {
vector3 velocity, cmdmove;
aas_clientmove_t move;
VectorClear(&velocity);
if (!AAS_Swimming(origin)) dir->z = 0;
VectorNormalize(dir);
VectorScale(dir, 400, &cmdmove);
cmdmove.z = 224;
AAS_ClearShownDebugLines();
AAS_PredictClientMovement(&move, entnum, origin, PRESENCE_NORMAL, qtrue,
&velocity, &cmdmove, 13, 13, 0.1f, SE_HITGROUND, 0, qtrue);//SE_LEAVEGROUND);
if (move.stopevent & SE_LEAVEGROUND)
{
botimport.Print(PRT_MESSAGE, "leave ground\n");
}
}
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_PresenceTypeBoundingBox(int presencetype, vec3_t mins, vec3_t maxs)
{
int index;
//bounding box size for each presence type
vec3_t boxmins[3] = {{0, 0, 0}, {-15, -15, -24}, {-15, -15, -24}};
vec3_t boxmaxs[3] = {{0, 0, 0}, { 15, 15, 32}, { 15, 15, 8}};
if (presencetype == PRESENCE_NORMAL) index = 1;
else if (presencetype == PRESENCE_CROUCH) index = 2;
else
{
botimport.Print(PRT_FATAL, "AAS_PresenceTypeBoundingBox: unknown presence type\n");
index = 2;
} //end if
VectorCopy(boxmins[index], mins);
VectorCopy(boxmaxs[index], maxs);
} //end of the function AAS_PresenceTypeBoundingBox
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
aas_link_t *AAS_AllocAASLink(void)
{
aas_link_t *link;
link = aasworld.freelinks;
if (!link)
{
#ifndef BSPC
if (botDeveloper)
#endif
{
botimport.Print(PRT_FATAL, "empty aas link heap\n");
} //end if
return NULL;
} //end if
if (aasworld.freelinks) aasworld.freelinks = aasworld.freelinks->next_ent;
if (aasworld.freelinks) aasworld.freelinks->prev_ent = NULL;
numaaslinks--;
return link;
} //end of the function AAS_AllocAASLink
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int AAS_AreaInfo( int areanum, aas_areainfo_t *info )
{
aas_areasettings_t *settings;
if (!info)
return 0;
if (areanum <= 0 || areanum >= aasworld.numareas)
{
botimport.Print(PRT_ERROR, "AAS_AreaInfo: areanum %d out of range\n", areanum);
return 0;
} //end if
settings = &aasworld.areasettings[areanum];
info->cluster = settings->cluster;
info->contents = settings->contents;
info->flags = settings->areaflags;
info->presencetype = settings->presencetype;
VectorCopy(aasworld.areas[areanum].mins, info->mins);
VectorCopy(aasworld.areas[areanum].maxs, info->maxs);
VectorCopy(aasworld.areas[areanum].center, info->center);
return sizeof(aas_areainfo_t);
} //end of the function AAS_AreaInfo
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_TestMovementPrediction(int entnum, vec3_t origin, vec3_t dir)
{
vec3_t velocity, cmdmove;
aas_clientmove_t move;
VectorClear(velocity);
if (!AAS_Swimming(origin))
{
dir[2] = 0;
}
VectorNormalize(dir);
VectorScale(dir, 400, cmdmove);
cmdmove[2] = 224;
AAS_ClearShownDebugLines();
AAS_PredictClientMovement(&move, entnum, origin, PRESENCE_NORMAL, qtrue,
velocity, cmdmove, 13, 13, 0.1, SE_HITGROUND, 0, qtrue); //SE_LEAVEGROUND);
if (move.stopevent & SE_LEAVEGROUND)
{
botimport.Print(PRT_MESSAGE, "leave ground\n");
} //end if
} //end of the function TestMovementPrediction
/*
============
GetBotLibAPI
============
*/
botlib_export_t *GetBotLibAPI( int apiVersion, botlib_import_t *import ) {
botimport = *import;
memset( &be_botlib_export, 0, sizeof( be_botlib_export ) );
if ( apiVersion != BOTLIB_API_VERSION ) {
botimport.Print( PRT_ERROR, "Mismatched BOTLIB_API_VERSION: expected %i, got %i\n", BOTLIB_API_VERSION, apiVersion );
return NULL;
}
Init_AAS_Export( &be_botlib_export.aas );
Init_EA_Export( &be_botlib_export.ea );
Init_AI_Export( &be_botlib_export.ai );
be_botlib_export.BotLibSetup = Export_BotLibSetup;
be_botlib_export.BotLibShutdown = Export_BotLibShutdown;
be_botlib_export.BotLibVarSet = Export_BotLibVarSet;
be_botlib_export.BotLibVarGet = Export_BotLibVarGet;
be_botlib_export.PC_AddGlobalDefine = PC_AddGlobalDefine;
#if defined RTCW_ET
be_botlib_export.PC_RemoveAllGlobalDefines = PC_RemoveAllGlobalDefines;
#endif // RTCW_XX
be_botlib_export.PC_LoadSourceHandle = PC_LoadSourceHandle;
be_botlib_export.PC_FreeSourceHandle = PC_FreeSourceHandle;
be_botlib_export.PC_ReadTokenHandle = PC_ReadTokenHandle;
be_botlib_export.PC_SourceFileAndLine = PC_SourceFileAndLine;
#if defined RTCW_ET
be_botlib_export.PC_UnreadLastTokenHandle = PC_UnreadLastTokenHandle;
#endif // RTCW_XX
be_botlib_export.BotLibStartFrame = Export_BotLibStartFrame;
be_botlib_export.BotLibLoadMap = Export_BotLibLoadMap;
be_botlib_export.BotLibUpdateEntity = Export_BotLibUpdateEntity;
be_botlib_export.Test = BotExportTest;
return &be_botlib_export;
}
/*
============
GetBotLibAPI
============
*/
botlib_export_t *GetBotLibAPI(int apiVersion, botlib_import_t *import) {
assert(import); // bk001129 - this wasn't set for base/
botimport = *import;
assert(botimport.Print); // bk001129 - pars pro toto
Com_Memset( &be_botlib_export, 0, sizeof( be_botlib_export ) );
if ( apiVersion != BOTLIB_API_VERSION ) {
botimport.Print( PRT_ERROR, "Mismatched BOTLIB_API_VERSION: expected %i, got %i\n", BOTLIB_API_VERSION, apiVersion );
return NULL;
}
Init_AAS_Export(&be_botlib_export.aas);
Init_EA_Export(&be_botlib_export.ea);
Init_AI_Export(&be_botlib_export.ai);
be_botlib_export.BotLibSetup = Export_BotLibSetup;
be_botlib_export.BotLibShutdown = Export_BotLibShutdown;
be_botlib_export.BotLibVarSet = Export_BotLibVarSet;
be_botlib_export.BotLibVarGet = Export_BotLibVarGet;
be_botlib_export.PC_AddGlobalDefine = PC_AddGlobalDefine;
be_botlib_export.PC_LoadSourceHandle = PC_LoadSourceHandle;
be_botlib_export.PC_FreeSourceHandle = PC_FreeSourceHandle;
be_botlib_export.PC_ReadTokenHandle = PC_ReadTokenHandle;
be_botlib_export.PC_SourceFileAndLine = PC_SourceFileAndLine;
be_botlib_export.PC_LoadGlobalDefines = PC_LoadGlobalDefines;
be_botlib_export.PC_RemoveAllGlobalDefines = PC_RemoveAllGlobalDefines;
be_botlib_export.BotLibStartFrame = Export_BotLibStartFrame;
be_botlib_export.BotLibLoadMap = Export_BotLibLoadMap;
be_botlib_export.BotLibUpdateEntity = Export_BotLibUpdateEntity;
be_botlib_export.Test = BotExportTest;
return &be_botlib_export;
}
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_ParseBSPEntities( void ) {
script_t *script;
token_t token;
bsp_entity_t *ent;
bsp_epair_t *epair;
byte *buffer, *buftrav;
int bufsize;
// RF, modified this, so that it first gathers up memory requirements, then allocates a single chunk,
// and places the strings all in there
bspworld.ebuffer = NULL;
script = LoadScriptMemory( bspworld.dentdata, bspworld.entdatasize, "entdata" );
SetScriptFlags( script, SCFL_NOSTRINGWHITESPACES | SCFL_NOSTRINGESCAPECHARS ); //SCFL_PRIMITIVE);
bufsize = 0;
while ( PS_ReadToken( script, &token ) )
{
if ( strcmp( token.string, "{" ) ) {
ScriptError( script, "invalid %s\n", token.string );
AAS_FreeBSPEntities();
FreeScript( script );
return;
} //end if
if ( bspworld.numentities >= MAX_BSPENTITIES ) {
botimport.Print( PRT_MESSAGE, "too many entities in BSP file\n" );
break;
} //end if
while ( PS_ReadToken( script, &token ) )
{
if ( !strcmp( token.string, "}" ) ) {
break;
}
bufsize += sizeof( bsp_epair_t );
if ( token.type != TT_STRING ) {
ScriptError( script, "invalid %s\n", token.string );
AAS_FreeBSPEntities();
FreeScript( script );
return;
} //end if
StripDoubleQuotes( token.string );
bufsize += strlen( token.string ) + 1;
if ( !PS_ExpectTokenType( script, TT_STRING, 0, &token ) ) {
AAS_FreeBSPEntities();
FreeScript( script );
return;
} //end if
StripDoubleQuotes( token.string );
bufsize += strlen( token.string ) + 1;
} //end while
if ( strcmp( token.string, "}" ) ) {
ScriptError( script, "missing }\n" );
AAS_FreeBSPEntities();
FreeScript( script );
return;
} //end if
} //end while
FreeScript( script );
buffer = (byte *)GetClearedHunkMemory( bufsize );
buftrav = buffer;
bspworld.ebuffer = buffer;
// RF, now parse the entities into memory
// RF, NOTE: removed error checks for speed, no need to do them twice
script = LoadScriptMemory( bspworld.dentdata, bspworld.entdatasize, "entdata" );
SetScriptFlags( script, SCFL_NOSTRINGWHITESPACES | SCFL_NOSTRINGESCAPECHARS ); //SCFL_PRIMITIVE);
bspworld.numentities = 1;
while ( PS_ReadToken( script, &token ) )
{
ent = &bspworld.entities[bspworld.numentities];
bspworld.numentities++;
ent->epairs = NULL;
while ( PS_ReadToken( script, &token ) )
{
if ( !strcmp( token.string, "}" ) ) {
break;
}
epair = (bsp_epair_t *) buftrav; buftrav += sizeof( bsp_epair_t );
epair->next = ent->epairs;
ent->epairs = epair;
StripDoubleQuotes( token.string );
epair->key = (char *) buftrav; buftrav += ( strlen( token.string ) + 1 );
strcpy( epair->key, token.string );
if ( !PS_ExpectTokenType( script, TT_STRING, 0, &token ) ) {
AAS_FreeBSPEntities();
FreeScript( script );
return;
} //end if
StripDoubleQuotes( token.string );
epair->value = (char *) buftrav; buftrav += ( strlen( token.string ) + 1 );
strcpy( epair->value, token.string );
} //end while
} //end while
FreeScript( script );
} //end of the function AAS_ParseBSPEntities
//===========================================================================
// recursive subdivision of the line by the BSP tree.
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int AAS_TraceAreas(vec3_t start, vec3_t end, int *areas, vec3_t *points, int maxareas)
{
int side, nodenum, tmpplanenum;
int numareas;
float front, back, frac;
vec3_t cur_start, cur_end, cur_mid;
aas_tracestack_t tracestack[127];
aas_tracestack_t *tstack_p;
aas_node_t *aasnode;
aas_plane_t *plane;
numareas = 0;
areas[0] = 0;
if (!aasworld.loaded) return numareas;
tstack_p = tracestack;
//we start with the whole line on the stack
VectorCopy(start, tstack_p->start);
VectorCopy(end, tstack_p->end);
tstack_p->planenum = 0;
//start with node 1 because node zero is a dummy for a solid leaf
tstack_p->nodenum = 1; //starting at the root of the tree
tstack_p++;
while (1)
{
//pop up the stack
tstack_p--;
//if the trace stack is empty (ended up with a piece of the
//line to be traced in an area)
if (tstack_p < tracestack)
{
return numareas;
} //end if
//number of the current node to test the line against
nodenum = tstack_p->nodenum;
//if it is an area
if (nodenum < 0)
{
#ifdef AAS_SAMPLE_DEBUG
if (-nodenum > aasworld.numareasettings)
{
botimport.Print(PRT_ERROR, "AAS_TraceAreas: -nodenum = %d out of range\n", -nodenum);
return numareas;
} //end if
#endif //AAS_SAMPLE_DEBUG
//botimport.Print(PRT_MESSAGE, "areanum = %d, must be %d\n", -nodenum, AAS_PointAreaNum(start));
areas[numareas] = -nodenum;
if (points) VectorCopy(tstack_p->start, points[numareas]);
numareas++;
if (numareas >= maxareas) return numareas;
continue;
} //end if
//if it is a solid leaf
if (!nodenum)
{
continue;
} //end if
#ifdef AAS_SAMPLE_DEBUG
if (nodenum > aasworld.numnodes)
{
botimport.Print(PRT_ERROR, "AAS_TraceAreas: nodenum out of range\n");
return numareas;
} //end if
#endif //AAS_SAMPLE_DEBUG
//the node to test against
aasnode = &aasworld.nodes[nodenum];
//start point of current line to test against node
VectorCopy(tstack_p->start, cur_start);
//end point of the current line to test against node
VectorCopy(tstack_p->end, cur_end);
//the current node plane
plane = &aasworld.planes[aasnode->planenum];
// switch(plane->type)
{/*FIXME: wtf doesn't this work? obviously the node planes aren't always facing positive!!!
//check for axial planes
case PLANE_X:
{
front = cur_start[0] - plane->dist;
back = cur_end[0] - plane->dist;
break;
} //end case
case PLANE_Y:
{
front = cur_start[1] - plane->dist;
back = cur_end[1] - plane->dist;
break;
} //end case
case PLANE_Z:
{
front = cur_start[2] - plane->dist;
back = cur_end[2] - plane->dist;
break;
} //end case*/
// default: //gee it's not an axial plane
{
front = DotProduct(cur_start, plane->normal) - plane->dist;
back = DotProduct(cur_end, plane->normal) - plane->dist;
// break;
} //end default
} //end switch
//if the whole to be traced line is totally at the front of this node
//only go down the tree with the front child
if (front > 0 && back > 0)
{
//keep the current start and end point on the stack
//and go down the tree with the front child
tstack_p->nodenum = aasnode->children[0];
tstack_p++;
if (tstack_p >= &tracestack[127])
{
botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
return numareas;
} //end if
} //end if
//if the whole to be traced line is totally at the back of this node
//only go down the tree with the back child
else if (front <= 0 && back <= 0)
{
//keep the current start and end point on the stack
//and go down the tree with the back child
tstack_p->nodenum = aasnode->children[1];
tstack_p++;
if (tstack_p >= &tracestack[127])
{
botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
return numareas;
} //end if
} //end if
//go down the tree both at the front and back of the node
else
{
tmpplanenum = tstack_p->planenum;
//calculate the hitpoint with the node (split point of the line)
//put the crosspoint TRACEPLANE_EPSILON pixels on the near side
if (front < 0) frac = (front)/(front-back);
else frac = (front)/(front-back);
if (frac < 0) frac = 0;
else if (frac > 1) frac = 1;
//frac = front / (front-back);
//
cur_mid[0] = cur_start[0] + (cur_end[0] - cur_start[0]) * frac;
cur_mid[1] = cur_start[1] + (cur_end[1] - cur_start[1]) * frac;
cur_mid[2] = cur_start[2] + (cur_end[2] - cur_start[2]) * frac;
// AAS_DrawPlaneCross(cur_mid, plane->normal, plane->dist, plane->type, LINECOLOR_RED);
//side the front part of the line is on
side = front < 0;
//first put the end part of the line on the stack (back side)
VectorCopy(cur_mid, tstack_p->start);
//not necesary to store because still on stack
//VectorCopy(cur_end, tstack_p->end);
tstack_p->planenum = aasnode->planenum;
tstack_p->nodenum = aasnode->children[!side];
tstack_p++;
if (tstack_p >= &tracestack[127])
{
botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
return numareas;
} //end if
//now put the part near the start of the line on the stack so we will
//continue with thats part first. This way we'll find the first
//hit of the bbox
VectorCopy(cur_start, tstack_p->start);
VectorCopy(cur_mid, tstack_p->end);
tstack_p->planenum = tmpplanenum;
tstack_p->nodenum = aasnode->children[side];
tstack_p++;
if (tstack_p >= &tracestack[127])
{
botimport.Print(PRT_ERROR, "AAS_TraceAreas: stack overflow\n");
return numareas;
} //end if
} //end else
} //end while
// return numareas;
} //end of the function AAS_TraceAreas
//===========================================================================
// predicts the movement
// assumes regular bounding box sizes
// NOTE: out of water jumping is not included
// NOTE: grappling hook is not included
//
// Parameter: origin : origin to start with
// presencetype : presence type to start with
// velocity : velocity to start with
// cmdmove : client command movement
// cmdframes : number of frame cmdmove is valid
// maxframes : maximum number of predicted frames
// frametime : duration of one predicted frame
// stopevent : events that stop the prediction
// stopareanum : stop as soon as entered this area
// Returns: aas_clientmove_t
// Changes Globals: -
//===========================================================================
int AAS_PredictClientMovement( struct aas_clientmove_s *move,
int entnum, vec3_t origin,
#if !defined RTCW_ET
int presencetype, int onground,
#else
int hitent, int onground,
#endif // RTCW_XX
vec3_t velocity, vec3_t cmdmove,
int cmdframes,
int maxframes, float frametime,
int stopevent, int stopareanum, int visualize ) {
float sv_friction, sv_stopspeed, sv_gravity, sv_waterfriction;
float sv_watergravity;
float sv_walkaccelerate, sv_airaccelerate, sv_swimaccelerate;
float sv_maxwalkvelocity, sv_maxcrouchvelocity, sv_maxswimvelocity;
float sv_maxstep, sv_maxsteepness, sv_jumpvel, friction;
float gravity, delta, maxvel, wishspeed, accelerate;
//float velchange, newvel;
int n, i, j, pc, step, swimming, ax, crouch, event, jump_frame, areanum;
int areas[20], numareas;
#if !defined RTCW_ET
vec3_t points[20];
vec3_t org, end, feet, start, stepend, lastorg, wishdir;
vec3_t frame_test_vel, old_frame_test_vel, left_test_vel;
vec3_t up = {0, 0, 1};
aas_plane_t *plane, *plane2;
aas_trace_t trace, steptrace;
#else
vec3_t points[20], mins, maxs;
vec3_t org, end, feet, start, stepend, lastorg, wishdir;
vec3_t frame_test_vel, old_frame_test_vel, left_test_vel, savevel;
vec3_t up = {0, 0, 1};
cplane_t *plane, *plane2, *lplane;
//aas_trace_t trace, steptrace;
bsp_trace_t trace, steptrace;
if ( visualize ) {
// These debugging tools are not currently available in bspc. Mad Doctor I, 1/27/2003.
#ifndef BSPC
AAS_ClearShownPolygons();
AAS_ClearShownDebugLines();
#endif
}
// don't let us succeed on interaction with area 0
if ( stopareanum == 0 ) {
stopevent &= ~( SE_ENTERAREA | SE_HITGROUNDAREA );
}
#endif // RTCW_XX
if ( frametime <= 0 ) {
frametime = 0.1;
}
//
sv_friction = aassettings.sv_friction;
sv_stopspeed = aassettings.sv_stopspeed;
sv_gravity = aassettings.sv_gravity;
sv_waterfriction = aassettings.sv_waterfriction;
sv_watergravity = aassettings.sv_watergravity;
sv_maxwalkvelocity = aassettings.sv_maxwalkvelocity; // * frametime;
sv_maxcrouchvelocity = aassettings.sv_maxcrouchvelocity; // * frametime;
sv_maxswimvelocity = aassettings.sv_maxswimvelocity; // * frametime;
sv_walkaccelerate = aassettings.sv_walkaccelerate;
sv_airaccelerate = aassettings.sv_airaccelerate;
sv_swimaccelerate = aassettings.sv_swimaccelerate;
sv_maxstep = aassettings.sv_maxstep;
sv_maxsteepness = aassettings.sv_maxsteepness;
sv_jumpvel = aassettings.sv_jumpvel * frametime;
//
memset( move, 0, sizeof( aas_clientmove_t ) );
#if !defined RTCW_ET
memset( &trace, 0, sizeof( aas_trace_t ) );
#else
memset( &trace, 0, sizeof( bsp_trace_t ) );
AAS_PresenceTypeBoundingBox( PRESENCE_NORMAL, mins, maxs );
#endif // RTCW_XX
//start at the current origin
VectorCopy( origin, org );
org[2] += 0.25;
#if defined RTCW_ET
// test this position, if it's in solid, move it up to adjust for capsules
//trace = AAS_TraceClientBBox(org, org, PRESENCE_NORMAL, entnum);
trace = AAS_Trace( org, mins, maxs, org, entnum, ( CONTENTS_SOLID | CONTENTS_PLAYERCLIP ) & ~CONTENTS_BODY );
while ( trace.startsolid ) {
org[2] += 8;
//trace = AAS_TraceClientBBox(org, org, PRESENCE_NORMAL, entnum);
trace = AAS_Trace( org, mins, maxs, org, entnum, ( CONTENTS_SOLID | CONTENTS_PLAYERCLIP ) & ~CONTENTS_BODY );
if ( trace.startsolid && ( org[2] - origin[2] > 16 ) ) {
move->stopevent = SE_NONE;
return qfalse;
}
}
#endif // RTCW_XX
//velocity to test for the first frame
VectorScale( velocity, frametime, frame_test_vel );
//
jump_frame = -1;
#if defined RTCW_ET
lplane = NULL;
#endif // RTCW_XX
//predict a maximum of 'maxframes' ahead
for ( n = 0; n < maxframes; n++ )
{
swimming = AAS_Swimming( org );
//get gravity depending on swimming or not
gravity = swimming ? sv_watergravity : sv_gravity;
//apply gravity at the START of the frame
frame_test_vel[2] = frame_test_vel[2] - ( gravity * 0.1 * frametime );
//if on the ground or swimming
if ( onground || swimming ) {
friction = swimming ? sv_friction : sv_waterfriction;
//apply friction
VectorScale( frame_test_vel, 1 / frametime, frame_test_vel );
AAS_ApplyFriction( frame_test_vel, friction, sv_stopspeed, frametime );
VectorScale( frame_test_vel, frametime, frame_test_vel );
} //end if
crouch = qfalse;
//apply command movement
#if !defined RTCW_ET
if ( n < cmdframes ) {
#else
if ( cmdframes < 0 ) {
// cmdmove is the destination, we should keep moving towards it
VectorSubtract( cmdmove, org, wishdir );
VectorNormalize( wishdir );
VectorScale( wishdir, sv_maxwalkvelocity, wishdir );
VectorCopy( frame_test_vel, savevel );
VectorScale( wishdir, frametime, frame_test_vel );
if ( !swimming ) {
frame_test_vel[2] = savevel[2];
}
} else if ( n < cmdframes ) {
#endif // RTCW_XX
ax = 0;
maxvel = sv_maxwalkvelocity;
accelerate = sv_airaccelerate;
VectorCopy( cmdmove, wishdir );
if ( onground ) {
if ( cmdmove[2] < -300 ) {
crouch = qtrue;
maxvel = sv_maxcrouchvelocity;
} //end if
//if not swimming and upmove is positive then jump
if ( !swimming && cmdmove[2] > 1 ) {
//jump velocity minus the gravity for one frame + 5 for safety
frame_test_vel[2] = sv_jumpvel - ( gravity * 0.1 * frametime ) + 5;
jump_frame = n;
//jumping so air accelerate
accelerate = sv_airaccelerate;
} //end if
else
{
accelerate = sv_walkaccelerate;
} //end else
ax = 2;
} //end if
if ( swimming ) {
maxvel = sv_maxswimvelocity;
accelerate = sv_swimaccelerate;
ax = 3;
} //end if
else
{
wishdir[2] = 0;
} //end else
//
wishspeed = VectorNormalize( wishdir );
if ( wishspeed > maxvel ) {
wishspeed = maxvel;
}
VectorScale( frame_test_vel, 1 / frametime, frame_test_vel );
AAS_Accelerate( frame_test_vel, frametime, wishdir, wishspeed, accelerate );
VectorScale( frame_test_vel, frametime, frame_test_vel );
/*
for (i = 0; i < ax; i++)
{
velchange = (cmdmove[i] * frametime) - frame_test_vel[i];
if (velchange > sv_maxacceleration) velchange = sv_maxacceleration;
else if (velchange < -sv_maxacceleration) velchange = -sv_maxacceleration;
newvel = frame_test_vel[i] + velchange;
//
if (frame_test_vel[i] <= maxvel && newvel > maxvel) frame_test_vel[i] = maxvel;
else if (frame_test_vel[i] >= -maxvel && newvel < -maxvel) frame_test_vel[i] = -maxvel;
else frame_test_vel[i] = newvel;
} //end for
*/
} //end if
#if !defined RTCW_ET
if ( crouch ) {
presencetype = PRESENCE_CROUCH;
} //end if
else if ( presencetype == PRESENCE_CROUCH ) {
if ( AAS_PointPresenceType( org ) & PRESENCE_NORMAL ) {
presencetype = PRESENCE_NORMAL;
} //end if
} //end else
#else
//if (crouch)
//{
// presencetype = PRESENCE_CROUCH;
//} //end if
//else if (presencetype == PRESENCE_CROUCH)
//{
// if (AAS_PointPresenceType(org) & PRESENCE_NORMAL)
// {
// presencetype = PRESENCE_NORMAL;
// } //end if
//} //end else
#endif // RTCW_XX
//save the current origin
VectorCopy( org, lastorg );
//move linear during one frame
VectorCopy( frame_test_vel, left_test_vel );
j = 0;
do
{
VectorAdd( org, left_test_vel, end );
//trace a bounding box
#if !defined RTCW_ET
trace = AAS_TraceClientBBox( org, end, presencetype, entnum );
#else
//trace = AAS_TraceClientBBox(org, end, PRESENCE_NORMAL, entnum);
trace = AAS_Trace( org, mins, maxs, end, entnum, ( CONTENTS_SOLID | CONTENTS_PLAYERCLIP ) & ~CONTENTS_BODY );
#endif // RTCW_XX
//
//#ifdef AAS_MOVE_DEBUG
if ( visualize ) {
#if !defined RTCW_ET
if ( trace.startsolid ) {
botimport.Print( PRT_MESSAGE, "PredictMovement: start solid\n" );
}
#else
//if (trace.startsolid)
//botimport.Print(PRT_MESSAGE, "PredictMovement: start solid\n");
#endif // RTCW_XX
AAS_DebugLine( org, trace.endpos, LINECOLOR_RED );
} //end if
//#endif //AAS_MOVE_DEBUG
//
#if defined RTCW_ET
if ( stopevent & SE_HITENT ) {
if ( trace.fraction < 1.0 && trace.ent == hitent ) {
areanum = AAS_PointAreaNum( org );
VectorCopy( org, move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->trace = trace;
move->stopevent = SE_HITENT;
move->presencetype = ( *aasworld ).areasettings[areanum].presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
#endif // RTCW_XX
if ( stopevent & SE_ENTERAREA ) {
numareas = AAS_TraceAreas( org, trace.endpos, areas, points, 20 );
for ( i = 0; i < numareas; i++ )
{
if ( areas[i] == stopareanum ) {
VectorCopy( points[i], move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->trace = trace;
move->stopevent = SE_ENTERAREA;
#if !defined RTCW_ET
move->presencetype = presencetype;
#else
move->presencetype = ( *aasworld ).areasettings[areas[i]].presencetype;
#endif // RTCW_XX
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end for
} //end if
#if defined RTCW_ET
if ( stopevent & SE_STUCK ) {
if ( trace.fraction < 1.0 ) {
plane = &trace.plane;
//if (Q_fabs(plane->normal[2]) <= sv_maxsteepness) {
VectorNormalize2( frame_test_vel, wishdir );
if ( DotProduct( plane->normal, wishdir ) < -0.8 ) {
areanum = AAS_PointAreaNum( org );
VectorCopy( org, move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->trace = trace;
move->stopevent = SE_STUCK;
move->presencetype = ( *aasworld ).areasettings[areanum].presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
}
#endif // RTCW_XX
//move the entity to the trace end point
VectorCopy( trace.endpos, org );
//if there was a collision
if ( trace.fraction < 1.0 ) {
//get the plane the bounding box collided with
#if !defined RTCW_ET
plane = AAS_PlaneFromNum( trace.planenum );
#else
plane = &trace.plane;
#endif // RTCW_XX
//
if ( stopevent & SE_HITGROUNDAREA ) {
if ( DotProduct( plane->normal, up ) > sv_maxsteepness ) {
VectorCopy( org, start );
start[2] += 0.5;
#if !defined RTCW_ET
if ( AAS_PointAreaNum( start ) == stopareanum ) {
#else
if ( ( stopareanum < 0 && AAS_PointAreaNum( start ) ) || ( AAS_PointAreaNum( start ) == stopareanum ) ) {
#endif // RTCW_XX
VectorCopy( start, move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->trace = trace;
move->stopevent = SE_HITGROUNDAREA;
#if !defined RTCW_ET
move->presencetype = presencetype;
#else
move->presencetype = ( *aasworld ).areasettings[stopareanum].presencetype;
#endif // RTCW_XX
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
} //end if
//assume there's no step
step = qfalse;
//if it is a vertical plane and the bot didn't jump recently
if ( plane->normal[2] == 0 && ( jump_frame < 0 || n - jump_frame > 2 ) ) {
//check for a step
VectorMA( org, -0.25, plane->normal, start );
VectorCopy( start, stepend );
start[2] += sv_maxstep;
#if !defined RTCW_ET
steptrace = AAS_TraceClientBBox( start, stepend, presencetype, entnum );
#else
//steptrace = AAS_TraceClientBBox(start, stepend, PRESENCE_NORMAL, entnum);
steptrace = AAS_Trace( start, mins, maxs, stepend, entnum, ( CONTENTS_SOLID | CONTENTS_PLAYERCLIP ) & ~CONTENTS_BODY );
#endif // RTCW_XX
//
if ( !steptrace.startsolid ) {
#if !defined RTCW_ET
plane2 = AAS_PlaneFromNum( steptrace.planenum );
#else
plane2 = &steptrace.plane;
#endif // RTCW_XX
if ( DotProduct( plane2->normal, up ) > sv_maxsteepness ) {
VectorSubtract( end, steptrace.endpos, left_test_vel );
left_test_vel[2] = 0;
frame_test_vel[2] = 0;
//#ifdef AAS_MOVE_DEBUG
if ( visualize ) {
if ( steptrace.endpos[2] - org[2] > 0.125 ) {
VectorCopy( org, start );
start[2] = steptrace.endpos[2];
AAS_DebugLine( org, start, LINECOLOR_BLUE );
} //end if
} //end if
//#endif //AAS_MOVE_DEBUG
org[2] = steptrace.endpos[2];
step = qtrue;
} //end if
} //end if
} //end if
//
if ( !step ) {
//velocity left to test for this frame is the projection
//of the current test velocity into the hit plane
VectorMA( left_test_vel, -DotProduct( left_test_vel, plane->normal ),
plane->normal, left_test_vel );
#if defined RTCW_ET
// RF: from PM_SlideMove()
// if this is the same plane we hit before, nudge velocity
// out along it, which fixes some epsilon issues with
// non-axial planes
if ( lplane && DotProduct( lplane->normal, plane->normal ) > 0.99 ) {
VectorAdd( plane->normal, left_test_vel, left_test_vel );
}
lplane = plane;
#endif // RTCW_XX
//store the old velocity for landing check
VectorCopy( frame_test_vel, old_frame_test_vel );
//test velocity for the next frame is the projection
//of the velocity of the current frame into the hit plane
VectorMA( frame_test_vel, -DotProduct( frame_test_vel, plane->normal ),
plane->normal, frame_test_vel );
//check for a landing on an almost horizontal floor
if ( DotProduct( plane->normal, up ) > sv_maxsteepness ) {
onground = qtrue;
} //end if
if ( stopevent & SE_HITGROUNDDAMAGE ) {
delta = 0;
if ( old_frame_test_vel[2] < 0 &&
frame_test_vel[2] > old_frame_test_vel[2] &&
!onground ) {
delta = old_frame_test_vel[2];
} //end if
else if ( onground ) {
delta = frame_test_vel[2] - old_frame_test_vel[2];
} //end else
if ( delta ) {
delta = delta * 10;
delta = delta * delta * 0.0001;
if ( swimming ) {
delta = 0;
}
// never take falling damage if completely underwater
/*
if (ent->waterlevel == 3) return;
if (ent->waterlevel == 2) delta *= 0.25;
if (ent->waterlevel == 1) delta *= 0.5;
*/
if ( delta > 40 ) {
VectorCopy( org, move->endpos );
VectorCopy( frame_test_vel, move->velocity );
move->trace = trace;
move->stopevent = SE_HITGROUNDDAMAGE;
#if !defined RTCW_ET
move->presencetype = presencetype;
#else
areanum = AAS_PointAreaNum( org );
if ( areanum ) {
move->presencetype = ( *aasworld ).areasettings[areanum].presencetype;
}
#endif // RTCW_XX
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
} //end if
} //end if
} //end if
//extra check to prevent endless loop
if ( ++j > 20 ) {
return qfalse;
}
//while there is a plane hit
} while ( trace.fraction < 1.0 );
//if going down
if ( frame_test_vel[2] <= 10 ) {
//check for a liquid at the feet of the bot
VectorCopy( org, feet );
feet[2] -= 22;
pc = AAS_PointContents( feet );
//get event from pc
event = SE_NONE;
if ( pc & CONTENTS_LAVA ) {
event |= SE_ENTERLAVA;
}
if ( pc & CONTENTS_SLIME ) {
event |= SE_ENTERSLIME;
}
if ( pc & CONTENTS_WATER ) {
event |= SE_ENTERWATER;
}
//
areanum = AAS_PointAreaNum( org );
if ( ( *aasworld ).areasettings[areanum].contents & AREACONTENTS_LAVA ) {
event |= SE_ENTERLAVA;
}
if ( ( *aasworld ).areasettings[areanum].contents & AREACONTENTS_SLIME ) {
event |= SE_ENTERSLIME;
}
if ( ( *aasworld ).areasettings[areanum].contents & AREACONTENTS_WATER ) {
event |= SE_ENTERWATER;
}
//if in lava or slime
if ( event & stopevent ) {
VectorCopy( org, move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->stopevent = event & stopevent;
#if !defined RTCW_ET
move->presencetype = presencetype;
#else
move->presencetype = ( *aasworld ).areasettings[areanum].presencetype;
#endif // RTCW_XX
move->endcontents = pc;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
//
#if !defined RTCW_ET
onground = AAS_OnGround( org, presencetype, entnum );
#else
onground = AAS_OnGround( org, PRESENCE_NORMAL, entnum );
#endif // RTCW_XX
//if onground and on the ground for at least one whole frame
if ( onground ) {
if ( stopevent & SE_HITGROUND ) {
VectorCopy( org, move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->trace = trace;
move->stopevent = SE_HITGROUND;
#if !defined RTCW_ET
move->presencetype = presencetype;
#else
areanum = AAS_PointAreaNum( org );
if ( areanum ) {
move->presencetype = ( *aasworld ).areasettings[areanum].presencetype;
}
#endif // RTCW_XX
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
else if ( stopevent & SE_LEAVEGROUND ) {
VectorCopy( org, move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->trace = trace;
move->stopevent = SE_LEAVEGROUND;
#if !defined RTCW_ET
move->presencetype = presencetype;
#else
areanum = AAS_PointAreaNum( org );
if ( areanum ) {
move->presencetype = ( *aasworld ).areasettings[areanum].presencetype;
}
#endif // RTCW_XX
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end else if
else if ( stopevent & SE_GAP ) {
#if !defined RTCW_ET
aas_trace_t gaptrace;
#else
bsp_trace_t gaptrace;
#endif // RTCW_XX
VectorCopy( org, start );
VectorCopy( start, end );
end[2] -= 48 + aassettings.sv_maxbarrier;
#if !defined RTCW_ET
gaptrace = AAS_TraceClientBBox( start, end, PRESENCE_CROUCH, -1 );
#else
//gaptrace = AAS_TraceClientBBox(start, end, PRESENCE_CROUCH, -1);
gaptrace = AAS_Trace( start, mins, maxs, end, -1, ( CONTENTS_SOLID | CONTENTS_PLAYERCLIP ) & ~CONTENTS_BODY );
#endif // RTCW_XX
//if solid is found the bot cannot walk any further and will not fall into a gap
if ( !gaptrace.startsolid ) {
//if it is a gap (lower than one step height)
if ( gaptrace.endpos[2] < org[2] - aassettings.sv_maxstep - 1 ) {
if ( !( AAS_PointContents( end ) & ( CONTENTS_WATER | CONTENTS_SLIME ) ) ) { //----(SA) modified since slime is no longer deadly
// if (!(AAS_PointContents(end) & CONTENTS_WATER))
VectorCopy( lastorg, move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->trace = trace;
move->stopevent = SE_GAP;
#if !defined RTCW_ET
move->presencetype = presencetype;
#else
areanum = AAS_PointAreaNum( org );
if ( areanum ) {
move->presencetype = ( *aasworld ).areasettings[areanum].presencetype;
}
#endif // RTCW_XX
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
} //end if
} //end else if
if ( stopevent & SE_TOUCHJUMPPAD ) {
if ( ( *aasworld ).areasettings[AAS_PointAreaNum( org )].contents & AREACONTENTS_JUMPPAD ) {
VectorCopy( org, move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->trace = trace;
move->stopevent = SE_TOUCHJUMPPAD;
#if !defined RTCW_ET
move->presencetype = presencetype;
#else
areanum = AAS_PointAreaNum( org );
if ( areanum ) {
move->presencetype = ( *aasworld ).areasettings[areanum].presencetype;
}
#endif // RTCW_XX
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
if ( stopevent & SE_TOUCHTELEPORTER ) {
if ( ( *aasworld ).areasettings[AAS_PointAreaNum( org )].contents & AREACONTENTS_TELEPORTER ) {
VectorCopy( org, move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->trace = trace;
move->stopevent = SE_TOUCHTELEPORTER;
#if !defined RTCW_ET
move->presencetype = presencetype;
#else
areanum = AAS_PointAreaNum( org );
if ( areanum ) {
move->presencetype = ( *aasworld ).areasettings[areanum].presencetype;
}
#endif // RTCW_XX
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
} //end if
} //end if
} //end for
//
#if defined RTCW_ET
areanum = AAS_PointAreaNum( org );
#endif // RTCW_XX
VectorCopy( org, move->endpos );
VectorScale( frame_test_vel, 1 / frametime, move->velocity );
move->stopevent = SE_NONE;
#if !defined RTCW_ET
move->presencetype = presencetype;
#else
move->presencetype = aasworld->areasettings ? aasworld->areasettings[areanum].presencetype : 0;
#endif // RTCW_XX
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
//
return qtrue;
} //end of the function AAS_PredictClientMovement
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_TestMovementPrediction( int entnum, vec3_t origin, vec3_t dir ) {
vec3_t velocity, cmdmove;
aas_clientmove_t move;
VectorClear( velocity );
if ( !AAS_Swimming( origin ) ) {
dir[2] = 0;
}
VectorNormalize( dir );
VectorScale( dir, 400, cmdmove );
cmdmove[2] = 224;
AAS_ClearShownDebugLines();
AAS_PredictClientMovement( &move, entnum, origin, PRESENCE_NORMAL, qtrue,
velocity, cmdmove, 13, 13, 0.1, SE_HITGROUND, 0, qtrue ); //SE_LEAVEGROUND);
if ( move.stopevent & SE_LEAVEGROUND ) {
botimport.Print( PRT_MESSAGE, "leave ground\n" );
} //end if
} //end of the function TestMovementPrediction
//===========================================================================
// calculates the horizontal velocity needed to perform a jump from start
// to end
//
// Parameter: zvel : z velocity for jump
// start : start position of jump
// end : end position of jump
// *speed : returned speed for jump
// Returns: qfalse if too high or too far from start to end
// Changes Globals: -
//===========================================================================
int AAS_HorizontalVelocityForJump( float zvel, vec3_t start, vec3_t end, float *velocity ) {
float sv_gravity, sv_maxvelocity;
float maxjump, height2fall, t, top;
vec3_t dir;
sv_gravity = aassettings.sv_gravity;
sv_maxvelocity = aassettings.sv_maxvelocity;
//maximum height a player can jump with the given initial z velocity
maxjump = 0.5 * sv_gravity * ( zvel / sv_gravity ) * ( zvel / sv_gravity );
//top of the parabolic jump
top = start[2] + maxjump;
//height the bot will fall from the top
height2fall = top - end[2];
//if the goal is to high to jump to
if ( height2fall < 0 ) {
*velocity = sv_maxvelocity;
return 0;
} //end if
//time a player takes to fall the height
t = c::sqrt( height2fall / ( 0.5 * sv_gravity ) );
//direction from start to end
VectorSubtract( end, start, dir );
//calculate horizontal speed
*velocity = c::sqrt( dir[0] * dir[0] + dir[1] * dir[1] ) / ( t + zvel / sv_gravity );
//the horizontal speed must be lower than the max speed
if ( *velocity > sv_maxvelocity ) {
*velocity = sv_maxvelocity;
return 0;
} //end if
return 1;
} //end of the function AAS_HorizontalVelocityForJump
//===========================================================================
// recursive subdivision of the line by the BSP tree.
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
aas_trace_t AAS_TraceClientBBox(vec3_t start, vec3_t end, int presencetype,
int passent)
{
int side, nodenum, tmpplanenum;
float front, back, frac;
vec3_t cur_start, cur_end, cur_mid, v1, v2;
aas_tracestack_t tracestack[127];
aas_tracestack_t *tstack_p;
aas_node_t *aasnode;
aas_plane_t *plane;
aas_trace_t trace;
//clear the trace structure
Com_Memset(&trace, 0, sizeof(aas_trace_t));
if (!aasworld.loaded) return trace;
tstack_p = tracestack;
//we start with the whole line on the stack
VectorCopy(start, tstack_p->start);
VectorCopy(end, tstack_p->end);
tstack_p->planenum = 0;
//start with node 1 because node zero is a dummy for a solid leaf
tstack_p->nodenum = 1; //starting at the root of the tree
tstack_p++;
while (1)
{
//pop up the stack
tstack_p--;
//if the trace stack is empty (ended up with a piece of the
//line to be traced in an area)
if (tstack_p < tracestack)
{
tstack_p++;
//nothing was hit
trace.startsolid = qfalse;
trace.fraction = 1.0;
//endpos is the end of the line
VectorCopy(end, trace.endpos);
//nothing hit
trace.ent = 0;
trace.area = 0;
trace.planenum = 0;
return trace;
} //end if
//number of the current node to test the line against
nodenum = tstack_p->nodenum;
//if it is an area
if (nodenum < 0)
{
#ifdef AAS_SAMPLE_DEBUG
if (-nodenum > aasworld.numareasettings)
{
botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: -nodenum out of range\n");
return trace;
} //end if
#endif //AAS_SAMPLE_DEBUG
//botimport.Print(PRT_MESSAGE, "areanum = %d, must be %d\n", -nodenum, AAS_PointAreaNum(start));
//if can't enter the area because it hasn't got the right presence type
if (!(aasworld.areasettings[-nodenum].presencetype & presencetype))
{
//if the start point is still the initial start point
//NOTE: no need for epsilons because the points will be
//exactly the same when they're both the start point
if (tstack_p->start[0] == start[0] &&
tstack_p->start[1] == start[1] &&
tstack_p->start[2] == start[2])
{
trace.startsolid = qtrue;
trace.fraction = 0.0;
VectorClear(v1);
} //end if
else
{
trace.startsolid = qfalse;
VectorSubtract(end, start, v1);
VectorSubtract(tstack_p->start, start, v2);
trace.fraction = VectorLength(v2) / VectorNormalize(v1);
VectorMA(tstack_p->start, -0.125, v1, tstack_p->start);
} //end else
VectorCopy(tstack_p->start, trace.endpos);
trace.ent = 0;
trace.area = -nodenum;
// VectorSubtract(end, start, v1);
trace.planenum = tstack_p->planenum;
//always take the plane with normal facing towards the trace start
plane = &aasworld.planes[trace.planenum];
if (DotProduct(v1, plane->normal) > 0) trace.planenum ^= 1;
return trace;
} //end if
else
{
if (passent >= 0)
{
if (AAS_AreaEntityCollision(-nodenum, tstack_p->start,
tstack_p->end, presencetype, passent,
&trace))
{
if (!trace.startsolid)
{
VectorSubtract(end, start, v1);
VectorSubtract(trace.endpos, start, v2);
trace.fraction = VectorLength(v2) / VectorLength(v1);
} //end if
return trace;
} //end if
} //end if
} //end else
trace.lastarea = -nodenum;
continue;
} //end if
//if it is a solid leaf
if (!nodenum)
{
//if the start point is still the initial start point
//NOTE: no need for epsilons because the points will be
//exactly the same when they're both the start point
if (tstack_p->start[0] == start[0] &&
tstack_p->start[1] == start[1] &&
tstack_p->start[2] == start[2])
{
trace.startsolid = qtrue;
trace.fraction = 0.0;
VectorClear(v1);
} //end if
else
{
trace.startsolid = qfalse;
VectorSubtract(end, start, v1);
VectorSubtract(tstack_p->start, start, v2);
trace.fraction = VectorLength(v2) / VectorNormalize(v1);
VectorMA(tstack_p->start, -0.125, v1, tstack_p->start);
} //end else
VectorCopy(tstack_p->start, trace.endpos);
trace.ent = 0;
trace.area = 0; //hit solid leaf
// VectorSubtract(end, start, v1);
trace.planenum = tstack_p->planenum;
//always take the plane with normal facing towards the trace start
plane = &aasworld.planes[trace.planenum];
if (DotProduct(v1, plane->normal) > 0) trace.planenum ^= 1;
return trace;
} //end if
#ifdef AAS_SAMPLE_DEBUG
if (nodenum > aasworld.numnodes)
{
botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: nodenum out of range\n");
return trace;
} //end if
#endif //AAS_SAMPLE_DEBUG
//the node to test against
aasnode = &aasworld.nodes[nodenum];
//start point of current line to test against node
VectorCopy(tstack_p->start, cur_start);
//end point of the current line to test against node
VectorCopy(tstack_p->end, cur_end);
//the current node plane
plane = &aasworld.planes[aasnode->planenum];
// switch(plane->type)
{/*FIXME: wtf doesn't this work? obviously the axial node planes aren't always facing positive!!!
//check for axial planes
case PLANE_X:
{
front = cur_start[0] - plane->dist;
back = cur_end[0] - plane->dist;
break;
} //end case
case PLANE_Y:
{
front = cur_start[1] - plane->dist;
back = cur_end[1] - plane->dist;
break;
} //end case
case PLANE_Z:
{
front = cur_start[2] - plane->dist;
back = cur_end[2] - plane->dist;
break;
} //end case*/
// default: //gee it's not an axial plane
{
front = DotProduct(cur_start, plane->normal) - plane->dist;
back = DotProduct(cur_end, plane->normal) - plane->dist;
// break;
} //end default
} //end switch
// bk010221 - old location of FPE hack and divide by zero expression
//if the whole to be traced line is totally at the front of this node
//only go down the tree with the front child
if ((front >= -ON_EPSILON && back >= -ON_EPSILON))
{
//keep the current start and end point on the stack
//and go down the tree with the front child
tstack_p->nodenum = aasnode->children[0];
tstack_p++;
if (tstack_p >= &tracestack[127])
{
botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
return trace;
} //end if
} //end if
//if the whole to be traced line is totally at the back of this node
//only go down the tree with the back child
else if ((front < ON_EPSILON && back < ON_EPSILON))
{
//keep the current start and end point on the stack
//and go down the tree with the back child
tstack_p->nodenum = aasnode->children[1];
tstack_p++;
if (tstack_p >= &tracestack[127])
{
botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
return trace;
} //end if
} //end if
//go down the tree both at the front and back of the node
else
{
tmpplanenum = tstack_p->planenum;
// bk010221 - new location of divide by zero (see above)
if ( front == back ) front -= 0.001f; // bk0101022 - hack/FPE
//calculate the hitpoint with the node (split point of the line)
//put the crosspoint TRACEPLANE_EPSILON pixels on the near side
if (front < 0) frac = (front + TRACEPLANE_EPSILON)/(front-back);
else frac = (front - TRACEPLANE_EPSILON)/(front-back); // bk010221
//
if (frac < 0)
frac = 0.001f; //0
else if (frac > 1)
frac = 0.999f; //1
//frac = front / (front-back);
//
cur_mid[0] = cur_start[0] + (cur_end[0] - cur_start[0]) * frac;
cur_mid[1] = cur_start[1] + (cur_end[1] - cur_start[1]) * frac;
cur_mid[2] = cur_start[2] + (cur_end[2] - cur_start[2]) * frac;
// AAS_DrawPlaneCross(cur_mid, plane->normal, plane->dist, plane->type, LINECOLOR_RED);
//side the front part of the line is on
side = front < 0;
//first put the end part of the line on the stack (back side)
VectorCopy(cur_mid, tstack_p->start);
//not necesary to store because still on stack
//VectorCopy(cur_end, tstack_p->end);
tstack_p->planenum = aasnode->planenum;
tstack_p->nodenum = aasnode->children[!side];
tstack_p++;
if (tstack_p >= &tracestack[127])
{
botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
return trace;
} //end if
//now put the part near the start of the line on the stack so we will
//continue with thats part first. This way we'll find the first
//hit of the bbox
VectorCopy(cur_start, tstack_p->start);
VectorCopy(cur_mid, tstack_p->end);
tstack_p->planenum = tmpplanenum;
tstack_p->nodenum = aasnode->children[side];
tstack_p++;
if (tstack_p >= &tracestack[127])
{
botimport.Print(PRT_ERROR, "AAS_TraceBoundingBox: stack overflow\n");
return trace;
} //end if
} //end else
} //end while
// return trace;
} //end of the function AAS_TraceClientBBox
aas_link_t *AAS_AASLinkEntity(vec3_t absmins, vec3_t absmaxs, int entnum)
{
int side, nodenum;
aas_linkstack_t linkstack[128];
aas_linkstack_t *lstack_p;
aas_node_t *aasnode;
aas_plane_t *plane;
aas_link_t *link, *areas;
if (!aasworld.loaded)
{
botimport.Print(PRT_ERROR, "AAS_LinkEntity: aas not loaded\n");
return NULL;
} //end if
areas = NULL;
//
lstack_p = linkstack;
//we start with the whole line on the stack
//start with node 1 because node zero is a dummy used for solid leafs
lstack_p->nodenum = 1; //starting at the root of the tree
lstack_p++;
while (1)
{
//pop up the stack
lstack_p--;
//if the trace stack is empty (ended up with a piece of the
//line to be traced in an area)
if (lstack_p < linkstack) break;
//number of the current node to test the line against
nodenum = lstack_p->nodenum;
//if it is an area
if (nodenum < 0)
{
//NOTE: the entity might have already been linked into this area
// because several node children can point to the same area
for (link = aasworld.arealinkedentities[-nodenum]; link; link = link->next_ent)
{
if (link->entnum == entnum) break;
} //end for
if (link) continue;
//
link = AAS_AllocAASLink();
if (!link) return areas;
link->entnum = entnum;
link->areanum = -nodenum;
//put the link into the double linked area list of the entity
link->prev_area = NULL;
link->next_area = areas;
if (areas) areas->prev_area = link;
areas = link;
//put the link into the double linked entity list of the area
link->prev_ent = NULL;
link->next_ent = aasworld.arealinkedentities[-nodenum];
if (aasworld.arealinkedentities[-nodenum])
aasworld.arealinkedentities[-nodenum]->prev_ent = link;
aasworld.arealinkedentities[-nodenum] = link;
//
continue;
} //end if
//if solid leaf
if (!nodenum) continue;
//the node to test against
aasnode = &aasworld.nodes[nodenum];
//the current node plane
plane = &aasworld.planes[aasnode->planenum];
//get the side(s) the box is situated relative to the plane
side = AAS_BoxOnPlaneSide2(absmins, absmaxs, plane);
//if on the front side of the node
if (side & 1)
{
lstack_p->nodenum = aasnode->children[0];
lstack_p++;
} //end if
if (lstack_p >= &linkstack[127])
{
botimport.Print(PRT_ERROR, "AAS_LinkEntity: stack overflow\n");
break;
} //end if
//if on the back side of the node
if (side & 2)
{
lstack_p->nodenum = aasnode->children[1];
lstack_p++;
} //end if
if (lstack_p >= &linkstack[127])
{
botimport.Print(PRT_ERROR, "AAS_LinkEntity: stack overflow\n");
break;
} //end if
} //end while
return areas;
} //end of the function AAS_AASLinkEntity
int BotExportTest(int parm0, char *parm1, vec3_t parm2, vec3_t parm3)
{
// return AAS_PointLight(parm2, NULL, NULL, NULL);
#ifdef DEBUG
static int area = -1;
static int line[2];
int newarea, i, highlightarea, flood;
// int reachnum;
vec3_t eye, forward, right, end, origin;
// vec3_t bottomcenter;
// aas_trace_t trace;
// aas_face_t *face;
// aas_entity_t *ent;
// bsp_trace_t bsptrace;
// aas_reachability_t reach;
// bot_goal_t goal;
// clock_t start_time, end_time;
vec3_t mins = {-16, -16, -24};
vec3_t maxs = {16, 16, 32};
// int areas[10], numareas;
//return 0;
if (!aasworld.loaded) return 0;
/*
if (parm0 & 1)
{
AAS_ClearShownPolygons();
AAS_FloodAreas(parm2);
} //end if
return 0;
*/
for (i = 0; i < 2; i++) if (!line[i]) line[i] = botimport.DebugLineCreate();
// AAS_ClearShownDebugLines();
//if (AAS_AgainstLadder(parm2)) botimport.Print(PRT_MESSAGE, "against ladder\n");
//BotOnGround(parm2, PRESENCE_NORMAL, 1, &newarea, &newarea);
//botimport.Print(PRT_MESSAGE, "%f %f %f\n", parm2[0], parm2[1], parm2[2]);
//*
highlightarea = LibVarGetValue("bot_highlightarea");
if (highlightarea > 0)
{
newarea = highlightarea;
} //end if
else
{
VectorCopy(parm2, origin);
origin[2] += 0.5;
//newarea = AAS_PointAreaNum(origin);
newarea = BotFuzzyPointReachabilityArea(origin);
} //end else
botimport.Print(PRT_MESSAGE, "\rtravel time to goal (%d) = %d ", botlibglobals.goalareanum,
AAS_AreaTravelTimeToGoalArea(newarea, origin, botlibglobals.goalareanum, TFL_DEFAULT));
//newarea = BotReachabilityArea(origin, qtrue);
if (newarea != area)
{
botimport.Print(PRT_MESSAGE, "origin = %f, %f, %f\n", origin[0], origin[1], origin[2]);
area = newarea;
botimport.Print(PRT_MESSAGE, "new area %d, cluster %d, presence type %d\n",
area, AAS_AreaCluster(area), AAS_PointPresenceType(origin));
botimport.Print(PRT_MESSAGE, "area contents: ");
if (aasworld.areasettings[area].contents & AREACONTENTS_WATER)
{
botimport.Print(PRT_MESSAGE, "water &");
} //end if
if (aasworld.areasettings[area].contents & AREACONTENTS_LAVA)
{
botimport.Print(PRT_MESSAGE, "lava &");
} //end if
if (aasworld.areasettings[area].contents & AREACONTENTS_SLIME)
{
botimport.Print(PRT_MESSAGE, "slime &");
} //end if
if (aasworld.areasettings[area].contents & AREACONTENTS_JUMPPAD)
{
botimport.Print(PRT_MESSAGE, "jump pad &");
} //end if
if (aasworld.areasettings[area].contents & AREACONTENTS_CLUSTERPORTAL)
{
botimport.Print(PRT_MESSAGE, "cluster portal &");
} //end if
if (aasworld.areasettings[area].contents & AREACONTENTS_VIEWPORTAL)
{
botimport.Print(PRT_MESSAGE, "view portal &");
} //end if
if (aasworld.areasettings[area].contents & AREACONTENTS_DONOTENTER)
{
botimport.Print(PRT_MESSAGE, "do not enter &");
} //end if
if (aasworld.areasettings[area].contents & AREACONTENTS_MOVER)
{
botimport.Print(PRT_MESSAGE, "mover &");
} //end if
if (!aasworld.areasettings[area].contents)
{
botimport.Print(PRT_MESSAGE, "empty");
} //end if
botimport.Print(PRT_MESSAGE, "\n");
botimport.Print(PRT_MESSAGE, "travel time to goal (%d) = %d\n", botlibglobals.goalareanum,
AAS_AreaTravelTimeToGoalArea(newarea, origin, botlibglobals.goalareanum, TFL_DEFAULT|TFL_ROCKETJUMP));
/*
VectorCopy(origin, end);
end[2] += 5;
numareas = AAS_TraceAreas(origin, end, areas, NULL, 10);
AAS_TraceClientBBox(origin, end, PRESENCE_CROUCH, -1);
botimport.Print(PRT_MESSAGE, "num areas = %d, area = %d\n", numareas, areas[0]);
*/
/*
botlibglobals.goalareanum = newarea;
VectorCopy(parm2, botlibglobals.goalorigin);
botimport.Print(PRT_MESSAGE, "new goal %2.1f %2.1f %2.1f area %d\n",
origin[0], origin[1], origin[2], newarea);
*/
} //end if
//*
flood = LibVarGetValue("bot_flood");
if (parm0 & 1)
{
if (flood)
{
AAS_ClearShownPolygons();
AAS_ClearShownDebugLines();
AAS_FloodAreas(parm2);
}
else
{
botlibglobals.goalareanum = newarea;
VectorCopy(parm2, botlibglobals.goalorigin);
botimport.Print(PRT_MESSAGE, "new goal %2.1f %2.1f %2.1f area %d\n",
origin[0], origin[1], origin[2], newarea);
}
} //end if*/
if (flood)
return 0;
// if (parm0 & BUTTON_USE)
// {
// botlibglobals.runai = !botlibglobals.runai;
// if (botlibglobals.runai) botimport.Print(PRT_MESSAGE, "started AI\n");
// else botimport.Print(PRT_MESSAGE, "stopped AI\n");
//* /
/*
goal.areanum = botlibglobals.goalareanum;
reachnum = BotGetReachabilityToGoal(parm2, newarea, 1,
ms.avoidreach, ms.avoidreachtimes,
&goal, TFL_DEFAULT);
if (!reachnum)
{
botimport.Print(PRT_MESSAGE, "goal not reachable\n");
} //end if
else
{
AAS_ReachabilityFromNum(reachnum, &reach);
AAS_ClearShownDebugLines();
AAS_ShowArea(area, qtrue);
AAS_ShowArea(reach.areanum, qtrue);
AAS_DrawCross(reach.start, 6, LINECOLOR_BLUE);
AAS_DrawCross(reach.end, 6, LINECOLOR_RED);
//
if ((reach.traveltype & TRAVELTYPE_MASK) == TRAVEL_ELEVATOR)
{
ElevatorBottomCenter(&reach, bottomcenter);
AAS_DrawCross(bottomcenter, 10, LINECOLOR_GREEN);
} //end if
} //end else*/
// botimport.Print(PRT_MESSAGE, "travel time to goal = %d\n",
// AAS_AreaTravelTimeToGoalArea(area, origin, botlibglobals.goalareanum, TFL_DEFAULT));
// botimport.Print(PRT_MESSAGE, "test rj from 703 to 716\n");
// AAS_Reachability_WeaponJump(703, 716);
// } //end if*/
/* face = AAS_AreaGroundFace(newarea, parm2);
if (face)
{
AAS_ShowFace(face - aasworld.faces);
} //end if*/
/*
AAS_ClearShownDebugLines();
AAS_ShowArea(newarea, parm0 & BUTTON_USE);
AAS_ShowReachableAreas(area);
*/
AAS_ClearShownPolygons();
AAS_ClearShownDebugLines();
AAS_ShowAreaPolygons(newarea, 1, parm0 & 4);
if (parm0 & 2) AAS_ShowReachableAreas(area);
else
{
static int lastgoalareanum, lastareanum;
static int avoidreach[MAX_AVOIDREACH];
static float avoidreachtimes[MAX_AVOIDREACH];
static int avoidreachtries[MAX_AVOIDREACH];
int reachnum, resultFlags;
bot_goal_t goal;
aas_reachability_t reach;
/*
goal.areanum = botlibglobals.goalareanum;
VectorCopy(botlibglobals.goalorigin, goal.origin);
reachnum = BotGetReachabilityToGoal(origin, newarea,
lastgoalareanum, lastareanum,
avoidreach, avoidreachtimes, avoidreachtries,
&goal, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP,
NULL, 0, &resultFlags);
AAS_ReachabilityFromNum(reachnum, &reach);
AAS_ShowReachability(&reach);
*/
int curarea;
vec3_t curorigin;
goal.areanum = botlibglobals.goalareanum;
VectorCopy(botlibglobals.goalorigin, goal.origin);
VectorCopy(origin, curorigin);
curarea = newarea;
for ( i = 0; i < 100; i++ ) {
if ( curarea == goal.areanum ) {
break;
}
reachnum = BotGetReachabilityToGoal(curorigin, curarea,
lastgoalareanum, lastareanum,
avoidreach, avoidreachtimes, avoidreachtries,
&goal, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP, TFL_DEFAULT|TFL_FUNCBOB|TFL_ROCKETJUMP,
NULL, 0, &resultFlags);
AAS_ReachabilityFromNum(reachnum, &reach);
AAS_ShowReachability(&reach);
VectorCopy(reach.end, origin);
lastareanum = curarea;
curarea = reach.areanum;
}
} //end else
VectorClear(forward);
//BotGapDistance(origin, forward, 0);
/*
if (parm0 & BUTTON_USE)
{
botimport.Print(PRT_MESSAGE, "test rj from 703 to 716\n");
AAS_Reachability_WeaponJump(703, 716);
} //end if*/
AngleVectors(parm3, forward, right, NULL);
//get the eye 16 units to the right of the origin
VectorMA(parm2, 8, right, eye);
//get the eye 24 units up
eye[2] += 24;
//get the end point for the line to be traced
VectorMA(eye, 800, forward, end);
// AAS_TestMovementPrediction(1, parm2, forward);
/*
//trace the line to find the hit point
trace = AAS_TraceClientBBox(eye, end, PRESENCE_NORMAL, 1);
if (!line[0]) line[0] = botimport.DebugLineCreate();
botimport.DebugLineShow(line[0], eye, trace.endpos, LINECOLOR_BLUE);
//
AAS_ClearShownDebugLines();
if (trace.ent)
{
ent = &aasworld.entities[trace.ent];
AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs);
} //end if
*/
/*
start_time = clock();
for (i = 0; i < 2000; i++)
{
AAS_Trace2(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
// AAS_TraceClientBBox(eye, end, PRESENCE_NORMAL, 1);
} //end for
end_time = clock();
botimport.Print(PRT_MESSAGE, "me %lu clocks, %lu CLOCKS_PER_SEC\n", end_time - start_time, CLOCKS_PER_SEC);
start_time = clock();
for (i = 0; i < 2000; i++)
{
AAS_Trace(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
} //end for
end_time = clock();
botimport.Print(PRT_MESSAGE, "id %lu clocks, %lu CLOCKS_PER_SEC\n", end_time - start_time, CLOCKS_PER_SEC);
*/
// TTimo: nested comments are BAD for gcc -Werror, use #if 0 instead..
#if 0
AAS_ClearShownDebugLines();
//bsptrace = AAS_Trace(eye, NULL, NULL, end, 1, MASK_PLAYERSOLID);
bsptrace = AAS_Trace(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
if (!line[0]) line[0] = botimport.DebugLineCreate();
botimport.DebugLineShow(line[0], eye, bsptrace.endpos, LINECOLOR_YELLOW);
if (bsptrace.fraction < 1.0)
{
face = AAS_TraceEndFace(&trace);
if (face)
{
AAS_ShowFace(face - aasworld.faces);
} //end if
AAS_DrawPlaneCross(bsptrace.endpos,
bsptrace.plane.normal,
bsptrace.plane.dist + bsptrace.exp_dist,
bsptrace.plane.type, LINECOLOR_GREEN);
if (trace.ent)
{
ent = &aasworld.entities[trace.ent];
AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs);
} //end if
} //end if
//bsptrace = AAS_Trace2(eye, NULL, NULL, end, 1, MASK_PLAYERSOLID);
bsptrace = AAS_Trace2(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
botimport.DebugLineShow(line[1], eye, bsptrace.endpos, LINECOLOR_BLUE);
if (bsptrace.fraction < 1.0)
{
AAS_DrawPlaneCross(bsptrace.endpos,
bsptrace.plane.normal,
bsptrace.plane.dist,// + bsptrace.exp_dist,
bsptrace.plane.type, LINECOLOR_RED);
if (bsptrace.ent)
{
ent = &aasworld.entities[bsptrace.ent];
AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs);
} //end if
} //end if
#endif
#endif
return 0;
} //end of the function BotExportTest
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_RemoveNotClusterClosingPortals(void)
{
int i, j, k, facenum, otherareanum, nonclosingportals;
aas_area_t *area;
aas_face_t *face;
AAS_RemoveTeleporterPortals();
//
nonclosingportals = 0;
for (i = 1; i < aasworld.numareas; i++)
{
if (!(aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)) continue;
//find a non-portal area adjacent to the portal area and flood
//the cluster from there
area = &aasworld.areas[i];
for (j = 0; j < area->numfaces; j++)
{
facenum = abs(aasworld.faceindex[area->firstface + j]);
face = &aasworld.faces[facenum];
//
if (face->frontarea != i) otherareanum = face->frontarea;
else otherareanum = face->backarea;
//
if (!otherareanum) continue;
//
if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL)
{
continue;
} //end if
//reset all cluster fields
AAS_RemoveClusterAreas();
//
AAS_FloodCluster_r(otherareanum, 1);
AAS_FloodClusterReachabilities(1);
//check if all adjacent non-portal areas have a cluster set
for (k = 0; k < area->numfaces; k++)
{
facenum = abs(aasworld.faceindex[area->firstface + k]);
face = &aasworld.faces[facenum];
//
if (face->frontarea != i) otherareanum = face->frontarea;
else otherareanum = face->backarea;
//
if (!otherareanum) continue;
//
if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL)
{
continue;
} //end if
//
if (!aasworld.areasettings[otherareanum].cluster) break;
} //end for
//if all adjacent non-portal areas have a cluster set then the portal
//didn't seal a cluster
if (k >= area->numfaces)
{
aasworld.areasettings[i].contents &= ~AREACONTENTS_CLUSTERPORTAL;
nonclosingportals++;
//recheck all the other portals again
i = 0;
break;
} //end if
} //end for
} //end for
botimport.Print(PRT_MESSAGE, "\r%6d non closing portals removed\n", nonclosingportals);
} //end of the function AAS_RemoveNotClusterClosingPortals
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_ParseBSPEntities(void)
{
script_t *script;
token_t token;
bsp_entity_t *ent;
bsp_epair_t *epair;
script = LoadScriptMemory(bspworld.dentdata, bspworld.entdatasize, "entdata");
SetScriptFlags(script, SCFL_NOSTRINGWHITESPACES|SCFL_NOSTRINGESCAPECHARS);//SCFL_PRIMITIVE);
bspworld.numentities = 1;
while(PS_ReadToken(script, &token))
{
if (strcmp(token.string, "{"))
{
ScriptError(script, "invalid %s", token.string);
AAS_FreeBSPEntities();
FreeScript(script);
return;
} //end if
if (bspworld.numentities >= MAX_BSPENTITIES)
{
botimport.Print(PRT_MESSAGE, "too many entities in BSP file\n");
break;
} //end if
ent = &bspworld.entities[bspworld.numentities];
bspworld.numentities++;
ent->epairs = NULL;
while(PS_ReadToken(script, &token))
{
if (!strcmp(token.string, "}")) break;
epair = (bsp_epair_t *) GetClearedHunkMemory(sizeof(bsp_epair_t));
epair->next = ent->epairs;
ent->epairs = epair;
if (token.type != TT_STRING)
{
ScriptError(script, "invalid %s", token.string);
AAS_FreeBSPEntities();
FreeScript(script);
return;
} //end if
StripDoubleQuotes(token.string);
epair->key = (char *) GetHunkMemory(strlen(token.string) + 1);
strcpy(epair->key, token.string);
if (!PS_ExpectTokenType(script, TT_STRING, 0, &token))
{
AAS_FreeBSPEntities();
FreeScript(script);
return;
} //end if
StripDoubleQuotes(token.string);
epair->value = (char *) GetHunkMemory(strlen(token.string) + 1);
strcpy(epair->value, token.string);
} //end while
if (strcmp(token.string, "}"))
{
ScriptError(script, "missing }");
AAS_FreeBSPEntities();
FreeScript(script);
return;
} //end if
} //end while
FreeScript(script);
} //end of the function AAS_ParseBSPEntities
int BotExportTest( int parm0, char *parm1, vec3_t parm2, vec3_t parm3 ) {
#if !defined RTCW_ET
// return AAS_PointLight(parm2, NULL, NULL, NULL);
#ifdef DEBUG
static int area = -1;
static int line[2];
#if defined RTCW_SP
int newarea, i, highlightarea, bot_testhidepos, hideposarea, bot_testroutevispos;
#elif defined RTCW_MP
int newarea, i, highlightarea, bot_testhidepos, hideposarea;
#endif // RTCW_XX
// int reachnum;
vec3_t eye, forward, right, end, origin;
// vec3_t bottomcenter;
// aas_trace_t trace;
// aas_face_t *face;
// aas_entity_t *ent;
// bsp_trace_t bsptrace;
// aas_reachability_t reach;
// bot_goal_t goal;
// clock_t start_time, end_time;
vec3_t mins = {-16, -16, -24};
vec3_t maxs = {16, 16, 32};
// int areas[10], numareas;
//return 0;
if ( !( *aasworld ).loaded ) {
return 0;
}
AAS_SetCurrentWorld( 0 );
for ( i = 0; i < 2; i++ ) if ( !line[i] ) {
line[i] = botimport.DebugLineCreate();
}
// AAS_ClearShownDebugLines();
bot_testhidepos = LibVarGetValue( "bot_testhidepos" );
if ( bot_testhidepos ) {
VectorCopy( parm2, origin );
newarea = BotFuzzyPointReachabilityArea( origin );
if ( parm0 & 1 ) {
botlibglobals.goalareanum = newarea;
VectorCopy( origin, botlibglobals.goalorigin );
botimport.Print( PRT_MESSAGE, "new enemy position %2.1f %2.1f %2.1f area %d\n",
origin[0], origin[1], origin[2], newarea );
} //end if
AAS_ClearShownPolygons();
AAS_ClearShownDebugLines();
#if defined RTCW_SP
hideposarea = AAS_NearestHideArea( -1, origin, AAS_PointAreaNum( origin ), 0,
#elif defined RTCW_MP
hideposarea = AAS_NearestHideArea( 0, origin, AAS_PointAreaNum( origin ), 0,
#endif // RTCW_XX
botlibglobals.goalorigin, botlibglobals.goalareanum, TFL_DEFAULT );
#if defined RTCW_SP
if ( bot_testhidepos > 1 ) {
if ( hideposarea ) {
botimport.Print( PRT_MESSAGE, "hidepos (%i) %2.1f %2.1f %2.1f\n",
hideposarea,
( *aasworld ).areawaypoints[hideposarea][0],
( *aasworld ).areawaypoints[hideposarea][1],
( *aasworld ).areawaypoints[hideposarea][2] );
} else {
botimport.Print( PRT_MESSAGE, "no hidepos found\n" );
}
}
#endif // RTCW_XX
//area we are currently in
AAS_ShowAreaPolygons( newarea, 1, qtrue );
//enemy position
AAS_ShowAreaPolygons( botlibglobals.goalareanum, 2, qtrue );
//area we should go hide
AAS_ShowAreaPolygons( hideposarea, 4, qtrue );
return 0;
}
#if defined RTCW_SP
bot_testroutevispos = LibVarGetValue( "bot_testroutevispos" );
if ( bot_testroutevispos ) {
VectorCopy( parm2, origin );
newarea = BotFuzzyPointReachabilityArea( origin );
if ( parm0 & 1 ) {
botlibglobals.goalareanum = newarea;
VectorCopy( origin, botlibglobals.goalorigin );
botimport.Print( PRT_MESSAGE, "new enemy position %2.1f %2.1f %2.1f area %d\n",
origin[0], origin[1], origin[2], newarea );
} //end if
AAS_ClearShownPolygons();
AAS_ClearShownDebugLines();
AAS_GetRouteFirstVisPos( botlibglobals.goalorigin, origin, TFL_DEFAULT, eye );
//area we are currently in
AAS_ShowAreaPolygons( newarea, 1, qtrue );
//enemy position
AAS_ShowAreaPolygons( botlibglobals.goalareanum, 2, qtrue );
//area that is visible in path from enemy pos
hideposarea = BotFuzzyPointReachabilityArea( eye );
AAS_ShowAreaPolygons( hideposarea, 4, qtrue );
return 0;
}
#endif // RTCW_XX
//if (AAS_AgainstLadder(parm2)) botimport.Print(PRT_MESSAGE, "against ladder\n");
//BotOnGround(parm2, PRESENCE_NORMAL, 1, &newarea, &newarea);
//botimport.Print(PRT_MESSAGE, "%f %f %f\n", parm2[0], parm2[1], parm2[2]);
//*
highlightarea = LibVarGetValue( "bot_highlightarea" );
if ( highlightarea > 0 ) {
newarea = highlightarea;
} //end if
else
{
VectorCopy( parm2, origin );
origin[2] += 0.5;
//newarea = AAS_PointAreaNum(origin);
newarea = BotFuzzyPointReachabilityArea( origin );
} //end else
botimport.Print( PRT_MESSAGE, "\rtravel time to goal (%d) = %d ", botlibglobals.goalareanum,
AAS_AreaTravelTimeToGoalArea( newarea, origin, botlibglobals.goalareanum, TFL_DEFAULT ) );
//newarea = BotReachabilityArea(origin, qtrue);
if ( newarea != area ) {
botimport.Print( PRT_MESSAGE, "origin = %f, %f, %f\n", origin[0], origin[1], origin[2] );
area = newarea;
botimport.Print( PRT_MESSAGE, "new area %d, cluster %d, presence type %d\n",
area, AAS_AreaCluster( area ), AAS_PointPresenceType( origin ) );
if ( ( *aasworld ).areasettings[area].areaflags & AREA_LIQUID ) {
botimport.Print( PRT_MESSAGE, "liquid area\n" );
} //end if
botimport.Print( PRT_MESSAGE, "area contents: " );
if ( ( *aasworld ).areasettings[area].contents & AREACONTENTS_WATER ) {
botimport.Print( PRT_MESSAGE, "water " );
} //end if
if ( ( *aasworld ).areasettings[area].contents & AREACONTENTS_LAVA ) {
botimport.Print( PRT_MESSAGE, "lava " );
} //end if
if ( ( *aasworld ).areasettings[area].contents & AREACONTENTS_SLIME ) {
// botimport.Print(PRT_MESSAGE, "slime ");
botimport.Print( PRT_MESSAGE, "slag " );
} //end if
if ( ( *aasworld ).areasettings[area].contents & AREACONTENTS_JUMPPAD ) {
botimport.Print( PRT_MESSAGE, "jump pad " );
} //end if
if ( ( *aasworld ).areasettings[area].contents & AREACONTENTS_CLUSTERPORTAL ) {
botimport.Print( PRT_MESSAGE, "cluster portal " );
} //end if
if ( ( *aasworld ).areasettings[area].contents & AREACONTENTS_DONOTENTER ) {
botimport.Print( PRT_MESSAGE, "do not enter " );
} //end if
if ( ( *aasworld ).areasettings[area].contents & AREACONTENTS_DONOTENTER_LARGE ) {
botimport.Print( PRT_MESSAGE, "do not enter large " );
} //end if
if ( !( *aasworld ).areasettings[area].contents ) {
botimport.Print( PRT_MESSAGE, "empty " );
} //end if
if ( ( *aasworld ).areasettings[area].areaflags & AREA_DISABLED ) {
botimport.Print( PRT_MESSAGE, "DISABLED" );
} //end if
botimport.Print( PRT_MESSAGE, "\n" );
botimport.Print( PRT_MESSAGE, "travel time to goal (%d) = %d\n", botlibglobals.goalareanum,
AAS_AreaTravelTimeToGoalArea( newarea, origin, botlibglobals.goalareanum, TFL_DEFAULT | TFL_ROCKETJUMP ) );
/*
VectorCopy(origin, end);
end[2] += 5;
numareas = AAS_TraceAreas(origin, end, areas, NULL, 10);
AAS_TraceClientBBox(origin, end, PRESENCE_CROUCH, -1);
botimport.Print(PRT_MESSAGE, "num areas = %d, area = %d\n", numareas, areas[0]);
*/
/*
botlibglobals.goalareanum = newarea;
VectorCopy(parm2, botlibglobals.goalorigin);
botimport.Print(PRT_MESSAGE, "new goal %2.1f %2.1f %2.1f area %d\n",
origin[0], origin[1], origin[2], newarea);
*/
} //end if
//*
if ( parm0 & 1 ) {
botlibglobals.goalareanum = newarea;
VectorCopy( parm2, botlibglobals.goalorigin );
botimport.Print( PRT_MESSAGE, "new goal %2.1f %2.1f %2.1f area %d\n",
origin[0], origin[1], origin[2], newarea );
} //end if*/
// if (parm0 & BUTTON_USE)
// {
// botlibglobals.runai = !botlibglobals.runai;
// if (botlibglobals.runai) botimport.Print(PRT_MESSAGE, "started AI\n");
// else botimport.Print(PRT_MESSAGE, "stopped AI\n");
//* /
/*
goal.areanum = botlibglobals.goalareanum;
reachnum = BotGetReachabilityToGoal(parm2, newarea, 1,
ms.avoidreach, ms.avoidreachtimes,
&goal, TFL_DEFAULT);
if (!reachnum)
{
botimport.Print(PRT_MESSAGE, "goal not reachable\n");
} //end if
else
{
AAS_ReachabilityFromNum(reachnum, &reach);
AAS_ClearShownDebugLines();
AAS_ShowArea(area, qtrue);
AAS_ShowArea(reach.areanum, qtrue);
AAS_DrawCross(reach.start, 6, LINECOLOR_BLUE);
AAS_DrawCross(reach.end, 6, LINECOLOR_RED);
//
if (reach.traveltype == TRAVEL_ELEVATOR)
{
ElevatorBottomCenter(&reach, bottomcenter);
AAS_DrawCross(bottomcenter, 10, LINECOLOR_GREEN);
} //end if
} //end else*/
// botimport.Print(PRT_MESSAGE, "travel time to goal = %d\n",
// AAS_AreaTravelTimeToGoalArea(area, origin, botlibglobals.goalareanum, TFL_DEFAULT));
// botimport.Print(PRT_MESSAGE, "test rj from 703 to 716\n");
// AAS_Reachability_WeaponJump(703, 716);
// } //end if*/
/* face = AAS_AreaGroundFace(newarea, parm2);
if (face)
{
AAS_ShowFace(face - (*aasworld).faces);
} //end if*/
/*
AAS_ClearShownDebugLines();
AAS_ShowArea(newarea, parm0 & BUTTON_USE);
AAS_ShowReachableAreas(area);
*/
AAS_ClearShownPolygons();
AAS_ClearShownDebugLines();
AAS_ShowAreaPolygons( newarea, 1, parm0 & 4 );
if ( parm0 & 2 ) {
AAS_ShowReachableAreas( area );
} else
{
static int lastgoalareanum, lastareanum;
static int avoidreach[MAX_AVOIDREACH];
static float avoidreachtimes[MAX_AVOIDREACH];
static int avoidreachtries[MAX_AVOIDREACH];
int reachnum;
bot_goal_t goal;
aas_reachability_t reach;
goal.areanum = botlibglobals.goalareanum;
VectorCopy( botlibglobals.goalorigin, goal.origin );
reachnum = BotGetReachabilityToGoal( origin, newarea, -1,
lastgoalareanum, lastareanum,
avoidreach, avoidreachtimes, avoidreachtries,
&goal, TFL_DEFAULT | TFL_FUNCBOB, TFL_DEFAULT | TFL_FUNCBOB );
AAS_ReachabilityFromNum( reachnum, &reach );
AAS_ShowReachability( &reach );
} //end else
VectorClear( forward );
//BotGapDistance(origin, forward, 0);
/*
if (parm0 & BUTTON_USE)
{
botimport.Print(PRT_MESSAGE, "test rj from 703 to 716\n");
AAS_Reachability_WeaponJump(703, 716);
} //end if*/
AngleVectors( parm3, forward, right, NULL );
//get the eye 16 units to the right of the origin
VectorMA( parm2, 8, right, eye );
//get the eye 24 units up
eye[2] += 24;
//get the end point for the line to be traced
VectorMA( eye, 800, forward, end );
// AAS_TestMovementPrediction(1, parm2, forward);
/* //trace the line to find the hit point
trace = AAS_TraceClientBBox(eye, end, PRESENCE_NORMAL, 1);
if (!line[0]) line[0] = botimport.DebugLineCreate();
botimport.DebugLineShow(line[0], eye, trace.endpos, LINECOLOR_BLUE);
//
AAS_ClearShownDebugLines();
if (trace.ent)
{
ent = &(*aasworld).entities[trace.ent];
AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs);
} //end if*/
/*
start_time = clock();
for (i = 0; i < 2000; i++)
{
AAS_Trace2(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
// AAS_TraceClientBBox(eye, end, PRESENCE_NORMAL, 1);
} //end for
end_time = clock();
botimport.Print(PRT_MESSAGE, "me %lu clocks, %lu CLOCKS_PER_SEC\n", end_time - start_time, CLOCKS_PER_SEC);
start_time = clock();
for (i = 0; i < 2000; i++)
{
AAS_Trace(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
} //end for
end_time = clock();
botimport.Print(PRT_MESSAGE, "id %lu clocks, %lu CLOCKS_PER_SEC\n", end_time - start_time, CLOCKS_PER_SEC);
*/
/*
AAS_ClearShownDebugLines();
//bsptrace = AAS_Trace(eye, NULL, NULL, end, 1, MASK_PLAYERSOLID);
bsptrace = AAS_Trace(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
if (!line[0]) line[0] = botimport.DebugLineCreate();
botimport.DebugLineShow(line[0], eye, bsptrace.endpos, LINECOLOR_YELLOW);
if (bsptrace.fraction < 1.0)
{
face = AAS_TraceEndFace(&trace);
if (face)
{
AAS_ShowFace(face - (*aasworld).faces);
} //end if
AAS_DrawPlaneCross(bsptrace.endpos,
bsptrace.plane.normal,
bsptrace.plane.dist + bsptrace.exp_dist,
bsptrace.plane.type, LINECOLOR_GREEN);
if (trace.ent)
{
ent = &(*aasworld).entities[trace.ent];
AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs);
} //end if
} //end if*/
/*/
//bsptrace = AAS_Trace2(eye, NULL, NULL, end, 1, MASK_PLAYERSOLID);
bsptrace = AAS_Trace2(eye, mins, maxs, end, 1, MASK_PLAYERSOLID);
botimport.DebugLineShow(line[1], eye, bsptrace.endpos, LINECOLOR_BLUE);
if (bsptrace.fraction < 1.0)
{
AAS_DrawPlaneCross(bsptrace.endpos,
bsptrace.plane.normal,
bsptrace.plane.dist,// + bsptrace.exp_dist,
bsptrace.plane.type, LINECOLOR_RED);
if (bsptrace.ent)
{
ent = &(*aasworld).entities[bsptrace.ent];
AAS_ShowBoundingBox(ent->origin, ent->mins, ent->maxs);
} //end if
} //end if
*/
#endif
#else
static int area = -1;
static int line[2];
int newarea, i, highlightarea, bot_testhidepos, hideposarea, bot_debug;
vec3_t forward, origin;
// vec3_t mins = {-16, -16, -24};
// vec3_t maxs = {16, 16, 32};
if ( !aasworld->loaded ) {
return 0;
}
AAS_SetCurrentWorld( 0 );
for ( i = 0; i < 2; i++ ) {
if ( !line[i] ) {
line[i] = botimport.DebugLineCreate();
}
}
// AAS_ClearShownDebugLines();
bot_testhidepos = LibVarGetValue( "bot_testhidepos" );
if ( bot_testhidepos ) {
VectorCopy( parm2, origin );
newarea = BotFuzzyPointReachabilityArea( origin );
if ( parm0 & 1 ) {
botlibglobals.goalareanum = newarea;
VectorCopy( origin, botlibglobals.goalorigin );
botimport.Print( PRT_MESSAGE, "new enemy position %2.1f %2.1f %2.1f area %d\n", origin[0], origin[1], origin[2], newarea );
} //end if
AAS_ClearShownPolygons();
AAS_ClearShownDebugLines();
hideposarea = AAS_NearestHideArea( 0, origin, AAS_PointAreaNum( origin ), 0,
botlibglobals.goalorigin, botlibglobals.goalareanum, TFL_DEFAULT, 99999, NULL );
//area we are currently in
AAS_ShowAreaPolygons( newarea, 1, qtrue );
//enemy position
AAS_ShowAreaPolygons( botlibglobals.goalareanum, 2, qtrue );
//area we should go hide
AAS_ShowAreaPolygons( hideposarea, 4, qtrue );
return 0;
}
highlightarea = LibVarGetValue( "bot_highlightarea" );
if ( highlightarea > 0 ) {
newarea = highlightarea;
} else {
VectorCopy( parm2, origin );
//origin[2] += 0.5;
newarea = BotFuzzyPointReachabilityArea( origin );
} //end else
bot_debug = LibVarGetValue( "bot_debug" );
if ( bot_debug == 9 ) {
aas_clientmove_t move;
vec3_t dest;
qboolean this_success;
if ( parm0 & 1 ) {
botlibglobals.goalareanum = newarea;
VectorCopy( parm2, botlibglobals.goalorigin );
botimport.Print( PRT_MESSAGE, "new goal %2.1f %2.1f %2.1f area %d\n", origin[0], origin[1], origin[2], newarea );
}
VectorCopy( parm2, origin );
VectorCopy( botlibglobals.goalorigin, dest );
// debug direct movement
VectorSubtract( dest, origin, forward );
VectorNormalize( forward );
VectorScale( forward, 300, forward );
this_success = AAS_PredictClientMovement( &move, 0, origin,
-1, qfalse,
forward, dest, -1,
40, 0.05, SE_ENTERAREA | SE_HITGROUNDDAMAGE | SE_HITENT | SE_HITGROUNDAREA | SE_STUCK | SE_GAP, botlibglobals.goalareanum,
qtrue );
if ( this_success ) {
switch ( move.stopevent ) {
case SE_ENTERAREA:
case SE_HITENT:
case SE_HITGROUNDAREA:
break;
default:
this_success = qfalse;
}
}
if ( this_success != botlibglobals.lastsuccess ) {
botimport.Print( PRT_MESSAGE, "DirectMove: %s\n", this_success ? "SUCCESS" : "FAILURE" );
botlibglobals.lastsuccess = this_success;
}
return 0;
}
botimport.Print( PRT_MESSAGE, "\rtravel time to goal (%d) = %d ", botlibglobals.goalareanum, AAS_AreaTravelTimeToGoalArea( newarea, origin, botlibglobals.goalareanum, TFL_DEFAULT ) );
if ( newarea != area ) {
botimport.Print( PRT_MESSAGE, "origin = %f, %f, %f\n", origin[0], origin[1], origin[2] );
area = newarea;
botimport.Print( PRT_MESSAGE, "new area %d, cluster %d, presence type %d\n", area, AAS_AreaCluster( area ), AAS_PointPresenceType( origin ) );
if ( aasworld->areasettings[area].areaflags & AREA_LIQUID ) {
botimport.Print( PRT_MESSAGE, "liquid area\n" );
} //end if
botimport.Print( PRT_MESSAGE, "area contents: " );
if ( aasworld->areasettings[area].contents & AREACONTENTS_MOVER ) {
botimport.Print( PRT_MESSAGE, "mover " );
} //end if
if ( aasworld->areasettings[area].contents & AREACONTENTS_WATER ) {
botimport.Print( PRT_MESSAGE, "water " );
} //end if
if ( aasworld->areasettings[area].contents & AREACONTENTS_LAVA ) {
botimport.Print( PRT_MESSAGE, "lava " );
} //end if
if ( aasworld->areasettings[area].contents & AREACONTENTS_SLIME ) {
botimport.Print( PRT_MESSAGE, "slag " );
} //end if
if ( aasworld->areasettings[area].contents & AREACONTENTS_JUMPPAD ) {
botimport.Print( PRT_MESSAGE, "jump pad " );
} //end if
if ( aasworld->areasettings[area].contents & AREACONTENTS_CLUSTERPORTAL ) {
botimport.Print( PRT_MESSAGE, "cluster portal " );
} //end if
if ( aasworld->areasettings[area].contents & AREACONTENTS_DONOTENTER ) {
botimport.Print( PRT_MESSAGE, "do not enter " );
} //end if
if ( aasworld->areasettings[area].contents & AREACONTENTS_DONOTENTER_LARGE ) {
botimport.Print( PRT_MESSAGE, "do not enter large " );
} //end if
if ( !aasworld->areasettings[area].contents ) {
botimport.Print( PRT_MESSAGE, "empty " );
} //end if
botimport.Print( PRT_MESSAGE, "\n" );
botimport.Print( PRT_MESSAGE, "area flags: " );
if ( aasworld->areasettings[area].areaflags & AREA_LADDER ) {
botimport.Print( PRT_MESSAGE, "ladder " );
}
if ( aasworld->areasettings[area].areaflags & AREA_GROUNDED ) {
botimport.Print( PRT_MESSAGE, "grounded " );
}
if ( aasworld->areasettings[area].areaflags & AREA_LIQUID ) {
botimport.Print( PRT_MESSAGE, "liquid " );
}
if ( aasworld->areasettings[area].areaflags & AREA_DISABLED ) {
botimport.Print( PRT_MESSAGE, "DISABLED " );
}
if ( aasworld->areasettings[area].areaflags & AREA_AVOID ) {
botimport.Print( PRT_MESSAGE, "AVOID " );
}
botimport.Print( PRT_MESSAGE, "\n" );
botimport.Print( PRT_MESSAGE, "travel time to goal (%d) = %d\n", botlibglobals.goalareanum, AAS_AreaTravelTimeToGoalArea( newarea, origin, botlibglobals.goalareanum, TFL_DEFAULT | TFL_ROCKETJUMP ) );
}
if ( parm0 & 1 ) {
botlibglobals.goalareanum = newarea;
VectorCopy( parm2, botlibglobals.goalorigin );
botimport.Print( PRT_MESSAGE, "new goal %2.1f %2.1f %2.1f area %d\n", origin[0], origin[1], origin[2], newarea );
}
AAS_ClearShownPolygons();
AAS_ClearShownDebugLines();
if ( parm0 & 8 ) {
int jk = 0;
if ( parm0 & 16 ) {
for ( ; jk < aasworld->numareas; jk++ ) {
if ( !( aasworld->areasettings[jk].areaflags & AREA_DISABLED ) ) {
AAS_ShowAreaPolygons( jk, 1, parm0 & 4 );
}
}
} else {
for ( ; jk < aasworld->numareas; jk++ ) {
AAS_ShowAreaPolygons( jk, 1, parm0 & 4 );
}
}
} else {
AAS_ShowAreaPolygons( newarea, 1, parm0 & 4 );
}
if ( parm0 & 2 ) {
AAS_ShowReachableAreas( area );
} else {
static int lastgoalareanum, lastareanum;
static int avoidreach[MAX_AVOIDREACH];
static float avoidreachtimes[MAX_AVOIDREACH];
static int avoidreachtries[MAX_AVOIDREACH];
int reachnum;
bot_goal_t goal;
aas_reachability_t reach;
static int lastreach;
goal.areanum = botlibglobals.goalareanum;
VectorCopy( botlibglobals.goalorigin, goal.origin );
reachnum = BotGetReachabilityToGoal( origin, newarea, -1,
lastgoalareanum, lastareanum,
avoidreach, avoidreachtimes, avoidreachtries,
&goal, TFL_DEFAULT | TFL_FUNCBOB, TFL_DEFAULT );
AAS_ReachabilityFromNum( reachnum, &reach );
if ( lastreach != reachnum ) {
botimport.Print( PRT_MESSAGE, "Travel Type: " );
AAS_PrintTravelType( reach.traveltype );
botimport.Print( PRT_MESSAGE, "\n" );
}
lastreach = reachnum;
AAS_ShowReachability( &reach );
} //end else
VectorClear( forward );
#endif // RTCW_XX
return 0;
} //end of the function BotExportTest
// predicts the movement
// assumes regular bounding box sizes
// NOTE: out of water jumping is not included
// NOTE: grappling hook is not included
// origin origin to start with
// presencetype presence type to start with
// velocity velocity to start with
// cmdmove client command movement
// cmdframes number of frame cmdmove is valid
// maxframes maximum number of predicted frames
// frametime duration of one predicted frame
// stopevent events that stop the prediction
// stopareanum stop as soon as entered this area
int AAS_ClientMovementPrediction(struct aas_clientmove_s *move,
int entnum, vector3 *origin,
int presencetype, int onground,
vector3 *velocity, vector3 *cmdmove,
int cmdframes,
int maxframes, float frametime,
int stopevent, int stopareanum,
vector3 *mins, vector3 *maxs, int visualize)
{
float phys_friction, phys_stopspeed, phys_gravity, phys_waterfriction;
float phys_watergravity;
float phys_walkaccelerate, phys_airaccelerate, phys_swimaccelerate;
float phys_maxwalkvelocity, phys_maxcrouchvelocity, phys_maxswimvelocity;
float phys_maxstep, phys_maxsteepness, phys_jumpvel, friction;
float gravity, delta, maxvel, wishspeed, accelerate;
//float velchange, newvel;
//int ax;
int n, i, j, pc, step, swimming, crouch, event, jump_frame, areanum;
int areas[20], numareas;
vector3 points[20];
vector3 org, end, feet, start, stepend, lastorg, wishdir;
vector3 frame_test_vel, old_frame_test_vel, left_test_vel;
vector3 up = {0, 0, 1};
aas_plane_t *plane, *plane2;
aas_trace_t trace, steptrace;
if (frametime <= 0) frametime = 0.1f;
//
phys_friction = aassettings.phys_friction;
phys_stopspeed = aassettings.phys_stopspeed;
phys_gravity = aassettings.phys_gravity;
phys_waterfriction = aassettings.phys_waterfriction;
phys_watergravity = aassettings.phys_watergravity;
phys_maxwalkvelocity = aassettings.phys_maxwalkvelocity;// * frametime;
phys_maxcrouchvelocity = aassettings.phys_maxcrouchvelocity;// * frametime;
phys_maxswimvelocity = aassettings.phys_maxswimvelocity;// * frametime;
phys_walkaccelerate = aassettings.phys_walkaccelerate;
phys_airaccelerate = aassettings.phys_airaccelerate;
phys_swimaccelerate = aassettings.phys_swimaccelerate;
phys_maxstep = aassettings.phys_maxstep;
phys_maxsteepness = aassettings.phys_maxsteepness;
phys_jumpvel = aassettings.phys_jumpvel * frametime;
//
memset(move, 0, sizeof(aas_clientmove_t));
memset(&trace, 0, sizeof(aas_trace_t));
//start at the current origin
VectorCopy(origin, &org);
org.z += 0.25f;
//velocity to test for the first frame
VectorScale(velocity, frametime, &frame_test_vel);
//
jump_frame = -1;
//predict a maximum of 'maxframes' ahead
for (n = 0; n < maxframes; n++)
{
swimming = AAS_Swimming(&org);
//get gravity depending on swimming or not
gravity = swimming ? phys_watergravity : phys_gravity;
//apply gravity at the START of the frame
frame_test_vel.z = frame_test_vel.z - (gravity * 0.1f * frametime);
//if on the ground or swimming
if (onground || swimming)
{
friction = swimming ? phys_friction : phys_waterfriction;
//apply friction
VectorScale(&frame_test_vel, 1/frametime, &frame_test_vel);
AAS_ApplyFriction(&frame_test_vel, friction, phys_stopspeed, frametime);
VectorScale(&frame_test_vel, frametime, &frame_test_vel);
}
crouch = qfalse;
//apply command movement
if (n < cmdframes)
{
//ax = 0;
maxvel = phys_maxwalkvelocity;
accelerate = phys_airaccelerate;
VectorCopy(cmdmove, &wishdir);
if (onground)
{
if (cmdmove->z < -300)
{
crouch = qtrue;
maxvel = phys_maxcrouchvelocity;
}
//if not swimming and upmove is positive then jump
if (!swimming && cmdmove->z > 1)
{
//jump velocity minus the gravity for one frame + 5 for safety
frame_test_vel.z = phys_jumpvel - (gravity * 0.1f * frametime) + 5;
jump_frame = n;
//jumping so air accelerate
accelerate = phys_airaccelerate;
}
else
{
accelerate = phys_walkaccelerate;
}
//ax = 2;
}
if (swimming)
{
maxvel = phys_maxswimvelocity;
accelerate = phys_swimaccelerate;
//ax = 3;
}
else
{
wishdir.z = 0;
}
//
wishspeed = VectorNormalize(&wishdir);
if (wishspeed > maxvel) wishspeed = maxvel;
VectorScale(&frame_test_vel, 1/frametime, &frame_test_vel);
AAS_Accelerate(&frame_test_vel, frametime, &wishdir, wishspeed, accelerate);
VectorScale(&frame_test_vel, frametime, &frame_test_vel);
/*
for (i = 0; i < ax; i++)
{
velchange = (cmdmove[i] * frametime) - frame_test_vel[i];
if (velchange > phys_maxacceleration) velchange = phys_maxacceleration;
else if (velchange < -phys_maxacceleration) velchange = -phys_maxacceleration;
newvel = frame_test_vel[i] + velchange;
//
if (frame_test_vel[i] <= maxvel && newvel > maxvel) frame_test_vel[i] = maxvel;
else if (frame_test_vel[i] >= -maxvel && newvel < -maxvel) frame_test_vel[i] = -maxvel;
else frame_test_vel[i] = newvel;
}
*/
}
if (crouch)
{
presencetype = PRESENCE_CROUCH;
}
else if (presencetype == PRESENCE_CROUCH)
{
if (AAS_PointPresenceType(&org) & PRESENCE_NORMAL)
{
presencetype = PRESENCE_NORMAL;
}
}
//save the current origin
VectorCopy(&org, &lastorg);
//move linear during one frame
VectorCopy(&frame_test_vel, &left_test_vel);
j = 0;
do
{
VectorAdd(&org, &left_test_vel, &end);
//trace a bounding box
trace = AAS_TraceClientBBox(&org, &end, presencetype, entnum);
//
//#ifdef AAS_MOVE_DEBUG
if (visualize)
{
if (trace.startsolid) botimport.Print(PRT_MESSAGE, "PredictMovement: start solid\n");
AAS_DebugLine(&org, &trace.endpos, LINECOLOR_RED);
}
//#endif //AAS_MOVE_DEBUG
//
if (stopevent & (SE_ENTERAREA|SE_TOUCHJUMPPAD|SE_TOUCHTELEPORTER|SE_TOUCHCLUSTERPORTAL))
{
numareas = AAS_TraceAreas(&org, &trace.endpos, areas, points, 20);
for (i = 0; i < numareas; i++)
{
if (stopevent & SE_ENTERAREA)
{
if (areas[i] == stopareanum)
{
VectorCopy(&points[i], &move->endpos);
VectorScale(&frame_test_vel, 1.0f/frametime, &move->velocity);
move->endarea = areas[i];
move->trace = trace;
move->stopevent = SE_ENTERAREA;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
//NOTE: if not the first frame
if ((stopevent & SE_TOUCHJUMPPAD) && n)
{
if (aasworld.areasettings[areas[i]].contents & AREACONTENTS_JUMPPAD)
{
VectorCopy(&points[i], &move->endpos);
VectorScale(&frame_test_vel, 1.0f/frametime, &move->velocity);
move->endarea = areas[i];
move->trace = trace;
move->stopevent = SE_TOUCHJUMPPAD;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
if (stopevent & SE_TOUCHTELEPORTER)
{
if (aasworld.areasettings[areas[i]].contents & AREACONTENTS_TELEPORTER)
{
VectorCopy(&points[i], &move->endpos);
move->endarea = areas[i];
VectorScale(&frame_test_vel, 1.0f/frametime, &move->velocity);
move->trace = trace;
move->stopevent = SE_TOUCHTELEPORTER;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
if (stopevent & SE_TOUCHCLUSTERPORTAL)
{
if (aasworld.areasettings[areas[i]].contents & AREACONTENTS_CLUSTERPORTAL)
{
VectorCopy(&points[i], &move->endpos);
move->endarea = areas[i];
VectorScale(&frame_test_vel, 1.0f/frametime, &move->velocity);
move->trace = trace;
move->stopevent = SE_TOUCHCLUSTERPORTAL;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
}
}
//
if (stopevent & SE_HITBOUNDINGBOX)
{
if (AAS_ClipToBBox(&trace, &org, &trace.endpos, presencetype, mins, maxs))
{
VectorCopy(&trace.endpos, &move->endpos);
move->endarea = AAS_PointAreaNum(&move->endpos);
VectorScale(&frame_test_vel, 1.0f/frametime, &move->velocity);
move->trace = trace;
move->stopevent = SE_HITBOUNDINGBOX;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
//move the entity to the trace end point
VectorCopy(&trace.endpos, &org);
//if there was a collision
if (trace.fraction < 1.0f)
{
//get the plane the bounding box collided with
plane = AAS_PlaneFromNum(trace.planenum);
//
if (stopevent & SE_HITGROUNDAREA)
{
if (DotProduct(&plane->normal, &up) > phys_maxsteepness)
{
VectorCopy(&org, &start);
start.z += 0.5f;
if (AAS_PointAreaNum(&start) == stopareanum)
{
VectorCopy(&start, &move->endpos);
move->endarea = stopareanum;
VectorScale(&frame_test_vel, 1.0f/frametime, &move->velocity);
move->trace = trace;
move->stopevent = SE_HITGROUNDAREA;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
}
//assume there's no step
step = qfalse;
//if it is a vertical plane and the bot didn't jump recently
if (plane->normal.z == 0 && (jump_frame < 0 || n - jump_frame > 2))
{
//check for a step
VectorMA(&org, -0.25f, &plane->normal, &start);
VectorCopy(&start, &stepend);
start.z += phys_maxstep;
steptrace = AAS_TraceClientBBox(&start, &stepend, presencetype, entnum);
//
if (!steptrace.startsolid)
{
plane2 = AAS_PlaneFromNum(steptrace.planenum);
if (DotProduct(&plane2->normal, &up) > phys_maxsteepness)
{
VectorSubtract(&end, &steptrace.endpos, &left_test_vel);
left_test_vel.z = 0;
frame_test_vel.z = 0;
//#ifdef AAS_MOVE_DEBUG
if (visualize)
{
if (steptrace.endpos.z - org.z > 0.125f)
{
VectorCopy(&org, &start);
start.z = steptrace.endpos.z;
AAS_DebugLine(&org, &start, LINECOLOR_BLUE);
}
}
//#endif //AAS_MOVE_DEBUG
org.z = steptrace.endpos.z;
step = qtrue;
}
}
}
//
if (!step)
{
//velocity left to test for this frame is the projection
//of the current test velocity into the hit plane
VectorMA(&left_test_vel, -DotProduct(&left_test_vel, &plane->normal), &plane->normal, &left_test_vel);
//store the old velocity for landing check
VectorCopy(&frame_test_vel, &old_frame_test_vel);
//test velocity for the next frame is the projection
//of the velocity of the current frame into the hit plane
VectorMA(&frame_test_vel, -DotProduct(&frame_test_vel, &plane->normal), &plane->normal, &frame_test_vel);
//check for a landing on an almost horizontal floor
if (DotProduct(&plane->normal, &up) > phys_maxsteepness)
{
onground = qtrue;
}
if (stopevent & SE_HITGROUNDDAMAGE)
{
delta = 0;
if (old_frame_test_vel.z < 0 &&
frame_test_vel.z > old_frame_test_vel.z &&
!onground)
{
delta = old_frame_test_vel.z;
}
else if (onground)
{
delta = frame_test_vel.z - old_frame_test_vel.z;
}
if (delta)
{
delta = delta * 10;
delta = delta * delta * 0.0001f;
if (swimming) delta = 0;
// never take falling damage if completely underwater
/*
if (ent->waterlevel == 3) return;
if (ent->waterlevel == 2) delta *= 0.25f;
if (ent->waterlevel == 1) delta *= 0.5f;
*/
if (delta > 40)
{
VectorCopy(&org, &move->endpos);
move->endarea = AAS_PointAreaNum(&org);
VectorCopy(&frame_test_vel, &move->velocity);
move->trace = trace;
move->stopevent = SE_HITGROUNDDAMAGE;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
}
}
}
//extra check to prevent endless loop
if (++j > 20) return qfalse;
//while there is a plane hit
} while(trace.fraction < 1.0f);
//if going down
if (frame_test_vel.z <= 10)
{
//check for a liquid at the feet of the bot
VectorCopy(&org, &feet);
feet.z -= 22;
pc = AAS_PointContents(&feet);
//get event from pc
event = SE_NONE;
if (pc & CONTENTS_LAVA) event |= SE_ENTERLAVA;
if (pc & CONTENTS_SLIME) event |= SE_ENTERSLIME;
if (pc & CONTENTS_WATER) event |= SE_ENTERWATER;
//
areanum = AAS_PointAreaNum(&org);
if (aasworld.areasettings[areanum].contents & AREACONTENTS_LAVA)
event |= SE_ENTERLAVA;
if (aasworld.areasettings[areanum].contents & AREACONTENTS_SLIME)
event |= SE_ENTERSLIME;
if (aasworld.areasettings[areanum].contents & AREACONTENTS_WATER)
event |= SE_ENTERWATER;
//if in lava or slime
if (event & stopevent)
{
VectorCopy(&org, &move->endpos);
move->endarea = areanum;
VectorScale(&frame_test_vel, 1.0f/frametime, &move->velocity);
move->stopevent = event & stopevent;
move->presencetype = presencetype;
move->endcontents = pc;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
//
onground = AAS_OnGround(&org, presencetype, entnum);
//if onground and on the ground for at least one whole frame
if (onground)
{
if (stopevent & SE_HITGROUND)
{
VectorCopy(&org, &move->endpos);
move->endarea = AAS_PointAreaNum(&org);
VectorScale(&frame_test_vel, 1.0f/frametime, &move->velocity);
move->trace = trace;
move->stopevent = SE_HITGROUND;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
else if (stopevent & SE_LEAVEGROUND)
{
VectorCopy(&org, &move->endpos);
move->endarea = AAS_PointAreaNum(&org);
VectorScale(&frame_test_vel, 1/frametime, &move->velocity);
move->trace = trace;
move->stopevent = SE_LEAVEGROUND;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
else if (stopevent & SE_GAP)
{
aas_trace_t gaptrace;
VectorCopy(&org, &start);
VectorCopy(&start, &end);
end.z -= 48 + aassettings.phys_maxbarrier;
gaptrace = AAS_TraceClientBBox(&start, &end, PRESENCE_CROUCH, -1);
//if solid is found the bot cannot walk any further and will not fall into a gap
if (!gaptrace.startsolid)
{
//if it is a gap (lower than one step height)
if (gaptrace.endpos.z < org.z - aassettings.phys_maxstep - 1)
{
if (!(AAS_PointContents(&end) & CONTENTS_WATER))
{
VectorCopy(&lastorg, &move->endpos);
move->endarea = AAS_PointAreaNum(&lastorg);
VectorScale(&frame_test_vel, 1.0f/frametime, &move->velocity);
move->trace = trace;
move->stopevent = SE_GAP;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
return qtrue;
}
}
}
}
}
//
VectorCopy(&org, &move->endpos);
move->endarea = AAS_PointAreaNum(&org);
VectorScale(&frame_test_vel, 1.0f/frametime, &move->velocity);
move->stopevent = SE_NONE;
move->presencetype = presencetype;
move->endcontents = 0;
move->time = n * frametime;
move->frames = n;
//
return qtrue;
}
int Export_BotLibSetup( void ) {
#else
int Export_BotLibSetup( qboolean singleplayer ) {
#endif // RTCW_XX
int errnum;
bot_developer = LibVarGetValue( "bot_developer" );
//BBi
////initialize byte swapping (litte endian etc.)
//Swap_Init();
//BBi
Log_Open( "botlib.log" );
//
botimport.Print( PRT_MESSAGE, "------- BotLib Initialization -------\n" );
//
botlibglobals.maxclients = (int) LibVarValue( "maxclients", "128" );
#if defined RTCW_SP
botlibglobals.maxentities = (int) LibVarValue( "maxentities", "2048" );
#else
botlibglobals.maxentities = (int) LibVarValue( "maxentities", "1024" );
#endif // RTCW_XX
errnum = AAS_Setup(); //be_aas_main.c
if ( errnum != BLERR_NOERROR ) {
return errnum;
}
errnum = EA_Setup(); //be_ea.c
if ( errnum != BLERR_NOERROR ) {
return errnum;
}
#if !defined RTCW_ET
// errnum = BotSetupWeaponAI(); //be_ai_weap.c
// if (errnum != BLERR_NOERROR)return errnum;
// errnum = BotSetupGoalAI(); //be_ai_goal.c
// if (errnum != BLERR_NOERROR) return errnum;
// errnum = BotSetupChatAI(); //be_ai_chat.c
// if (errnum != BLERR_NOERROR) return errnum;
#else
errnum = BotSetupWeaponAI(); //be_ai_weap.c
if ( errnum != BLERR_NOERROR ) {
return errnum;
}
// START Arnout changes, 28-08-2002.
// added single player
errnum = BotSetupGoalAI( singleplayer ); //be_ai_goal.c
// END Arnout changes, 28-08-2002.
if ( errnum != BLERR_NOERROR ) {
return errnum;
}
errnum = BotSetupChatAI(); //be_ai_chat.c
if ( errnum != BLERR_NOERROR ) {
return errnum;
}
#endif // RTCW_XX
#if defined RTCW_MP
// errnum = BotSetupMoveAI(); //be_ai_move.c
// if (errnum != BLERR_NOERROR) return errnum;
#endif // RTCW_XX
#if !defined RTCW_MP
errnum = BotSetupMoveAI(); //be_ai_move.c
if ( errnum != BLERR_NOERROR ) {
return errnum;
}
#endif // RTCW_XX
#if defined RTCW_ET
globaldefines = NULL;
#endif // RTCW_XX
botlibsetup = qtrue;
botlibglobals.botlibsetup = qtrue;
return BLERR_NOERROR;
} //end of the function Export_BotLibSetup
void AAS_RemoveNotClusterClosingPortals(void)
{
int i, j, facenum, otherareanum, nonclosingportals, numseperatedclusters;
aas_area_t *area;
aas_face_t *face;
AAS_RemoveTeleporterPortals();
//
nonclosingportals = 0;
for (i = 1; i < aasworld.numareas; i++)
{
if (!(aasworld.areasettings[i].contents & AREACONTENTS_CLUSTERPORTAL)) continue;
//
numseperatedclusters = 0;
//reset all cluster fields
AAS_RemoveClusterAreas();
//find a non-portal area adjacent to the portal area and flood
//the cluster from there
area = &aasworld.areas[i];
for (j = 0; j < area->numfaces; j++)
{
facenum = abs(aasworld.faceindex[area->firstface + j]);
face = &aasworld.faces[facenum];
//
if (face->frontarea != i) otherareanum = face->frontarea;
else otherareanum = face->backarea;
//if not solid at the other side of the face
if (!otherareanum) continue;
//don't flood into other portals
if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL) continue;
//if the area already has a cluster set
if (aasworld.areasettings[otherareanum].cluster) continue;
//another cluster is seperated by this portal
numseperatedclusters++;
//flood the cluster
AAS_FloodCluster_r(otherareanum, numseperatedclusters);
AAS_FloodClusterReachabilities(numseperatedclusters);
} //end for
//use the reachabilities to flood into other areas
for (j = 0; j < aasworld.areasettings[i].numreachableareas; j++)
{
otherareanum = aasworld.reachability[
aasworld.areasettings[i].firstreachablearea + j].areanum;
//this should never be qtrue but we check anyway
if (!otherareanum) continue;
//don't flood into other portals
if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL) continue;
//if the area already has a cluster set
if (aasworld.areasettings[otherareanum].cluster) continue;
//another cluster is seperated by this portal
numseperatedclusters++;
//flood the cluster
AAS_FloodCluster_r(otherareanum, numseperatedclusters);
AAS_FloodClusterReachabilities(numseperatedclusters);
} //end for
//a portal must seperate no more and no less than 2 clusters
if (numseperatedclusters != 2)
{
aasworld.areasettings[i].contents &= ~AREACONTENTS_CLUSTERPORTAL;
nonclosingportals++;
//recheck all the other portals again
i = 0;
} //end if
} //end for
botimport.Print(PRT_MESSAGE, "\r%6d non closing portals removed\n", nonclosingportals);
} //end of the function AAS_RemoveNotClusterClosingPortals
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
void AAS_InitClustering(void)
{
int i, removedPortalAreas;
int n, total, numreachabilityareas;
if (!aasworld.loaded) return;
//if there are clusters
if (aasworld.numclusters >= 1)
{
#ifndef BSPC
//if clustering isn't forced
if (!((int)LibVarGetValue("forceclustering")) &&
!((int)LibVarGetValue("forcereachability"))) return;
#endif
} //end if
//set all view portals as cluster portals in case we re-calculate the reachabilities and clusters (with -reach)
AAS_SetViewPortalsAsClusterPortals();
//count the number of forced cluster portals
AAS_CountForcedClusterPortals();
//remove all area cluster marks
AAS_RemoveClusterAreas();
//find possible cluster portals
AAS_FindPossiblePortals();
//craete portals to for the bot view
AAS_CreateViewPortals();
//remove all portals that are not closing a cluster
//AAS_RemoveNotClusterClosingPortals();
//initialize portal memory
if (aasworld.portals) FreeMemory(aasworld.portals);
aasworld.portals = (aas_portal_t *) GetClearedMemory(AAS_MAX_PORTALS * sizeof(aas_portal_t));
//initialize portal index memory
if (aasworld.portalindex) FreeMemory(aasworld.portalindex);
aasworld.portalindex = (aas_portalindex_t *) GetClearedMemory(AAS_MAX_PORTALINDEXSIZE * sizeof(aas_portalindex_t));
//initialize cluster memory
if (aasworld.clusters) FreeMemory(aasworld.clusters);
aasworld.clusters = (aas_cluster_t *) GetClearedMemory(AAS_MAX_CLUSTERS * sizeof(aas_cluster_t));
//
removedPortalAreas = 0;
botimport.Print(PRT_MESSAGE, "\r%6d removed portal areas", removedPortalAreas);
while(1)
{
botimport.Print(PRT_MESSAGE, "\r%6d", removedPortalAreas);
//initialize the number of portals and clusters
aasworld.numportals = 1; //portal 0 is a dummy
aasworld.portalindexsize = 0;
aasworld.numclusters = 1; //cluster 0 is a dummy
//create the portals from the portal areas
AAS_CreatePortals();
//
removedPortalAreas++;
//find the clusters
if (!AAS_FindClusters())
continue;
//test the portals
if (!AAS_TestPortals())
continue;
//
break;
} //end while
botimport.Print(PRT_MESSAGE, "\n");
//the AAS file should be saved
aasworld.savefile = qtrue;
//write the portal areas to the log file
for (i = 1; i < aasworld.numportals; i++)
{
Log_Write("portal %d: area %d\r\n", i, aasworld.portals[i].areanum);
} //end for
// report cluster info
botimport.Print(PRT_MESSAGE, "%6d portals created\n", aasworld.numportals);
botimport.Print(PRT_MESSAGE, "%6d clusters created\n", aasworld.numclusters);
for (i = 1; i < aasworld.numclusters; i++)
{
botimport.Print(PRT_MESSAGE, "cluster %d has %d reachability areas\n", i,
aasworld.clusters[i].numreachabilityareas);
} //end for
// report AAS file efficiency
numreachabilityareas = 0;
total = 0;
for (i = 0; i < aasworld.numclusters; i++) {
n = aasworld.clusters[i].numreachabilityareas;
numreachabilityareas += n;
total += n * n;
}
total += numreachabilityareas * aasworld.numportals;
//
botimport.Print(PRT_MESSAGE, "%6i total reachability areas\n", numreachabilityareas);
botimport.Print(PRT_MESSAGE, "%6i AAS memory/CPU usage (the lower the better)\n", total * 3);
} //end of the function AAS_InitClustering
void botlib_stub( void ) {
botimport.Print( PRT_WARNING, "WARNING: botlib stub!\n" );
}
void AAS_AddTeleporterPortals(void)
{
int j, area2num, facenum, otherareanum;
char *target, *targetname, *classname;
bsp_entity_t *entities, *ent, *dest;
vec3_t origin, destorigin, mins, maxs, end;
vec3_t bbmins, bbmaxs;
aas_area_t *area;
aas_face_t *face;
aas_trace_t trace;
aas_link_t *areas, *link;
entities = AAS_ParseBSPEntities();
for (ent = entities; ent; ent = ent->next)
{
classname = AAS_ValueForBSPEpairKey(ent, "classname");
if (classname && !strcmp(classname, "misc_teleporter"))
{
if (!AAS_VectorForBSPEpairKey(ent, "origin", origin))
{
botimport.Print(PRT_ERROR, "teleporter (%s) without origin\n", target);
continue;
} //end if
//
target = AAS_ValueForBSPEpairKey(ent, "target");
if (!target)
{
botimport.Print(PRT_ERROR, "teleporter (%s) without target\n", target);
continue;
} //end if
for (dest = entities; dest; dest = dest->next)
{
classname = AAS_ValueForBSPEpairKey(dest, "classname");
if (classname && !strcmp(classname, "misc_teleporter_dest"))
{
targetname = AAS_ValueForBSPEpairKey(dest, "targetname");
if (targetname && !strcmp(targetname, target))
{
break;
} //end if
} //end if
} //end for
if (!dest)
{
botimport.Print(PRT_ERROR, "teleporter without destination (%s)\n", target);
continue;
} //end if
if (!AAS_VectorForBSPEpairKey(dest, "origin", destorigin))
{
botimport.Print(PRT_ERROR, "teleporter destination (%s) without origin\n", target);
continue;
} //end if
destorigin[2] += 24; //just for q2e1m2, the dork has put the telepads in the ground
VectorCopy(destorigin, end);
end[2] -= 100;
trace = AAS_TraceClientBBox(destorigin, end, PRESENCE_CROUCH, -1);
if (trace.startsolid)
{
botimport.Print(PRT_ERROR, "teleporter destination (%s) in solid\n", target);
continue;
} //end if
VectorCopy(trace.endpos, destorigin);
area2num = AAS_PointAreaNum(destorigin);
//reset all cluster fields
for (j = 0; j < aasworld.numareas; j++)
{
aasworld.areasettings[j].cluster = 0;
} //end for
//
VectorSet(mins, -8, -8, 8);
VectorSet(maxs, 8, 8, 24);
//
AAS_PresenceTypeBoundingBox(PRESENCE_CROUCH, bbmins, bbmaxs);
//
VectorAdd(origin, mins, mins);
VectorAdd(origin, maxs, maxs);
//add bounding box size
VectorSubtract(mins, bbmaxs, mins);
VectorSubtract(maxs, bbmins, maxs);
//link an invalid (-1) entity
areas = AAS_AASLinkEntity(mins, maxs, -1);
//
for (link = areas; link; link = link->next_area)
{
if (!AAS_AreaGrounded(link->areanum)) continue;
//add the teleporter portal mark
aasworld.areasettings[link->areanum].contents |= AREACONTENTS_CLUSTERPORTAL |
AREACONTENTS_TELEPORTAL;
} //end for
//
for (link = areas; link; link = link->next_area)
{
if (!AAS_AreaGrounded(link->areanum)) continue;
//find a non-portal area adjacent to the portal area and flood
//the cluster from there
area = &aasworld.areas[link->areanum];
for (j = 0; j < area->numfaces; j++)
{
facenum = abs(aasworld.faceindex[area->firstface + j]);
face = &aasworld.faces[facenum];
//
if (face->frontarea != link->areanum) otherareanum = face->frontarea;
else otherareanum = face->backarea;
//
if (!otherareanum) continue;
//
if (aasworld.areasettings[otherareanum].contents & AREACONTENTS_CLUSTERPORTAL)
{
continue;
} //end if
//
AAS_FloodCluster_r(otherareanum, 1);
} //end for
} //end for
//if the teleport destination IS in the same cluster
if (aasworld.areasettings[area2num].cluster)
{
for (link = areas; link; link = link->next_area)
{
if (!AAS_AreaGrounded(link->areanum)) continue;
//add the teleporter portal mark
aasworld.areasettings[link->areanum].contents &= ~(AREACONTENTS_CLUSTERPORTAL |
AREACONTENTS_TELEPORTAL);
} //end for
} //end if
} //end if
} //end for
AAS_FreeBSPEntities(entities);
} //end of the function AAS_AddTeleporterPortals