First version of the SOurce SDK 2013

1 files changed, 580 insertions, 0 deletions

diff --git a/mp/src/game/server/ai_utils.cpp b/mp/src/game/server/ai_utils.cpp
new file mode 100644
index 00000000..3119d2f8
--- /dev/null
+++ b/mp/src/game/server/ai_utils.cpp
@@ -0,0 +1,580 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose:

+//

+//=============================================================================//

+

+#include "cbase.h"

+#include "ai_utils.h"

+#include "ai_memory.h"

+#include "ai_basenpc.h"

+#include "ai_senses.h"

+#include "ai_moveprobe.h"

+#include "vphysics/object_hash.h"

+

+// memdbgon must be the last include file in a .cpp file!!!

+#include "tier0/memdbgon.h"

+

+//-----------------------------------------------------------------------------

+

+BEGIN_SIMPLE_DATADESC( CAI_MoveMonitor )

+	DEFINE_FIELD( m_vMark, FIELD_POSITION_VECTOR ), 

+	DEFINE_FIELD( m_flMarkTolerance, FIELD_FLOAT )

+END_DATADESC()

+

+//-----------------------------------------------------------------------------

+

+BEGIN_SIMPLE_DATADESC( CAI_ShotRegulator )

+	DEFINE_FIELD( m_flNextShotTime, FIELD_TIME ),

+	DEFINE_FIELD( m_bInRestInterval, FIELD_BOOLEAN ),

+	DEFINE_FIELD( m_nBurstShotsRemaining, FIELD_SHORT ),

+	DEFINE_FIELD( m_nMinBurstShots, FIELD_SHORT ),

+	DEFINE_FIELD( m_nMaxBurstShots, FIELD_SHORT ),

+	DEFINE_FIELD( m_flMinRestInterval, FIELD_FLOAT ),

+	DEFINE_FIELD( m_flMaxRestInterval, FIELD_FLOAT ),

+	DEFINE_FIELD( m_flMinBurstInterval, FIELD_FLOAT ),

+	DEFINE_FIELD( m_flMaxBurstInterval, FIELD_FLOAT ),

+	DEFINE_FIELD( m_bDisabled, FIELD_BOOLEAN ),

+END_DATADESC()

+

+//-----------------------------------------------------------------------------

+

+

+//-----------------------------------------------------------------------------

+// Constructor

+//-----------------------------------------------------------------------------

+CAI_ShotRegulator::CAI_ShotRegulator() : m_nMinBurstShots(1), m_nMaxBurstShots(1)

+{

+	m_flMinRestInterval = 0.0f;

+	m_flMinRestInterval = 0.0f;

+	m_flMinBurstInterval = 0.0f;

+	m_flMaxBurstInterval = 0.0f;

+	m_flNextShotTime = -1;

+	m_nBurstShotsRemaining = 1;

+	m_bInRestInterval = false;

+	m_bDisabled = false;

+}

+

+

+//-----------------------------------------------------------------------------

+// For backward compatibility

+//-----------------------------------------------------------------------------

+void CAI_ShotRegulator::SetParameters( int minShotsPerBurst, int maxShotsPerBurst, float minRestTime, float maxRestTime )

+{

+	SetBurstShotCountRange( minShotsPerBurst, maxShotsPerBurst );

+	SetRestInterval( minRestTime, maxRestTime );

+	Reset( false );

+}

+

+

+//-----------------------------------------------------------------------------

+// Sets the number of shots to shoot in a single burst

+//-----------------------------------------------------------------------------

+void CAI_ShotRegulator::SetBurstShotCountRange( int minShotsPerBurst, int maxShotsPerBurst )

+{

+	m_nMinBurstShots = minShotsPerBurst;

+	m_nMaxBurstShots = maxShotsPerBurst;

+}

+

+

+//-----------------------------------------------------------------------------

+// How much time should I rest between bursts?

+//-----------------------------------------------------------------------------

+void CAI_ShotRegulator::SetRestInterval( float flMinRestInterval, float flMaxRestInterval )

