1HEADmaster

1 files changed, 628 insertions, 0 deletions

diff --git a/game/server/tf/bot/behavior/sniper/tf_bot_sniper_lurk.cpp b/game/server/tf/bot/behavior/sniper/tf_bot_sniper_lurk.cpp
new file mode 100644
index 0000000..88b5204
--- /dev/null
+++ b/game/server/tf/bot/behavior/sniper/tf_bot_sniper_lurk.cpp
@@ -0,0 +1,628 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// tf_bot_sniper_lurk.h
+// Move into position and wait for victims
+// Michael Booth, October 2009
+
+#include "cbase.h"
+#include "tf_player.h"
+
+#ifdef TF_RAID_MODE
+#include "raid/tf_raid_logic.h"
+#endif // TF_RAID_MODE
+
+#include "bot/tf_bot.h"
+#include "bot/behavior/sniper/tf_bot_sniper_lurk.h"
+#include "bot/behavior/sniper/tf_bot_sniper_attack.h"
+#include "bot/behavior/tf_bot_retreat_to_cover.h"
+#include "bot/behavior/tf_bot_melee_attack.h"
+#include "bot/map_entities/tf_bot_hint.h"
+
+#include "nav_mesh.h"
+
+extern ConVar tf_bot_path_lookahead_range;
+extern ConVar tf_bot_sniper_flee_range;
+extern ConVar tf_bot_sniper_melee_range;
+extern ConVar tf_bot_debug_sniper;
+
+extern float SkewedRandomValue( void );
+
+ConVar tf_bot_sniper_patience_duration( "tf_bot_sniper_patience_duration", "10", FCVAR_CHEAT, "How long a Sniper bot will wait without seeing an enemy before picking a new spot" );
+ConVar tf_bot_sniper_target_linger_duration( "tf_bot_sniper_target_linger_duration", "2", FCVAR_CHEAT, "How long a Sniper bot will keep toward at a target it just lost sight of" );
+ConVar tf_bot_sniper_allow_opportunistic( "tf_bot_sniper_allow_opportunistic", "1", FCVAR_NONE, "If set, Snipers will stop on their way to their preferred lurking spot to snipe at opportunistic targets" );
+
+ConVar tf_mvm_bot_sniper_target_by_dps( "tf_mvm_bot_sniper_target_by_dps", "1", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "If set, Snipers in MvM mode target the victim that has the highest DPS" );
+
+#ifdef STAGING_ONLY
+extern ConVar tf_bot_use_items;
+#endif
+
+//---------------------------------------------------------------------------------------------
+ActionResult< CTFBot >	CTFBotSniperLurk::OnStart( CTFBot *me, Action< CTFBot > *priorAction )
+{
+	m_boredTimer.Start( RandomFloat( 0.9f, 1.1f ) * tf_bot_sniper_patience_duration.GetFloat() );
+
+	m_homePosition = me->GetAbsOrigin();
+	m_isHomePositionValid = false;
+	m_isAtHome = false;
+	m_failCount = 0;
+
+	m_isOpportunistic = tf_bot_sniper_allow_opportunistic.GetBool();
+
+	CTFBotHint *hint = NULL;
+	while( ( hint = (CTFBotHint *)( gEntList.FindEntityByClassname( hint, "func_tfbot_hint" ) ) ) != NULL )
+	{
+		if ( hint->IsA( CTFBotHint::HINT_SNIPER_SPOT ) )
+		{
+			m_hintVector.AddToTail( hint );
+
+			// make sure we don't yet own any of these hints
+			if ( me->IsSelf( hint->GetOwnerEntity() ) )
+			{
+				hint->SetOwnerEntity( NULL );
+			}
+		}
+	}
+
+	m_priorHint = NULL;
+
+	if ( TFGameRules()->IsMannVsMachineMode() && me->GetTeamNumber() == TF_TEAM_PVE_INVADERS )
+	{
+		// mann vs machine snipers shouldn't stop until they reach their home
+		//m_isOpportunistic = false;
+
+		// mann vs machine snipers should ignore the scenario and just snipe
+		me->SetMission( CTFBot::MISSION_SNIPER, MISSION_DOESNT_RESET_BEHAVIOR_SYSTEM );
+	}
+
+#ifdef STAGING_ONLY
+	if ( tf_bot_use_items.GetInt() && ( RandomInt(0, 100) <= tf_bot_use_items.GetInt() ) )
+	{
+		CBaseCombatWeapon *myGun = me->Weapon_GetSlot( TF_WPN_TYPE_PRIMARY );
+		me->Weapon_Detach( myGun );
+		UTIL_Remove( myGun );
+
+		BotGenerateAndWearItem( me, "The Huntsman" );
+	}
+#endif // STAGING_ONLY
+
+	return Continue();
+}
+
+
+//---------------------------------------------------------------------------------------------
+ActionResult< CTFBot >	CTFBotSniperLurk::Update( CTFBot *me, float interval )
+{
+#ifdef TF_RAID_MODE
+	if ( TFGameRules()->IsRaidMode() )
+	{
+	}
+	else
+#endif
+	{
+		// continuously search for good sniping spots
+		me->AccumulateSniperSpots();
+
+		if ( !m_isHomePositionValid )
+		{
+			// just found our first sniper spot - update our home position
+			FindNewHome( me );
+		}
+	}
+
+	// aim at bad guys
+	const CKnownEntity *threat = me->GetVisionInterface()->GetPrimaryKnownThreat();
+
+	if ( threat && !threat->GetEntity()->IsAlive() )
+	{
+		// he's dead
+		threat = NULL;
+	}
+
+	if ( threat && me->GetIntentionInterface()->ShouldAttack( me, threat ) == ANSWER_NO )
+	{
+		threat = NULL;
+	}
+
+	if ( threat && threat->IsVisibleInFOVNow() )
+	{
+		m_failCount = 0;
+
+		if ( me->IsDistanceBetweenLessThan( threat->GetLastKnownPosition(), tf_bot_sniper_melee_range.GetFloat() ) )
+		{
+			const float giveUpRange = 1.25f * tf_bot_sniper_melee_range.GetFloat();
+			return SuspendFor( new CTFBotMeleeAttack( giveUpRange ), "Melee attacking nearby threat" );
+		}
+	}
+
+	bool isSightingRifle = false;
+
+	if ( threat && 
+		 threat->GetTimeSinceLastSeen() < tf_bot_sniper_target_linger_duration.GetFloat() &&
+		 me->IsLineOfFireClear( threat->GetEntity() ) )
+	{
+		// we see something...
+		if ( m_isOpportunistic )
+		{
+			// switch to our sniper rifle
+			CBaseCombatWeapon *myGun = me->Weapon_GetSlot( TF_WPN_TYPE_PRIMARY );
+			if ( myGun )
+			{
+				me->Weapon_Switch( myGun );
+			}
+
+			isSightingRifle = true;
+			m_boredTimer.Reset();
+
+			if ( !m_isHomePositionValid )
+			{
+				// make this our opportunistic home for awhile
+				m_homePosition = me->GetAbsOrigin();
+				m_boredTimer.Start( RandomFloat( 0.9f, 1.1f ) * tf_bot_sniper_patience_duration.GetFloat() );
+			}
+		}
+		else
+		{
+			// switch to our SMG and fire while we run
+			CBaseCombatWeapon *myGun = me->Weapon_GetSlot( TF_WPN_TYPE_SECONDARY );
+			if ( myGun )
+			{
+				me->Weapon_Switch( myGun );
+			}
+		}
+	}
+
+	const float homeRange = 25.0f; // 100.0f;
+	m_isAtHome = ( me->GetAbsOrigin() - m_homePosition ).AsVector2D().IsLengthLessThan( homeRange );
+
+	if ( m_isAtHome )
+	{
+		isSightingRifle = true;
+
+		// once we've reached a good home spot, opportunistically attack from there
+		m_isOpportunistic = tf_bot_sniper_allow_opportunistic.GetBool();
+
+		if ( m_boredTimer.IsElapsed() )
+		{
+			++m_failCount;
+
+			if ( FindNewHome( me ) )
+			{
+				me->SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_NEGATIVE );
+				m_boredTimer.Start( RandomFloat( 0.9f, 1.1f ) * tf_bot_sniper_patience_duration.GetFloat() );
+			}
+			else
+			{
+				// try again soon
+				m_boredTimer.Start( 1.0f );
+			}
+		}
+	}
+	else
+	{
+		// not yet at home - can't start to be bored
+		m_boredTimer.Reset();
+	}
+
+	if ( isSightingRifle )
+	{
+		// switch to our sniper rifle
+		CTFWeaponBase *myGun = (CTFWeaponBase *)me->Weapon_GetSlot( TF_WPN_TYPE_PRIMARY );
+		if ( myGun )
+		{
+			me->Weapon_Switch( myGun );
+
+			if ( !me->m_Shared.InCond( TF_COND_ZOOMED ) && !myGun->IsWeapon( TF_WEAPON_COMPOUND_BOW ) )
+			{
+				// zoom in and stand still
+				me->PressAltFireButton();
+			}
+		}
+	}
+	else 
+	{
+		// move to our home position
+		if ( m_repathTimer.IsElapsed() )
+		{
+			m_repathTimer.Start( RandomFloat( 1.0f, 2.0f ) );
+
+			CTFBotPathCost cost( me, SAFEST_ROUTE );
+			m_path.Compute( me, m_homePosition, cost );
+		}
+
+		m_path.Update( me );
+		
+		if ( me->m_Shared.InCond( TF_COND_ZOOMED ) )
+		{
+			me->PressAltFireButton();
+		}
+	}
+
+	return Continue();
+}
+
+
+//---------------------------------------------------------------------------------------------
+void CTFBotSniperLurk::OnEnd( CTFBot *me, Action< CTFBot > *nextAction )
+{
+	if ( me->m_Shared.InCond( TF_COND_ZOOMED ) )
+	{
+		// we're leaving to do something else - unzoom
+		me->PressAltFireButton();
+	}
+
+	if ( m_priorHint != NULL )
+	{
+		// release my hint
+		m_priorHint->SetOwnerEntity( NULL );
+
+		if ( tf_bot_debug_sniper.GetBool() )
+		{
+			DevMsg( "%3.2f: %s: Releasing hint.\n", gpGlobals->curtime, me->GetPlayerName() );
+		}
+	}
+}
+
+
+//---------------------------------------------------------------------------------------------
+ActionResult< CTFBot >	CTFBotSniperLurk::OnSuspend( CTFBot *me, Action< CTFBot > *interruptingAction )
+{
+	if ( me->m_Shared.InCond( TF_COND_ZOOMED ) )
+	{
+		// we're leaving to do something else - unzoom
+		me->PressAltFireButton();
+	}
+
+	if ( m_priorHint != NULL )
+	{
+		// release my hint
+		m_priorHint->SetOwnerEntity( NULL );
+
+		if ( tf_bot_debug_sniper.GetBool() )
+		{
+			DevMsg( "%3.2f: %s: Releasing hint.\n", gpGlobals->curtime, me->GetPlayerName() );
+		}
+	}
+
+	return Continue();
+}
+
+
+//---------------------------------------------------------------------------------------------
+ActionResult< CTFBot >	CTFBotSniperLurk::OnResume( CTFBot *me, Action< CTFBot > *interruptingAction )
+{
+	m_repathTimer.Invalidate();
+	m_priorHint = NULL;
+
+	// we probably just fetched some health because the enemy shot us - pick a new place to lurk
+	FindNewHome( me );
+
+	return Continue();
+}
+
+
+//---------------------------------------------------------------------------------------------
+bool CTFBotSniperLurk::FindHint( CTFBot *me )
+{
+	// if any sniper spot hints exist, pick one of them
+	CUtlVector< CTFBotHint * > activeHintVector;
+	for( int i=0; i<m_hintVector.Count(); ++i )
+	{
+		if ( m_hintVector[i] != NULL && m_hintVector[i]->IsFor( me ) )
+		{
+			activeHintVector.AddToTail( m_hintVector[i] );
+		}
+	}
+
+	if ( activeHintVector.Count() == 0 )
+	{
+		return false;
+	}
+
+	if ( m_priorHint != NULL )
+	{
+		// release my hint
+		m_priorHint->SetOwnerEntity( NULL );
+
+		if ( tf_bot_debug_sniper.GetBool() )
+		{
+			DevMsg( "%3.2f: %s: Releasing hint.\n", gpGlobals->curtime, me->GetPlayerName() );
+		}
+	}
+
+	CTFBotHint *hint = NULL;
+
+	if ( m_priorHint != NULL && m_failCount < 2 )
+	{
+		// there used to be targets here - pick nearby hint
+		float nearRange = 500.0f;
+		CUtlVector< CTFBotHint * > nearHintVector;
+		for( int i=0; i<activeHintVector.Count(); ++i )
+		{
+			if ( activeHintVector[i] == m_priorHint )
+				continue;
+
+			if ( ( activeHintVector[i]->WorldSpaceCenter() - m_priorHint->WorldSpaceCenter() ).IsLengthGreaterThan( nearRange ) )
+				continue;
+
+			if ( activeHintVector[i]->GetOwnerEntity() != NULL )
+				continue;
+
+			nearHintVector.AddToTail( activeHintVector[i] );
+		}
+
+		if ( nearHintVector.Count() == 0 )
+		{
+			++m_failCount;
+			return false;
+		}
+
+		int whichHint = RandomInt( 0, nearHintVector.Count()-1 );
+		hint = nearHintVector[ whichHint ];
+	}
+	else
+	{
+		// picking either our first hint, or we haven't seen a victim in a long time - pick a hint that can actually see someone
+		CUtlVector< CTFPlayer * > victimVector;
+		CollectPlayers( &victimVector, GetEnemyTeam( me->GetTeamNumber() ), COLLECT_ONLY_LIVING_PLAYERS );
+
+		CUtlVector< CTFBotHint * > hotHintVector;
+		CUtlVector< CTFBotHint * > freeHintVector;
+
+		for( int i=0; i<activeHintVector.Count(); ++i )
+		{
+			if ( activeHintVector[i]->GetOwnerEntity() != NULL )
+				continue;
+
+			freeHintVector.AddToTail( activeHintVector[i] );
+
+			for( int p=0; p<victimVector.Count(); ++p )
+			{
+				if ( victimVector[p]->IsLineOfSightClear( activeHintVector[i]->WorldSpaceCenter(), CBaseCombatCharacter::IGNORE_ACTORS ) )
+				{
+					// at least one victim is visible from this hint
+					hotHintVector.AddToTail( activeHintVector[i] );
+					break;
+				}
+			}
+		}
+
+		if ( hotHintVector.Count() == 0 )
+		{
+			// no hints can see any victims - pick at random
+			if ( freeHintVector.Count() == 0 )
+			{
+				// all hints are owned by another sniper - double up
+				int whichHint = RandomInt( 0, activeHintVector.Count()-1 );
+				hint = activeHintVector[ whichHint ];
+
+				if ( tf_bot_debug_sniper.GetBool() )
+				{
+					DevMsg( "%3.2f: %s: No un-owned hints available! Doubling up.\n", gpGlobals->curtime, me->GetPlayerName() );
+				}
+			}
+			else
+			{
+				int whichHint = RandomInt( 0, freeHintVector.Count()-1 );
+				hint = freeHintVector[ whichHint ];
+			}
+		}
+		else
+		{
+			int whichHint = RandomInt( 0, hotHintVector.Count()-1 );
+			hint = hotHintVector[ whichHint ];
+		}
+	}
+
+	if ( hint == NULL )
+	{
+		return false;
+	}
+
+	Extent hintExtent;
+	hintExtent.Init( hint );
+
+	Vector hintSpot;
+	hintSpot.x = RandomFloat( hintExtent.lo.x, hintExtent.hi.x );
+	hintSpot.y = RandomFloat( hintExtent.lo.y, hintExtent.hi.y );
+	hintSpot.z = ( hintExtent.lo.z + hintExtent.hi.z ) / 2.0f;
+
+	TheNavMesh->GetSimpleGroundHeight( hintSpot, &hintSpot.z );
+
+	m_homePosition = hintSpot;
+	m_isHomePositionValid = true;
+	m_priorHint = hint;
+
+	// my hint
+	hint->SetOwnerEntity( me );
+
+	return true;
+}
+
+
+//---------------------------------------------------------------------------------------------
+bool CTFBotSniperLurk::FindNewHome( CTFBot *me )
+{
+	if ( !m_findHomeTimer.IsElapsed() )
+	{
+		return false;
+	}
+
+	m_findHomeTimer.Start( RandomFloat( 1.0f, 2.0f ) );
+
+
+#ifdef TF_RAID_MODE
+	if ( TFGameRules()->IsRaidMode() )
+	{
+		// stay put for now
+		return true;
+	}
+	else
+#endif // TF_RAID_MODE
+	{
+		// if any sniper spot hints exist, pick one of them
+		if ( FindHint( me ) )
+		{
+			return true;
+		}
+
+		// pick a sniper spot from our ongoing search
+		const CUtlVector< CTFBot::SniperSpotInfo > *sniperSpotVector = me->GetSniperSpots();
+		if ( sniperSpotVector->Count() > 0 )
+		{
+			m_homePosition = sniperSpotVector->Element( RandomInt( 0, sniperSpotVector->Count()-1 ) ).m_vantageSpot;
+			m_isHomePositionValid = true;
+			return true;
+		}
+	}
+
+	// can't find a real sniper spot - pick another goal that will get us out into the fray
+	m_isHomePositionValid = false;
+
+	// head toward the point
+	CTeamControlPoint *point = me->GetMyControlPoint();
+	if ( point && !point->IsLocked() )
+	{
+		const CUtlVector< CTFNavArea * > *pointAreaVector = TheTFNavMesh()->GetControlPointAreas( point->GetPointIndex() );
+
+		if ( pointAreaVector && pointAreaVector->Count() > 0 )
+		{
+			int which = RandomInt( 0, pointAreaVector->Count()-1 );
+
+			m_homePosition = pointAreaVector->Element( which )->GetRandomPoint();
+
+			return false;
+		}
+	}
+
+	// no available point at the moment - head toward the enemy spawn room and opportunistically snipe
+	CUtlVector< CTFNavArea * > enemySpawnThresholdVector;
+	TheTFNavMesh()->CollectSpawnRoomThresholdAreas( &enemySpawnThresholdVector, GetEnemyTeam( me->GetTeamNumber() ) );
+
+	if ( enemySpawnThresholdVector.Count() > 0 )
+	{
+		m_homePosition = enemySpawnThresholdVector[ RandomInt( 0, enemySpawnThresholdVector.Count()-1 ) ]->GetCenter();
+	}
+	else
+	{
+		m_homePosition = me->GetAbsOrigin();
+	}
+
+	return false;
+}
+
+
+//---------------------------------------------------------------------------------------------
+QueryResultType CTFBotSniperLurk::ShouldAttack( const INextBot *bot, const CKnownEntity *them ) const
+{
+	CTFBot *me = (CTFBot *)bot->GetEntity();
+
+	CTFNavArea *area = me->GetLastKnownArea();
+
+	if ( TFGameRules()->IsMannVsMachineMode() && area && area->HasAttributeTF( TF_NAV_SPAWN_ROOM_BLUE ) )
+	{
+		// don't fire while in the spawn area
+		return ANSWER_NO;
+	}
+
+	// take the shot if you've got it
+	return ANSWER_YES;
+}
+
+
+//---------------------------------------------------------------------------------------------
+QueryResultType CTFBotSniperLurk::ShouldRetreat( const INextBot *me ) const
+{
+	if ( TFGameRules()->IsMannVsMachineMode() && me->GetEntity()->GetTeamNumber() == TF_TEAM_PVE_INVADERS )
+	{
+		return ANSWER_NO;
+	}
+
+	return ANSWER_UNDEFINED;
+}
+
+//---------------------------------------------------------------------------------------------
+// Return the more dangerous of the two threats to 'subject', or NULL if we have no opinion
+const CKnownEntity *CTFBotSniperLurk::SelectMoreDangerousThreat( const INextBot *meBot, 
+																 const CBaseCombatCharacter *subject,
+																 const CKnownEntity *threat1, 
+																 const CKnownEntity *threat2 ) const
+{
+	if ( TFGameRules()->IsMannVsMachineMode() && tf_mvm_bot_sniper_target_by_dps.GetBool() )
+	{
+		CTFBot *me = ToTFBot( meBot->GetEntity() );
+
+		// If one threat is visible and the other not, always pick the visible one
+		if ( !threat1->IsVisibleRecently() )
+		{
+			if ( threat2->IsVisibleRecently() )
+			{
+				return threat2;
+			}
+		}
+		else if ( !threat2->IsVisibleRecently() )
+		{
+			return threat1;
+		}
+
+		// At this point, threat1 and threat2 are either both visible, or both not
+
+		CTFPlayer *playerThreat1 = ToTFPlayer( threat1->GetEntity() );
+		CTFPlayer *playerThreat2 = ToTFPlayer( threat2->GetEntity() );
+
+		if ( playerThreat1 && playerThreat2 )
+		{
+			float rangeSq1 = me->GetRangeSquaredTo( playerThreat1 );
+			float rangeSq2 = me->GetRangeSquaredTo( playerThreat2 );
+
+			if ( me->HasWeaponRestriction( CTFBot::MELEE_ONLY ) )
+			{
+				// Melee-only bots just use closest threat
+				if ( rangeSq1 < rangeSq2 )
+				{
+					return threat1;
+				}
+				return threat2;
+			}
+
+			// Very near threats are always immediately dangerous
+			const float nearbyRangeSq = 500.0f * 500.0f;
+			if ( rangeSq1 < nearbyRangeSq )
+			{
+				if ( rangeSq2 > nearbyRangeSq )
+				{
+					return threat1;
+				}
+			}
+			else if ( rangeSq2 < nearbyRangeSq )
+			{
+				return threat2;
+			}
+
+			// At this point, both threats are either both very near or both "far"
+
+			// Choose the threat that has the highest DPS
+			const int equalTolerance = 50;
+
+			if ( playerThreat1->GetDamagePerSecond() > playerThreat2->GetDamagePerSecond() + equalTolerance )
+			{
+				return threat1;
+			}
+			else if ( playerThreat2->GetDamagePerSecond() > playerThreat1->GetDamagePerSecond() + equalTolerance )
+			{
+				return threat2;
+			}
+			else
+			{
+				// approximately equal DPS, choose closest
+				if ( rangeSq1 < rangeSq2 )
+				{
+					return threat1;
+				}
+				return threat2;
+			}
+		}
+	}
+
+	// Use normal threat selection
+	return NULL;
+}