mirror of
https://github.com/UberGames/RPG-X2.git
synced 2024-11-22 12:32:13 +00:00
2858 lines
81 KiB
C
2858 lines
81 KiB
C
// Copyright (C) 1999-2000 Id Software, Inc.
|
|
//
|
|
/*****************************************************************************
|
|
* name: ai_dmq3.c
|
|
*
|
|
* desc: Quake3 bot AI
|
|
*
|
|
* $Archive: /StarTrek/Code-DM/game/ai_dmq3.c $
|
|
* $Author: Mgummelt $
|
|
* $Revision: 33 $
|
|
* $Modtime: 4/04/01 5:01p $
|
|
* $Date: 4/04/01 5:17p $
|
|
*
|
|
*****************************************************************************/
|
|
|
|
|
|
#include "g_local.h"
|
|
#include "botlib.h"
|
|
#include "be_aas.h"
|
|
#include "be_ea.h"
|
|
#include "be_ai_char.h"
|
|
#include "be_ai_chat.h"
|
|
#include "be_ai_gen.h"
|
|
#include "be_ai_goal.h"
|
|
#include "be_ai_move.h"
|
|
#include "be_ai_weap.h"
|
|
//
|
|
#include "ai_main.h"
|
|
#include "ai_dmq3.h"
|
|
#include "ai_chat.h"
|
|
#include "ai_cmd.h"
|
|
#include "ai_dmnet.h"
|
|
#include "ai_team.h"
|
|
//
|
|
#include "chars.h" //characteristics
|
|
#include "inv.h" //indexes into the inventory
|
|
#include "syn.h" //synonyms
|
|
#include "match.h" //string matching types and vars
|
|
|
|
#define IDEAL_ATTACKDIST 140
|
|
#define WEAPONINDEX_PHASER 2
|
|
|
|
#define MAX_WAYPOINTS 128
|
|
//
|
|
bot_waypoint_t botai_waypoints[MAX_WAYPOINTS];
|
|
bot_waypoint_t *botai_freewaypoints;
|
|
|
|
//NOTE: not using a cvars which can be updated because the game should be reloaded anyway
|
|
int gametype; //game type
|
|
int maxclients; //maximum number of clients
|
|
|
|
vmCvar_t bot_grapple;
|
|
vmCvar_t bot_rocketjump;
|
|
vmCvar_t bot_fastchat;
|
|
vmCvar_t bot_nochat;
|
|
vmCvar_t bot_testrchat;
|
|
vmCvar_t bot_challenge;
|
|
|
|
vec3_t lastteleport_origin; //last teleport event origin
|
|
float lastteleport_time; //last teleport event time
|
|
int max_bspmodelindex; //maximum BSP model index
|
|
|
|
//CTF flag goals
|
|
bot_goal_t ctf_redflag;
|
|
bot_goal_t ctf_blueflag;
|
|
|
|
#ifdef CTF
|
|
/*
|
|
==================
|
|
BotCTFCarryingFlag
|
|
==================
|
|
*/
|
|
int BotCTFCarryingFlag(bot_state_t *bs) {
|
|
if (gametype != GT_CTF) return CTF_FLAG_NONE;
|
|
|
|
if (bs->inventory[INVENTORY_REDFLAG] > 0) return CTF_FLAG_RED;
|
|
else if (bs->inventory[INVENTORY_BLUEFLAG] > 0) return CTF_FLAG_BLUE;
|
|
return CTF_FLAG_NONE;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotCTFTeam
|
|
==================
|
|
*/
|
|
int BotCTFTeam(bot_state_t *bs) {
|
|
char info[1024];
|
|
|
|
if (gametype != GT_CTF) return CTF_TEAM_NONE;
|
|
if (bs->client < 0 || bs->client >= MAX_CLIENTS) {
|
|
//BotAI_Print(PRT_ERROR, "BotCTFTeam: client out of range\n");
|
|
return qfalse;
|
|
}
|
|
trap_GetConfigstring(CS_PLAYERS+bs->client, info, sizeof(info));
|
|
//
|
|
if (atoi(Info_ValueForKey(info, "t")) == TEAM_RED) return CTF_TEAM_RED;
|
|
else if (atoi(Info_ValueForKey(info, "t")) == TEAM_BLUE) return CTF_TEAM_BLUE;
|
|
return CTF_TEAM_NONE;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotCTFRetreatGoals
|
|
==================
|
|
*/
|
|
void BotCTFRetreatGoals(bot_state_t *bs) {
|
|
//when carrying a flag in ctf the bot should rush to the base
|
|
if (BotCTFCarryingFlag(bs)) {
|
|
//if not already rushing to the base
|
|
if (bs->ltgtype != LTG_RUSHBASE) {
|
|
bs->ltgtype = LTG_RUSHBASE;
|
|
bs->teamgoal_time = trap_AAS_Time() + CTF_RUSHBASE_TIME;
|
|
bs->rushbaseaway_time = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
EntityIsDead
|
|
==================
|
|
*/
|
|
qboolean EntityIsDead(aas_entityinfo_t *entinfo) {
|
|
playerState_t ps;
|
|
|
|
if (entinfo->number >= 0 && entinfo->number < MAX_CLIENTS) {
|
|
//retrieve the current client state
|
|
BotAI_GetClientState( entinfo->number, &ps );
|
|
if (ps.pm_type != PM_NORMAL) return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
EntityIsInvisible
|
|
==================
|
|
*/
|
|
qboolean EntityIsInvisible(aas_entityinfo_t *entinfo) {
|
|
if (entinfo->powerups & (1 << PW_GHOST))
|
|
{ // 50% chance of being visible?
|
|
if (((unsigned int)(level.time)/1024)&0x01) // Every second or so, the bot will see the player, so he doesn't jitter.
|
|
{
|
|
return qtrue;
|
|
}
|
|
else
|
|
{
|
|
return qfalse;
|
|
}
|
|
}
|
|
else if (entinfo->powerups & (1 << PW_INVIS))
|
|
{
|
|
return qtrue;
|
|
}
|
|
else if ( entinfo->flags & EF_NODRAW )
|
|
{
|
|
return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
EntityCarriesFlag
|
|
==================
|
|
*/
|
|
qboolean EntityCarriesFlag(aas_entityinfo_t *entinfo) {
|
|
/*if ( entinfo->powerups & ( 1 << PW_REDFLAG ) ) return qtrue;*/
|
|
//if ( entinfo->powerups & ( 1 << PW_BORG_ADAPT ) ) return qtrue;
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
EntityIsShooting
|
|
==================
|
|
*/
|
|
qboolean EntityIsShooting(aas_entityinfo_t *entinfo) {
|
|
if (entinfo->flags & EF_FIRING) {
|
|
return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
EntityIsChatting
|
|
==================
|
|
*/
|
|
qboolean EntityIsChatting(aas_entityinfo_t *entinfo) {
|
|
if (entinfo->flags & EF_TALK) {
|
|
return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
EntityHasQuad
|
|
==================
|
|
*/
|
|
qboolean EntityHasQuad(aas_entityinfo_t *entinfo) {
|
|
if (entinfo->powerups & (1 << PW_QUAD)) {
|
|
return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotCTFSeekGoals
|
|
==================
|
|
*/
|
|
void BotCTFSeekGoals(bot_state_t *bs) {
|
|
float rnd;
|
|
int flagstatus, c;
|
|
|
|
//when carrying a flag in ctf the bot should rush to the base
|
|
if (BotCTFCarryingFlag(bs)) {
|
|
//if not already rushing to the base
|
|
if (bs->ltgtype != LTG_RUSHBASE) {
|
|
bs->ltgtype = LTG_RUSHBASE;
|
|
bs->teamgoal_time = trap_AAS_Time() + CTF_RUSHBASE_TIME;
|
|
bs->rushbaseaway_time = 0;
|
|
}
|
|
else if (bs->rushbaseaway_time > trap_AAS_Time()) {
|
|
if (BotCTFTeam(bs) == CTF_TEAM_RED) flagstatus = bs->redflagstatus;
|
|
else flagstatus = bs->blueflagstatus;
|
|
//if the flag is back
|
|
if (flagstatus == 0) {
|
|
bs->rushbaseaway_time = 0;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
//
|
|
if (BotCTFTeam(bs) == CTF_TEAM_RED) flagstatus = bs->redflagstatus * 2 + bs->blueflagstatus;
|
|
else flagstatus = bs->blueflagstatus * 2 + bs->redflagstatus;
|
|
//if the enemy flag is not at it's base
|
|
if (flagstatus == 1) {
|
|
//if Not defending the base
|
|
if (!(bs->ltgtype == LTG_DEFENDKEYAREA &&
|
|
(bs->teamgoal.number == ctf_redflag.number ||
|
|
bs->teamgoal.number == ctf_blueflag.number))) {
|
|
//if not already accompanying someone
|
|
if (bs->ltgtype != LTG_TEAMACCOMPANY) {
|
|
//if there is avisible team mate flag carrier
|
|
c = BotTeamFlagCarrierVisible(bs);
|
|
if (c >= 0) {
|
|
//follow the flag carrier
|
|
//the team mate
|
|
bs->teammate = c;
|
|
//last time the team mate was visible
|
|
bs->teammatevisible_time = trap_AAS_Time();
|
|
//set the time to send a message to the team mates
|
|
bs->teammessage_time = trap_AAS_Time() + 2 * random();
|
|
//get the team goal time
|
|
bs->teamgoal_time = trap_AAS_Time() + TEAM_ACCOMPANY_TIME;
|
|
bs->ltgtype = LTG_TEAMACCOMPANY;
|
|
bs->formation_dist = 3.5 * 32; //3.5 meter
|
|
bs->arrive_time = 0;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//if the base flag is stolen
|
|
else if (flagstatus == 2) {
|
|
//if not already going for the enemy flag
|
|
if (bs->ltgtype != LTG_GETFLAG) {
|
|
//if there's no bot team leader
|
|
if (!BotTeamLeader(bs)) {
|
|
//go for the enemy flag
|
|
bs->ltgtype = LTG_GETFLAG;
|
|
//no team message
|
|
bs->teammessage_time = 1;
|
|
//set the time the bot will stop getting the flag
|
|
bs->teamgoal_time = trap_AAS_Time() + CTF_GETFLAG_TIME;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
//if both flags not at their bases
|
|
else if (flagstatus == 3) {
|
|
//
|
|
if (bs->ltgtype != LTG_GETFLAG &&
|
|
bs->ltgtype != LTG_TEAMACCOMPANY) {
|
|
//if there is avisible team mate flag carrier
|
|
c = BotTeamFlagCarrierVisible(bs);
|
|
if (c >= 0) {
|
|
//follow the flag carrier
|
|
return;
|
|
}
|
|
else {
|
|
//otherwise attack the enemy base
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
//if the bot is roaming
|
|
if (bs->ctfroam_time > trap_AAS_Time()) return;
|
|
//if already a CTF or team goal
|
|
if (bs->ltgtype == LTG_TEAMHELP ||
|
|
bs->ltgtype == LTG_TEAMACCOMPANY ||
|
|
bs->ltgtype == LTG_DEFENDKEYAREA ||
|
|
bs->ltgtype == LTG_GETFLAG ||
|
|
bs->ltgtype == LTG_RUSHBASE ||
|
|
bs->ltgtype == LTG_RETURNFLAG ||
|
|
bs->ltgtype == LTG_CAMPORDER ||
|
|
bs->ltgtype == LTG_PATROL) {
|
|
return;
|
|
}
|
|
//if the bot has anough aggression to decide what to do
|
|
if (BotAggression(bs) < 50) return;
|
|
//set the time to send a message to the team mates
|
|
bs->teammessage_time = trap_AAS_Time() + 2 * random();
|
|
//get the flag or defend the base
|
|
rnd = random();
|
|
if (rnd < 0.33 && ctf_redflag.areanum && ctf_blueflag.areanum) {
|
|
bs->ltgtype = LTG_GETFLAG;
|
|
//set the time the bot will stop getting the flag
|
|
bs->teamgoal_time = trap_AAS_Time() + CTF_GETFLAG_TIME;
|
|
}
|
|
else if (rnd < 0.66 && ctf_redflag.areanum && ctf_blueflag.areanum) {
|
|
//
|
|
if (BotCTFTeam(bs) == CTF_TEAM_RED) memcpy(&bs->teamgoal, &ctf_redflag, sizeof(bot_goal_t));
|
|
else memcpy(&bs->teamgoal, &ctf_blueflag, sizeof(bot_goal_t));
|
|
//set the ltg type
|
|
bs->ltgtype = LTG_DEFENDKEYAREA;
|
|
//set the time the bot stops defending the base
|
|
bs->teamgoal_time = trap_AAS_Time() + TEAM_DEFENDKEYAREA_TIME;
|
|
bs->defendaway_time = 0;
|
|
}
|
|
else {
|
|
bs->ltgtype = 0;
|
|
//set the time the bot will stop roaming
|
|
bs->ctfroam_time = trap_AAS_Time() + CTF_ROAM_TIME;
|
|
}
|
|
#ifdef DEBUG
|
|
BotPrintTeamGoal(bs);
|
|
#endif //DEBUG
|
|
}
|
|
|
|
#endif //CTF
|
|
|
|
/*
|
|
==================
|
|
BotPointAreaNum
|
|
==================
|
|
*/
|
|
int BotPointAreaNum(vec3_t origin) {
|
|
int areanum, numareas, areas[10];
|
|
vec3_t end;
|
|
|
|
areanum = trap_AAS_PointAreaNum(origin);
|
|
if (areanum) return areanum;
|
|
VectorCopy(origin, end);
|
|
end[2] += 10;
|
|
numareas = trap_AAS_TraceAreas(origin, end, areas, NULL, 10);
|
|
if (numareas > 0) return areas[0];
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
ClientName
|
|
==================
|
|
*/
|
|
char *ClientName(int client, char *name, int size) {
|
|
char buf[MAX_INFO_STRING];
|
|
|
|
if (client < 0 || client >= MAX_CLIENTS) {
|
|
BotAI_Print(PRT_ERROR, "ClientName: client out of range\n");
|
|
return "[client out of range]";
|
|
}
|
|
trap_GetConfigstring(CS_PLAYERS+client, buf, sizeof(buf));
|
|
strncpy(name, Info_ValueForKey(buf, "n"), size-1);
|
|
name[size-1] = '\0';
|
|
Q_CleanStr( name );
|
|
return name;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
ClientSkin
|
|
==================
|
|
*/
|
|
char *ClientSkin(int client, char *skin, int size) {
|
|
char buf[MAX_INFO_STRING];
|
|
|
|
if (client < 0 || client >= MAX_CLIENTS) {
|
|
BotAI_Print(PRT_ERROR, "ClientSkin: client out of range\n");
|
|
return "[client out of range]";
|
|
}
|
|
trap_GetConfigstring(CS_PLAYERS+client, buf, sizeof(buf));
|
|
strncpy(skin, Info_ValueForKey(buf, "model"), size-1);
|
|
skin[size-1] = '\0';
|
|
return skin;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
ClientFromName
|
|
==================
|
|
*/
|
|
int ClientFromName(char *name) {
|
|
int i;
|
|
char buf[MAX_INFO_STRING];
|
|
static int maxclis;
|
|
|
|
if (!maxclis)
|
|
maxclis = trap_Cvar_VariableIntegerValue("sv_maxclients");
|
|
for (i = 0; i < maxclis && i < MAX_CLIENTS; i++) {
|
|
trap_GetConfigstring(CS_PLAYERS+i, buf, sizeof(buf));
|
|
Q_CleanStr( buf );
|
|
if (!Q_stricmp(Info_ValueForKey(buf, "n"), name)) return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
stristr
|
|
==================
|
|
*/
|
|
char *stristr(char *str, char *charset) {
|
|
int i;
|
|
|
|
while(*str) {
|
|
for (i = 0; charset[i] && str[i]; i++) {
|
|
if (toupper(charset[i]) != toupper(str[i])) break;
|
|
}
|
|
if (!charset[i]) return str;
|
|
str++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
EasyClientName
|
|
==================
|
|
*/
|
|
char *EasyClientName(int client, char *buf, int size) {
|
|
int i;
|
|
char *str1, *str2, *ptr, c;
|
|
char name[128];
|
|
|
|
strcpy(name, ClientName(client, name, sizeof(name)));
|
|
for (i = 0; name[i]; i++) name[i] &= 127;
|
|
//remove all spaces
|
|
for (ptr = strstr(name, " "); ptr; ptr = strstr(name, " ")) {
|
|
memmove(ptr, ptr+1, strlen(ptr+1)+1);
|
|
}
|
|
//check for [x] and ]x[ clan names
|
|
str1 = strstr(name, "[");
|
|
str2 = strstr(name, "]");
|
|
if (str1 && str2) {
|
|
if (str2 > str1) memmove(str1, str2+1, strlen(str2+1)+1);
|
|
else memmove(str2, str1+1, strlen(str1+1)+1);
|
|
}
|
|
//remove Mr prefix
|
|
if ((name[0] == 'm' || name[0] == 'M') &&
|
|
(name[1] == 'r' || name[1] == 'R')) {
|
|
memmove(name, name+2, strlen(name+2)+1);
|
|
}
|
|
//only allow lower case alphabet characters
|
|
ptr = name;
|
|
while(*ptr) {
|
|
c = *ptr;
|
|
if ((c >= 'a' && c <= 'z') ||
|
|
(c >= '0' && c <= '9') || c == '_') {
|
|
ptr++;
|
|
}
|
|
else if (c >= 'A' && c <= 'Z') {
|
|
*ptr += 'a' - 'A';
|
|
ptr++;
|
|
}
|
|
else {
|
|
memmove(ptr, ptr+1, strlen(ptr + 1)+1);
|
|
}
|
|
}
|
|
strncpy(buf, name, size-1);
|
|
buf[size-1] = '\0';
|
|
return buf;
|
|
}
|
|
|
|
qboolean BotUseMeleeWeapon(bot_state_t *bs) {
|
|
if ( bs->inventory[ENEMY_HORIZONTAL_DIST] < 64 )
|
|
{
|
|
/*if ( bs->cur_ps.persistant[PERS_CLASS] == PC_BORG || bs->cur_ps.persistant[PERS_CLASS] == PC_MEDIC )
|
|
{
|
|
return qtrue;
|
|
}*/
|
|
}
|
|
return qfalse;
|
|
}
|
|
/*
|
|
==================
|
|
BotChooseWeapon
|
|
|
|
MCG - FIXME: This should really take into account:
|
|
Projectile vs. instant?
|
|
gravity on projectile?
|
|
Range to enemy vs range of weapon?
|
|
Some randomness on the weights?
|
|
|
|
==================
|
|
*/
|
|
void BotChooseWeapon(bot_state_t *bs) {
|
|
int newweaponnum;
|
|
|
|
if (bs->cur_ps.weaponstate == WEAPON_RAISING || bs->cur_ps.weaponstate == WEAPON_DROPPING)
|
|
{
|
|
trap_EA_SelectWeapon(bs->client, bs->weaponnum);
|
|
}
|
|
else
|
|
{
|
|
newweaponnum = trap_BotChooseBestFightWeapon(bs->ws, bs->inventory, BotUseMeleeWeapon(bs));
|
|
if (bs->weaponnum != newweaponnum)
|
|
{
|
|
bs->weaponchange_time = trap_AAS_Time();
|
|
}
|
|
bs->weaponnum = newweaponnum;
|
|
//BotAI_Print(PRT_MESSAGE, "bs->weaponnum = %d\n", bs->weaponnum);
|
|
trap_EA_SelectWeapon(bs->client, bs->weaponnum);
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotSetupForMovement
|
|
==================
|
|
*/
|
|
void BotSetupForMovement(bot_state_t *bs) {
|
|
bot_initmove_t initmove;
|
|
|
|
memset(&initmove, 0, sizeof(bot_initmove_t));
|
|
VectorCopy(bs->cur_ps.origin, initmove.origin);
|
|
VectorCopy(bs->cur_ps.velocity, initmove.velocity);
|
|
VectorCopy(bs->cur_ps.origin, initmove.viewoffset);
|
|
initmove.viewoffset[2] += bs->cur_ps.viewheight;
|
|
initmove.entitynum = bs->entitynum;
|
|
initmove.client = bs->client;
|
|
initmove.thinktime = bs->thinktime;
|
|
//set the onground flag
|
|
if (bs->cur_ps.groundEntityNum != ENTITYNUM_NONE) initmove.or_moveflags |= MFL_ONGROUND;
|
|
//set the teleported flag
|
|
if ((bs->cur_ps.pm_flags & PMF_TIME_KNOCKBACK) && (bs->cur_ps.pm_time > 0)) {
|
|
initmove.or_moveflags |= MFL_TELEPORTED;
|
|
}
|
|
//set the waterjump flag
|
|
if ((bs->cur_ps.pm_flags & PMF_TIME_WATERJUMP) && (bs->cur_ps.pm_time > 0)) {
|
|
initmove.or_moveflags |= MFL_WATERJUMP;
|
|
}
|
|
//set presence type
|
|
if (bs->cur_ps.pm_flags & PMF_DUCKED) initmove.presencetype = PRESENCE_CROUCH;
|
|
else initmove.presencetype = PRESENCE_NORMAL;
|
|
//
|
|
if (bs->walker > 0.5) initmove.or_moveflags |= MFL_WALK;
|
|
//
|
|
VectorCopy(bs->viewangles, initmove.viewangles);
|
|
//
|
|
trap_BotInitMoveState(bs->ms, &initmove);
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotUpdateInventory
|
|
==================
|
|
*/
|
|
void BotUpdateInventory(bot_state_t *bs) {
|
|
//armor
|
|
bs->inventory[INVENTORY_ARMOR] = bs->cur_ps.stats[STAT_ARMOR];
|
|
|
|
//weapons
|
|
bs->inventory[INVENTORY_GRENADELAUNCHER] = (bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_GRENADE_LAUNCHER)) != 0;
|
|
bs->inventory[INVENTORY_STASIS] = (bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_DISRUPTOR)) != 0;
|
|
bs->inventory[INVENTORY_PHASER] = (bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_PHASER)) != 0;
|
|
bs->inventory[INVENTORY_DREADNOUGHT] = (bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_DERMAL_REGEN)) != 0;
|
|
bs->inventory[INVENTORY_IMOD] = (bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_NULL_HAND)) != 0;
|
|
bs->inventory[INVENTORY_COMPRESSION] = (bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_COMPRESSION_RIFLE)) != 0;
|
|
bs->inventory[INVENTORY_TETRION] = (bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_TR116)) != 0;
|
|
bs->inventory[INVENTORY_SCAVENGER] = (bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_COFFEE)) != 0;
|
|
bs->inventory[INVENTORY_QUANTUM] = (bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_QUANTUM_BURST)) != 0;
|
|
|
|
//ammo
|
|
bs->inventory[INVENTORY_GRENADES] = bs->cur_ps.ammo[WP_GRENADE_LAUNCHER];
|
|
bs->inventory[INVENTORY_STASISAMMO] = bs->cur_ps.ammo[WP_DISRUPTOR];
|
|
bs->inventory[INVENTORY_PHASERAMMO] = bs->cur_ps.ammo[WP_PHASER];
|
|
bs->inventory[INVENTORY_DREADNOUGHTAMMO] = bs->cur_ps.ammo[WP_DERMAL_REGEN];
|
|
bs->inventory[INVENTORY_IMODAMMO] = bs->cur_ps.ammo[WP_NULL_HAND];
|
|
bs->inventory[INVENTORY_COMPRESSIONAMMO] = bs->cur_ps.ammo[WP_COMPRESSION_RIFLE];
|
|
bs->inventory[INVENTORY_TETRIONAMMO] = bs->cur_ps.ammo[WP_TR116];
|
|
bs->inventory[INVENTORY_SCAVENGERAMMO] = bs->cur_ps.ammo[WP_COFFEE];
|
|
bs->inventory[INVENTORY_QUANTUMAMMO] = bs->cur_ps.ammo[WP_QUANTUM_BURST];
|
|
|
|
//powerups
|
|
bs->inventory[INVENTORY_HEALTH] = bs->cur_ps.stats[STAT_HEALTH];
|
|
bs->inventory[INVENTORY_TRANSPORTER] = bs->cur_ps.stats[STAT_HOLDABLE_ITEM] == MODELINDEX_TELEPORTER;
|
|
bs->inventory[INVENTORY_MEDKIT] = bs->cur_ps.stats[STAT_HOLDABLE_ITEM] == MODELINDEX_MEDKIT;
|
|
bs->inventory[INVENTORY_QUAD] = bs->cur_ps.powerups[PW_QUAD] != 0;
|
|
bs->inventory[INVENTORY_ENVIRONMENTSUIT] = bs->cur_ps.powerups[PW_BOLTON] != 0;
|
|
bs->inventory[INVENTORY_HASTE] = bs->cur_ps.powerups[PW_HASTE] != 0;
|
|
bs->inventory[INVENTORY_INVISIBILITY] = bs->cur_ps.powerups[PW_INVIS] != 0;
|
|
bs->inventory[INVENTORY_REGEN] = bs->cur_ps.powerups[PW_LASER] != 0;
|
|
bs->inventory[INVENTORY_FLIGHT] = bs->cur_ps.powerups[PW_FLIGHT] != 0;
|
|
//bs->inventory[INVENTORY_REDFLAG] = bs->cur_ps.powerups[PW_REDFLAG] != 0;
|
|
//bs->inventory[INVENTORY_BLUEFLAG] = bs->cur_ps.powerups[PW_REDFLAG] != 0;
|
|
bs->inventory[INVENTORY_SEEKER] = bs->cur_ps.powerups[PW_FLASHLIGHT] != 0;
|
|
bs->inventory[INVENTORY_SHIELD] = bs->cur_ps.stats[STAT_HOLDABLE_ITEM] == MODELINDEX_SHIELD;
|
|
bs->inventory[INVENTORY_DETPACK] = bs->cur_ps.stats[STAT_HOLDABLE_ITEM] == MODELINDEX_DETPACK;
|
|
//
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotUpdateBattleInventory
|
|
==================
|
|
*/
|
|
void BotUpdateBattleInventory(bot_state_t *bs, int enemy) {
|
|
vec3_t dir;
|
|
aas_entityinfo_t entinfo;
|
|
|
|
BotEntityInfo(enemy, &entinfo);
|
|
VectorSubtract(entinfo.origin, bs->origin, dir);
|
|
bs->inventory[ENEMY_HEIGHT] = (int) dir[2];
|
|
dir[2] = 0;
|
|
bs->inventory[ENEMY_HORIZONTAL_DIST] = (int) VectorLength(dir);
|
|
//FIXME: add num visible enemies and num visible team mates to the inventory
|
|
}
|
|
|
|
/*
|
|
=========================
|
|
BotShouldDetonateDetPack
|
|
=========================
|
|
*/
|
|
#define DETPACK_RADIUS 500
|
|
|
|
qboolean BotShouldDetonateDetPack(bot_state_t *bs)
|
|
{
|
|
int botNum = 0, detWeight = 0;
|
|
vec3_t packOrg, dir;
|
|
float dist;
|
|
aas_entityinfo_t botinfo;
|
|
|
|
// find the location of the DetPack
|
|
gentity_t *detpack = NULL;
|
|
char *classname = BG_FindClassnameForHoldable(HI_DETPACK);
|
|
|
|
if (!classname)
|
|
{
|
|
return qfalse;
|
|
}
|
|
|
|
//while ((detpack = G_Find (detpack, FOFS(classname), classname)) != NULL)
|
|
while ((detpack = G_Find (detpack, FOFS(classname), classname)) != NULL)
|
|
{
|
|
VectorCopy(detpack->r.currentOrigin, packOrg);
|
|
}
|
|
|
|
// determine who would be killed in the blast radius
|
|
for (botNum = 0; botNum < MAX_CLIENTS; botNum++)
|
|
{
|
|
BotEntityInfo(botNum, &botinfo);
|
|
if (!botinfo.valid) continue;
|
|
|
|
//calculate the distance towards the enemy
|
|
VectorSubtract(botinfo.origin, packOrg, dir);
|
|
dist = VectorLength(dir);
|
|
|
|
if (dist < DETPACK_RADIUS) // bot would get caught in blast radius
|
|
{
|
|
if (BotSameTeam(bs, botNum)) // friendly casualty potential
|
|
{
|
|
if (botNum == bs->client) // suicide... bad
|
|
{
|
|
detWeight--;
|
|
}
|
|
if (EntityCarriesFlag(&botinfo)) // it's my teammate, and he's got the flag!
|
|
{
|
|
detWeight -= 11;
|
|
continue;
|
|
}
|
|
detWeight--;
|
|
}
|
|
else
|
|
{
|
|
if(EntityCarriesFlag(&botinfo)) // mwahaha
|
|
{
|
|
detWeight += 14;
|
|
}
|
|
detWeight++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Com_Printf("detWeight %d\n", detWeight);
|
|
|
|
if (detWeight > 0)
|
|
{
|
|
return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
==================
|
|
BotBattleUseItems
|
|
==================
|
|
*/
|
|
void BotBattleUseItems(bot_state_t *bs) {
|
|
|
|
|
|
if (bs->inventory[INVENTORY_DETPACK] > 0)
|
|
{
|
|
// this needs to be in two stages: placement and detonation
|
|
if (bs->ltgtype == LTG_DEFENDKEYAREA)
|
|
{
|
|
if (bs->inventory[INVENTORY_DETPACK_PLACED] == 0) // not placed yet
|
|
{
|
|
bs->inventory[INVENTORY_DETPACK_PLACED] = 1;
|
|
trap_EA_Use(bs->client); // place it
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (bs->inventory[INVENTORY_DETPACK_PLACED] == 1) // placed
|
|
{
|
|
if (BotShouldDetonateDetPack(bs)) // logic
|
|
{
|
|
bs->inventory[INVENTORY_DETPACK_PLACED] = 0;
|
|
trap_EA_Use(bs->client); // BOOM
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (bs->inventory[INVENTORY_SHIELD] > 0)
|
|
{
|
|
if (BotWantsToRetreat(bs) && (bs->inventory[INVENTORY_HEALTH] < 50))
|
|
{
|
|
trap_EA_Use(bs->client);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (bs->inventory[INVENTORY_TRANSPORTER] > 0)
|
|
{
|
|
if (!BotCTFCarryingFlag(bs) && (bs->inventory[INVENTORY_HEALTH] < 50))
|
|
{
|
|
trap_EA_Use(bs->client);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (bs->inventory[INVENTORY_MEDKIT] > 0)
|
|
{
|
|
if (bs->inventory[INVENTORY_HEALTH] < 30)
|
|
{
|
|
trap_EA_Use(bs->client);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotSetTeleportTime
|
|
==================
|
|
*/
|
|
void BotSetTeleportTime(bot_state_t *bs) {
|
|
if ((bs->cur_ps.eFlags ^ bs->last_eFlags) & EF_TELEPORT_BIT) {
|
|
bs->teleport_time = trap_AAS_Time();
|
|
}
|
|
bs->last_eFlags = bs->cur_ps.eFlags;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotIsDead
|
|
==================
|
|
*/
|
|
qboolean BotIsDead(bot_state_t *bs) {
|
|
return (bs->cur_ps.pm_type == PM_DEAD);
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotIsObserver
|
|
==================
|
|
*/
|
|
qboolean BotIsObserver(bot_state_t *bs) {
|
|
char buf[MAX_INFO_STRING];
|
|
if (bs->cur_ps.pm_type == PM_SPECTATOR) return qtrue;
|
|
trap_GetConfigstring(CS_PLAYERS+bs->client, buf, sizeof(buf));
|
|
if (atoi(Info_ValueForKey(buf, "t")) == TEAM_SPECTATOR) return qtrue;
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotIntermission
|
|
==================
|
|
*/
|
|
qboolean BotIntermission(bot_state_t *bs) {
|
|
//NOTE: we shouldn't be looking at the game code...
|
|
if (level.intermissiontime) return qtrue;
|
|
return (bs->cur_ps.pm_type == PM_FREEZE || bs->cur_ps.pm_type == PM_INTERMISSION);
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotInLavaOrSlime
|
|
==================
|
|
*/
|
|
qboolean BotInLavaOrSlime(bot_state_t *bs) {
|
|
vec3_t feet;
|
|
|
|
VectorCopy(bs->origin, feet);
|
|
feet[2] -= 23;
|
|
return (trap_AAS_PointContents(feet) & (CONTENTS_LAVA|CONTENTS_SLIME));
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotCreateWayPoint
|
|
==================
|
|
*/
|
|
bot_waypoint_t *BotCreateWayPoint(char *name, vec3_t origin, int areanum) {
|
|
bot_waypoint_t *wp;
|
|
vec3_t waypointmins = {-8, -8, -8}, waypointmaxs = {8, 8, 8};
|
|
|
|
wp = botai_freewaypoints;
|
|
if ( !wp ) {
|
|
BotAI_Print( PRT_WARNING, "BotCreateWayPoint: Out of waypoints\n" );
|
|
return NULL;
|
|
}
|
|
botai_freewaypoints = botai_freewaypoints->next;
|
|
|
|
Q_strncpyz( wp->name, name, sizeof(wp->name) );
|
|
VectorCopy(origin, wp->goal.origin);
|
|
VectorCopy(waypointmins, wp->goal.mins);
|
|
VectorCopy(waypointmaxs, wp->goal.maxs);
|
|
wp->goal.areanum = areanum;
|
|
wp->next = NULL;
|
|
wp->prev = NULL;
|
|
return wp;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotFindWayPoint
|
|
==================
|
|
*/
|
|
bot_waypoint_t *BotFindWayPoint(bot_waypoint_t *waypoints, char *name) {
|
|
bot_waypoint_t *wp;
|
|
|
|
for (wp = waypoints; wp; wp = wp->next) {
|
|
if (!Q_stricmp(wp->name, name)) return wp;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotFreeWaypoints
|
|
==================
|
|
*/
|
|
void BotFreeWaypoints(bot_waypoint_t *wp) {
|
|
bot_waypoint_t *nextwp;
|
|
|
|
for (; wp; wp = nextwp) {
|
|
nextwp = wp->next;
|
|
wp->next = botai_freewaypoints;
|
|
botai_freewaypoints = wp;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotInitWaypoints
|
|
==================
|
|
*/
|
|
void BotInitWaypoints(void) {
|
|
int i;
|
|
|
|
botai_freewaypoints = NULL;
|
|
for (i = 0; i < MAX_WAYPOINTS; i++) {
|
|
botai_waypoints[i].next = botai_freewaypoints;
|
|
botai_freewaypoints = &botai_waypoints[i];
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
TeamPlayIsOn
|
|
==================
|
|
*/
|
|
int TeamPlayIsOn(void) {
|
|
return ( gametype == GT_TEAM || gametype == GT_CTF );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotAggression
|
|
==================
|
|
*/
|
|
float BotAggression(bot_state_t *bs) {
|
|
//if the bot has quad
|
|
if (bs->inventory[INVENTORY_QUAD]) {
|
|
//if the bot is not holding the gauntlet or the enemy is really nearby
|
|
if (bs->inventory[ENEMY_HORIZONTAL_DIST] < 80) {
|
|
return 70;
|
|
}
|
|
}
|
|
//if the enemy is located way higher than the bot
|
|
if (bs->inventory[ENEMY_HEIGHT] > 200) return 0;
|
|
//if the bot is very low on health
|
|
if (bs->inventory[INVENTORY_HEALTH] < 60) return 0;
|
|
//if the bot is low on health
|
|
if (bs->inventory[INVENTORY_HEALTH] < 80) {
|
|
//if the bot has insufficient armor
|
|
if (bs->inventory[INVENTORY_ARMOR] < 40) return 0;
|
|
}
|
|
|
|
if (bs->inventory[INVENTORY_DREADNOUGHT] > 0 &&
|
|
bs->inventory[INVENTORY_DREADNOUGHTAMMO] > 0) return 100;
|
|
|
|
if (bs->inventory[INVENTORY_TETRION] > 0 &&
|
|
bs->inventory[INVENTORY_TETRIONAMMO] > 0) return 95;
|
|
|
|
if (bs->inventory[INVENTORY_QUANTUM] > 0 &&
|
|
bs->inventory[INVENTORY_QUANTUMAMMO] > 0) return 90;
|
|
|
|
if (bs->inventory[INVENTORY_STASIS] > 0 &&
|
|
bs->inventory[INVENTORY_STASISAMMO] > 0) return 85;
|
|
|
|
if (bs->inventory[INVENTORY_SCAVENGER] > 0 &&
|
|
bs->inventory[INVENTORY_SCAVENGERAMMO] > 0) return 80;
|
|
|
|
if (bs->inventory[INVENTORY_GRENADELAUNCHER] > 0 &&
|
|
bs->inventory[INVENTORY_GRENADES] > 0) return 75;
|
|
|
|
if (bs->inventory[INVENTORY_IMOD] > 0 &&
|
|
bs->inventory[INVENTORY_IMODAMMO] > 0) return 70;
|
|
|
|
if (bs->inventory[INVENTORY_COMPRESSION] > 0 &&
|
|
bs->inventory[INVENTORY_COMPRESSIONAMMO] > 0) return 65;
|
|
|
|
//otherwise the bot is not feeling too aggressive
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotWantsToRetreat
|
|
==================
|
|
*/
|
|
int BotWantsToRetreat(bot_state_t *bs) {
|
|
aas_entityinfo_t entinfo;
|
|
|
|
//always retreat when carrying a CTF flag
|
|
if (BotCTFCarryingFlag(bs)) return qtrue;
|
|
//
|
|
if (bs->enemy >= 0) {
|
|
//if the enemy is carrying a flag
|
|
BotEntityInfo(bs->enemy, &entinfo);
|
|
if (EntityCarriesFlag(&entinfo)) return qfalse;
|
|
}
|
|
//if the bot is getting the flag
|
|
if (bs->ltgtype == LTG_GETFLAG) return qtrue;
|
|
//
|
|
if (BotAggression(bs) < 50) return qtrue;
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotWantsToChase
|
|
==================
|
|
*/
|
|
int BotWantsToChase(bot_state_t *bs) {
|
|
aas_entityinfo_t entinfo;
|
|
|
|
//always retreat when carrying a CTF flag
|
|
if (BotCTFCarryingFlag(bs)) return qfalse;
|
|
//if the enemy is carrying a flag
|
|
BotEntityInfo(bs->enemy, &entinfo);
|
|
if (EntityCarriesFlag(&entinfo)) return qtrue;
|
|
//if the bot is getting the flag
|
|
if (bs->ltgtype == LTG_GETFLAG) return qfalse;
|
|
//
|
|
if (BotAggression(bs) > 50) return qtrue;
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotWantsToHelp
|
|
==================
|
|
*/
|
|
int BotWantsToHelp(bot_state_t *bs) {
|
|
return qtrue;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotCanAndWantsToRocketJump
|
|
==================
|
|
*/
|
|
int BotCanAndWantsToRocketJump(bot_state_t *bs) {
|
|
float rocketjumper;
|
|
|
|
//if rocket jumping is disabled
|
|
if (!bot_rocketjump.integer) return qfalse;
|
|
//if no rocket launcher
|
|
if (bs->inventory[INVENTORY_QUANTUM] <= 0) return qfalse;
|
|
//if low on rockets
|
|
if (bs->inventory[INVENTORY_QUANTUMAMMO] < 1) return qfalse;
|
|
//never rocket jump with the Quad
|
|
if (bs->inventory[INVENTORY_QUAD])
|
|
{
|
|
if ( rpg_selfdamage.integer != 0 )
|
|
{
|
|
return qfalse;
|
|
}
|
|
}
|
|
//if low on health
|
|
if (bs->inventory[INVENTORY_HEALTH] < 50)
|
|
{ //if not full health
|
|
if ( rpg_selfdamage.integer != 0 )
|
|
{
|
|
return qfalse;
|
|
}
|
|
}
|
|
if (bs->inventory[INVENTORY_HEALTH] < 60)
|
|
{ //if the bot has insufficient armor
|
|
if (bs->inventory[INVENTORY_ARMOR] < 20)
|
|
{
|
|
if ( rpg_selfdamage.integer != 0 )
|
|
{
|
|
return qfalse;
|
|
}
|
|
}
|
|
}
|
|
rocketjumper = 1;
|
|
return qtrue;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotGoCamp
|
|
==================
|
|
*/
|
|
void BotGoCamp(bot_state_t *bs, bot_goal_t *goal) {
|
|
float camper;
|
|
|
|
//set message time to zero so bot will NOT show any message
|
|
bs->teammessage_time = 0;
|
|
//set the ltg type
|
|
bs->ltgtype = LTG_CAMP;
|
|
//set the team goal
|
|
memcpy(&bs->teamgoal, goal, sizeof(bot_goal_t));
|
|
//get the team goal time
|
|
camper = 0;
|
|
if (camper > 0.99) bs->teamgoal_time = 99999;
|
|
else bs->teamgoal_time = 120 + 180 * camper + random() * 15;
|
|
//set the last time the bot started camping
|
|
bs->camp_time = trap_AAS_Time();
|
|
//the teammate that requested the camping
|
|
bs->teammate = 0;
|
|
//do NOT type arrive message
|
|
bs->arrive_time = 1;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotWantsToCamp
|
|
==================
|
|
*/
|
|
int BotWantsToCamp(bot_state_t *bs) {
|
|
float camper;
|
|
camper = 0;
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotDontAvoid
|
|
==================
|
|
*/
|
|
void BotDontAvoid(bot_state_t *bs, char *itemname) {
|
|
bot_goal_t goal;
|
|
int num;
|
|
|
|
num = trap_BotGetLevelItemGoal(-1, itemname, &goal);
|
|
while(num >= 0) {
|
|
trap_BotRemoveFromAvoidGoals(bs->gs, goal.number);
|
|
num = trap_BotGetLevelItemGoal(num, itemname, &goal);
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotGoForPowerups
|
|
==================
|
|
*/
|
|
void BotGoForPowerups(bot_state_t *bs) {
|
|
|
|
//don't avoid any of the powerups anymore
|
|
BotDontAvoid(bs, "Quantum Weapon Enhancer");
|
|
BotDontAvoid(bs, "Nano-Regenerative Protoplasmer");
|
|
BotDontAvoid(bs, "Metaphasic Shielding");
|
|
BotDontAvoid(bs, "Temporal Accelerator");
|
|
BotDontAvoid(bs, "Personal Cloaking Device");
|
|
BotDontAvoid(bs, "Seeker Drone");
|
|
BotDontAvoid(bs, "Anti-Gravity Pack");
|
|
//reset the long term goal time so the bot will go for the powerup
|
|
//NOTE: the long term goal type doesn't change
|
|
bs->ltg_time = 0;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotRoamGoal
|
|
==================
|
|
*/
|
|
void BotRoamGoal(bot_state_t *bs, vec3_t goal) {
|
|
int pc, i;
|
|
float len, rnd;
|
|
vec3_t dir, bestorg, belowbestorg;
|
|
bsp_trace_t trace;
|
|
|
|
for (i = 0; i < 10; i++) {
|
|
//start at the bot origin
|
|
VectorCopy(bs->origin, bestorg);
|
|
rnd = random();
|
|
if (rnd > 0.25) {
|
|
//add a random value to the x-coordinate
|
|
if (random() < 0.5) bestorg[0] -= 800 * random() + 100;
|
|
else bestorg[0] += 800 * random() + 100;
|
|
}
|
|
if (rnd < 0.75) {
|
|
//add a random value to the y-coordinate
|
|
if (random() < 0.5) bestorg[1] -= 800 * random() + 100;
|
|
else bestorg[1] += 800 * random() + 100;
|
|
}
|
|
//add a random value to the z-coordinate (NOTE: 48 = maxjump?)
|
|
bestorg[2] += 2 * 48 * crandom();
|
|
//trace a line from the origin to the roam target
|
|
BotAI_Trace(&trace, bs->origin, NULL, NULL, bestorg, bs->entitynum, MASK_SOLID);
|
|
//direction and length towards the roam target
|
|
VectorSubtract(trace.endpos, bs->origin, dir);
|
|
len = VectorNormalize(dir);
|
|
//if the roam target is far away anough
|
|
if (len > 200) {
|
|
//the roam target is in the given direction before walls
|
|
VectorScale(dir, len * trace.fraction - 40, dir);
|
|
VectorAdd(bs->origin, dir, bestorg);
|
|
//get the coordinates of the floor below the roam target
|
|
belowbestorg[0] = bestorg[0];
|
|
belowbestorg[1] = bestorg[1];
|
|
belowbestorg[2] = bestorg[2] - 800;
|
|
BotAI_Trace(&trace, bestorg, NULL, NULL, belowbestorg, bs->entitynum, MASK_SOLID);
|
|
//
|
|
if (!trace.startsolid) {
|
|
trace.endpos[2]++;
|
|
pc = trap_PointContents(trace.endpos, bs->entitynum);
|
|
if (!(pc & (CONTENTS_LAVA | CONTENTS_SLIME))) {
|
|
VectorCopy(bestorg, goal);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
VectorCopy(bestorg, goal);
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotAttackMove
|
|
==================
|
|
*/
|
|
bot_moveresult_t BotAttackMove(bot_state_t *bs, int tfl) {
|
|
int movetype, i;
|
|
float attack_skill, jumper, croucher, dist, strafechange_time;
|
|
float attack_dist, attack_range;
|
|
vec3_t forward, backward, sideward, hordir, up = {0, 0, 1};
|
|
aas_entityinfo_t entinfo;
|
|
bot_moveresult_t moveresult;
|
|
bot_goal_t goal;
|
|
|
|
if (bs->attackchase_time > trap_AAS_Time()) {
|
|
//create the chase goal
|
|
goal.entitynum = bs->enemy;
|
|
goal.areanum = bs->lastenemyareanum;
|
|
VectorCopy(bs->lastenemyorigin, goal.origin);
|
|
VectorSet(goal.mins, -8, -8, -8);
|
|
VectorSet(goal.maxs, 8, 8, 8);
|
|
//initialize the movement state
|
|
BotSetupForMovement(bs);
|
|
//move towards the goal
|
|
trap_BotMoveToGoal(&moveresult, bs->ms, &goal, tfl);
|
|
return moveresult;
|
|
}
|
|
//
|
|
memset(&moveresult, 0, sizeof(bot_moveresult_t));
|
|
//
|
|
attack_skill = 1;
|
|
jumper = 1;
|
|
croucher = 1;
|
|
//initialize the movement state
|
|
BotSetupForMovement(bs);
|
|
//get the enemy entity info
|
|
BotEntityInfo(bs->enemy, &entinfo);
|
|
//direction towards the enemy
|
|
VectorSubtract(entinfo.origin, bs->origin, forward);
|
|
//the distance towards the enemy
|
|
dist = VectorNormalize(forward);
|
|
VectorNegate(forward, backward);
|
|
//walk, crouch or jump
|
|
movetype = MOVE_WALK;
|
|
//
|
|
if (bs->attackcrouch_time < trap_AAS_Time() - 1) {
|
|
if (random() < jumper) {
|
|
movetype = MOVE_JUMP;
|
|
}
|
|
//wait at least one second before crouching again
|
|
else if (bs->attackcrouch_time < trap_AAS_Time() - 1 && random() < croucher) {
|
|
bs->attackcrouch_time = trap_AAS_Time() + croucher * 5;
|
|
}
|
|
}
|
|
if (bs->attackcrouch_time > trap_AAS_Time()) movetype = MOVE_CROUCH;
|
|
//if the bot should jump
|
|
if (movetype == MOVE_JUMP) {
|
|
//if jumped last frame
|
|
if (bs->attackjump_time > trap_AAS_Time()) {
|
|
movetype = MOVE_WALK;
|
|
}
|
|
else {
|
|
bs->attackjump_time = trap_AAS_Time() + 1;
|
|
}
|
|
}
|
|
|
|
//if using assimilator or alt-fire hypo...
|
|
if ( bs->weaponnum == WP_TOOLKIT || bs->weaponnum == (WP_VOYAGER_HYPO+WP_NUM_WEAPONS) )
|
|
{//get real close
|
|
attack_dist = 16;
|
|
attack_range = 16;
|
|
}
|
|
else
|
|
{
|
|
attack_dist = IDEAL_ATTACKDIST;
|
|
attack_range = 40;
|
|
}
|
|
|
|
//increase the strafe time
|
|
bs->attackstrafe_time += bs->thinktime;
|
|
//get the strafe change time
|
|
strafechange_time = 0.4 + (1 - attack_skill) * 0.2;
|
|
if (attack_skill > 0.7) strafechange_time += crandom() * 0.2;
|
|
//if the strafe direction should be changed
|
|
if (bs->attackstrafe_time > strafechange_time) {
|
|
//some magic number :)
|
|
if (random() > 0.935) {
|
|
//flip the strafe direction
|
|
bs->flags ^= BFL_STRAFERIGHT;
|
|
bs->attackstrafe_time = 0;
|
|
}
|
|
}
|
|
//
|
|
for (i = 0; i < 2; i++) {
|
|
hordir[0] = forward[0];
|
|
hordir[1] = forward[1];
|
|
hordir[2] = 0;
|
|
VectorNormalize(hordir);
|
|
//get the sideward vector
|
|
CrossProduct(hordir, up, sideward);
|
|
//reverse the vector depending on the strafe direction
|
|
if (bs->flags & BFL_STRAFERIGHT) VectorNegate(sideward, sideward);
|
|
//randomly go back a little
|
|
if (random() > 0.9) {
|
|
VectorAdd(sideward, backward, sideward);
|
|
}
|
|
else {
|
|
//walk forward or backward to get at the ideal attack distance
|
|
if (dist > attack_dist + attack_range) VectorAdd(sideward, forward, sideward);
|
|
else if (dist < attack_dist - attack_range) VectorAdd(sideward, backward, sideward);
|
|
}
|
|
//perform the movement
|
|
if (trap_BotMoveInDirection(bs->ms, sideward, 400, movetype)) return moveresult;
|
|
//movement failed, flip the strafe direction
|
|
bs->flags ^= BFL_STRAFERIGHT;
|
|
bs->attackstrafe_time = 0;
|
|
}
|
|
//bot couldn't do any usefull movement
|
|
// bs->attackchase_time = AAS_Time() + 6;
|
|
return moveresult;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotSameTeam
|
|
==================
|
|
*/
|
|
int BotSameTeam(bot_state_t *bs, int entnum) {
|
|
char info1[1024], info2[1024];
|
|
|
|
if (bs->client < 0 || bs->client >= MAX_CLIENTS) {
|
|
//BotAI_Print(PRT_ERROR, "BotSameTeam: client out of range\n");
|
|
return qfalse;
|
|
}
|
|
if (entnum < 0 || entnum >= MAX_CLIENTS) {
|
|
//BotAI_Print(PRT_ERROR, "BotSameTeam: client out of range\n");
|
|
return qfalse;
|
|
}
|
|
if (gametype == GT_TEAM || gametype == GT_CTF) {
|
|
trap_GetConfigstring(CS_PLAYERS+bs->client, info1, sizeof(info1));
|
|
trap_GetConfigstring(CS_PLAYERS+entnum, info2, sizeof(info2));
|
|
//
|
|
if (atoi(Info_ValueForKey(info1, "t")) == atoi(Info_ValueForKey(info2, "t"))) return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
InFieldOfVision
|
|
==================
|
|
*/
|
|
qboolean InFieldOfVision(vec3_t viewangles, float fov, vec3_t angles)
|
|
{
|
|
int i;
|
|
float diff, angle;
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
angle = AngleMod(viewangles[i]);
|
|
angles[i] = AngleMod(angles[i]);
|
|
diff = angles[i] - angle;
|
|
if (angles[i] > angle) {
|
|
if (diff > 180.0) diff -= 360.0;
|
|
}
|
|
else {
|
|
if (diff < -180.0) diff += 360.0;
|
|
}
|
|
if (diff > 0) {
|
|
if (diff > fov * 0.5) return qfalse;
|
|
}
|
|
else {
|
|
if (diff < -fov * 0.5) return qfalse;
|
|
}
|
|
}
|
|
return qtrue;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotEntityVisible
|
|
|
|
returns visibility in the range [0, 1] taking fog and water surfaces into account
|
|
==================
|
|
*/
|
|
float BotEntityVisible(int viewer, vec3_t eye, vec3_t viewangles, float fov, int ent) {
|
|
int i, contents_mask, passent, hitent, infog, inwater, otherinfog, pc;
|
|
float fogdist, waterfactor, vis, bestvis;
|
|
bsp_trace_t trace;
|
|
aas_entityinfo_t entinfo;
|
|
vec3_t dir, entangles, start, end, middle;
|
|
|
|
//calculate middle of bounding box
|
|
BotEntityInfo(ent, &entinfo);
|
|
VectorAdd(entinfo.mins, entinfo.maxs, middle);
|
|
VectorScale(middle, 0.5, middle);
|
|
VectorAdd(entinfo.origin, middle, middle);
|
|
//check if entity is within field of vision
|
|
VectorSubtract(middle, eye, dir);
|
|
vectoangles(dir, entangles);
|
|
if (!InFieldOfVision(viewangles, fov, entangles)) return 0;
|
|
//
|
|
pc = trap_AAS_PointContents(eye);
|
|
infog = (pc & CONTENTS_SOLID);
|
|
inwater = (pc & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER));
|
|
//
|
|
bestvis = 0;
|
|
for (i = 0; i < 3; i++) {
|
|
//if the point is not in potential visible sight
|
|
//if (!AAS_inPVS(eye, middle)) continue;
|
|
//
|
|
contents_mask = CONTENTS_SOLID|CONTENTS_PLAYERCLIP;
|
|
passent = viewer;
|
|
hitent = ent;
|
|
VectorCopy(eye, start);
|
|
VectorCopy(middle, end);
|
|
//if the entity is in water, lava or slime
|
|
if (trap_AAS_PointContents(middle) & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER)) {
|
|
contents_mask |= (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER);
|
|
}
|
|
//if eye is in water, lava or slime
|
|
if (inwater) {
|
|
if (!(contents_mask & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER))) {
|
|
passent = ent;
|
|
hitent = viewer;
|
|
VectorCopy(middle, start);
|
|
VectorCopy(eye, end);
|
|
}
|
|
contents_mask ^= (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER);
|
|
}
|
|
//trace from start to end
|
|
BotAI_Trace(&trace, start, NULL, NULL, end, passent, contents_mask);
|
|
//if water was hit
|
|
waterfactor = 1.0;
|
|
if (trace.contents & (CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER)) {
|
|
//if the water surface is translucent
|
|
if (1) {
|
|
//trace through the water
|
|
contents_mask &= ~(CONTENTS_LAVA|CONTENTS_SLIME|CONTENTS_WATER);
|
|
BotAI_Trace(&trace, trace.endpos, NULL, NULL, end, passent, contents_mask);
|
|
waterfactor = 0.5;
|
|
}
|
|
}
|
|
//if a full trace or the hitent was hit
|
|
if (trace.fraction >= 1 || trace.ent == hitent) {
|
|
//check for fog, assuming there's only one fog brush where
|
|
//either the viewer or the entity is in or both are in
|
|
otherinfog = (trap_AAS_PointContents(middle) & CONTENTS_FOG);
|
|
if (infog && otherinfog) {
|
|
VectorSubtract(trace.endpos, eye, dir);
|
|
fogdist = VectorLength(dir);
|
|
}
|
|
else if (infog) {
|
|
VectorCopy(trace.endpos, start);
|
|
BotAI_Trace(&trace, start, NULL, NULL, eye, viewer, CONTENTS_FOG);
|
|
VectorSubtract(eye, trace.endpos, dir);
|
|
fogdist = VectorLength(dir);
|
|
}
|
|
else if (otherinfog) {
|
|
VectorCopy(trace.endpos, end);
|
|
BotAI_Trace(&trace, eye, NULL, NULL, end, viewer, CONTENTS_FOG);
|
|
VectorSubtract(end, trace.endpos, dir);
|
|
fogdist = VectorLength(dir);
|
|
}
|
|
else {
|
|
//if the entity and the viewer are not in fog assume there's no fog in between
|
|
fogdist = 0;
|
|
}
|
|
//decrease visibility with the view distance through fog
|
|
vis = 1 / ((fogdist * fogdist * 0.001) < 1 ? 1 : (fogdist * fogdist * 0.001));
|
|
//if entering water visibility is reduced
|
|
vis *= waterfactor;
|
|
//
|
|
if (vis > bestvis) bestvis = vis;
|
|
//if pretty much no fog
|
|
if (bestvis >= 0.95) return bestvis;
|
|
}
|
|
//check bottom and top of bounding box as well
|
|
if (i == 0) middle[2] += entinfo.mins[2];
|
|
else if (i == 1) middle[2] += entinfo.maxs[2] - entinfo.mins[2];
|
|
}
|
|
return bestvis;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotFindEnemy
|
|
==================
|
|
*/
|
|
int BotFindEnemy(bot_state_t *bs, int curenemy) {
|
|
int i, healthdecrease;
|
|
float f, dist, curdist, alertness, easyfragger, vis;
|
|
aas_entityinfo_t entinfo, curenemyinfo;
|
|
vec3_t dir, angles;
|
|
|
|
alertness = 1;
|
|
easyfragger = 1;
|
|
//check if the health decreased
|
|
healthdecrease = bs->lasthealth > bs->inventory[INVENTORY_HEALTH];
|
|
//remember the current health value
|
|
bs->lasthealth = bs->inventory[INVENTORY_HEALTH];
|
|
//
|
|
if (curenemy >= 0) {
|
|
BotEntityInfo(curenemy, &curenemyinfo);
|
|
if (EntityCarriesFlag(&curenemyinfo)) return qfalse;
|
|
VectorSubtract(curenemyinfo.origin, bs->origin, dir);
|
|
curdist = VectorLength(dir);
|
|
}
|
|
else {
|
|
curdist = 0;
|
|
}
|
|
//
|
|
|
|
//FIXME: This only finds lowest numbered enemy, not the closest or best!!!
|
|
// 6/15/00 dpk changed this
|
|
for (i = 0; i < maxclients && i < MAX_CLIENTS; i++) {
|
|
|
|
if (i == bs->client) continue;
|
|
//if it's the current enemy
|
|
if (i == curenemy) continue;
|
|
//
|
|
BotEntityInfo(i, &entinfo);
|
|
//
|
|
if (!entinfo.valid) continue;
|
|
//if on the same team
|
|
if (BotSameTeam(bs, i)) continue;
|
|
//if the enemy isn't dead and the enemy isn't the bot self
|
|
if (EntityIsDead(&entinfo) || entinfo.number == bs->entitynum) continue;
|
|
//if the enemy is invisible and not shooting
|
|
if (EntityIsInvisible(&entinfo) && !EntityIsShooting(&entinfo)) {
|
|
continue;
|
|
}
|
|
//if not an easy fragger don't shoot at chatting players
|
|
if (easyfragger < 0.5 && EntityIsChatting(&entinfo)) continue;
|
|
//
|
|
if (lastteleport_time > trap_AAS_Time() - 3) {
|
|
VectorSubtract(entinfo.origin, lastteleport_origin, dir);
|
|
if (VectorLength(dir) < 70) continue;
|
|
}
|
|
//calculate the distance towards the enemy
|
|
VectorSubtract(entinfo.origin, bs->origin, dir);
|
|
dist = VectorLength(dir);
|
|
|
|
|
|
//if this entity is not carrying a flag
|
|
if (!EntityCarriesFlag(&entinfo))
|
|
// if (EntityCarriesFlag(&entinfo))
|
|
/* {
|
|
// pick this one!
|
|
}
|
|
else
|
|
*/ {
|
|
//if this enemy is further away than the current one
|
|
if (curenemy >= 0 && dist > curdist) continue;
|
|
}
|
|
|
|
//if the bot in too far away for me to notice
|
|
if (dist > 900 + alertness * 4000) continue;
|
|
|
|
|
|
//if the bot's health decreased or the enemy is shooting
|
|
if (curenemy < 0 && (healthdecrease || EntityIsShooting(&entinfo))) f = 360;
|
|
else f = 90 + 90 - (90 - (dist > 810 ? 810 : dist) / 9);
|
|
//check if the enemy is visible
|
|
vis = BotEntityVisible(bs->entitynum, bs->eye, bs->viewangles, f, i);
|
|
if (vis <= 0) continue;
|
|
//if the enemy is quite far away, not shooting and the bot is not damaged
|
|
if (curenemy < 0 && dist > 200 && !healthdecrease && !EntityIsShooting(&entinfo))
|
|
{
|
|
//check if we can avoid this enemy
|
|
VectorSubtract(bs->origin, entinfo.origin, dir);
|
|
vectoangles(dir, angles);
|
|
//if the bot isn't in the fov of the enemy
|
|
if (!InFieldOfVision(entinfo.angles, 120, angles)) {
|
|
//update some stuff for this enemy
|
|
BotUpdateBattleInventory(bs, i);
|
|
//if the bot doesn't really want to fight
|
|
if (BotWantsToRetreat(bs)) continue;
|
|
}
|
|
}
|
|
// }
|
|
//found an enemy
|
|
bs->enemy = entinfo.number;
|
|
if (curenemy >= 0) bs->enemysight_time = trap_AAS_Time() - 2;
|
|
else bs->enemysight_time = trap_AAS_Time();
|
|
bs->enemysuicide = qfalse;
|
|
bs->enemydeath_time = 0;
|
|
return qtrue;
|
|
}
|
|
return qfalse;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotTeamFlagCarrierVisible
|
|
==================
|
|
*/
|
|
int BotTeamFlagCarrierVisible(bot_state_t *bs) {
|
|
int i;
|
|
float vis;
|
|
aas_entityinfo_t entinfo;
|
|
|
|
for (i = 0; i < maxclients && i < MAX_CLIENTS; i++) {
|
|
if (i == bs->client) continue;
|
|
//
|
|
BotEntityInfo(i, &entinfo);
|
|
//if this player is active
|
|
if (!entinfo.valid) continue;
|
|
//if this player is carrying a flag
|
|
if (!EntityCarriesFlag(&entinfo)) continue;
|
|
//if the flag carrier is not on the same team
|
|
if (!BotSameTeam(bs, i)) continue;
|
|
//if the flag carrier is not visible
|
|
vis = BotEntityVisible(bs->entitynum, bs->eye, bs->viewangles, 360, i);
|
|
if (vis <= 0) continue;
|
|
//
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotAimAtEnemy
|
|
|
|
MCG - FIXME: This is not set up at all correctly in the following areas:
|
|
Needs to consider if weapon is an alt weapon for aim and accuracy as well as functionality
|
|
Need to consider range?
|
|
Grenade Primary and alt as well as Scavenger alt need to take into account gravity
|
|
Needs to pick our new weapons correctly to determine which ones they should:
|
|
lead with (projectiles have speed)
|
|
decay aim purposely (instant hit weaps)
|
|
shoot "around corners" (bouncers, mines, splashdamage?)
|
|
|
|
==================
|
|
*/
|
|
void BotAimAtEnemy(bot_state_t *bs) {
|
|
int i, enemyvisible;
|
|
float dist, f, aim_skill, aim_accuracy, speed, reactiontime;
|
|
vec3_t dir, bestorigin, end, start, groundtarget, cmdmove, enemyvelocity;
|
|
vec3_t mins = {-4,-4,-4}, maxs = {4, 4, 4};
|
|
weaponinfo_t wi;
|
|
aas_entityinfo_t entinfo;
|
|
bot_goal_t goal;
|
|
bsp_trace_t trace;
|
|
vec3_t target;
|
|
|
|
//if the bot has no enemy
|
|
if (bs->enemy < 0) return;
|
|
//
|
|
//BotAI_Print(PRT_MESSAGE, "client %d: aiming at client %d\n", bs->entitynum, bs->enemy);
|
|
//
|
|
aim_skill = 1;
|
|
aim_accuracy = 1;
|
|
//
|
|
if (aim_skill > 0.95)
|
|
{
|
|
//don't aim too early
|
|
reactiontime = 0.5;
|
|
if (bs->enemysight_time > trap_AAS_Time() - reactiontime) return;
|
|
if (bs->teleport_time > trap_AAS_Time() - reactiontime) return;
|
|
}
|
|
|
|
//get the weapon information
|
|
trap_BotGetWeaponInfo(bs->ws, bs->weaponnum, &wi);
|
|
//get the weapon specific aim accuracy and or aim skill
|
|
|
|
if (wi.number == WP_GRENADE_LAUNCHER) {
|
|
aim_accuracy = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_ACCURACY_GRENADELAUNCHER, 0, 1);
|
|
aim_skill = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_SKILL_GRENADELAUNCHER, 0, 1);
|
|
}
|
|
if (wi.number == WP_DISRUPTOR) {
|
|
aim_accuracy = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_ACCURACY_STASIS, 0, 1);
|
|
aim_skill = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_SKILL_STASIS, 0, 1);
|
|
}
|
|
if (wi.number == WP_PHASER) {
|
|
aim_accuracy = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_ACCURACY_PHASER, 0, 1);
|
|
}
|
|
if (wi.number == WP_NULL_HAND) {
|
|
aim_accuracy = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_ACCURACY_IMOD, 0, 1);
|
|
}
|
|
if (wi.number == WP_COMPRESSION_RIFLE) {
|
|
aim_accuracy = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_ACCURACY_COMPRESSION, 0, 1);
|
|
}
|
|
if (wi.number == WP_TR116) {
|
|
aim_accuracy = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_ACCURACY_TETRION, 0, 1);
|
|
}
|
|
if (wi.number == WP_DERMAL_REGEN) {
|
|
aim_accuracy = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_ACCURACY_DREADNOUGHT, 0, 1);
|
|
}
|
|
if (wi.number == WP_QUANTUM_BURST) {
|
|
aim_accuracy = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_ACCURACY_QUANTUM, 0, 1);
|
|
aim_skill = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_SKILL_QUANTUM, 0, 1);
|
|
}
|
|
if (wi.number == WP_COFFEE) {
|
|
aim_accuracy = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_AIM_ACCURACY_SCAVENGER, 0, 1);
|
|
}
|
|
|
|
//
|
|
if (aim_accuracy <= 0) aim_accuracy = 0.0001;
|
|
//get the enemy entity information
|
|
BotEntityInfo(bs->enemy, &entinfo);
|
|
//if the enemy is invisible then shoot crappy most of the time
|
|
if (EntityIsInvisible(&entinfo)) {
|
|
if (random() > 0.1) aim_accuracy *= 0.4;
|
|
}
|
|
//
|
|
VectorSubtract(entinfo.origin, entinfo.lastvisorigin, enemyvelocity);
|
|
VectorScale(enemyvelocity, 1 / entinfo.update_time, enemyvelocity);
|
|
//enemy origin and velocity is remembered every 0.5 seconds
|
|
if (bs->enemyposition_time < trap_AAS_Time()) {
|
|
//
|
|
bs->enemyposition_time = trap_AAS_Time() + 0.5;
|
|
VectorCopy(enemyvelocity, bs->enemyvelocity);
|
|
VectorCopy(entinfo.origin, bs->enemyorigin);
|
|
}
|
|
//if not extremely skilled
|
|
if (aim_skill < 0.9) {
|
|
VectorSubtract(entinfo.origin, bs->enemyorigin, dir);
|
|
//if the enemy moved a bit
|
|
if (VectorLength(dir) > 48) {
|
|
//if the enemy changed direction
|
|
if (DotProduct(bs->enemyvelocity, enemyvelocity) < 0) {
|
|
//aim accuracy should be worse now
|
|
aim_accuracy *= 0.7;
|
|
}
|
|
}
|
|
}
|
|
//check visibility of enemy
|
|
enemyvisible = BotEntityVisible(bs->entitynum, bs->eye, bs->viewangles, 360, bs->enemy);
|
|
//if the enemy is visible
|
|
if (enemyvisible) {
|
|
//
|
|
VectorCopy(entinfo.origin, bestorigin);
|
|
bestorigin[2] += 8;
|
|
//get the start point shooting from
|
|
//NOTE: the x and y projectile start offsets are ignored
|
|
VectorCopy(bs->origin, start);
|
|
start[2] += bs->cur_ps.viewheight;
|
|
start[2] += wi.offset[2];
|
|
//
|
|
BotAI_Trace(&trace, start, mins, maxs, bestorigin, bs->entitynum, MASK_SHOT);
|
|
//if the enemy is NOT hit
|
|
if (trace.fraction <= 1 && trace.ent != entinfo.number) {
|
|
bestorigin[2] += 16;
|
|
}
|
|
//if it is not an instant hit weapon the bot might want to predict the enemy
|
|
if (wi.speed) {
|
|
//
|
|
VectorSubtract(bestorigin, bs->origin, dir);
|
|
dist = VectorLength(dir);
|
|
VectorSubtract(entinfo.origin, bs->enemyorigin, dir);
|
|
//if the enemy is NOT pretty far away and strafing just small steps left and right
|
|
if (!(dist > 100 && VectorLength(dir) < 32)) {
|
|
//if skilled anough do exact prediction
|
|
if (aim_skill > 0.8 &&
|
|
//if the weapon is ready to fire
|
|
bs->cur_ps.weaponstate == WEAPON_READY) {
|
|
aas_clientmove_t move;
|
|
vec3_t origin;
|
|
|
|
VectorSubtract(entinfo.origin, bs->origin, dir);
|
|
//distance towards the enemy
|
|
dist = VectorLength(dir);
|
|
//direction the enemy is moving in
|
|
VectorSubtract(entinfo.origin, entinfo.lastvisorigin, dir);
|
|
//
|
|
VectorScale(dir, 1 / entinfo.update_time, dir);
|
|
//
|
|
VectorCopy(entinfo.origin, origin);
|
|
origin[2] += 1;
|
|
//
|
|
VectorClear(cmdmove);
|
|
//AAS_ClearShownDebugLines();
|
|
trap_AAS_PredictClientMovement(&move, bs->enemy, origin,
|
|
PRESENCE_CROUCH, qfalse,
|
|
dir, cmdmove, 0,
|
|
dist * 10 / wi.speed, 0.1, 0, 0, qfalse);
|
|
VectorCopy(move.endpos, bestorigin);
|
|
//BotAI_Print(PRT_MESSAGE, "%1.1f predicted speed = %f, frames = %f\n", trap_AAS_Time(), VectorLength(dir), dist * 10 / wi.speed);
|
|
}
|
|
//if not that skilled do linear prediction
|
|
else if (aim_skill > 0.4) {
|
|
VectorSubtract(entinfo.origin, bs->origin, dir);
|
|
//distance towards the enemy
|
|
dist = VectorLength(dir);
|
|
//direction the enemy is moving in
|
|
VectorSubtract(entinfo.origin, entinfo.lastvisorigin, dir);
|
|
dir[2] = 0;
|
|
//
|
|
speed = VectorNormalize(dir) / entinfo.update_time;
|
|
//botimport.Print(PRT_MESSAGE, "speed = %f, wi->speed = %f\n", speed, wi->speed);
|
|
//best spot to aim at
|
|
VectorMA(entinfo.origin, (dist / wi.speed) * speed, dir, bestorigin);
|
|
}
|
|
}
|
|
}
|
|
//if the projectile does radial damage
|
|
if (aim_skill > 0.6 && wi.proj.damagetype & DAMAGETYPE_RADIAL) {
|
|
//if the enemy isn't standing significantly higher than the bot
|
|
if (entinfo.origin[2] < bs->origin[2] + 16) {
|
|
//try to aim at the ground in front of the enemy
|
|
VectorCopy(entinfo.origin, end);
|
|
end[2] -= 64;
|
|
BotAI_Trace(&trace, entinfo.origin, NULL, NULL, end, entinfo.number, MASK_SHOT);
|
|
//
|
|
VectorCopy(bestorigin, groundtarget);
|
|
if (trace.startsolid) groundtarget[2] = entinfo.origin[2] - 16;
|
|
else groundtarget[2] = trace.endpos[2] - 8;
|
|
//trace a line from projectile start to ground target
|
|
BotAI_Trace(&trace, start, NULL, NULL, groundtarget, bs->entitynum, MASK_SHOT);
|
|
//if hitpoint is not vertically too far from the ground target
|
|
if (fabs(trace.endpos[2] - groundtarget[2]) < 50) {
|
|
VectorSubtract(trace.endpos, groundtarget, dir);
|
|
//if the hitpoint is near anough the ground target
|
|
if (VectorLength(dir) < 60) {
|
|
VectorSubtract(trace.endpos, start, dir);
|
|
//if the hitpoint is far anough from the bot
|
|
if (VectorLength(dir) > 100) {
|
|
//check if the bot is visible from the ground target
|
|
trace.endpos[2] += 1;
|
|
BotAI_Trace(&trace, trace.endpos, NULL, NULL, entinfo.origin, entinfo.number, MASK_SHOT);
|
|
if (trace.fraction >= 1) {
|
|
//botimport.Print(PRT_MESSAGE, "%1.1f aiming at ground\n", AAS_Time());
|
|
VectorCopy(groundtarget, bestorigin);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
bestorigin[0] += 20 * crandom() * (1 - aim_accuracy);
|
|
bestorigin[1] += 20 * crandom() * (1 - aim_accuracy);
|
|
bestorigin[2] += 10 * crandom() * (1 - aim_accuracy);
|
|
}
|
|
else {
|
|
//
|
|
VectorCopy(bs->lastenemyorigin, bestorigin);
|
|
bestorigin[2] += 8;
|
|
//if the bot is skilled anough
|
|
if (aim_skill > 0.5) {
|
|
//do prediction shots around corners
|
|
if (wi.number == WP_DISRUPTOR ||
|
|
wi.number == WP_GRENADE_LAUNCHER)
|
|
{
|
|
//create the chase goal
|
|
goal.entitynum = bs->client;
|
|
goal.areanum = bs->areanum;
|
|
VectorCopy(bs->eye, goal.origin);
|
|
VectorSet(goal.mins, -8, -8, -8);
|
|
VectorSet(goal.maxs, 8, 8, 8);
|
|
//
|
|
if (trap_BotPredictVisiblePosition(bs->lastenemyorigin, bs->lastenemyareanum, &goal, TFL_DEFAULT, target)) {
|
|
VectorSubtract(target, bs->eye, dir);
|
|
if (VectorLength(dir) > 80) {
|
|
VectorCopy(target, bestorigin);
|
|
bestorigin[2] -= 20;
|
|
}
|
|
}
|
|
aim_accuracy = 1;
|
|
}
|
|
}
|
|
}
|
|
//
|
|
if (enemyvisible) {
|
|
BotAI_Trace(&trace, bs->eye, NULL, NULL, bestorigin, bs->entitynum, MASK_SHOT);
|
|
VectorCopy(trace.endpos, bs->aimtarget);
|
|
}
|
|
else {
|
|
VectorCopy(bestorigin, bs->aimtarget);
|
|
}
|
|
//get aim direction
|
|
VectorSubtract(bestorigin, bs->eye, dir);
|
|
// kef -- fixme. i'm guessing this is listing all of the instant-hit weapons?
|
|
if (wi.number == WP_PHASER ||
|
|
wi.number == WP_NULL_HAND) {
|
|
//distance towards the enemy
|
|
dist = VectorLength(dir);
|
|
if (dist > 150) dist = 150;
|
|
f = 0.6 + dist / 150 * 0.4;
|
|
aim_accuracy *= f;
|
|
}
|
|
//add some random stuff to the aim direction depending on the aim accuracy
|
|
if (aim_accuracy < 0.8) {
|
|
VectorNormalize(dir);
|
|
for (i = 0; i < 3; i++) dir[i] += 0.3 * crandom() * (1 - aim_accuracy);
|
|
}
|
|
//set the ideal view angles
|
|
vectoangles(dir, bs->ideal_viewangles);
|
|
//take the weapon spread into account for lower skilled bots
|
|
bs->ideal_viewangles[PITCH] += 6 * wi.vspread * crandom() * (1 - aim_accuracy);
|
|
bs->ideal_viewangles[PITCH] = AngleMod(bs->ideal_viewangles[PITCH]);
|
|
bs->ideal_viewangles[YAW] += 6 * wi.hspread * crandom() * (1 - aim_accuracy);
|
|
bs->ideal_viewangles[YAW] = AngleMod(bs->ideal_viewangles[YAW]);
|
|
//if the bots should be really challenging
|
|
//if the bot is really accurate and has the enemy in view for some time
|
|
if (aim_accuracy > 0.9 && bs->enemysight_time < trap_AAS_Time() - 1)
|
|
{
|
|
//set the view angles directly
|
|
if (bs->ideal_viewangles[PITCH] > 180)
|
|
{
|
|
bs->ideal_viewangles[PITCH] -= 360;
|
|
}
|
|
VectorCopy(bs->ideal_viewangles, bs->viewangles);
|
|
trap_EA_View(bs->client, bs->viewangles);
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotCheckAttack
|
|
==================
|
|
*/
|
|
void BotCheckAttack(bot_state_t *bs) {
|
|
float points, reactiontime, fov, firethrottle;
|
|
bsp_trace_t bsptrace;
|
|
//float selfpreservation;
|
|
vec3_t forward, right, start, end, dir, angles;
|
|
weaponinfo_t wi;
|
|
bsp_trace_t trace;
|
|
aas_entityinfo_t entinfo;
|
|
vec3_t mins = {-8, -8, -8}, maxs = {8, 8, 8};
|
|
|
|
if (bs->enemy < 0) return;
|
|
//
|
|
reactiontime = 0;
|
|
if (bs->enemysight_time > trap_AAS_Time() - reactiontime) return;
|
|
if (bs->teleport_time > trap_AAS_Time() - reactiontime) return;
|
|
//if changing weapons
|
|
if (bs->weaponchange_time > trap_AAS_Time() - 0.1) return;
|
|
//check fire throttle characteristic
|
|
if (bs->firethrottlewait_time > trap_AAS_Time()) return;
|
|
firethrottle = 1;
|
|
if (bs->firethrottleshoot_time < trap_AAS_Time()) {
|
|
if (random() > firethrottle) {
|
|
bs->firethrottlewait_time = trap_AAS_Time() + firethrottle;
|
|
bs->firethrottleshoot_time = 0;
|
|
}
|
|
else {
|
|
bs->firethrottleshoot_time = trap_AAS_Time() + 1 - firethrottle;
|
|
bs->firethrottlewait_time = 0;
|
|
}
|
|
}
|
|
//
|
|
BotEntityInfo(bs->enemy, &entinfo);
|
|
VectorSubtract(entinfo.origin, bs->eye, dir);
|
|
//
|
|
if (VectorLength(dir) < 100) fov = 120;
|
|
else fov = 50;
|
|
/*
|
|
//if the enemy isn't visible
|
|
if (!BotEntityVisible(bs->entitynum, bs->eye, bs->viewangles, fov, bs->enemy)) {
|
|
//botimport.Print(PRT_MESSAGE, "enemy not visible\n");
|
|
return;
|
|
}*/
|
|
vectoangles(dir, angles);
|
|
if (!InFieldOfVision(bs->viewangles, fov, angles)) return;
|
|
BotAI_Trace(&bsptrace, bs->eye, NULL, NULL, bs->aimtarget, bs->client, CONTENTS_SOLID|CONTENTS_PLAYERCLIP);
|
|
if (bsptrace.fraction < 1 && bsptrace.ent != bs->enemy) return;
|
|
|
|
//get the weapon info
|
|
trap_BotGetWeaponInfo(bs->ws, bs->weaponnum, &wi);
|
|
//get the start point shooting from
|
|
VectorCopy(bs->origin, start);
|
|
start[2] += bs->cur_ps.viewheight;
|
|
AngleVectors(bs->viewangles, forward, right, NULL);
|
|
start[0] += forward[0] * wi.offset[0] + right[0] * wi.offset[1];
|
|
start[1] += forward[1] * wi.offset[0] + right[1] * wi.offset[1];
|
|
start[2] += forward[2] * wi.offset[0] + right[2] * wi.offset[1] + wi.offset[2];
|
|
//end point aiming at
|
|
VectorMA(start, 1000, forward, end);
|
|
//a little back to make sure not inside a very close enemy
|
|
VectorMA(start, -12, forward, start);
|
|
BotAI_Trace(&trace, start, mins, maxs, end, bs->entitynum, MASK_SHOT);
|
|
//if won't hit the enemy
|
|
if (trace.ent != bs->enemy) {
|
|
//if the entity is a client
|
|
if (trace.ent > 0 && trace.ent <= MAX_CLIENTS) {
|
|
//if a teammate is hit
|
|
if (BotSameTeam(bs, trace.ent)) return;
|
|
}
|
|
//if the projectile does a radial damage
|
|
if (wi.proj.damagetype & DAMAGETYPE_RADIAL) {
|
|
if (trace.fraction * 1000 < wi.proj.radius) {
|
|
points = (wi.proj.damage - 0.5 * trace.fraction * 1000) * 0.5;
|
|
if (points > 0) {
|
|
// selfpreservation = trap_Characteristic_BFloat(bs->character, CHARACTERISTIC_SELFPRESERVATION, 0, 1);
|
|
// if (random() < selfpreservation) return;
|
|
return;
|
|
}
|
|
}
|
|
//FIXME: check if a teammate gets radial damage
|
|
}
|
|
}
|
|
//if fire has to be release to activate weapon
|
|
if (wi.flags & WFL_FIRERELEASED) {
|
|
if (bs->flags & BFL_ATTACKED)
|
|
{// check in here to either call the alt_fire or not!! also, adjust the bots weapon... hackery?
|
|
if (bs->weaponnum > WP_NUM_WEAPONS) // it's an alt_fire!
|
|
{
|
|
bs->weaponnum -= WP_NUM_WEAPONS;
|
|
trap_EA_Alt_Attack(bs->client);
|
|
}
|
|
else
|
|
{
|
|
trap_EA_Attack(bs->client);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{ // check in here to either call the alt_fire or not!! also, adjust the bots weapon... hackery?
|
|
if (bs->weaponnum > WP_NUM_WEAPONS) // it's an alt_fire!
|
|
{
|
|
bs->weaponnum -= WP_NUM_WEAPONS;
|
|
trap_EA_Alt_Attack(bs->client);
|
|
}
|
|
else
|
|
{
|
|
trap_EA_Attack(bs->client);
|
|
}
|
|
}
|
|
bs->flags ^= BFL_ATTACKED;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotMapScripts
|
|
==================
|
|
*/
|
|
void BotMapScripts(bot_state_t *bs) {
|
|
char info[1024];
|
|
char mapname[128];
|
|
int i, shootbutton;
|
|
float aim_accuracy;
|
|
aas_entityinfo_t entinfo;
|
|
vec3_t dir;
|
|
|
|
trap_GetServerinfo(info, sizeof(info));
|
|
|
|
strncpy(mapname, Info_ValueForKey( info, "mapname" ), sizeof(mapname)-1);
|
|
mapname[sizeof(mapname)-1] = '\0';
|
|
|
|
if (!Q_stricmp(mapname, "q3tourney6")) {
|
|
vec3_t mins = {700, 204, 672}, maxs = {964, 468, 680};
|
|
vec3_t buttonorg = {304, 352, 920};
|
|
//NOTE: NEVER use the func_bobbing in q3tourney6
|
|
bs->tfl &= ~TFL_FUNCBOB;
|
|
//if the bot is below the bounding box
|
|
if (bs->origin[0] > mins[0] && bs->origin[0] < maxs[0]) {
|
|
if (bs->origin[1] > mins[1] && bs->origin[1] < maxs[1]) {
|
|
if (bs->origin[2] < mins[2]) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
shootbutton = qfalse;
|
|
//if an enemy is below this bounding box then shoot the button
|
|
for (i = 0; i < maxclients && i < MAX_CLIENTS; i++) {
|
|
|
|
if (i == bs->client) continue;
|
|
//
|
|
BotEntityInfo(i, &entinfo);
|
|
//
|
|
if (!entinfo.valid) continue;
|
|
//if the enemy isn't dead and the enemy isn't the bot self
|
|
if (EntityIsDead(&entinfo) || entinfo.number == bs->entitynum) continue;
|
|
//
|
|
if (entinfo.origin[0] > mins[0] && entinfo.origin[0] < maxs[0]) {
|
|
if (entinfo.origin[1] > mins[1] && entinfo.origin[1] < maxs[1]) {
|
|
if (entinfo.origin[2] < mins[2]) {
|
|
//if there's a team mate below the crusher
|
|
if (BotSameTeam(bs, i)) {
|
|
shootbutton = qfalse;
|
|
break;
|
|
}
|
|
else {
|
|
shootbutton = qtrue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (shootbutton) {
|
|
bs->flags |= BFL_IDEALVIEWSET;
|
|
VectorSubtract(buttonorg, bs->eye, dir);
|
|
vectoangles(dir, bs->ideal_viewangles);
|
|
aim_accuracy = 1;
|
|
bs->ideal_viewangles[PITCH] += 8 * crandom() * (1 - aim_accuracy);
|
|
bs->ideal_viewangles[PITCH] = AngleMod(bs->ideal_viewangles[PITCH]);
|
|
bs->ideal_viewangles[YAW] += 8 * crandom() * (1 - aim_accuracy);
|
|
bs->ideal_viewangles[YAW] = AngleMod(bs->ideal_viewangles[YAW]);
|
|
//
|
|
if (InFieldOfVision(bs->viewangles, 20, bs->ideal_viewangles))
|
|
{// check in here to either call the alt_fire or not!! also, adjust the bots weapon... hackery?
|
|
if (bs->weaponnum > WP_NUM_WEAPONS) // it's an alt_fire!
|
|
{
|
|
bs->weaponnum -= WP_NUM_WEAPONS;
|
|
trap_EA_Alt_Attack(bs->client);
|
|
}
|
|
else
|
|
{
|
|
trap_EA_Attack(bs->client);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotEntityToActivate
|
|
==================
|
|
*/
|
|
//#define OBSTACLEDEBUG
|
|
|
|
int BotEntityToActivate(int entitynum) {
|
|
int i, ent, cur_entities[10];
|
|
char model[MAX_INFO_STRING], tmpmodel[128];
|
|
char target[128], classname[128];
|
|
float health;
|
|
char targetname[10][128];
|
|
aas_entityinfo_t entinfo;
|
|
|
|
BotEntityInfo(entitynum, &entinfo);
|
|
Com_sprintf(model, sizeof( model ), "*%d", entinfo.modelindex);
|
|
for (ent = trap_AAS_NextBSPEntity(0); ent; ent = trap_AAS_NextBSPEntity(ent)) {
|
|
if (!trap_AAS_ValueForBSPEpairKey(ent, "model", tmpmodel, sizeof(tmpmodel))) continue;
|
|
if (!strcmp(model, tmpmodel)) break;
|
|
}
|
|
if (!ent) {
|
|
BotAI_Print(PRT_ERROR, "BotEntityToActivate: no entity found with model %s\n", model);
|
|
return 0;
|
|
}
|
|
trap_AAS_ValueForBSPEpairKey(ent, "classname", classname, sizeof(classname));
|
|
if (!classname[0]) {
|
|
BotAI_Print(PRT_ERROR, "BotEntityToActivate: entity with model %s has no classname\n", model);
|
|
return 0;
|
|
}
|
|
//if it is a door
|
|
if (!strcmp(classname, "func_door")) {
|
|
if (trap_AAS_FloatForBSPEpairKey(ent, "health", &health)) {
|
|
//if health the door must be shot to open
|
|
if (health) return ent;
|
|
}
|
|
}
|
|
//get the targetname so we can find an entity with a matching target
|
|
if (!trap_AAS_ValueForBSPEpairKey(ent, "targetname", targetname[0], sizeof(targetname[0]))) {
|
|
#ifdef OBSTACLEDEBUG
|
|
BotAI_Print(PRT_ERROR, "BotEntityToActivate: entity with model \"%s\" has no targetname\n", model);
|
|
#endif //OBSTACLEDEBUG
|
|
return 0;
|
|
}
|
|
//only allows single activation chains, tree-like activation can be added back in
|
|
cur_entities[0] = trap_AAS_NextBSPEntity(0);
|
|
for (i = 0; i >= 0 && i < 10;) {
|
|
for (ent = cur_entities[i]; ent; ent = trap_AAS_NextBSPEntity(ent)) {
|
|
if (!trap_AAS_ValueForBSPEpairKey(ent, "target", target, sizeof(target))) continue;
|
|
if (!strcmp(targetname[i], target)) {
|
|
cur_entities[i] = trap_AAS_NextBSPEntity(ent);
|
|
break;
|
|
}
|
|
}
|
|
if (!ent) {
|
|
BotAI_Print(PRT_ERROR, "BotEntityToActivate: no entity with target \"%s\"\n", targetname[i]);
|
|
i--;
|
|
continue;
|
|
}
|
|
if (!trap_AAS_ValueForBSPEpairKey(ent, "classname", classname, sizeof(classname))) {
|
|
BotAI_Print(PRT_ERROR, "BotEntityToActivate: entity with target \"%s\" has no classname\n", targetname[i]);
|
|
continue;
|
|
}
|
|
if (!strcmp(classname, "func_button")) {
|
|
//BSP button model
|
|
return ent;
|
|
}
|
|
else if (!strcmp(classname, "trigger_multiple")) {
|
|
//invisible trigger multiple box
|
|
return ent;
|
|
}
|
|
else {
|
|
i--;
|
|
}
|
|
}
|
|
BotAI_Print(PRT_ERROR, "BotEntityToActivate: unknown activator with classname \"%s\"\n", classname);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotSetMovedir
|
|
==================
|
|
*/
|
|
vec3_t VEC_UP = {0, -1, 0};
|
|
vec3_t MOVEDIR_UP = {0, 0, 1};
|
|
vec3_t VEC_DOWN = {0, -2, 0};
|
|
vec3_t MOVEDIR_DOWN = {0, 0, -1};
|
|
|
|
void BotSetMovedir(vec3_t angles, vec3_t movedir) {
|
|
if (VectorCompare(angles, VEC_UP)) {
|
|
VectorCopy(MOVEDIR_UP, movedir);
|
|
}
|
|
else if (VectorCompare(angles, VEC_DOWN)) {
|
|
VectorCopy(MOVEDIR_DOWN, movedir);
|
|
}
|
|
else {
|
|
AngleVectors(angles, movedir, NULL, NULL);
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotModelMinsMaxs
|
|
|
|
this is ugly
|
|
==================
|
|
*/
|
|
void BotModelMinsMaxs(int modelindex, int eType, vec3_t mins, vec3_t maxs) {
|
|
gentity_t *ent;
|
|
int i;
|
|
|
|
ent = &g_entities[0];
|
|
for (i = 0; i < level.num_entities; i++, ent++) {
|
|
if ( !ent->inuse ) {
|
|
continue;
|
|
}
|
|
if ( ent->s.eType != eType) {
|
|
continue;
|
|
}
|
|
if (ent->s.modelindex == modelindex) {
|
|
VectorAdd(ent->r.currentOrigin, ent->r.mins, mins);
|
|
VectorAdd(ent->r.currentOrigin, ent->r.maxs, maxs);
|
|
return;
|
|
}
|
|
}
|
|
VectorClear(mins);
|
|
VectorClear(maxs);
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotAIBlocked
|
|
|
|
very basic handling of bots being blocked by other entities
|
|
check what kind of entity is blocking the bot and try to activate
|
|
it otherwise try to walk around the entity
|
|
before the bot ends in this part of the AI it should predict which doors to open,
|
|
which buttons to activate etc.
|
|
==================
|
|
*/
|
|
void BotAIBlocked(bot_state_t *bs, bot_moveresult_t *moveresult, int activate) {
|
|
int movetype, ent, i, areas[10], numareas, modelindex;
|
|
char classname[128], model[128];
|
|
float lip, dist, health, angle;
|
|
vec3_t hordir, size, start, end, mins, maxs, sideward, angles;
|
|
vec3_t movedir, origin, goalorigin, bboxmins, bboxmaxs;
|
|
vec3_t up = {0, 0, 1}, extramins = {1, 1, 1}, extramaxs = {-1, -1, -1};
|
|
aas_entityinfo_t entinfo;
|
|
//bsp_trace_t bsptrace;
|
|
#ifdef OBSTACLEDEBUG
|
|
char netname[MAX_NETNAME];
|
|
char buf[128];
|
|
#endif
|
|
|
|
if (!moveresult->blocked) {
|
|
bs->notblocked_time = trap_AAS_Time();
|
|
return;
|
|
}
|
|
//
|
|
BotEntityInfo(moveresult->blockentity, &entinfo);
|
|
#ifdef OBSTACLEDEBUG
|
|
ClientName(bs->client, netname, sizeof(netname));
|
|
BotAI_Print(PRT_MESSAGE, "%s: I'm blocked by model %d\n", netname, entinfo.modelindex);
|
|
#endif
|
|
//if blocked by a bsp model and the bot wants to activate it if possible
|
|
if (entinfo.modelindex > 0 && entinfo.modelindex <= max_bspmodelindex && activate) {
|
|
//find the bsp entity which should be activated in order to remove
|
|
//the blocking entity
|
|
ent = BotEntityToActivate(entinfo.number);
|
|
if (!ent) {
|
|
strcpy(classname, "");
|
|
#ifdef OBSTACLEDEBUG
|
|
BotAI_Print(PRT_MESSAGE, "%s: can't find activator for blocking entity\n", ClientName(bs->client, netname, sizeof(netname)));
|
|
#endif
|
|
}
|
|
else {
|
|
trap_AAS_ValueForBSPEpairKey(ent, "classname", classname, sizeof(classname));
|
|
#ifdef OBSTACLEDEBUG
|
|
ClientName(bs->client, netname, sizeof(netname));
|
|
BotAI_Print(PRT_MESSAGE, "%s: I should activate %s\n", netname, classname);
|
|
#endif
|
|
}
|
|
if (!strcmp(classname, "func_button")) {
|
|
//create a bot goal towards the button
|
|
trap_AAS_ValueForBSPEpairKey(ent, "model", model, sizeof(model));
|
|
modelindex = atoi(model+1);
|
|
//if the model is not loaded
|
|
if (!modelindex) return;
|
|
VectorClear(angles);
|
|
BotModelMinsMaxs(modelindex, ET_MOVER, mins, maxs);
|
|
//get the lip of the button
|
|
trap_AAS_FloatForBSPEpairKey(ent, "lip", &lip);
|
|
if (!lip) lip = 4;
|
|
//get the move direction from the angle
|
|
trap_AAS_FloatForBSPEpairKey(ent, "angle", &angle);
|
|
VectorSet(angles, 0, angle, 0);
|
|
BotSetMovedir(angles, movedir);
|
|
//button size
|
|
VectorSubtract(maxs, mins, size);
|
|
//button origin
|
|
VectorAdd(mins, maxs, origin);
|
|
VectorScale(origin, 0.5, origin);
|
|
//touch distance of the button
|
|
dist = fabs(movedir[0]) * size[0] + fabs(movedir[1]) * size[1] + fabs(movedir[2]) * size[2];
|
|
dist *= 0.5;
|
|
//
|
|
trap_AAS_FloatForBSPEpairKey(ent, "health", &health);
|
|
//if the button is shootable
|
|
if (health) {
|
|
//FIXME: walk to a point where the button is visible and shoot at the button
|
|
//calculate the goal origin
|
|
VectorMA(origin, -dist, movedir, goalorigin);
|
|
//
|
|
VectorSubtract(goalorigin, bs->origin, movedir);
|
|
vectoangles(movedir, moveresult->ideal_viewangles);
|
|
moveresult->flags |= MOVERESULT_MOVEMENTVIEW;
|
|
moveresult->flags |= MOVERESULT_MOVEMENTWEAPON;
|
|
//select the machinegun and shoot
|
|
trap_EA_SelectWeapon(bs->client, WEAPONINDEX_PHASER);
|
|
if (bs->cur_ps.weapon == WEAPONINDEX_PHASER) {
|
|
trap_EA_Attack(bs->client);
|
|
}
|
|
return;
|
|
}
|
|
else {
|
|
//add bounding box size to the dist
|
|
trap_AAS_PresenceTypeBoundingBox(PRESENCE_CROUCH, bboxmins, bboxmaxs);
|
|
for (i = 0; i < 3; i++) {
|
|
if (movedir[i] < 0) dist += fabs(movedir[i]) * fabs(bboxmaxs[i]);
|
|
else dist += fabs(movedir[i]) * fabs(bboxmins[i]);
|
|
}
|
|
//calculate the goal origin
|
|
VectorMA(origin, -dist, movedir, goalorigin);
|
|
//
|
|
VectorCopy(goalorigin, start);
|
|
start[2] += 24;
|
|
VectorCopy(start, end);
|
|
end[2] -= 100;
|
|
numareas = trap_AAS_TraceAreas(start, end, areas, NULL, 10);
|
|
//
|
|
for (i = 0; i < numareas; i++) {
|
|
if (trap_AAS_AreaReachability(areas[i])) {
|
|
break;
|
|
}
|
|
}
|
|
if (i < numareas) {
|
|
//
|
|
#ifdef OBSTACLEDEBUG
|
|
if (bs->activatemessage_time < trap_AAS_Time()) {
|
|
Com_sprintf(buf, sizeof(buf), "I have to activate a button at %1.1f %1.1f %1.1f in area %d\n",
|
|
goalorigin[0], goalorigin[1], goalorigin[2], areas[i]);
|
|
trap_EA_Say(bs->client, buf);
|
|
bs->activatemessage_time = trap_AAS_Time() + 5;
|
|
}
|
|
#endif //OBSTACLEDEBUG
|
|
//
|
|
VectorCopy(origin, bs->activategoal.origin);
|
|
bs->activategoal.areanum = areas[i];
|
|
VectorSubtract(mins, origin, bs->activategoal.mins);
|
|
VectorSubtract(maxs, origin, bs->activategoal.maxs);
|
|
//
|
|
for (i = 0; i < 3; i++)
|
|
{
|
|
if (movedir[i] < 0) bs->activategoal.maxs[i] += fabs(movedir[i]) * fabs(extramaxs[i]);
|
|
else bs->activategoal.mins[i] += fabs(movedir[i]) * fabs(extramins[i]);
|
|
} //end for
|
|
//
|
|
bs->activategoal.entitynum = entinfo.number;
|
|
bs->activategoal.number = 0;
|
|
bs->activategoal.flags = 0;
|
|
bs->activate_time = trap_AAS_Time() + 10;
|
|
AIEnter_Seek_ActivateEntity(bs);
|
|
return;
|
|
}
|
|
else {
|
|
#ifdef OBSTACLEDEBUG
|
|
if (!numareas) BotAI_Print(PRT_MESSAGE, "button not in an area\n");
|
|
else BotAI_Print(PRT_MESSAGE, "button area has no reachabilities\n");
|
|
#endif //OBSTACLEDEBUG
|
|
if (bs->ainode == AINode_Seek_NBG) bs->nbg_time = 0;
|
|
else if (bs->ainode == AINode_Seek_LTG) bs->ltg_time = 0;
|
|
}
|
|
}
|
|
}
|
|
else if (!strcmp(classname, "func_door")) {
|
|
//shoot at the shootable door
|
|
trap_AAS_ValueForBSPEpairKey(ent, "model", model, sizeof(model));
|
|
modelindex = atoi(model+1);
|
|
//if the model is not loaded
|
|
if (!modelindex) return;
|
|
VectorClear(angles);
|
|
BotModelMinsMaxs(modelindex, ET_MOVER, mins, maxs);
|
|
//door origin
|
|
VectorAdd(mins, maxs, origin);
|
|
VectorScale(origin, 0.5, origin);
|
|
//
|
|
VectorSubtract(origin, bs->eye, movedir);
|
|
vectoangles(movedir, moveresult->ideal_viewangles);
|
|
moveresult->flags |= MOVERESULT_MOVEMENTVIEW;
|
|
moveresult->flags |= MOVERESULT_MOVEMENTWEAPON;
|
|
//select the machinegun and shoot
|
|
trap_EA_SelectWeapon(bs->client, WEAPONINDEX_PHASER);
|
|
if (bs->cur_ps.weapon == WEAPONINDEX_PHASER) {
|
|
trap_EA_Attack(bs->client);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
//just some basic dynamic obstacle avoidance code
|
|
hordir[0] = moveresult->movedir[0];
|
|
hordir[1] = moveresult->movedir[1];
|
|
hordir[2] = 0;
|
|
//if no direction just take a random direction
|
|
if (VectorNormalize(hordir) < 0.1) {
|
|
VectorSet(angles, 0, 360 * random(), 0);
|
|
AngleVectors(angles, hordir, NULL, NULL);
|
|
}
|
|
//
|
|
//if (moveresult->flags & MOVERESULT_ONTOPOFOBSTACLE) movetype = MOVE_JUMP;
|
|
//else
|
|
movetype = MOVE_WALK;
|
|
//if there's an obstacle at the bot's feet and head then
|
|
//the bot might be able to crouch through
|
|
VectorCopy(bs->origin, start);
|
|
start[2] += 18;
|
|
VectorMA(start, 5, hordir, end);
|
|
VectorSet(mins, -16, -16, -24);
|
|
VectorSet(maxs, 16, 16, 4);
|
|
//
|
|
//bsptrace = AAS_Trace(start, mins, maxs, end, bs->entitynum, MASK_PLAYERSOLID);
|
|
//if (bsptrace.fraction >= 1) movetype = MOVE_CROUCH;
|
|
//get the sideward vector
|
|
CrossProduct(hordir, up, sideward);
|
|
//
|
|
if (bs->flags & BFL_AVOIDRIGHT) VectorNegate(sideward, sideward);
|
|
//try to crouch straight forward?
|
|
if (movetype != MOVE_CROUCH || !trap_BotMoveInDirection(bs->ms, hordir, 400, movetype)) {
|
|
//perform the movement
|
|
if (!trap_BotMoveInDirection(bs->ms, sideward, 400, movetype)) {
|
|
//flip the avoid direction flag
|
|
bs->flags ^= BFL_AVOIDRIGHT;
|
|
//flip the direction
|
|
VectorNegate(sideward, sideward);
|
|
//move in the other direction
|
|
trap_BotMoveInDirection(bs->ms, sideward, 400, movetype);
|
|
}
|
|
}
|
|
//
|
|
if (bs->notblocked_time < trap_AAS_Time() - 0.4) {
|
|
//just reset goals and hope the bot will go into another direction
|
|
//is this still needed??
|
|
if (bs->ainode == AINode_Seek_NBG) bs->nbg_time = 0;
|
|
else if (bs->ainode == AINode_Seek_LTG) bs->ltg_time = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotCheckConsoleMessages
|
|
==================
|
|
*/
|
|
void BotCheckConsoleMessages(bot_state_t *bs) {
|
|
char botname[MAX_NETNAME], message[MAX_MESSAGE_SIZE], netname[MAX_NETNAME], *ptr;
|
|
float chat_reply;
|
|
int context, handle;
|
|
bot_consolemessage_t m;
|
|
bot_match_t match;
|
|
|
|
//the name of this bot
|
|
ClientName(bs->client, botname, sizeof(botname));
|
|
//
|
|
while((handle = trap_BotNextConsoleMessage(bs->cs, &m)) != 0) {
|
|
//if the chat state is flooded with messages the bot will read them quickly
|
|
if (trap_BotNumConsoleMessages(bs->cs) < 10) {
|
|
//if it is a chat message the bot needs some time to read it
|
|
if (m.type == CMS_CHAT && m.time > trap_AAS_Time() - (1 + random())) break;
|
|
}
|
|
//
|
|
ptr = m.message;
|
|
//if it is a chat message then don't unify white spaces and don't
|
|
//replace synonyms in the netname
|
|
if (m.type == CMS_CHAT) {
|
|
//
|
|
if (trap_BotFindMatch(m.message, &match, MTCONTEXT_REPLYCHAT)) {
|
|
ptr = m.message + match.variables[MESSAGE].offset;
|
|
}
|
|
}
|
|
//unify the white spaces in the message
|
|
trap_UnifyWhiteSpaces(ptr);
|
|
//replace synonyms in the right context
|
|
context = CONTEXT_NORMAL|CONTEXT_NEARBYITEM|CONTEXT_NAMES;
|
|
if (BotCTFTeam(bs) == CTF_TEAM_RED) context |= CONTEXT_CTFREDTEAM;
|
|
else context |= CONTEXT_CTFBLUETEAM;
|
|
trap_BotReplaceSynonyms(ptr, context);
|
|
//if there's no match
|
|
if (!BotMatchMessage(bs, m.message)) {
|
|
//if it is a chat message
|
|
if (m.type == CMS_CHAT && !bot_nochat.integer) {
|
|
//
|
|
if (!trap_BotFindMatch(m.message, &match, MTCONTEXT_REPLYCHAT)) {
|
|
trap_BotRemoveConsoleMessage(bs->cs, handle);
|
|
continue;
|
|
}
|
|
//don't use eliza chats with team messages
|
|
if (match.subtype & ST_TEAM) {
|
|
trap_BotRemoveConsoleMessage(bs->cs, handle);
|
|
continue;
|
|
}
|
|
//
|
|
trap_BotMatchVariable(&match, NETNAME, netname, sizeof(netname));
|
|
trap_BotMatchVariable(&match, MESSAGE, message, sizeof(message));
|
|
//if this is a message from the bot self
|
|
if (!Q_stricmp(netname, botname)) {
|
|
trap_BotRemoveConsoleMessage(bs->cs, handle);
|
|
continue;
|
|
}
|
|
//unify the message
|
|
trap_UnifyWhiteSpaces(message);
|
|
//
|
|
trap_Cvar_Update(&bot_testrchat);
|
|
if (bot_testrchat.integer) {
|
|
//
|
|
trap_BotLibVarSet("bot_testrchat", "1");
|
|
//if bot replies with a chat message
|
|
if (trap_BotReplyChat(bs->cs, message, context, CONTEXT_REPLY,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
botname, netname)) {
|
|
BotAI_Print(PRT_MESSAGE, "------------------------\n");
|
|
}
|
|
else {
|
|
BotAI_Print(PRT_MESSAGE, "**** no valid reply ****\n");
|
|
}
|
|
}
|
|
//if at a valid chat position and not chatting already
|
|
else if (bs->ainode != AINode_Stand && BotValidChatPosition(bs)) {
|
|
chat_reply = 0;
|
|
if (random() < 1.5 / (NumBots()+1) && random() < chat_reply) {
|
|
//if bot replies with a chat message
|
|
if (trap_BotReplyChat(bs->cs, message, context, CONTEXT_REPLY,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
NULL, NULL,
|
|
botname, netname)) {
|
|
//remove the console message
|
|
trap_BotRemoveConsoleMessage(bs->cs, handle);
|
|
bs->stand_time = trap_AAS_Time() + BotChatTime(bs);
|
|
AIEnter_Stand(bs);
|
|
//EA_Say(bs->client, bs->cs.chatmessage);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//remove the console message
|
|
trap_BotRemoveConsoleMessage(bs->cs, handle);
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotCheckEvents
|
|
==================
|
|
*/
|
|
void BotCheckEvents(bot_state_t *bs, entityState_t *state) {
|
|
int event;
|
|
char buf[128];
|
|
//
|
|
//NOTE: this sucks, we're accessing the gentity_t directly
|
|
//but there's no other fast way to do it right now
|
|
if (bs->entityeventTime[state->number] == g_entities[state->number].eventTime) {
|
|
return;
|
|
}
|
|
bs->entityeventTime[state->number] = g_entities[state->number].eventTime;
|
|
//if it's an event only entity
|
|
if (state->eType > ET_EVENTS) {
|
|
event = (state->eType - ET_EVENTS) & ~EV_EVENT_BITS;
|
|
}
|
|
else {
|
|
event = state->event & ~EV_EVENT_BITS;
|
|
}
|
|
//
|
|
switch(event) {
|
|
//client obituary event
|
|
case EV_OBITUARY:
|
|
{
|
|
int target, attacker, mod;
|
|
|
|
target = state->otherEntityNum;
|
|
attacker = state->otherEntityNum2;
|
|
mod = state->eventParm;
|
|
//
|
|
if (target == bs->client) {
|
|
bs->botdeathtype = mod;
|
|
bs->lastkilledby = attacker;
|
|
//
|
|
if (target == attacker) bs->botsuicide = qtrue;
|
|
else bs->botsuicide = qfalse;
|
|
//
|
|
bs->num_deaths++;
|
|
}
|
|
//else if this client was killed by the bot
|
|
else if (attacker == bs->client) {
|
|
bs->enemydeathtype = mod;
|
|
bs->lastkilledplayer = target;
|
|
bs->killedenemy_time = trap_AAS_Time();
|
|
//
|
|
bs->num_kills++;
|
|
}
|
|
else if (attacker == bs->enemy && target == attacker) {
|
|
bs->enemysuicide = qtrue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case EV_GLOBAL_SOUND:
|
|
{
|
|
if (state->eventParm < 0 || state->eventParm > MAX_SOUNDS) {
|
|
BotAI_Print(PRT_ERROR, "EV_GLOBAL_SOUND: eventParm (%d) out of range\n", state->eventParm);
|
|
break;
|
|
}
|
|
else {
|
|
trap_GetConfigstring(CS_SOUNDS + state->eventParm, buf, sizeof(buf));
|
|
if (!strcmp(buf, "sound/items/poweruprespawn.wav")) {
|
|
//powerup respawned... go get it
|
|
BotGoForPowerups(bs);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case EV_TEAM_SOUND:
|
|
{
|
|
if (state->eventParm < 0 || state->eventParm > MAX_TEAM_SOUNDS) {
|
|
BotAI_Print(PRT_ERROR, "EV_TEAM_SOUND: eventParm (%d) out of range\n", state->eventParm);
|
|
break;
|
|
}
|
|
|
|
if (state->eventParm == RETURN_FLAG_SOUND)
|
|
{
|
|
if (state->otherEntityNum == TEAM_RED)
|
|
{
|
|
//red flag is returned
|
|
bs->redflagstatus = 0;
|
|
bs->flagstatuschanged = qtrue;
|
|
}
|
|
else
|
|
{
|
|
//blue flag is returned
|
|
bs->blueflagstatus = 0;
|
|
bs->flagstatuschanged = qtrue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
case EV_PLAYER_TELEPORT_IN:
|
|
{
|
|
VectorCopy(state->origin, lastteleport_origin);
|
|
lastteleport_time = trap_AAS_Time();
|
|
break;
|
|
}
|
|
case EV_GENERAL_SOUND:
|
|
{
|
|
//if this sound is played on the bot
|
|
if (state->number == bs->client) {
|
|
if (state->eventParm < 0 || state->eventParm > MAX_SOUNDS) {
|
|
BotAI_Print(PRT_ERROR, "EV_GENERAL_SOUND: eventParm (%d) out of range\n", state->eventParm);
|
|
break;
|
|
}
|
|
//check out the sound
|
|
trap_GetConfigstring(CS_SOUNDS + state->eventParm, buf, sizeof(buf));
|
|
//if falling into a death pit
|
|
if (!strcmp(buf, "*falling1.wav")) {
|
|
//if the bot has a personal teleporter
|
|
if (bs->inventory[INVENTORY_TRANSPORTER] > 0) {
|
|
//use the holdable item
|
|
trap_EA_Use(bs->client);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotCheckSnapshot
|
|
==================
|
|
*/
|
|
void BotCheckSnapshot(bot_state_t *bs) {
|
|
int ent;
|
|
entityState_t state;
|
|
|
|
//
|
|
ent = 0;
|
|
while( ( ent = BotAI_GetSnapshotEntity( bs->client, ent, &state ) ) != -1 ) {
|
|
//check the entity state for events
|
|
BotCheckEvents(bs, &state);
|
|
}
|
|
//check the player state for events
|
|
BotAI_GetEntityState(bs->client, &state);
|
|
//copy the player state events to the entity state
|
|
state.event = bs->cur_ps.externalEvent;
|
|
state.eventParm = bs->cur_ps.externalEventParm;
|
|
//
|
|
BotCheckEvents(bs, &state);
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotCheckAir
|
|
==================
|
|
*/
|
|
void BotCheckAir(bot_state_t *bs) {
|
|
if (bs->inventory[INVENTORY_ENVIRONMENTSUIT] <= 0) {
|
|
if (trap_AAS_PointContents(bs->eye) & (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA)) {
|
|
return;
|
|
}
|
|
}
|
|
bs->lastair_time = trap_AAS_Time();
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotDeathmatchAI
|
|
==================
|
|
*/
|
|
void BotDeathmatchAI(bot_state_t *bs, float thinktime) {
|
|
char gender[144], name[144], buf[144];
|
|
char userinfo[MAX_INFO_STRING];
|
|
int i;
|
|
|
|
//if the bot has just been setup
|
|
if (bs->setupcount > 0) {
|
|
bs->setupcount--;
|
|
if (bs->setupcount > 0) return;
|
|
//get the gender characteristic
|
|
trap_Characteristic_String(bs->character, CHARACTERISTIC_GENDER, gender, sizeof(gender));
|
|
//set the bot gender
|
|
trap_GetUserinfo(bs->client, userinfo, sizeof(userinfo));
|
|
Info_SetValueForKey(userinfo, "sex", gender);
|
|
trap_SetUserinfo(bs->client, userinfo);
|
|
//set the team
|
|
if ( g_gametype.integer != GT_TOURNAMENT ) {
|
|
Com_sprintf(buf, sizeof(buf), "team %s", bs->settings.team);
|
|
trap_EA_Command(bs->client, buf);
|
|
}
|
|
if ( g_pModSpecialties.integer ) {
|
|
Com_sprintf(buf, sizeof(buf), "class %s", bs->settings.pclass);
|
|
trap_EA_Command(bs->client, buf);
|
|
}
|
|
//set the chat gender
|
|
if (gender[0] == 'm') trap_BotSetChatGender(bs->cs, CHAT_GENDERMALE);
|
|
else if (gender[0] == 'f') trap_BotSetChatGender(bs->cs, CHAT_GENDERFEMALE);
|
|
else trap_BotSetChatGender(bs->cs, CHAT_GENDERLESS);
|
|
//set the chat name
|
|
ClientName(bs->client, name, sizeof(name));
|
|
trap_BotSetChatName(bs->cs, name);
|
|
//
|
|
bs->lastframe_health = bs->inventory[INVENTORY_HEALTH];
|
|
bs->lasthitcount = bs->cur_ps.persistant[PERS_HITS];
|
|
//
|
|
bs->setupcount = 0;
|
|
}
|
|
//no ideal view set
|
|
bs->flags &= ~BFL_IDEALVIEWSET;
|
|
//set the teleport time
|
|
BotSetTeleportTime(bs);
|
|
//update some inventory values
|
|
BotUpdateInventory(bs);
|
|
//check the console messages
|
|
BotCheckConsoleMessages(bs);
|
|
//check out the snapshot
|
|
BotCheckSnapshot(bs);
|
|
//check for air
|
|
BotCheckAir(bs);
|
|
//if not in the intermission and not in observer mode
|
|
if (!BotIntermission(bs) && !BotIsObserver(bs)) {
|
|
//do team AI
|
|
BotTeamAI(bs);
|
|
}
|
|
//if the bot has no ai node
|
|
if (!bs->ainode) {
|
|
AIEnter_Seek_LTG(bs);
|
|
}
|
|
//if the bot entered the game less than 8 seconds ago
|
|
if (!bs->entergamechat && bs->entergame_time > trap_AAS_Time() - 8) {
|
|
if (BotChat_EnterGame(bs)) {
|
|
bs->stand_time = trap_AAS_Time() + BotChatTime(bs);
|
|
AIEnter_Stand(bs);
|
|
}
|
|
bs->entergamechat = qtrue;
|
|
}
|
|
//reset the node switches from the previous frame
|
|
BotResetNodeSwitches();
|
|
//execute AI nodes
|
|
for (i = 0; i < MAX_NODESWITCHES; i++) {
|
|
if (bs->ainode(bs)) break;
|
|
}
|
|
//if the bot removed itself :)
|
|
if (!bs->inuse) return;
|
|
//if the bot executed too many AI nodes
|
|
if (i >= MAX_NODESWITCHES) {
|
|
trap_BotDumpGoalStack(bs->gs);
|
|
trap_BotDumpAvoidGoals(bs->gs);
|
|
BotDumpNodeSwitches(bs);
|
|
ClientName(bs->client, name, sizeof(name));
|
|
BotAI_Print(PRT_ERROR, "%s at %1.1f switched more than %d AI nodes\n", name, trap_AAS_Time(), MAX_NODESWITCHES);
|
|
}
|
|
//
|
|
bs->lastframe_health = bs->inventory[INVENTORY_HEALTH];
|
|
bs->lasthitcount = bs->cur_ps.persistant[PERS_HITS];
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotSetupDeathmatchAI
|
|
==================
|
|
*/
|
|
void BotSetupDeathmatchAI(void) {
|
|
int ent, modelnum;
|
|
char model[128];
|
|
|
|
gametype = trap_Cvar_VariableIntegerValue("g_gametype");
|
|
maxclients = trap_Cvar_VariableIntegerValue("sv_maxclients");
|
|
|
|
trap_Cvar_Register(&bot_rocketjump, "bot_rocketjump", "1", 0);
|
|
trap_Cvar_Register(&bot_grapple, "bot_grapple", "0", 0);
|
|
trap_Cvar_Register(&bot_fastchat, "bot_fastchat", "0", 0);
|
|
trap_Cvar_Register(&bot_nochat, "bot_nochat", "0", 0);
|
|
trap_Cvar_Register(&bot_testrchat, "bot_testrchat", "0", 0);
|
|
trap_Cvar_Register(&bot_challenge, "bot_challenge", "0", 0);
|
|
//
|
|
if (gametype == GT_CTF) {
|
|
if (trap_BotGetLevelItemGoal(-1, "Red Flag", &ctf_redflag) < 0)
|
|
BotAI_Print(PRT_WARNING, "CTF without Red Flag\n");
|
|
if (trap_BotGetLevelItemGoal(-1, "Blue Flag", &ctf_blueflag) < 0)
|
|
BotAI_Print(PRT_WARNING, "CTF without Blue Flag\n");
|
|
}
|
|
|
|
max_bspmodelindex = 0;
|
|
for (ent = trap_AAS_NextBSPEntity(0); ent; ent = trap_AAS_NextBSPEntity(ent)) {
|
|
if (!trap_AAS_ValueForBSPEpairKey(ent, "model", model, sizeof(model))) continue;
|
|
if (model[0] == '*') {
|
|
modelnum = atoi(model+1);
|
|
if (modelnum > max_bspmodelindex)
|
|
max_bspmodelindex = modelnum;
|
|
}
|
|
}
|
|
//initialize the waypoint heap
|
|
BotInitWaypoints();
|
|
}
|
|
|
|
/*
|
|
==================
|
|
BotShutdownDeathmatchAI
|
|
==================
|
|
*/
|
|
void BotShutdownDeathmatchAI(void) {
|
|
}
|
|
|