+{

+	m_flMinRestInterval = flMinRestInterval;

+	m_flMaxRestInterval = flMaxRestInterval;

+}

+

+

+//-----------------------------------------------------------------------------

+// How much time should I wait in between shots in a single burst?

+//-----------------------------------------------------------------------------

+void CAI_ShotRegulator::SetBurstInterval( float flMinBurstInterval, float flMaxBurstInterval )

+{

+	m_flMinBurstInterval = flMinBurstInterval;

+	m_flMaxBurstInterval = flMaxBurstInterval;

+}

+

+

+//-----------------------------------------------------------------------------

+// Poll the current parameters

+//-----------------------------------------------------------------------------

+void CAI_ShotRegulator::GetBurstShotCountRange( int *pMinShotsPerBurst, int *pMaxShotsPerBurst ) const

+{

+	*pMinShotsPerBurst = m_nMinBurstShots;

+	*pMaxShotsPerBurst = m_nMaxBurstShots;

+}

+

+void CAI_ShotRegulator::GetRestInterval( float *pMinRestInterval, float *pMaxRestInterval ) const

+{

+	*pMinRestInterval = m_flMinRestInterval;

+	*pMaxRestInterval = m_flMaxRestInterval;

+}

+

+void CAI_ShotRegulator::GetBurstInterval( float *pMinBurstInterval, float *pMaxBurstInterval ) const

+{

+	*pMinBurstInterval = m_flMinBurstInterval;

+	*pMaxBurstInterval = m_flMaxBurstInterval;

+}

+

+

+//-----------------------------------------------------------------------------

+// Resets the shot regulator to start a new burst

+//-----------------------------------------------------------------------------

+void CAI_ShotRegulator::Reset( bool bStartShooting )

