3614 lines
111 KiB
C++
3614 lines
111 KiB
C++
// Copyright (C) 2007 Id Software, Inc.
|
|
//
|
|
|
|
#include "../precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include "../Game_local.h"
|
|
#include "../ContentMask.h"
|
|
#include "BotThreadData.h"
|
|
#include "BotAI_Main.h"
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_FindEnemy
|
|
|
|
We'll sort thru the clients, and ignore certain clients if we're too busy
|
|
to be buggered (carrying obj, planting/hacking, etc) or they're not valid enemies
|
|
(in disguise, hidden by smoke, etc).
|
|
================
|
|
*/
|
|
bool idBotAI::Bot_FindEnemy( int ignoreClientNum ) {
|
|
bool hasAttackedMate;
|
|
bool hasAttackedCriticalMate;
|
|
bool hasObj;
|
|
bool isTouchingItems;
|
|
bool isDefusingOurBomb;
|
|
bool inFront;
|
|
bool botGotShotRecently;
|
|
bool botIsBigShot;
|
|
bool audible;
|
|
bool isVisible;
|
|
bool isFacingUs;
|
|
bool isFiringWeapon;
|
|
bool isNearOurObj;
|
|
bool hasBeenNarced;
|
|
int i;
|
|
int infantry = 0;
|
|
int vehicle = 0;
|
|
int aircraft = 0;
|
|
int heardPriority;
|
|
int entClientNum = -1;
|
|
int heardClientNum = -1;
|
|
float dist;
|
|
float botSightDist = botWorld->botGoalInfo.botSightDist;
|
|
float entDist = idMath::INFINITY;
|
|
float heardDist = idMath::INFINITY;
|
|
proxyInfo_t vehicleInfo;
|
|
idVec3 vec;
|
|
|
|
hammerTime = false;
|
|
hammerClient = -1;
|
|
testFireShot = false;
|
|
numVisEnemies = 0;
|
|
|
|
//mal: some debugging stuff....
|
|
if ( botWorld->gameLocalInfo.botIgnoreEnemies == 1 ) {
|
|
return false;
|
|
} else if ( botWorld->gameLocalInfo.botIgnoreEnemies == 2 ) {
|
|
if ( botInfo->team == GDF ) {
|
|
return false;
|
|
}
|
|
} else if ( botWorld->gameLocalInfo.botIgnoreEnemies == 3 ) {
|
|
if ( botInfo->team == STROGG ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( Bot_ShouldIgnoreEnemies() ) {
|
|
return false;
|
|
}
|
|
|
|
#ifdef _XENON
|
|
if ( briefPlayerTime > botWorld->gameLocalInfo.time ) {
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
idVec3 turretLoc;
|
|
|
|
if ( Bot_IsUnderAttackByAPT( turretLoc ) && Bot_IsAttackingDeployables() ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->weapInfo.covertToolInfo.entNum != 0 && botInfo->team == STROGG && botInfo->weapInfo.covertToolInfo.clientIsUsing == true ) { //mal: if using the flyer hive, dont worry about enemies.
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->botGoalInfo.teamRetreatInfo[ botInfo->team ].retreatTime > botWorld->gameLocalInfo.time ) {
|
|
botSightDist = 1000.0f;
|
|
}
|
|
|
|
botIsBigShot = Bot_CheckCombatExceptions();
|
|
|
|
for ( i = 0; i < MAX_CLIENTS; i++ ) {
|
|
|
|
if ( ignoreClientNum == i ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue; //mal: no valid client in this client slot!
|
|
}
|
|
|
|
if ( i == botNum ) {
|
|
continue; //mal: dont try to fight ourselves!
|
|
}
|
|
|
|
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.inLimbo ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.isActor ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.isDisguised && botThreadData.GetBotSkill() == BOT_SKILL_EASY ) {
|
|
continue;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_DEMO ) {
|
|
if ( Bot_CheckForHumanInteractingWithEntity( i ) == true ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( playerInfo.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) { //mal: pick the driver of a vehicle as the target, NOT passengers, unless there is no driver - then kill whoever.
|
|
|
|
GetVehicleInfo( playerInfo.proxyInfo.entNum, vehicleInfo );
|
|
|
|
if ( vehicleInfo.type != MCP ) {
|
|
if ( vehicleInfo.driverEntNum != i && vehicleInfo.driverEntNum != -1 ) {
|
|
continue;
|
|
}
|
|
|
|
vec = vehicleInfo.origin - botInfo->origin;
|
|
|
|
float vehicleDist = vec.LengthSqr();
|
|
|
|
if ( vehicleInfo.xyspeed > 600.0f && vehicleDist > Square( 1900.0f ) && !InFrontOfVehicle( playerInfo.proxyInfo.entNum, botInfo->origin ) ) { //mal: if they're in a mad dash away from us, forget about them!
|
|
continue;
|
|
}
|
|
|
|
if ( ( vehicleInfo.type == GOLIATH || vehicleInfo.type == TITAN || vehicleInfo.type == DESECRATOR ) && vehicleInfo.health > ( vehicleInfo.maxHealth / 3 ) ) {
|
|
|
|
bool canNadeAttack = ( !botInfo->weapInfo.hasNadeAmmo || vehicleDist > Square( GRENADE_ATTACK_DIST ) ) ? false : true;
|
|
|
|
if ( botInfo->classType == FIELDOPS ) {
|
|
if ( vehicleDist > Square( GRENADE_ATTACK_DIST ) ) {
|
|
if ( !Bot_HasWorkingDeployable() || !ClassWeaponCharged( AIRCAN ) || Bot_EnemyAITInArea( vehicleInfo.origin ) ) {
|
|
continue;
|
|
}
|
|
} else {
|
|
if ( !canNadeAttack && !ClassWeaponCharged( AIRCAN ) && !botInfo->weapInfo.primaryWeapHasAmmo ) {
|
|
continue;
|
|
}
|
|
}
|
|
} else if ( botInfo->classType == COVERTOPS ) {
|
|
if ( !canNadeAttack && ( botInfo->weapInfo.primaryWeapon != SNIPERRIFLE || !botInfo->weapInfo.primaryWeapHasAmmo ) ) {
|
|
continue;
|
|
}
|
|
} else if ( botInfo->classType == SOLDIER ) {
|
|
if ( !canNadeAttack && ( botInfo->weapInfo.primaryWeapon != ROCKET || !botInfo->weapInfo.primaryWeapHasAmmo ) ) {
|
|
continue;
|
|
}
|
|
} else {
|
|
if ( !canNadeAttack && vehicleDist > Square( INFANTRY_ATTACK_HEAVY_DIST ) && !botInfo->weapInfo.primaryWeapHasAmmo ) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if ( vehicleInfo.isImmobilized && vehicleInfo.driverEntNum == i ) {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( playerInfo.invulnerableEndTime > botWorld->gameLocalInfo.time ) {
|
|
continue; //mal: ignore revived/just spawned in clients - get the ppl around them!
|
|
}
|
|
|
|
if ( playerInfo.health <= 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.team == botInfo->team ) {
|
|
continue;
|
|
}
|
|
|
|
hasAttackedCriticalMate = ClientHasAttackedTeammate( i, true, 3000 );
|
|
|
|
int attackeMateAwarenessTime = ( playerInfo.isDisguised ) ? 3000 : 9000;
|
|
|
|
hasAttackedMate = ClientHasAttackedTeammate( i, false, attackeMateAwarenessTime );
|
|
hasObj = ClientHasObj( i );
|
|
isTouchingItems = ( playerInfo.touchingItemTime + BOT_THINK_DELAY_TIME < botWorld->gameLocalInfo.time ) ? false : true;
|
|
isDefusingOurBomb = ClientIsDefusingOurTeamCharge( i );
|
|
inFront = InFrontOfClient( botNum, playerInfo.origin );
|
|
isFacingUs = InFrontOfClient( i, botInfo->origin );
|
|
botGotShotRecently = ( botInfo->lastAttackerTime + 3000 < botWorld->gameLocalInfo.time ) ? false : true;
|
|
isFiringWeapon = playerInfo.weapInfo.isFiringWeap;
|
|
isNearOurObj = ( LocationDistFromCurrentObj( botInfo->team, playerInfo.origin ) < 2500.0f ) ? true : false;
|
|
hasBeenNarced = ( playerInfo.covertWarningTime + 5000 < botWorld->gameLocalInfo.time ) ? false : true;
|
|
bool hasAttackedActorsFriend = ClientHasAttackedActorsMate( i, 3000 );
|
|
|
|
if ( botIsBigShot && botInfo->classType == MEDIC && !hasObj && !isDefusingOurBomb ) { //mal: medics need to do their jobs, with a LOT less restrictions then others.
|
|
continue;
|
|
}
|
|
|
|
if ( botIsBigShot && ( !isFacingUs || !inFront ) && !hasObj && !isNearOurObj && !isDefusingOurBomb ) {
|
|
continue;
|
|
} //mal: if we're trying to do an important obj, dont get into a fight with everyone.
|
|
|
|
if ( botInfo->isDisguised ) { //mal: dont attack, unless they have the obj on them, or they shot us, or they're attacking an important mate, or they're defusing our team's bomb!
|
|
if ( !hasObj && ( !botGotShotRecently || ( botInfo->lastAttacker != i && botInfo->lastAttacker != botInfo->disguisedClient ) || botThreadData.random.RandomInt( 100 ) < 75 ) &&
|
|
!hasAttackedCriticalMate && !isDefusingOurBomb && Client_IsCriticalForCurrentObj( i, 2500.0f ) == false ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( botInfo->isDisguised ) {
|
|
if ( !botGotShotRecently && aiState == NBG && nbgType == STALK_VICTIM && nbgTarget == i ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
vec = playerInfo.viewOrigin - botInfo->viewOrigin;
|
|
dist = vec.LengthSqr();
|
|
|
|
if ( botInfo->isActor && ( !hasAttackedActorsFriend && dist > Square( 900.0f ) ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( botWorld->botGoalInfo.teamRetreatInfo[ botInfo->team ].retreatTime > botWorld->gameLocalInfo.time ) { //mal: the bots should try to fall back, not get caught up in combat.
|
|
if ( !inFront && ( !botGotShotRecently || botInfo->lastAttacker != i ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( dist > Square( botSightDist ) ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( dist > Square( botSightDist ) ) {
|
|
if ( botInfo->classType == SOLDIER && botInfo->weapInfo.primaryWeapon == ROCKET && botInfo->weapInfo.primaryWeapHasAmmo && playerInfo.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
if ( dist > Square( WEAPON_LOCK_DIST ) ) {
|
|
continue;
|
|
}
|
|
} else if ( botInfo->classType == FIELDOPS && ClassWeaponCharged( AIRCAN ) && Bot_HasWorkingDeployable() && !Bot_EnemyAITInArea( playerInfo.origin ) ) {
|
|
if ( !LocationVis2Sky( playerInfo.origin ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( dist > Square( WEAPON_LOCK_DIST ) && !ClientIsDangerous( i ) ) {
|
|
continue;
|
|
}
|
|
|
|
deployableInfo_t deployableInfo;
|
|
|
|
GetDeployableInfo( true, 0, deployableInfo );
|
|
|
|
if ( dist > Square( deployableInfo.maxAttackRange ) ) {
|
|
continue;
|
|
}
|
|
|
|
bool vis2Sky = LocationVis2Sky( playerInfo.origin );
|
|
|
|
if ( ClientIsDangerous( i ) && vis2Sky ) { //mal: we'll slam campers, just because!
|
|
hammerTime = true;
|
|
hammerVehicle = false;
|
|
hammerLocation = playerInfo.origin;
|
|
hammerClient = i;
|
|
|
|
if ( playerInfo.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
GetVehicleInfo( playerInfo.proxyInfo.entNum, vehicleInfo );
|
|
|
|
if ( deployableInfo.type == ROCKET_ARTILLERY ) {
|
|
hammerVehicle = true;
|
|
}
|
|
|
|
hammerLocation = vehicleInfo.origin;
|
|
hammerLocation.z += ( vehicleInfo.bbox[ 1 ][ 2 ] - vehicleInfo.bbox[ 0 ][ 2 ] ) * 0.2f;//mal: 20%
|
|
}
|
|
} else if ( playerInfo.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE && deployableInfo.type == ROCKET_ARTILLERY && vis2Sky ) {
|
|
GetVehicleInfo( playerInfo.proxyInfo.entNum, vehicleInfo );
|
|
|
|
if ( vehicleInfo.type != HUSKY && vehicleInfo.type != ICARUS && vehicleInfo.type != PLATYPUS ) {
|
|
float vehicleOffset = botThreadData.GetVehicleTargetOffset( vehicleInfo.type );
|
|
hammerTime = true;
|
|
hammerVehicle = true;
|
|
hammerLocation = vehicleInfo.origin;
|
|
hammerLocation.z += ( vehicleInfo.bbox[ 1 ][ 2 ] - vehicleInfo.bbox[ 0 ][ 2 ] ) * vehicleOffset;
|
|
hammerClient = i;
|
|
} else {
|
|
continue;
|
|
}
|
|
} else { //mal: need to have some ppl around to make it worth our while....
|
|
|
|
int numEnemiesInArea = ClientsInArea( botNum, playerInfo.origin, 1024.0f, ( botInfo->team == GDF ) ? STROGG : GDF, NOCLASS, false, true, false, false, false );
|
|
int numFriendsInArea = ClientsInArea( botNum, playerInfo.origin, 1024.0f, botInfo->team, NOCLASS, false, true, false, false, false );
|
|
|
|
if ( numEnemiesInArea < 2 || numFriendsInArea > 2 ) {
|
|
continue;
|
|
}
|
|
|
|
hammerTime = true;
|
|
hammerVehicle = false;
|
|
hammerLocation = playerInfo.origin;
|
|
hammerClient = i;
|
|
}
|
|
} else if ( botInfo->classType == COVERTOPS && botInfo->weapInfo.primaryWeapon == SNIPERRIFLE && botInfo->weapInfo.primaryWeapHasAmmo && !botIsBigShot ) {
|
|
if ( dist > Square( MAX_SNIPER_VIEW_DIST ) ) {
|
|
continue;
|
|
}
|
|
} else {
|
|
if ( aiState == LTG && ltgType == HUNT_GOAL && ltgTarget == i ) {
|
|
continue;
|
|
}
|
|
|
|
if ( dist > Square( botSightDist * 2.0f ) || !ClientIsMarkedForDeath( i, false ) ) {
|
|
if ( botInfo->xySpeed == 0.0f && botInfo->lastAttacker == i && botInfo->lastAttackerTime + 100 > botWorld->gameLocalInfo.time ) { //mal: if getting hit, dont just stand there, move around.
|
|
Bot_ResetState( false, true );
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( playerInfo.isDisguised ) {
|
|
if ( ( playerInfo.disguisedClient != botNum || dist > Square( COVERT_SIGHT_DIST * 2.0f ) ) && !hasAttackedMate && !DisguisedClientIsActingOdd( i ) ) {
|
|
if ( inFront && botThreadData.GetBotSkill() == BOT_SKILL_EXPERT ) {
|
|
if ( ( ( !isTouchingItems || ( playerInfo.health == playerInfo.maxHealth && !playerInfo.weapInfo.primaryWeapNeedsAmmo ) || dist > Square( COVERT_SIGHT_DIST ) ) && ( !hasBeenNarced || dist > Square( COVERT_SIGHT_DIST ) ) ) ) {
|
|
continue; //mal: won't "see" disguised clients, unless they look like us, or theyre in front of us touching our/their items, or someone warned us about them!
|
|
}
|
|
} else {
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !ClientHasObj( i ) ) {
|
|
audible = ClientIsAudibleToBot( i ); //mal: if we can hear you, we'll skip the FOV test in the vis check below
|
|
} else {
|
|
audible = true;
|
|
dist = Square( 500.0f ); //mal: if you've got the docs, your our priority target, unless someone else is right on top of us!
|
|
}
|
|
|
|
isVisible = ClientIsVisibleToBot( i, !audible, false );
|
|
|
|
//mal: if client isn't visible, but is audible, see if we should hunt them down - ESPECIALLY if they're attacking a nearby critical teammate or are carrying docs!
|
|
if ( !isVisible ) {
|
|
if ( audible ) {
|
|
heardPriority = Bot_ShouldInvestigateNoise( i );
|
|
if ( heardPriority != 0 ) {
|
|
if ( dist < Square( heardDist ) ) {
|
|
if ( heardPriority == 2 ) {
|
|
heardDist = Square( 200.0f ); //mal: we heard someone we should worry about, so they get somewhat priority!
|
|
} else if ( heardDist == 3 ) {
|
|
heardDist = Square( 100.0f ); //mal: we heard someone we should REALLY worry about, so they get TOTAL priority!
|
|
} else {
|
|
heardDist = dist;
|
|
}
|
|
heardClientNum = i;
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill != BOT_SKILL_DEMO || botWorld->botGoalInfo.gameIsOnFinalObjective || botWorld->botGoalInfo.attackingTeam == botInfo->team ) { //mal: don't be too good about picking our targets in training mode if we're the defenders, unless its the final obj....
|
|
if ( isDefusingOurBomb ) {
|
|
dist = Square( 100.0f );
|
|
}
|
|
|
|
if ( hasAttackedCriticalMate && inFront && botWorld->gameLocalInfo.botSkill > BOT_SKILL_EASY && botWorld->gameLocalInfo.botSkill != BOT_SKILL_DEMO ) {
|
|
dist = Square( 600.0f ); //mal: will give higher priority to someone attacking a critical mate, if we can see it happening.
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill > BOT_SKILL_EASY && botWorld->gameLocalInfo.botSkill != BOT_SKILL_DEMO ) {
|
|
if ( Client_IsCriticalForCurrentObj( i, 1200.0f ) ) {
|
|
dist = Square( 700.0f ); //mal: if your a critical client, we're more likely to kill you.
|
|
}
|
|
}
|
|
|
|
if ( botWorld->botGoalInfo.mapHasMCPGoal ) {
|
|
if ( playerInfo.proxyInfo.entNum == botWorld->botGoalInfo.botGoal_MCP_VehicleNum ) {
|
|
dist = Square( 800.0f );
|
|
}
|
|
} //mal: if your in MCP, you get higher priority then a normal enemy.
|
|
} else {
|
|
if ( !playerInfo.isBot || playerInfo.isActor ) {
|
|
dist += Square( TRAINING_MODE_RANGE_ADDITION );
|
|
}
|
|
}
|
|
|
|
numVisEnemies++;
|
|
|
|
if ( playerInfo.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
if ( vehicleInfo.isAirborneVehicle ) {
|
|
if ( vehicleInfo.type != ICARUS ) {
|
|
aircraft++;
|
|
} else {
|
|
infantry++; //mal: the icarus doesn't really count as a aircraft threat.
|
|
}
|
|
} else {
|
|
if ( vehicleInfo.type != HUSKY ) {
|
|
vehicle++; //mal: tanks, water craft, and everything else falls into this group.
|
|
} else {
|
|
infantry++; //mal: ditto for the husky - doesn't really count as much of a vehicle threat.
|
|
}
|
|
}
|
|
} else {
|
|
infantry++;
|
|
}
|
|
|
|
if ( dist < entDist ) {
|
|
entClientNum = i;
|
|
entDist = dist;
|
|
}
|
|
}
|
|
|
|
if ( entClientNum != -1 ) {
|
|
|
|
enemy = entClientNum;
|
|
enemySpawnID = botWorld->clientInfo[ entClientNum ].spawnID;
|
|
|
|
if ( hammerClient != -1 && enemy != hammerClient ) {
|
|
hammerTime = false;
|
|
}
|
|
|
|
if ( aiState == LTG && ltgType == HUNT_GOAL && ltgTarget == enemy ) {
|
|
enemyIsHuntGoal = true;
|
|
} else {
|
|
enemyIsHuntGoal = false;
|
|
}
|
|
|
|
enemyInfo.enemy_FS_Pos = botWorld->clientInfo[ entClientNum ].origin;
|
|
enemyInfo.enemy_LS_Pos = enemyInfo.enemy_FS_Pos;
|
|
|
|
bot_FS_Enemy_Pos = botInfo->origin;
|
|
bot_LS_Enemy_Pos = bot_FS_Enemy_Pos;
|
|
enemyInfo.enemyLastVisTime = botWorld->gameLocalInfo.time;
|
|
|
|
enemyAcquireTime = botWorld->gameLocalInfo.time;
|
|
|
|
Bot_SetAttackTimeDelay( inFront ); //mal: this sets a delay on how long the bot should take to see enemy, based on bot's state.
|
|
|
|
COMBAT_AI_SUB_NODE = NULL; //mal: reset the bot's combat AI node
|
|
COMBAT_MOVEMENT_STATE = NULL;
|
|
combatNBGType = NO_COMBAT_TYPE;
|
|
|
|
if ( numVisEnemies > 2 ) { //mal: if a big wave of enemies is incoming, let everyone else know!
|
|
if ( botThreadData.random.RandomInt( 100 ) > 90 ) {
|
|
if ( vehicle > infantry && vehicle > aircraft ) {
|
|
Bot_AddDelayedChat( botNum, INCOMING_VEHICLE, 1 );
|
|
} else if ( aircraft > infantry ) {
|
|
Bot_AddDelayedChat( botNum, INCOMING_AIRCRAFT, 1 );
|
|
} else {
|
|
Bot_AddDelayedChat( botNum, INCOMING_INFANTRY, 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
} else if ( heardClientNum != -1 ) { //mal: we dont see an enemy, but did we find someone we want to investigate?
|
|
if ( ClientHasObj( heardClientNum ) ) {
|
|
ltgTime = botWorld->gameLocalInfo.time + BOT_INFINITY;
|
|
} else if ( aiState == NBG && nbgType == DEFENSE_CAMP ) {
|
|
ltgTime = botWorld->gameLocalInfo.time + 15000;
|
|
} else {
|
|
ltgTime = botWorld->gameLocalInfo.time + 60000;
|
|
}
|
|
|
|
aiState = LTG;
|
|
ltgType = HUNT_GOAL;
|
|
ROOT_AI_NODE = &idBotAI::Run_LTG_Node;
|
|
LTG_AI_SUB_NODE = &idBotAI::Enter_LTG_HuntGoal;
|
|
ltgTarget = heardClientNum;
|
|
ltgTargetSpawnID = botWorld->clientInfo[ heardClientNum ].spawnID;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::ClientIsAudibleToBot
|
|
|
|
Cheaply tells us if the client is question is making enough noise for this bot
|
|
to "notice" them and possibly consider them an enemy.
|
|
================
|
|
*/
|
|
bool idBotAI::ClientIsAudibleToBot( int clientNum ) {
|
|
heardClient = -1; // reset this every frame.
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_EASY && botWorld->gameLocalInfo.botSkill != BOT_SKILL_DEMO ) { // stupid bot - you can't hear anyone!
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->botGoalInfo.teamRetreatInfo[ botInfo->team ].retreatTime > botWorld->gameLocalInfo.time ) {
|
|
return false;
|
|
}
|
|
|
|
if ( ClientIsDefusingOurTeamCharge( clientNum ) ) {
|
|
return true;
|
|
}
|
|
|
|
if ( aiState == LTG && ( ltgType == DEFENSE_CAMP_GOAL || ltgType == HUNT_GOAL ) ) {
|
|
return false;
|
|
}
|
|
|
|
bool audible = false;
|
|
float hearingRange = PLAYER_HEARING_DIST;
|
|
const clientInfo_t& client = botWorld->clientInfo[ clientNum ];
|
|
idVec3 vec = client.origin - botInfo->origin;
|
|
float dist = vec.LengthSqr();
|
|
|
|
bool skipBattleSenseSoundChecks = false;
|
|
bool inVehicle = ( botVehicleInfo != NULL ) ? true : false;
|
|
|
|
if ( !inVehicle ) { //mal: if its far enough away, make sure its actually in the same area, and not a floor above/below us.
|
|
bool botOutSide = LocationVis2Sky( botInfo->origin );
|
|
bool enemyOutSide = LocationVis2Sky( client.origin );
|
|
|
|
if ( botOutSide != enemyOutSide && botInfo->areaNum != client.areaNum && idMath::Fabs( vec.z ) > 150.0f ) {
|
|
skipBattleSenseSoundChecks = true;
|
|
}
|
|
}
|
|
|
|
if ( !skipBattleSenseSoundChecks ) {
|
|
|
|
float weapFireHearingRange = hearingRange;
|
|
|
|
if ( client.proxyInfo.entNum == CLIENT_HAS_NO_VEHICLE && client.weapInfo.weapon == SNIPERRIFLE && botWorld->gameLocalInfo.botSkill > BOT_SKILL_EASY ) {
|
|
weapFireHearingRange = SNIPER_HEARING_DIST;
|
|
}
|
|
|
|
if ( client.weapInfo.isFiringWeap && dist < Square( weapFireHearingRange ) ) {
|
|
heardClient = clientNum;
|
|
audible = true;
|
|
}
|
|
|
|
if ( dist < Square( FOOTSTEP_DIST ) && client.xySpeed >= RUNNING_SPEED && botInfo->xySpeed < WALKING_SPEED ) {
|
|
if ( client.abilities.stroggCovertNoFootSteps == false || client.isDisguised || client.classType != COVERTOPS ) {
|
|
heardClient = clientNum;
|
|
audible = true;
|
|
}
|
|
}
|
|
|
|
if ( !client.isDisguised && dist < Square( FOOTSTEP_DIST ) && client.isPanting && botInfo->xySpeed < WALKING_SPEED && !botInfo->isPanting && botWorld->gameLocalInfo.botSkill == BOT_SKILL_EXPERT ) {
|
|
audible = true;
|
|
heardClient = clientNum;
|
|
} //mal: REALLY high skilled bots will hear the enemy running around, panting. We check for disguised clients elsewhere.
|
|
}
|
|
|
|
if ( ClientHasObj( clientNum ) && ( botWorld->gameLocalInfo.botSkill > BOT_SKILL_EASY || client.isInRadar ) ) {
|
|
audible = true;
|
|
}
|
|
|
|
if ( client.isInRadar && dist < Square( 1500.0f ) && ( client.abilities.gdfStealthToRadar == false || client.classType != COVERTOPS ) ) { //mal_TODO: test me!!!
|
|
audible = true;
|
|
}
|
|
|
|
if ( ClientIsMarkedForDeath( clientNum, false ) ) {
|
|
audible = true;
|
|
}
|
|
|
|
if ( ClientIsDangerous( clientNum ) ) { //mal: we're "aware" of campers, and will kill them if they're vis to us.
|
|
heardClient = clientNum;
|
|
audible = true;
|
|
}
|
|
|
|
if ( botInfo->lastAttacker == clientNum && botInfo->lastAttackerTime + 3000 > botWorld->gameLocalInfo.time ) {
|
|
audible = true;
|
|
}
|
|
|
|
if ( botVehicleInfo != NULL && client.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
if ( ( client.targetLockEntNum == botNum || client.targetLockEntNum == botInfo->proxyInfo.entNum ) && client.targetLockTime + 3000 < botWorld->gameLocalInfo.time ) {
|
|
audible = true;
|
|
}
|
|
}
|
|
|
|
if ( botThreadData.AllowDebugData() ) {
|
|
if ( audible != false ) {
|
|
// common->Printf("I'm aware of client #: %i\n", clientNum );
|
|
}
|
|
}
|
|
|
|
return audible;
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
idBotAI::ClientIsVisibleToBot
|
|
|
|
Tells us if the client is question is visible to the bot.
|
|
Not the cheapest function to call!
|
|
================
|
|
*/
|
|
bool idBotAI::ClientIsVisibleToBot ( int clientNum, bool useFOV, bool saveEnt ) {
|
|
int entNum = -1;
|
|
trace_t tr;
|
|
proxyInfo_t vehicleInfo;
|
|
const clientInfo_t& client = botWorld->clientInfo[ clientNum ];
|
|
idVec3 enemyView;
|
|
|
|
if ( client.proxyInfo.entNum == CLIENT_HAS_NO_VEHICLE && !ClientHasObj( clientNum ) ) {
|
|
if ( ClientObscuredBySmokeToBot( clientNum ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( client.proxyInfo.entNum == CLIENT_HAS_NO_VEHICLE ) {
|
|
enemyView = GetPlayerViewPosition( clientNum ); //mal: look them in the eye...
|
|
} else {
|
|
GetVehicleInfo( client.proxyInfo.entNum, vehicleInfo );
|
|
enemyView = vehicleInfo.origin;
|
|
float enemyVehicleOffset = botThreadData.GetVehicleTargetOffset( vehicleInfo.type );
|
|
enemyView.z += ( vehicleInfo.bbox[ 1 ][ 2 ] - vehicleInfo.bbox[ 0 ][ 2 ] ) * enemyVehicleOffset; //mal: look at the top of their vehicle - if we can see it, we can shoot it!
|
|
}
|
|
|
|
//mal: see if hes in our field of view, if thats desired...
|
|
if ( useFOV ) {
|
|
if ( botVehicleInfo == NULL || botInfo->proxyInfo.hasTurretWeapon ) {
|
|
if ( !InFrontOfClient( botNum, enemyView ) ) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if ( !InFrontOfVehicle( botInfo->proxyInfo.entNum, enemyView ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( botVehicleInfo != NULL ) {
|
|
entNum = botInfo->proxyInfo.entNum;
|
|
}
|
|
|
|
//mal: hes in our FOV (or we don't care about FOV) - need to see if hes visible now!
|
|
botThreadData.clip->TracePointExt( CLIP_DEBUG_PARMS tr, botInfo->viewOrigin, enemyView, BOT_VISIBILITY_TRACE_MASK, GetGameEntity( botNum ), ( entNum == -1 ) ? NULL : GetGameEntity( entNum ) );
|
|
|
|
if ( saveEnt ) {
|
|
if ( ( client.isLeaning || client.usingMountedGPMG ) && tr.fraction == 1.0f ) {
|
|
gunTargetEntNum = clientNum;
|
|
} else {
|
|
gunTargetEntNum = tr.c.entityNum; //mal: lets save off whos in our gun sights for later...
|
|
}
|
|
}
|
|
|
|
if ( tr.c.entityNum != clientNum && tr.fraction != 1.0f ) {
|
|
if ( client.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) { //mal: is the bastid in a vehicle?
|
|
if ( tr.c.entityNum != client.proxyInfo.entNum ) {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( botVehicleInfo != NULL && botVehicleInfo->canRotateInPlace && botVehicleInfo->type != MCP ) { //mal: tanks need a 2nd trace, to make sure we can actually see AND shoot the target!
|
|
botThreadData.clip->TracePointExt( CLIP_DEBUG_PARMS tr, botInfo->proxyInfo.weaponOrigin, enemyView, BOT_VISIBILITY_TRACE_MASK, GetGameEntity( botNum ), GetGameEntity( botVehicleInfo->entNum ) );
|
|
|
|
if ( tr.c.entityNum != clientNum && tr.fraction != 1.0f ) {
|
|
if ( client.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) { //mal: is the bastid in a vehicle?
|
|
if ( tr.c.entityNum != client.proxyInfo.entNum ) {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true; //mal: we see him!
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::ClientObscuredBySmokeToBot
|
|
|
|
Check to see if the client in question is obscured from the bot's view
|
|
by a cloud of smoke.
|
|
================
|
|
*/
|
|
bool idBotAI::ClientObscuredBySmokeToBot ( int clientNum ) {
|
|
int smokeExplodeDelay = 6000;
|
|
float maxSmokeRadius = 320.0f;
|
|
float maxSmokeRadiusTime = 5000;
|
|
float smokeRadius;
|
|
float dist;
|
|
idVec3 point;
|
|
idVec3 start = botInfo->viewOrigin;
|
|
idVec3 end = botWorld->clientInfo[ clientNum ].viewOrigin;
|
|
idVec3 temp;
|
|
idVec3 vec, pVec, vProj;
|
|
|
|
point = botWorld->clientInfo[ clientNum ].origin - botInfo->origin;
|
|
|
|
if ( point.LengthSqr() < Square( 450.0f ) ) {
|
|
return false;
|
|
} //mal: too close for it to matter.
|
|
|
|
for( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
|
|
const smokeBombInfo_t &smokeNade = botWorld->smokeGrenades[ i ];
|
|
|
|
if ( smokeNade.entNum == 0 && smokeNade.birthTime + 30000 < botWorld->gameLocalInfo.time ) {
|
|
continue;
|
|
}
|
|
|
|
if ( smokeNade.birthTime + smokeExplodeDelay > botWorld->gameLocalInfo.time ) {
|
|
continue;
|
|
} //mal: takes a few seconds for the effect to be generated
|
|
|
|
if ( smokeNade.xySpeed > 50.0f ) {
|
|
continue;
|
|
} //mal: dont worry about it if its still moving
|
|
|
|
point = smokeNade.origin;
|
|
|
|
point[ 2 ] += 32.0f; //mal: raise it off the ground.
|
|
|
|
smokeRadius = maxSmokeRadius * ( ( botWorld->gameLocalInfo.time - ( smokeNade.birthTime + smokeExplodeDelay - 3000 ) ) / maxSmokeRadiusTime );
|
|
|
|
if ( smokeRadius > maxSmokeRadius ) {
|
|
smokeRadius = maxSmokeRadius;
|
|
}
|
|
|
|
if ( botThreadData.AllowDebugData() ) {
|
|
gameRenderWorld->DebugCircle( colorRed, point, idVec3( 0, 0, 1 ), smokeRadius, 24, 16, true );
|
|
gameRenderWorld->DebugLine( colorOrange, point, point + idVec3( 0, 0, 128.0f ) );
|
|
}
|
|
|
|
pVec = point - start;
|
|
vec = end - start;
|
|
float lengthSqr = vec.LengthSqr();
|
|
float f = ( pVec * vec ) / lengthSqr;
|
|
f = idMath::ClampFloat( 0.0f, 1.0f, f );
|
|
vProj = pVec - ( f * vec );
|
|
|
|
dist = vProj.LengthSqr();
|
|
|
|
if ( dist < Square( smokeRadius ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_SetAttackTimeDelay
|
|
|
|
Sets how long the bot should delay "awareness" of an enemy.
|
|
Is influenced by what state the bot is currently in.
|
|
================
|
|
*/
|
|
void idBotAI::Bot_SetAttackTimeDelay( bool inFront ) {
|
|
|
|
if ( aiState == NBG && ( nbgType != CAMP && nbgType != DEFENSE_CAMP ) ) {
|
|
timeTilAttackEnemy = botWorld->gameLocalInfo.time + 450; // a bit longer, because bot was busy doing something.
|
|
} else if ( aiState == COMBAT ) {
|
|
timeTilAttackEnemy = botWorld->gameLocalInfo.time + 100; // really fast if already in a fighting mood
|
|
} else { // LTG, etc
|
|
timeTilAttackEnemy = botWorld->gameLocalInfo.time + 300; // not too long normally.
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_DEMO ) {
|
|
timeTilAttackEnemy += 1000; //mal: if training mode, add a bit of "lag" in our targettting of enemies
|
|
} else if ( botWorld->gameLocalInfo.botAimSkill == 0 ) {
|
|
timeTilAttackEnemy += 1000; //mal: if low skill, add a bit of "lag" in our targettting of enemies
|
|
} else if ( botWorld->gameLocalInfo.botAimSkill < 2 ) {
|
|
timeTilAttackEnemy += 500; //mal: if low skill, add a bit of "lag" in our targettting of enemies
|
|
} else {
|
|
|
|
if ( botInfo->isDisguised ) { //mal: if we were disguised and decided to fight, obviously we already see our enemy, so be quicker about attacking.
|
|
fastAwareness = true;
|
|
}
|
|
|
|
if ( ClientIsDangerous( enemy ) ) { //mal: be quicker about catching campers.
|
|
fastAwareness = true;
|
|
}
|
|
|
|
if ( Client_IsCriticalForCurrentObj( botNum, 1500.0f ) && inFront != false ) { //mal: if the guys in front of us, we're prolly aware of him already, just didnt want a distracting fight.
|
|
fastAwareness = true;
|
|
}
|
|
|
|
if ( aiState == NBG && ( nbgType == CAMP || nbgType == DEFENSE_CAMP ) && heardClient == enemy ) { //mal: if we were camping and heard this guy coming, we're gonna react faster.
|
|
fastAwareness = true;
|
|
}
|
|
}
|
|
|
|
if ( fastAwareness != false ) {
|
|
timeTilAttackEnemy = botWorld->gameLocalInfo.time + 50; //REALLY fast - only used for enemies that we already "spotted" somewhere else, or had purposely ignored for some reason.
|
|
fastAwareness = false;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_CheckCurrentStateForCombat
|
|
================
|
|
*/
|
|
void idBotAI::Bot_CheckCurrentStateForCombat() {
|
|
float evadeDist = Square( 1500.0f );
|
|
idVec3 vec;
|
|
|
|
//mal: this code will decide if the bot should chase, flank, flee, etc.
|
|
//mal: will make this decsion based on health, weapon, ammo, what the enemy is/has, how many enemies are vis, and what the bot is trying to do ( heal/revive, get some obj, etc).
|
|
if ( AIStack.STACK_AI_NODE != NULL ) {
|
|
if ( ( AIStack.isPriority && !botInfo->isDisguised ) || ClientHasObj( botNum ) || Client_IsCriticalForCurrentObj( botNum, 2500.0f ) ) {
|
|
if ( AIStack.stackActionNum != ACTION_NULL ) {
|
|
vec = botThreadData.botActions[ AIStack.stackActionNum ]->origin - botInfo->origin;
|
|
|
|
if ( botThreadData.botActions[ AIStack.stackActionNum ]->GetObjForTeam( botInfo->team ) == ACTION_DEFENSE_CAMP ) {
|
|
evadeDist = Square( 10000.0f );
|
|
}
|
|
} else if ( AIStack.stackClientNum != -1 ) {
|
|
vec = botWorld->clientInfo[ AIStack.stackClientNum ].origin - botInfo->origin;
|
|
} else if ( AIStack.stackEntNum != -1 ) {
|
|
if ( AIStack.stackEntNum < MAX_CARRYABLES && ( AIStack.stackLTGType == RECOVER_GOAL || AIStack.stackLTGType == STEAL_GOAL ) ) {
|
|
vec = botWorld->botGoalInfo.carryableObjs[ AIStack.stackEntNum ].origin;
|
|
evadeDist = Square( 3500.0f );
|
|
} else {
|
|
vec = botInfo->origin;
|
|
}
|
|
} else { //mal: not currently supported - so just fight.
|
|
vec = botInfo->origin;
|
|
}
|
|
}
|
|
|
|
if ( ClientHasObj( botNum ) || Client_IsCriticalForCurrentObj( botNum, 2500.0f ) ) {
|
|
evadeDist = Square( 3500.0f );
|
|
}
|
|
|
|
if ( vec.LengthSqr() < evadeDist ) {
|
|
COMBAT_AI_SUB_NODE = &idBotAI::Enter_COMBAT_Foot_EvadeEnemy; //mal: if bot has a priority target, and its close, try to avoid combat as much as possible.
|
|
return;
|
|
}
|
|
}
|
|
|
|
COMBAT_AI_SUB_NODE = &idBotAI::Enter_COMBAT_Foot_AttackEnemy;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::ClassWeaponCharged
|
|
================
|
|
*/
|
|
bool idBotAI::ClassWeaponCharged( const playerWeaponTypes_t weaponNum ) {
|
|
|
|
//mal_TODO: add skill based code someday! also class code for other classes! also exceptions that may arise when bot gets combat awards
|
|
|
|
if ( weaponNum == HEALTH || weaponNum == AMMO_PACK ) {
|
|
int baseCharge = 80;
|
|
|
|
if ( weaponNum == HEALTH && botInfo->abilities.fasterMedicCharge ) {
|
|
baseCharge = 90;
|
|
}
|
|
|
|
if ( botInfo->supplyChargeUsed < baseCharge ) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( weaponNum == NEEDLE ) {
|
|
if ( botInfo->classChargeUsed == 0 ) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( weaponNum == SHIELD_GUN ) {
|
|
if ( botInfo->deviceChargeUsed < 50 ) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( weaponNum == AIRCAN ) {
|
|
if ( botInfo->fireSupportChargedUsed == 0 ) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( weaponNum == THIRD_EYE ) {
|
|
if ( botInfo->deviceChargeUsed == 0 && botInfo->weapInfo.covertToolInfo.entNum == 0 ) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( weaponNum == TELEPORTER ) {
|
|
if ( botInfo->deviceChargeUsed == 0 && botInfo->hasTeleporterInWorld == false ) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( weaponNum == SMOKE_NADE || weaponNum == FLYER_HIVE ) {
|
|
if ( botInfo->deviceChargeUsed == 0 ) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( weaponNum == SUPPLY_MARKER ) {
|
|
if ( botInfo->supplyChargeUsed == 0 ) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::UpdateEnemyInfo
|
|
================
|
|
*/
|
|
void idBotAI::UpdateEnemyInfo() {
|
|
|
|
idVec3 vec;
|
|
|
|
if ( !ClientIsVisibleToBot( enemy, false, true ) ) {
|
|
enemyInfo.enemyVisible = false;
|
|
} else {
|
|
enemyInfo.enemyVisible = true;
|
|
}
|
|
|
|
if ( enemyInfo.enemyVisible ) {
|
|
enemyInfo.enemy_LS_Pos = botWorld->clientInfo[ enemy ].origin;
|
|
bot_LS_Enemy_Pos = botInfo->origin;
|
|
enemyInfo.enemy_NS_Pos = vec3_zero;
|
|
enemyInfo.enemyLastVisTime = botWorld->gameLocalInfo.time;
|
|
}
|
|
|
|
vec = botWorld->clientInfo[ enemy ].origin - botInfo->origin;
|
|
|
|
enemyInfo.enemyHeight = idMath::Ftoi( vec.z );
|
|
|
|
enemyInfo.enemyDist = vec.LengthFast();
|
|
|
|
enemyInfo.enemyInfont = ( botVehicleInfo == NULL ) ? InFrontOfClient( botNum, botWorld->clientInfo[ enemy ].origin ) : InFrontOfVehicle( botInfo->proxyInfo.entNum, botWorld->clientInfo[ enemy ].origin );
|
|
|
|
enemyInfo.enemyFacingBot = ( botWorld->clientInfo[ enemy ].proxyInfo.entNum == CLIENT_HAS_NO_VEHICLE ) ? InFrontOfClient( enemy, botInfo->origin ) : InFrontOfVehicle( botWorld->clientInfo[ enemy ].proxyInfo.entNum, botInfo->origin );
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_FindBetterEnemy
|
|
|
|
We'll sort thru the clients, and ignore certain clients if we're too busy
|
|
to be buggered (carrying obj, planting/hacking, etc) or they're not valid enemies
|
|
(in disguise, hidden by smoke, etc). Our current enemy will be the standard we measure
|
|
others against.
|
|
================
|
|
*/
|
|
bool idBotAI::Bot_FindBetterEnemy() {
|
|
bool useFOV = true;
|
|
int i;
|
|
int entClientNum = enemy;
|
|
float dist;
|
|
float entDist;
|
|
float sightDist = ENEMY_SIGHT_BUSY_DIST;
|
|
idVec3 vec;
|
|
|
|
if ( enemy == -1 ) { //mal: we lost our enemy for some reason, so just skip finding a new one til next frame.
|
|
return false;
|
|
}
|
|
|
|
if ( ignoreNewEnemiesTime > botWorld->gameLocalInfo.time ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->clientInfo[ enemy ].proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) { //mal: if we're attacking the MCP, its the priority.
|
|
if ( botWorld->clientInfo[ enemy ].proxyInfo.entNum == botWorld->botGoalInfo.botGoal_MCP_VehicleNum ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
vec = botWorld->clientInfo[ enemy ].origin - botInfo->origin;
|
|
entDist = vec.LengthSqr();
|
|
|
|
if ( !enemyInfo.enemyVisible ) {
|
|
entDist = idMath::INFINITY;
|
|
}
|
|
|
|
const clientInfo_t& enemyPlayerInfo = botWorld->clientInfo[ enemy ];
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_DEMO && !botWorld->botGoalInfo.gameIsOnFinalObjective && ( !enemyPlayerInfo.isBot || enemyPlayerInfo.isActor ) ) { //mal: dont worry about keeping our human target in training mode, unless its the final obj...
|
|
entDist += Square( TRAINING_MODE_RANGE_ADDITION );
|
|
sightDist += TRAINING_MODE_RANGE_ADDITION;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_EASY ) {
|
|
sightDist = 700.0f;
|
|
}
|
|
|
|
numVisEnemies = 1; //mal: our current enemy is always visible to us
|
|
|
|
//mal_TODO: this will need to be VASTLY improved as time goes on!!!!
|
|
|
|
for ( i = 0; i < MAX_CLIENTS; i++ ) {
|
|
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue; //mal: no valid client in this client slot!
|
|
}
|
|
|
|
if ( i == botNum ) {
|
|
continue; //mal: dont try to fight ourselves!
|
|
}
|
|
|
|
if ( i == enemy ) { //mal: ignore an enemy we already have
|
|
continue;
|
|
}
|
|
|
|
if ( EnemyIsIgnored( i ) ) {
|
|
continue; //mal: dont try to fight someone we've flagged to ignore for whatever reason!
|
|
}
|
|
|
|
//mal: if we're in the middle of a critical obj, dont go looking for trouble, unless they're shooting us!
|
|
if ( Client_IsCriticalForCurrentObj( botNum, -1.0f ) && ( botInfo->lastAttacker != i || botInfo->lastAttackerTime + 3000 < botWorld->gameLocalInfo.time ) ) {
|
|
continue;
|
|
}
|
|
|
|
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.isDisguised && playerInfo.disguisedClient != botNum ) {
|
|
continue; //mal: won't "see" disguised clients, unless they look like us!
|
|
}
|
|
|
|
if ( playerInfo.inLimbo ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.isActor ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.invulnerableEndTime > botWorld->gameLocalInfo.time ) {
|
|
continue; //mal: ignore revived/just spawned in clients - get the ppl around them!
|
|
}
|
|
|
|
if ( playerInfo.health <= 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.team == botInfo->team ) {
|
|
continue;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_DEMO && !botWorld->botGoalInfo.gameIsOnFinalObjective && !playerInfo.isBot && enemyPlayerInfo.isBot ) { //mal: dont worry about human targets in training mode if we have a bot one, unless its the final obj...
|
|
continue;
|
|
}
|
|
|
|
vec = playerInfo.viewOrigin - botInfo->viewOrigin;
|
|
|
|
dist = vec.LengthSqr();
|
|
|
|
if ( dist > Square( sightDist ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill != BOT_SKILL_DEMO || botWorld->botGoalInfo.gameIsOnFinalObjective ) { //mal: dont worry about picking the best targets in training mode, unless its the final obj...
|
|
if ( Client_IsCriticalForCurrentObj( i, sightDist ) ) { //mal: if a critical class, get high priority
|
|
dist = Square( 100 );
|
|
ignoreNewEnemiesTime = botWorld->gameLocalInfo.time + IGNORE_NEW_ENEMIES_TIME;
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill > BOT_SKILL_EASY ) { //mal: high skill bots are aware of enemies near obj.
|
|
useFOV = false;
|
|
}
|
|
}
|
|
|
|
if ( ClientHasAttackedTeammate( i, true, 3000 ) ) {
|
|
dist = Square( 150 );
|
|
ignoreNewEnemiesTime = botWorld->gameLocalInfo.time + IGNORE_NEW_ENEMIES_TIME;
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill > BOT_SKILL_EASY ) { //mal: high skill bots are aware of enemies attacking our critical friends.
|
|
useFOV = false;
|
|
}
|
|
}
|
|
|
|
if ( ClientHasObj( i ) ) { //mal: if have docs, get HIGHER priority.
|
|
dist = Square( 50 );
|
|
ignoreNewEnemiesTime = botWorld->gameLocalInfo.time + IGNORE_NEW_ENEMIES_TIME;
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill > BOT_SKILL_EASY ) { //mal: high skill bots are aware of enemies near obj.
|
|
useFOV = false;
|
|
}
|
|
}
|
|
|
|
if ( botWorld->botGoalInfo.mapHasMCPGoal ) {
|
|
if ( playerInfo.proxyInfo.entNum == botWorld->botGoalInfo.botGoal_MCP_VehicleNum ) {
|
|
dist = Square( 200.0f );
|
|
ignoreNewEnemiesTime = botWorld->gameLocalInfo.time + IGNORE_NEW_ENEMIES_TIME;
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill > BOT_SKILL_EASY ) { //mal: high skill bots are aware of enemies near obj.
|
|
useFOV = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !ClientIsVisibleToBot( i, useFOV, false ) ) {
|
|
continue;
|
|
}
|
|
|
|
numVisEnemies++;
|
|
|
|
if ( dist < entDist )
|
|
{
|
|
entClientNum = i;
|
|
entDist = dist;
|
|
}
|
|
}
|
|
|
|
if ( entClientNum != enemy ) {
|
|
|
|
enemy = entClientNum;
|
|
enemySpawnID = botWorld->clientInfo[ entClientNum ].spawnID;
|
|
|
|
enemyInfo.enemy_FS_Pos = botWorld->clientInfo[ entClientNum ].origin;
|
|
enemyInfo.enemy_LS_Pos = enemyInfo.enemy_FS_Pos;
|
|
|
|
enemyIsHuntGoal = false;
|
|
|
|
enemyAcquireTime = botWorld->gameLocalInfo.time;
|
|
|
|
enemyInfo.enemyLastVisTime = botWorld->gameLocalInfo.time;
|
|
|
|
bot_FS_Enemy_Pos = botInfo->origin;
|
|
bot_LS_Enemy_Pos = bot_FS_Enemy_Pos;
|
|
|
|
COMBAT_AI_SUB_NODE = NULL; //mal: reset the bot's combat AI node and movement state.
|
|
COMBAT_MOVEMENT_STATE = NULL;
|
|
combatNBGType = NO_COMBAT_TYPE;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_PickBestWeapon
|
|
================
|
|
*/
|
|
void idBotAI::Bot_PickBestWeapon( bool useNades ) {
|
|
bool isAirborneVehicle = false;
|
|
bool isGroundVehicle = false;
|
|
bool enemyIsMovingSlow;
|
|
int ourEnemiesAroundEnemy;
|
|
int ourFriendsAroundEnemy;
|
|
|
|
if ( weapSwitchTime > botWorld->gameLocalInfo.time ) {
|
|
return;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.inWarmup ) {
|
|
return;
|
|
}
|
|
|
|
if ( botInfo->usingMountedGPMG ) {
|
|
return;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_DEMO || botWorld->gameLocalInfo.botSkill <= BOT_SKILL_NORMAL ) {
|
|
if ( botThreadData.random.RandomInt( 100 ) > 30 ) {
|
|
useNades = false;
|
|
}
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botKnifeOnly != false ) {
|
|
botIdealWeapNum = NULL_WEAP;
|
|
botIdealWeapSlot = MELEE;
|
|
return;
|
|
}
|
|
|
|
const clientInfo_t& enemyClient = botWorld->clientInfo[ enemy ];
|
|
|
|
if ( botInfo->classType == COVERTOPS ) {
|
|
if ( !enemyInfo.enemyFacingBot && enemyInfo.enemyDist < 300.0f && enemyClient.xySpeed <= RUNNING_SPEED && enemyClient.proxyInfo.entNum == CLIENT_HAS_NO_VEHICLE ) {
|
|
if ( botInfo->lastAttacker != enemy || botInfo->lastAttackerTime + 3000 < botWorld->gameLocalInfo.time ) {
|
|
botIdealWeapSlot = MELEE;
|
|
return;
|
|
}
|
|
}
|
|
} //mal: we got the drop on someone - knife them in the back for major humiliation points!
|
|
|
|
ourEnemiesAroundEnemy = ClientsInArea( botNum, enemyClient.origin, 700.0f, ( botInfo->team == GDF ) ? STROGG : GDF, NOCLASS, false, false, false, false, false );
|
|
ourFriendsAroundEnemy = ClientsInArea( botNum, enemyClient.origin, 700.0f, botInfo->team, NOCLASS, false, false, false, false, false );
|
|
|
|
enemyIsMovingSlow = ( enemyClient.xySpeed < 600.0f ) ? true : false; //mal: if enemy is moving too fast, cant target with things like nades, etc.
|
|
|
|
if ( enemyClient.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
proxyInfo_t vehicleInfo;
|
|
|
|
GetVehicleInfo( enemyClient.proxyInfo.entNum, vehicleInfo );
|
|
|
|
isAirborneVehicle = ( vehicleInfo.isAirborneVehicle != false ) ? true : false;
|
|
isGroundVehicle = ( vehicleInfo.type < ICARUS && !( vehicleInfo.flags & WATER ) ) ? true : false;
|
|
}
|
|
|
|
switch( botInfo->classType ) {
|
|
case MEDIC:
|
|
if ( useNades && useNadeOnEnemy == false ) {
|
|
if ( ( !enemyInfo.enemyFacingBot || ourEnemiesAroundEnemy > 2 || isGroundVehicle == true && ( isAirborneVehicle == false && enemyIsMovingSlow ) ) && enemyInfo.enemyDist > 500.0f && enemyInfo.enemyDist < GRENADE_ATTACK_DIST && enemyInfo.enemyHeight < 100.0f && botInfo->weapInfo.hasNadeAmmo ) {
|
|
useNadeOnEnemy = true;
|
|
}
|
|
}
|
|
|
|
if ( useNadeOnEnemy == false ) {
|
|
if ( botInfo->weapInfo.primaryWeapon == SHOTGUN ) {
|
|
if ( enemyInfo.enemyDist < SHOTGUN_DIST ) {
|
|
botIdealWeapSlot = GUN;
|
|
} else {
|
|
botIdealWeapSlot = SIDEARM;
|
|
}
|
|
} else {
|
|
botIdealWeapSlot = GUN;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case FIELDOPS:
|
|
if ( hammerTime ) {
|
|
if ( ClassWeaponCharged( AIRCAN ) || ( hammerVehicle && botInfo->weapInfo.artyAttackInfo.deathTime > botWorld->gameLocalInfo.time ) ) {
|
|
botIdealWeapNum = BINOCS;
|
|
botIdealWeapSlot = NO_WEAPON;
|
|
break;
|
|
} else {
|
|
hammerTime = false;
|
|
hammerVehicle = false;
|
|
resetEnemy = true;
|
|
break; //mal: dont do anything for a frame.
|
|
}
|
|
}
|
|
|
|
if ( useNades && useNadeOnEnemy == false && useAircanOnEnemy == false) {
|
|
if ( ( !enemyInfo.enemyFacingBot || ClientIsDefusingOurTeamCharge( enemy ) || ourEnemiesAroundEnemy > 2 || isGroundVehicle == true && ( isAirborneVehicle == false && enemyIsMovingSlow ) ) && enemyInfo.enemyDist > 700.0f && enemyInfo.enemyDist < 1700.0f && enemyInfo.enemyHeight < 100.0f && ClassWeaponCharged( AIRCAN ) && LocationVis2Sky( enemyClient.origin ) ) {
|
|
useAircanOnEnemy = true;
|
|
} else if ( ( !enemyInfo.enemyFacingBot || ourEnemiesAroundEnemy > 2 || isGroundVehicle == true && ( isAirborneVehicle == false && enemyIsMovingSlow ) ) && enemyInfo.enemyDist > 500.0f && enemyInfo.enemyDist < GRENADE_ATTACK_DIST && enemyInfo.enemyHeight < 100.0f && botInfo->weapInfo.hasNadeAmmo ) {
|
|
useNadeOnEnemy = true;
|
|
}
|
|
}
|
|
|
|
if ( useNadeOnEnemy == false && useAircanOnEnemy == false ) {
|
|
botIdealWeapSlot = GUN; //mal: the weap autoswitch code will handle switching to pistol if gun is out of ammo.
|
|
}
|
|
|
|
break;
|
|
|
|
case ENGINEER: //mal_TODO: need to add code here for the eng's nade launcher. Currently its a upgrade, but it may change.
|
|
if ( useNades && useNadeOnEnemy == false ) {
|
|
if ( ( !enemyInfo.enemyFacingBot || ourEnemiesAroundEnemy > 2 || isGroundVehicle == true && ( isAirborneVehicle == false && enemyIsMovingSlow ) ) && enemyInfo.enemyDist > 500.0f && enemyInfo.enemyDist < GRENADE_ATTACK_DIST && enemyInfo.enemyHeight < 100.0f && botInfo->weapInfo.hasNadeAmmo ) {
|
|
useNadeOnEnemy = true;
|
|
}
|
|
}
|
|
|
|
if ( useNadeOnEnemy == false ) {
|
|
if ( botInfo->weapInfo.primaryWeapon == SHOTGUN ) {
|
|
if ( enemyInfo.enemyDist < SHOTGUN_DIST ) {
|
|
botIdealWeapSlot = GUN; //mal: the weap autoswitch code will handle switching to pistol if gun is out of ammo.
|
|
} else {
|
|
botIdealWeapSlot = SIDEARM;
|
|
}
|
|
} else {
|
|
botIdealWeapSlot = GUN;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case COVERTOPS:
|
|
if ( useNades && useNadeOnEnemy == false ) {
|
|
if ( ( !enemyInfo.enemyFacingBot || ourEnemiesAroundEnemy > 2 || isGroundVehicle == true && ( isAirborneVehicle == false && enemyIsMovingSlow ) ) && enemyInfo.enemyDist > 500.0f && enemyInfo.enemyDist < GRENADE_ATTACK_DIST && enemyInfo.enemyHeight < 100.0f && botInfo->weapInfo.hasNadeAmmo ) {
|
|
useNadeOnEnemy = true;
|
|
}
|
|
}
|
|
|
|
if ( useNadeOnEnemy == false ) {
|
|
if ( botInfo->weapInfo.primaryWeapon == SNIPERRIFLE ) {
|
|
if ( ( enemyInfo.enemyDist > 900.0f || enemyInfo.enemyDist < 300.0f ) && botInfo->enemiesInArea < 2 && ( botInfo->weapInfo.primaryWeapClipEmpty == false || enemyInfo.enemyDist > 700.0f || botInfo->friendsInArea > 0 ) ) {
|
|
botIdealWeapSlot = GUN; //mal: if my enemy is far away, or REALLY close, and I'm not surrounded, and I have a bullet in the clip, or my enemy is far enough away for me to safely reload or I have some friends near me to cover me while I reload, I'll use my sniperrifle.
|
|
} else {
|
|
botIdealWeapSlot = SIDEARM;
|
|
}
|
|
} else {
|
|
botIdealWeapSlot = GUN;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case SOLDIER:
|
|
if ( useNades && useNadeOnEnemy == false ) {
|
|
if ( ( !enemyInfo.enemyFacingBot || ourEnemiesAroundEnemy > 2 || isGroundVehicle == true && ( isAirborneVehicle == false && enemyIsMovingSlow ) ) && enemyInfo.enemyDist > 500.0f && enemyInfo.enemyDist < GRENADE_ATTACK_DIST && enemyInfo.enemyHeight < 100.0f && botInfo->weapInfo.hasNadeAmmo && ( botInfo->weapInfo.primaryWeapon != ROCKET && botInfo->weapInfo.primaryWeapon != HEAVY_MG ) ) {
|
|
useNadeOnEnemy = true;
|
|
}
|
|
}
|
|
|
|
if ( useNadeOnEnemy == false ) {
|
|
if ( botInfo->weapInfo.primaryWeapon == SHOTGUN ) {
|
|
if ( enemyInfo.enemyDist < SHOTGUN_DIST ) {
|
|
botIdealWeapSlot = GUN; //mal: the weap autoswitch code will handle switching to pistol if gun is out of ammo.
|
|
} else {
|
|
if ( botInfo->team == STROGG ) {
|
|
if ( enemyInfo.enemyDist > LIGHTNING_GUN_DIST ) {
|
|
botIdealWeapSlot = GUN;
|
|
} else {
|
|
botIdealWeapSlot = SIDEARM; //mal: lightning gun is ranged.
|
|
}
|
|
} else {
|
|
botIdealWeapSlot = SIDEARM;
|
|
}
|
|
}
|
|
} else if ( botInfo->weapInfo.primaryWeapon == SMG ) { //mal: the easiest of the bunch! :-D
|
|
botIdealWeapSlot = GUN;
|
|
} else if ( botInfo->weapInfo.primaryWeapon == HEAVY_MG ) {
|
|
if ( enemyInfo.enemyDist < 2500.0f && ( botInfo->weapInfo.primaryWeapClipEmpty == false || enemyInfo.enemyDist > 700.0f || botInfo->friendsInArea > 0 ) ) {
|
|
botIdealWeapSlot = GUN; //mal: the weap autoswitch code will handle switching to pistol if gun is out of ammo.
|
|
} else {
|
|
botIdealWeapSlot = SIDEARM;
|
|
}
|
|
} else if ( botInfo->weapInfo.primaryWeapon == ROCKET ) {
|
|
if ( enemyClient.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE && ourFriendsAroundEnemy == 0 && enemyInfo.enemyDist < WEAPON_LOCK_DIST ) { //mal: dont kill our friends!
|
|
botIdealWeapSlot = GUN;
|
|
} else {
|
|
if ( enemyInfo.enemyDist > 500.0f && enemyInfo.enemyDist < 2500.0f && ( botInfo->weapInfo.primaryWeapClipEmpty == false || enemyInfo.enemyDist > 1200.0f || enemyClient.friendsInArea > 1 ) && ourFriendsAroundEnemy == 0 ) {
|
|
botIdealWeapSlot = GUN;
|
|
} else {
|
|
if ( botInfo->team == STROGG ) {
|
|
if ( enemyInfo.enemyDist > LIGHTNING_GUN_DIST ) {
|
|
botIdealWeapSlot = GUN;
|
|
} else {
|
|
botIdealWeapSlot = SIDEARM; //mal: lightning gun is ranged.
|
|
}
|
|
} else {
|
|
botIdealWeapSlot = SIDEARM;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
botIdealWeapSlot = GUN;
|
|
break;
|
|
}
|
|
|
|
weapSwitchTime = botWorld->gameLocalInfo.time + 1500; //mal: dont constantly switch back and forth between weapons.
|
|
|
|
if ( useAircanOnEnemy != false ) {
|
|
botIdealWeapSlot = NO_WEAPON;
|
|
botIdealWeapNum = AIRCAN;
|
|
} else if ( useNadeOnEnemy != false ) {
|
|
botIdealWeapSlot = NADE;
|
|
botIdealWeapNum = NULL_WEAP;
|
|
|
|
if ( combatMoveType != GRENADE_ATTACK ) {
|
|
COMBAT_MOVEMENT_STATE = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_PickPostCombatGoal
|
|
|
|
Decide if we should do something to our recently deceased enemy.
|
|
|
|
TODO: add more possible post combat behaviors?
|
|
================
|
|
*/
|
|
bool idBotAI::Bot_PickPostCombatGoal() {
|
|
if ( !ClientIsValid( enemy, -1 ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( Client_IsCriticalForCurrentObj( botNum, -1.0f ) ) { //mal: bots who are critical to the war effort will ignore such sillyness.
|
|
return false;
|
|
}
|
|
|
|
if ( AIStack.STACK_AI_NODE != NULL && AIStack.isPriority == true ) { //mal: we were doing something important before we got in combat - get back to it!
|
|
return false;
|
|
}
|
|
|
|
if ( ( botInfo->classType != MEDIC || botInfo->team != STROGG ) && botInfo->classType != COVERTOPS && botThreadData.random.RandomInt( 100 ) > 80 ) {
|
|
if ( !botWorld->clientInfo[ enemy ].inLimbo && !botWorld->clientInfo[ enemy ].inWater && !botWorld->clientInfo[ enemy ].isBot ) {
|
|
if ( botWorld->clientInfo[ enemy ].areaNum > 0 ) {
|
|
idVec3 vec = botWorld->clientInfo[ enemy ].origin - botInfo->origin;
|
|
if ( vec.LengthSqr() < Square( 700.0f ) ) {
|
|
nbgTarget = enemy;
|
|
nbgTargetSpawnID = enemySpawnID;
|
|
ROOT_AI_NODE = &idBotAI::Run_NBG_Node;
|
|
NBG_AI_SUB_NODE = &idBotAI::Enter_NBG_HumiliateEnemy;
|
|
Bot_ResetEnemy();
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//mal: slows the game down too much in ETQW.
|
|
/*
|
|
if ( botThreadData.random.RandomInt( 100 ) > 80 && !LocationVis2Sky( botInfo->origin ) ) { //mal: sometimes, when indoors, take a sec to look around for more enemies.
|
|
nbgOrigin = enemyInfo.enemy_FS_Pos;
|
|
ROOT_AI_NODE = &idBotAI::Run_NBG_Node;
|
|
NBG_AI_SUB_NODE = &idBotAI::Enter_NBG_Pause;
|
|
Bot_ResetEnemy();
|
|
return true;
|
|
}
|
|
*/
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_ShouldChaseHiddenEnemy
|
|
================
|
|
*/
|
|
bool idBotAI::Bot_ShouldChaseHiddenEnemy( bool chase ) {
|
|
|
|
proxyInfo_t vehicleInfo;
|
|
idVec3 vec, origin;
|
|
chaseEnemy = false;
|
|
chasingEnemy = false;
|
|
|
|
if ( enemyIsHuntGoal ) {
|
|
return true;
|
|
}
|
|
|
|
if ( botInfo->usingMountedGPMG ) {
|
|
return false;
|
|
}
|
|
|
|
if ( ClientHasObj( botNum ) || Client_IsCriticalForCurrentObj( botNum, -1.0f ) ) { //mal: never chase if we are important!
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->health <= 30 ) {
|
|
if ( botThreadData.random.RandomInt( 100 ) > 50 ) { //mal: if we're in bad shape, sometimes we'll give up the fight
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( !botInfo->weapInfo.primaryWeapHasAmmo && !ClientHasObj( enemy ) ) { //mal: we don't have any ammo, and hes not that important, so let him go...
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->clientInfo[ enemy ].proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
|
|
GetVehicleInfo( botWorld->clientInfo[ enemy ].proxyInfo.entNum, vehicleInfo );
|
|
|
|
if ( vehicleInfo.inWater ) {
|
|
return false;
|
|
} //mal: hes in the water, but we can't chase him, so forget him!
|
|
|
|
if ( !ClientHasObj( enemy ) && !Client_IsCriticalForCurrentObj( enemy, 2000.0f ) ) {
|
|
if ( botThreadData.random.RandomInt( 100 ) > 50 ) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( AIStack.STACK_AI_NODE != NULL && AIStack.isPriority != false && !ClientHasObj( enemy ) ) {
|
|
return false;
|
|
} // we have something important on our mind, and cant chase ATM - UNLESS they have the obj! Always chase them!
|
|
|
|
origin = ( chase ) ? enemyInfo.enemy_NS_Pos : enemyInfo.enemy_LS_Pos;
|
|
vec = origin - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() > Square( ENEMY_CHASE_DIST ) ) {
|
|
return false;
|
|
} // too far away to chase
|
|
|
|
vec = origin - botWorld->clientInfo[ enemy ].origin;
|
|
|
|
if ( vec.LengthSqr() > Square( 900.0f ) && !ClientHasObj( enemy ) && !Client_IsCriticalForCurrentObj( enemy, 1500.0f ) && !ClientIsDangerous( enemy ) ) { // unless he's REALLY close or a major threat, sometimes we'll stop the chase, just because....
|
|
if ( botThreadData.random.RandomInt( 100 ) > 50 ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//mal_TODO: add more stuff here as we need to.
|
|
|
|
if ( chase ) {
|
|
chaseEnemy = true;
|
|
}
|
|
|
|
chasingEnemy = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_CheckShouldUseGrenade
|
|
================
|
|
*/
|
|
bool idBotAI::Bot_CheckShouldUseGrenade( bool targetVisible ) {
|
|
bool useGrenade = false;
|
|
idVec3 vec;
|
|
float dist;
|
|
|
|
if ( botInfo->weapInfo.hasNadeAmmo == false ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_DEMO || botWorld->gameLocalInfo.botSkill == BOT_SKILL_EASY ) {
|
|
if ( botThreadData.random.RandomInt( 100 ) > 30 ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( !targetVisible ) {
|
|
if ( ( lastGrenadeTime + 15000 ) > botWorld->gameLocalInfo.time ) { //mal: we already threw a nade recently - dont do so again.
|
|
return false;
|
|
}
|
|
|
|
if ( enemyInfo.enemy_LS_Pos == vec3_zero ) {
|
|
return false;
|
|
}
|
|
|
|
vec = enemyInfo.enemy_LS_Pos - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() > Square( GRENADE_THROW_MAXDIST ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botThreadData.random.RandomInt( 100 ) > 85 ) {
|
|
return false;
|
|
}
|
|
|
|
vec = enemyInfo.enemy_LS_Pos - botWorld->clientInfo[ enemy ].origin;
|
|
|
|
if ( vec.LengthSqr() > Square( 900.0f ) ) {
|
|
return false;
|
|
}
|
|
|
|
trace_t tr;
|
|
|
|
botThreadData.clip->TracePointExt( CLIP_DEBUG_PARMS tr, botInfo->viewOrigin, enemyInfo.enemy_LS_Pos, MASK_SHOT_BOUNDINGBOX | MASK_VEHICLESOLID | CONTENTS_FORCEFIELD, GetGameEntity( botNum ), NULL );
|
|
|
|
if ( tr.fraction < 1.0f ) {
|
|
return false;
|
|
}
|
|
|
|
useGrenade = true;
|
|
|
|
safeGrenade = ( botThreadData.random.RandomInt( 100 ) > 40 ) ? true : false; // for safe nade - will stand back and throw, else will charge up to enemy and toss at them
|
|
|
|
} else { //mal: target is visible!
|
|
|
|
int clients;
|
|
|
|
vec = botWorld->clientInfo[ enemy ].origin - botInfo->origin;
|
|
dist = vec.LengthFast();
|
|
|
|
if ( dist > GRENADE_THROW_MAXDIST ) { // too far away!
|
|
return false;
|
|
}
|
|
|
|
if ( !enemyInfo.enemyFacingBot ) { //sneak attack!
|
|
return true;
|
|
}
|
|
|
|
clients = ClientsInArea( -1, botWorld->clientInfo[ enemy ].origin, 600.0f, ( botInfo->team == GDF ) ? STROGG : GDF, NOCLASS, false, false, false, false, false );
|
|
|
|
if ( clients > 3 ) { // bunch of them in the same area - take advantage of this! need more clients in same area to make this worthwhile
|
|
return true;
|
|
}
|
|
|
|
if ( enemyInfo.enemyHeight <= -150 ) { // we have the height advantage - so use it!
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return useGrenade;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::UpdateNonVisEnemyInfo
|
|
================
|
|
*/
|
|
void idBotAI::UpdateNonVisEnemyInfo() {
|
|
if ( !ClientIsValid( enemy, -1 ) ) {
|
|
return;
|
|
}
|
|
|
|
trace_t tr;
|
|
botThreadData.clip->TracePoint( CLIP_DEBUG_PARMS tr, enemyInfo.enemy_LS_Pos, botWorld->clientInfo[ enemy ].origin, BOT_VISIBILITY_TRACE_MASK, GetGameEntity( enemy ) );
|
|
|
|
if ( tr.fraction == 1.0f ) {
|
|
enemyInfo.enemy_NS_Pos = botWorld->clientInfo[ enemy ].origin;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_ThrowGrenade
|
|
================
|
|
*/
|
|
bool idBotAI::Bot_ThrowGrenade( const idVec3 &origin, bool fastNade ) {
|
|
int fuseTime = ( fastNade == true ) ? 250 : 3000;
|
|
float height;
|
|
idVec3 vec = origin - botInfo->origin;
|
|
float dist = vec.LengthSqr();
|
|
|
|
// Bot_LookAtLocation( origin, INSTANT_TURN );
|
|
|
|
if ( botInfo->weapInfo.weapon == GRENADE || botInfo->weapInfo.weapon == EMP ) {
|
|
botUcmd->botCmds.attack = true;
|
|
botUcmd->botCmds.constantFire = true;
|
|
|
|
height = vec[ 2 ];
|
|
|
|
idVec3 nadeTarget = origin;
|
|
|
|
if ( dist > Square( GRENADE_THROW_MINDIST ) && height < 150.0f ) {
|
|
nadeTarget.z += 32.0f;
|
|
botUcmd->botCmds.throwNade = true;
|
|
}
|
|
|
|
Bot_LookAtLocation( nadeTarget, INSTANT_TURN, true );
|
|
|
|
if ( botThreadData.AllowDebugData() ) {
|
|
gameRenderWorld->DebugLine( colorLtGrey, botInfo->viewOrigin, nadeTarget, 99 );
|
|
}
|
|
|
|
if ( botInfo->weapInfo.weapon == EMP ) {
|
|
if ( botThreadData.random.RandomInt( 100 ) > 90 ) {
|
|
botUcmd->botCmds.attack = false;
|
|
lastGrenadeTime = botWorld->gameLocalInfo.time;
|
|
useNadeOnEnemy = false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
if ( botInfo->weapInfo.grenadeFuseStart != -1 ) {
|
|
if ( botWorld->gameLocalInfo.time > ( ( botInfo->weapInfo.grenadeFuseStart * 1000 ) + fuseTime ) ) {
|
|
botUcmd->botCmds.attack = false;
|
|
lastGrenadeTime = botWorld->gameLocalInfo.time;
|
|
useNadeOnEnemy = false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_CheckCombatExceptions
|
|
================
|
|
*/
|
|
bool idBotAI::Bot_CheckCombatExceptions() {
|
|
int attackerHealth;
|
|
float distToAttackerSqr = Square( 99999.0f );
|
|
float ignoreDangerDist = 2500.0f;
|
|
idVec3 vec;
|
|
|
|
if ( botInfo->lastAttacker > -1 && botInfo->lastAttacker < MAX_CLIENTS ) {
|
|
attackerHealth = botWorld->clientInfo[ botInfo->lastAttacker ].health;
|
|
vec = botWorld->clientInfo[ botInfo->lastAttacker ].origin - botInfo->origin;
|
|
distToAttackerSqr = vec.LengthSqr();
|
|
} else { //mal: paranoid safety check!
|
|
attackerHealth = 0;
|
|
} //mal: check to see if the guy who attacked us last is dead - in which case we won't worry about having been shot by him recently!
|
|
|
|
if ( botInfo->onLadder ) {
|
|
if ( botInfo->lastAttackerTime + 1500 < botWorld->gameLocalInfo.time || attackerHealth <= 0 || distToAttackerSqr > Square( ignoreDangerDist ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if ( aiState == LTG && ( ltgType == STEAL_GOAL || ltgType == DELIVER_GOAL || ltgType == RECOVER_GOAL ) ) {
|
|
if ( botInfo->lastAttackerTime + 1500 < botWorld->gameLocalInfo.time || attackerHealth <= 0 || distToAttackerSqr > Square( ignoreDangerDist ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
switch ( botInfo->classType ) {
|
|
|
|
case MEDIC: {
|
|
if ( ( aiState == NBG && nbgType == SUPPLY_TEAMMATE ) ) { // medics will try to heal humans no matter what!
|
|
if ( botInfo->isActor ) {
|
|
return false;
|
|
}
|
|
|
|
if ( ClientIsValid( nbgTarget, -1 ) ) {
|
|
const clientInfo_t& player = botWorld->clientInfo[ nbgTarget ];
|
|
|
|
if ( !player.isBot ) { //mal: always make the human feel special and try to heal him no matter what, even tho it will likely get us killed.
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( ( aiState == NBG && nbgType == REVIVE_TEAMMATE ) ) { // medics will try to revive before fighting, unless they are under attack!
|
|
|
|
if ( DisguisedKillerInArea() && botInfo->team != GDF ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->team == GDF && distToAttackerSqr > Square( 1500.0f ) ) { //mal: our intstant revive means we can get the job done before without dying ( hopefully! ).
|
|
return true;
|
|
}
|
|
|
|
if ( ( botInfo->lastAttackerTime + 1000 ) < botWorld->gameLocalInfo.time || attackerHealth <= 0 || distToAttackerSqr > Square( ignoreDangerDist ) ) {
|
|
return true;
|
|
} // if not under direct attack - try to revive, the more friendlies we can bring to bear on our enemy, the better chance we've got of winning!
|
|
|
|
if ( ClientIsValid( nbgTarget, -1 ) ) {
|
|
const clientInfo_t& player = botWorld->clientInfo[ nbgTarget ];
|
|
|
|
if ( !player.isBot ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if ( botInfo->team == STROGG ) { //mal: strogg take so much longer to revive, that if we're under attack, we MUST decide whether to engage!
|
|
return false;
|
|
}
|
|
|
|
if ( attackerHealth > 0 ) { //mal: if the guy who shot us is in front of us, NEVER ignore him!
|
|
if ( InFrontOfClient( botNum, botWorld->clientInfo[ botInfo->lastAttacker ].origin ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
vec = botWorld->clientInfo[ nbgTarget ].origin - botInfo->origin;
|
|
|
|
if ( vec.LengthFast() < 500.0f ) { // really close to our target - take a chance to revive them
|
|
return true;
|
|
}
|
|
|
|
if ( botInfo->enemiesInArea == 0 || botInfo->friendsInArea > 1 ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if ( aiState == LTG && ( ltgType == DEFENSE_CAMP_GOAL || ltgType == DESTROY_DEPLOYABLE_GOAL || ltgType == FDA_GOAL || ltgType == STEAL_SPAWN_GOAL ) ) {
|
|
if ( ( botInfo->lastAttackerTime + 1000 ) < botWorld->gameLocalInfo.time || attackerHealth <= 0 || distToAttackerSqr > Square( ignoreDangerDist ) ) {
|
|
return true;
|
|
} // if not under direct attack - try to build. This is important!
|
|
|
|
if ( attackerHealth > 0 ) { //mal: if the guy who shot us is in front of us, NEVER ignore him!
|
|
if ( InFrontOfClient( botNum, botWorld->clientInfo[ botInfo->lastAttacker ].origin ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( botInfo->enemiesInArea < 2 || botInfo->friendsInArea > 0 ) { //mal: we'll ignore only 1 enemy, hopefully theres some backup around here.
|
|
return true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case ENGINEER: {
|
|
if ( ( aiState == NBG && ( nbgType == BUILD || nbgType == DEFUSE_BOMB || nbgType == PLANT_MINE ) ) || Client_IsCriticalForCurrentObj( botNum, 900.0f ) || ( aiState == LTG && ( ltgType == DEFENSE_CAMP_GOAL || ltgType == DESTROY_DEPLOYABLE_GOAL || ltgType == FDA_GOAL || ltgType == FIX_MCP || ltgType == STEAL_SPAWN_GOAL ) ) ) { // eng is actually in the process of building ATM - lets see if he should ignore any enemies - engs will try to build at all costs, unless they are under attack!
|
|
|
|
if ( actionNum != -1 ) {
|
|
if ( botThreadData.botActions[ actionNum ]->GetHumanObj() == ACTION_MINOR_OBJ_BUILD || botThreadData.botActions[ actionNum ]->GetStroggObj() == ACTION_MINOR_OBJ_BUILD ) {
|
|
return false; //mal: dont care about minor build objs - they're not worth dying for!
|
|
}
|
|
}
|
|
|
|
if ( ( botInfo->lastAttackerTime + 1000 ) < botWorld->gameLocalInfo.time || attackerHealth <= 0 || distToAttackerSqr > Square( ignoreDangerDist ) ) {
|
|
return true;
|
|
} // if not under direct attack - try to build. This is important!
|
|
|
|
if ( attackerHealth > 0 ) { //mal: if the guy who shot us is in front of us, NEVER ignore him!
|
|
if ( InFrontOfClient( botNum, botWorld->clientInfo[ botInfo->lastAttacker ].origin ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( CriticalEnemyClientNearUs( SOLDIER ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( aiState == LTG && ltgType == FIX_MCP ) {
|
|
if ( attackerHealth > 0 ) {
|
|
proxyInfo_t enemyVehicle;
|
|
GetVehicleInfo( botWorld->clientInfo[ botInfo->lastAttacker ].proxyInfo.entNum, enemyVehicle );
|
|
|
|
if ( enemyVehicle.entNum != 0 ) {
|
|
if ( enemyVehicle.isAirborneVehicle ) {
|
|
return true;
|
|
}
|
|
|
|
idVec3 vec = enemyVehicle.origin - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() > Square( 1500.0f ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( botInfo->enemiesInArea < 2 || botInfo->friendsInArea > 0 ) { //mal: we'll ignore only 1 enemy, hopefully theres some backup around here.
|
|
return true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if ( ( aiState == NBG && nbgType == DROP_DEPLOYABLE ) || ( aiState == LTG && ltgType == DROP_DEPLOYABLE_GOAL ) ) {
|
|
if ( actionNum != -1 ) {
|
|
if ( botThreadData.botActions[ actionNum ]->ActionIsPriority() == false ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( ( botInfo->lastAttackerTime + 1000 ) < botWorld->gameLocalInfo.time || attackerHealth <= 0 || distToAttackerSqr > Square( ignoreDangerDist ) ) {
|
|
return true;
|
|
} // if not under direct attack - try to build. This is important!
|
|
|
|
if ( attackerHealth > 0 ) { //mal: if the guy who shot us is in front of us, NEVER ignore him!
|
|
if ( InFrontOfClient( botNum, botWorld->clientInfo[ botInfo->lastAttacker ].origin ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( botInfo->enemiesInArea == 0 ) {
|
|
return true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case COVERTOPS: {
|
|
if ( Client_IsCriticalForCurrentObj( botNum, 900.0f ) || ( aiState == NBG && nbgType == HACK ) || ( aiState == LTG && ( ltgType == DEFENSE_CAMP_GOAL || ltgType == DESTROY_DEPLOYABLE_GOAL || ltgType == FDA_GOAL || ltgType == STEAL_SPAWN_GOAL ) ) ) {
|
|
|
|
if ( ( botInfo->lastAttackerTime + 1000 ) < botWorld->gameLocalInfo.time || attackerHealth <= 0 || distToAttackerSqr > Square( ignoreDangerDist ) ) {
|
|
return true;
|
|
} // if not under direct attack - try to hack. This is important!
|
|
|
|
if ( attackerHealth > 0 ) { //mal: if the guy who shot us is in front of us, NEVER ignore him!
|
|
if ( InFrontOfClient( botNum, botWorld->clientInfo[ botInfo->lastAttacker ].origin ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( botInfo->enemiesInArea < 2 || botInfo->friendsInArea > 0 ) { //mal: we'll ignore only 1 enemy, hopefully theres some backup around here.
|
|
return true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case FIELDOPS: {
|
|
if ( aiState == LTG && ( ltgType == DESTROY_DEPLOYABLE_GOAL || ltgType == FDA_GOAL || ltgType == STEAL_SPAWN_GOAL || ltgType == DEFENSE_CAMP_GOAL || ( ltgType == FIRESUPPORT_CAMP_GOAL && ltgReached == false ) ) ) {
|
|
if ( ( botInfo->lastAttackerTime + 1000 ) < botWorld->gameLocalInfo.time || attackerHealth <= 0 || distToAttackerSqr > Square( ignoreDangerDist ) ) {
|
|
return true;
|
|
} // if not under direct attack - try to destroy. This is important!
|
|
|
|
if ( attackerHealth > 0 ) { //mal: if the guy who shot us is in front of us, NEVER ignore him!
|
|
if ( InFrontOfClient( botNum, botWorld->clientInfo[ botInfo->lastAttacker ].origin ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( botInfo->enemiesInArea < 2 || botInfo->friendsInArea > 0 ) { //mal: we'll ignore only 1 enemy, hopefully theres some backup around here.
|
|
return true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
case SOLDIER: {
|
|
if ( Client_IsCriticalForCurrentObj( botNum, 900.0f ) || ( aiState == NBG && nbgType == PLANT_BOMB ) || ( aiState == LTG && ( ltgType == DEFENSE_CAMP_GOAL || ltgType == DESTROY_DEPLOYABLE_GOAL || ltgType == FDA_GOAL || ltgType == STEAL_SPAWN_GOAL ) ) ) {
|
|
|
|
if ( actionNum != ACTION_NULL ) {
|
|
if ( ClientHasChargeInWorld( botNum, true, actionNum ) ) { //mal: if we've planted, and are just camping nearby, DO attack anyone we see!
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( ( botInfo->lastAttackerTime + 1000 ) < botWorld->gameLocalInfo.time || attackerHealth <= 0 || distToAttackerSqr > Square( ignoreDangerDist ) ) {
|
|
return true;
|
|
} // if not under direct attack - try to plant. This is important!
|
|
|
|
if ( attackerHealth > 0 ) { //mal: if the guy who shot us is in front of us, NEVER ignore him!
|
|
if ( InFrontOfClient( botNum, botWorld->clientInfo[ botInfo->lastAttacker ].origin ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( CriticalEnemyClientNearUs( ENGINEER ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->enemiesInArea < 2 || botInfo->friendsInArea > 0 ) { //mal: we'll ignore only 1 enemy, if we've got some backup around here.
|
|
return true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::ClientsInArea
|
|
================
|
|
*/
|
|
int idBotAI::ClientsInArea( int ignoreClientNum, const idVec3 &org, float range, int team, const playerClassTypes_t clientClass, bool inFront, bool vis2Sky, bool ignoreInvulnerable, bool ignoreDisguised, bool ignoreInVehicle, bool humanOnly ) {
|
|
int i;
|
|
int clients = 0;
|
|
idVec3 vec;
|
|
|
|
for( i = 0; i < MAX_CLIENTS; i++ ) {
|
|
|
|
if ( i == ignoreClientNum ) { // dont scan the client who started this
|
|
continue;
|
|
}
|
|
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue; //mal: no valid client in this client slot!
|
|
}
|
|
|
|
const clientInfo_t& playerInfo = botWorld->clientInfo[ i ];
|
|
|
|
if ( !playerInfo.inGame ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.health <= 0 ) { //mal: dont count dead clients!
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.isNoTarget ) { //mal: let me debug behavior!
|
|
continue;
|
|
}
|
|
|
|
if ( humanOnly ) {
|
|
if ( playerInfo.isBot ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( clientClass != NOCLASS ) {
|
|
if ( playerInfo.classType != clientClass ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( ignoreInVehicle ) {
|
|
if ( playerInfo.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( ignoreDisguised ) {
|
|
if ( playerInfo.isDisguised ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( ignoreInvulnerable ) {
|
|
if ( playerInfo.invulnerableEndTime > botWorld->gameLocalInfo.time ) {
|
|
continue; //mal: ignore revived/just spawned in clients
|
|
}
|
|
}
|
|
|
|
if ( vis2Sky ) {
|
|
if ( !LocationVis2Sky( playerInfo.origin ) ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( team != NOTEAM ) {
|
|
if ( playerInfo.team != team ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
vec = playerInfo.origin - org;
|
|
|
|
if ( vec.LengthSqr() > Square( range ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( inFront && ignoreClientNum != -1 ) {
|
|
if ( !InFrontOfClient( ignoreClientNum, playerInfo.origin )) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
clients++;
|
|
}
|
|
|
|
return clients;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_CheckShouldUseAircan
|
|
================
|
|
*/
|
|
bool idBotAI::Bot_CheckShouldUseAircan( bool targetVisible ) {
|
|
|
|
idVec3 vec;
|
|
float dist;
|
|
|
|
if ( botInfo->classType != FIELDOPS ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_DEMO || botWorld->gameLocalInfo.botSkill == BOT_SKILL_EASY ) {
|
|
if ( botThreadData.random.RandomInt( 100 ) > 30 ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( !ClassWeaponCharged( AIRCAN )) {
|
|
return false;
|
|
}
|
|
|
|
if ( !targetVisible ) {
|
|
|
|
if ( !LocationVis2Sky( enemyInfo.enemy_LS_Pos )) {
|
|
return false;
|
|
}
|
|
|
|
if ( enemyInfo.enemy_LS_Pos == vec3_zero ) {
|
|
return false;
|
|
}
|
|
|
|
vec = enemyInfo.enemy_LS_Pos - botInfo->origin;
|
|
dist = vec.LengthFast();
|
|
vec = enemyInfo.enemy_LS_Pos - botWorld->clientInfo[ enemy ].origin;
|
|
|
|
if ( dist > 900.0f ) {
|
|
return false;
|
|
}
|
|
|
|
if ( vec.LengthFast() > 900.0f ) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
|
|
} else { //mal: target is visible!
|
|
|
|
int clients;
|
|
|
|
vec = botWorld->clientInfo[ enemy ].origin - botInfo->origin;
|
|
dist = vec.LengthFast();
|
|
|
|
if ( !LocationVis2Sky( botWorld->clientInfo[ enemy ].origin ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( dist > 900.0f ) { // too far away!
|
|
return false;
|
|
}
|
|
|
|
if ( !enemyInfo.enemyFacingBot ) { //sneak attack!
|
|
return true;
|
|
}
|
|
|
|
clients = ClientsInArea( -1, botWorld->clientInfo[ enemy ].origin, 600.0f, ( botInfo->team == GDF ) ? STROGG : GDF, NOCLASS, false, true, false, false, false );
|
|
|
|
if ( clients > 1 ) { // bunch of them in the same area - take advantage of this!
|
|
return true;
|
|
}
|
|
|
|
if ( enemyInfo.enemyHeight <= -100 ) { // we have the height advantage - so use it!
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_UseCannister
|
|
================
|
|
*/
|
|
void idBotAI::Bot_UseCannister( const playerWeaponTypes_t weapType, const idVec3 &origin ) {
|
|
botIdealWeapNum = weapType;
|
|
botIdealWeapSlot = NO_WEAPON;
|
|
|
|
if ( botInfo->weapInfo.isReady && botInfo->weapInfo.weapon == weapType ) {
|
|
|
|
if ( botThreadData.random.RandomInt( 100 ) > 50 ) {
|
|
botUcmd->botCmds.attack = false;
|
|
} else {
|
|
botUcmd->botCmds.attack = true;
|
|
}
|
|
|
|
idVec3 vec = origin - botInfo->origin;
|
|
|
|
float height = vec.z;
|
|
|
|
if ( vec.LengthSqr() > Square( 700.0f ) && height < 150.0f ) {
|
|
botUcmd->botCmds.throwNade = true;
|
|
}
|
|
}
|
|
|
|
Bot_LookAtLocation( origin, FAST_TURN );
|
|
|
|
if ( weapType == AIRCAN ) {
|
|
if ( !ClassWeaponCharged( AIRCAN ) ) {
|
|
useAircanOnEnemy = false;
|
|
weapSwitchTime = 0;
|
|
}
|
|
}
|
|
|
|
if ( weapType == SUPPLY_MARKER ) {
|
|
botUcmd->botCmds.droppingSupplyCrate = true;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::EnemyValid
|
|
================
|
|
*/
|
|
bool idBotAI::EnemyValid() {
|
|
if ( !ClientIsValid( enemy, -1 ) ) {
|
|
return false;
|
|
}
|
|
|
|
const clientInfo_t& playerEnemyInfo = botWorld->clientInfo[ enemy ];
|
|
|
|
if ( playerEnemyInfo.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
if ( !botInfo->weapInfo.primaryWeapHasAmmo ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( enemyInfo.enemyDist > botWorld->botGoalInfo.botSightDist ) {
|
|
if ( botInfo->classType == COVERTOPS && botInfo->weapInfo.primaryWeapon == SNIPERRIFLE && botInfo->weapInfo.primaryWeapHasAmmo ) {
|
|
return true;
|
|
}
|
|
|
|
if ( botInfo->classType == SOLDIER && botInfo->weapInfo.primaryWeapon == ROCKET && botInfo->weapInfo.primaryWeapHasAmmo ) {
|
|
if ( botWorld->clientInfo[ enemy ].proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
idVec3 enemyOrg = botWorld->clientInfo[ enemy ].origin;
|
|
|
|
if ( botInfo->classType == FIELDOPS && ClassWeaponCharged( AIRCAN ) && Bot_HasWorkingDeployable() && !Bot_EnemyAITInArea( enemyOrg ) ) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::BotLeftEnemysSight
|
|
================
|
|
*/
|
|
bool idBotAI::BotLeftEnemysSight() {
|
|
trace_t tr;
|
|
idVec3 otherView = ( botWorld->clientInfo[ enemy ].proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) ? botWorld->clientInfo[ enemy ].origin : botWorld->clientInfo[ enemy ].viewOrigin;
|
|
|
|
botThreadData.clip->TracePoint( CLIP_DEBUG_PARMS tr, bot_LS_Enemy_Pos, otherView, BOT_VISIBILITY_TRACE_MASK, GetGameEntity( botNum ) );
|
|
|
|
if ( tr.fraction != 1.0f ) {
|
|
return false;
|
|
} else {
|
|
return true; // our enemy can still see the pos we were in when we last saw the enemy!
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_CheckAttack
|
|
================
|
|
*/
|
|
void idBotAI::Bot_CheckAttack() {
|
|
|
|
bool useLockon = ( botInfo->weapInfo.weapon == ROCKET && botWorld->clientInfo[ enemy ].proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) ? true : false;
|
|
|
|
float minUseScopeDist = ( botInfo->weapInfo.weapon == HEAVY_MG ) ? 400.0f : 700.0f;
|
|
|
|
if ( botWorld->gameLocalInfo.botAimSkill > 0 ) {
|
|
if ( ( botInfo->xySpeed == 0.0f || botInfo->posture == IS_CROUCHED || botInfo->posture == IS_PRONE || combatMoveType == STAND_GROUND_ATTACK || useLockon || botInfo->weapInfo.weapon == HEAVY_MG ) && enemyInfo.enemyDist > minUseScopeDist ) {
|
|
if ( botInfo->weapInfo.weapon == SMG || botInfo->weapInfo.weapon == PISTOL || botInfo->weapInfo.weapon == SHOTGUN || botInfo->weapInfo.weapon == SCOPED_SMG || botInfo->weapInfo.weapon == SNIPERRIFLE || botInfo->weapInfo.weapon == HEAVY_MG || useLockon ) {
|
|
botUcmd->botCmds.altAttackOn = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( timeOnTarget > botWorld->gameLocalInfo.time && hammerTime == false ) { //mal: dont fire until we get the enemy in our "sights".
|
|
return;
|
|
}
|
|
|
|
bool shotIsBlocked = false;
|
|
bool botWantsToAttack = false;
|
|
|
|
if ( botWorld->gameLocalInfo.botAimSkill == 0 && botInfo->weapInfo.weapon != ROCKET && botInfo->weapInfo.weapon != HEAVY_MG && botWorld->gameLocalInfo.botSkill != BOT_SKILL_DEMO ) { //mal: low skill bots won't shoot that much
|
|
if ( botThreadData.random.RandomInt( 100 ) > 10 ) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( gunTargetEntNum != -1 ) {
|
|
if ( EntityIsClient( gunTargetEntNum, true ) || botWorld->gameLocalInfo.inWarmup ) { //mal: always unload on enemies, even if not OUR enemy. In warmup - shoot everyone.
|
|
botWantsToAttack = true;
|
|
} else if ( EntityIsClient( gunTargetEntNum, false ) ) { //mal: never shoot a teammate
|
|
shotIsBlocked = true;
|
|
} else if ( EntityIsVehicle( gunTargetEntNum, true, true ) || botWorld->gameLocalInfo.inWarmup ) { //mal: enemy vehicles are OK to shoot, as long as theres someone in them. In warmup, will shoot any vehicle.
|
|
if ( useLockon ) {
|
|
botUcmd->botCmds.altAttackOn = true;
|
|
if ( botInfo->targetLockEntNum != -1 && botInfo->targetLocked != false ) {
|
|
botWantsToAttack = true;
|
|
}
|
|
} else {
|
|
botWantsToAttack = true;
|
|
}
|
|
} else if ( EntityIsVehicle( gunTargetEntNum, false, false ) ) { //mal: never shoot friendly vehicles.
|
|
shotIsBlocked = true;
|
|
} else if ( EntityIsDeployable( gunTargetEntNum, false ) ) { //mal: deployable in the way.
|
|
shotIsBlocked = true;
|
|
} else if ( gunTargetEntNum == ENTITYNUM_WORLD ) {
|
|
shotIsBlocked = true;
|
|
} else {
|
|
botWantsToAttack = true;
|
|
}
|
|
}
|
|
|
|
if ( !shotIsBlocked ) {
|
|
shotIsBlockedCounter = 0;
|
|
} else {
|
|
shotIsBlockedCounter++;
|
|
}
|
|
|
|
if ( !botWantsToAttack ) {
|
|
return;
|
|
}
|
|
|
|
if ( testFireShot ) {
|
|
if ( botInfo->weapInfo.weapon == SMG ) {
|
|
timeOnTarget = botWorld->gameLocalInfo.time + 1500; //mal: we want to "test" if our target returns a "ping", so shoot, wait a sec, then blast them!
|
|
}
|
|
testFireShot = false;
|
|
} //mal: no point if we dont have a SMG type weapon.
|
|
|
|
if ( botInfo->weapInfo.weapon == KNIFE ) {
|
|
if ( enemyInfo.enemyDist < 125.0f ) {
|
|
botUcmd->botCmds.attack = true;
|
|
botUcmd->botCmds.constantFire = true;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ( ( botInfo->weapInfo.weapon == GRENADE || botInfo->weapInfo.weapon == EMP ) && botInfo->weapInfo.hasNadeAmmo ) {
|
|
bool quickNade = false;
|
|
|
|
if ( enemyInfo.enemyFacingBot ) {
|
|
quickNade = true;
|
|
}
|
|
|
|
Bot_ThrowGrenade( botWorld->clientInfo[ enemy ].origin, quickNade );
|
|
return;
|
|
}
|
|
|
|
if ( botInfo->weapInfo.weapon == BINOCS ) {
|
|
botUcmd->botCmds.attack = true;
|
|
botUcmd->botCmds.constantFire = true;
|
|
return;
|
|
}
|
|
|
|
if ( botInfo->weapInfo.weapon == AIRCAN ) {
|
|
if ( ClassWeaponCharged( AIRCAN ) ) {
|
|
Bot_UseCannister( AIRCAN, botWorld->clientInfo[ enemy ].origin );
|
|
return;
|
|
} else {
|
|
weapSwitchTime = 0;
|
|
useAircanOnEnemy = false;
|
|
return;
|
|
}
|
|
}
|
|
|
|
botUcmd->botCmds.attack = true;
|
|
|
|
if ( botInfo->weapInfo.weapon == PISTOL && botInfo->team == STROGG && botInfo->classType == SOLDIER ) {
|
|
botUcmd->botCmds.constantFire = true;
|
|
return;
|
|
}
|
|
|
|
if ( botInfo->weapInfo.weapon == SNIPERRIFLE && botInfo->weapInfo.isFiringWeap ) {
|
|
timeOnTarget = botWorld->gameLocalInfo.time + 900; //mal: wait for nearly a second before fire again, so aim isn't all wonky.
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::CheckClientAttacker
|
|
|
|
check if clientNum has been attacked recently.
|
|
Returns the client who did the attacking.
|
|
================
|
|
*/
|
|
int idBotAI::CheckClientAttacker( int clientNum, int checkTimeInSeconds ) {
|
|
int attacker = -1;
|
|
|
|
if ( ( botWorld->clientInfo[ clientNum ].lastAttackerTime + ( checkTimeInSeconds * 1000 ) ) > botWorld->gameLocalInfo.time ) {
|
|
attacker = botWorld->clientInfo[ clientNum ].lastAttacker;
|
|
|
|
if ( ClientIsDead( attacker ) ) {
|
|
return -1;
|
|
}
|
|
|
|
if ( ClientIsIgnored( attacker ) ) {
|
|
return -1;
|
|
}
|
|
|
|
if ( botWorld->clientInfo[ attacker ].team == botWorld->clientInfo[ clientNum ].team ) {
|
|
return -1;
|
|
}
|
|
|
|
idVec3 vec = botWorld->clientInfo[ attacker ].origin - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() > Square( botWorld->botGoalInfo.botSightDist ) ) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return attacker;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_CanBackStabClient
|
|
================
|
|
*/
|
|
bool idBotAI::Bot_CanBackStabClient( int clientNum, float backStabDist ) {
|
|
int travelFlags = ( botInfo->team == GDF ) ? TFL_VALID_GDF : TFL_VALID_STROGG;
|
|
aasTraceFloor_t trace;
|
|
const clientInfo_t& player = botWorld->clientInfo[ clientNum ];
|
|
idVec3 end = player.viewOrigin; //player.origin;
|
|
|
|
end += ( -backStabDist * player.viewAxis[ 0 ] );
|
|
|
|
travelFlags &= ~TFL_WALKOFFLEDGE;
|
|
|
|
botAAS.aas->TraceFloor( trace, player.viewOrigin /*player.origin*/, player.areaNum, end, travelFlags );
|
|
|
|
if ( botThreadData.AllowDebugData() ) {
|
|
gameRenderWorld->DebugLine( colorRed, player.viewOrigin, end );
|
|
}
|
|
|
|
if ( trace.fraction >= 1.0f ) {
|
|
botBackStabMoveGoal = end;
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::ClientHasAttackedMate
|
|
|
|
Has this client attacked any of our teammates recently?
|
|
Can be used to spot coverts who run around knifing teammates or anyone who might be causing trouble.
|
|
Can be filtered to only check if important mates were attacked.
|
|
================
|
|
*/
|
|
bool idBotAI::ClientHasAttackedTeammate( int clientNum, bool criticalOnly, int time ) {
|
|
|
|
int i;
|
|
|
|
for( i = 0; i < MAX_CLIENTS; i++ ) {
|
|
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue; //mal: no valid client in this client slot!
|
|
}
|
|
|
|
const clientInfo_t& playerInfo = botWorld->clientInfo[ i ];
|
|
|
|
if ( playerInfo.team != botInfo->team ) {
|
|
continue;
|
|
}
|
|
|
|
if ( criticalOnly != false ) {
|
|
if ( botInfo->team == GDF ) {
|
|
if ( playerInfo.classType == botWorld->botGoalInfo.team_GDF_criticalClass && playerInfo.lastAttackerTime + time > botWorld->gameLocalInfo.time && playerInfo.lastAttacker == clientNum ) {
|
|
return true;
|
|
}
|
|
} else {
|
|
if ( playerInfo.classType == botWorld->botGoalInfo.team_STROGG_criticalClass && playerInfo.lastAttackerTime + time > botWorld->gameLocalInfo.time && playerInfo.lastAttacker == clientNum ) {
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
if ( playerInfo.lastAttackerTime + time > botWorld->gameLocalInfo.time && playerInfo.lastAttacker == clientNum ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::DisguisedKillerInArea
|
|
|
|
Is there a disguised killer ( covert ops ) in the area thats been killing some of our teammates?
|
|
If so, the bot should be more aware of its surroundings, and not skip any part of its
|
|
enemy checks.
|
|
================
|
|
*/
|
|
bool idBotAI::DisguisedKillerInArea() {
|
|
|
|
int i;
|
|
|
|
for( i = 0; i < MAX_CLIENTS; i++ ) {
|
|
|
|
if ( i == botNum ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue; //mal: no valid client in this client slot!
|
|
}
|
|
|
|
const clientInfo_t& playerInfo = botWorld->clientInfo[ i ];
|
|
|
|
if ( !playerInfo.isDisguised ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.team == botInfo->team ) {
|
|
continue;
|
|
}
|
|
|
|
if ( ClientHasAttackedTeammate( i , false, 3000 ) ) {
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::ClientIsDefusingOurTeamCharge
|
|
|
|
Is this client trying to defuse our team's charge? In which case, he should become a priority target!
|
|
================
|
|
*/
|
|
bool idBotAI::ClientIsDefusingOurTeamCharge( int clientNum ) {
|
|
|
|
int botActionNum;
|
|
const clientInfo_t& playerInfo = botWorld->clientInfo[ clientNum ];
|
|
idVec3 vec;
|
|
|
|
if ( playerInfo.classType != ENGINEER ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->team == GDF ) {
|
|
botActionNum = botWorld->botGoalInfo.team_GDF_PrimaryAction;
|
|
|
|
if ( botActionNum == -1 ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botThreadData.botActions[ botActionNum ]->GetHumanObj() == ACTION_HE_CHARGE ) {
|
|
if ( botThreadData.botActions[ botActionNum ]->ArmedChargesInsideActionBBox( -1 ) ) {
|
|
vec = botThreadData.botActions[ botActionNum ]->GetActionOrigin() - playerInfo.origin;
|
|
|
|
if ( vec.LengthSqr() < Square( 1500.0f ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
botActionNum = botWorld->botGoalInfo.team_STROGG_PrimaryAction;
|
|
|
|
if ( botActionNum == -1 ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botThreadData.botActions[ botActionNum ]->GetStroggObj() == ACTION_HE_CHARGE ) {
|
|
if ( botThreadData.botActions[ botActionNum ]->ArmedChargesInsideActionBBox( -1 ) ) {
|
|
vec = botThreadData.botActions[ botActionNum ]->GetActionOrigin() - playerInfo.origin;
|
|
|
|
if ( vec.LengthSqr() < Square( 1500.0f ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_PickChaseType
|
|
|
|
Choose how the bot will chase the enemy.
|
|
If the enemy is making a lot of noise, use that info to chase the enemy, ONLY if the bot is highskilled.
|
|
================
|
|
*/
|
|
void idBotAI::Bot_PickChaseType() {
|
|
bool isAudible;
|
|
idVec3 vec;
|
|
|
|
vec = enemyInfo.enemy_LS_Pos - botInfo->origin;
|
|
|
|
isAudible = ClientIsAudibleToBot( enemy );
|
|
|
|
if ( vec.LengthFast() < ENEMY_CHASE_DIST && ( ( isAudible && botThreadData.GetBotSkill() == BOT_SKILL_NORMAL ) || ( botThreadData.random.RandomInt( 100 ) > 40 && botThreadData.GetBotSkill() == BOT_SKILL_EXPERT ) ) ) {
|
|
COMBAT_AI_SUB_NODE = &idBotAI::Enter_COMBAT_Foot_ChaseUnseenEnemy;
|
|
} else {
|
|
COMBAT_AI_SUB_NODE = &idBotAI::Enter_COMBAT_Foot_ChaseEnemy;
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_CheckIfShouldInvestigateNoise
|
|
|
|
Checks to see if a bot should go investigate a client making some noise. Wont do this if busy doing something
|
|
more important!
|
|
================
|
|
*/
|
|
int idBotAI::Bot_ShouldInvestigateNoise( int clientNum ) {
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_EASY ) {
|
|
return 0;
|
|
} //mal: dumb bots dont worry about this kind of stuff!
|
|
|
|
if ( ClientIsIgnored( clientNum ) ) {
|
|
return 0;
|
|
}
|
|
|
|
if ( aiState == LTG && ltgType == HUNT_GOAL ) { //mal: already doing something about this!
|
|
return 0;
|
|
}
|
|
|
|
const clientInfo_t& playerInfo = botWorld->clientInfo[ clientNum ];
|
|
|
|
int travelTime;
|
|
|
|
if ( !Bot_LocationIsReachable( false, playerInfo.origin, travelTime ) ) { //mal: if we can't reach you, can't really investigate you.
|
|
return 0;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_DEMO && !botWorld->botGoalInfo.gameIsOnFinalObjective && !playerInfo.isBot ) { //mal: dont worry about noises made by human players in training mode, unless its the final obj...
|
|
return 0;
|
|
}
|
|
|
|
if ( botInfo->isActor ) { //mal: dont ever leave the player!
|
|
return 0;
|
|
}
|
|
|
|
if ( ClientIsDefusingOurTeamCharge( clientNum ) ) {
|
|
return 3;
|
|
}
|
|
|
|
if ( aiState == LTG && ( ltgType != ROAM_GOAL && ltgType != CAMP_GOAL && ltgType != INVESTIGATE_ACTION ) ) {
|
|
return 0;
|
|
}
|
|
|
|
if ( aiState == NBG && ( nbgType != CAMP && nbgType != DESTROY_DANGER && nbgType != SNIPE && nbgType != DEFENSE_CAMP ) ) {
|
|
return 0;
|
|
}
|
|
|
|
if ( ClientIsMarkedForDeath( clientNum, true ) ) {
|
|
if ( Bot_LTGIsAvailable( clientNum, ACTION_NULL, HUNT_GOAL, 1 ) ) {
|
|
Bot_AddDelayedChat( botNum, ACKNOWLEDGE_YES, 2 );
|
|
return 3;
|
|
}
|
|
}
|
|
|
|
if ( stayInPosition == true ) { //mal: we've decided to hold our ground ( low skills bots do this always, high skill sometimes to be unpredictable ), so leave.
|
|
return 0;
|
|
}
|
|
|
|
if ( ClientHasObj( clientNum ) ) {
|
|
return 3;
|
|
}
|
|
|
|
if ( Client_IsCriticalForCurrentObj( clientNum, 1500.0f ) ) {
|
|
return 3;
|
|
}
|
|
|
|
if ( ClientIsDangerous( clientNum ) ) { //mal: we're not gonna sit back and let someone camp us!
|
|
return 3;
|
|
}
|
|
|
|
if ( playerInfo.lastAttackClient > -1 && playerInfo.lastAttackClient < MAX_CLIENTS && playerInfo.lastAttackClientTime + 5000 > botWorld->gameLocalInfo.time ) {
|
|
if ( Client_IsCriticalForCurrentObj( playerInfo.lastAttackClient, -1.0f ) ) {
|
|
return 2;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_SetTimeOnTarget
|
|
|
|
Sets how long the bot should delay before he fires his weapon at the enemy.
|
|
================
|
|
*/
|
|
void idBotAI::Bot_SetTimeOnTarget( bool inVehicle ) {
|
|
bool inFront = InFrontOfClient( botNum, botWorld->clientInfo[ enemy ].origin );
|
|
|
|
if ( inVehicle ) {
|
|
if ( botVehicleInfo->driverEntNum == botNum ) {
|
|
timeOnTarget = botWorld->gameLocalInfo.time + 1500;
|
|
} else {
|
|
timeOnTarget = botWorld->gameLocalInfo.time + 150;
|
|
}
|
|
} else {
|
|
if ( botInfo->weapInfo.primaryWeapon == SNIPERRIFLE && !botInfo->weapInfo.isScopeUp ) { //mal: give us time to get scope up.
|
|
timeOnTarget = botWorld->gameLocalInfo.time + 1500;
|
|
return;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botAimSkill >= 3 ) {
|
|
timeOnTarget = 50;
|
|
return;
|
|
}
|
|
|
|
if ( !inFront ) {
|
|
if ( botWorld->gameLocalInfo.botAimSkill == 0 ) {
|
|
timeOnTarget = botWorld->gameLocalInfo.time + 950;
|
|
} else {
|
|
timeOnTarget = botWorld->gameLocalInfo.time + 250;
|
|
}
|
|
} else {
|
|
if ( botWorld->gameLocalInfo.botAimSkill == 0 ) {
|
|
timeOnTarget = botWorld->gameLocalInfo.time + 550;
|
|
} else {
|
|
timeOnTarget = botWorld->gameLocalInfo.time + 150;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Client_HasMultipleAttackers
|
|
================
|
|
*/
|
|
bool idBotAI::Client_HasMultipleAttackers( int clientNum ) {
|
|
int n = 0;
|
|
const clientInfo_t& client = botWorld->clientInfo[ clientNum ];
|
|
|
|
for( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
if ( i == clientNum ) {
|
|
continue;
|
|
}
|
|
|
|
const clientInfo_t& player = botWorld->clientInfo[ clientNum ];
|
|
|
|
if ( player.inGame == false || player.team == NOTEAM || player.team != client.team ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.lastAttackClient != clientNum || player.lastAttackClientTime + 5000 < botWorld->gameLocalInfo.time ) {
|
|
continue;
|
|
}
|
|
|
|
n++;
|
|
}
|
|
|
|
if ( n > 1 ) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Bot_IsNearTeamGoalUnderAttack
|
|
|
|
In the bots travels, he may move near a team goal thats currently under attack. Its possible that when the event of the goal being under attack was first sent,
|
|
the bot was too far away, or too busy to answer it. If so, he should stop doing whatever hes doing, and move to that goal to defend it.
|
|
================
|
|
*/
|
|
bool idBotAI::Bot_IsNearTeamGoalUnderAttack() {
|
|
|
|
if ( botThreadData.GetBotSkill() == BOT_SKILL_EASY ) { //mal: only the smartest bots will do this.
|
|
return false;
|
|
}
|
|
|
|
if ( Client_IsCriticalForCurrentObj( botNum, -1 ) && botWorld->botGoalInfo.attackingTeam == botInfo->team ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_DEMO && !botWorld->botGoalInfo.gameIsOnFinalObjective ) { //mal: dont worry about the obj if we're in training mode, unless its the final one...
|
|
return false;
|
|
}
|
|
|
|
if ( aiState == LTG && ( ltgType == DEFUSE_GOAL || ltgType == PLANT_GOAL || ltgType == BUILD_GOAL || ltgType == HACK_GOAL || ltgType == FOLLOW_TEAMMATE_BY_REQUEST || ltgType == HUNT_GOAL ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( aiState == NBG && ( nbgType == BUILD || nbgType == HACK || nbgType == DEFUSE_BOMB || nbgType == PLANT_BOMB || nbgType == INVESTIGATE_CAMP || nbgType == GRAB_SUPPLIES || nbgType == REVIVE_TEAMMATE || nbgType == TK_REVIVE_TEAMMATE || nbgType == SUPPLY_TEAMMATE ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( ClientHasObj( botNum ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->isActor ) {
|
|
return false;
|
|
}
|
|
|
|
if ( botVehicleInfo != NULL ) { //mal: if we're in a vehicle, ignore this goal.
|
|
return false;
|
|
}
|
|
|
|
#ifdef STROGG_INSTANT_REVIVE
|
|
if ( aiState == NBG && ( nbgType == REVIVE_TEAMMATE || nbgType == TK_REVIVE_TEAMMATE || nbgType == SUPPLY_TEAMMATE ) ) { //mal: medics need a chance to finish their job!
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->classType == MEDIC && Bot_HasTeamWoundedInArea( true ) ) {
|
|
return false;
|
|
}
|
|
#else
|
|
if ( aiState == NBG && nbgType == REVIVE_TEAMMATE && botInfo->team == GDF ) { //mal: medics need a chance to finish their job! Strogg take too long to revive.
|
|
return false;
|
|
}
|
|
|
|
if ( botInfo->classType == MEDIC && botInfo->team == GDF && Bot_HasTeamWoundedInArea( true ) ) { //mal: strogg medics take too long to revive to make this worthwhile
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
if ( botInfo->classType == ENGINEER && nextObjChargeCheckTime < botWorld->gameLocalInfo.time && Bot_CheckChargeExistsOnObjInWorld() ) {
|
|
nextObjChargeCheckTime = botWorld->gameLocalInfo.time + 5000;
|
|
Bot_ResetState( false, true );
|
|
return true;
|
|
}
|
|
|
|
if ( aiState == LTG && ltgType == PROTECT_CHARGE ) { //mal: if we're guarding, only heal those close to our goal.
|
|
if ( botInfo->classType == MEDIC && Bot_HasTeamWoundedInArea( false, MEDIC_RANGE_BUSY ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ( aiState == LTG && ( ltgType == INVESTIGATE_ACTION || ltgType == PROTECT_CHARGE ) ) { //mal: already doing something about this, so keep doing it.
|
|
return true;
|
|
} //mal: this needs to be checked last.
|
|
|
|
if ( botInfo->team == botWorld->botGoalInfo.attackingTeam && ignorePlantedChargeTime < botWorld->gameLocalInfo.time ) { //mal: if we're on the attacking team, check our charge.
|
|
if ( Bot_LTGIsAvailable( -1, -1, PROTECT_CHARGE, MAX_NUM_DEFEND_CHARGE_CLIENTS ) ) {
|
|
for( int i = 0; i < MAX_CHARGES; i++ ) {
|
|
const plantedChargeInfo_t& charge = botWorld->chargeInfo[ i ];
|
|
|
|
if ( charge.entNum == 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( charge.team != botInfo->team ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !charge.isOnObjective ) {
|
|
continue;
|
|
}
|
|
|
|
if ( charge.areaNum == 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( charge.state != BOMB_ARMED ) {
|
|
continue;
|
|
}
|
|
|
|
idVec3 vec = charge.origin - botInfo->origin;
|
|
|
|
float awareOfChargeDist = 2500.0f;
|
|
|
|
if ( vec.LengthSqr() > Square( awareOfChargeDist ) ) {
|
|
continue;
|
|
}
|
|
|
|
int matesInArea = ClientsInArea( botNum, charge.origin, 300.0f, botInfo->team, NOCLASS, false, false, false, false, true );
|
|
|
|
if ( matesInArea > MAX_NUM_DEFEND_CHARGE_CLIENTS ) {
|
|
continue;
|
|
} //mal: already some ppl there, so lets do something else.
|
|
|
|
int enemyEngineersInArea = ClientsInArea( botNum, charge.origin, awareOfChargeDist, ( botInfo->team == GDF ) ? STROGG : GDF, ENGINEER, false, false, false, false, true );
|
|
|
|
if ( enemyEngineersInArea == 0 ) {
|
|
continue;
|
|
} //mal: noone there to defuse our charge, so why worry about it?
|
|
|
|
Bot_ResetState( true, true );
|
|
aiState = LTG;
|
|
ltgType = PROTECT_CHARGE;
|
|
ltgTarget = charge.entNum;
|
|
ltgTargetSpawnID = charge.spawnID;
|
|
ROOT_AI_NODE = &idBotAI::Run_LTG_Node;
|
|
LTG_AI_SUB_NODE = &idBotAI::Enter_LTG_ProtectCharge;
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
for( int i = 0; i < botThreadData.botActions.Num(); i++ ) {
|
|
if ( !botThreadData.botActions[ i ]->ActionIsActive() ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !botThreadData.botActions[ i ]->ActionIsValid() ) {
|
|
continue;
|
|
}
|
|
|
|
if ( botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) == ACTION_NULL ) {
|
|
continue;
|
|
}
|
|
|
|
if ( botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) != ACTION_DEFUSE && botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) != ACTION_PREVENT_BUILD &&
|
|
botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) != ACTION_PREVENT_HACK && botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) != ACTION_HE_CHARGE &&
|
|
botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) != ACTION_PREVENT_STEAL && botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) != ACTION_PREVENT_DELIVER ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !botThreadData.botActions[ i ]->ActionIsPriority() ) {
|
|
if ( botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) == ACTION_HE_CHARGE || botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) == ACTION_DEFUSE && botInfo->classType != ENGINEER ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( ( botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) == ACTION_HE_CHARGE || botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) == ACTION_DEFUSE ) && !botThreadData.botActions[ i ]->ArmedChargesInsideActionBBox( -1 ) ) {
|
|
continue;
|
|
}
|
|
|
|
int enemiesInArea = ClientsInArea( botNum, botThreadData.botActions[ i ]->GetActionOrigin(), BOT_INVESTIGATE_RANGE, ( botInfo->team == GDF ) ? STROGG : GDF, NOCLASS, false, false, false, false, false );
|
|
|
|
if ( botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) == ACTION_PREVENT_BUILD && ( botThreadData.botActions[ i ]->GetActionState() == ACTION_STATE_NORMAL && enemiesInArea == 0 ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) == ACTION_PREVENT_HACK && ( botThreadData.botActions[ i ]->GetActionState() == ACTION_STATE_NORMAL && enemiesInArea == 0 ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( ( botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) == ACTION_PREVENT_STEAL || botThreadData.botActions[ i ]->GetObjForTeam( botInfo->team ) == ACTION_PREVENT_DELIVER ) && enemiesInArea == 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( lastCheckActionTime > botWorld->gameLocalInfo.time ) { //mal: don't repeat ourselves, unless there is a critical enemy nearby
|
|
if ( botThreadData.GetBotSkill() != BOT_SKILL_EXPERT ) { //mal: only the smartest bots will do this.
|
|
continue;
|
|
}
|
|
|
|
int criticalEnemiesInArea = ClientsInArea( botNum, botThreadData.botActions[ i ]->GetActionOrigin(), CRITICAL_ENEMY_CLOSE_TO_GOAL_RANGE, ( botInfo->team == GDF ) ? STROGG : GDF, TeamCriticalClass( ( botInfo->team == GDF ) ? STROGG : GDF ), false, false, false, false, false, true );
|
|
|
|
if ( criticalEnemiesInArea == 0 ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
int matesInArea = ClientsInArea( botNum, botThreadData.botActions[ i ]->GetActionOrigin(), 300.0f, botInfo->team, NOCLASS, false, false, false, false, true );
|
|
|
|
if ( matesInArea > MIN_NUM_INVESTIGATE_CLIENTS ) {
|
|
continue;
|
|
} //mal: already some ppl there, so lets do something else.
|
|
|
|
idVec3 vec = botThreadData.botActions[ i ]->GetActionOrigin() - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() > Square( BOT_INVESTIGATE_RANGE ) ) { //mal: its too far away, we'll never make it in time!
|
|
continue;
|
|
}
|
|
|
|
Bot_ResetState( true, true );
|
|
actionNum = i;
|
|
ltgTime = botWorld->gameLocalInfo.time + 30000;
|
|
lastCheckActionTime = botWorld->gameLocalInfo.time + 20000; //mal: dont do this again for a while.
|
|
aiState = LTG;
|
|
ltgType = INVESTIGATE_ACTION;
|
|
ROOT_AI_NODE = &idBotAI::Run_LTG_Node;
|
|
LTG_AI_SUB_NODE = &idBotAI::Enter_LTG_InvestigateGoal;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::DisguisedClientIsActingOdd
|
|
|
|
Disguised clients only have access to the knife/gun of the disguised client they impersonate. Most clients won't ever run around with a knife in hand, so if a client
|
|
is walking around with a knife, acting goofy, a high skill bot may "spot" them and attack. Also, look around and see if the disguised client he impersonates is nearby.
|
|
================
|
|
*/
|
|
bool idBotAI::DisguisedClientIsActingOdd( int clientNum ) {
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill < BOT_SKILL_EXPERT ) {
|
|
return false;
|
|
}
|
|
|
|
if ( ignoreSpyTime > botWorld->gameLocalInfo.time ) {
|
|
return false;
|
|
}
|
|
|
|
if ( Bot_IsBusy() ) {
|
|
return false;
|
|
}
|
|
|
|
ignoreSpyTime = botWorld->gameLocalInfo.time + 1500;
|
|
|
|
const clientInfo_t& player = botWorld->clientInfo[ clientNum ];
|
|
|
|
int attackingClient;
|
|
|
|
if ( Bot_TeammateHasClientAsEnemy( clientNum, attackingClient ) ) { //mal: if bot teammate has covert as enemy - the covert becomes our enemy too.
|
|
return true;
|
|
}
|
|
|
|
idVec3 vec = player.origin - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() > Square( COVERT_SIGHT_DIST ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( player.isPanting && !botInfo->isPanting && botInfo->xySpeed < WALKING_SPEED ) {
|
|
return true;
|
|
} //mal: high skill bot will "hear" you making your teams "heavy panting" noise, and will hunt you down.
|
|
|
|
if ( !InFrontOfClient( botNum, player.origin ) ) {
|
|
return false;
|
|
}
|
|
|
|
float dist = vec.LengthSqr();
|
|
|
|
const clientInfo_t& mate = botWorld->clientInfo[ player.disguisedClient ];
|
|
|
|
vec = mate.origin - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() < Square( COVERT_SIGHT_DIST ) ) {
|
|
if ( InFrontOfClient( botNum, mate.origin ) ) {
|
|
testFireShot = true;
|
|
return true;
|
|
}
|
|
} //mal: dirty spy - I see you!!
|
|
|
|
if ( botInfo->xySpeed >= RUNNING_SPEED ) { //mal: when we're on the move, kinda hard to do this.
|
|
return false;
|
|
}
|
|
|
|
int randChance = 90;
|
|
|
|
if ( player.covertWarningTime + 5000 > botWorld->gameLocalInfo.time ) {
|
|
randChance = 70;
|
|
}
|
|
|
|
if ( player.weapInfo.weapon == KNIFE ) { //mal: kinda odd to see someone running around with a knife out. Hmmmm......
|
|
if ( botThreadData.random.RandomInt( 100 ) > randChance ) {
|
|
testFireShot = true;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::ClientIsDangerous
|
|
|
|
Target campers, and clients who are on a killing spree.
|
|
================
|
|
*/
|
|
bool idBotAI::ClientIsDangerous( int clientNum ) {
|
|
|
|
if ( !ClientIsValid( clientNum, -1 ) ) {
|
|
return false;
|
|
}
|
|
|
|
const clientInfo_t& player = botWorld->clientInfo[ clientNum ];
|
|
|
|
if ( player.isBot ) {
|
|
return false;
|
|
}
|
|
|
|
if ( player.killsSinceSpawn < KILLING_SPREE && !player.isCamper ) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::ClientIsMarkedForDeath
|
|
|
|
Checks to see if this client, or the vehicle hes in, has been marked for death.
|
|
================
|
|
*/
|
|
bool idBotAI::ClientIsMarkedForDeath( int clientNum, bool clearRequest ) {
|
|
if ( !ClientIsValid( clientNum, -1 ) ) {
|
|
return false;
|
|
}
|
|
|
|
bool isMarked = false;
|
|
|
|
for( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( i == botNum ) {
|
|
continue;
|
|
}
|
|
|
|
const clientInfo_t& player = botWorld->clientInfo[ i ];
|
|
|
|
if ( player.team != botInfo->team ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.isBot ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.killTargetNum == -1 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.killTargetUpdateTime + MAX_TARGET_TIME < botWorld->gameLocalInfo.time ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.killTargetNum < MAX_CLIENTS && player.killTargetNum != clientNum ) {
|
|
continue;
|
|
}
|
|
|
|
entityTypes_t entityType = FindEntityType( player.killTargetNum, player.killTargetSpawnID );
|
|
|
|
if ( entityType == ENTITY_NULL || entityType == ENTITY_DEPLOYABLE ) {
|
|
continue;
|
|
}
|
|
|
|
if ( entityType == ENTITY_VEHICLE && botWorld->clientInfo[ clientNum ].proxyInfo.entNum != player.killTargetNum ) {
|
|
continue;
|
|
}
|
|
|
|
if ( clearRequest ) {
|
|
botUcmd->ackKillForClient = i;
|
|
}
|
|
|
|
isMarked = true;
|
|
break;
|
|
}
|
|
|
|
return isMarked;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::DeployableIsMarkedForDeath
|
|
|
|
Checks to see if this deployable has been marked for death.
|
|
================
|
|
*/
|
|
bool idBotAI::DeployableIsMarkedForDeath( int entNum, bool clearRequest ) {
|
|
deployableInfo_t deployable;
|
|
|
|
if ( GetDeployableInfo( false, entNum, deployable ) ) {
|
|
return false;
|
|
}
|
|
|
|
bool isMarked = false;
|
|
|
|
for( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( i == botNum ) {
|
|
continue;
|
|
}
|
|
|
|
const clientInfo_t& player = botWorld->clientInfo[ i ];
|
|
|
|
if ( player.team != botInfo->team ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.isBot ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.killTargetNum == -1 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.killTargetUpdateTime + MAX_TARGET_TIME < botWorld->gameLocalInfo.time ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.killTargetNum < MAX_CLIENTS ) {
|
|
continue;
|
|
}
|
|
|
|
entityTypes_t entityType = FindEntityType( player.killTargetNum, player.killTargetSpawnID );
|
|
|
|
if ( entityType == ENTITY_NULL || entityType == ENTITY_VEHICLE || entityType == ENTITY_PLAYER ) {
|
|
continue;
|
|
}
|
|
|
|
if ( deployable.entNum != player.killTargetNum ) {
|
|
continue;
|
|
}
|
|
|
|
if ( clearRequest ) {
|
|
botUcmd->ackKillForClient = i;
|
|
}
|
|
|
|
isMarked = true;
|
|
break;
|
|
}
|
|
|
|
return isMarked;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::Flyer_FindEnemy
|
|
|
|
A find enemy that only works for the flyer hive.
|
|
================
|
|
*/
|
|
int idBotAI::Flyer_FindEnemy( float range) {
|
|
int enemyNum = -1;
|
|
float closest = idMath::INFINITY;
|
|
|
|
for ( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue; //mal: no valid client in this client slot!
|
|
}
|
|
|
|
if ( i == botNum ) {
|
|
continue; //mal: dont try to fight ourselves!
|
|
}
|
|
|
|
const clientInfo_t& playerInfo = botWorld->clientInfo[ i ];
|
|
|
|
if ( playerInfo.inLimbo ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.isDisguised ) {
|
|
continue;
|
|
}
|
|
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_DEMO && !playerInfo.isBot ) { //mal: dont harass humans in training mode.
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.isNoTarget ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.invulnerableEndTime > botWorld->gameLocalInfo.time ) {
|
|
continue; //mal: ignore revived/just spawned in clients - get the ppl around them!
|
|
}
|
|
|
|
if ( playerInfo.health <= 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( playerInfo.team == botInfo->team ) {
|
|
continue;
|
|
}
|
|
|
|
idVec3 vec = playerInfo.viewOrigin - botInfo->weapInfo.covertToolInfo.origin;
|
|
float distSqr = vec.LengthSqr();
|
|
|
|
if ( distSqr > Square( range ) ) {
|
|
continue;
|
|
}
|
|
|
|
bool clientHasLotsOfFriendsInArea = ( ClientsInArea( botNum, playerInfo.origin, 700.0f, GDF, NOCLASS, false, false, false, true, true ) > 0 ) ? true : false;
|
|
bool clientIsDangerous = ClientIsDangerous( i );
|
|
|
|
if ( clientHasLotsOfFriendsInArea ) { //mal: juicy target!
|
|
distSqr = 500.0f;
|
|
} else if ( Client_IsCriticalForCurrentObj( i, 3000.0f ) ) { //mal: juicier target!
|
|
distSqr = 400.0f;
|
|
} else if ( clientIsDangerous ) { //mal: juiciest target!
|
|
distSqr = 100.0f;
|
|
}
|
|
|
|
if ( distSqr < closest ) {
|
|
enemyNum = i;
|
|
closest = distSqr;
|
|
}
|
|
}
|
|
|
|
return enemyNum;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBotAI::Bot_CanAttackVehicles
|
|
============
|
|
*/
|
|
bool idBotAI::Bot_CanAttackVehicles() {
|
|
//mal_TODO: add a check for engs who have the grenade launcher.
|
|
|
|
if ( botVehicleInfo == NULL ) {
|
|
if ( ( botInfo->classType != SOLDIER || botInfo->weapInfo.primaryWeapon != ROCKET ) && ( botInfo->classType != FIELDOPS || !Bot_HasWorkingDeployable( false, ROCKET_ARTILLERY ) ) ) {
|
|
return false;
|
|
}
|
|
} else {
|
|
if ( Bot_IsInHeavyAttackVehicle() ) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBotAI::Bot_HasEnemySniperInArea
|
|
============
|
|
*/
|
|
bool idBotAI::Bot_HasEnemySniperInArea( float range ) {
|
|
if ( botWorld->gameLocalInfo.botSkill == BOT_SKILL_EASY ) {
|
|
return false;
|
|
}
|
|
|
|
bool hasSniper = false;
|
|
|
|
for( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue;
|
|
}
|
|
|
|
const clientInfo_t& player = botWorld->clientInfo[ i ];
|
|
|
|
if ( player.isBot ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.team == botInfo->team || player.health <= 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.weapInfo.primaryWeapon != SNIPERRIFLE || !player.weapInfo.primaryWeapHasAmmo ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !player.isCamper && player.killsSinceSpawn < KILLING_SPREE ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
continue;
|
|
}
|
|
|
|
idVec3 vec = player.origin - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() > Square( range ) ) {
|
|
continue;
|
|
}
|
|
|
|
idVec3 dangerOrg = player.viewOrigin;
|
|
dangerOrg += ( vec.LengthFast() * player.viewAxis[ 0 ] );
|
|
|
|
vec = dangerOrg - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() > Square( MAX_SNIPER_CROSSHAIR_DANGER_DIST ) ) {
|
|
continue;
|
|
}
|
|
|
|
hasSniper = true;
|
|
break;
|
|
}
|
|
|
|
return hasSniper;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBotAI::Bot_IsUnderAttackByAPT
|
|
============
|
|
*/
|
|
bool idBotAI::Bot_IsUnderAttackByAPT( idVec3& turretLocation ) {
|
|
bool isUnderAttack = false;
|
|
|
|
for( int i = 0; i < MAX_DEPLOYABLES; i++ ) {
|
|
const deployableInfo_t& deployable = botWorld->deployableInfo[ i ];
|
|
|
|
if ( deployable.entNum == 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( deployable.health <= 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( !deployable.inPlace ) {
|
|
continue;
|
|
}
|
|
|
|
if ( deployable.ownerClientNum == -1 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( deployable.type != APT ) {
|
|
continue;
|
|
}
|
|
|
|
if ( deployable.enemyEntNum != botNum ) {
|
|
continue;
|
|
}
|
|
|
|
turretLocation = deployable.origin;
|
|
turretLocation.z += DEPLOYABLE_PATH_ORIGIN_OFFSET;
|
|
isUnderAttack = true;
|
|
break;
|
|
}
|
|
|
|
return isUnderAttack;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBotAI::Bot_TeammateHasClientAsEnemy
|
|
============
|
|
*/
|
|
bool idBotAI::Bot_TeammateHasClientAsEnemy( int clientNum, int& attackingClient ) {
|
|
bool isTargeted = false;
|
|
attackingClient = -1;
|
|
|
|
|
|
for( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue;
|
|
}
|
|
|
|
if ( i == botNum ) {
|
|
continue;
|
|
}
|
|
|
|
const clientInfo_t& player = botWorld->clientInfo[ i ];
|
|
|
|
if ( player.isBot == false ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.team != botInfo->team ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.health <= 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( botThreadData.bots[ i ] == NULL ) {
|
|
continue;
|
|
}
|
|
|
|
if ( botThreadData.bots[ i ]->GetEnemyNum() != clientNum ) {
|
|
continue;
|
|
}
|
|
|
|
isTargeted = true;
|
|
attackingClient = i;
|
|
break;
|
|
}
|
|
|
|
return isTargeted;
|
|
}
|
|
|
|
/*
|
|
================
|
|
idBotAI::ClientHasAttackedActorsMate
|
|
|
|
================
|
|
*/
|
|
bool idBotAI::ClientHasAttackedActorsMate( int clientNum, int time ) {
|
|
if ( !ClientIsValid( botThreadData.actorMissionInfo.targetClientNum, -1 ) ) {
|
|
return false;
|
|
}
|
|
|
|
if ( !ClientIsValid( clientNum, -1 ) ) {
|
|
return false;
|
|
}
|
|
|
|
const clientInfo_t& playerInfo = botWorld->clientInfo[ clientNum ];
|
|
|
|
if ( playerInfo.lastAttackerTime + time > botWorld->gameLocalInfo.time && playerInfo.lastAttacker == botThreadData.actorMissionInfo.targetClientNum ) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBotAI::Bot_ShouldIgnoreEnemies
|
|
|
|
The latest versions of ETQW make it worthwhile to make suicide runs on objs. Update the bots to let them do so as well.
|
|
============
|
|
*/
|
|
bool idBotAI::Bot_ShouldIgnoreEnemies() {
|
|
if ( ClientHasObj( botNum ) ) {
|
|
if ( botWorld->botGoalInfo.deliverActionNumber > -1 && botWorld->botGoalInfo.deliverActionNumber < botThreadData.botActions.Num() ) {
|
|
idVec3 vec = botThreadData.botActions[ botWorld->botGoalInfo.deliverActionNumber ]->GetActionOrigin() - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() < Square( 1500.0f ) ) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( Client_IsCriticalForCurrentObj( botNum, 900.0f ) && botInfo->classType != SOLDIER ) {
|
|
return true;
|
|
}
|
|
|
|
switch ( botInfo->classType ) {
|
|
|
|
case MEDIC: {
|
|
if ( aiState == NBG && nbgType == REVIVE_TEAMMATE ) {
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ENGINEER: {
|
|
if ( aiState == NBG && ( nbgType == BUILD || nbgType == DEFUSE_BOMB || nbgType == FIXING_MCP ) ) {
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case COVERTOPS: {
|
|
if ( aiState == NBG && nbgType == HACK ) {
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case SOLDIER: {
|
|
if ( aiState == NBG && nbgType == PLANT_BOMB && !ClientHasChargeInWorld( botNum, true, ACTION_NULL ) ) {
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idBotAI::Bot_CheckIfEnemyHasUsInTheirSightsWhenInAirVehicle
|
|
============
|
|
*/
|
|
bool idBotAI::Bot_CheckIfEnemyHasUsInTheirSightsWhenInAirVehicle() {
|
|
if ( botWorld->gameLocalInfo.botSkill != BOT_SKILL_EXPERT ) {
|
|
return false;
|
|
}
|
|
|
|
bool hasEnemy = false;
|
|
|
|
for( int i = 0; i < MAX_CLIENTS; i++ ) {
|
|
if ( !ClientIsValid( i, -1 ) ) {
|
|
continue;
|
|
}
|
|
|
|
const clientInfo_t& player = botWorld->clientInfo[ i ];
|
|
|
|
if ( player.team == botInfo->team || player.health <= 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( player.proxyInfo.entNum != CLIENT_HAS_NO_VEHICLE ) {
|
|
proxyInfo_t enemyVehicle;
|
|
GetVehicleInfo( player.proxyInfo.entNum, enemyVehicle );
|
|
|
|
if ( enemyVehicle.entNum == 0 ) {
|
|
continue;
|
|
}
|
|
|
|
if ( enemyVehicle.type != TITAN && enemyVehicle.type != DESECRATOR && enemyVehicle.type != GOLIATH && enemyVehicle.type != TROJAN ) {
|
|
continue;
|
|
}
|
|
|
|
if ( enemyVehicle.type == TROJAN && enemyVehicle.driverEntNum == i ) { //mal: dont worry about trojan driver
|
|
continue;
|
|
}
|
|
|
|
if ( ( enemyVehicle.type == TITAN || enemyVehicle.type == DESECRATOR ) && enemyVehicle.driverEntNum != i ) { //mal: dont worry about tank gunners
|
|
continue;
|
|
}
|
|
|
|
idVec3 vec = player.origin - botInfo->origin;
|
|
idVec3 dangerOrg = player.viewOrigin;
|
|
dangerOrg += ( vec.LengthFast() * player.viewAxis[ 0 ] );
|
|
|
|
vec = dangerOrg - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() > Square( 500.0f ) ) {
|
|
continue;
|
|
}
|
|
} else {
|
|
if ( player.weapInfo.weapon != ROCKET && player.weapInfo.weapon != HEAVY_MG ) {
|
|
continue;
|
|
}
|
|
|
|
idVec3 vec = player.origin - botInfo->origin;
|
|
float distToEnemy = vec.LengthFast();
|
|
|
|
#ifdef _XENON
|
|
float avoidDist = ( player.weapInfo.weapon == ROCKET ) ? FLYER_WORRY_ABOUT_ROCKETS_MAX_DIST : 3500.0f; //mal: make it a bit easier on the Xbox to take out flyers.
|
|
#else
|
|
float avoidDist = 3500.0f;
|
|
#endif
|
|
|
|
if ( distToEnemy > avoidDist ) {
|
|
continue;
|
|
}
|
|
|
|
idVec3 dangerOrg = player.viewOrigin;
|
|
dangerOrg += ( distToEnemy * player.viewAxis[ 0 ] );
|
|
|
|
vec = dangerOrg - botInfo->origin;
|
|
|
|
if ( vec.LengthSqr() > Square( 300.0f ) ) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
hasEnemy = true;
|
|
break;
|
|
}
|
|
|
|
return hasEnemy;
|
|
} |