You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1649 lines
48 KiB
1649 lines
48 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
// tf_bot_behavior.cpp |
|
// Team Fortress NextBot |
|
// Michael Booth, February 2009 |
|
|
|
#include "cbase.h" |
|
#include "fmtstr.h" |
|
|
|
#include "nav_mesh.h" |
|
#include "tf_player.h" |
|
#include "tf_gamerules.h" |
|
#include "tf_projectile_rocket.h" |
|
#include "tf_weaponbase_grenadeproj.h" |
|
#include "tf_obj.h" |
|
#include "tf_obj_sentrygun.h" |
|
#include "tf_weapon_flamethrower.h" |
|
#include "tf_weapon_sniperrifle.h" |
|
#include "tf_weapon_compound_bow.h" |
|
#include "bot/tf_bot.h" |
|
#include "bot/tf_bot_manager.h" |
|
#include "bot/behavior/tf_bot_behavior.h" |
|
#include "bot/behavior/tf_bot_dead.h" |
|
#include "NextBot/NavMeshEntities/func_nav_prerequisite.h" |
|
#include "bot/behavior/nav_entities/tf_bot_nav_ent_destroy_entity.h" |
|
#include "bot/behavior/nav_entities/tf_bot_nav_ent_move_to.h" |
|
#include "bot/behavior/nav_entities/tf_bot_nav_ent_wait.h" |
|
#include "bot/behavior/tf_bot_tactical_monitor.h" |
|
#include "bot/behavior/tf_bot_taunt.h" |
|
#include "bot/behavior/scenario/creep_wave/tf_bot_creep_wave.h" |
|
#include "player_vs_environment/tf_population_manager.h" |
|
|
|
|
|
extern ConVar tf_bot_health_ok_ratio; |
|
|
|
ConVar tf_bot_path_lookahead_range( "tf_bot_path_lookahead_range", "300" ); |
|
ConVar tf_bot_sniper_aim_error( "tf_bot_sniper_aim_error", "0.01", FCVAR_CHEAT ); |
|
ConVar tf_bot_sniper_aim_steady_rate( "tf_bot_sniper_aim_steady_rate", "10", FCVAR_CHEAT ); |
|
ConVar tf_bot_debug_sniper( "tf_bot_debug_sniper", "0", FCVAR_CHEAT ); |
|
ConVar tf_bot_fire_weapon_min_time( "tf_bot_fire_weapon_min_time", "1", FCVAR_CHEAT ); |
|
ConVar tf_bot_taunt_victim_chance( "tf_bot_taunt_victim_chance", "20" ); // community requested this not be a cheat cvar |
|
|
|
ConVar tf_bot_notice_backstab_chance( "tf_bot_notice_backstab_chance", "25", FCVAR_CHEAT ); |
|
ConVar tf_bot_notice_backstab_min_range( "tf_bot_notice_backstab_min_range", "100", FCVAR_CHEAT ); |
|
ConVar tf_bot_notice_backstab_max_range( "tf_bot_notice_backstab_max_range", "750", FCVAR_CHEAT ); |
|
|
|
ConVar tf_bot_arrow_elevation_rate( "tf_bot_arrow_elevation_rate", "0.0001", FCVAR_CHEAT, "When firing arrows at far away targets, this is the degree/range slope to raise our aim" ); |
|
ConVar tf_bot_ballistic_elevation_rate( "tf_bot_ballistic_elevation_rate", "0.01", FCVAR_CHEAT, "When lobbing grenades at far away targets, this is the degree/range slope to raise our aim" ); |
|
|
|
ConVar tf_bot_hitscan_range_limit( "tf_bot_hitscan_range_limit", "1800", FCVAR_CHEAT ); |
|
|
|
ConVar tf_bot_always_full_reload( "tf_bot_always_full_reload", "0", FCVAR_CHEAT ); |
|
|
|
ConVar tf_bot_fire_weapon_allowed( "tf_bot_fire_weapon_allowed", "1", FCVAR_CHEAT, "If zero, TFBots will not pull the trigger of their weapons (but will act like they did)" ); |
|
|
|
#ifdef STAGING_ONLY |
|
ConVar tf_bot_use_items( "tf_bot_use_items", "0", FCVAR_CHEAT, "0-100: Chance bot will use random item." ); |
|
#endif |
|
|
|
//--------------------------------------------------------------------------------------------- |
|
Action< CTFBot > *CTFBotMainAction::InitialContainedAction( CTFBot *me ) |
|
{ |
|
return new CTFBotTacticalMonitor; |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
ActionResult< CTFBot > CTFBotMainAction::OnStart( CTFBot *me, Action< CTFBot > *priorAction ) |
|
{ |
|
m_lastTouch = NULL; |
|
m_lastTouchTime = 0.0f; |
|
m_aimErrorRadius = 0.0f; |
|
m_aimErrorAngle = 0.0f; |
|
m_nextDisguise = TF_CLASS_UNDEFINED; |
|
|
|
m_yawRate = 0.0f; |
|
m_priorYaw = 0.0f; |
|
|
|
m_isWaitingForFullReload = false; |
|
|
|
// if bot is already dead at this point, make sure it's dead |
|
// check for !IsAlive because bot could be DYING |
|
if ( !me->IsAlive() ) |
|
{ |
|
return ChangeTo( new CTFBotDead, "I'm actually dead" ); |
|
} |
|
|
|
#ifdef TF_CREEP_MODE |
|
if ( TFGameRules()->IsCreepWaveMode() ) |
|
{ |
|
return ChangeTo( new CTFBotCreepWave, "I'm a creep" ); |
|
} |
|
#endif // TF_CREEP_MODE |
|
|
|
|
|
#ifdef STAGING_ONLY |
|
if ( tf_bot_use_items.GetInt() && ( RandomInt(0, 100) <= tf_bot_use_items.GetInt() ) ) |
|
{ |
|
me->GiveRandomItem( LOADOUT_POSITION_PRIMARY ); |
|
me->GiveRandomItem( LOADOUT_POSITION_SECONDARY ); |
|
me->GiveRandomItem( LOADOUT_POSITION_MELEE ); |
|
|
|
me->GiveRandomItem( LOADOUT_POSITION_HEAD ); |
|
me->GiveRandomItem( LOADOUT_POSITION_MISC ); |
|
me->GiveRandomItem( LOADOUT_POSITION_MISC2 ); |
|
} |
|
#endif // STAGING_ONLY |
|
|
|
return Continue(); |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
ActionResult< CTFBot > CTFBotMainAction::Update( CTFBot *me, float interval ) |
|
{ |
|
VPROF_BUDGET( "CTFBotMainAction::Update", "NextBot" ); |
|
|
|
if ( me->GetTeamNumber() != TF_TEAM_BLUE && me->GetTeamNumber() != TF_TEAM_RED ) |
|
{ |
|
// not on a team - do nothing |
|
return Done( "Not on a playing team" ); |
|
} |
|
|
|
// Should I accept taunt from my partner? |
|
if ( me->FindPartnerTauntInitiator() ) |
|
{ |
|
return SuspendFor( new CTFBotTaunt, "Responding to teammate partner taunt" ); |
|
} |
|
|
|
// make sure our vision FOV matches the player's |
|
me->GetVisionInterface()->SetFieldOfView( me->GetFOV() ); |
|
|
|
// teammates in training have infinite ammo |
|
if ( TFGameRules()->IsInTraining() && me->GetTeamNumber() == TF_TEAM_BLUE ) |
|
{ |
|
me->GiveAmmo( 1000, TF_AMMO_METAL, true ); |
|
} |
|
|
|
// track aim velocity ourselves, since body aim "steady" is too loose |
|
float deltaYaw = me->EyeAngles().y - m_priorYaw; |
|
m_yawRate = fabs( deltaYaw / ( interval + 0.0001f ) ); |
|
m_priorYaw = me->EyeAngles().y; |
|
|
|
if ( m_yawRate < tf_bot_sniper_aim_steady_rate.GetFloat() ) |
|
{ |
|
if ( !m_steadyTimer.HasStarted() ) |
|
m_steadyTimer.Start(); |
|
|
|
// if ( tf_bot_debug_sniper.GetBool() ) |
|
// { |
|
// DevMsg( "%3.2f: STEADY\n", gpGlobals->curtime ); |
|
// } |
|
} |
|
else |
|
{ |
|
m_steadyTimer.Invalidate(); |
|
|
|
// if ( tf_bot_debug_sniper.GetBool() ) |
|
// { |
|
// DevMsg( "%3.2f: Yaw rate = %3.2f\n", gpGlobals->curtime, m_yawRate ); |
|
// } |
|
} |
|
|
|
if ( TFGameRules()->IsMannVsMachineMode() && me->GetTeamNumber() == TF_TEAM_PVE_INVADERS ) |
|
{ |
|
// infinite ammo |
|
// me->GiveAmmo( 100, TF_AMMO_PRIMARY, true ); |
|
// me->GiveAmmo( 100, TF_AMMO_SECONDARY, true ); |
|
// This resets the Sandman |
|
//me->GiveAmmo( 100, TF_AMMO_GRENADES1, true ); |
|
// This resets the Bonk drink meter... |
|
//me->GiveAmmo( 100, TF_AMMO_GRENADES2, true ); |
|
me->GiveAmmo( 100, TF_AMMO_METAL, true ); |
|
|
|
me->m_Shared.AddToSpyCloakMeter( 100.0f ); |
|
|
|
CTFNavArea *myArea = me->GetLastKnownArea(); |
|
int spawnRoomFlag = me->GetTeamNumber() == TF_TEAM_RED ? TF_NAV_SPAWN_ROOM_RED : TF_NAV_SPAWN_ROOM_BLUE; |
|
|
|
if ( myArea && myArea->HasAttributeTF( spawnRoomFlag ) ) |
|
{ |
|
// invading bots get uber while they leave their spawn so they don't drop their cash where players can't pick it up |
|
me->m_Shared.AddCond( TF_COND_INVULNERABLE, 0.5f ); |
|
me->m_Shared.AddCond( TF_COND_INVULNERABLE_HIDE_UNLESS_DAMAGED, 0.5f ); |
|
me->m_Shared.AddCond( TF_COND_INVULNERABLE_WEARINGOFF, 0.5f ); |
|
} |
|
|
|
// watch for bots that have fallen through the ground |
|
if ( myArea && myArea->GetZ( me->GetAbsOrigin() ) - me->GetAbsOrigin().z > 100.0f ) |
|
{ |
|
if ( !m_undergroundTimer.HasStarted() ) |
|
{ |
|
m_undergroundTimer.Start(); |
|
} |
|
else if ( m_undergroundTimer.IsGreaterThen( 3.0f ) ) |
|
{ |
|
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" underground (position \"%3.2f %3.2f %3.2f\")\n", |
|
me->GetPlayerName(), |
|
me->GetUserID(), |
|
me->GetNetworkIDString(), |
|
me->GetTeam()->GetName(), |
|
me->GetAbsOrigin().x, me->GetAbsOrigin().y, me->GetAbsOrigin().z ); |
|
|
|
// teleport bot to a reasonable place |
|
me->SetAbsOrigin( myArea->GetCenter() ); |
|
} |
|
} |
|
else |
|
{ |
|
m_undergroundTimer.Invalidate(); |
|
} |
|
|
|
if ( me->ShouldAutoJump() ) |
|
{ |
|
me->GetLocomotionInterface()->Jump(); |
|
} |
|
} |
|
|
|
// spies always want to be disguised |
|
if ( !me->IsFiringWeapon() && !me->m_Shared.InCond( TF_COND_DISGUISED ) && !me->m_Shared.InCond( TF_COND_DISGUISING ) ) |
|
{ |
|
if ( me->CanDisguise() ) |
|
{ |
|
if ( m_nextDisguise == TF_CLASS_UNDEFINED ) |
|
{ |
|
if ( me->IsDifficulty( CTFBot::EASY ) || me->IsDifficulty( CTFBot::NORMAL ) ) |
|
{ |
|
// disguise as a random class |
|
me->m_Shared.Disguise( GetEnemyTeam( me->GetTeamNumber() ), RandomInt( TF_FIRST_NORMAL_CLASS, TF_LAST_NORMAL_CLASS-1 ) ); |
|
} |
|
else |
|
{ |
|
me->DisguiseAsMemberOfEnemyTeam(); |
|
} |
|
} |
|
else |
|
{ |
|
// disguise as the class we just killed |
|
me->m_Shared.Disguise( GetEnemyTeam( me->GetTeamNumber() ), m_nextDisguise ); |
|
m_nextDisguise = TF_CLASS_UNDEFINED; |
|
} |
|
} |
|
} |
|
|
|
me->EquipRequiredWeapon(); |
|
|
|
me->UpdateLookingAroundForEnemies(); |
|
FireWeaponAtEnemy( me ); |
|
Dodge( me ); |
|
|
|
if ( me->IsPlayerClass( TF_CLASS_DEMOMAN ) ) |
|
{ |
|
// dont auto reload, so we fire stickies fast |
|
me->SetAutoReload( false ); |
|
} |
|
else |
|
{ |
|
// reload weapons |
|
me->SetAutoReload( true ); |
|
} |
|
|
|
return Continue(); |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
EventDesiredResult<CTFBot> CTFBotMainAction::OnKilled( CTFBot *me, const CTakeDamageInfo& info ) |
|
{ |
|
return TryChangeTo( new CTFBotDead, RESULT_CRITICAL, "I died!" ); |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
EventDesiredResult< CTFBot > CTFBotMainAction::OnInjured( CTFBot *me, const CTakeDamageInfo &info ) |
|
{ |
|
CBaseObject *obj = dynamic_cast< CBaseObject * >( info.GetInflictor() ); |
|
|
|
// if an object hurt me, it must be a sentry |
|
CBaseEntity *subject = obj ? obj : info.GetAttacker(); |
|
|
|
// notice the gunfire - needed for sentry guns, which don't go through the player OnWeaponFired() system |
|
me->GetVisionInterface()->AddKnownEntity( subject ); |
|
|
|
if ( info.GetInflictor() && info.GetInflictor()->GetTeamNumber() != me->GetTeamNumber() ) |
|
{ |
|
CObjectSentrygun *sentrygun = dynamic_cast< CObjectSentrygun * >( info.GetInflictor() ); |
|
|
|
if ( sentrygun ) |
|
{ |
|
// we were injured by an enemy sentry - remember it |
|
me->RememberEnemySentry( sentrygun, me->GetAbsOrigin() ); |
|
} |
|
|
|
if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB ) |
|
{ |
|
// backstabs that don't kill me make me mad |
|
me->DelayedThreatNotice( info.GetInflictor(), 0.5f ); |
|
|
|
// chance of nearby friends noticing the backstab |
|
CUtlVector< CTFPlayer * > playerVector; |
|
CollectPlayers( &playerVector, me->GetTeamNumber(), COLLECT_ONLY_LIVING_PLAYERS ); |
|
|
|
float minRange = tf_bot_notice_backstab_min_range.GetFloat(); |
|
float maxRange = tf_bot_notice_backstab_max_range.GetFloat(); |
|
float deltaRange = maxRange - minRange; |
|
|
|
for( int i=0; i<playerVector.Count(); ++i ) |
|
{ |
|
CTFBot *bot = ToTFBot( playerVector[i] ); |
|
if ( bot ) |
|
{ |
|
if ( !me->IsSelf( bot ) ) |
|
{ |
|
float range = me->GetRangeTo( bot ); |
|
|
|
if ( range > maxRange ) |
|
{ |
|
// too far away to notice |
|
continue; |
|
} |
|
|
|
int noticeChance = tf_bot_notice_backstab_chance.GetInt(); |
|
|
|
if ( range > minRange ) |
|
{ |
|
// scale notice chance down to zero at max range |
|
noticeChance *= ( range - minRange ) / deltaRange; |
|
} |
|
|
|
if ( RandomInt( 0, 100 ) < noticeChance ) |
|
{ |
|
bot->DelayedThreatNotice( info.GetInflictor(), 0.5f ); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
else if ( info.GetAttacker() && ( info.GetDamageType() & DMG_CRITICAL ) && ( info.GetDamageType() & DMG_BURN ) ) |
|
{ |
|
// Notice anyone nearby hitting us with crit fire (i.e. Backburner) |
|
if ( me->GetRangeTo( info.GetAttacker() ) < tf_bot_notice_backstab_max_range.GetFloat() ) |
|
{ |
|
me->DelayedThreatNotice( info.GetAttacker(), 0.5f ); |
|
} |
|
} |
|
} |
|
|
|
|
|
#ifdef UNNEEDED // known entity/listening to gunfire handles this without insta-turn |
|
|
|
if ( false && !me->IsSelf( info.GetAttacker() ) ) |
|
{ |
|
// hack to stop engineers from looking away from healing their sentry |
|
if ( !me->IsPlayerClass( TF_CLASS_ENGINEER ) && !me->IsPlayerClass( TF_CLASS_MEDIC ) ) |
|
{ |
|
CBaseObject *obj = dynamic_cast< CBaseObject * >( info.GetInflictor() ); |
|
|
|
// if an object hurt me, it must be a sentry |
|
CBaseEntity *subject = obj ? obj : info.GetAttacker(); |
|
|
|
if ( !me->GetVisionInterface()->IsInFieldOfView( subject ) ) |
|
{ |
|
// something out of my field of view hurt me - look around for it |
|
// turn right or left, since player's damage indicators tell them which way |
|
Vector forward, right; |
|
me->EyeVectors( &forward, &right ); |
|
|
|
Vector toAttacker = subject->EyePosition() - me->EyePosition(); |
|
Vector newForward; |
|
float error = 1.0f; RandomFloat( -1.0f, 1.0f ); |
|
|
|
if ( DotProduct( right, toAttacker ) > 0.0f ) |
|
{ |
|
newForward = error * forward + right; |
|
} |
|
else |
|
{ |
|
newForward = error * forward - right; |
|
} |
|
|
|
me->GetBodyInterface()->AimHeadTowards( me->EyePosition() + 100.0f * newForward, IBody::IMPORTANT, RandomFloat( 0.5f, 1.0f ), NULL, "Something hurt me!" ); |
|
} |
|
} |
|
} |
|
#endif // _DEBUG |
|
|
|
return TryContinue(); |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
EventDesiredResult< CTFBot > CTFBotMainAction::OnContact( CTFBot *me, CBaseEntity *other, CGameTrace *result ) |
|
{ |
|
if ( other && !other->IsSolidFlagSet( FSOLID_NOT_SOLID ) && !other->IsWorld() && !other->IsPlayer() ) |
|
{ |
|
m_lastTouch = other; |
|
m_lastTouchTime = gpGlobals->curtime; |
|
|
|
// Mini-bosses destroy non-Sentrygun objects they bump into (ie: Dispensers) |
|
if ( TFGameRules()->IsMannVsMachineMode() && me->IsMiniBoss() ) |
|
{ |
|
if ( other->IsBaseObject() ) |
|
{ |
|
CBaseObject *pObject = assert_cast< CBaseObject* >( other ); |
|
if ( pObject->GetType() != OBJ_SENTRYGUN || pObject->IsMiniBuilding() ) |
|
{ |
|
int damage = MAX( other->GetMaxHealth(), other->GetHealth() ); |
|
|
|
Vector toVictim = other->WorldSpaceCenter() - me->WorldSpaceCenter(); |
|
|
|
CTakeDamageInfo info( me, me, 4 * damage, DMG_BLAST, TF_DMG_CUSTOM_NONE ); |
|
CalculateMeleeDamageForce( &info, toVictim, me->WorldSpaceCenter(), 1.0f ); |
|
other->TakeDamage( info ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
return TryContinue(); |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
class BlockOverlappingAreaScan |
|
{ |
|
public: |
|
BlockOverlappingAreaScan( int teamID, CBaseEntity *blocker ) |
|
{ |
|
m_teamID = teamID; |
|
m_blocker = blocker; |
|
} |
|
|
|
bool operator() ( CNavArea *baseArea ) |
|
{ |
|
CTFNavArea *area = static_cast< CTFNavArea * >( baseArea ); |
|
|
|
area->SetAttributeTF( TF_NAV_BLOCKED_UNTIL_POINT_CAPTURE ); |
|
|
|
return true; |
|
} |
|
|
|
int m_teamID; |
|
CBaseEntity *m_blocker; |
|
}; |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
EventDesiredResult< CTFBot > CTFBotMainAction::OnStuck( CTFBot *me ) |
|
{ |
|
/* |
|
// if we are touching a func_door while stuck, assume the door is locked and block |
|
// the nav areas underneath it until the next stage of the scenario |
|
if ( m_lastTouch != NULL && gpGlobals->curtime - m_lastTouchTime < 2.0f ) |
|
{ |
|
if ( FClassnameIs( m_lastTouch, "func_door*" ) || FClassnameIs( m_lastTouch, "prop_door*" ) || FClassnameIs( m_lastTouch, "func_brush" ) ) |
|
{ |
|
Extent extent; |
|
extent.Init( m_lastTouch ); |
|
|
|
BlockOverlappingAreaScan block( me->GetTeamNumber(), m_lastTouch ); |
|
TheNavMesh->ForAllAreasOverlappingExtent( block, extent ); |
|
} |
|
} |
|
*/ |
|
|
|
if ( TFGameRules()->IsMannVsMachineMode() ) |
|
{ |
|
if ( me->m_Shared.InCond( TF_COND_MVM_BOT_STUN_RADIOWAVE ) ) |
|
{ |
|
// bot is stunned, not stuck |
|
return TryContinue(); |
|
} |
|
|
|
if ( m_lastTouch != NULL && gpGlobals->curtime - m_lastTouchTime < 2.0f ) |
|
{ |
|
if ( m_lastTouch->IsBaseObject() && dynamic_cast< CObjectSentrygun * >( m_lastTouch.Get() ) == NULL ) |
|
{ |
|
// we are stuck on a teleporter or dispenser - destroy it! |
|
int damage = MAX( m_lastTouch->GetMaxHealth(), m_lastTouch->GetHealth() ); |
|
|
|
Vector toVictim = m_lastTouch->WorldSpaceCenter() - me->WorldSpaceCenter(); |
|
|
|
CTakeDamageInfo info( me, me, 4 * damage, DMG_BLAST, TF_DMG_CUSTOM_NONE ); |
|
CalculateMeleeDamageForce( &info, toVictim, me->WorldSpaceCenter(), 1.0f ); |
|
m_lastTouch->TakeDamage( info ); |
|
} |
|
} |
|
} |
|
|
|
UTIL_LogPrintf( "\"%s<%i><%s><%s>\" stuck (position \"%3.2f %3.2f %3.2f\") (duration \"%3.2f\") ", |
|
me->GetPlayerName(), |
|
me->GetUserID(), |
|
me->GetNetworkIDString(), |
|
me->GetTeam()->GetName(), |
|
me->GetAbsOrigin().x, me->GetAbsOrigin().y, me->GetAbsOrigin().z, |
|
me->GetLocomotionInterface()->GetStuckDuration() ); |
|
|
|
const PathFollower *path = me->GetCurrentPath(); |
|
if ( path && path->GetCurrentGoal() ) |
|
{ |
|
UTIL_LogPrintf( " path_goal ( \"%3.2f %3.2f %3.2f\" )\n", |
|
path->GetCurrentGoal()->pos.x, |
|
path->GetCurrentGoal()->pos.y, |
|
path->GetCurrentGoal()->pos.z ); |
|
} |
|
else |
|
{ |
|
UTIL_LogPrintf( " path_goal ( \"NULL\" )\n" ); |
|
} |
|
|
|
me->GetLocomotionInterface()->Jump(); |
|
|
|
if ( RandomInt( 0, 100 ) < 50 ) |
|
{ |
|
me->PressLeftButton(); |
|
} |
|
else |
|
{ |
|
me->PressRightButton(); |
|
} |
|
|
|
/* |
|
if ( me->GetLocomotionInterface()->GetStuckDuration() > 3.0f ) |
|
{ |
|
// stuck for too long, do something drastic |
|
// warp to the our next path goal |
|
if ( me->GetCurrentPath() && me->GetCurrentPath()->GetCurrentGoal() ) |
|
{ |
|
me->SetAbsOrigin( me->GetCurrentPath()->GetCurrentGoal()->pos + Vector( 0, 0, StepHeight ) ); |
|
|
|
UTIL_LogPrintf( "%3.2f: TFBot '%s' stuck for too long - slammed to goal position. Entindex = %d.\n", gpGlobals->curtime, me->GetPlayerName(), me->entindex() ); |
|
} |
|
} |
|
*/ |
|
|
|
return TryContinue(); |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
EventDesiredResult< CTFBot > CTFBotMainAction::OnOtherKilled( CTFBot *me, CBaseCombatCharacter *victim, const CTakeDamageInfo &info ) |
|
{ |
|
// make sure we forget about this guy |
|
me->GetVisionInterface()->ForgetEntity( victim ); |
|
|
|
bool do_taunt = victim && victim->IsPlayer(); |
|
|
|
#ifdef STAGING_ONLY |
|
if ( !do_taunt ) |
|
{ |
|
// If bots are using items, go ahead and let bots taunt other bots. |
|
do_taunt = victim && tf_bot_use_items.GetBool(); |
|
} |
|
#endif |
|
|
|
if ( do_taunt ) |
|
{ |
|
CTFPlayer *playerVictim = ToTFPlayer( victim ); |
|
|
|
me->ForgetSpy( playerVictim ); |
|
|
|
if ( me->IsSelf( info.GetAttacker() ) && me->IsPlayerClass( TF_CLASS_SPY ) ) |
|
{ |
|
// disguise as our victim |
|
m_nextDisguise = playerVictim->GetPlayerClass()->GetClassIndex(); |
|
} |
|
|
|
if ( !ToTFPlayer( victim )->IsBot() && me->IsEnemy( victim ) && me->IsSelf( info.GetAttacker() ) ) |
|
{ |
|
bool isTaunting = !me->HasTheFlag() && RandomFloat( 0.0f, 100.0f ) <= tf_bot_taunt_victim_chance.GetFloat(); |
|
|
|
if ( TFGameRules()->IsMannVsMachineMode() && me->IsMiniBoss() ) |
|
{ |
|
// Bosses don't taunt puny humans |
|
isTaunting = false; |
|
} |
|
|
|
if ( isTaunting ) |
|
{ |
|
// we just killed a human - taunt! |
|
return TrySuspendFor( new CTFBotTaunt, RESULT_IMPORTANT, "Taunting our victim" ); |
|
} |
|
} |
|
} |
|
|
|
// if we saw a friend killed by a sentry, kill the sentry |
|
if ( victim && victim->IsPlayer() && me->IsFriend( victim ) && info.GetInflictor() && me->IsEnemy( info.GetInflictor() ) && me->IsLineOfSightClear( victim->WorldSpaceCenter() ) ) |
|
{ |
|
CObjectSentrygun *sentry = dynamic_cast< CObjectSentrygun * >( info.GetInflictor() ); |
|
|
|
if ( sentry && !me->GetEnemySentry() ) |
|
{ |
|
me->RememberEnemySentry( sentry, victim->GetAbsOrigin() ); |
|
} |
|
} |
|
|
|
return TryContinue(); |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
/** |
|
* Given a subject, return the world space position we should aim at |
|
*/ |
|
Vector CTFBotMainAction::SelectTargetPoint( const INextBot *meBot, const CBaseCombatCharacter *subject ) const |
|
{ |
|
CTFBot *me = (CTFBot *)meBot->GetEntity(); |
|
|
|
if ( subject ) |
|
{ |
|
// if our subject is a sentry gun, aim at it's "eye position", which is updated based on the sentry's level |
|
if ( subject->IsBaseObject() ) |
|
{ |
|
CObjectSentrygun *sentry = dynamic_cast< CObjectSentrygun * >( const_cast< CBaseCombatCharacter * >( subject ) ); |
|
if ( sentry ) |
|
{ |
|
// Aim a bit lower than eye height to ensure we hit the body of the sentry |
|
return sentry->GetAbsOrigin() + 0.5f * sentry->GetViewOffset(); |
|
} |
|
} |
|
|
|
CTFWeaponBase *myWeapon = me->m_Shared.GetActiveTFWeapon(); |
|
if ( myWeapon ) |
|
{ |
|
// lead our target and aim for the feet with the rocket launcher |
|
if ( !me->IsDifficulty( CTFBot::EASY ) ) |
|
{ |
|
if ( myWeapon->GetWeaponID() == TF_WEAPON_ROCKETLAUNCHER ) |
|
{ |
|
// if they are above us, don't aim for the feet |
|
const float aboveTolerance = 30.0f; |
|
if ( subject->GetAbsOrigin().z - aboveTolerance > me->GetAbsOrigin().z ) |
|
{ |
|
if ( me->GetVisionInterface()->IsAbleToSee( subject->GetAbsOrigin(), IVision::DISREGARD_FOV ) ) |
|
return subject->GetAbsOrigin(); |
|
|
|
if ( me->GetVisionInterface()->IsAbleToSee( subject->WorldSpaceCenter(), IVision::DISREGARD_FOV ) ) |
|
return subject->WorldSpaceCenter(); |
|
|
|
return subject->EyePosition(); |
|
} |
|
|
|
// aim at the ground under the subject |
|
if ( subject->GetGroundEntity() == NULL ) |
|
{ |
|
// they are airborne, find the ground underneath them, if they aren't too high |
|
trace_t result; |
|
UTIL_TraceLine( subject->GetAbsOrigin(), subject->GetAbsOrigin() + Vector( 0, 0, -200 ), MASK_SOLID, subject, COLLISION_GROUP_NONE, &result ); |
|
if ( result.DidHit() ) |
|
{ |
|
return result.endpos; |
|
} |
|
} |
|
|
|
// aim at their feet |
|
|
|
// lead our target |
|
const float missileSpeed = 1100.0f; |
|
float rangeBetween = me->GetRangeTo( subject->GetAbsOrigin() ); |
|
|
|
const float veryCloseRange = 150.0f; |
|
if ( rangeBetween > veryCloseRange ) |
|
{ |
|
float timeToTravel = rangeBetween / missileSpeed; |
|
|
|
Vector targetPos = subject->GetAbsOrigin() + timeToTravel * subject->GetAbsVelocity(); |
|
|
|
if ( me->GetVisionInterface()->IsAbleToSee( targetPos, IVision::DISREGARD_FOV ) ) |
|
return targetPos; |
|
|
|
// try their head and hope |
|
return subject->EyePosition() + timeToTravel * subject->GetAbsVelocity(); |
|
} |
|
|
|
return subject->EyePosition(); |
|
} |
|
else if ( myWeapon->GetWeaponID() == TF_WEAPON_COMPOUND_BOW ) |
|
{ |
|
// lead our target |
|
const float missileSpeed = ( (CTFCompoundBow *)myWeapon )->GetProjectileSpeed(); |
|
float rangeBetween = me->GetRangeTo( subject->GetAbsOrigin() ); |
|
|
|
const float veryCloseRange = 150.0f; |
|
if ( rangeBetween > veryCloseRange ) |
|
{ |
|
float timeToTravel = rangeBetween / missileSpeed; |
|
|
|
Vector targetSpot = me->IsDifficulty( CTFBot::NORMAL ) ? subject->WorldSpaceCenter() : subject->EyePosition(); |
|
|
|
Vector leadTargetSpot = targetSpot + timeToTravel * subject->GetAbsVelocity(); |
|
|
|
// elevate our aim based on range |
|
float elevationAngle = rangeBetween * tf_bot_arrow_elevation_rate.GetFloat(); |
|
|
|
if ( elevationAngle > 45.0f ) |
|
{ |
|
// ballistic range maximum at 45 degrees - aiming higher would decrease the range |
|
elevationAngle = 45.0f; |
|
} |
|
|
|
float s, c; |
|
FastSinCos( elevationAngle * M_PI / 180.0f, &s, &c ); |
|
|
|
if ( c > 0.0f ) |
|
{ |
|
float elevation = rangeBetween * s / c; |
|
return leadTargetSpot + Vector( 0, 0, elevation ); |
|
} |
|
|
|
return leadTargetSpot; |
|
} |
|
|
|
return subject->EyePosition(); |
|
} |
|
} |
|
|
|
if ( WeaponID_IsSniperRifle( myWeapon->GetWeaponID() ) ) |
|
{ |
|
if ( m_aimAdjustTimer.IsElapsed() ) |
|
{ |
|
m_aimAdjustTimer.Start( RandomFloat( 0.5f, 1.5f ) ); |
|
|
|
m_aimErrorAngle = RandomFloat( -M_PI, M_PI ); |
|
m_aimErrorRadius = RandomFloat( 0.0f, tf_bot_sniper_aim_error.GetFloat() ); |
|
} |
|
|
|
Vector toThreat = subject->GetAbsOrigin() - me->GetAbsOrigin(); |
|
float threatRange = toThreat.NormalizeInPlace(); |
|
|
|
float s1, c1; |
|
FastSinCos( m_aimErrorRadius, &s1, &c1 ); |
|
|
|
float error = threatRange * s1; |
|
|
|
Vector up( 0, 0, 1 ); |
|
Vector side; |
|
CrossProduct( toThreat, up, side ); |
|
|
|
float s, c; |
|
FastSinCos( m_aimErrorAngle, &s, &c ); |
|
|
|
// aim a bit lower than the head - the imperfections may yet give us a headshot |
|
Vector desiredAimSpot; |
|
|
|
switch( me->GetDifficulty() ) |
|
{ |
|
case CTFBot::EXPERT: |
|
case CTFBot::HARD: |
|
// aim for the head - reaction times will differentiate the skill levels |
|
desiredAimSpot = subject->EyePosition(); |
|
break; |
|
|
|
default: |
|
Assert(0); |
|
case CTFBot::NORMAL: |
|
desiredAimSpot = ( subject->EyePosition() + subject->EyePosition() + subject->WorldSpaceCenter() ) / 3.0f; |
|
break; |
|
|
|
case CTFBot::EASY: |
|
desiredAimSpot = subject->WorldSpaceCenter(); |
|
break; |
|
} |
|
|
|
Vector imperfectAimSpot = desiredAimSpot + error * s * up + error * c * side; |
|
|
|
return imperfectAimSpot; |
|
} |
|
|
|
if ( myWeapon->IsWeapon( TF_WEAPON_GRENADELAUNCHER ) || |
|
myWeapon->IsWeapon( TF_WEAPON_PIPEBOMBLAUNCHER ) ) |
|
{ |
|
Vector toThreat = subject->GetAbsOrigin() - me->GetAbsOrigin(); |
|
float threatRange = toThreat.NormalizeInPlace(); |
|
float elevationAngle = threatRange * tf_bot_ballistic_elevation_rate.GetFloat(); |
|
|
|
if ( elevationAngle > 45.0f ) |
|
{ |
|
// ballistic range maximum at 45 degrees - aiming higher would decrease the range |
|
elevationAngle = 45.0f; |
|
} |
|
|
|
float s, c; |
|
FastSinCos( elevationAngle * M_PI / 180.0f, &s, &c ); |
|
|
|
if ( c > 0.0f ) |
|
{ |
|
float elevation = threatRange * s / c; |
|
return subject->WorldSpaceCenter() + Vector( 0, 0, elevation ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
// aim for the center of the object (ie: sentry gun) |
|
return subject->WorldSpaceCenter(); |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
/** |
|
* Allow bot to approve of positions game movement tries to put him into. |
|
* This is most useful for bots derived from CBasePlayer that go through |
|
* the player movement system. |
|
*/ |
|
QueryResultType CTFBotMainAction::IsPositionAllowed( const INextBot *me, const Vector &pos ) const |
|
{ |
|
return ANSWER_YES; |
|
|
|
// This is causing bots to get hung up on drop-downs, particularly in MvM. MSB 6/11/2012 |
|
/* |
|
if ( me->GetLocomotionInterface()->IsScrambling() ) |
|
{ |
|
// anything goes when we're in the air/etc |
|
return ANSWER_YES; |
|
} |
|
|
|
// if we are at a DROP_DOWN segment of our path, allow us to drop |
|
const PathFollower *path = me->GetCurrentPath(); |
|
if ( path && path->IsValid() ) |
|
{ |
|
const Path::Segment *goal = path->GetCurrentGoal(); |
|
if ( goal ) |
|
{ |
|
if ( goal->type == Path::DROP_DOWN || me->GetLocomotionInterface()->GetFeet().z - goal->pos.z >= me->GetLocomotionInterface()->GetMaxJumpHeight() ) |
|
{ |
|
// our goal requires us to drop down |
|
return ANSWER_YES; |
|
} |
|
} |
|
} |
|
|
|
// do not fall off someplace we can't get back up from! |
|
trace_t result; |
|
NextBotTraceFilterIgnoreActors filter( me->GetEntity(), COLLISION_GROUP_PLAYER_MOVEMENT ); |
|
ILocomotion *mover = me->GetLocomotionInterface(); |
|
IBody *body = me->GetBodyInterface(); |
|
|
|
// slightly smaller to allow skirting the edge |
|
float halfWidth = 0.4f * body->GetHullWidth(); |
|
|
|
mover->TraceHull( pos + Vector( 0, 0, mover->GetStepHeight() ), // start up a bit to handle rough terrain |
|
pos + Vector( 0, 0, -mover->GetMaxJumpHeight() ), |
|
Vector( -halfWidth, -halfWidth, 0 ), |
|
Vector( halfWidth, halfWidth, body->GetHullHeight() ), |
|
body->GetSolidMask(), |
|
&filter, |
|
&result ); |
|
|
|
if ( result.DidHit() ) |
|
{ |
|
// there is ground safe beneath us |
|
return ANSWER_YES; |
|
} |
|
|
|
return ANSWER_NO; |
|
*/ |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
bool CTFBotMainAction::IsImmediateThreat( const CBaseCombatCharacter *subject, const CKnownEntity *threat ) const |
|
{ |
|
CTFBot *me = GetActor(); |
|
|
|
// the TFBot code assumes the subject is always "me" |
|
if ( !me || !me->IsSelf( subject ) ) |
|
return false; |
|
|
|
if ( me->InSameTeam( threat->GetEntity() ) ) |
|
return false; |
|
|
|
if ( !threat->GetEntity()->IsAlive() ) |
|
return false; |
|
|
|
if ( !threat->IsVisibleRecently() ) |
|
return false; |
|
|
|
// if they can't hurt me, they aren't an immediate threat |
|
if ( !me->IsLineOfFireClear( threat->GetEntity() ) ) |
|
return false; |
|
|
|
CTFPlayer *threatPlayer = ToTFPlayer( threat->GetEntity() ); |
|
|
|
Vector to = me->GetAbsOrigin() - threat->GetLastKnownPosition(); |
|
float threatRange = to.NormalizeInPlace(); |
|
|
|
const float nearbyRange = 500.0f; |
|
if ( threatRange < nearbyRange ) |
|
{ |
|
// very near threats are always immediately dangerous |
|
return true; |
|
} |
|
|
|
// mid-to-far away threats |
|
|
|
if ( me->IsThreatFiringAtMe( threat->GetEntity() ) ) |
|
{ |
|
// distant threat firing on me - an immediate threat whether in my FOV or not |
|
return true; |
|
} |
|
|
|
if ( threatPlayer == NULL ) |
|
{ |
|
// non-player threat - sentry guns |
|
|
|
CObjectSentrygun *sentry = dynamic_cast< CObjectSentrygun * >( threat->GetEntity() ); |
|
if ( sentry && !sentry->HasSapper() && !sentry->IsPlasmaDisabled() && !sentry->IsPlacing() ) |
|
{ |
|
// are we in range? (or will be very soon) |
|
if ( threatRange < 1.5f * SENTRY_MAX_RANGE ) |
|
{ |
|
// is it pointing at us? |
|
Vector sentryForward; |
|
AngleVectors( sentry->GetTurretAngles(), &sentryForward ); |
|
|
|
if ( DotProduct( to, sentryForward ) > 0.8f ) |
|
{ |
|
return true; |
|
} |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
// does a sniper have a shot on me? |
|
if ( threatPlayer->IsPlayerClass( TF_CLASS_SNIPER ) ) |
|
{ |
|
Vector sniperForward; |
|
threatPlayer->EyeVectors( &sniperForward ); |
|
|
|
if ( DotProduct( to, sniperForward ) > 0.0f ) |
|
{ |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
if ( me->GetDifficulty() > CTFBot::NORMAL && threatPlayer->IsPlayerClass( TF_CLASS_MEDIC ) ) |
|
{ |
|
// always try to kill these guys first |
|
return true; |
|
} |
|
|
|
if ( me->GetDifficulty() > CTFBot::NORMAL && threatPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) ) |
|
{ |
|
// take out engineers to let the team kill their sentry nests |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
const CKnownEntity *CTFBotMainAction::SelectCloserThreat( CTFBot *me, const CKnownEntity *threat1, const CKnownEntity *threat2 ) const |
|
{ |
|
float rangeSq1 = me->GetRangeSquaredTo( threat1->GetEntity() ); |
|
float rangeSq2 = me->GetRangeSquaredTo( threat2->GetEntity() ); |
|
|
|
if ( rangeSq1 < rangeSq2 ) |
|
return threat1; |
|
|
|
return threat2; |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
// If the given threat is being healed by a Medic, return the Medic, otherwise just |
|
// return the threat. |
|
const CKnownEntity *CTFBotMainAction::GetHealerOfThreat( const CKnownEntity *threat ) const |
|
{ |
|
if ( !threat || !threat->GetEntity() ) |
|
return NULL; |
|
|
|
CTFPlayer *playerThreat = ToTFPlayer( threat->GetEntity() ); |
|
if ( playerThreat ) |
|
{ |
|
for( int i=0; i<playerThreat->m_Shared.GetNumHealers(); ++i ) |
|
{ |
|
CBaseEntity *healer = playerThreat->m_Shared.GetHealerByIndex( i ); |
|
CTFPlayer *playerHealer = ToTFPlayer( healer ); |
|
|
|
if ( playerHealer ) |
|
{ |
|
const CKnownEntity *knownHealer = GetActor()->GetVisionInterface()->GetKnown( playerHealer ); |
|
|
|
if ( knownHealer && knownHealer->IsVisibleInFOVNow() ) |
|
{ |
|
return knownHealer; |
|
} |
|
} |
|
} |
|
} |
|
|
|
return threat; |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
// return the more dangerous of the two threats to 'subject', or NULL if we have no opinion |
|
const CKnownEntity *CTFBotMainAction::SelectMoreDangerousThreat( const INextBot *meBot, |
|
const CBaseCombatCharacter *subject, |
|
const CKnownEntity *threat1, |
|
const CKnownEntity *threat2 ) const |
|
{ |
|
CTFBot *me = ToTFBot( meBot->GetEntity() ); |
|
|
|
// determine the actual threat |
|
const CKnownEntity *threat = SelectMoreDangerousThreatInternal( me, subject, threat1, threat2 ); |
|
|
|
if ( me->IsDifficulty( CTFBot::EASY ) ) |
|
{ |
|
return threat; |
|
} |
|
|
|
if ( me->IsDifficulty( CTFBot::NORMAL ) && me->TransientlyConsistentRandomValue() < 0.5f ) |
|
{ |
|
return threat; |
|
} |
|
|
|
// smarter bots first aim at the Medic healing our dangerous target |
|
return GetHealerOfThreat( threat ); |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
// Given a pair of enemy players, return the closest Spy of those two, or NULL if neither is a Spy |
|
const CKnownEntity *SelectClosestSpyToMe( CTFBot *me, const CKnownEntity *threat1, const CKnownEntity *threat2 ) |
|
{ |
|
CTFPlayer *playerThreat1 = ToTFPlayer( threat1->GetEntity() ); |
|
CTFPlayer *playerThreat2 = ToTFPlayer( threat2->GetEntity() ); |
|
|
|
if ( playerThreat1 && playerThreat1->IsPlayerClass( TF_CLASS_SPY ) ) |
|
{ |
|
if ( playerThreat2 && playerThreat2->IsPlayerClass( TF_CLASS_SPY ) ) |
|
{ |
|
if ( me->GetRangeSquaredTo( playerThreat1 ) < me->GetRangeSquaredTo( playerThreat2 ) ) |
|
return threat1; |
|
|
|
return threat2; |
|
} |
|
|
|
return threat1; |
|
} |
|
else if ( playerThreat2 && playerThreat2->IsPlayerClass( TF_CLASS_SPY ) ) |
|
{ |
|
return threat2; |
|
} |
|
|
|
return NULL; |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
// Return the more dangerous of the two threats to 'subject', or NULL if we have no opinion |
|
const CKnownEntity *CTFBotMainAction::SelectMoreDangerousThreatInternal( const INextBot *meBot, |
|
const CBaseCombatCharacter *subject, |
|
const CKnownEntity *threat1, |
|
const CKnownEntity *threat2 ) const |
|
{ |
|
CTFBot *me = ToTFBot( meBot->GetEntity() ); |
|
const CKnownEntity *closerThreat = SelectCloserThreat( me, threat1, threat2 ); |
|
|
|
if ( me->HasWeaponRestriction( CTFBot::MELEE_ONLY ) ) |
|
{ |
|
// melee only bots just use closest threat |
|
return closerThreat; |
|
} |
|
|
|
// close range sentries are the most dangerous of all |
|
bool shouldFearSentryGuns = true; |
|
|
|
if ( TFGameRules()->IsMannVsMachineMode() ) |
|
{ |
|
// MvM bots are not afraid of sentry guns and treat them like other enemy players |
|
shouldFearSentryGuns = false; |
|
} |
|
|
|
if ( shouldFearSentryGuns ) |
|
{ |
|
CObjectSentrygun *sentry1 = NULL; |
|
if ( threat1->IsVisibleRecently() && !threat1->GetEntity()->IsPlayer() ) |
|
{ |
|
sentry1 = dynamic_cast< CObjectSentrygun * >( threat1->GetEntity() ); |
|
} |
|
|
|
CObjectSentrygun *sentry2 = NULL; |
|
if ( threat2->IsVisibleRecently() && !threat2->GetEntity()->IsPlayer() ) |
|
{ |
|
sentry2 = dynamic_cast< CObjectSentrygun * >( threat2->GetEntity() ); |
|
} |
|
|
|
if ( sentry1 && me->IsRangeLessThan( sentry1, SENTRY_MAX_RANGE ) && !sentry1->HasSapper() && !sentry1->IsPlasmaDisabled() && !sentry1->IsPlacing() ) |
|
{ |
|
// in range of a visible sentry! |
|
if ( sentry2 && me->IsRangeLessThan( sentry2, SENTRY_MAX_RANGE ) && !sentry2->HasSapper() && !sentry2->IsPlasmaDisabled() && !sentry2->IsPlacing() ) |
|
{ |
|
// in range of two visible sentries! we're probably dead meat at this point. |
|
// default is choose closest |
|
return closerThreat; |
|
} |
|
|
|
return threat1; |
|
} |
|
|
|
if ( sentry2 && me->IsRangeLessThan( sentry2, SENTRY_MAX_RANGE ) && !sentry2->HasSapper() && !sentry2->IsPlasmaDisabled() && !sentry2->IsPlacing() ) |
|
{ |
|
// in range of a visible sentry! |
|
return threat2; |
|
} |
|
} |
|
|
|
// enforce Spy hatred in MvM mode |
|
if ( TFGameRules()->IsMannVsMachineMode() ) |
|
{ |
|
const float spyHateRadius = 1000.0f; |
|
|
|
const CKnownEntity *spyThreat = SelectClosestSpyToMe( me, threat1, threat2 ); |
|
if ( spyThreat && me->IsRangeLessThan( spyThreat->GetEntity(), spyHateRadius ) ) |
|
{ |
|
return spyThreat; |
|
} |
|
} |
|
|
|
|
|
bool isImmediateThreat1 = IsImmediateThreat( subject, threat1 ); |
|
bool isImmediateThreat2 = IsImmediateThreat( subject, threat2 ); |
|
|
|
if ( isImmediateThreat1 && !isImmediateThreat2 ) |
|
{ |
|
return threat1; |
|
} |
|
else if ( !isImmediateThreat1 && isImmediateThreat2 ) |
|
{ |
|
return threat2; |
|
} |
|
else if ( !isImmediateThreat1 && !isImmediateThreat2 ) |
|
{ |
|
// neither threat is immediately dangerous - use closest |
|
return closerThreat; |
|
} |
|
|
|
// both threats are immediately dangerous! |
|
// check if any are extremely dangerous |
|
|
|
const CKnownEntity *spyThreat = SelectClosestSpyToMe( me, threat1, threat2 ); |
|
if ( spyThreat ) |
|
{ |
|
return spyThreat; |
|
} |
|
|
|
// choose most recent attacker (assume an enemy firing their weapon at us has attacked us) |
|
if ( me->IsThreatFiringAtMe( threat1->GetEntity() ) ) |
|
{ |
|
if ( me->IsThreatFiringAtMe( threat2->GetEntity() ) ) |
|
{ |
|
// choose closest |
|
return closerThreat; |
|
} |
|
|
|
return threat1; |
|
} |
|
else if ( me->IsThreatFiringAtMe( threat2->GetEntity() ) ) |
|
{ |
|
return threat2; |
|
} |
|
|
|
// choose closest |
|
return closerThreat; |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
QueryResultType CTFBotMainAction::ShouldAttack( const INextBot *meBot, const CKnownEntity *them ) const |
|
{ |
|
if ( g_pPopulationManager ) |
|
{ |
|
// if I'm in my spawn room, obey the population manager's attack restrictions |
|
CTFBot *me = ToTFBot( meBot->GetEntity() ); |
|
CTFNavArea *myArea = me->GetLastKnownArea(); |
|
int spawnRoomFlag = me->GetTeamNumber() == TF_TEAM_RED ? TF_NAV_SPAWN_ROOM_RED : TF_NAV_SPAWN_ROOM_BLUE; |
|
|
|
if ( myArea && myArea->HasAttributeTF( spawnRoomFlag ) ) |
|
{ |
|
return g_pPopulationManager->CanBotsAttackWhileInSpawnRoom() ? ANSWER_YES : ANSWER_NO; |
|
} |
|
} |
|
|
|
return ANSWER_YES; |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
QueryResultType CTFBotMainAction::ShouldHurry( const INextBot *meBot ) const |
|
{ |
|
if ( g_pPopulationManager ) |
|
{ |
|
// if I'm in my spawn room, obey the population manager's attack restrictions |
|
CTFBot *me = ToTFBot( meBot->GetEntity() ); |
|
CTFNavArea *myArea = me->GetLastKnownArea(); |
|
int spawnRoomFlag = me->GetTeamNumber() == TF_TEAM_RED ? TF_NAV_SPAWN_ROOM_RED : TF_NAV_SPAWN_ROOM_BLUE; |
|
|
|
if ( myArea && myArea->HasAttributeTF( spawnRoomFlag ) ) |
|
{ |
|
if ( !g_pPopulationManager->CanBotsAttackWhileInSpawnRoom() ) |
|
{ |
|
// hurry to leave the spawn |
|
return ANSWER_YES; |
|
} |
|
} |
|
} |
|
|
|
return ANSWER_UNDEFINED; |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
void CTFBotMainAction::FireWeaponAtEnemy( CTFBot *me ) |
|
{ |
|
if ( !me->IsAlive() ) |
|
return; |
|
|
|
if ( me->HasAttribute( CTFBot::SUPPRESS_FIRE ) ) |
|
return; |
|
|
|
if ( me->HasAttribute( CTFBot::IGNORE_ENEMIES ) ) |
|
return; |
|
|
|
if ( me->m_Shared.InCond( TF_COND_TAUNTING ) ) |
|
return; |
|
|
|
if ( !tf_bot_fire_weapon_allowed.GetBool() ) |
|
{ |
|
return; |
|
} |
|
|
|
CTFWeaponBase *myWeapon = me->m_Shared.GetActiveTFWeapon(); |
|
if ( !myWeapon ) |
|
return; |
|
|
|
if ( me->IsBarrageAndReloadWeapon( myWeapon ) ) |
|
{ |
|
if ( me->HasAttribute( CTFBot::HOLD_FIRE_UNTIL_FULL_RELOAD ) || tf_bot_always_full_reload.GetBool() ) |
|
{ |
|
if ( myWeapon->Clip1() <= 0 ) |
|
{ |
|
m_isWaitingForFullReload = true; |
|
} |
|
|
|
if ( m_isWaitingForFullReload ) |
|
{ |
|
if ( myWeapon->Clip1() < myWeapon->GetMaxClip1() ) |
|
{ |
|
return; |
|
} |
|
|
|
// we are fully reloaded |
|
m_isWaitingForFullReload = false; |
|
} |
|
} |
|
} |
|
|
|
if ( me->HasAttribute( CTFBot::ALWAYS_FIRE_WEAPON ) ) |
|
{ |
|
me->PressFireButton(); |
|
return; |
|
} |
|
|
|
if ( me->IsPlayerClass( TF_CLASS_MEDIC ) ) |
|
{ |
|
if ( myWeapon && myWeapon->IsWeapon( TF_WEAPON_MEDIGUN ) ) |
|
{ |
|
// don't interfere with medic healing behaviors |
|
return; |
|
} |
|
} |
|
|
|
// if we're a heavy and just saw a bad guy, keep the barrel spinning (unless we're in a hurry) |
|
if ( me->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && !me->IsAmmoLow() && me->GetIntentionInterface()->ShouldHurry( me ) != ANSWER_YES ) |
|
{ |
|
const float spinTime = 3.0f; |
|
if ( me->GetVisionInterface()->GetTimeSinceVisible( GetEnemyTeam( me->GetTeamNumber() ) ) < spinTime ) |
|
{ |
|
me->PressAltFireButton(); |
|
} |
|
} |
|
|
|
// shoot at bad guys |
|
const CKnownEntity *threat = me->GetVisionInterface()->GetPrimaryKnownThreat(); |
|
|
|
// ignore non-visible threats here so we don't force a premature weapon switch if we're doing something else |
|
if ( threat == NULL || !threat->GetEntity() || !threat->IsVisibleRecently() ) |
|
return; |
|
|
|
// don't shoot through windows/etc |
|
if ( !me->IsLineOfFireClear( threat->GetEntity()->EyePosition() ) ) |
|
{ |
|
if ( !me->IsLineOfFireClear( threat->GetEntity()->WorldSpaceCenter() ) ) |
|
{ |
|
if ( !me->IsLineOfFireClear( threat->GetEntity()->GetAbsOrigin() ) ) |
|
return; |
|
} |
|
} |
|
|
|
// if our target is uber'd, most weapons are useless - unless we're in MvM, where invuln tanking is valuable |
|
if ( TFGameRules() && !TFGameRules()->IsMannVsMachineMode() ) |
|
{ |
|
CTFPlayer *playerThreat = ToTFPlayer( threat->GetEntity() ); |
|
if ( playerThreat && playerThreat->m_Shared.IsInvulnerable() ) |
|
{ |
|
if ( !myWeapon->IsWeapon( TF_WEAPON_ROCKETLAUNCHER ) && |
|
!myWeapon->IsWeapon( TF_WEAPON_GRENADELAUNCHER ) && |
|
!myWeapon->IsWeapon( TF_WEAPON_PIPEBOMBLAUNCHER ) & |
|
!myWeapon->IsWeapon( TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT ) ) |
|
{ |
|
// firing would just waste ammo, so don't |
|
return; |
|
} |
|
} |
|
} |
|
|
|
if ( me->GetIntentionInterface()->ShouldAttack( me, threat ) == ANSWER_NO ) |
|
return; |
|
|
|
if ( TFGameRules()->InSetup() ) |
|
{ |
|
// wait until the gates open |
|
return; |
|
} |
|
|
|
if ( myWeapon->IsMeleeWeapon() ) |
|
{ |
|
if ( me->IsRangeLessThan( threat->GetEntity(), 250.0f ) ) |
|
{ |
|
me->PressFireButton(); |
|
} |
|
return; |
|
} |
|
|
|
// limit range of hitscan weapon fire in MvM |
|
if ( TFGameRules()->IsMannVsMachineMode() && !me->IsPlayerClass( TF_CLASS_SNIPER ) && me->IsHitScanWeapon( myWeapon ) ) |
|
{ |
|
if ( me->IsRangeGreaterThan( threat->GetEntity(), tf_bot_hitscan_range_limit.GetFloat() ) ) |
|
{ |
|
return; |
|
} |
|
} |
|
|
|
if ( myWeapon->IsWeapon( TF_WEAPON_FLAMETHROWER ) ) |
|
{ |
|
CTFFlameThrower *pFlamethrower = assert_cast< CTFFlameThrower* >( myWeapon ); |
|
// watch for enemy projectiles heading our way |
|
if ( pFlamethrower->CanAirBlast() && me->ShouldFireCompressionBlast() ) |
|
{ |
|
// bounce missiles with compression blast |
|
me->PressAltFireButton(); |
|
} |
|
else if ( threat->GetTimeSinceLastSeen() < 1.0f && |
|
me->IsDistanceBetweenLessThan( threat->GetEntity(), me->GetMaxAttackRange() ) ) |
|
{ |
|
me->PressFireButton( tf_bot_fire_weapon_min_time.GetFloat() ); |
|
} |
|
|
|
return; |
|
} |
|
|
|
float threatRange = ( threat->GetEntity()->GetAbsOrigin() - me->GetAbsOrigin() ).Length(); |
|
|
|
// actual head aiming is handled elsewhere, just check if we're on target |
|
if ( me->GetBodyInterface()->IsHeadAimingOnTarget() && threatRange < me->GetMaxAttackRange() ) |
|
{ |
|
if ( myWeapon->IsWeapon( TF_WEAPON_COMPOUND_BOW ) ) |
|
{ |
|
CTFCompoundBow *myBow = (CTFCompoundBow *)myWeapon; |
|
|
|
if ( myBow->GetCurrentCharge() < 0.95f || !me->IsLineOfFireClear( threat->GetEntity() ) ) |
|
{ |
|
me->PressFireButton(); |
|
} |
|
} |
|
else if ( WeaponID_IsSniperRifle( myWeapon->GetWeaponID() ) ) |
|
{ |
|
// only fire if zoomed in |
|
if ( me->m_Shared.InCond( TF_COND_ZOOMED ) ) |
|
{ |
|
const float reactionTime = TFGameRules()->IsMannVsMachineMode() ? 0.5f : 0.1f; // just a moment to stop headshots when obviously panning too fast to see |
|
if ( m_steadyTimer.HasStarted() && m_steadyTimer.IsGreaterThen( reactionTime ) ) |
|
{ |
|
trace_t trace; |
|
|
|
Vector forward; |
|
me->EyeVectors( &forward ); |
|
|
|
// allow bot to see through projectile shield |
|
CTraceFilterIgnoreFriendlyCombatItems filter( me, COLLISION_GROUP_NONE, me->GetTeamNumber() ); |
|
UTIL_TraceLine( me->EyePosition(), me->EyePosition() + 9000.0f * forward, MASK_SHOT, &filter, &trace ); |
|
|
|
if ( trace.m_pEnt == threat->GetEntity() ) |
|
{ |
|
// we're on target - fire! |
|
me->PressFireButton(); |
|
} |
|
} |
|
} |
|
} |
|
else if ( me->IsCombatWeapon( MY_CURRENT_GUN ) ) |
|
{ |
|
if ( me->IsContinuousFireWeapon( MY_CURRENT_GUN ) ) |
|
{ |
|
// spray for a bit |
|
me->PressFireButton( tf_bot_fire_weapon_min_time.GetFloat() ); |
|
} |
|
else |
|
{ |
|
if ( me->IsExplosiveProjectileWeapon( MY_CURRENT_GUN ) ) |
|
{ |
|
// don't fire if we're going to hit a nearby wall |
|
trace_t trace; |
|
|
|
Vector forward; |
|
me->EyeVectors( &forward ); |
|
|
|
// allow bot to see through projectile shield |
|
CTraceFilterIgnoreFriendlyCombatItems filter( me, COLLISION_GROUP_NONE, me->GetTeamNumber() ); |
|
UTIL_TraceLine( me->EyePosition(), me->EyePosition() + 1.1f * threatRange * forward, MASK_SHOT, &filter, &trace ); |
|
|
|
float hitRange = trace.fraction * 1.1f * threatRange; |
|
|
|
if ( hitRange < TF_ROCKET_RADIUS ) |
|
{ |
|
// shot will impact very near us |
|
if ( !trace.m_pEnt || ( trace.m_pEnt && !trace.m_pEnt->MyCombatCharacterPointer() ) ) |
|
{ |
|
// don't fire, we'd only hit the world or a non-player or non-sentry |
|
return; |
|
} |
|
} |
|
} |
|
|
|
me->PressFireButton(); |
|
} |
|
} |
|
|
|
} |
|
} |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
/** |
|
* Compute nearby friends influence and visible enemy influence |
|
*/ |
|
class CCompareFriendFoeInfluence : public IVision::IForEachKnownEntity |
|
{ |
|
public: |
|
CCompareFriendFoeInfluence( CTFBot *me ) |
|
{ |
|
m_me = me; |
|
m_friendScore = 0; |
|
m_foeScore = 0; |
|
} |
|
|
|
virtual bool Inspect( const CKnownEntity &known ) |
|
{ |
|
if ( known.GetEntity()->IsAlive() ) |
|
{ |
|
const float nearRange = 750.0f; |
|
if ( m_me->IsRangeLessThan( known.GetEntity(), nearRange ) ) |
|
{ |
|
if ( m_me->IsFriend( known.GetEntity() ) ) |
|
{ |
|
m_friendScore += m_me->GetThreatDanger( known.GetEntity()->MyCombatCharacterPointer() ); |
|
} |
|
else if ( known.WasEverVisible() && known.GetTimeSinceLastSeen() < 3.0f && m_me->IsEnemy( known.GetEntity() ) ) |
|
{ |
|
// ignore disguised spies, etc |
|
if ( m_me->GetVisionInterface()->IsIgnored( known.GetEntity() ) ) |
|
return true; |
|
|
|
// only count them if they are facing me |
|
if ( UTIL_IsFacingWithinTolerance( known.GetEntity(), m_me->EyePosition(), 0.5f ) ) |
|
{ |
|
m_foeScore += m_me->GetThreatDanger( known.GetEntity()->MyCombatCharacterPointer() ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
return true; |
|
} |
|
|
|
CTFBot *m_me; |
|
float m_friendScore; |
|
float m_foeScore; |
|
}; |
|
|
|
|
|
//--------------------------------------------------------------------------------------------- |
|
/** |
|
* If we're outnumbered, retreat and wait for backup - unless we're ubered! |
|
*/ |
|
QueryResultType CTFBotMainAction::ShouldRetreat( const INextBot *bot ) const |
|
{ |
|
CTFBot *me = (CTFBot *)bot->GetEntity(); |
|
|
|
// don't retreat if we're in "melee only" mode |
|
if ( TheTFBots().IsMeleeOnly() ) |
|
return ANSWER_NO; |
|
|
|
// don't retreat if ubered |
|
if ( me->m_Shared.IsInvulnerable() ) |
|
return ANSWER_NO; |
|
|
|
// don't retreat if we're ignoring enemies |
|
if ( me->HasAttribute( CTFBot::IGNORE_ENEMIES ) ) |
|
return ANSWER_NO; |
|
|
|
// retreat if stunned |
|
if ( me->m_Shared.IsControlStunned() || me->m_Shared.IsLoserStateStunned() ) |
|
return ANSWER_YES; |
|
|
|
// don't retreat during setup time, since we're always safe |
|
if ( TFGameRules()->InSetup() ) |
|
return ANSWER_NO; |
|
|
|
// if we're an undercover spy, don't blow our cover |
|
if ( me->IsPlayerClass( TF_CLASS_SPY ) ) |
|
{ |
|
if ( me->m_Shared.InCond( TF_COND_DISGUISED ) || |
|
me->m_Shared.InCond( TF_COND_DISGUISING ) || |
|
me->m_Shared.IsStealthed() ) |
|
{ |
|
return ANSWER_NO; |
|
} |
|
} |
|
|
|
CCompareFriendFoeInfluence compare( me ); |
|
me->GetVisionInterface()->ForEachKnownEntity( compare ); |
|
|
|
if ( compare.m_friendScore < compare.m_foeScore ) |
|
{ |
|
return ANSWER_YES; |
|
} |
|
|
|
return ANSWER_NO; |
|
} |
|
|
|
|
|
//----------------------------------------------------------------------------------------- |
|
void CTFBotMainAction::Dodge( CTFBot *me ) |
|
{ |
|
// low-skill bots don't dodge |
|
if ( me->IsDifficulty( CTFBot::EASY ) ) |
|
return; |
|
|
|
// no need to dodge if we're invulnerable |
|
if ( me->m_Shared.IsInvulnerable() ) |
|
return; |
|
|
|
// don't dodge if we're trying to snipe |
|
if ( me->m_Shared.InCond( TF_COND_ZOOMED ) ) |
|
return; |
|
|
|
// don't dodge if we are taunting |
|
if ( me->m_Shared.InCond( TF_COND_TAUNTING ) ) |
|
return; |
|
|
|
// don't dodge if that ability is "turned off" |
|
if ( me->HasAttribute( CTFBot::DISABLE_DODGE ) ) |
|
return; |
|
|
|
// don't dodge if we're not trying to fight back |
|
if ( !me->IsCombatWeapon( MY_CURRENT_GUN ) ) |
|
return; |
|
|
|
// don't waste time doding if we're in a hurry |
|
if ( me->GetIntentionInterface()->ShouldHurry( me ) == ANSWER_YES ) |
|
return; |
|
|
|
// for now, engies don't dodge |
|
if ( me->IsPlayerClass( TF_CLASS_ENGINEER ) ) |
|
return; |
|
|
|
// disguised/cloaked spies don't dodge |
|
if ( me->m_Shared.InCond( TF_COND_DISGUISED ) || |
|
me->m_Shared.InCond( TF_COND_DISGUISING ) || |
|
me->m_Shared.IsStealthed() ) |
|
{ |
|
return; |
|
} |
|
|
|
|
|
#ifdef TF_RAID_MODE |
|
if ( TFGameRules()->IsRaidMode() ) |
|
return; |
|
#endif // TF_RAID_MODE |
|
|
|
const CKnownEntity *threat = me->GetVisionInterface()->GetPrimaryKnownThreat(); |
|
if ( threat && threat->IsVisibleRecently() ) |
|
{ |
|
bool isShotClear = true; |
|
|
|
CTFWeaponBase *myGun = (CTFWeaponBase *)me->Weapon_GetSlot( TF_WPN_TYPE_PRIMARY ); |
|
if ( myGun && myGun->IsWeapon( TF_WEAPON_COMPOUND_BOW ) ) |
|
{ |
|
CTFCompoundBow *myBow = (CTFCompoundBow *)myGun; |
|
if ( myBow->GetCurrentCharge() > 0.0f ) |
|
{ |
|
// we're drawing back our bow - hold still |
|
return; |
|
} |
|
|
|
// if we don't have a clear shot, dodge around until we do |
|
isShotClear = true; |
|
} |
|
else |
|
{ |
|
isShotClear = me->IsLineOfFireClear( threat->GetLastKnownPosition() ); |
|
} |
|
|
|
// don't dodge if they can't hit us |
|
if ( !isShotClear ) |
|
return; |
|
|
|
Vector forward; |
|
me->EyeVectors( &forward ); |
|
Vector left( -forward.y, forward.x, 0.0f ); |
|
left.NormalizeInPlace(); |
|
|
|
const float sideStepSize = 25.0f; |
|
|
|
int rnd = RandomInt( 0, 100 ); |
|
if ( rnd < 33 ) |
|
{ |
|
if ( !me->GetLocomotionInterface()->HasPotentialGap( me->GetAbsOrigin(), me->GetAbsOrigin() + sideStepSize * left ) ) |
|
{ |
|
me->PressLeftButton(); |
|
} |
|
} |
|
else if ( rnd > 66 ) |
|
{ |
|
if ( !me->GetLocomotionInterface()->HasPotentialGap( me->GetAbsOrigin(), me->GetAbsOrigin() - sideStepSize * left ) ) |
|
{ |
|
me->PressRightButton(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
|