codemp/game/ai_main.c File Reference

#include "g_local.h"
#include "q_shared.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 "w_saber.h"
#include "chars.h"
#include "inv.h"
#include "syn.h"

Go to the source code of this file.

Defines
#define	MAX_PATH   144
#define	BOT_THINK_TIME   0
#define	BOT_STRAFE_AVOIDANCE
#define	STRAFEAROUND_RIGHT   1
#define	STRAFEAROUND_LEFT   2
Functions
void	BotStraightTPOrderCheck (gentity_t *ent, int ordernum, bot_state_t *bs)
void	BotSelectWeapon (int client, int weapon)
void	BotReportStatus (bot_state_t *bs)
void	BotOrder (gentity_t *ent, int clientnum, int ordernum)
int	BotMindTricked (int botClient, int enemyClient)
int	BotGetWeaponRange (bot_state_t *bs)
int	PassLovedOneCheck (bot_state_t *bs, gentity_t *ent)
void	ExitLevel (void)
void QDECL	BotAI_Print (int type, char *fmt,...)
qboolean	WP_ForcePowerUsable (gentity_t *self, forcePowers_t forcePower)
int	IsTeamplay (void)
int	BotAI_GetClientState (int clientNum, playerState_t *state)
int	BotAI_GetEntityState (int entityNum, entityState_t *state)
int	BotAI_GetSnapshotEntity (int clientNum, int sequence, entityState_t *state)
void	BotEntityInfo (int entnum, aas_entityinfo_t *info)
int	NumBots (void)
float	AngleDifference (float ang1, float ang2)
float	BotChangeViewAngle (float angle, float ideal_angle, float speed)
void	BotChangeViewAngles (bot_state_t *bs, float thinktime)
void	BotInputToUserCommand (bot_input_t *bi, usercmd_t *ucmd, int delta_angles[3], int time, int useTime)
void	BotUpdateInput (bot_state_t *bs, int time, int elapsed_time)
void	BotAIRegularUpdate (void)
void	RemoveColorEscapeSequences (char *text)
int	BotAI (int client, float thinktime)
void	BotScheduleBotThink (void)
int	PlayersInGame (void)
int	BotAISetupClient (int client, struct bot_settings_s *settings, qboolean restart)
int	BotAIShutdownClient (int client, qboolean restart)
void	BotResetState (bot_state_t *bs)
int	BotAILoadMap (int restart)
int	OrgVisible (vec3_t org1, vec3_t org2, int ignore)
int	WPOrgVisible (gentity_t *bot, vec3_t org1, vec3_t org2, int ignore)
int	OrgVisibleBox (vec3_t org1, vec3_t mins, vec3_t maxs, vec3_t org2, int ignore)
int	CheckForFunc (vec3_t org, int ignore)
qboolean	BotPVSCheck (const vec3_t p1, const vec3_t p2)
int	GetNearestVisibleWP (vec3_t org, int ignore)
int	PassWayCheck (bot_state_t *bs, int windex)
float	TotalTrailDistance (int start, int end, bot_state_t *bs)
void	CheckForShorterRoutes (bot_state_t *bs, int newwpindex)
void	WPConstantRoutine (bot_state_t *bs)
qboolean	BotCTFGuardDuty (bot_state_t *bs)
void	WPTouchRoutine (bot_state_t *bs)
void	MoveTowardIdealAngles (bot_state_t *bs)
int	BotTrace_Strafe (bot_state_t *bs, vec3_t traceto)
int	BotTrace_Jump (bot_state_t *bs, vec3_t traceto)
int	BotTrace_Duck (bot_state_t *bs, vec3_t traceto)
int	PassStandardEnemyChecks (bot_state_t *bs, gentity_t *en)
void	BotDamageNotification (gclient_t *bot, gentity_t *attacker)
int	BotCanHear (bot_state_t *bs, gentity_t *en, float endist)
void	UpdateEventTracker (void)
int	InFieldOfVision (vec3_t viewangles, float fov, vec3_t angles)
qboolean	G_ThereIsAMaster (void)
int	ScanForEnemies (bot_state_t *bs)
int	WaitingForNow (bot_state_t *bs, vec3_t goalpos)
int	BotIsAChickenWuss (bot_state_t *bs)
gentity_t *	GetNearestBadThing (bot_state_t *bs)
int	BotDefendFlag (bot_state_t *bs)
int	BotGetEnemyFlag (bot_state_t *bs)
int	BotGetFlagBack (bot_state_t *bs)
int	BotGuardFlagCarrier (bot_state_t *bs)
int	BotGetFlagHome (bot_state_t *bs)
void	GetNewFlagPoint (wpobject_t *wp, gentity_t *flagEnt, int team)
int	CTFTakesPriority (bot_state_t *bs)
int	EntityVisibleBox (vec3_t org1, vec3_t mins, vec3_t maxs, vec3_t org2, int ignore, int ignore2)
int	Siege_TargetClosestObjective (bot_state_t *bs, int flag)
void	Siege_DefendFromAttackers (bot_state_t *bs)
int	Siege_CountDefenders (bot_state_t *bs)
int	Siege_CountTeammates (bot_state_t *bs)
int	SiegeTakesPriority (bot_state_t *bs)
int	JMTakesPriority (bot_state_t *bs)
int	BotHasAssociated (bot_state_t *bs, wpobject_t *wp)
int	GetBestIdleGoal (bot_state_t *bs)
void	GetIdealDestination (bot_state_t *bs)
void	CommanderBotCTFAI (bot_state_t *bs)
void	CommanderBotSiegeAI (bot_state_t *bs)
void	BotDoTeamplayAI (bot_state_t *bs)
void	CommanderBotTeamplayAI (bot_state_t *bs)
void	CommanderBotAI (bot_state_t *bs)
void	MeleeCombatHandling (bot_state_t *bs)
void	SaberCombatHandling (bot_state_t *bs)
float	BotWeaponCanLead (bot_state_t *bs)
void	BotAimLeading (bot_state_t *bs, vec3_t headlevel, float leadAmount)
void	BotAimOffsetGoalAngles (bot_state_t *bs)
int	ShouldSecondaryFire (bot_state_t *bs)
int	CombatBotAI (bot_state_t *bs, float thinktime)
int	BotFallbackNavigation (bot_state_t *bs)
int	BotTryAnotherWeapon (bot_state_t *bs)
qboolean	BotWeaponSelectable (bot_state_t *bs, int weapon)
int	BotSelectIdealWeapon (bot_state_t *bs)
int	BotSelectChoiceWeapon (bot_state_t *bs, int weapon, int doselection)
int	BotSelectMelee (bot_state_t *bs)
int	GetLoveLevel (bot_state_t *bs, bot_state_t *love)
void	BotLovedOneDied (bot_state_t *bs, bot_state_t *loved, int lovelevel)
void	BotDeathNotify (bot_state_t *bs)
void	StrafeTracing (bot_state_t *bs)
int	PrimFiring (bot_state_t *bs)
int	KeepPrimFromFiring (bot_state_t *bs)
int	AltFiring (bot_state_t *bs)
int	KeepAltFromFiring (bot_state_t *bs)
gentity_t *	CheckForFriendInLOF (bot_state_t *bs)
void	BotScanForLeader (bot_state_t *bs)
void	BotReplyGreetings (bot_state_t *bs)
void	CTFFlagMovement (bot_state_t *bs)
void	BotCheckDetPacks (bot_state_t *bs)
int	BotUseInventoryItem (bot_state_t *bs)
int	BotSurfaceNear (bot_state_t *bs)
int	BotWeaponBlockable (int weapon)
void	Cmd_EngageDuel_f (gentity_t *ent)
void	Cmd_ToggleSaber_f (gentity_t *ent)
void	Bot_SetForcedMovement (int bot, int forward, int right, int up)
void	StandardBotAI (bot_state_t *bs, float thinktime)
int	BotAIStartFrame (int time)
int	BotAISetup (int restart)
int	BotAIShutdown (int restart)
Variables
bot_state_t *	botstates [MAX_CLIENTS]
int	numbots
float	floattime
float	regularupdate_time
int	rebel_attackers
int	imperial_attackers
boteventtracker_t	gBotEventTracker [MAX_CLIENTS]
vmCvar_t	bot_forcepowers
vmCvar_t	bot_forgimmick
vmCvar_t	bot_honorableduelacceptance
vmCvar_t	bot_pvstype
vmCvar_t	bot_normgpath
vmCvar_t	bot_getinthecarrr
vmCvar_t	bot_attachments
vmCvar_t	bot_camp
vmCvar_t	bot_wp_info
vmCvar_t	bot_wp_edit
vmCvar_t	bot_wp_clearweight
vmCvar_t	bot_wp_distconnect
vmCvar_t	bot_wp_visconnect
wpobject_t *	flagRed
wpobject_t *	oFlagRed
wpobject_t *	flagBlue
wpobject_t *	oFlagBlue
gentity_t *	eFlagRed
gentity_t *	droppedRedFlag
gentity_t *	eFlagBlue
gentity_t *	droppedBlueFlag
char *	ctfStateNames []
char *	ctfStateDescriptions []
char *	siegeStateDescriptions []
char *	teamplayStateDescriptions []
int	gUpdateVars = 0

---

Define Documentation

#define BOT_STRAFE_AVOIDANCE

Definition at line 1548 of file ai_main.c.

#define BOT_THINK_TIME   0

Definition at line 43 of file ai_main.c. Referenced by BotAIStartFrame(), and BotScheduleBotThink().

#define MAX_PATH   144

Definition at line 41 of file ai_main.c.

#define STRAFEAROUND_LEFT   2

Definition at line 1552 of file ai_main.c. Referenced by BotTrace_Strafe(), and StandardBotAI().

#define STRAFEAROUND_RIGHT   1

Definition at line 1551 of file ai_main.c. Referenced by BotTrace_Strafe(), and StandardBotAI().

---

Function Documentation

int AltFiring (  bot_state_t *  bs  )

Definition at line 5502 of file ai_main.c. References bot_state_t, bot_state_s::cur_ps, bot_state_s::doAltAttack, WEAPON_CHARGING_ALT, and playerState_s::weaponstate. Referenced by StandardBotAI(). { if (bs->cur_ps.weaponstate != WEAPON_CHARGING_ALT && bs->doAltAttack) { return 1; } if (bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT && !bs->doAltAttack) { return 1; } return 0; }

float AngleDifference (  float  ang1, float  ang2 )

Definition at line 425 of file ai_main.c. Referenced by BotChangeViewAngles(), and BotTrace_Strafe(). { float diff; diff = ang1 - ang2; if (ang1 > ang2) { if (diff > 180.0) diff -= 360.0; } else { if (diff < -180.0) diff += 360.0; } return diff; }

void Bot_SetForcedMovement (  int  bot, int  forward, int  right, int  up )