+{

+	m_bDisabled = false;

+	m_nBurstShotsRemaining = random->RandomInt( m_nMinBurstShots, m_nMaxBurstShots );

+	if ( bStartShooting )

+	{

+		m_flNextShotTime = gpGlobals->curtime;

+		m_bInRestInterval = false;

+	}

+	else

+	{

+		m_flNextShotTime = gpGlobals->curtime + random->RandomFloat( m_flMinRestInterval, m_flMaxRestInterval );

+		m_bInRestInterval = true;

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Should we shoot?

+//-----------------------------------------------------------------------------

+bool CAI_ShotRegulator::ShouldShoot() const

+{ 

+	return ( !m_bDisabled && (m_flNextShotTime <= gpGlobals->curtime) ); 

+}

+

+

+//-----------------------------------------------------------------------------

+// Am I in the middle of a burst?

+//-----------------------------------------------------------------------------

+bool CAI_ShotRegulator::IsInRestInterval() const

+{

+	return (m_bInRestInterval && !ShouldShoot()); 

+}

+

+

+//-----------------------------------------------------------------------------

+// When will I shoot next?

+//-----------------------------------------------------------------------------

+float CAI_ShotRegulator::NextShotTime() const

+{

+	return m_flNextShotTime;

+}

+

+

+//-----------------------------------------------------------------------------

+// Causes us to potentially delay our shooting time

+//-----------------------------------------------------------------------------

+void CAI_ShotRegulator::FireNoEarlierThan( float flTime )

+{

+	if ( flTime > m_flNextShotTime )

+	{

+		m_flNextShotTime = flTime;

+	}

+}

+

+

+//-----------------------------------------------------------------------------

+// Burst shot count accessors

+//-----------------------------------------------------------------------------

+int CAI_ShotRegulator::GetBurstShotsRemaining() const				

+{ 

+	return m_nBurstShotsRemaining; 

+}

+

+void CAI_ShotRegulator::SetBurstShotsRemaining( int shots )	

+{

+	m_nBurstShotsRemaining = shots;

+}

+

+

+//-----------------------------------------------------------------------------

+// We fired the weapon! Update the next shot time

+//-----------------------------------------------------------------------------

+void CAI_ShotRegulator::OnFiredWeapon()

+{

+	--m_nBurstShotsRemaining;

+	if ( m_nBurstShotsRemaining <= 0 )

+	{

+		Reset( false );

+	}

+	else

+	{

+		m_bInRestInterval = false;

+		m_flNextShotTime += random->RandomFloat( m_flMinBurstInterval, m_flMaxBurstInterval );

+		if ( m_flNextShotTime < gpGlobals->curtime )

+		{

+			m_flNextShotTime = gpGlobals->curtime;

+		}

+	}

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CAI_ShotRegulator::EnableShooting( void )

+{

+	m_bDisabled = false;

+}

+

+//-----------------------------------------------------------------------------

+// Purpose: 

+//-----------------------------------------------------------------------------

+void CAI_ShotRegulator::DisableShooting( void )

+{

+	m_bDisabled = true;

+}

+

+

+//-----------------------------------------------------------------------------

+//

+//-----------------------------------------------------------------------------

+

+BEGIN_SIMPLE_DATADESC( CAI_AccelDecay )

+	DEFINE_FIELD( m_velocity,		FIELD_FLOAT ),

+	DEFINE_FIELD( m_maxVelocity,	FIELD_FLOAT ),

+	DEFINE_FIELD( m_minVelocity,	FIELD_FLOAT ),

+	DEFINE_FIELD( m_invDecay,		FIELD_FLOAT ),

+	DEFINE_FIELD( m_decayTime,		FIELD_FLOAT ),

+	DEFINE_FIELD( m_accel,			FIELD_FLOAT ),

+END_DATADESC()

+

+

+void CAI_AccelDecay::SetParameters( float minVelocity, float maxVelocity, float accelPercentPerTick, float decelPercentPerTick )

+{

+	m_minVelocity = minVelocity;

+	m_maxVelocity = maxVelocity;

+

+	m_accel = accelPercentPerTick;

+	m_invDecay = 1.0 - decelPercentPerTick;

+

+	m_decayTime = 0.0;

+	float d = 1.0;

+

+	int i = 0;

+	while (d * m_maxVelocity > m_minVelocity && i < 10)

+	{

+		d = d * m_invDecay;

+		m_decayTime = m_decayTime + 0.1 * d; // appox interval call

+		i++;

+	}

+}

+

+//-----------------------------------------------------------------------------

+//

+//-----------------------------------------------------------------------------

+

+float CAI_AccelDecay::Update( float flCurrent, float flTarget, float flInterval )

+{

+	float delta = flTarget - flCurrent;

+	float deltaSign = ( delta < 0 ) ? -1 : 1;

+	delta = fabsf( delta );

+

+	float curVelocity = m_velocity;

+

+	if ( delta > 0.01 )

+	{

+		if (fabsf( m_velocity ) < m_minVelocity)

+			m_velocity = m_minVelocity * deltaSign;

+

+		if (delta < m_velocity * deltaSign * m_decayTime )

+		{

+			m_velocity = m_velocity * m_invDecay;

+

+			if (delta < m_velocity * deltaSign * flInterval)

+			{

+				m_velocity = delta * deltaSign / flInterval;

+			}

+		}

+		else

+		{

+			m_velocity = m_velocity * (1.0f - m_accel) + m_maxVelocity * m_accel * deltaSign;

+			if (delta < m_velocity * deltaSign * m_decayTime)

+			{

+				m_velocity = delta * deltaSign / m_decayTime;

+			}

+		}

+

+		float newValue = flCurrent + (curVelocity + m_velocity) * 0.5 * flInterval;

+		return newValue;

+	}

+

+	return flTarget;

+}

+

+

+

+void CAI_AccelDecay::ResetVelocity( float flVelocity )

+{

+	m_velocity = flVelocity;

+}

+

+

+void CAI_AccelDecay::SetMaxVelocity( float maxVelocity )

+{

+	if (maxVelocity != m_maxVelocity)

+	{

+		SetParameters( m_minVelocity, maxVelocity, m_accel, 1.0 - m_invDecay );

+	}

+}

+

+//-----------------------------------------------------------------------------

+//-----------------------------------------------------------------------------

+

+ConVar free_pass_peek_debug( "free_pass_peek_debug", "0" );

+

+BEGIN_SIMPLE_DATADESC( AI_FreePassParams_t )

+

+	DEFINE_KEYFIELD( timeToTrigger,			FIELD_FLOAT, "freepass_timetotrigger"),

+	DEFINE_KEYFIELD( duration,				FIELD_FLOAT, "freepass_duration"),

+	DEFINE_KEYFIELD( moveTolerance,			FIELD_FLOAT, "freepass_movetolerance"),

+	DEFINE_KEYFIELD( refillRate,			FIELD_FLOAT, "freepass_refillrate"),

+	DEFINE_FIELD(	 coverDist,				FIELD_FLOAT),

+	DEFINE_KEYFIELD( peekTime,				FIELD_FLOAT, "freepass_peektime"),

+	DEFINE_FIELD(	 peekTimeAfterDamage,	FIELD_FLOAT),

+	DEFINE_FIELD(	 peekEyeDist,			FIELD_FLOAT),

+	DEFINE_FIELD(	 peekEyeDistZ,			FIELD_FLOAT),

+

+END_DATADESC()

+

+BEGIN_SIMPLE_DATADESC( CAI_FreePass )

+

+	DEFINE_FIELD( m_hTarget, FIELD_EHANDLE ),

+	DEFINE_FIELD( m_FreePassTimeRemaining,	FIELD_FLOAT ),

+	DEFINE_EMBEDDED( m_FreePassMoveMonitor ), 

+	DEFINE_EMBEDDED( m_Params ), 

+

+END_DATADESC()

+

+//---------------------------------------------------------

+//---------------------------------------------------------

+

+void CAI_FreePass::Reset( float passTime, float moveTolerance )

+{

+	CBaseEntity *pTarget = GetPassTarget();

+

+	if ( !pTarget || m_Params.duration < 0.1 )

+		return;

+

+	if ( passTime == -1 )

+	{

+		m_FreePassTimeRemaining = m_Params.duration;

+	}

+	else

+	{

+		m_FreePassTimeRemaining = passTime;

+	}

+

+	if ( moveTolerance == -1  )

+	{

+		m_FreePassMoveMonitor.SetMark( pTarget, m_Params.moveTolerance );

+	}

+	else

+	{

+		m_FreePassMoveMonitor.SetMark( pTarget, moveTolerance );

+	}

+}

+

+//---------------------------------------------------------

+//---------------------------------------------------------

+

+void CAI_FreePass::Update( )

+{

+	CBaseEntity *pTarget = GetPassTarget();

+	if ( !pTarget || m_Params.duration < 0.1 )

+		return;

+

+	//---------------------------------

+	//

+	// Free pass logic

+	//

+	AI_EnemyInfo_t *pTargetInfo = GetOuter()->GetEnemies()->Find( pTarget );

+

+	// This works with old data because need to do before base class so as to not choose as enemy

+	if ( !HasPass() )

+	{

+		float timePlayerLastSeen = (pTargetInfo) ? pTargetInfo->timeLastSeen : AI_INVALID_TIME;

+		float lastTimeDamagedBy = (pTargetInfo) ? pTargetInfo->timeLastReceivedDamageFrom : AI_INVALID_TIME;

+

+		if ( timePlayerLastSeen == AI_INVALID_TIME || gpGlobals->curtime - timePlayerLastSeen > .15 ) // If didn't see the player last think

+		{

+			trace_t tr;

+			UTIL_TraceLine( pTarget->EyePosition(), GetOuter()->EyePosition(), MASK_BLOCKLOS, GetOuter(), COLLISION_GROUP_NONE, &tr );

+			if ( tr.fraction != 1.0 && tr.m_pEnt != pTarget )

+			{

+				float dist = (tr.endpos - tr.startpos).Length() * tr.fraction;

+

+				if ( dist < m_Params.coverDist )

+				{

+					if ( ( timePlayerLastSeen == AI_INVALID_TIME || gpGlobals->curtime - timePlayerLastSeen > m_Params.timeToTrigger ) &&

+						 ( lastTimeDamagedBy == AI_INVALID_TIME || gpGlobals->curtime - lastTimeDamagedBy > m_Params.timeToTrigger ) )

+					{

+						m_FreePassTimeRemaining = m_Params.duration;

+						m_FreePassMoveMonitor.SetMark( pTarget, m_Params.moveTolerance );

+					}

+				}

+			}

+		}

+	}

+	else

+	{

+		float temp = m_FreePassTimeRemaining;

+		m_FreePassTimeRemaining = 0;

+		CAI_Senses *pSenses = GetOuter()->GetSenses();

+		bool bCanSee = ( pSenses && pSenses->ShouldSeeEntity( pTarget ) && pSenses->CanSeeEntity( pTarget ) );

+		m_FreePassTimeRemaining = temp;

+

+		if ( bCanSee )

+		{

+			if ( !m_FreePassMoveMonitor.TargetMoved( pTarget ) )

+				m_FreePassTimeRemaining -= 0.1;

+			else

+				Revoke( true );

+		}

+		else

+		{

+			m_FreePassTimeRemaining += 0.1 * m_Params.refillRate;

+			if ( m_FreePassTimeRemaining > m_Params.duration )

+				m_FreePassTimeRemaining = m_Params.duration;

+			m_FreePassMoveMonitor.SetMark( pTarget, m_Params.moveTolerance );

+		}

+	}

+}

+

+//---------------------------------------------------------

+//---------------------------------------------------------

+bool CAI_FreePass::HasPass()

+{

+	return ( m_FreePassTimeRemaining > 0 );

+}

+

+//---------------------------------------------------------

+//---------------------------------------------------------

+void CAI_FreePass::Revoke( bool bUpdateMemory )

+{

+	m_FreePassTimeRemaining = 0;

+	if ( bUpdateMemory && GetPassTarget() )

+	{

+		GetOuter()->UpdateEnemyMemory( GetPassTarget(), GetPassTarget()->GetAbsOrigin() );

+	}

+}

+

+//---------------------------------------------------------

+//---------------------------------------------------------

+bool CAI_FreePass::ShouldAllowFVisible(bool bBaseResult )

+{

+	CBaseEntity *	pTarget 	= GetPassTarget();

+	AI_EnemyInfo_t *pTargetInfo = GetOuter()->GetEnemies()->Find( pTarget );

+	

+	if ( !bBaseResult || HasPass() )

+		return false;

+		

+	bool bIsVisible = true;

+		

+	// Peek logic

+	if ( m_Params.peekTime > 0.1 )

+	{

+		float lastTimeSeen = (pTargetInfo) ? pTargetInfo->timeLastSeen : AI_INVALID_TIME;

+		float lastTimeDamagedBy = (pTargetInfo) ? pTargetInfo->timeLastReceivedDamageFrom : AI_INVALID_TIME;

+		

+		if ( ( lastTimeSeen == AI_INVALID_TIME || gpGlobals->curtime - lastTimeSeen > m_Params.peekTime ) &&

+			 ( lastTimeDamagedBy == AI_INVALID_TIME || gpGlobals->curtime - lastTimeDamagedBy > m_Params.peekTimeAfterDamage ) )

+		{

+			Vector vToTarget;

+

+			VectorSubtract( pTarget->EyePosition(), GetOuter()->EyePosition(), vToTarget );

+			vToTarget.z = 0.0f;

+			VectorNormalize( vToTarget );

+

+			Vector vecRight( -vToTarget.y, vToTarget.x, 0.0f );

+			trace_t	tr;

+

+			UTIL_TraceLine( GetOuter()->EyePosition(), pTarget->EyePosition() + (vecRight * m_Params.peekEyeDist - Vector( 0, 0, m_Params.peekEyeDistZ )), MASK_BLOCKLOS, GetOuter(), COLLISION_GROUP_NONE, &tr );

+			if ( tr.fraction != 1.0 && tr.m_pEnt != pTarget )

+			{

+				if ( free_pass_peek_debug.GetBool() )

+					NDebugOverlay::Line( tr.startpos, tr.endpos - Vector( 0, 0, 2), 0, 255, 0, false, 0.1 );

+				bIsVisible = false;

+			}

+			

+			if ( bIsVisible )

+			{

+				UTIL_TraceLine( GetOuter()->EyePosition(), pTarget->EyePosition() + (-vecRight * m_Params.peekEyeDist - Vector( 0, 0, m_Params.peekEyeDistZ )), MASK_BLOCKLOS, GetOuter(), COLLISION_GROUP_NONE, &tr );

+				if ( tr.fraction != 1.0 && tr.m_pEnt != pTarget )

+				{

+					if ( free_pass_peek_debug.GetBool() )

+						NDebugOverlay::Line( tr.startpos, tr.endpos - Vector( 0, 0, 2), 0, 255, 0, false, 0.1 );

+					bIsVisible = false;

+				}

+			}

+		}

+		

+		if ( bIsVisible && free_pass_peek_debug.GetBool() )

+			NDebugOverlay::Line( GetOuter()->EyePosition(), pTarget->EyePosition() - Vector( 0, 0, 2), 255, 0, 0, false, 0.1 );

+	}

+

+	return bIsVisible;

+}

+

+

+//-----------------------------------------------------------------------------

+//-----------------------------------------------------------------------------

+

+string_t g_iszFuncBrushClassname = NULL_STRING;

+

+//-----------------------------------------------------------------------------

+CTraceFilterNav::CTraceFilterNav( CAI_BaseNPC *pProber, bool bIgnoreTransientEntities, const IServerEntity *passedict, int collisionGroup, bool bAllowPlayerAvoid ) : 

+	CTraceFilterSimple( passedict, collisionGroup ),

+	m_pProber(pProber),

+	m_bIgnoreTransientEntities(bIgnoreTransientEntities),

+	m_bAllowPlayerAvoid(bAllowPlayerAvoid)

+{

+	m_bCheckCollisionTable = g_EntityCollisionHash->IsObjectInHash( pProber );

+}

+

+//-----------------------------------------------------------------------------

+bool CTraceFilterNav::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )

+{

+	IServerEntity *pServerEntity = (IServerEntity*)pHandleEntity;

+	CBaseEntity *pEntity = (CBaseEntity *)pServerEntity;

+

+	if ( m_pProber == pEntity )

+		return false;

+

+	if ( m_pProber->GetMoveProbe()->ShouldBrushBeIgnored( pEntity ) == true )

+		return false;

+

+#ifdef HL1_DLL 

+	if ( ( contentsMask & CONTENTS_MOVEABLE ) == 0 )

+	{

+		if ( pEntity->ClassMatches( "func_pushable" ) )

+			return false;

+	}

+#endif

+

+	if ( m_bIgnoreTransientEntities && (pEntity->IsPlayer() || pEntity->IsNPC() ) )

+		return false;

+

+	//Adrian - If I'm flagged as using the new collision method, then ignore the player when trying

+	//to check if I can get somewhere.

+	if ( m_bAllowPlayerAvoid && m_pProber->ShouldPlayerAvoid() && pEntity->IsPlayer() )

+		return false;

+

+	if ( pEntity->IsNavIgnored() )

+		return false;

+

+	if ( m_bCheckCollisionTable )

+	{

+		if ( g_EntityCollisionHash->IsObjectPairInHash( m_pProber, pEntity ) )

+			return false;

+	}

+

+	if ( m_pProber->ShouldProbeCollideAgainstEntity( pEntity ) == false )

+		return false;

+

+	return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );

+}