602 lines
17 KiB
C++
602 lines
17 KiB
C++
// Copyright (C) 2007 Id Software, Inc.
|
|
//
|
|
|
|
#include "../precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "../Game_local.h"
|
|
#include "BotThreadData.h"
|
|
#include "BotAI_Main.h"
|
|
|
|
/*
|
|
================
|
|
idBotAI::Run_LTG_Node
|
|
|
|
This is the bot's long term goal thinking.
|
|
================
|
|
*/
|
|
bool idBotAI::Run_LTG_Node() {
|
|
|
|
//mal: first, lets check if we should be running a different node....
|
|
if ( botWorld->gameLocalInfo.inWarmup && botWorld->gameLocalInfo.botsSillyWarmup != false ) {
|
|
ROOT_AI_NODE = &idBotAI::Run_Warmup_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.inEndGame ) {
|
|
ROOT_AI_NODE = &idBotAI::Run_Intermission_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( ClientIsDead( botNum ) ) {
|
|
ROOT_AI_NODE = &idBotAI::Enter_Run_Dead_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( timeTilAttackEnemy != -1 && timeTilAttackEnemy < botWorld->gameLocalInfo.time && enemy != -1 ) {
|
|
Bot_SetTimeOnTarget( false );
|
|
ROOT_AI_NODE = &idBotAI::Run_Combat_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( LTG_AI_SUB_NODE == NULL ) {
|
|
if ( !PopAINodeOffStack() ) {
|
|
Bot_FindLongTermGoal();
|
|
assert( LTG_AI_SUB_NODE != NULL );
|
|
}
|
|
}
|
|
|
|
aiState = LTG;
|
|
|
|
CallFuncPtr( LTG_AI_SUB_NODE ); //mal: run the bot's current Long Term Goal think node
|
|
|
|
Bot_Check_NBG_Goals();
|
|
|
|
Bot_CheckWeapon();
|
|
|
|
Bot_CheckClassState(); //mal: check if we should do some kind of class based action on the move!
|
|
|
|
Bot_CheckForDangers( false );
|
|
|
|
if ( enemy <= -1 ) {
|
|
Bot_FindEnemy( -1 );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
idBotAI::Run_NBG_Node
|
|
|
|
This is the bot's short term goal thinking.
|
|
================
|
|
*/
|
|
bool idBotAI::Run_NBG_Node() {
|
|
|
|
//mal: first, lets check if we should be running a different node....
|
|
if ( botWorld->gameLocalInfo.inWarmup && botWorld->gameLocalInfo.botsSillyWarmup != false ) {
|
|
ROOT_AI_NODE = &idBotAI::Run_Warmup_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.inEndGame ) {
|
|
ROOT_AI_NODE = &idBotAI::Run_Intermission_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( ClientIsDead( botNum ) ) {
|
|
ROOT_AI_NODE = &idBotAI::Enter_Run_Dead_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( timeTilAttackEnemy != -1 && timeTilAttackEnemy < botWorld->gameLocalInfo.time && enemy != -1 ) {
|
|
ROOT_AI_NODE = &idBotAI::Run_Combat_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( NBG_AI_SUB_NODE == false ) { //mal: if we have no NBG sub node, we're done here and need to reset and find a LTG next frame
|
|
Bot_ResetState( false, false );
|
|
return false;
|
|
}
|
|
|
|
aiState = NBG;
|
|
|
|
Bot_CheckClassState(); //mal: we run this early in NBG, so if medic is reviving, he'll switch weap as needed
|
|
|
|
CallFuncPtr( NBG_AI_SUB_NODE ); //mal: run the bot's current short term goal think node
|
|
|
|
Bot_Check_NBG_Goals();
|
|
|
|
Bot_CheckForDangers( false );
|
|
|
|
if ( enemy <= -1 ) {
|
|
Bot_FindEnemy( -1 );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
idBotAI::Run_Combat_Node
|
|
|
|
This is the bot's combat thinking.
|
|
================
|
|
*/
|
|
bool idBotAI::Run_Combat_Node() {
|
|
|
|
bool needNewEnemy = false;
|
|
bool haveClientToHaze = false;
|
|
|
|
//mal: first, lets check if we should be running a different node....
|
|
if ( botWorld->gameLocalInfo.inWarmup && botWorld->gameLocalInfo.botsSillyWarmup != false ) {
|
|
ROOT_AI_NODE = &idBotAI::Run_Warmup_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.inEndGame ) {
|
|
ROOT_AI_NODE = &idBotAI::Run_Intermission_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( ClientIsDead( botNum ) ) {
|
|
ROOT_AI_NODE = &idBotAI::Enter_Run_Dead_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->isDisguised ) {
|
|
botUcmd->botCmds.dropDisguise = true;
|
|
botIdealWeapSlot = RESET_WEAPON;
|
|
return true; //mal: wait til we drop uniform to attack
|
|
}
|
|
|
|
if ( !ClientIsValid( enemy, enemySpawnID ) ) { //mal: enemy disconnected/got kicked/ etc
|
|
needNewEnemy = true;
|
|
}
|
|
|
|
if ( !EnemyValid() ) {
|
|
needNewEnemy = true;
|
|
}
|
|
|
|
if ( ClientIsDead( enemy ) ) {
|
|
needNewEnemy = true;
|
|
haveClientToHaze = true;
|
|
}
|
|
|
|
if ( resetEnemy ) {
|
|
Bot_ResetEnemy();
|
|
needNewEnemy = true;
|
|
}
|
|
|
|
if ( needNewEnemy ) {
|
|
if ( !Bot_FindEnemy( enemy ) ) {
|
|
if ( haveClientToHaze ) {
|
|
if ( !Bot_PickPostCombatGoal() ) {
|
|
Bot_ResetState( true, false );
|
|
}
|
|
} else {
|
|
Bot_ResetState( true, false );
|
|
}
|
|
}
|
|
return false; //mal: no matter what we decide, leave this node for a frame.
|
|
}
|
|
|
|
int vehicleNum = botWorld->clientInfo[ enemy ].proxyInfo.entNum;
|
|
needNewEnemy = false;
|
|
|
|
if ( vehicleNum != CLIENT_HAS_NO_VEHICLE ) { //mal: dont fight pointless battles with vehicles if we're outgunned.
|
|
proxyInfo_t vehicleInfo;
|
|
GetVehicleInfo( vehicleNum, vehicleInfo );
|
|
|
|
if ( vehicleInfo.type == MCP && vehicleInfo.isImmobilized && vehicleInfo.driverEntNum == enemy ) {
|
|
needNewEnemy = true;
|
|
} else if ( ( vehicleInfo.type == GOLIATH || vehicleInfo.type == TITAN || vehicleInfo.type == DESECRATOR ) && vehicleInfo.health > ( vehicleInfo.maxHealth / 3 ) ) {
|
|
|
|
bool canNadeAttack = ( !botInfo->weapInfo.hasNadeAmmo || enemyInfo.enemyDist > GRENADE_ATTACK_DIST ) ? false : true;
|
|
|
|
if ( botInfo->classType == FIELDOPS ) {
|
|
if ( enemyInfo.enemyDist > GRENADE_ATTACK_DIST ) {
|
|
if ( !Bot_HasWorkingDeployable() || !ClassWeaponCharged( AIRCAN ) || Bot_EnemyAITInArea( vehicleInfo.origin ) ) {
|
|
needNewEnemy = true;
|
|
}
|
|
} else {
|
|
if ( !canNadeAttack && !ClassWeaponCharged( AIRCAN ) && !botInfo->weapInfo.primaryWeapHasAmmo ) {
|
|
needNewEnemy = true;
|
|
}
|
|
}
|
|
} else if ( botInfo->classType == COVERTOPS ) {
|
|
if ( !canNadeAttack && ( botInfo->weapInfo.primaryWeapon != SNIPERRIFLE || !botInfo->weapInfo.primaryWeapHasAmmo ) ) {
|
|
needNewEnemy = true;
|
|
}
|
|
} else if ( botInfo->classType == SOLDIER ) {
|
|
if ( !canNadeAttack && ( botInfo->weapInfo.primaryWeapon != ROCKET || !botInfo->weapInfo.primaryWeapHasAmmo ) ) {
|
|
needNewEnemy = true;
|
|
}
|
|
} else {
|
|
if ( ( !canNadeAttack && enemyInfo.enemyDist > INFANTRY_ATTACK_HEAVY_DIST ) && !botInfo->weapInfo.primaryWeapHasAmmo ) {
|
|
needNewEnemy = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( needNewEnemy ) {
|
|
if ( !Bot_FindEnemy( enemy ) ) {
|
|
Bot_ResetState( true, false );
|
|
return false;
|
|
}
|
|
}
|
|
|
|
aiState = COMBAT;
|
|
|
|
UpdateEnemyInfo();
|
|
|
|
if ( !enemyInfo.enemyVisible && enemyInfo.enemyLastVisTime + 5000 < botWorld->gameLocalInfo.time && !chasingEnemy ) {
|
|
if ( !Bot_FindEnemy( enemy ) ) {
|
|
Bot_ResetState( true, false );
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Bot_CheckForDangers( true );
|
|
|
|
if ( turretDangerExists && turretDangerEntNum != -1 && combatNBGType != COMBAT_ATTACK_TURRET && enemyInfo.enemyDist > 500.0f && Bot_HasExplosives( true, true ) && !Client_IsCriticalForCurrentObj( botNum, BOT_WILL_ATTACK_TURRETS_IN_COMBAT_DIST ) ) {
|
|
combatNBGTarget = turretDangerEntNum;
|
|
COMBAT_AI_SUB_NODE = &idBotAI::Enter_COMBAT_Foot_AttackTurret;
|
|
}
|
|
|
|
if ( COMBAT_AI_SUB_NODE == NULL ) {
|
|
Bot_CheckCurrentStateForCombat();
|
|
}
|
|
|
|
CallFuncPtr( COMBAT_AI_SUB_NODE ); //mal: run the bot's current combat think node
|
|
|
|
Bot_FindBetterEnemy(); //mal: the last thing to run
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Run_Intermission_Node
|
|
|
|
This node is run at game end. Bots jeer/cheer based on who won. can also just say silly things for fun.
|
|
================
|
|
*/
|
|
bool idBotAI::Run_Intermission_Node() {
|
|
|
|
int randChance = ( botWorld->gameLocalInfo.numClients > 12 ) ? 97 : 70;
|
|
|
|
if ( !botWorld->gameLocalInfo.inEndGame ) {
|
|
Bot_ResetState( true, true );
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.winningTeam == NOTEAM ) { //mal: may take a bit to get updated. Ignore til its ready.
|
|
return true;
|
|
}
|
|
|
|
if ( botThreadData.random.RandomInt( 100 ) < randChance ) {
|
|
return true;
|
|
}
|
|
|
|
if ( botThreadData.random.RandomInt( 100 ) > 98 ) {
|
|
if ( botWorld->gameLocalInfo.winningTeam == botInfo->team ) {
|
|
Bot_AddDelayedChat( botNum, ENDGAME_WIN, 1 ); //I'm a winnah!!!1
|
|
} else {
|
|
Bot_AddDelayedChat( botNum, ENDGAME_LOSE, 1 ); //OMG H4X!!1
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Run_Warmup_Node
|
|
|
|
This is run while the game is in warmup mode. In warmup, the bots just
|
|
screw around and shoot each other, do other wacky stuff.
|
|
================
|
|
*/
|
|
bool idBotAI::Run_Warmup_Node() {
|
|
|
|
float attackDist = 3500.0f; //mal: the range of the bot's "awareness" during warmup
|
|
float dist;
|
|
idVec3 vec;
|
|
|
|
if ( !botWorld->gameLocalInfo.inWarmup || botWorld->gameLocalInfo.botsSillyWarmup == false ) {
|
|
Bot_ResetState( true, true );
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.inEndGame ) {
|
|
ROOT_AI_NODE = &idBotAI::Run_Intermission_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( enemy == -1 ) { //mal: if we have no enemy, lets look for one! NOTE: if a bot is killed, he keeps his enemy, to get revenge!
|
|
|
|
int i, j;
|
|
|
|
if ( !botInfo->hasGroundContact && !botInfo->hasJumped && botInfo->invulnerableEndTime > botWorld->gameLocalInfo.time ) {
|
|
return false; //mal: if we're dropping in (and not jumping around) dont pick targets yet (just spawned).
|
|
}
|
|
|
|
//mal: don't ALWAYS pick on the human! So lets just pick a random client and fight them.
|
|
if ( botThreadData.random.RandomInt( 100 ) > 75 ) {
|
|
j = 0;
|
|
} else {
|
|
j = botThreadData.random.RandomInt( botWorld->gameLocalInfo.numClients );
|
|
}
|
|
|
|
COMBAT_MOVEMENT_STATE = NULL;
|
|
|
|
for ( i = j; i < MAX_CLIENTS; i++ ) {
|
|
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue; //mal: no valid client in this client slot!
|
|
}
|
|
|
|
if ( i == botNum ) { //mal: don't target yourself!
|
|
continue;
|
|
}
|
|
|
|
if ( EnemyIsIgnored( i ) ) {
|
|
continue; //mal: dont try to fight someone we've flagged to ignore for whatever reason!
|
|
}
|
|
|
|
const clientInfo_t& playerInfo = botWorld->clientInfo[ i ];
|
|
|
|
if ( playerInfo.isNoTarget ) {
|
|
continue;
|
|
} //mal: dont target clients that have notarget set - this is useful for debugging, etc.
|
|
|
|
if ( playerInfo.health <= 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !playerInfo.hasGroundContact && !playerInfo.hasJumped && playerInfo.invulnerableEndTime > botWorld->gameLocalInfo.time ) {
|
|
continue; //mal: dont shoot them when they're in the air!
|
|
}
|
|
|
|
vec = playerInfo.viewOrigin - botInfo->viewOrigin;
|
|
|
|
dist = vec.LengthFast();
|
|
|
|
if ( dist > attackDist ) { //mal: too far away - ignore!
|
|
continue;
|
|
}
|
|
|
|
enemy = i; //mal: just pick the first guy we come across
|
|
enemySpawnID = botWorld->clientInfo[ i ].spawnID;
|
|
|
|
botIdealWeapNum = NULL_WEAP;
|
|
|
|
if ( botThreadData.random.RandomInt( 100 ) > 50 || dist > 2500.0f ) { //mal: lets have a little fun - sometimes we'll try to knife our enemy!
|
|
botIdealWeapSlot = GUN;
|
|
} else {
|
|
if ( botThreadData.random.RandomInt( 100 ) > 50 ) {
|
|
botIdealWeapSlot = MELEE;
|
|
} else {
|
|
if ( botInfo->weapInfo.hasNadeAmmo ) {
|
|
botIdealWeapSlot = NADE;
|
|
} else {
|
|
botIdealWeapSlot = MELEE;
|
|
}
|
|
}
|
|
}
|
|
|
|
warmupUseActionMoveGoalTime = 0;
|
|
|
|
if ( botThreadData.random.RandomInt( 100 ) > 75 ) {
|
|
warmupActionMoveGoal = Bot_FindNearbySafeActionToMoveToward( botInfo->origin, 1024.0f, true );
|
|
|
|
if ( warmupActionMoveGoal != ACTION_NULL ) {
|
|
warmupUseActionMoveGoalTime = botWorld->gameLocalInfo.time + WARMUP_ACTION_TIME;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
return true; //mal: dont do anything til next pass, whether found someone or not.
|
|
}
|
|
|
|
if ( warmupUseActionMoveGoalTime > botWorld->gameLocalInfo.time ) { //mal: don't always attack, sometimes move away from the spawn, and attack from a diff position
|
|
|
|
Bot_SetupMove( vec3_zero, -1, warmupActionMoveGoal );
|
|
|
|
if ( MoveIsInvalid() ) {
|
|
warmupUseActionMoveGoalTime = 0;
|
|
return true;
|
|
}
|
|
|
|
Bot_MoveAlongPath( SPRINT );
|
|
|
|
if ( botInfo->backPedalTime > botWorld->gameLocalInfo.time ) { //mal: add a bit of variety...
|
|
botUcmd->viewType = VIEW_REVERSE;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
if ( !botWorld->clientInfo[ enemy ].inGame ) {
|
|
enemy = -1; //mal: our enemy disconnected, got kicked, etc. get another one
|
|
return true;
|
|
}
|
|
|
|
if ( ClientIsDead( enemy ) ) {
|
|
enemy = -1; //mal: our enemy is dead, get another one!
|
|
return true;
|
|
}
|
|
|
|
vec = botWorld->clientInfo[ enemy ].origin - botInfo->origin;
|
|
|
|
dist = vec.LengthFast();
|
|
|
|
if ( dist > attackDist ) { //mal: hes too far away (maybe flying), so forget him!
|
|
enemy = -1;
|
|
return true;
|
|
}
|
|
|
|
if ( botIdealWeapSlot == MELEE && dist > 2500.0f ) {
|
|
botIdealWeapSlot = GUN;
|
|
}
|
|
|
|
if ( botThreadData.random.RandomInt( 100 ) > 98 && botThreadData.random.RandomInt( 100 ) > 50 ) {
|
|
if ( botInfo->classType == FIELDOPS && botInfo->fireSupportChargedUsed == 0 ) {
|
|
botIdealWeapNum = AIRCAN;
|
|
botIdealWeapSlot = NO_WEAPON;
|
|
}
|
|
}
|
|
|
|
UpdateEnemyInfo();
|
|
|
|
if ( !ClientIsVisibleToBot( enemy, false, false ) ) {
|
|
|
|
Bot_SetupMove(vec3_zero, enemy, ACTION_NULL );
|
|
|
|
if ( MoveIsInvalid() ) { //mal: cant find a valid path - ignore this client for a while!
|
|
Bot_IgnoreEnemy( enemy, ENEMY_IGNORE_TIME );
|
|
Bot_ResetEnemy();
|
|
}
|
|
|
|
Bot_MoveAlongPath( SPRINT );
|
|
return true;
|
|
}
|
|
|
|
COMBAT_AI_SUB_NODE = &idBotAI::COMBAT_Foot_AttackEnemy;
|
|
|
|
if ( botIdealWeapSlot == MELEE ) {
|
|
COMBAT_MOVEMENT_STATE = &idBotAI::Knife_Attack_Movement;
|
|
}
|
|
|
|
bool result = CallFuncPtr( COMBAT_AI_SUB_NODE ); //mal: run the bot's current combat think node
|
|
|
|
if ( botInfo->weapInfo.weapon == AIRCAN || botInfo->weapInfo.weapon == GRENADE || botInfo->weapInfo.weapon == EMP ) {
|
|
|
|
if ( !botInfo->weapInfo.hasNadeAmmo && ( botInfo->weapInfo.weapon == GRENADE || botInfo->weapInfo.weapon == EMP ) ) {
|
|
botIdealWeapSlot = GUN;
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->weapInfo.weapon == AIRCAN && botInfo->fireSupportChargedUsed > 0 ) {
|
|
botIdealWeapSlot = GUN;
|
|
return false;
|
|
}
|
|
|
|
combatMoveFailedCount = 0;
|
|
|
|
COMBAT_MOVEMENT_STATE = &idBotAI::Crazy_Jump_Attack_Movement;
|
|
|
|
if ( botThreadData.random.RandomInt( 100 ) > 95 ) {
|
|
botUcmd->botCmds.attack = false;
|
|
}
|
|
}
|
|
|
|
if ( result == false ) {
|
|
Bot_IgnoreEnemy( enemy, ENEMY_IGNORE_TIME );
|
|
Bot_ResetEnemy();
|
|
}
|
|
|
|
if ( botThreadData.random.RandomInt( 100 ) > 98 && botThreadData.random.RandomInt( 100 ) > 95 ) {
|
|
botUcmd->desiredChat = WARMUP_TAUNT;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Enter_Run_Dead_Node
|
|
|
|
This node is run if the bot is killed/dead/waiting for a medic.
|
|
================
|
|
*/
|
|
bool idBotAI::Enter_Run_Dead_Node() {
|
|
|
|
int attackerNum;
|
|
|
|
attackerNum = botWorld->clientInfo[ botNum ].lastAttacker;
|
|
|
|
Bot_ResetState( true, false ); //mal: clear out the bot's state, but keep any important goals on the stack in case he gets revived.
|
|
|
|
memset( delayedChats, 0, sizeof( delayedChats ) );
|
|
|
|
ROOT_AI_NODE = &idBotAI::Run_Dead_Node;
|
|
|
|
if ( attackerNum > -1 && attackerNum < MAX_CLIENTS ) {
|
|
if ( botWorld->clientInfo[ attackerNum ].team != botInfo->team ) {
|
|
if ( botWorld->clientInfo[ attackerNum ].isDisguised ) {
|
|
if ( botThreadData.random.RandomInt( 100 ) > 50 ) {
|
|
if ( botWorld->clientInfo[ attackerNum ].disguisedClient == botNum ) {
|
|
Bot_AddDelayedChat( botNum, ENEMY_DISGUISED_AS_ME, 3 );
|
|
} else {
|
|
Bot_AddDelayedChat( botNum, ENEMY_DISGUISED, 3 );
|
|
}
|
|
}
|
|
} else if ( !botWorld->clientInfo[ attackerNum ].isBot && botThreadData.random.RandomInt( 100 ) > 85 && botThreadData.random.RandomInt( 100 ) > 50 ) {
|
|
Bot_AddDelayedChat( botNum, KILLED_TAUNT, 2 );
|
|
}
|
|
}
|
|
}
|
|
|
|
lastAINode = "Dead Think";
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
idBotAI::Run_Dead_Node
|
|
|
|
This node is run if the bot is killed/dead/waiting for a medic.
|
|
================
|
|
*/
|
|
bool idBotAI::Run_Dead_Node() {
|
|
|
|
int medicsInArea;
|
|
|
|
if ( botWorld->gameLocalInfo.inWarmup && botWorld->gameLocalInfo.botsSillyWarmup != false ) {
|
|
ROOT_AI_NODE = &idBotAI::Run_Warmup_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.inEndGame ) {
|
|
ROOT_AI_NODE = &idBotAI::Run_Intermission_Node;
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->health > 0 ) {
|
|
if ( botInfo->revived ) {
|
|
Bot_ResetState( true, false ); //mal: got revived - get back into the action doing whatever we were doing before.
|
|
} else {
|
|
Bot_ResetState( true, true ); //mal: if respawned, wipe everything and start from scratch.
|
|
lastActionNum = ACTION_NULL;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->inLimbo ) { //mal: if we're in limbo, just exit out of here for now.
|
|
return true;
|
|
}
|
|
|
|
botThreadData.GetBotOutputState()->botOutput[ botNum ].botCmds.hasMedicInFOV = Bot_CheckHasVisibleMedicNearby(); //mal: we'll use this later to decide if we should tap out, or wait.
|
|
|
|
if ( botThreadData.random.RandomInt( 100 ) > 98 && botThreadData.random.RandomInt( 100 ) > 50 ) {
|
|
|
|
medicsInArea = ClientsInArea( botNum, botInfo->origin, 700.0f, botInfo->team, MEDIC, false, false, false, false, true, true );
|
|
|
|
if ( medicsInArea > 0 && botThreadData.random.RandomInt( 100 ) > 98 ) { //mal: no point in begging for a medic, if theres none around ( or they're all dead ).
|
|
botUcmd->desiredChat = REVIVE_ME;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|