Definition at line 5883 of file ai_main.c. References bot_state_t, botstates, bot_state_s::forceMove_Forward, bot_state_s::forceMove_Right, and bot_state_s::forceMove_Up. Referenced by ClientCommand(). { bot_state_t *bs; bs = botstates[bot]; if (!bs) { //not a bot return; } if (forward != -1) { if (bs->forceMove_Forward) { bs->forceMove_Forward = 0; } else { bs->forceMove_Forward = forward; } } if (right != -1) { if (bs->forceMove_Right) { bs->forceMove_Right = 0; } else { bs->forceMove_Right = right; } } if (up != -1) { if (bs->forceMove_Up) { bs->forceMove_Up = 0; } else { bs->forceMove_Up = up; } } }

int BotAI (  int  client, float  thinktime )

Definition at line 696 of file ai_main.c. References AngleMod(), bot_state_t, BotAI_GetClientState(), BotAI_Print(), botstates, client, Com_Printf(), bot_state_s::cur_ps, playerState_s::delta_angles, bot_state_s::eye, vmCvar_t::integer, bot_state_s::inuse, bot_state_s::ltime, bot_state_s::origin, playerState_s::origin, PRT_FATAL, Q_stricmp(), qfalse, qtrue, RemoveColorEscapeSequences(), SHORT2ANGLE, StandardBotAI(), strchr(), bot_state_s::thinktime, trap_BotGetServerCommand(), trap_Cvar_Update(), trap_EA_ResetInput(), trap_Milliseconds(), VectorCopy, bot_state_s::viewangles, and playerState_s::viewheight. Referenced by BotAIStartFrame(). { bot_state_t *bs; char buf[1024], *args; int j; #ifdef _DEBUG int start = 0; int end = 0; #endif trap_EA_ResetInput(client); // bs = botstates[client]; if (!bs || !bs->inuse) { BotAI_Print(PRT_FATAL, "BotAI: client %d is not setup\n", client); return qfalse; } //retrieve the current client state BotAI_GetClientState( client, &bs->cur_ps ); //retrieve any waiting server commands while( trap_BotGetServerCommand(client, buf, sizeof(buf)) ) { //have buf point to the command and args to the command arguments args = strchr( buf, ' '); if (!args) continue; *args++ = '\0'; //remove color espace sequences from the arguments RemoveColorEscapeSequences( args ); if (!Q_stricmp(buf, "cp ")) { /*CenterPrintf*/ } else if (!Q_stricmp(buf, "cs")) { /*ConfigStringModified*/ } else if (!Q_stricmp(buf, "scores")) { /*FIXME: parse scores?*/ } else if (!Q_stricmp(buf, "clientLevelShot")) { /*ignore*/ } } //add the delta angles to the bot's current view angles for (j = 0; j < 3; j++) { bs->viewangles[j] = AngleMod(bs->viewangles[j] + SHORT2ANGLE(bs->cur_ps.delta_angles[j])); } //increase the local time of the bot bs->ltime += thinktime; // bs->thinktime = thinktime; //origin of the bot VectorCopy(bs->cur_ps.origin, bs->origin); //eye coordinates of the bot VectorCopy(bs->cur_ps.origin, bs->eye); bs->eye[2] += bs->cur_ps.viewheight; //get the area the bot is in #ifdef _DEBUG start = trap_Milliseconds(); #endif StandardBotAI(bs, thinktime); #ifdef _DEBUG end = trap_Milliseconds(); trap_Cvar_Update(&bot_debugmessages); if (bot_debugmessages.integer) { Com_Printf("Single AI frametime: %i\n", (end - start)); } #endif //subtract the delta angles for (j = 0; j < 3; j++) { bs->viewangles[j] = AngleMod(bs->viewangles[j] - SHORT2ANGLE(bs->cur_ps.delta_angles[j])); } //everything was ok return qtrue; }

int BotAI_GetClientState (  int  clientNum, playerState_t *  state )

Definition at line 351 of file ai_main.c. References gentity_s::client, g_entities, gentity_t, gentity_s::inuse, memcpy(), playerState_t, gclient_s::ps, qfalse, and qtrue. Referenced by BotAI(). { gentity_t *ent; ent = &g_entities[clientNum]; if ( !ent->inuse ) { return qfalse; } if ( !ent->client ) { return qfalse; } memcpy( state, &ent->client->ps, sizeof(playerState_t) ); return qtrue; }

int BotAI_GetEntityState (  int  entityNum, entityState_t *  state )

Definition at line 371 of file ai_main.c. References entityState_t, g_entities, gentity_t, gentity_s::inuse, entityShared_t::linked, memcpy(), memset(), qfalse, qtrue, gentity_s::r, gentity_s::s, SVF_NOCLIENT, and entityShared_t::svFlags. Referenced by BotAI_GetSnapshotEntity(). { gentity_t *ent; ent = &g_entities[entityNum]; memset( state, 0, sizeof(entityState_t) ); if (!ent->inuse) return qfalse; if (!ent->r.linked) return qfalse; if (ent->r.svFlags & SVF_NOCLIENT) return qfalse; memcpy( state, &ent->s, sizeof(entityState_t) ); return qtrue; }

int BotAI_GetSnapshotEntity (  int  clientNum, int  sequence, entityState_t *  state )

Definition at line 388 of file ai_main.c. References BotAI_GetEntityState(), entityState_t, memset(), and trap_BotGetSnapshotEntity(). { int entNum; entNum = trap_BotGetSnapshotEntity( clientNum, sequence ); if ( entNum == -1 ) { memset(state, 0, sizeof(entityState_t)); return -1; } BotAI_GetEntityState( entNum, state ); return sequence + 1; }

void QDECL BotAI_Print (  int  type, char *  fmt, ...  )

Definition at line 332 of file ai_main.c. References QDECL. Referenced by BotAI(), and BotAISetupClient(). { return; }

int BotAILoadMap (  int  restart  )

Definition at line 966 of file ai_main.c. References BotResetState(), botstates, bot_state_s::inuse, MAX_CLIENTS, qtrue, and bot_state_s::setupcount. Referenced by G_InitGame(). { int i; for (i = 0; i < MAX_CLIENTS; i++) { if (botstates[i] && botstates[i]->inuse) { BotResetState( botstates[i] ); botstates[i]->setupcount = 4; } } return qtrue; }

void BotAimLeading (  bot_state_t *  bs, vec3_t  headlevel, float  leadAmount )

Definition at line 4607 of file ai_main.c. References bot_state_t, gentity_s::client, bot_state_s::currentEnemy, bot_state_s::eye, bot_state_s::frame_Enemy_Len, bot_state_s::goalAngles, gclient_s::ps, vec3_t, vectoangles(), VectorCopy, VectorNormalize(), VectorSubtract, and playerState_s::velocity. Referenced by StandardBotAI(). { int x; vec3_t predictedSpot; vec3_t movementVector; vec3_t a, ang; float vtotal; if (!bs->currentEnemy || !bs->currentEnemy->client) { return; } if (!bs->frame_Enemy_Len) { return; } vtotal = 0; if (bs->currentEnemy->client->ps.velocity[0] < 0) { vtotal += -bs->currentEnemy->client->ps.velocity[0]; } else { vtotal += bs->currentEnemy->client->ps.velocity[0]; } if (bs->currentEnemy->client->ps.velocity[1] < 0) { vtotal += -bs->currentEnemy->client->ps.velocity[1]; } else { vtotal += bs->currentEnemy->client->ps.velocity[1]; } if (bs->currentEnemy->client->ps.velocity[2] < 0) { vtotal += -bs->currentEnemy->client->ps.velocity[2]; } else { vtotal += bs->currentEnemy->client->ps.velocity[2]; } //G_Printf("Leadin target with a velocity total of %f\n", vtotal); VectorCopy(bs->currentEnemy->client->ps.velocity, movementVector); VectorNormalize(movementVector); x = bs->frame_Enemy_Len*leadAmount; //hardly calculated with an exact science, but it works if (vtotal > 400) { vtotal = 400; } if (vtotal) { x = (bs->frame_Enemy_Len*0.9)*leadAmount*(vtotal*0.0012); //hardly calculated with an exact science, but it works } else { x = (bs->frame_Enemy_Len*0.9)*leadAmount; //hardly calculated with an exact science, but it works } predictedSpot[0] = headlevel[0] + (movementVector[0]*x); predictedSpot[1] = headlevel[1] + (movementVector[1]*x); predictedSpot[2] = headlevel[2] + (movementVector[2]*x); VectorSubtract(predictedSpot, bs->eye, a); vectoangles(a, ang); VectorCopy(ang, bs->goalAngles); }

void BotAimOffsetGoalAngles (  bot_state_t *  bs  )

Definition at line 4687 of file ai_main.c. References botskills_s::accuracy, bot_state_s::aimOffsetAmtPitch, bot_state_s::aimOffsetAmtYaw, bot_state_s::aimOffsetTime, bot_state_t, BotMindTricked(), bot_state_s::client, bot_state_s::currentEnemy, bot_state_s::frame_Enemy_Vis, g_entities, bot_state_s::goalAngles, level, entityState_s::number, botskills_s::perfectaim, PITCH, entityState_s::pos, rand(), bot_state_s::revengeEnemy, bot_state_s::revengeHateLevel, gentity_s::s, bot_state_s::settings, bot_settings_s::skill, bot_state_s::skills, level_locals_t::time, trajectory_t::trDelta, and YAW. Referenced by StandardBotAI(). { int i; float accVal; i = 0; if (bs->skills.perfectaim) { return; } if (bs->aimOffsetTime > level.time) { if (bs->aimOffsetAmtYaw) { bs->goalAngles[YAW] += bs->aimOffsetAmtYaw; } if (bs->aimOffsetAmtPitch) { bs->goalAngles[PITCH] += bs->aimOffsetAmtPitch; } while (i <= 2) { if (bs->goalAngles[i] > 360) { bs->goalAngles[i] -= 360; } if (bs->goalAngles[i] < 0) { bs->goalAngles[i] += 360; } i++; } return; } accVal = bs->skills.accuracy/bs->settings.skill; if (bs->currentEnemy && BotMindTricked(bs->client, bs->currentEnemy->s.number)) { //having to judge where they are by hearing them, so we should be quite inaccurate here accVal *= 7; if (accVal < 30) { accVal = 30; } } if (bs->revengeEnemy && bs->revengeHateLevel && bs->currentEnemy == bs->revengeEnemy) { //bot becomes more skilled as anger level raises accVal = accVal/bs->revengeHateLevel; } if (bs->currentEnemy && bs->frame_Enemy_Vis) { //assume our goal is aiming at the enemy, seeing as he's visible and all if (!bs->currentEnemy->s.pos.trDelta[0] && !bs->currentEnemy->s.pos.trDelta[1] && !bs->currentEnemy->s.pos.trDelta[2]) { accVal = 0; //he's not even moving, so he shouldn't really be hard to hit. } else { accVal += accVal*0.25; //if he's moving he's this much harder to hit } if (g_entities[bs->client].s.pos.trDelta[0] || g_entities[bs->client].s.pos.trDelta[1] || g_entities[bs->client].s.pos.trDelta[2]) { accVal += accVal*0.15; //make it somewhat harder to aim if we're moving also } } if (accVal > 90) { accVal = 90; } if (accVal < 1) { accVal = 0; } if (!accVal) { bs->aimOffsetAmtYaw = 0; bs->aimOffsetAmtPitch = 0; return; } if (rand()%10 <= 5) { bs->aimOffsetAmtYaw = rand()%(int)accVal; } else { bs->aimOffsetAmtYaw = -(rand()%(int)accVal); } if (rand()%10 <= 5) { bs->aimOffsetAmtPitch = rand()%(int)accVal; } else { bs->aimOffsetAmtPitch = -(rand()%(int)accVal); } bs->aimOffsetTime = level.time + rand()%500 + 200; }

void BotAIRegularUpdate (  void   )

Definition at line 662 of file ai_main.c. References FloatTime, regularupdate_time, and trap_BotUpdateEntityItems(). { if (regularupdate_time < FloatTime()) { trap_BotUpdateEntityItems(); regularupdate_time = FloatTime() + 0.3; } }

int BotAISetup (  int  restart  )

Definition at line 7575 of file ai_main.c. References bot_attachments, bot_camp, bot_forcepowers, bot_forgimmick, bot_getinthecarrr, bot_honorableduelacceptance, bot_pvstype, bot_wp_clearweight, bot_wp_distconnect, bot_wp_edit, bot_wp_info, bot_wp_visconnect, botstates, CVAR_CHEAT, memset(), qfalse, qtrue, trap_BotLibSetup(), trap_Cvar_Register(), and trap_Cvar_Update(). Referenced by G_InitGame(). { //rww - new bot cvars.. trap_Cvar_Register(&bot_forcepowers, "bot_forcepowers", "1", CVAR_CHEAT); trap_Cvar_Register(&bot_forgimmick, "bot_forgimmick", "0", CVAR_CHEAT); trap_Cvar_Register(&bot_honorableduelacceptance, "bot_honorableduelacceptance", "0", CVAR_CHEAT); trap_Cvar_Register(&bot_pvstype, "bot_pvstype", "1", CVAR_CHEAT); #ifndef FINAL_BUILD trap_Cvar_Register(&bot_getinthecarrr, "bot_getinthecarrr", "0", 0); #endif #ifdef _DEBUG trap_Cvar_Register(&bot_nogoals, "bot_nogoals", "0", CVAR_CHEAT); trap_Cvar_Register(&bot_debugmessages, "bot_debugmessages", "0", CVAR_CHEAT); #endif trap_Cvar_Register(&bot_attachments, "bot_attachments", "1", 0); trap_Cvar_Register(&bot_camp, "bot_camp", "1", 0); trap_Cvar_Register(&bot_wp_info, "bot_wp_info", "1", 0); trap_Cvar_Register(&bot_wp_edit, "bot_wp_edit", "0", CVAR_CHEAT); trap_Cvar_Register(&bot_wp_clearweight, "bot_wp_clearweight", "1", 0); trap_Cvar_Register(&bot_wp_distconnect, "bot_wp_distconnect", "1", 0); trap_Cvar_Register(&bot_wp_visconnect, "bot_wp_visconnect", "1", 0); trap_Cvar_Update(&bot_forcepowers); //end rww //if the game is restarted for a tournament if (restart) { return qtrue; } //initialize the bot states memset( botstates, 0, sizeof(botstates) ); if (!trap_BotLibSetup()) { return qfalse; //wts?! } return qtrue; }

int BotAISetupClient (  int  client, struct bot_settings_s *  settings, qboolean  restart )

Definition at line 819 of file ai_main.c. References B_Alloc(), bot_settings_t, bot_state_t, BotAI_Print(), BotDoChat(), BotScheduleBotThink(), botstates, BotUtilizePersonality(), bot_state_s::botWeaponWeights, client, bot_state_s::client, bot_state_s::entergame_time, bot_state_s::entitynum, FloatTime, g_gametype, bot_state_s::gs, GT_DUEL, GT_POWERDUEL, vmCvar_t::integer, bot_state_s::inuse, memcpy(), memset(), bot_state_s::ms, numbots, PlayersInGame(), PRT_FATAL, qfalse, qtrue, bot_state_s::settings, bot_state_s::setupcount, trap_BotAllocGoalState(), trap_BotAllocMoveState(), trap_BotAllocWeaponState(), WP_BLASTER, WP_BOWCASTER, WP_BRYAR_PISTOL, WP_DEMP2, WP_DET_PACK, WP_DISRUPTOR, WP_FLECHETTE, WP_MELEE, WP_NONE, WP_REPEATER, WP_ROCKET_LAUNCHER, WP_SABER, WP_STUN_BATON, WP_THERMAL, WP_TRIP_MINE, and bot_state_s::ws. Referenced by G_BotConnect(). { bot_state_t *bs; if (!botstates[client]) botstates[client] = (bot_state_t *) B_Alloc(sizeof(bot_state_t)); //G_Alloc(sizeof(bot_state_t)); //rww - G_Alloc bad! B_Alloc good. memset(botstates[client], 0, sizeof(bot_state_t)); bs = botstates[client]; if (bs && bs->inuse) { BotAI_Print(PRT_FATAL, "BotAISetupClient: client %d already setup\n", client); return qfalse; } memcpy(&bs->settings, settings, sizeof(bot_settings_t)); bs->client = client; //need to know the client number before doing personality stuff //initialize weapon weight defaults.. bs->botWeaponWeights[WP_NONE] = 0; bs->botWeaponWeights[WP_STUN_BATON] = 1; bs->botWeaponWeights[WP_SABER] = 10; bs->botWeaponWeights[WP_BRYAR_PISTOL] = 11; bs->botWeaponWeights[WP_BLASTER] = 12; bs->botWeaponWeights[WP_DISRUPTOR] = 13; bs->botWeaponWeights[WP_BOWCASTER] = 14; bs->botWeaponWeights[WP_REPEATER] = 15; bs->botWeaponWeights[WP_DEMP2] = 16; bs->botWeaponWeights[WP_FLECHETTE] = 17; bs->botWeaponWeights[WP_ROCKET_LAUNCHER] = 18; bs->botWeaponWeights[WP_THERMAL] = 14; bs->botWeaponWeights[WP_TRIP_MINE] = 0; bs->botWeaponWeights[WP_DET_PACK] = 0; bs->botWeaponWeights[WP_MELEE] = 1; BotUtilizePersonality(bs); if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) { bs->botWeaponWeights[WP_SABER] = 13; } //allocate a goal state bs->gs = trap_BotAllocGoalState(client); //allocate a weapon state bs->ws = trap_BotAllocWeaponState(); bs->inuse = qtrue; bs->entitynum = client; bs->setupcount = 4; bs->entergame_time = FloatTime(); bs->ms = trap_BotAllocMoveState(); numbots++; //NOTE: reschedule the bot thinking BotScheduleBotThink(); if (PlayersInGame()) { //don't talk to yourself BotDoChat(bs, "GeneralGreetings", 0); } return qtrue; }

int BotAIShutdown (  int  restart  )

Definition at line 7623 of file ai_main.c. References BotAIShutdownClient(), botstates, client, bot_state_s::inuse, MAX_CLIENTS, qtrue, and trap_BotLibShutdown(). Referenced by G_ShutdownGame(). { int i; //if the game is restarted for a tournament if ( restart ) { //shutdown all the bots in the botlib for (i = 0; i < MAX_CLIENTS; i++) { if (botstates[i] && botstates[i]->inuse) { BotAIShutdownClient(botstates[i]->client, restart); } } //don't shutdown the bot library } else { trap_BotLibShutdown(); } return qtrue; }

int BotAIShutdownClient (  int  client, qboolean  restart )

Definition at line 891 of file ai_main.c. References bot_state_t, botstates, client, bot_state_s::gs, bot_state_s::inuse, memset(), bot_state_s::ms, numbots, qfalse, qtrue, trap_BotFreeGoalState(), trap_BotFreeMoveState(), trap_BotFreeWeaponState(), and bot_state_s::ws. Referenced by BotAIShutdown(), and ClientDisconnect(). { bot_state_t *bs; bs = botstates[client]; if (!bs || !bs->inuse) { //BotAI_Print(PRT_ERROR, "BotAIShutdownClient: client %d already shutdown\n", client); return qfalse; } trap_BotFreeMoveState(bs->ms); //free the goal state` trap_BotFreeGoalState(bs->gs); //free the weapon weights trap_BotFreeWeaponState(bs->ws); // //clear the bot state memset(bs, 0, sizeof(bot_state_t)); //set the inuse flag to qfalse bs->inuse = qfalse; //there's one bot less numbots--; //everything went ok return qtrue; }

int BotAIStartFrame (  int  time  )

Definition at line 7492 of file ai_main.c. References bot_attachments, bot_camp, bot_forgimmick, bot_getinthecarrr, bot_honorableduelacceptance, bot_pvstype, BOT_THINK_TIME, bot_wp_info, BotAI(), BotScheduleBotThink(), botstates, bot_state_s::botthink_residual, BotUpdateInput(), BotWaypointRender(), gentity_s::client, client, CON_CONNECTED, clientPersistant_t::connected, G_CheckBotSpawn(), g_entities, gBotEdit, gUpdateVars, bot_state_s::inuse, level, MAX_CLIENTS, gclient_s::pers, qtrue, level_locals_t::time, trap_BotUserCommand(), trap_Cvar_Update(), and UpdateEventTracker(). Referenced by vmMain(). { int i; int elapsed_time, thinktime; static int local_time; static int botlib_residual; static int lastbotthink_time; if (gUpdateVars < level.time) { trap_Cvar_Update(&bot_pvstype); trap_Cvar_Update(&bot_camp); trap_Cvar_Update(&bot_attachments); trap_Cvar_Update(&bot_forgimmick); trap_Cvar_Update(&bot_honorableduelacceptance); #ifndef FINAL_BUILD trap_Cvar_Update(&bot_getinthecarrr); #endif gUpdateVars = level.time + 1000; } G_CheckBotSpawn(); //rww - addl bot frame functions if (gBotEdit) { trap_Cvar_Update(&bot_wp_info); BotWaypointRender(); } UpdateEventTracker(); //end rww //cap the bot think time //if the bot think time changed we should reschedule the bots if (BOT_THINK_TIME != lastbotthink_time) { lastbotthink_time = BOT_THINK_TIME; BotScheduleBotThink(); } elapsed_time = time - local_time; local_time = time; if (elapsed_time > BOT_THINK_TIME) thinktime = elapsed_time; else thinktime = BOT_THINK_TIME; // execute scheduled bot AI for( i = 0; i < MAX_CLIENTS; i++ ) { if( !botstates[i] || !botstates[i]->inuse ) { continue; } // botstates[i]->botthink_residual += elapsed_time; // if ( botstates[i]->botthink_residual >= thinktime ) { botstates[i]->botthink_residual -= thinktime; if (g_entities[i].client->pers.connected == CON_CONNECTED) { BotAI(i, (float) thinktime / 1000); } } } // execute bot user commands every frame for( i = 0; i < MAX_CLIENTS; i++ ) { if( !botstates[i] || !botstates[i]->inuse ) { continue; } if( g_entities[i].client->pers.connected != CON_CONNECTED ) { continue; } BotUpdateInput(botstates[i], time, elapsed_time); trap_BotUserCommand(botstates[i]->client, &botstates[i]->lastucmd); } return qtrue; }

int BotCanHear (  bot_state_t *  bs, gentity_t *  en, float  endist )

Definition at line 1945 of file ai_main.c. References bot_state_t, BotMindTricked(), bot_state_s::client, gentity_s::client, EV_ALT_FIRE, EV_FIRE_WEAPON, EV_FOOTSTEP, EV_FOOTSTEP_METAL, EV_FOOTWADE, EV_GLOBAL_SOUND, EV_JUMP, EV_ROLL, EV_SABER_ATTACK, EV_STEP_12, EV_STEP_16, EV_STEP_4, EV_STEP_8, playerState_s::footstepTime, gBotEventTracker, gentity_t, level, MAX_PS_EVENTS, entityState_s::number, playerState_s::otherSoundLen, playerState_s::otherSoundTime, gclient_s::ps, gentity_s::s, and level_locals_t::time. Referenced by ScanForEnemies(). { float minlen; if (!en || !en->client) { return 0; } if (en && en->client && en->client->ps.otherSoundTime > level.time) { //they made a noise in recent time minlen = en->client->ps.otherSoundLen; goto checkStep; } if (en && en->client && en->client->ps.footstepTime > level.time) { //they made a footstep minlen = 256; goto checkStep; } if (gBotEventTracker[en->s.number].eventTime < level.time) { //no recent events to check return 0; } switch(gBotEventTracker[en->s.number].events[gBotEventTracker[en->s.number].eventSequence & (MAX_PS_EVENTS-1)]) { //did the last event contain a sound? case EV_GLOBAL_SOUND: minlen = 256; break; case EV_FIRE_WEAPON: case EV_ALT_FIRE: case EV_SABER_ATTACK: minlen = 512; break; case EV_STEP_4: case EV_STEP_8: case EV_STEP_12: case EV_STEP_16: case EV_FOOTSTEP: case EV_FOOTSTEP_METAL: case EV_FOOTWADE: minlen = 256; break; case EV_JUMP: case EV_ROLL: minlen = 256; break; default: minlen = 999999; break; } checkStep: if (BotMindTricked(bs->client, en->s.number)) { //if mindtricked by this person, cut down on the minlen so they can't "hear" as well minlen /= 4; } if (endist <= minlen) { //we heard it return 1; } return 0; }

float BotChangeViewAngle (  float  angle, float  ideal_angle, float  speed )

Definition at line 443 of file ai_main.c. References AngleMod(). { float move; angle = AngleMod(angle); ideal_angle = AngleMod(ideal_angle); if (angle == ideal_angle) return angle; move = ideal_angle - angle; if (ideal_angle > angle) { if (move > 180.0) move -= 360.0; } else { if (move < -180.0) move += 360.0; } if (move > 0) { if (move > speed) move = speed; } else { if (move < -speed) move = -speed; } return AngleMod(angle + move); }

void BotChangeViewAngles (  bot_state_t *  bs, float  thinktime )

Definition at line 470 of file ai_main.c. References AngleDifference(), AngleMod(), bot_state_t, bot_state_s::client, bot_state_s::currentEnemy, bot_state_s::frame_Enemy_Vis, bot_state_s::ideal_viewangles, botskills_s::maxturn, PITCH, bot_state_s::settings, bot_settings_s::skill, bot_state_s::skills, trap_EA_View(), botskills_s::turnspeed, botskills_s::turnspeed_combat, bot_state_s::viewangles, and bot_state_s::viewanglespeed. Referenced by BotUpdateInput(). { float diff, factor, maxchange, anglespeed, disired_speed; int i; if (bs->ideal_viewangles[PITCH] > 180) bs->ideal_viewangles[PITCH] -= 360; if (bs->currentEnemy && bs->frame_Enemy_Vis) { if (bs->settings.skill <= 1) { factor = (bs->skills.turnspeed_combat*0.4f)*bs->settings.skill; } else if (bs->settings.skill <= 2) { factor = (bs->skills.turnspeed_combat*0.6f)*bs->settings.skill; } else if (bs->settings.skill <= 3) { factor = (bs->skills.turnspeed_combat*0.8f)*bs->settings.skill; } else { factor = bs->skills.turnspeed_combat*bs->settings.skill; } } else { factor = bs->skills.turnspeed; } if (factor > 1) { factor = 1; } if (factor < 0.001) { factor = 0.001f; } maxchange = bs->skills.maxturn; //if (maxchange < 240) maxchange = 240; maxchange *= thinktime; for (i = 0; i < 2; i++) { bs->viewangles[i] = AngleMod(bs->viewangles[i]); bs->ideal_viewangles[i] = AngleMod(bs->ideal_viewangles[i]); diff = AngleDifference(bs->viewangles[i], bs->ideal_viewangles[i]); disired_speed = diff * factor; bs->viewanglespeed[i] += (bs->viewanglespeed[i] - disired_speed); if (bs->viewanglespeed[i] > 180) bs->viewanglespeed[i] = maxchange; if (bs->viewanglespeed[i] < -180) bs->viewanglespeed[i] = -maxchange; anglespeed = bs->viewanglespeed[i]; if (anglespeed > maxchange) anglespeed = maxchange; if (anglespeed < -maxchange) anglespeed = -maxchange; bs->viewangles[i] += anglespeed; bs->viewangles[i] = AngleMod(bs->viewangles[i]); bs->viewanglespeed[i] *= 0.45 * (1 - factor); } if (bs->viewangles[PITCH] > 180) bs->viewangles[PITCH] -= 360; trap_EA_View(bs->client, bs->viewangles); }

void BotCheckDetPacks (  bot_state_t *  bs  )

Definition at line 5726 of file ai_main.c. References BOT_PLANT_BLOW_DISTANCE, bot_state_t, gentity_s::client, bot_state_s::client, bot_state_s::currentEnemy, FOFS, bot_state_s::frame_Enemy_Vis, G_Find(), gentity_t, level, NULL, entityState_s::number, OrgVisible(), bot_state_s::origin, playerState_s::origin, gentity_s::parent, bot_state_s::plantContinue, bot_state_s::plantKillEmAll, entityState_s::pos, gclient_s::ps, gentity_s::s, level_locals_t::time, trajectory_t::trBase, vec3_t, and VectorSubtract. Referenced by StandardBotAI(). { gentity_t *dp = NULL; gentity_t *myDet = NULL; vec3_t a; float enLen; float myLen; while ( (dp = G_Find( dp, FOFS(classname), "detpack") ) != NULL ) { if (dp && dp->parent && dp->parent->s.number == bs->client) { myDet = dp; break; } } if (!myDet) { return; } if (!bs->currentEnemy || !bs->currentEnemy->client || !bs->frame_Enemy_Vis) { //require the enemy to be visilbe just to be fair.. //unless.. if (bs->currentEnemy && bs->currentEnemy->client && (level.time - bs->plantContinue) < 5000) { //it's a fresh plant (within 5 seconds) so we should be able to guess goto stillmadeit; } return; } stillmadeit: VectorSubtract(bs->currentEnemy->client->ps.origin, myDet->s.pos.trBase, a); enLen = VectorLength(a); VectorSubtract(bs->origin, myDet->s.pos.trBase, a); myLen = VectorLength(a); if (enLen > myLen) { return; } if (enLen < BOT_PLANT_BLOW_DISTANCE && OrgVisible(bs->currentEnemy->client->ps.origin, myDet->s.pos.trBase, bs->currentEnemy->s.number)) { //we could just call the "blow all my detpacks" function here, but I guess that's cheating. bs->plantKillEmAll = level.time + 500; } }

qboolean BotCTFGuardDuty (  bot_state_t *  bs  )

Definition at line 1432 of file ai_main.c. References bot_state_t, bot_state_s::ctfState, CTFSTATE_DEFENDER, g_gametype, GT_CTF, GT_CTY, vmCvar_t::integer, qboolean, qfalse, and qtrue. Referenced by WPTouchRoutine(). { if (g_gametype.integer != GT_CTF && g_gametype.integer != GT_CTY) { return qfalse; } if (bs->ctfState == CTFSTATE_DEFENDER) { return qtrue; } return qfalse; }

void BotDamageNotification (  gclient_t *  bot, gentity_t *  attacker )

Definition at line 1861 of file ai_main.c. References bot_state_t, botstates, gentity_s::client, bot_state_s::client, playerState_s::clientNum, bot_state_s::currentEnemy, ENEMY_FORGET_MS, bot_state_s::enemySeenTime, g_entities, gclient_t, gentity_t, bot_state_s::lastAttacked, bot_state_s::lastHurt, level, MAX_CLIENTS, NULL, entityState_s::number, PassLovedOneCheck(), PassStandardEnemyChecks(), gclient_s::ps, gentity_s::s, and level_locals_t::time. Referenced by G_Damage(). { bot_state_t *bs; bot_state_t *bs_a; int i; if (!bot || !attacker || !attacker->client) { return; } if (bot->ps.clientNum >= MAX_CLIENTS) { //an NPC.. do nothing for them. return; } if (attacker->s.number >= MAX_CLIENTS) { //if attacker is an npc also don't care I suppose. return; } bs_a = botstates[attacker->s.number]; if (bs_a) { //if the client attacking us is a bot as well bs_a->lastAttacked = &g_entities[bot->ps.clientNum]; i = 0; while (i < MAX_CLIENTS) { if (botstates[i] && i != bs_a->client && botstates[i]->lastAttacked == &g_entities[bot->ps.clientNum]) { botstates[i]->lastAttacked = NULL; } i++; } } else //got attacked by a real client, so no one gets rights to lastAttacked { i = 0; while (i < MAX_CLIENTS) { if (botstates[i] && botstates[i]->lastAttacked == &g_entities[bot->ps.clientNum]) { botstates[i]->lastAttacked = NULL; } i++; } } bs = botstates[bot->ps.clientNum]; if (!bs) { return; } bs->lastHurt = attacker; if (bs->currentEnemy) { //we don't care about the guy attacking us if we have an enemy already return; } if (!PassStandardEnemyChecks(bs, attacker)) { //the person that hurt us is not a valid enemy return; } if (PassLovedOneCheck(bs, attacker)) { //the person that hurt us is the one we love! bs->currentEnemy = attacker; bs->enemySeenTime = level.time + ENEMY_FORGET_MS; } }

void BotDeathNotify (  bot_state_t *  bs  )

Definition at line 5390 of file ai_main.c. References bot_state_t, BotLovedOneDied(), botstates, bot_state_s::client, level_locals_t::clients, level, bot_state_s::loved, bot_state_s::lovednum, MAX_CLIENTS, botattachment_s::name, and strcmp(). Referenced by StandardBotAI(). { //in case someone has an emotional attachment to us, we'll notify them int i = 0; int ltest = 0; while (i < MAX_CLIENTS) { if (botstates[i] && botstates[i]->lovednum) { ltest = 0; while (ltest < botstates[i]->lovednum) { if (strcmp(level.clients[bs->client].pers.netname, botstates[i]->loved[ltest].name) == 0) { BotLovedOneDied(botstates[i], bs, botstates[i]->loved[ltest].level); break; } ltest++; } } i++; } }

int BotDefendFlag (  bot_state_t *  bs  )

Definition at line 2507 of file ai_main.c. References BASE_GUARD_DISTANCE, bot_state_t, bot_state_s::client, level_locals_t::clients, flagBlue, flagRed, level, wpobject_s::origin, bot_state_s::origin, TEAM_BLUE, TEAM_RED, vec3_t, VectorSubtract, bot_state_s::wpDestination, and wpobject_t. Referenced by CTFTakesPriority(). { wpobject_t *flagPoint; vec3_t a; if (level.clients[bs->client].sess.sessionTeam == TEAM_RED) { flagPoint = flagRed; } else if (level.clients[bs->client].sess.sessionTeam == TEAM_BLUE) { flagPoint = flagBlue; } else { return 0; } if (!flagPoint) { return 0; } VectorSubtract(bs->origin, flagPoint->origin, a); if (VectorLength(a) > BASE_GUARD_DISTANCE) { bs->wpDestination = flagPoint; } return 1; }

void BotDoTeamplayAI (  bot_state_t *  bs  )

Definition at line 4143 of file ai_main.c. References bot_state_t, bot_state_s::isSquadLeader, NULL, bot_state_s::squadLeader, bot_state_s::state_Forced, bot_state_s::teamplayState, and TEAMPLAYSTATE_REGROUP. Referenced by StandardBotAI(). { if (bs->state_Forced) { bs->teamplayState = bs->state_Forced; } if (bs->teamplayState == TEAMPLAYSTATE_REGROUP) { //force to find a new leader bs->squadLeader = NULL; bs->isSquadLeader = 0; } }

void BotEntityInfo (  int  entnum, aas_entityinfo_t *  info )

Definition at line 407 of file ai_main.c. References aas_entityinfo_t, and trap_AAS_EntityInfo(). { trap_AAS_EntityInfo(entnum, info); }

int BotFallbackNavigation (  bot_state_t *  bs  )

Definition at line 5029 of file ai_main.c. References AngleVectors(), bot_state_t, bot_state_s::currentEnemy, ENTITYNUM_NONE, trace_t::fraction, bot_state_s::frame_Enemy_Vis, bot_state_s::goalAngles, bot_state_s::goalPosition, MASK_SOLID, NULL, bot_state_s::origin, PITCH, rand(), ROLL, trap_Trace(), vec3_t, VectorCopy, and YAW. Referenced by StandardBotAI(). { vec3_t b_angle, fwd, trto, mins, maxs; trace_t tr; if (bs->currentEnemy && bs->frame_Enemy_Vis) { return 2; //we're busy } mins[0] = -15; mins[1] = -15; mins[2] = 0; maxs[0] = 15; maxs[1] = 15; maxs[2] = 32; bs->goalAngles[PITCH] = 0; bs->goalAngles[ROLL] = 0; VectorCopy(bs->goalAngles, b_angle); AngleVectors(b_angle, fwd, NULL, NULL); trto[0] = bs->origin[0] + fwd[0]*16; trto[1] = bs->origin[1] + fwd[1]*16; trto[2] = bs->origin[2] + fwd[2]*16; trap_Trace(&tr, bs->origin, mins, maxs, trto, ENTITYNUM_NONE, MASK_SOLID); if (tr.fraction == 1) { VectorCopy(trto, bs->goalPosition); return 1; //success! } else { bs->goalAngles[YAW] = rand()%360; } return 0; }

int BotGetEnemyFlag (  bot_state_t *  bs  )

Definition at line 2541 of file ai_main.c. References BASE_GETENEMYFLAG_DISTANCE, bot_state_t, bot_state_s::client, level_locals_t::clients, flagBlue, flagRed, level, wpobject_s::origin, bot_state_s::origin, TEAM_BLUE, TEAM_RED, vec3_t, VectorSubtract, bot_state_s::wpDestination, and wpobject_t. Referenced by CTFTakesPriority(). { wpobject_t *flagPoint; vec3_t a; if (level.clients[bs->client].sess.sessionTeam == TEAM_RED) { flagPoint = flagBlue; } else if (level.clients[bs->client].sess.sessionTeam == TEAM_BLUE) { flagPoint = flagRed; } else { return 0; } if (!flagPoint) { return 0; } VectorSubtract(bs->origin, flagPoint->origin, a); if (VectorLength(a) > BASE_GETENEMYFLAG_DISTANCE) { bs->wpDestination = flagPoint; } return 1; }

int BotGetFlagBack (  bot_state_t *  bs  )

Definition at line 2575 of file ai_main.c. References bot_state_t, gentity_s::client, bot_state_s::client, level_locals_t::clients, g_entities, gentity_t, GetNearestVisibleWP(), gWPArray, wpobject_s::index, level, MAX_CLIENTS, NULL, OnSameTeam(), entityState_s::origin, playerState_s::origin, playerState_s::powerups, gclient_s::ps, PW_BLUEFLAG, PW_REDFLAG, Q_irand(), gentity_s::s, TEAM_RED, level_locals_t::time, TotalTrailDistance(), vec3_t, VectorCopy, bot_state_s::wpCurrent, bot_state_s::wpDestination, and bot_state_s::wpDestSwitchTime. Referenced by CTFTakesPriority(). { int i = 0; int myFlag = 0; int foundCarrier = 0; int tempInt = 0; gentity_t *ent = NULL; vec3_t usethisvec; if (level.clients[bs->client].sess.sessionTeam == TEAM_RED) { myFlag = PW_REDFLAG; } else { myFlag = PW_BLUEFLAG; } while (i < MAX_CLIENTS) { ent = &g_entities[i]; if (ent && ent->client && ent->client->ps.powerups[myFlag] && !OnSameTeam(&g_entities[bs->client], ent)) { foundCarrier = 1; break; } i++; } if (!foundCarrier) { return 0; } if (!ent) { return 0; } if (bs->wpDestSwitchTime < level.time) { if (ent->client) { VectorCopy(ent->client->ps.origin, usethisvec); } else { VectorCopy(ent->s.origin, usethisvec); } tempInt = GetNearestVisibleWP(usethisvec, 0); if (tempInt != -1 && TotalTrailDistance(bs->wpCurrent->index, tempInt, bs) != -1) { bs->wpDestination = gWPArray[tempInt]; bs->wpDestSwitchTime = level.time + Q_irand(1000, 5000); } } return 1; }

int BotGetFlagHome (  bot_state_t *  bs  )

Definition at line 2706 of file ai_main.c. References BASE_FLAGWAIT_DISTANCE, bot_state_t, bot_state_s::client, level_locals_t::clients, flagBlue, flagRed, level, wpobject_s::origin, bot_state_s::origin, TEAM_BLUE, TEAM_RED, vec3_t, VectorSubtract, bot_state_s::wpDestination, and wpobject_t. Referenced by CTFTakesPriority(). { wpobject_t *flagPoint; vec3_t a; if (level.clients[bs->client].sess.sessionTeam == TEAM_RED) { flagPoint = flagRed; } else if (level.clients[bs->client].sess.sessionTeam == TEAM_BLUE) { flagPoint = flagBlue; } else { return 0; } if (!flagPoint) { return 0; } VectorSubtract(bs->origin, flagPoint->origin, a); if (VectorLength(a) > BASE_FLAGWAIT_DISTANCE) { bs->wpDestination = flagPoint; } return 1; }

int BotGetWeaponRange (  bot_state_t *  bs  )

Definition at line 2264 of file ai_main.c. References bot_state_t, BWEAPONRANGE_LONG, BWEAPONRANGE_MELEE, BWEAPONRANGE_MID, BWEAPONRANGE_SABER, bot_state_s::cur_ps, playerState_s::weapon, WP_BLASTER, WP_BOWCASTER, WP_BRYAR_PISTOL, WP_DEMP2, WP_DET_PACK, WP_DISRUPTOR, WP_FLECHETTE, WP_MELEE, WP_REPEATER, WP_ROCKET_LAUNCHER, WP_SABER, WP_STUN_BATON, WP_THERMAL, and WP_TRIP_MINE. Referenced by BotIsAChickenWuss(), BotTrace_Jump(), CombatBotAI(), GetIdealDestination(), Siege_TargetClosestObjective(), and StandardBotAI(). { switch (bs->cur_ps.weapon) { case WP_STUN_BATON: case WP_MELEE: return BWEAPONRANGE_MELEE; case WP_SABER: return BWEAPONRANGE_SABER; case WP_BRYAR_PISTOL: return BWEAPONRANGE_MID; case WP_BLASTER: return BWEAPONRANGE_MID; case WP_DISRUPTOR: return BWEAPONRANGE_MID; case WP_BOWCASTER: return BWEAPONRANGE_LONG; case WP_REPEATER: return BWEAPONRANGE_MID; case WP_DEMP2: return BWEAPONRANGE_LONG; case WP_FLECHETTE: return BWEAPONRANGE_LONG; case WP_ROCKET_LAUNCHER: return BWEAPONRANGE_LONG; case WP_THERMAL: return BWEAPONRANGE_LONG; case WP_TRIP_MINE: return BWEAPONRANGE_LONG; case WP_DET_PACK: return BWEAPONRANGE_LONG; default: return BWEAPONRANGE_MID; } }

int BotGuardFlagCarrier (  bot_state_t *  bs  )

Definition at line 2641 of file ai_main.c. References bot_state_t, gentity_s::client, bot_state_s::client, level_locals_t::clients, g_entities, gentity_t, GetNearestVisibleWP(), gWPArray, wpobject_s::index, level, MAX_CLIENTS, NULL, OnSameTeam(), entityState_s::origin, playerState_s::origin, playerState_s::powerups, gclient_s::ps, PW_BLUEFLAG, PW_REDFLAG, Q_irand(), gentity_s::s, TEAM_RED, level_locals_t::time, TotalTrailDistance(), vec3_t, VectorCopy, bot_state_s::wpCurrent, bot_state_s::wpDestination, and bot_state_s::wpDestSwitchTime. Referenced by CTFTakesPriority(). { int i = 0; int enemyFlag = 0; int foundCarrier = 0; int tempInt = 0; gentity_t *ent = NULL; vec3_t usethisvec; if (level.clients[bs->client].sess.sessionTeam == TEAM_RED) { enemyFlag = PW_BLUEFLAG; } else { enemyFlag = PW_REDFLAG; } while (i < MAX_CLIENTS) { ent = &g_entities[i]; if (ent && ent->client && ent->client->ps.powerups[enemyFlag] && OnSameTeam(&g_entities[bs->client], ent)) { foundCarrier = 1; break; } i++; } if (!foundCarrier) { return 0; } if (!ent) { return 0; } if (bs->wpDestSwitchTime < level.time) { if (ent->client) { VectorCopy(ent->client->ps.origin, usethisvec); } else { VectorCopy(ent->s.origin, usethisvec); } tempInt = GetNearestVisibleWP(usethisvec, 0); if (tempInt != -1 && TotalTrailDistance(bs->wpCurrent->index, tempInt, bs) != -1) { bs->wpDestination = gWPArray[tempInt]; bs->wpDestSwitchTime = level.time + Q_irand(1000, 5000); } } return 1; }

int BotHasAssociated (  bot_state_t *  bs, wpobject_t *  wp )

Definition at line 3500 of file ai_main.c. References playerState_s::ammo, wpobject_s::associated_entity, bot_state_t, bot_state_s::cur_ps, ENTITYNUM_NONE, g_entities, gentity_t, gitem_s::giTag, gitem_s::giType, IT_AMMO, IT_HOLDABLE, IT_POWERUP, IT_WEAPON, gentity_s::item, playerState_s::powerups, STAT_HOLDABLE_ITEMS, STAT_WEAPONS, playerState_s::stats, and wpobject_t. Referenced by GetBestIdleGoal(). { gentity_t *as; if (wp->associated_entity == ENTITYNUM_NONE) { //make it think this is an item we have so we don't go after nothing return 1; } as = &g_entities[wp->associated_entity]; if (!as || !as->item) { return 0; } if (as->item->giType == IT_WEAPON) { if (bs->cur_ps.stats[STAT_WEAPONS] & (1 << as->item->giTag)) { return 1; } return 0; } else if (as->item->giType == IT_HOLDABLE) { if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << as->item->giTag)) { return 1; } return 0; } else if (as->item->giType == IT_POWERUP) { if (bs->cur_ps.powerups[as->item->giTag]) { return 1; } return 0; } else if (as->item->giType == IT_AMMO) { if (bs->cur_ps.ammo[as->item->giTag] > 10) //hack { return 1; } return 0; } return 0; }

void BotInputToUserCommand (  bot_input_t *  bi, usercmd_t *  ucmd, int  delta_angles[3], int  time, int  useTime )

Definition at line 537 of file ai_main.c. References abs(), ACTION_ALT_ATTACK, ACTION_ATTACK, ACTION_CROUCH, ACTION_DELAYEDJUMP, ACTION_FORCEPOWER, ACTION_GESTURE, ACTION_JUMP, ACTION_MOVEBACK, ACTION_MOVEFORWARD, ACTION_MOVELEFT, ACTION_MOVERIGHT, ACTION_RESPAWN, ACTION_USE, ACTION_WALK, bot_input_s::actionflags, ANGLE2SHORT, usercmd_s::angles, AngleVectors(), bot_input_t, BUTTON_ALT_ATTACK, BUTTON_ATTACK, BUTTON_FORCEPOWER, BUTTON_GESTURE, BUTTON_USE, BUTTON_USE_HOLDABLE, BUTTON_WALKING, usercmd_s::buttons, bot_input_s::dir, DotProduct, usercmd_s::forwardmove, level, memset(), NULL, PITCH, Q_irand(), usercmd_s::rightmove, ROLL, usercmd_s::serverTime, bot_input_s::speed, level_locals_t::time, ucmd, usercmd_s::upmove, usercmd_t, vec3_t, bot_input_s::viewangles, usercmd_s::weapon, bot_input_s::weapon, WP_BRYAR_PISTOL, WP_NONE, and YAW. Referenced by BotUpdateInput(). { vec3_t angles, forward, right; short temp; int j; //clear the whole structure memset(ucmd, 0, sizeof(usercmd_t)); // //Com_Printf("dir = %f %f %f speed = %f\n", bi->dir[0], bi->dir[1], bi->dir[2], bi->speed); //the duration for the user command in milli seconds ucmd->serverTime = time; // if (bi->actionflags & ACTION_DELAYEDJUMP) { bi->actionflags |= ACTION_JUMP; bi->actionflags &= ~ACTION_DELAYEDJUMP; } //set the buttons if (bi->actionflags & ACTION_RESPAWN) ucmd->buttons = BUTTON_ATTACK; if (bi->actionflags & ACTION_ATTACK) ucmd->buttons |= BUTTON_ATTACK; if (bi->actionflags & ACTION_ALT_ATTACK) ucmd->buttons |= BUTTON_ALT_ATTACK; // if (bi->actionflags & ACTION_TALK) ucmd->buttons |= BUTTON_TALK; if (bi->actionflags & ACTION_GESTURE) ucmd->buttons |= BUTTON_GESTURE; if (bi->actionflags & ACTION_USE) ucmd->buttons |= BUTTON_USE_HOLDABLE; if (bi->actionflags & ACTION_WALK) ucmd->buttons |= BUTTON_WALKING; if (bi->actionflags & ACTION_FORCEPOWER) ucmd->buttons |= BUTTON_FORCEPOWER; if (useTime < level.time && Q_irand(1, 10) < 5) { //for now just hit use randomly in case there's something useable around ucmd->buttons |= BUTTON_USE; } #if 0 // Here's an interesting bit. The bots in TA used buttons to do additional gestures. // I ripped them out because I didn't want too many buttons given the fact that I was already adding some for JK2. // We can always add some back in if we want though. if (bi->actionflags & ACTION_AFFIRMATIVE) ucmd->buttons |= BUTTON_AFFIRMATIVE; if (bi->actionflags & ACTION_NEGATIVE) ucmd->buttons |= BUTTON_NEGATIVE; if (bi->actionflags & ACTION_GETFLAG) ucmd->buttons |= BUTTON_GETFLAG; if (bi->actionflags & ACTION_GUARDBASE) ucmd->buttons |= BUTTON_GUARDBASE; if (bi->actionflags & ACTION_PATROL) ucmd->buttons |= BUTTON_PATROL; if (bi->actionflags & ACTION_FOLLOWME) ucmd->buttons |= BUTTON_FOLLOWME; #endif //0 if (bi->weapon == WP_NONE) { #ifdef _DEBUG // Com_Printf("WARNING: Bot tried to use WP_NONE!\n"); #endif bi->weapon = WP_BRYAR_PISTOL; } // ucmd->weapon = bi->weapon; //set the view angles //NOTE: the ucmd->angles are the angles WITHOUT the delta angles ucmd->angles[PITCH] = ANGLE2SHORT(bi->viewangles[PITCH]); ucmd->angles[YAW] = ANGLE2SHORT(bi->viewangles[YAW]); ucmd->angles[ROLL] = ANGLE2SHORT(bi->viewangles[ROLL]); //subtract the delta angles for (j = 0; j < 3; j++) { temp = ucmd->angles[j] - delta_angles[j]; ucmd->angles[j] = temp; } //NOTE: movement is relative to the REAL view angles //get the horizontal forward and right vector //get the pitch in the range [-180, 180] if (bi->dir[2]) angles[PITCH] = bi->viewangles[PITCH]; else angles[PITCH] = 0; angles[YAW] = bi->viewangles[YAW]; angles[ROLL] = 0; AngleVectors(angles, forward, right, NULL); //bot input speed is in the range [0, 400] bi->speed = bi->speed * 127 / 400; //set the view independent movement ucmd->forwardmove = DotProduct(forward, bi->dir) * bi->speed; ucmd->rightmove = DotProduct(right, bi->dir) * bi->speed; ucmd->upmove = abs((int)(forward[2])) * bi->dir[2] * bi->speed; //normal keyboard movement if (bi->actionflags & ACTION_MOVEFORWARD) ucmd->forwardmove += 127; if (bi->actionflags & ACTION_MOVEBACK) ucmd->forwardmove -= 127; if (bi->actionflags & ACTION_MOVELEFT) ucmd->rightmove -= 127; if (bi->actionflags & ACTION_MOVERIGHT) ucmd->rightmove += 127; //jump/moveup if (bi->actionflags & ACTION_JUMP) ucmd->upmove += 127; //crouch/movedown if (bi->actionflags & ACTION_CROUCH) ucmd->upmove -= 127; // //Com_Printf("forward = %d right = %d up = %d\n", ucmd.forwardmove, ucmd.rightmove, ucmd.upmove); //Com_Printf("ucmd->serverTime = %d\n", ucmd->serverTime); }

int BotIsAChickenWuss (  bot_state_t *  bs  )

Definition at line 2301 of file ai_main.c. References BOT_RUN_HEALTH, bot_state_t, BotGetWeaponRange(), BWEAPONRANGE_MELEE, BWEAPONRANGE_SABER, bot_state_s::chickenWussCalculationTime, gentity_s::client, bot_state_s::client, bot_state_s::cur_ps, bot_state_s::currentEnemy, playerState_s::electrifyTime, playerState_s::fd, forcedata_s::forcePowersActive, FP_RAGE, bot_state_s::frame_Enemy_Len, g_entities, g_gametype, gLevelFlags, GT_CTF, GT_JEDIMASTER, GT_SINGLE_PLAYER, gentity_s::health, vmCvar_t::integer, playerState_s::isJediMaster, level, LEVELFLAG_IMUSTNTRUNAWAY, MAX_CHICKENWUSS_TIME, playerState_s::powerups, gclient_s::ps, PW_BLUEFLAG, PW_REDFLAG, bot_state_s::saberSpecialist, level_locals_t::time, playerState_s::weapon, WP_BRYAR_PISTOL, WP_ROCKET_LAUNCHER, and WP_SABER. Referenced by GetIdealDestination(), and WPTouchRoutine(). { int bWRange; if (gLevelFlags & LEVELFLAG_IMUSTNTRUNAWAY) { //The level says we mustn't run away! return 0; } if (g_gametype.integer == GT_SINGLE_PLAYER) { //"coop" (not really) return 0; } if (g_gametype.integer == GT_JEDIMASTER && !bs->cur_ps.isJediMaster) { //Then you may know no fear. //Well, unless he's strong. if (bs->currentEnemy && bs->currentEnemy->client && bs->currentEnemy->client->ps.isJediMaster && bs->currentEnemy->health > 40 && bs->cur_ps.weapon < WP_ROCKET_LAUNCHER) { //explosive weapons are most effective against the Jedi Master goto jmPass; } return 0; } if (g_gametype.integer == GT_CTF && bs->currentEnemy && bs->currentEnemy->client) { if (bs->currentEnemy->client->ps.powerups[PW_REDFLAG] || bs->currentEnemy->client->ps.powerups[PW_BLUEFLAG]) { //don't be afraid of flag carriers, they must die! return 0; } } jmPass: if (bs->chickenWussCalculationTime > level.time) { return 2; //don't want to keep going between two points... } if (bs->cur_ps.fd.forcePowersActive & (1 << FP_RAGE)) { //don't run while raging return 0; } if (g_gametype.integer == GT_JEDIMASTER && !bs->cur_ps.isJediMaster) { //be frightened of the jedi master? I guess in this case. return 1; } bs->chickenWussCalculationTime = level.time + MAX_CHICKENWUSS_TIME; if (g_entities[bs->client].health < BOT_RUN_HEALTH) { //we're low on health, let's get away return 1; } bWRange = BotGetWeaponRange(bs); if (bWRange == BWEAPONRANGE_MELEE || bWRange == BWEAPONRANGE_SABER) { if (bWRange != BWEAPONRANGE_SABER || !bs->saberSpecialist) { //run away if we're using melee, or if we're using a saber and not a "saber specialist" return 1; } } if (bs->cur_ps.weapon == WP_BRYAR_PISTOL) { //the bryar is a weak weapon, so just try to find a new one if it's what you're having to use return 1; } if (bs->currentEnemy && bs->currentEnemy->client && bs->currentEnemy->client->ps.weapon == WP_SABER && bs->frame_Enemy_Len < 512 && bs->cur_ps.weapon != WP_SABER) { //if close to an enemy with a saber and not using a saber, then try to back off return 1; } if ((level.time-bs->cur_ps.electrifyTime) < 16000) { //lightning is dangerous. return 1; } //didn't run, reset the timer bs->chickenWussCalculationTime = 0; return 0; }

void BotLovedOneDied (  bot_state_t *  bs, bot_state_t *  loved, int  lovelevel )

Definition at line 5315 of file ai_main.c. References bot_attachments, bot_state_t, BotDoChat(), bot_state_s::chatAltObject, bot_state_s::chatObject, bot_state_s::client, gentity_s::client, g_entities, g_gametype, GT_DUEL, GT_POWERDUEL, vmCvar_t::integer, IsTeamplay(), bot_state_s::lastHurt, bot_state_s::loved_death_thresh, NULL, entityState_s::number, OnSameTeam(), PassLovedOneCheck(), bot_state_s::revengeEnemy, bot_state_s::revengeHateLevel, and gentity_s::s. Referenced by BotDeathNotify(). { if (!loved->lastHurt || !loved->lastHurt->client || loved->lastHurt->s.number == loved->client) { return; } if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) { //There is no love in 1-on-1 return; } if (!IsTeamplay()) { if (lovelevel < 2) { return; } } else if (OnSameTeam(&g_entities[bs->client], loved->lastHurt)) { //don't hate teammates no matter what return; } if (loved->client == loved->lastHurt->s.number) { return; } if (bs->client == loved->lastHurt->s.number) { //oops! return; } if (!bot_attachments.integer) { return; } if (!PassLovedOneCheck(bs, loved->lastHurt)) { //a loved one killed a loved one.. you cannot hate them bs->chatObject = loved->lastHurt; bs->chatAltObject = &g_entities[loved->client]; BotDoChat(bs, "LovedOneKilledLovedOne", 0); return; } if (bs->revengeEnemy == loved->lastHurt) { if (bs->revengeHateLevel < bs->loved_death_thresh) { bs->revengeHateLevel++; if (bs->revengeHateLevel == bs->loved_death_thresh) { //broke into the highest anger level //CHAT: Hatred section bs->chatObject = loved->lastHurt; bs->chatAltObject = NULL; BotDoChat(bs, "Hatred", 1); } } } else if (bs->revengeHateLevel < bs->loved_death_thresh-1) { //only switch hatred if we don't hate the existing revenge-enemy too much //CHAT: BelovedKilled section bs->chatObject = &g_entities[loved->client]; bs->chatAltObject = loved->lastHurt; BotDoChat(bs, "BelovedKilled", 0); bs->revengeHateLevel = 0; bs->revengeEnemy = loved->lastHurt; } }

int BotMindTricked (  int  botClient, int  enemyClient )

Definition at line 279 of file ai_main.c. References gentity_s::client, playerState_s::fd, forcedata_t, forcedata_s::forceMindtrickTargetIndex, forcedata_s::forceMindtrickTargetIndex2, forcedata_s::forceMindtrickTargetIndex3, forcedata_s::forceMindtrickTargetIndex4, g_entities, and gclient_s::ps. Referenced by BotAimOffsetGoalAngles(), BotCanHear(), PassStandardEnemyChecks(), ScanForEnemies(), and StandardBotAI(). { forcedata_t *fd; if (!g_entities[enemyClient].client) { return 0; } fd = &g_entities[enemyClient].client->ps.fd; if (!fd) { return 0; } if (botClient > 47) { if (fd->forceMindtrickTargetIndex4 & (1 << (botClient-48))) { return 1; } } else if (botClient > 31) { if (fd->forceMindtrickTargetIndex3 & (1 << (botClient-32))) { return 1; } } else if (botClient > 15) { if (fd->forceMindtrickTargetIndex2 & (1 << (botClient-16))) { return 1; } } else { if (fd->forceMindtrickTargetIndex & (1 << botClient)) { return 1; } } return 0; }

void BotOrder (  gentity_t *  ent, int  clientnum, int  ordernum )

Definition at line 184 of file ai_main.c. References BotDoChat(), BotReportStatus(), botstates, BotStraightTPOrderCheck(), bot_state_s::chatAltObject, bot_state_s::chatObject, bot_state_s::chatTeam, gentity_s::client, CTFSTATE_MAXCTFSTATES, CTFSTATE_NONE, g_entities, g_gametype, gentity_t, GT_CTF, GT_CTY, GT_SIEGE, GT_TEAM, vmCvar_t::integer, MAX_CLIENTS, NULL, OnSameTeam(), gclient_s::sess, SIEGESTATE_MAXSIEGESTATES, SIEGESTATE_NONE, bot_state_s::state_Forced, clientSession_t::teamLeader, TEAMPLAYSTATE_MAXTPSTATES, and TEAMPLAYSTATE_NONE. { int stateMin = 0; int stateMax = 0; int i = 0; if (!ent || !ent->client || !ent->client->sess.teamLeader) { return; } if (clientnum != -1 && !botstates[clientnum]) { return; } if (clientnum != -1 && !OnSameTeam(ent, &g_entities[clientnum])) { return; } if (g_gametype.integer != GT_CTF && g_gametype.integer != GT_CTY && g_gametype.integer != GT_SIEGE && g_gametype.integer != GT_TEAM) { return; } if (g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY) { stateMin = CTFSTATE_NONE; stateMax = CTFSTATE_MAXCTFSTATES; } else if (g_gametype.integer == GT_SIEGE) { stateMin = SIEGESTATE_NONE; stateMax = SIEGESTATE_MAXSIEGESTATES; } else if (g_gametype.integer == GT_TEAM) { stateMin = TEAMPLAYSTATE_NONE; stateMax = TEAMPLAYSTATE_MAXTPSTATES; } if ((ordernum < stateMin && ordernum != -1) || ordernum >= stateMax) { return; } if (clientnum != -1) { if (ordernum == -1) { BotReportStatus(botstates[clientnum]); } else { BotStraightTPOrderCheck(ent, ordernum, botstates[clientnum]); botstates[clientnum]->state_Forced = ordernum; botstates[clientnum]->chatObject = ent; botstates[clientnum]->chatAltObject = NULL; if (BotDoChat(botstates[clientnum], "OrderAccepted", 1)) { botstates[clientnum]->chatTeam = 1; } } } else { while (i < MAX_CLIENTS) { if (botstates[i] && OnSameTeam(ent, &g_entities[i])) { if (ordernum == -1) { BotReportStatus(botstates[i]); } else { BotStraightTPOrderCheck(ent, ordernum, botstates[i]); botstates[i]->state_Forced = ordernum; botstates[i]->chatObject = ent; botstates[i]->chatAltObject = NULL; if (BotDoChat(botstates[i], "OrderAccepted", 0)) { botstates[i]->chatTeam = 1; } } } i++; } } }

qboolean BotPVSCheck (  const vec3_t  p1, const vec3_t  p2 )

Definition at line 1086 of file ai_main.c. References bot_pvstype, g_RMG, vmCvar_t::integer, qboolean, qfalse, qtrue, trap_InPVS(), vec3_t, and VectorSubtract. Referenced by GetNearestBadThing(), GetNearestVisibleWP(), ScanForEnemies(), and SiegeTakesPriority(). { if (g_RMG.integer && bot_pvstype.integer) { vec3_t subPoint; VectorSubtract(p1, p2, subPoint); if (VectorLength(subPoint) > 5000) { return qfalse; } return qtrue; } return trap_InPVS(p1, p2); }

void BotReplyGreetings (  bot_state_t *  bs  )

Definition at line 5618 of file ai_main.c. References bot_state_t, BotDoChat(), botstates, bot_state_s::canChat, bot_state_s::chatAltObject, bot_state_s::chatObject, bot_state_s::client, g_entities, MAX_CLIENTS, and NULL. Referenced by StandardBotAI(). { int i = 0; int numhello = 0; while (i < MAX_CLIENTS) { if (botstates[i] && botstates[i]->canChat && i != bs->client) { botstates[i]->chatObject = &g_entities[bs->client]; botstates[i]->chatAltObject = NULL; if (BotDoChat(botstates[i], "ResponseGreetings", 0)) { numhello++; } } if (numhello > 3) { //don't let more than 4 bots say hello at once return; } i++; } }

void BotReportStatus (  bot_state_t *  bs  )

Definition at line 167 of file ai_main.c. References bot_state_t, bot_state_s::client, bot_state_s::ctfState, ctfStateDescriptions, g_gametype, GT_CTF, GT_CTY, GT_SIEGE, GT_TEAM, vmCvar_t::integer, bot_state_s::siegeState, siegeStateDescriptions, bot_state_s::teamplayState, teamplayStateDescriptions, and trap_EA_SayTeam(). Referenced by BotOrder(). { if (g_gametype.integer == GT_TEAM) { trap_EA_SayTeam(bs->client, teamplayStateDescriptions[bs->teamplayState]); } else if (g_gametype.integer == GT_SIEGE) { trap_EA_SayTeam(bs->client, siegeStateDescriptions[bs->siegeState]); } else if (g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY) { trap_EA_SayTeam(bs->client, ctfStateDescriptions[bs->ctfState]); } }

void BotResetState (  bot_state_t *  bs  )

Definition at line 924 of file ai_main.c. References bot_settings_t, bot_state_t, client, bot_state_s::client, bot_state_s::cur_ps, bot_state_s::entergame_time, bot_state_s::entitynum, bot_state_s::gs, bot_state_s::inuse, memcpy(), memset(), bot_state_s::ms, playerState_t, bot_state_s::settings, trap_BotResetAvoidGoals(), trap_BotResetAvoidReach(), trap_BotResetGoalState(), trap_BotResetMoveState(), trap_BotResetWeaponState(), and bot_state_s::ws. Referenced by BotAILoadMap(). { int client, entitynum, inuse; int movestate, goalstate, weaponstate; bot_settings_t settings; playerState_t ps; //current player state float entergame_time; //save some things that should not be reset here memcpy(&settings, &bs->settings, sizeof(bot_settings_t)); memcpy(&ps, &bs->cur_ps, sizeof(playerState_t)); inuse = bs->inuse; client = bs->client; entitynum = bs->entitynum; movestate = bs->ms; goalstate = bs->gs; weaponstate = bs->ws; entergame_time = bs->entergame_time; //reset the whole state memset(bs, 0, sizeof(bot_state_t)); //copy back some state stuff that should not be reset bs->ms = movestate; bs->gs = goalstate; bs->ws = weaponstate; memcpy(&bs->cur_ps, &ps, sizeof(playerState_t)); memcpy(&bs->settings, &settings, sizeof(bot_settings_t)); bs->inuse = inuse; bs->client = client; bs->entitynum = entitynum; bs->entergame_time = entergame_time; //reset several states if (bs->ms) trap_BotResetMoveState(bs->ms); if (bs->gs) trap_BotResetGoalState(bs->gs); if (bs->ws) trap_BotResetWeaponState(bs->ws); if (bs->gs) trap_BotResetAvoidGoals(bs->gs); if (bs->ms) trap_BotResetAvoidReach(bs->ms); }

void BotScanForLeader (  bot_state_t *  bs  )

Definition at line 5585 of file ai_main.c. References bot_state_t, botstates, bot_state_s::client, gentity_s::client, g_entities, gentity_t, GetLoveLevel(), bot_state_s::isSquadLeader, IsTeamplay(), MAX_CLIENTS, OnSameTeam(), and bot_state_s::squadLeader. Referenced by StandardBotAI(). { //bots will only automatically obtain a leader if it's another bot using this method. int i = 0; gentity_t *ent; if (bs->isSquadLeader) { return; } while (i < MAX_CLIENTS) { ent = &g_entities[i]; if (ent && ent->client && botstates[i] && botstates[i]->isSquadLeader && bs->client != i) { if (OnSameTeam(&g_entities[bs->client], ent)) { bs->squadLeader = ent; break; } if (GetLoveLevel(bs, botstates[i]) > 1 && !IsTeamplay()) { //ignore love status regarding squad leaders if we're in teamplay bs->squadLeader = ent; break; } } i++; } }

void BotScheduleBotThink (  void   )

Definition at line 778 of file ai_main.c. References BOT_THINK_TIME, botstates, bot_state_s::botthink_residual, bot_state_s::inuse, MAX_CLIENTS, and numbots. Referenced by BotAISetupClient(), and BotAIStartFrame(). { int i, botnum; botnum = 0; for( i = 0; i < MAX_CLIENTS; i++ ) { if( !botstates[i] || !botstates[i]->inuse ) { continue; } //initialize the bot think residual time botstates[i]->botthink_residual = BOT_THINK_TIME * botnum / numbots; botnum++; } }

int BotSelectChoiceWeapon (  bot_state_t *  bs, int  weapon, int  doselection )

Definition at line 5216 of file ai_main.c. References playerState_s::ammo, weaponData_s::ammoIndex, bot_state_t, BotSelectWeapon(), bot_state_s::client, bot_state_s::cur_ps, weaponData_s::energyPerShot, STAT_WEAPONS, playerState_s::stats, bot_state_s::virtualWeapon, playerState_s::weapon, weaponData, and WP_NUM_WEAPONS. Referenced by StandardBotAI(). { //if !doselection then bot will only check if he has the specified weapon and return 1 (yes) or 0 (no) int i; int hasit = 0; i = 0; while (i < WP_NUM_WEAPONS) { if (bs->cur_ps.ammo[weaponData[i].ammoIndex] > weaponData[i].energyPerShot && i == weapon && (bs->cur_ps.stats[STAT_WEAPONS] & (1 << i))) { hasit = 1; break; } i++; } if (hasit && bs->cur_ps.weapon != weapon && doselection && bs->virtualWeapon != weapon) { bs->virtualWeapon = weapon; BotSelectWeapon(bs->client, weapon); //bs->cur_ps.weapon = weapon; //level.clients[bs->client].ps.weapon = weapon; return 2; } if (hasit) { return 1; } return 0; }

int BotSelectIdealWeapon (  bot_state_t *  bs  )

Definition at line 5123 of file ai_main.c. References playerState_s::ammo, weaponData_s::ammoIndex, bot_state_t, BotSelectWeapon(), BotWeaponSelectable(), bot_state_s::botWeaponWeights, bot_state_s::client, gentity_s::client, bot_state_s::cur_ps, bot_state_s::currentEnemy, weaponData_s::energyPerShot, bot_state_s::frame_Enemy_Len, gclient_s::ps, STAT_WEAPONS, playerState_s::stats, bot_state_s::virtualWeapon, playerState_s::weapon, weaponData, WP_BLASTER, WP_BOWCASTER, WP_BRYAR_PISTOL, WP_DEMP2, WP_DISRUPTOR, WP_NUM_WEAPONS, WP_REPEATER, WP_ROCKET_LAUNCHER, WP_SABER, and WP_THERMAL. Referenced by StandardBotAI(). { int i; int bestweight = -1; int bestweapon = 0; i = 0; while (i < WP_NUM_WEAPONS) { if (bs->cur_ps.ammo[weaponData[i].ammoIndex] >= weaponData[i].energyPerShot && bs->botWeaponWeights[i] > bestweight && (bs->cur_ps.stats[STAT_WEAPONS] & (1 << i))) { if (i == WP_THERMAL) { //special case.. if (bs->currentEnemy && bs->frame_Enemy_Len < 700) { bestweight = bs->botWeaponWeights[i]; bestweapon = i; } } else { bestweight = bs->botWeaponWeights[i]; bestweapon = i; } } i++; } if ( bs->currentEnemy && bs->frame_Enemy_Len < 300 && (bestweapon == WP_BRYAR_PISTOL || bestweapon == WP_BLASTER || bestweapon == WP_BOWCASTER) && (bs->cur_ps.stats[STAT_WEAPONS] & (1 << WP_SABER)) ) { bestweapon = WP_SABER; bestweight = 1; } if ( bs->currentEnemy && bs->frame_Enemy_Len > 300 && bs->currentEnemy->client && bs->currentEnemy->client->ps.weapon != WP_SABER && (bestweapon == WP_SABER) ) { //if the enemy is far away, and we have our saber selected, see if we have any good distance weapons instead if (BotWeaponSelectable(bs, WP_DISRUPTOR)) { bestweapon = WP_DISRUPTOR; bestweight = 1; } else if (BotWeaponSelectable(bs, WP_ROCKET_LAUNCHER)) { bestweapon = WP_ROCKET_LAUNCHER; bestweight = 1; } else if (BotWeaponSelectable(bs, WP_BOWCASTER)) { bestweapon = WP_BOWCASTER; bestweight = 1; } else if (BotWeaponSelectable(bs, WP_BLASTER)) { bestweapon = WP_BLASTER; bestweight = 1; } else if (BotWeaponSelectable(bs, WP_REPEATER)) { bestweapon = WP_REPEATER; bestweight = 1; } else if (BotWeaponSelectable(bs, WP_DEMP2)) { bestweapon = WP_DEMP2; bestweight = 1; } } //assert(bs->cur_ps.weapon > 0 && bestweapon > 0); if (bestweight != -1 && bs->cur_ps.weapon != bestweapon && bs->virtualWeapon != bestweapon) { bs->virtualWeapon = bestweapon; BotSelectWeapon(bs->client, bestweapon); //bs->cur_ps.weapon = bestweapon; //level.clients[bs->client].ps.weapon = bestweapon; return 1; } //assert(bs->cur_ps.weapon > 0); return 0; }

int BotSelectMelee (  bot_state_t *  bs  )

Definition at line 5254 of file ai_main.c. References bot_state_t, BotSelectWeapon(), bot_state_s::client, bot_state_s::cur_ps, bot_state_s::virtualWeapon, and playerState_s::weapon. { if (bs->cur_ps.weapon != 1 && bs->virtualWeapon != 1) { bs->virtualWeapon = 1; BotSelectWeapon(bs->client, 1); //bs->cur_ps.weapon = 1; //level.clients[bs->client].ps.weapon = 1; return 1; } return 0; }

void BotSelectWeapon (  int  client, int  weapon )

Definition at line 157 of file ai_main.c. References client, trap_EA_SelectWeapon(), and WP_NONE. Referenced by BotSelectChoiceWeapon(), BotSelectIdealWeapon(), BotSelectMelee(), and BotTryAnotherWeapon(). { if (weapon <= WP_NONE) { // assert(0); return; } trap_EA_SelectWeapon(client, weapon); }

void BotStraightTPOrderCheck (  gentity_t *  ent, int  ordernum, bot_state_t *  bs )

Definition at line 128 of file ai_main.c. References bot_state_t, gentity_t, bot_state_s::isSquadLeader, NULL, bot_state_s::squadLeader, bot_state_s::teamplayState, TEAMPLAYSTATE_ASSISTING, TEAMPLAYSTATE_FOLLOWING, and bot_state_s::wpDestSwitchTime. Referenced by BotOrder(). { switch (ordernum) { case 0: if (bs->squadLeader == ent) { bs->teamplayState = 0; bs->squadLeader = NULL; } break; case TEAMPLAYSTATE_FOLLOWING: bs->teamplayState = ordernum; bs->isSquadLeader = 0; bs->squadLeader = ent; bs->wpDestSwitchTime = 0; break; case TEAMPLAYSTATE_ASSISTING: bs->teamplayState = ordernum; bs->isSquadLeader = 0; bs->squadLeader = ent; bs->wpDestSwitchTime = 0; break; default: bs->teamplayState = ordernum; break; } }

int BotSurfaceNear (  bot_state_t *  bs  )

Definition at line 5833 of file ai_main.c. References AngleVectors(), bot_state_t, bot_state_s::client, trace_t::fraction, MASK_SOLID, NULL, bot_state_s::origin, trap_Trace(), vec3_t, and bot_state_s::viewangles. Referenced by StandardBotAI(). { trace_t tr; vec3_t fwd; AngleVectors(bs->viewangles, fwd, NULL, NULL); fwd[0] = bs->origin[0]+(fwd[0]*64); fwd[1] = bs->origin[1]+(fwd[1]*64); fwd[2] = bs->origin[2]+(fwd[2]*64); trap_Trace(&tr, bs->origin, NULL, NULL, fwd, bs->client, MASK_SOLID); if (tr.fraction != 1) { return 1; } return 0; }

int BotTrace_Duck (  bot_state_t *  bs, vec3_t  traceto )

Definition at line 1702 of file ai_main.c. References AngleVectors(), bot_state_t, bot_state_s::client, trace_t::fraction, MASK_PLAYERSOLID, NULL, bot_state_s::origin, trap_Trace(), vec3_t, vectoangles(), VectorCopy, and VectorSubtract. Referenced by StandardBotAI(). { vec3_t mins, maxs, a, fwd, traceto_mod, tracefrom_mod; trace_t tr; VectorSubtract(traceto, bs->origin, a); vectoangles(a, a); AngleVectors(a, fwd, NULL, NULL); traceto_mod[0] = bs->origin[0] + fwd[0]*4; traceto_mod[1] = bs->origin[1] + fwd[1]*4; traceto_mod[2] = bs->origin[2] + fwd[2]*4; mins[0] = -15; mins[1] = -15; mins[2] = -23; maxs[0] = 15; maxs[1] = 15; maxs[2] = 8; trap_Trace(&tr, bs->origin, mins, maxs, traceto_mod, bs->client, MASK_PLAYERSOLID); if (tr.fraction != 1) { return 0; } VectorCopy(bs->origin, tracefrom_mod); tracefrom_mod[2] += 31;//33; traceto_mod[2] += 31;//33; mins[0] = -15; mins[1] = -15; mins[2] = 0; maxs[0] = 15; maxs[1] = 15; maxs[2] = 32; trap_Trace(&tr, tracefrom_mod, mins, maxs, traceto_mod, bs->client, MASK_PLAYERSOLID); if (tr.fraction != 1) { return 1; } return 0; }

int BotTrace_Jump (  bot_state_t *  bs, vec3_t  traceto )

Definition at line 1638 of file ai_main.c. References AngleVectors(), bot_state_t, BotGetWeaponRange(), botstates, BWEAPONRANGE_MELEE, BWEAPONRANGE_SABER, bot_state_s::client, bot_state_s::currentEnemy, trace_t::entityNum, trace_t::fraction, bot_state_s::jumpTime, level, MASK_PLAYERSOLID, MAX_CLIENTS, NULL, entityState_s::number, bot_state_s::origin, gentity_s::s, level_locals_t::time, trap_Trace(), vec3_t, vectoangles(), VectorCopy, and VectorSubtract. Referenced by StandardBotAI(). { vec3_t mins, maxs, a, fwd, traceto_mod, tracefrom_mod; trace_t tr; int orTr; VectorSubtract(traceto, bs->origin, a); vectoangles(a, a); AngleVectors(a, fwd, NULL, NULL); traceto_mod[0] = bs->origin[0] + fwd[0]*4; traceto_mod[1] = bs->origin[1] + fwd[1]*4; traceto_mod[2] = bs->origin[2] + fwd[2]*4; mins[0] = -15; mins[1] = -15; mins[2] = -18; maxs[0] = 15; maxs[1] = 15; maxs[2] = 32; trap_Trace(&tr, bs->origin, mins, maxs, traceto_mod, bs->client, MASK_PLAYERSOLID); if (tr.fraction == 1) { return 0; } orTr = tr.entityNum; VectorCopy(bs->origin, tracefrom_mod); tracefrom_mod[2] += 41; traceto_mod[2] += 41; mins[0] = -15; mins[1] = -15; mins[2] = 0; maxs[0] = 15; maxs[1] = 15; maxs[2] = 8; trap_Trace(&tr, tracefrom_mod, mins, maxs, traceto_mod, bs->client, MASK_PLAYERSOLID); if (tr.fraction == 1) { if (orTr >= 0 && orTr < MAX_CLIENTS && botstates[orTr] && botstates[orTr]->jumpTime > level.time) { return 0; //so bots don't try to jump over each other at the same time } if (bs->currentEnemy && bs->currentEnemy->s.number == orTr && (BotGetWeaponRange(bs) == BWEAPONRANGE_SABER || BotGetWeaponRange(bs) == BWEAPONRANGE_MELEE)) { return 0; } return 1; } return 0; }

int BotTrace_Strafe (  bot_state_t *  bs, vec3_t  traceto )

Definition at line 1556 of file ai_main.c. References AngleDifference(), AngleVectors(), bot_state_t, bot_state_s::client, bot_state_s::cur_ps, DEFAULT_MAXS_2, ENTITYNUM_NONE, trace_t::fraction, playerState_s::groundEntityNum, MASK_PLAYERSOLID, bot_state_s::origin, playerMaxs, playerMins, STRAFEAROUND_LEFT, STRAFEAROUND_RIGHT, trap_Trace(), vec3_t, vectoangles(), VectorCopy, VectorNormalize(), VectorSubtract, bot_state_s::viewangles, and YAW. Referenced by StandardBotAI(). { vec3_t playerMins = {-15, -15, /*DEFAULT_MINS_2*/-8}; vec3_t playerMaxs = {15, 15, DEFAULT_MAXS_2}; vec3_t from, to; vec3_t dirAng, dirDif; vec3_t forward, right; trace_t tr; if (bs->cur_ps.groundEntityNum == ENTITYNUM_NONE) { //don't do this in the air, it can be.. dangerous. return 0; } VectorSubtract(traceto, bs->origin, dirAng); VectorNormalize(dirAng); vectoangles(dirAng, dirAng); if (AngleDifference(bs->viewangles[YAW], dirAng[YAW]) > 60 || AngleDifference(bs->viewangles[YAW], dirAng[YAW]) < -60) { //If we aren't facing the direction we're going here, then we've got enough excuse to be too stupid to strafe around anyway return 0; } VectorCopy(bs->origin, from); VectorCopy(traceto, to); VectorSubtract(to, from, dirDif); VectorNormalize(dirDif); vectoangles(dirDif, dirDif); AngleVectors(dirDif, forward, 0, 0); to[0] = from[0] + forward[0]*32; to[1] = from[1] + forward[1]*32; to[2] = from[2] + forward[2]*32; trap_Trace(&tr, from, playerMins, playerMaxs, to, bs->client, MASK_PLAYERSOLID); if (tr.fraction == 1) { return 0; } AngleVectors(dirAng, 0, right, 0); from[0] += right[0]*32; from[1] += right[1]*32; from[2] += right[2]*16; to[0] += right[0]*32; to[1] += right[1]*32; to[2] += right[2]*32; trap_Trace(&tr, from, playerMins, playerMaxs, to, bs->client, MASK_PLAYERSOLID); if (tr.fraction == 1) { return STRAFEAROUND_RIGHT; } from[0] -= right[0]*64; from[1] -= right[1]*64; from[2] -= right[2]*64; to[0] -= right[0]*64; to[1] -= right[1]*64; to[2] -= right[2]*64; trap_Trace(&tr, from, playerMins, playerMaxs, to, bs->client, MASK_PLAYERSOLID); if (tr.fraction == 1) { return STRAFEAROUND_LEFT; } return 0; }

int BotTryAnotherWeapon (  bot_state_t *  bs  )

Definition at line 5072 of file ai_main.c. References playerState_s::ammo, weaponData_s::ammoIndex, bot_state_t, BotSelectWeapon(), bot_state_s::client, bot_state_s::cur_ps, weaponData_s::energyPerShot, STAT_WEAPONS, playerState_s::stats, bot_state_s::virtualWeapon, playerState_s::weapon, weaponData, and WP_NUM_WEAPONS. Referenced by StandardBotAI(). { //out of ammo, resort to the first weapon we come across that has ammo int i; i = 1; while (i < WP_NUM_WEAPONS) { if (bs->cur_ps.ammo[weaponData[i].ammoIndex] >= weaponData[i].energyPerShot && (bs->cur_ps.stats[STAT_WEAPONS] & (1 << i))) { bs->virtualWeapon = i; BotSelectWeapon(bs->client, i); //bs->cur_ps.weapon = i; //level.clients[bs->client].ps.weapon = i; return 1; } i++; } if (bs->cur_ps.weapon != 1 && bs->virtualWeapon != 1) { //should always have this.. shouldn't we? bs->virtualWeapon = 1; BotSelectWeapon(bs->client, 1); //bs->cur_ps.weapon = 1; //level.clients[bs->client].ps.weapon = 1; return 1; } return 0; }

void BotUpdateInput (  bot_state_t *  bs, int  time, int  elapsed_time )

Definition at line 633 of file ai_main.c. References ACTION_ATTACK, ACTION_RESPAWN, bot_input_s::actionflags, AngleMod(), bot_input_t, bot_state_t, BotChangeViewAngles(), BotInputToUserCommand(), BUTTON_ATTACK, usercmd_s::buttons, bot_state_s::client, bot_state_s::cur_ps, playerState_s::delta_angles, bot_state_s::lastucmd, bot_state_s::noUseTime, SHORT2ANGLE, trap_EA_GetInput(), and bot_state_s::viewangles. Referenced by BotAIStartFrame(). { bot_input_t bi; int j; //add the delta angles to the bot's current view angles for (j = 0; j < 3; j++) { bs->viewangles[j] = AngleMod(bs->viewangles[j] + SHORT2ANGLE(bs->cur_ps.delta_angles[j])); } //change the bot view angles BotChangeViewAngles(bs, (float) elapsed_time / 1000); //retrieve the bot input trap_EA_GetInput(bs->client, (float) time / 1000, &bi); //respawn hack if (bi.actionflags & ACTION_RESPAWN) { if (bs->lastucmd.buttons & BUTTON_ATTACK) bi.actionflags &= ~(ACTION_RESPAWN|ACTION_ATTACK); } //convert the bot input to a usercmd BotInputToUserCommand(&bi, &bs->lastucmd, bs->cur_ps.delta_angles, time, bs->noUseTime); //subtract the delta angles for (j = 0; j < 3; j++) { bs->viewangles[j] = AngleMod(bs->viewangles[j] - SHORT2ANGLE(bs->cur_ps.delta_angles[j])); } }

int BotUseInventoryItem (  bot_state_t *  bs  )

Definition at line 5780 of file ai_main.c. References BG_GetItemIndexByTag(), bot_state_t, bot_state_s::client, level_locals_t::clients, bot_state_s::cur_ps, bot_state_s::currentEnemy, bot_state_s::frame_Enemy_Vis, g_entities, HI_MEDPAC, HI_MEDPAC_BIG, HI_SEEKER, HI_SENTRY_GUN, HI_SHIELD, IT_HOLDABLE, level, bot_state_s::runningToEscapeThreat, STAT_HOLDABLE_ITEM, STAT_HOLDABLE_ITEMS, and playerState_s::stats. Referenced by StandardBotAI(). { if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_MEDPAC)) { if (g_entities[bs->client].health <= 75) { bs->cur_ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_MEDPAC, IT_HOLDABLE); goto wantuseitem; } } if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_MEDPAC_BIG)) { if (g_entities[bs->client].health <= 50) { bs->cur_ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_MEDPAC_BIG, IT_HOLDABLE); goto wantuseitem; } } if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SEEKER)) { if (bs->currentEnemy && bs->frame_Enemy_Vis) { bs->cur_ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_SEEKER, IT_HOLDABLE); goto wantuseitem; } } if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SENTRY_GUN)) { if (bs->currentEnemy && bs->frame_Enemy_Vis) { bs->cur_ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_SENTRY_GUN, IT_HOLDABLE); goto wantuseitem; } } if (bs->cur_ps.stats[STAT_HOLDABLE_ITEMS] & (1 << HI_SHIELD)) { if (bs->currentEnemy && bs->frame_Enemy_Vis && bs->runningToEscapeThreat) { //this will (hopefully) result in the bot placing the shield down while facing //the enemy and running away bs->cur_ps.stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(HI_SHIELD, IT_HOLDABLE); goto wantuseitem; } } return 0; wantuseitem: level.clients[bs->client].ps.stats[STAT_HOLDABLE_ITEM] = bs->cur_ps.stats[STAT_HOLDABLE_ITEM]; return 1; }

int BotWeaponBlockable (  int  weapon  )

Definition at line 5855 of file ai_main.c. References WP_DEMP2, WP_DET_PACK, WP_DISRUPTOR, WP_MELEE, WP_ROCKET_LAUNCHER, WP_STUN_BATON, WP_THERMAL, and WP_TRIP_MINE. Referenced by StandardBotAI(). { switch (weapon) { case WP_STUN_BATON: case WP_MELEE: return 0; case WP_DISRUPTOR: return 0; case WP_DEMP2: return 0; case WP_ROCKET_LAUNCHER: return 0; case WP_THERMAL: return 0; case WP_TRIP_MINE: return 0; case WP_DET_PACK: return 0; default: return 1; } }

float BotWeaponCanLead (  bot_state_t *  bs  )

Definition at line 4570 of file ai_main.c. References bot_state_t, bot_state_s::cur_ps, playerState_s::weapon, WP_BLASTER, WP_BOWCASTER, WP_BRYAR_PISTOL, WP_DEMP2, WP_REPEATER, WP_ROCKET_LAUNCHER, and WP_THERMAL. Referenced by StandardBotAI(). { int weap = bs->cur_ps.weapon; if (weap == WP_BRYAR_PISTOL) { return 0.5; } if (weap == WP_BLASTER) { return 0.35; } if (weap == WP_BOWCASTER) { return 0.5; } if (weap == WP_REPEATER) { return 0.45; } if (weap == WP_THERMAL) { return 0.5; } if (weap == WP_DEMP2) { return 0.35; } if (weap == WP_ROCKET_LAUNCHER) { return 0.7; } return 0; }

qboolean BotWeaponSelectable (  bot_state_t *  bs, int  weapon )

Definition at line 5106 of file ai_main.c. References playerState_s::ammo, weaponData_s::ammoIndex, bot_state_t, bot_state_s::cur_ps, weaponData_s::energyPerShot, qboolean, qfalse, qtrue, STAT_WEAPONS, playerState_s::stats, weaponData, and WP_NONE. Referenced by BotSelectIdealWeapon(). { if (weapon == WP_NONE) { return qfalse; } if (bs->cur_ps.ammo[weaponData[weapon].ammoIndex] >= weaponData[weapon].energyPerShot && (bs->cur_ps.stats[STAT_WEAPONS] & (1 << weapon))) { return qtrue; } return qfalse; }

gentity_t* CheckForFriendInLOF (  bot_state_t *  bs  )

Definition at line 5538 of file ai_main.c. References AngleVectors(), bot_state_t, botstates, gentity_s::client, bot_state_s::client, trace_t::entityNum, bot_state_s::eye, trace_t::fraction, g_entities, gentity_t, GetLoveLevel(), IsTeamplay(), MASK_PLAYERSOLID, MAX_CLIENTS, NULL, entityState_s::number, OnSameTeam(), gentity_s::s, trap_Trace(), vec3_t, VectorCopy, and bot_state_s::viewangles. Referenced by StandardBotAI(). { vec3_t fwd; vec3_t trfrom, trto; vec3_t mins, maxs; gentity_t *trent; trace_t tr; mins[0] = -3; mins[1] = -3; mins[2] = -3; maxs[0] = 3; maxs[1] = 3; maxs[2] = 3; AngleVectors(bs->viewangles, fwd, NULL, NULL); VectorCopy(bs->eye, trfrom); trto[0] = trfrom[0] + fwd[0]*2048; trto[1] = trfrom[1] + fwd[1]*2048; trto[2] = trfrom[2] + fwd[2]*2048; trap_Trace(&tr, trfrom, mins, maxs, trto, bs->client, MASK_PLAYERSOLID); if (tr.fraction != 1 && tr.entityNum <= MAX_CLIENTS) { trent = &g_entities[tr.entityNum]; if (trent && trent->client) { if (IsTeamplay() && OnSameTeam(&g_entities[bs->client], trent)) { return trent; } if (botstates[trent->s.number] && GetLoveLevel(bs, botstates[trent->s.number]) > 1) { return trent; } } } return NULL; }

int CheckForFunc (  vec3_t  org, int  ignore )

Definition at line 1053 of file ai_main.c. References gentity_s::classname, trace_t::entityNum, trace_t::fraction, g_entities, gentity_t, MASK_SOLID, NULL, strstr(), trap_Trace(), vec3_t, and VectorCopy. Referenced by StandardBotAI(), and WaitingForNow(). { gentity_t *fent; vec3_t under; trace_t tr; VectorCopy(org, under); under[2] -= 64; trap_Trace(&tr, org, NULL, NULL, under, ignore, MASK_SOLID); if (tr.fraction == 1) { return 0; } fent = &g_entities[tr.entityNum]; if (!fent) { return 0; } if (strstr(fent->classname, "func_")) { return 1; //there's a func brush here } return 0; }

void CheckForShorterRoutes (  bot_state_t *  bs, int  newwpindex )

Definition at line 1263 of file ai_main.c. References bot_state_s::beStill, bot_state_t, bot_state_s::cur_ps, playerState_s::fd, bot_state_s::forceJumpChargeTime, bot_state_s::forceJumping, wpneighbor_s::forceJumpTo, forcedata_s::forcePowerLevel, FP_LEVITATION, gWPArray, wpobject_s::index, bot_state_s::jDelay, bot_state_s::jumpTime, level, wpobject_s::neighbornum, wpobject_s::neighbors, wpneighbor_s::num, level_locals_t::time, TotalTrailDistance(), bot_state_s::wpCurrent, bot_state_s::wpDestination, bot_state_s::wpDirection, and bot_state_s::wpSwitchTime. Referenced by WPTouchRoutine(). { float bestlen; float checklen; int bestindex; int i; int fj; i = 0; fj = 0; if (!bs->wpDestination) { return; } //set our traversal direction based on the index of the point if (newwpindex < bs->wpDestination->index) { bs->wpDirection = 0; } else if (newwpindex > bs->wpDestination->index) { bs->wpDirection = 1; } //can't switch again yet if (bs->wpSwitchTime > level.time) { return; } //no neighboring points to check off of if (!gWPArray[newwpindex]->neighbornum) { return; } //get the trail distance for our wp bestindex = newwpindex; bestlen = TotalTrailDistance(newwpindex, bs->wpDestination->index, bs); while (i < gWPArray[newwpindex]->neighbornum) { //now go through the neighbors and check the distance to the desired point from each neighbor checklen = TotalTrailDistance(gWPArray[newwpindex]->neighbors[i].num, bs->wpDestination->index, bs); if (checklen < bestlen-64 || bestlen == -1) { //this path covers less distance, let's take it instead if (bs->cur_ps.fd.forcePowerLevel[FP_LEVITATION] >= gWPArray[newwpindex]->neighbors[i].forceJumpTo) { bestlen = checklen; bestindex = gWPArray[newwpindex]->neighbors[i].num; if (gWPArray[newwpindex]->neighbors[i].forceJumpTo) { fj = gWPArray[newwpindex]->neighbors[i].forceJumpTo; } else { fj = 0; } } } i++; } if (bestindex != newwpindex && bestindex != -1) { //we found a path we want to switch to, let's do it bs->wpCurrent = gWPArray[bestindex]; bs->wpSwitchTime = level.time + 3000; if (fj) { //do we have to force jump to get to this neighbor? #ifndef FORCEJUMP_INSTANTMETHOD bs->forceJumpChargeTime = level.time + 1000; bs->beStill = level.time + 1000; bs->forceJumping = bs->forceJumpChargeTime; #else bs->beStill = level.time + 500; bs->jumpTime = level.time + fj*1200; bs->jDelay = level.time + 200; bs->forceJumping = bs->jumpTime; #endif } } }

void Cmd_EngageDuel_f (  gentity_t *  ent  )

Definition at line 2766 of file g_cmds.c. { trace_t tr; vec3_t forward, fwdOrg; if (!g_privateDuel.integer) { return; } if (g_gametype.integer == GT_DUEL || g_gametype.integer == GT_POWERDUEL) { //rather pointless in this mode.. trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NODUEL_GAMETYPE")) ); return; } //if (g_gametype.integer >= GT_TEAM && g_gametype.integer != GT_SIEGE) if (g_gametype.integer >= GT_TEAM) { //no private dueling in team modes trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "NODUEL_GAMETYPE")) ); return; } if (ent->client->ps.duelTime >= level.time) { return; } if (ent->client->ps.weapon != WP_SABER) { return; } /* if (!ent->client->ps.saberHolstered) { //must have saber holstered at the start of the duel return; } */ //NOTE: No longer doing this.. if (ent->client->ps.saberInFlight) { return; } if (ent->client->ps.duelInProgress) { return; } //New: Don't let a player duel if he just did and hasn't waited 10 seconds yet (note: If someone challenges him, his duel timer will reset so he can accept) if (ent->client->ps.fd.privateDuelTime > level.time) { trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "CANTDUEL_JUSTDID")) ); return; } if (G_OtherPlayersDueling()) { trap_SendServerCommand( ent-g_entities, va("print \"%s\n\"", G_GetStringEdString("MP_SVGAME", "CANTDUEL_BUSY")) ); return; } AngleVectors( ent->client->ps.viewangles, forward, NULL, NULL ); fwdOrg[0] = ent->client->ps.origin[0] + forward[0]*256; fwdOrg[1] = ent->client->ps.origin[1] + forward[1]*256; fwdOrg[2] = (ent->client->ps.origin[2]+ent->client->ps.viewheight) + forward[2]*256; trap_Trace(&tr, ent->client->ps.origin, NULL, NULL, fwdOrg, ent->s.number, MASK_PLAYERSOLID); if (tr.fraction != 1 && tr.entityNum < MAX_CLIENTS) { gentity_t *challenged = &g_entities[tr.entityNum]; if (!challenged || !challenged->client || !challenged->inuse || challenged->health < 1 || challenged->client->ps.stats[STAT_HEALTH] < 1 || challenged->client->ps.weapon != WP_SABER || challenged->client->ps.duelInProgress || challenged->client->ps.saberInFlight) { return; } if (g_gametype.integer >= GT_TEAM && OnSameTeam(ent, challenged)) { return; } if (challenged->client->ps.duelIndex == ent->s.number && challenged->client->ps.duelTime >= level.time) { trap_SendServerCommand( /*challenged-g_entities*/-1, va("print \"%s %s %s!\n\"", challenged->client->pers.netname, G_GetStringEdString("MP_SVGAME", "PLDUELACCEPT"), ent->client->pers.netname) ); ent->client->ps.duelInProgress = qtrue; challenged->client->ps.duelInProgress = qtrue; ent->client->ps.duelTime = level.time + 2000; challenged->client->ps.duelTime = level.time + 2000; G_AddEvent(ent, EV_PRIVATE_DUEL, 1); G_AddEvent(challenged, EV_PRIVATE_DUEL, 1); //Holster their sabers now, until the duel starts (then they'll get auto-turned on to look cool) if (!ent->client->ps.saberHolstered) { if (ent->client->saber[0].soundOff) { G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOff); } if (ent->client->saber[1].soundOff && ent->client->saber[1].model[0]) { G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOff); } ent->client->ps.weaponTime = 400; ent->client->ps.saberHolstered = 2; } if (!challenged->client->ps.saberHolstered) { if (challenged->client->saber[0].soundOff) { G_Sound(challenged, CHAN_AUTO, challenged->client->saber[0].soundOff); } if (challenged->client->saber[1].soundOff && challenged->client->saber[1].model[0]) { G_Sound(challenged, CHAN_AUTO, challenged->client->saber[1].soundOff); } challenged->client->ps.weaponTime = 400; challenged->client->ps.saberHolstered = 2; } } else { //Print the message that a player has been challenged in private, only announce the actual duel initiation in private trap_SendServerCommand( challenged-g_entities, va("cp \"%s %s\n\"", ent->client->pers.netname, G_GetStringEdString("MP_SVGAME", "PLDUELCHALLENGE")) ); trap_SendServerCommand( ent-g_entities, va("cp \"%s %s\n\"", G_GetStringEdString("MP_SVGAME", "PLDUELCHALLENGED"), challenged->client->pers.netname) ); } challenged->client->ps.fd.privateDuelTime = 0; //reset the timer in case this player just got out of a duel. He should still be able to accept the challenge. ent->client->ps.forceHandExtend = HANDEXTEND_DUELCHALLENGE; ent->client->ps.forceHandExtendTime = level.time + 1000; ent->client->ps.duelIndex = challenged->s.number; ent->client->ps.duelTime = level.time + 5000; } }

void Cmd_ToggleSaber_f (  gentity_t *  ent  )

Definition at line 2467 of file g_cmds.c. { if (ent->client->ps.fd.forceGripCripple) { //if they are being gripped, don't let them unholster their saber if (ent->client->ps.saberHolstered) { return; } } if (ent->client->ps.saberInFlight) { if (ent->client->ps.saberEntityNum) { //turn it off in midair saberKnockDown(&g_entities[ent->client->ps.saberEntityNum], ent, ent); } return; } if (ent->client->ps.forceHandExtend != HANDEXTEND_NONE) { return; } if (ent->client->ps.weapon != WP_SABER) { return; } // if (ent->client->ps.duelInProgress && !ent->client->ps.saberHolstered) // { // return; // } if (ent->client->ps.duelTime >= level.time) { return; } if (ent->client->ps.saberLockTime >= level.time) { return; } if (ent->client && ent->client->ps.weaponTime < 1) { if (ent->client->ps.saberHolstered == 2) { ent->client->ps.saberHolstered = 0; if (ent->client->saber[0].soundOn) { G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOn); } if (ent->client->saber[1].soundOn) { G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOn); } } else { ent->client->ps.saberHolstered = 2; if (ent->client->saber[0].soundOff) { G_Sound(ent, CHAN_AUTO, ent->client->saber[0].soundOff); } if (ent->client->saber[1].soundOff && ent->client->saber[1].model[0]) { G_Sound(ent, CHAN_AUTO, ent->client->saber[1].soundOff); } //prevent anything from being done for 400ms after holster ent->client->ps.weaponTime = 400; } } }

int CombatBotAI (  bot_state_t *  bs, float  thinktime )

Definition at line 4885 of file ai_main.c. References bot_state_s::altChargeTime, bot_state_t, BotGetWeaponRange(), BWEAPONRANGE_MELEE, BWEAPONRANGE_SABER, gentity_s::client, bot_state_s::cur_ps, bot_state_s::currentEnemy, bot_state_s::doAltAttack, bot_state_s::doAttack, bot_state_s::eye, bot_state_s::frame_Enemy_Len, InFieldOfVision(), level, MELEE_ATTACK_RANGE, entityState_s::origin, playerState_s::origin, gclient_s::ps, Q_irand(), gentity_s::s, SABER_ATTACK_RANGE, ShouldSecondaryFire(), level_locals_t::time, vec3_t, vectoangles(), VectorCopy, VectorSubtract, bot_state_s::viewangles, playerState_s::weapon, WEAPON_CHARGING, WEAPON_CHARGING_ALT, playerState_s::weaponChargeTime, playerState_s::weaponstate, WP_ROCKET_LAUNCHER, and WP_THERMAL. Referenced by StandardBotAI(). { vec3_t eorg, a; int secFire; float fovcheck; if (!bs->currentEnemy) { return 0; } if (bs->currentEnemy->client) { VectorCopy(bs->currentEnemy->client->ps.origin, eorg); } else { VectorCopy(bs->currentEnemy->s.origin, eorg); } VectorSubtract(eorg, bs->eye, a); vectoangles(a, a); if (BotGetWeaponRange(bs) == BWEAPONRANGE_SABER) { if (bs->frame_Enemy_Len <= SABER_ATTACK_RANGE) { bs->doAttack = 1; } } else if (BotGetWeaponRange(bs) == BWEAPONRANGE_MELEE) { if (bs->frame_Enemy_Len <= MELEE_ATTACK_RANGE) { bs->doAttack = 1; } } else { if (bs->cur_ps.weapon == WP_THERMAL || bs->cur_ps.weapon == WP_ROCKET_LAUNCHER) { //be careful with the hurty weapons fovcheck = 40; if (bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT && bs->cur_ps.weapon == WP_ROCKET_LAUNCHER) { //if we're charging the weapon up then we can hold fire down within a normal fov fovcheck = 60; } } else { fovcheck = 60; } if (bs->cur_ps.weaponstate == WEAPON_CHARGING || bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT) { fovcheck = 160; } if (bs->frame_Enemy_Len < 128) { fovcheck *= 2; } if (InFieldOfVision(bs->viewangles, fovcheck, a)) { if (bs->cur_ps.weapon == WP_THERMAL) { if (((level.time - bs->cur_ps.weaponChargeTime) < (bs->frame_Enemy_Len*2) && (level.time - bs->cur_ps.weaponChargeTime) < 4000 && bs->frame_Enemy_Len > 64) || (bs->cur_ps.weaponstate != WEAPON_CHARGING && bs->cur_ps.weaponstate != WEAPON_CHARGING_ALT)) { if (bs->cur_ps.weaponstate != WEAPON_CHARGING && bs->cur_ps.weaponstate != WEAPON_CHARGING_ALT) { if (bs->frame_Enemy_Len > 512 && bs->frame_Enemy_Len < 800) { bs->doAltAttack = 1; //bs->doAttack = 1; } else { bs->doAttack = 1; //bs->doAltAttack = 1; } } if (bs->cur_ps.weaponstate == WEAPON_CHARGING) { bs->doAttack = 1; } else if (bs->cur_ps.weaponstate == WEAPON_CHARGING_ALT) { bs->doAltAttack = 1; } } } else { secFire = ShouldSecondaryFire(bs); if (bs->cur_ps.weaponstate != WEAPON_CHARGING_ALT && bs->cur_ps.weaponstate != WEAPON_CHARGING) { bs->altChargeTime = Q_irand(500, 1000); } if (secFire == 1) { bs->doAltAttack = 1; } else if (!secFire) { if (bs->cur_ps.weapon != WP_THERMAL) { if (bs->cur_ps.weaponstate != WEAPON_CHARGING || bs->altChargeTime > (level.time - bs->cur_ps.weaponChargeTime)) { bs->doAttack = 1; } } else { bs->doAttack = 1; } } if (secFire == 2) { //released a charge return 1; } } } } return 0; }

void CommanderBotAI (  bot_state_t *  bs  )

Definition at line 4252 of file ai_main.c. References bot_state_t, CommanderBotCTFAI(), CommanderBotSiegeAI(), CommanderBotTeamplayAI(), g_gametype, GT_CTF, GT_CTY, GT_SIEGE, GT_TEAM, and vmCvar_t::integer. Referenced by StandardBotAI(). { if (g_gametype.integer == GT_CTF || g_gametype.integer == GT_CTY) { CommanderBotCTFAI(bs); } else if (g_gametype.integer == GT_SIEGE) { CommanderBotSiegeAI(bs); } else if (g_gametype.integer == GT_TEAM) { CommanderBotTeamplayAI(bs); } }

void CommanderBotCTFAI (  bot_state_t *  bs  )

Definition at line 3911 of file ai_main.c. References bot_state_t, botstates, gentity_s::client, bot_state_s::client, level_locals_t::clients, bot_state_s::ctfState, CTFSTATE_ATTACKER, CTFSTATE_DEFENDER, CTFSTATE_GETFLAGHOME, CTFSTATE_GUARDCARRIER, CTFSTATE_RETRIEVAL, g_entities, gentity_t, level, MAX_CLIENTS, entityState_s::number, OnSameTeam(), playerState_s::powerups, gclient_s::ps, PW_BLUEFLAG, PW_REDFLAG, gentity_s::s, bot_state_s::squadLeader, and TEAM_RED. Referenced by CommanderBotAI(). { int i = 0; gentity_t *ent; int squadmates = 0; gentity_t *squad[MAX_CLIENTS]; int defendAttackPriority = 0; //0 == attack, 1 == defend int guardDefendPriority = 0; //0 == defend, 1 == guard int attackRetrievePriority = 0; //0 == retrieve, 1 == attack int myFlag = 0; int enemyFlag = 0; int enemyHasOurFlag = 0; int weHaveEnemyFlag = 0; int numOnMyTeam = 0; int numOnEnemyTeam = 0; int numAttackers = 0; int numDefenders = 0; if (level.clients[bs->client].sess.sessionTeam == TEAM_RED) { myFlag = PW_REDFLAG; } else { myFlag = PW_BLUEFLAG; } if (level.clients[bs->client].sess.sessionTeam == TEAM_RED) { enemyFlag = PW_BLUEFLAG; } else { enemyFlag = PW_REDFLAG; } while (i < MAX_CLIENTS) { ent = &g_entities[i]; if (ent && ent->client) { if (ent->client->ps.powerups[enemyFlag] && OnSameTeam(&g_entities[bs->client], ent)) { weHaveEnemyFlag = 1; } else if (ent->client->ps.powerups[myFlag] && !OnSameTeam(&g_entities[bs->client], ent)) { enemyHasOurFlag = 1; } if (OnSameTeam(&g_entities[bs->client], ent)) { numOnMyTeam++; } else { numOnEnemyTeam++; } if (botstates[ent->s.number]) { if (botstates[ent->s.number]->ctfState == CTFSTATE_ATTACKER || botstates[ent->s.number]->ctfState == CTFSTATE_RETRIEVAL) { numAttackers++; } else { numDefenders++; } } else { //assume real players to be attackers in our logic numAttackers++; } } i++; } i = 0; while (i < MAX_CLIENTS) { ent = &g_entities[i]; if (ent && ent->client && botstates[i] && botstates[i]->squadLeader && botstates[i]->squadLeader->s.number == bs->client && i != bs->client) { squad[squadmates] = ent; squadmates++; } i++; } squad[squadmates] = &g_entities[bs->client]; squadmates++; i = 0; if (enemyHasOurFlag && !weHaveEnemyFlag) { //start off with an attacker instead of a retriever if we don't have the enemy flag yet so that they can't capture it first. //after that we focus on getting our flag back. attackRetrievePriority = 1; } while (i < squadmates) { if (squad[i] && squad[i]->client && botstates[squad[i]->s.number]) { if (botstates[squad[i]->s.number]->ctfState != CTFSTATE_GETFLAGHOME) { //never tell a bot to stop trying to bring the flag to the base if (defendAttackPriority) { if (weHaveEnemyFlag) { if (guardDefendPriority) { botstates[squad[i]->s.number]->ctfState = CTFSTATE_GUARDCARRIER; guardDefendPriority = 0; } else { botstates[squad[i]->s.number]->ctfState = CTFSTATE_DEFENDER; guardDefendPriority = 1; } } else { botstates[squad[i]->s.number]->ctfState = CTFSTATE_DEFENDER; } defendAttackPriority = 0; } else { if (enemyHasOurFlag) { if (attackRetrievePriority) { botstates[squad[i]->s.number]->ctfState = CTFSTATE_ATTACKER; attackRetrievePriority = 0; } else { botstates[squad[i]->s.number]->ctfState = CTFSTATE_RETRIEVAL; attackRetrievePriority = 1; } } else { botstates[squad[i]->s.number]->ctfState = CTFSTATE_ATTACKER; } defendAttackPriority = 1; } } else if ((numOnMyTeam < 2 || !numAttackers) && enemyHasOurFlag) { //I'm the only one on my team who will attack and the enemy has my flag, I have to go after him botstates[squad[i]->s.number]->ctfState = CTFSTATE_RETRIEVAL; } } i++; } }

void CommanderBotSiegeAI (  bot_state_t *  bs  )

Definition at line 4077 of file ai_main.c. References bot_state_t, botstates, bot_state_s::client, gentity_s::client, g_entities, gentity_t, bot_state_s::isSquadLeader, MAX_CLIENTS, entityState_s::number, OnSameTeam(), gentity_s::s, bot_state_s::siegeState, and bot_state_s::state_Forced. Referenced by CommanderBotAI(). { int i = 0; int squadmates = 0; int commanded = 0; int teammates = 0; gentity_t *squad[MAX_CLIENTS]; gentity_t *ent; bot_state_t *bst; while (i < MAX_CLIENTS) { ent = &g_entities[i]; if (ent && ent->client && OnSameTeam(&g_entities[bs->client], ent) && botstates[ent->s.number]) { bst = botstates[ent->s.number]; if (bst && !bst->isSquadLeader && !bst->state_Forced) { squad[squadmates] = ent; squadmates++; } else if (bst && !bst->isSquadLeader && bst->state_Forced) { //count them as commanded commanded++; } } if (ent && ent->client && OnSameTeam(&g_entities[bs->client], ent)) { teammates++; } i++; } if (!squadmates) { return; } //tell squad mates to do what I'm doing, up to half of team, let the other half make their own decisions i = 0; while (i < squadmates && squad[i]) { bst = botstates[squad[i]->s.number]; if (commanded > teammates/2) { break; } if (bst) { bst->state_Forced = bs->siegeState; bst->siegeState = bs->siegeState; commanded++; } i++; } }

void CommanderBotTeamplayAI (  bot_state_t *  bs  )

Definition at line 4158 of file ai_main.c. References bot_state_t, botstates, bot_state_s::client, gentity_s::client, g_entities, gentity_t, gentity_s::health, bot_state_s::isSquadLeader, level, MAX_CLIENTS, entityState_s::number, OnSameTeam(), Q_irand(), gentity_s::s, bot_state_s::squadCannotLead, bot_state_s::squadLeader, bot_state_s::squadRegroupInterval, bot_state_s::state_Forced, bot_state_s::teamplayState, TEAMPLAYSTATE_ASSISTING, TEAMPLAYSTATE_FOLLOWING, TEAMPLAYSTATE_REGROUP, and level_locals_t::time. Referenced by CommanderBotAI(). { int i = 0; int squadmates = 0; int teammates = 0; int teammate_indanger = -1; int teammate_helped = 0; int foundsquadleader = 0; int worsthealth = 50; gentity_t *squad[MAX_CLIENTS]; gentity_t *ent; bot_state_t *bst; while (i < MAX_CLIENTS) { ent = &g_entities[i]; if (ent && ent->client && OnSameTeam(&g_entities[bs->client], ent) && botstates[ent->s.number]) { bst = botstates[ent->s.number]; if (foundsquadleader && bst && bst->isSquadLeader) { //never more than one squad leader bst->isSquadLeader = 0; } if (bst && !bst->isSquadLeader) { squad[squadmates] = ent; squadmates++; } else if (bst) { foundsquadleader = 1; } } if (ent && ent->client && OnSameTeam(&g_entities[bs->client], ent)) { teammates++; if (ent->health < worsthealth) { teammate_indanger = ent->s.number; worsthealth = ent->health; } } i++; } if (!squadmates) { return; } i = 0; while (i < squadmates && squad[i]) { bst = botstates[squad[i]->s.number]; if (bst && !bst->state_Forced) { //only order if this guy is not being ordered directly by the real player team leader if (teammate_indanger >= 0 && !teammate_helped) { //send someone out to help whoever needs help most at the moment bst->teamplayState = TEAMPLAYSTATE_ASSISTING; bst->squadLeader = &g_entities[teammate_indanger]; teammate_helped = 1; } else if ((teammate_indanger == -1 || teammate_helped) && bst->teamplayState == TEAMPLAYSTATE_ASSISTING) { //no teammates need help badly, but this guy is trying to help them anyway, so stop bst->teamplayState = TEAMPLAYSTATE_FOLLOWING; bst->squadLeader = &g_entities[bs->client]; } if (bs->squadRegroupInterval < level.time && Q_irand(1, 10) < 5) { //every so often tell the squad to regroup for the sake of variation if (bst->teamplayState == TEAMPLAYSTATE_FOLLOWING) { bst->teamplayState = TEAMPLAYSTATE_REGROUP; } bs->isSquadLeader = 0; bs->squadCannotLead = level.time + 500; bs->squadRegroupInterval = level.time + Q_irand(45000, 65000); } } i++; } }

void CTFFlagMovement (  bot_state_t *  bs  )

Definition at line 5647 of file ai_main.c. References BOT_FLAG_GET_DISTANCE, bot_state_t, gentity_s::classname, bot_state_s::client, droppedBlueFlag, droppedRedFlag, trace_t::entityNum, FL_DROPPED_ITEM, flagBlue, flagRed, gentity_s::flags, trace_t::fraction, gentity_t, bot_state_s::goalPosition, MASK_SOLID, NULL, entityState_s::number, bot_state_s::origin, entityState_s::pos, gentity_s::s, bot_state_s::staticFlagSpot, strcmp(), trap_Trace(), trajectory_t::trBase, vec3_t, VectorCopy, VectorSubtract, bot_state_s::wantFlag, and bot_state_s::wpDestination. Referenced by StandardBotAI(). { int diddrop = 0; gentity_t *desiredDrop = NULL; vec3_t a, mins, maxs; trace_t tr; mins[0] = -15; mins[1] = -15; mins[2] = -7; maxs[0] = 15; maxs[1] = 15; maxs[2] = 7; if (bs->wantFlag && (bs->wantFlag->flags & FL_DROPPED_ITEM)) { if (bs->staticFlagSpot[0] == bs->wantFlag->s.pos.trBase[0] && bs->staticFlagSpot[1] == bs->wantFlag->s.pos.trBase[1] && bs->staticFlagSpot[2] == bs->wantFlag->s.pos.trBase[2]) { VectorSubtract(bs->origin, bs->wantFlag->s.pos.trBase, a); if (VectorLength(a) <= BOT_FLAG_GET_DISTANCE) { VectorCopy(bs->wantFlag->s.pos.trBase, bs->goalPosition); return; } else { bs->wantFlag = NULL; } } else { bs->wantFlag = NULL; } } else if (bs->wantFlag) { bs->wantFlag = NULL; } if (flagRed && flagBlue) { if (bs->wpDestination == flagRed || bs->wpDestination == flagBlue) { if (bs->wpDestination == flagRed && droppedRedFlag && (droppedRedFlag->flags & FL_DROPPED_ITEM) && droppedRedFlag->classname && strcmp(droppedRedFlag->classname, "freed") != 0) { desiredDrop = droppedRedFlag; diddrop = 1; } if (bs->wpDestination == flagBlue && droppedBlueFlag && (droppedBlueFlag->flags & FL_DROPPED_ITEM) && droppedBlueFlag->classname && strcmp(droppedBlueFlag->classname, "freed") != 0) { desiredDrop = droppedBlueFlag; diddrop = 1; } if (diddrop && desiredDrop) { VectorSubtract(bs->origin, desiredDrop->s.pos.trBase, a); if (VectorLength(a) <= BOT_FLAG_GET_DISTANCE) { trap_Trace(&tr, bs->origin, mins, maxs, desiredDrop->s.pos.trBase, bs->client, MASK_SOLID); if (tr.fraction == 1 || tr.entityNum == desiredDrop->s.number) { VectorCopy(desiredDrop->s.pos.trBase, bs->goalPosition); VectorCopy(desiredDrop->s.pos.trBase, bs->staticFlagSpot); return; } } } } } }

int CTFTakesPriority (  bot_state_t *  bs  )

Definition at line 2804 of file ai_main.c. References BOT_MAX_WEAPON_CHASE_CTF, BOT_MAX_WEAPON_GATHER_TIME, bot_state_t, BotDefendFlag(), BotGetEnemyFlag(), BotGetFlagBack(), BotGetFlagHome(),