|
|
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
|
|
//
|
|
|
|
// Purpose:
|
|
|
|
//
|
|
|
|
//=============================================================================//
|
|
|
|
|
|
|
|
#include "cbase.h"
|
|
|
|
#include "tier1/utllinkedlist.h"
|
|
|
|
#include "bitstring.h"
|
|
|
|
#include "utlvector.h"
|
|
|
|
#include "ai_navigator.h"
|
|
|
|
#include "scripted.h"
|
|
|
|
#include "ai_hint.h"
|
|
|
|
#include "ai_behavior_follow.h"
|
|
|
|
#include "ai_memory.h"
|
|
|
|
#include "ai_squad.h"
|
|
|
|
#include "ai_tacticalservices.h"
|
|
|
|
#include "ndebugoverlay.h"
|
|
|
|
#include "ai_senses.h"
|
|
|
|
|
|
|
|
#ifdef HL2_EPISODIC
|
|
|
|
#include "info_darknessmode_lightsource.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
|
|
ConVar ai_debug_follow( "ai_debug_follow", "0" );
|
|
|
|
ConVar ai_follow_use_points( "ai_follow_use_points", "1" );
|
|
|
|
ConVar ai_follow_use_points_when_moving( "ai_follow_use_points_when_moving", "1" );
|
|
|
|
#define FollowMsg(s) if ( !GetOuter() || !ai_debug_follow.GetBool() ) ; else DevMsg( GetOuter(), "Follow: " s )
|
|
|
|
|
|
|
|
#define WAIT_HINT_MIN_DIST (16*16) // Was: Square(GetHullWidth())
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// Purpose: Formation management
|
|
|
|
//
|
|
|
|
// Right now, this is in a very preliminary sketch state. (toml 03-03-03)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
struct AI_FollowSlot_t;
|
|
|
|
struct AI_FollowFormation_t;
|
|
|
|
struct AI_FollowGroup_t;
|
|
|
|
|
|
|
|
struct AI_Follower_t
|
|
|
|
{
|
|
|
|
AI_Follower_t()
|
|
|
|
{
|
|
|
|
slot = -1;
|
|
|
|
memset( &navInfo, 0, sizeof(navInfo) );
|
|
|
|
pGroup = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
AIHANDLE hFollower;
|
|
|
|
intp slot;
|
|
|
|
AI_FollowNavInfo_t navInfo;
|
|
|
|
AI_FollowGroup_t * pGroup; // backpointer for efficiency
|
|
|
|
};
|
|
|
|
|
|
|
|
struct AI_FollowGroup_t
|
|
|
|
{
|
|
|
|
AI_FollowFormation_t * pFormation;
|
|
|
|
EHANDLE hFollowTarget;
|
|
|
|
CUtlFixedLinkedList<AI_Follower_t> followers;
|
|
|
|
CVarBitVec slotUsage;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
class CAI_FollowManager
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
~CAI_FollowManager()
|
|
|
|
{
|
|
|
|
for ( int i = 0; i < m_groups.Count(); i++ )
|
|
|
|
delete m_groups[i];
|
|
|
|
}
|
|
|
|
|
|
|
|
bool AddFollower( CBaseEntity *pTarget, CAI_BaseNPC *pFollower, AI_Formations_t formation, AI_FollowManagerInfoHandle_t *pHandle );
|
|
|
|
void ChangeFormation( AI_FollowManagerInfoHandle_t &handle, AI_Formations_t formation );
|
|
|
|
void RemoveFollower( AI_FollowManagerInfoHandle_t &handle );
|
|
|
|
bool CalcFollowPosition( AI_FollowManagerInfoHandle_t &handle, AI_FollowNavInfo_t *pNavInfo );
|
|
|
|
|
|
|
|
int CountFollowersInGroup( CAI_BaseNPC *pMember )
|
|
|
|
{
|
|
|
|
AI_FollowGroup_t *pGroup = FindFollowerGroup( pMember );
|
|
|
|
|
|
|
|
if( !pGroup )
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pGroup->followers.Count();
|
|
|
|
}
|
|
|
|
|
|
|
|
int CountFollowers( CBaseEntity *pFollowTarget, string_t iszClassname )
|
|
|
|
{
|
|
|
|
AI_FollowGroup_t *pGroup = FindGroup( pFollowTarget );
|
|
|
|
|
|
|
|
if( !pGroup )
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( iszClassname == NULL_STRING )
|
|
|
|
{
|
|
|
|
return pGroup->followers.Count();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
for ( intp i = pGroup->followers.Head(); i != pGroup->followers.InvalidIndex(); i = pGroup->followers.Next( i ) )
|
|
|
|
{
|
|
|
|
if ( pGroup->followers[i].hFollower && pGroup->followers[i].hFollower->ClassMatches( iszClassname ) )
|
|
|
|
{
|
|
|
|
result++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int GetFollowerSlot( CAI_BaseNPC *pFollower )
|
|
|
|
{
|
|
|
|
AI_FollowGroup_t *pGroup = FindFollowerGroup( pFollower );
|
|
|
|
|
|
|
|
if( !pGroup )
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
intp h = pGroup->followers.Head();
|
|
|
|
|
|
|
|
while( h != pGroup->followers.InvalidIndex() )
|
|
|
|
{
|
|
|
|
AI_Follower_t *it = &pGroup->followers[h];
|
|
|
|
if ( it->hFollower.Get() == pFollower )
|
|
|
|
{
|
|
|
|
return it->slot;
|
|
|
|
}
|
|
|
|
|
|
|
|
h = pGroup->followers.Next( h );
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
bool RedistributeSlots( AI_FollowGroup_t *pGroup );
|
|
|
|
int FindBestSlot( AI_FollowGroup_t *pGroup );
|
|
|
|
void CalculateFieldsFromSlot( AI_FollowSlot_t *pSlot, AI_FollowNavInfo_t *pFollowerInfo );
|
|
|
|
|
|
|
|
AI_FollowGroup_t *FindCreateGroup( CBaseEntity *pTarget, AI_Formations_t formation );
|
|
|
|
AI_FollowGroup_t *FindGroup( CBaseEntity *pTarget );
|
|
|
|
AI_FollowGroup_t *FindFollowerGroup( CBaseEntity *pFollower );
|
|
|
|
void RemoveGroup( AI_FollowGroup_t * );
|
|
|
|
|
|
|
|
//---------------------------------
|
|
|
|
|
|
|
|
CUtlVector<AI_FollowGroup_t *> m_groups;
|
|
|
|
};
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
CAI_FollowManager g_AIFollowManager;
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
int AIGetNumFollowers( CBaseEntity *pEntity, string_t iszClassname )
|
|
|
|
{
|
|
|
|
return g_AIFollowManager.CountFollowers( pEntity, iszClassname );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// CAI_FollowBehavior
|
|
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
BEGIN_SIMPLE_DATADESC( AI_FollowNavInfo_t )
|
|
|
|
DEFINE_FIELD( flags, FIELD_INTEGER ),
|
|
|
|
DEFINE_FIELD( position, FIELD_POSITION_VECTOR ),
|
|
|
|
DEFINE_FIELD( range, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( Zrange, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( tolerance, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( followPointTolerance, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( targetMoveTolerance, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( repathOnRouteTolerance, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( walkTolerance, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( coverTolerance, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( enemyLOSTolerance, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( chaseEnemyTolerance, FIELD_FLOAT ),
|
|
|
|
END_DATADESC();
|
|
|
|
|
|
|
|
BEGIN_SIMPLE_DATADESC( AI_FollowParams_t )
|
|
|
|
DEFINE_FIELD( formation, FIELD_INTEGER ),
|
|
|
|
DEFINE_FIELD( bNormalMemoryDiscard, FIELD_BOOLEAN ),
|
|
|
|
|
|
|
|
END_DATADESC();
|
|
|
|
|
|
|
|
BEGIN_DATADESC( CAI_FollowBehavior )
|
|
|
|
DEFINE_FIELD( m_hFollowTarget, FIELD_EHANDLE ),
|
|
|
|
DEFINE_EMBEDDED( m_FollowNavGoal ),
|
|
|
|
DEFINE_FIELD( m_flTimeUpdatedFollowPosition, FIELD_TIME ),
|
|
|
|
DEFINE_FIELD( m_bFirstFacing, FIELD_BOOLEAN ),
|
|
|
|
DEFINE_FIELD( m_flTimeFollowTargetVisible, FIELD_TIME ),
|
|
|
|
DEFINE_EMBEDDED( m_TargetMonitor ),
|
|
|
|
DEFINE_FIELD( m_bTargetUnreachable, FIELD_BOOLEAN ),
|
|
|
|
DEFINE_FIELD( m_bFollowNavFailed, FIELD_BOOLEAN ),
|
|
|
|
DEFINE_FIELD( m_bMovingToCover, FIELD_BOOLEAN ),
|
|
|
|
DEFINE_FIELD( m_flOriginalEnemyDiscardTime, FIELD_FLOAT ),
|
|
|
|
DEFINE_FIELD( m_SavedDistTooFar, FIELD_FLOAT ),
|
|
|
|
DEFINE_EMBEDDED( m_FollowDelay ),
|
|
|
|
DEFINE_EMBEDDED( m_RepathOnFollowTimer ),
|
|
|
|
DEFINE_CUSTOM_FIELD( m_CurrentFollowActivity, ActivityDataOps() ),
|
|
|
|
DEFINE_EMBEDDED( m_TimeBlockUseWaitPoint ),
|
|
|
|
DEFINE_EMBEDDED( m_TimeCheckForWaitPoint ),
|
|
|
|
DEFINE_FIELD( m_pInterruptWaitPoint, FIELD_CLASSPTR ),
|
|
|
|
DEFINE_EMBEDDED( m_TimeBeforeSpreadFacing ),
|
|
|
|
DEFINE_EMBEDDED( m_TimeNextSpreadFacing ),
|
|
|
|
// m_hFollowManagerInfo (reset on load)
|
|
|
|
DEFINE_EMBEDDED( m_params ),
|
|
|
|
DEFINE_FIELD( m_hFollowGoalEnt, FIELD_EHANDLE ),
|
|
|
|
DEFINE_FIELD( m_nFailedFollowAttempts, FIELD_INTEGER ),
|
|
|
|
DEFINE_FIELD( m_flTimeFailFollowStarted, FIELD_TIME ),
|
|
|
|
DEFINE_FIELD( m_vFollowMoveAnchor, FIELD_POSITION_VECTOR ),
|
|
|
|
END_DATADESC();
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
CAI_FollowBehavior::CAI_FollowBehavior( const AI_FollowParams_t ¶ms )
|
|
|
|
{
|
|
|
|
memset( &m_FollowNavGoal, 0, sizeof( m_FollowNavGoal ) );
|
|
|
|
|
|
|
|
m_FollowDelay.Set( 1.0, 3.0 );
|
|
|
|
m_hFollowManagerInfo.m_pGroup = NULL;
|
|
|
|
m_hFollowManagerInfo.m_hFollower = 0;
|
|
|
|
|
|
|
|
m_TimeBlockUseWaitPoint.Set( 0.5, 1.5 );
|
|
|
|
m_TimeCheckForWaitPoint.Set( 1.0 );
|
|
|
|
m_pInterruptWaitPoint = NULL;
|
|
|
|
|
|
|
|
m_TimeBeforeSpreadFacing.Set( 2.0, 4.0 );
|
|
|
|
m_TimeNextSpreadFacing.Set( 3.0, 12.0 );
|
|
|
|
|
|
|
|
m_params = params;
|
|
|
|
|
|
|
|
NoteSuccessfulFollow();
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
CAI_FollowBehavior::~CAI_FollowBehavior()
|
|
|
|
{
|
|
|
|
Assert( !m_hFollowManagerInfo.m_pGroup );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// Purpose: Draw any text overlays
|
|
|
|
// Input : Previous text offset from the top
|
|
|
|
// Output : Current text offset from the top
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int CAI_FollowBehavior::DrawDebugTextOverlays( int text_offset )
|
|
|
|
{
|
|
|
|
char tempstr[ 512 ];
|
|
|
|
int offset;
|
|
|
|
CBaseEntity * followEnt;
|
|
|
|
|
|
|
|
offset = BaseClass::DrawDebugTextOverlays( text_offset );
|
|
|
|
if ( GetOuter()->m_debugOverlays & OVERLAY_TEXT_BIT )
|
|
|
|
{
|
|
|
|
followEnt = GetFollowTarget();
|
|
|
|
if ( followEnt != NULL )
|
|
|
|
{
|
|
|
|
Q_snprintf( tempstr, sizeof(tempstr), "Follow: (%d) %s (%s)", followEnt->entindex(), followEnt->GetDebugName(), followEnt->GetClassname() );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Q_snprintf( tempstr, sizeof(tempstr), "Follow: NULL" );
|
|
|
|
}
|
|
|
|
GetOuter()->EntityText( offset, tempstr, 0 );
|
|
|
|
offset++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::DrawDebugGeometryOverlays()
|
|
|
|
{
|
|
|
|
if ( GetFollowTarget() )
|
|
|
|
{
|
|
|
|
Vector vecFollowPos = GetGoalPosition();
|
|
|
|
NDebugOverlay::HorzArrow( GetOuter()->GetAbsOrigin(), vecFollowPos, 16.0f, 0, 255, 0, 0, true, 0 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::SetParameters( const AI_FollowParams_t ¶ms )
|
|
|
|
{
|
|
|
|
m_params = params;
|
|
|
|
|
|
|
|
if ( m_hFollowManagerInfo.m_pGroup )
|
|
|
|
{
|
|
|
|
g_AIFollowManager.ChangeFormation( m_hFollowManagerInfo, params.formation );
|
|
|
|
m_flTimeUpdatedFollowPosition = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
CBaseEntity * CAI_FollowBehavior::GetFollowTarget()
|
|
|
|
{
|
|
|
|
return m_hFollowTarget;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
// Returns true if the NPC is actively following a target.
|
|
|
|
bool CAI_FollowBehavior::IsActive( void )
|
|
|
|
{
|
|
|
|
if ( IsRunning() && GetFollowTarget() )
|
|
|
|
{
|
|
|
|
// Only true if we're running a follow schedule
|
|
|
|
return IsCurScheduleFollowSchedule();
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::SetFollowTarget( CBaseEntity *pLeader, bool fFinishCurSchedule )
|
|
|
|
{
|
|
|
|
if ( pLeader == m_hFollowTarget )
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ( !GetOuter()->IsAlive() )
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_flTimeUpdatedFollowPosition = 0;
|
|
|
|
|
|
|
|
if ( m_hFollowTarget )
|
|
|
|
{
|
|
|
|
g_AIFollowManager.RemoveFollower( m_hFollowManagerInfo );
|
|
|
|
m_hFollowTarget = NULL;
|
|
|
|
m_hFollowManagerInfo.m_pGroup = NULL;
|
|
|
|
if ( IsRunning() )
|
|
|
|
{
|
|
|
|
if ( GetNavigator()->GetGoalType() == GOALTYPE_TARGETENT )
|
|
|
|
{
|
|
|
|
GetNavigator()->StopMoving(); // Stop him from walking toward the player
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( GetEnemy() != NULL )
|
|
|
|
{
|
|
|
|
GetOuter()->SetIdealState( NPC_STATE_COMBAT );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( pLeader )
|
|
|
|
{
|
|
|
|
if ( g_AIFollowManager.AddFollower( pLeader, GetOuter(), m_params.formation, &m_hFollowManagerInfo ) )
|
|
|
|
{
|
|
|
|
m_hFollowTarget = pLeader;
|
|
|
|
m_bFirstFacing = true;
|
|
|
|
m_flTimeFollowTargetVisible = 0;
|
|
|
|
SetCondition( COND_TARGET_MOVED_FROM_MARK );
|
|
|
|
m_TargetMonitor.ClearMark();
|
|
|
|
NoteSuccessfulFollow();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NotifyChangeBehaviorStatus(fFinishCurSchedule);
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
void CAI_FollowBehavior::SetFollowGoalDirect( CAI_FollowGoal *pGoal )
|
|
|
|
{
|
|
|
|
m_hFollowGoalEnt = pGoal;
|
|
|
|
m_flTimeUpdatedFollowPosition = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::SetFollowGoal( CAI_FollowGoal *pGoal, bool fFinishCurSchedule )
|
|
|
|
{
|
|
|
|
if ( GetOuter()->ShouldAcceptGoal( this, pGoal ) )
|
|
|
|
{
|
|
|
|
GetOuter()->ClearCommandGoal();
|
|
|
|
|
|
|
|
if( hl2_episodic.GetBool() )
|
|
|
|
{
|
|
|
|
// Poke the NPC to interrupt any stubborn schedules
|
|
|
|
GetOuter()->SetCondition(COND_PROVOKED);
|
|
|
|
}
|
|
|
|
|
|
|
|
SetFollowTarget( pGoal->GetGoalEntity() );
|
|
|
|
Assert( pGoal->m_iFormation == AIF_SIMPLE || pGoal->m_iFormation == AIF_WIDE || pGoal->m_iFormation == AIF_MEDIUM || pGoal->m_iFormation == AIF_SIDEKICK || pGoal->m_iFormation == AIF_VORTIGAUNT );
|
|
|
|
SetParameters( AI_FollowParams_t( (AI_Formations_t)pGoal->m_iFormation ) );
|
|
|
|
m_hFollowGoalEnt = pGoal;
|
|
|
|
m_flTimeUpdatedFollowPosition = 0;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::ClearFollowGoal( CAI_FollowGoal *pGoal )
|
|
|
|
{
|
|
|
|
GetOuter()->OnClearGoal( this, pGoal );
|
|
|
|
if ( pGoal == m_hFollowGoalEnt )
|
|
|
|
{
|
|
|
|
SetFollowTarget( NULL );
|
|
|
|
m_hFollowGoalEnt = NULL;
|
|
|
|
m_flTimeUpdatedFollowPosition = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::UpdateFollowPosition()
|
|
|
|
{
|
|
|
|
AI_PROFILE_SCOPE( CAI_FollowBehavior_UpdateFollowPosition );
|
|
|
|
|
|
|
|
if ( m_flTimeUpdatedFollowPosition == gpGlobals->curtime )
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_hFollowTarget == NULL)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ( !g_AIFollowManager.CalcFollowPosition( m_hFollowManagerInfo, &m_FollowNavGoal ) )
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
CBaseEntity *pFollowTarget = GetFollowTarget();
|
|
|
|
|
|
|
|
if ( pFollowTarget->GetParent() )
|
|
|
|
{
|
|
|
|
if ( pFollowTarget->GetParent()->GetServerVehicle() )
|
|
|
|
{
|
|
|
|
m_FollowNavGoal.targetMoveTolerance *= 1.5;
|
|
|
|
m_FollowNavGoal.range += pFollowTarget->GetParent()->BoundingRadius() * 0.333;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if TODO
|
|
|
|
// @TODO (toml 07-27-03): this is too simplistic. fails when the new point is an inappropriate target
|
|
|
|
CBasePlayer *pPlayer = dynamic_cast<CBasePlayer *>(m_hFollowTarget.Get());
|
|
|
|
Vector targetVelocity = pPlayer->GetSmoothedVelocity();
|
|
|
|
m_FollowNavGoal.position += targetVelocity * 0.5;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
m_flTimeUpdatedFollowPosition = gpGlobals->curtime;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::IsMovingToFollowTarget()
|
|
|
|
{
|
|
|
|
return ( IsRunning() && ( IsCurSchedule(SCHED_FOLLOW, false) || IsCurSchedule(SCHED_FOLLOWER_GO_TO_WAIT_POINT, false) ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::CanSelectSchedule()
|
|
|
|
{
|
|
|
|
if ( !GetOuter()->IsInterruptable() )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ( !ShouldFollow() )
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::PlayerIsPushing()
|
|
|
|
{
|
|
|
|
return (m_hFollowTarget && m_hFollowTarget->IsPlayer() && HasCondition( COND_PLAYER_PUSHING ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::IsFollowTargetInRange( float rangeMultiplier )
|
|
|
|
{
|
|
|
|
if ( !GetFollowTarget()->IsPlayer() && HasCondition( COND_RECEIVED_ORDERS ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if( GetNpcState() == NPC_STATE_COMBAT )
|
|
|
|
{
|
|
|
|
if( IsFollowGoalInRange( MAX( m_FollowNavGoal.coverTolerance, m_FollowNavGoal.enemyLOSTolerance ) * rangeMultiplier, GetGoalZRange(), GetGoalFlags() ) )
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if( IsFollowGoalInRange( MAX( m_FollowNavGoal.tolerance, GetGoalRange() ) * rangeMultiplier, GetGoalZRange(), GetGoalFlags() ) )
|
|
|
|
{
|
|
|
|
if ( m_FollowNavGoal.flags & AIFF_REQUIRE_LOS_OUTSIDE_COMBAT )
|
|
|
|
{
|
|
|
|
//trace_t tr;
|
|
|
|
//AI_TraceLOS( vecStart, vecStart + vecDir * 8192, m_hFollowTarget, &tr );
|
|
|
|
//if ( AI_TraceLOS m_FollowNavGoal.position
|
|
|
|
if ( !HasCondition(COND_SEE_PLAYER) )
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::IsFollowGoalInRange( float tolerance, float zTolerance, int flags )
|
|
|
|
{
|
|
|
|
const Vector &origin = WorldSpaceCenter();
|
|
|
|
const Vector &goal = GetGoalPosition();
|
|
|
|
if ( zTolerance == -1 )
|
|
|
|
zTolerance = GetHullHeight();
|
|
|
|
float distanceSq = ( goal.AsVector2D() - origin.AsVector2D() ).LengthSqr();
|
|
|
|
tolerance += 0.1;
|
|
|
|
|
|
|
|
// Increase Z tolerance slightly as XY distance decreases
|
|
|
|
float flToleranceSq = (tolerance*tolerance);
|
|
|
|
float flIncreaseRange = flToleranceSq * 0.25;
|
|
|
|
zTolerance += zTolerance * clamp((distanceSq / flIncreaseRange), 0.f, 1.f );
|
|
|
|
if ( fabs( origin.z - goal.z ) > zTolerance )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ( distanceSq > flToleranceSq )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ( flags & AIFF_REQUIRE_LOS_OUTSIDE_COMBAT && m_hFollowTarget.Get() )
|
|
|
|
{
|
|
|
|
if ( !GetOuter()->GetSenses()->DidSeeEntity( m_hFollowTarget ) )
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::IsChaseGoalInRange()
|
|
|
|
{
|
|
|
|
if ( GetEnemy() && ( GetEnemy()->WorldSpaceCenter() - m_FollowNavGoal.position ).LengthSqr() > Square( m_FollowNavGoal.chaseEnemyTolerance ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::NoteFailedFollow()
|
|
|
|
{
|
|
|
|
m_nFailedFollowAttempts++;
|
|
|
|
if ( m_flTimeFailFollowStarted == FLT_MAX )
|
|
|
|
m_flTimeFailFollowStarted = gpGlobals->curtime;
|
|
|
|
|
|
|
|
if ( GetOuter() && ai_debug_follow.GetBool() )
|
|
|
|
DevMsg( GetOuter(), "Follow: NoteFailedFollow() (%d, %f)\n", m_nFailedFollowAttempts, m_flTimeFailFollowStarted );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::NoteSuccessfulFollow()
|
|
|
|
{
|
|
|
|
m_nFailedFollowAttempts = 0;
|
|
|
|
m_flTimeFailFollowStarted = FLT_MAX;
|
|
|
|
FollowMsg( "NoteSuccessfulFollow()\n" );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::BeginScheduleSelection()
|
|
|
|
{
|
|
|
|
if ( GetOuter()->m_hCine )
|
|
|
|
GetOuter()->m_hCine->CancelScript();
|
|
|
|
|
|
|
|
m_TimeBeforeSpreadFacing.Reset();
|
|
|
|
|
|
|
|
SetCondition( COND_TARGET_MOVED_FROM_MARK );
|
|
|
|
m_TargetMonitor.ClearMark();
|
|
|
|
NoteSuccessfulFollow();
|
|
|
|
|
|
|
|
if ( !m_params.bNormalMemoryDiscard )
|
|
|
|
{
|
|
|
|
// Forget about enemies that I haven't seen for >5 seconds
|
|
|
|
m_flOriginalEnemyDiscardTime = GetOuter()->GetEnemies()->GetEnemyDiscardTime();
|
|
|
|
GetOuter()->GetEnemies()->SetEnemyDiscardTime( 5.0f );
|
|
|
|
}
|
|
|
|
|
|
|
|
m_SavedDistTooFar = GetOuter()->m_flDistTooFar;
|
|
|
|
if ( GetFollowTarget() && GetFollowTarget()->IsPlayer() )
|
|
|
|
{
|
|
|
|
GetOuter()->m_flDistTooFar = FLT_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
BaseClass::BeginScheduleSelection();
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::EndScheduleSelection()
|
|
|
|
{
|
|
|
|
if ( !m_params.bNormalMemoryDiscard )
|
|
|
|
{
|
|
|
|
// Restore our original enemy discard time
|
|
|
|
GetOuter()->GetEnemies()->SetEnemyDiscardTime( m_flOriginalEnemyDiscardTime );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( m_SavedDistTooFar > 0.1 ) // backward savefile compatability
|
|
|
|
{
|
|
|
|
GetOuter()->m_flDistTooFar = m_SavedDistTooFar;
|
|
|
|
}
|
|
|
|
|
|
|
|
BaseClass::EndScheduleSelection();
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::CleanupOnDeath( CBaseEntity *pCulprit, bool bFireDeathOutput )
|
|
|
|
{
|
|
|
|
if ( m_hFollowManagerInfo.m_pGroup )
|
|
|
|
{
|
|
|
|
g_AIFollowManager.RemoveFollower( m_hFollowManagerInfo );
|
|
|
|
m_hFollowManagerInfo.m_pGroup = NULL;
|
|
|
|
m_hFollowTarget = NULL;
|
|
|
|
}
|
|
|
|
BaseClass::CleanupOnDeath( pCulprit, bFireDeathOutput );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::Precache()
|
|
|
|
{
|
|
|
|
if ( m_hFollowTarget != NULL && m_hFollowManagerInfo.m_pGroup == NULL )
|
|
|
|
{
|
|
|
|
// Post load fixup
|
|
|
|
if ( !g_AIFollowManager.AddFollower( m_hFollowTarget, GetOuter(), m_params.formation, &m_hFollowManagerInfo ) )
|
|
|
|
{
|
|
|
|
m_hFollowTarget = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::GatherConditions( void )
|
|
|
|
{
|
|
|
|
BaseClass::GatherConditions();
|
|
|
|
|
|
|
|
if ( !GetFollowTarget() )
|
|
|
|
{
|
|
|
|
ClearCondition( COND_FOLLOW_PLAYER_IS_LIT );
|
|
|
|
ClearCondition( COND_FOLLOW_PLAYER_IS_NOT_LIT );
|
|
|
|
ClearCondition( COND_FOLLOW_TARGET_VISIBLE );
|
|
|
|
ClearCondition( COND_FOLLOW_TARGET_NOT_VISIBLE );
|
|
|
|
ClearCondition( COND_FOLLOW_DELAY_EXPIRED );
|
|
|
|
ClearCondition( COND_TARGET_MOVED_FROM_MARK );
|
|
|
|
ClearFollowPoint();
|
|
|
|
m_pInterruptWaitPoint = NULL;
|
|
|
|
m_bTargetUnreachable = false;
|
|
|
|
m_flTimeFollowTargetVisible = 0;
|
|
|
|
|
|
|
|
if ( IsRunning() )
|
|
|
|
{
|
|
|
|
GetOuter()->ClearSchedule( "Follow target gone" );
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !m_TargetMonitor.IsMarkSet() )
|
|
|
|
{
|
|
|
|
FollowMsg( "No mark set\n" );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( m_FollowDelay.IsRunning() && m_FollowDelay.Expired())
|
|
|
|
{
|
|
|
|
SetCondition( COND_FOLLOW_DELAY_EXPIRED );
|
|
|
|
m_FollowDelay.Stop();
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( m_TargetMonitor.TargetMoved2D( GetFollowTarget() ) )
|
|
|
|
{
|
|
|
|
FollowMsg( "Target moved\n" );
|
|
|
|
m_TargetMonitor.ClearMark();
|
|
|
|
SetCondition( COND_TARGET_MOVED_FROM_MARK );
|
|
|
|
m_bTargetUnreachable = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !m_TargetMonitor.IsMarkSet() )
|
|
|
|
m_bTargetUnreachable = false;
|
|
|
|
|
|
|
|
m_pInterruptWaitPoint = NULL;
|
|
|
|
|
|
|
|
if ( GetHintNode() == NULL )
|
|
|
|
{
|
|
|
|
if ( ShouldUseFollowPoints() && m_TimeBlockUseWaitPoint.Expired() && m_TimeCheckForWaitPoint.Expired() )
|
|
|
|
{
|
|
|
|
m_TimeCheckForWaitPoint.Reset();
|
|
|
|
m_pInterruptWaitPoint = FindFollowPoint();
|
|
|
|
if ( m_pInterruptWaitPoint )
|
|
|
|
SetCondition( COND_FOUND_WAIT_POINT );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( m_flTimeUpdatedFollowPosition == 0 || gpGlobals->curtime - m_flTimeUpdatedFollowPosition > 2.0 )
|
|
|
|
UpdateFollowPosition();
|
|
|
|
|
|
|
|
if ( IsFollowTargetInRange() )
|
|
|
|
{
|
|
|
|
NoteSuccessfulFollow();
|
|
|
|
}
|
|
|
|
else if ( GetOuter()->GetTask() && !IsCurScheduleFollowSchedule() )
|
|
|
|
{
|
|
|
|
if ( !m_FollowDelay.IsRunning() || m_FollowDelay.Expired() )
|
|
|
|
{
|
|
|
|
switch ( GetOuter()->GetTask()->iTask )
|
|
|
|
{
|
|
|
|
case TASK_WAIT_RANDOM:
|
|
|
|
case TASK_WAIT_INDEFINITE:
|
|
|
|
case TASK_WAIT:
|
|
|
|
case TASK_WAIT_FACE_ENEMY:
|
|
|
|
case TASK_WAIT_FACE_ENEMY_RANDOM:
|
|
|
|
{
|
|
|
|
m_TargetMonitor.ClearMark();
|
|
|
|
if ( !HasCondition(COND_FOLLOW_PLAYER_IS_NOT_LIT) )
|
|
|
|
{
|
|
|
|
SetCondition( COND_TARGET_MOVED_FROM_MARK );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
else if ( !IsFollowPointInRange() )
|
|
|
|
{
|
|
|
|
GetHintNode()->Unlock();
|
|
|
|
SetHintNode( NULL );
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HL2_EPISODIC
|
|
|
|
// Let followers know if the player is lit in the darkness
|
|
|
|
if ( GetFollowTarget()->IsPlayer() && HL2GameRules()->IsAlyxInDarknessMode() )
|
|
|
|
{
|
|
|
|
if ( LookerCouldSeeTargetInDarkness( GetOuter(), GetFollowTarget() ) )
|
|
|
|
{
|
|
|
|
SetCondition( COND_FOLLOW_PLAYER_IS_LIT );
|
|
|
|
ClearCondition( COND_FOLLOW_PLAYER_IS_NOT_LIT );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
SetCondition( COND_FOLLOW_PLAYER_IS_NOT_LIT );
|
|
|
|
ClearCondition( COND_FOLLOW_PLAYER_IS_LIT );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Set our follow target visibility state
|
|
|
|
if ( (GetFollowTarget()->IsPlayer() && HasCondition( COND_SEE_PLAYER )) || GetOuter()->FVisible( GetFollowTarget()) )
|
|
|
|
{
|
|
|
|
SetCondition( COND_FOLLOW_TARGET_VISIBLE );
|
|
|
|
ClearCondition( COND_FOLLOW_TARGET_NOT_VISIBLE );
|
|
|
|
m_flTimeFollowTargetVisible = gpGlobals->curtime;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ClearCondition( COND_FOLLOW_TARGET_VISIBLE );
|
|
|
|
SetCondition( COND_FOLLOW_TARGET_NOT_VISIBLE );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( HasFollowPoint() && ( m_flTimeFollowTargetVisible != 0 && gpGlobals->curtime - m_flTimeFollowTargetVisible > 5.0 ) )
|
|
|
|
SetCondition( COND_FOLLOW_WAIT_POINT_INVALID );
|
|
|
|
else
|
|
|
|
ClearCondition( COND_FOLLOW_WAIT_POINT_INVALID );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
int CAI_FollowBehavior::SelectFailSchedule( int failedSchedule, int failedTask, AI_TaskFailureCode_t taskFailCode )
|
|
|
|
{
|
|
|
|
if ( failedTask == TASK_MOVE_TO_FOLLOW_POSITION || failedTask == TASK_GET_PATH_TO_FOLLOW_POSITION )
|
|
|
|
{
|
|
|
|
if ( m_hFollowTarget )
|
|
|
|
{
|
|
|
|
m_TargetMonitor.SetMark( m_hFollowTarget, m_FollowNavGoal.targetMoveTolerance * 0.5 );
|
|
|
|
m_FollowDelay.Start();
|
|
|
|
NoteFailedFollow();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return BaseClass::SelectFailSchedule( failedSchedule, failedTask, taskFailCode );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::ShouldFollow()
|
|
|
|
{
|
|
|
|
if ( !GetFollowTarget() )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if ( GetFollowTarget()->GetFlags() & FL_NOTARGET )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If we recently failed to build a follow path, wait a while to
|
|
|
|
// give other schedules a chance to run.
|
|
|
|
if ( m_bFollowNavFailed && m_FollowDelay.IsRunning() && !m_FollowDelay.Expired() )
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_bFollowNavFailed = false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::ShouldMoveToFollowTarget()
|
|
|
|
{
|
|
|
|
if ( GetFollowTarget() == NULL )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if( m_bTargetUnreachable )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
#ifdef HL2_EPISODIC
|
|
|
|
if ( HL2GameRules()->IsAlyxInDarknessMode() )
|
|
|
|
{
|
|
|
|
// If we're in darkness mode, the player needs to be lit by
|
|
|
|
// darkness, but we don't need line of sight to him.
|
|
|
|
if ( HasCondition(COND_FOLLOW_PLAYER_IS_NOT_LIT) )
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if ( HasFollowPoint() )
|
|
|
|
{
|
|
|
|
if ( IsFollowPointInRange() )
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else if ( IsFollowTargetInRange() )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if( m_FollowDelay.IsRunning() && !m_FollowDelay.Expired() && !HasCondition( COND_TARGET_MOVED_FROM_MARK ) )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
int CAI_FollowBehavior::SelectScheduleManagePosition()
|
|
|
|
{
|
|
|
|
if ( PlayerIsPushing() )
|
|
|
|
return SCHED_MOVE_AWAY;
|
|
|
|
|
|
|
|
if ( !UpdateFollowPosition() )
|
|
|
|
return SCHED_FAIL;
|
|
|
|
|
|
|
|
return SCHED_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::ShouldUseFollowPoints()
|
|
|
|
{
|
|
|
|
if ( !ai_follow_use_points.GetBool() || GetEnemy() != NULL )
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::HasFollowPoint()
|
|
|
|
{
|
|
|
|
return ( GetHintNode() && GetHintNode()->HintType() == HINT_FOLLOW_WAIT_POINT );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::ClearFollowPoint()
|
|
|
|
{
|
|
|
|
if ( GetHintNode() && GetHintNode()->HintType() == HINT_FOLLOW_WAIT_POINT )
|
|
|
|
{
|
|
|
|
GetHintNode()->Unlock();
|
|
|
|
SetHintNode( NULL );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
const Vector &CAI_FollowBehavior::GetFollowPoint()
|
|
|
|
{
|
|
|
|
static Vector invalid = vec3_invalid;
|
|
|
|
if ( GetHintNode() && GetHintNode()->HintType() == HINT_FOLLOW_WAIT_POINT )
|
|
|
|
return GetHintNode()->GetAbsOrigin();
|
|
|
|
return invalid;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
CAI_Hint *CAI_FollowBehavior::FindFollowPoint()
|
|
|
|
{
|
|
|
|
if ( !m_TimeBlockUseWaitPoint.Expired() )
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
CHintCriteria hintCriteria;
|
|
|
|
hintCriteria.SetHintType( HINT_FOLLOW_WAIT_POINT );
|
|
|
|
hintCriteria.SetFlag( bits_HINT_NODE_VISIBLE | bits_HINT_NODE_NEAREST );
|
|
|
|
|
|
|
|
// Add the search position
|
|
|
|
hintCriteria.AddIncludePosition( GetGoalPosition(), MAX( m_FollowNavGoal.followPointTolerance, GetGoalRange() ) );
|
|
|
|
hintCriteria.AddExcludePosition( GetGoalPosition(), (GetFollowTarget()->WorldAlignMins().AsVector2D() - GetFollowTarget()->WorldAlignMaxs().AsVector2D()).Length());
|
|
|
|
|
|
|
|
return CAI_HintManager::FindHint( GetOuter(), hintCriteria );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::IsFollowPointInRange()
|
|
|
|
{
|
|
|
|
return ( GetHintNode() &&
|
|
|
|
GetHintNode()->HintType() == HINT_FOLLOW_WAIT_POINT &&
|
|
|
|
(GetHintNode()->GetAbsOrigin() - GetFollowTarget()->GetAbsOrigin()).LengthSqr() < Square(MAX(m_FollowNavGoal.followPointTolerance, GetGoalRange())) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::ShouldIgnoreFollowPointFacing()
|
|
|
|
{
|
|
|
|
if ( !GetHintNode() )
|
|
|
|
return true;
|
|
|
|
|
|
|
|
HintIgnoreFacing_t hintSetting = GetHintNode()->GetIgnoreFacing();
|
|
|
|
|
|
|
|
if ( hintSetting == HIF_DEFAULT )
|
|
|
|
return ( GetHintNode()->HintActivityName() == NULL_STRING );
|
|
|
|
|
|
|
|
return ( hintSetting == HIF_YES );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::SetFollowPoint( CAI_Hint *pHintNode )
|
|
|
|
{
|
|
|
|
if ( !pHintNode )
|
|
|
|
return;
|
|
|
|
|
|
|
|
Assert( pHintNode->HintType() == HINT_FOLLOW_WAIT_POINT );
|
|
|
|
|
|
|
|
if ( GetHintNode() == pHintNode )
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ( GetHintNode() )
|
|
|
|
GetHintNode()->Unlock();
|
|
|
|
|
|
|
|
if ( !pHintNode->Lock( GetOuter() ) )
|
|
|
|
{
|
|
|
|
SetHintNode( NULL );
|
|
|
|
m_TimeBlockUseWaitPoint.Reset();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
SetHintNode( pHintNode );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
int CAI_FollowBehavior::SelectScheduleFollowPoints()
|
|
|
|
{
|
|
|
|
bool bShouldUseFollowPoints = ( ShouldUseFollowPoints() && IsFollowGoalInRange( m_FollowNavGoal.followPointTolerance + 0.1, GetGoalZRange(), GetGoalFlags() ) );
|
|
|
|
float distSqToPoint = FLT_MAX;
|
|
|
|
bool bHasFollowPoint = HasFollowPoint();
|
|
|
|
|
|
|
|
if ( bHasFollowPoint )
|
|
|
|
{
|
|
|
|
distSqToPoint = (GetHintNode()->GetAbsOrigin() - GetAbsOrigin()).LengthSqr();
|
|
|
|
if ( !bShouldUseFollowPoints ||
|
|
|
|
distSqToPoint > Square(2.0 * GetHullWidth()) ||
|
|
|
|
HasCondition( COND_FOLLOW_WAIT_POINT_INVALID ) )
|
|
|
|
{
|
|
|
|
GetHintNode()->Unlock();
|
|
|
|
SetHintNode( NULL );
|
|
|
|
m_TimeBlockUseWaitPoint.Reset();
|
|
|
|
bShouldUseFollowPoints = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( bShouldUseFollowPoints )
|
|
|
|
{
|
|
|
|
bool bNewHint = false;
|
|
|
|
if ( GetHintNode() && !bHasFollowPoint )
|
|
|
|
{
|
|
|
|
GetHintNode()->Unlock();
|
|
|
|
SetHintNode( NULL );
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!GetHintNode())
|
|
|
|
{
|
|
|
|
bNewHint = true;
|
|
|
|
SetFollowPoint( ( m_pInterruptWaitPoint ) ? m_pInterruptWaitPoint : FindFollowPoint() );
|
|
|
|
|
|
|
|
if ( GetHintNode() )
|
|
|
|
distSqToPoint = (GetHintNode()->GetAbsOrigin() - GetAbsOrigin()).LengthSqr();
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( GetHintNode() )
|
|
|
|
{
|
|
|
|
if ( bNewHint || distSqToPoint > WAIT_HINT_MIN_DIST )
|
|
|
|
return SCHED_FOLLOWER_GO_TO_WAIT_POINT;
|
|
|
|
if ( !ShouldIgnoreFollowPointFacing() )
|
|
|
|
return SCHED_FOLLOWER_STAND_AT_WAIT_POINT;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ClearFollowPoint();
|
|
|
|
|
|
|
|
return SCHED_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
int CAI_FollowBehavior::SelectScheduleMoveToFormation()
|
|
|
|
{
|
|
|
|
if( ( GetNpcState() != NPC_STATE_COMBAT && !( HasCondition( COND_LIGHT_DAMAGE ) || HasCondition( COND_HEAVY_DAMAGE ))) ||
|
|
|
|
!IsFollowGoalInRange( GetGoalRange(), GetGoalZRange(), GetGoalFlags() ) )
|
|
|
|
{
|
|
|
|
AISquadIter_t iter;
|
|
|
|
CAI_Squad *pSquad = GetOuter()->GetSquad();
|
|
|
|
if ( pSquad )
|
|
|
|
{
|
|
|
|
for ( CAI_BaseNPC *pSquadMember = pSquad->GetFirstMember( &iter ); pSquadMember; pSquadMember = pSquad->GetNextMember( &iter ) )
|
|
|
|
{
|
|
|
|
if ( pSquadMember->HasCondition( COND_PLAYER_PUSHING ) )
|
|
|
|
{
|
|
|
|
return SCHED_NONE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( ShouldMoveToFollowTarget() || m_bFirstFacing )
|
|
|
|
{
|
|
|
|
return SCHED_TARGET_FACE; // Code for "SCHED_MOVE_TO_FACE_FOLLOW_TARGET". Used by Talker clients to interject comment
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return SCHED_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
int CAI_FollowBehavior::SelectSchedule()
|
|
|
|
{
|
|
|
|
// Allow a range attack if we need to do it
|
|
|
|
if ( hl2_episodic.GetBool() )
|
|
|
|
{
|
|
|
|
// Range attack
|
|
|
|
if ( GetOuter()->ShouldMoveAndShoot() == false && HasCondition( COND_CAN_RANGE_ATTACK1 ) )
|
|
|
|
return SCHED_RANGE_ATTACK1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( GetFollowTarget() )
|
|
|
|
{
|
|
|
|
if ( !GetFollowTarget()->IsAlive() )
|
|
|
|
{
|
|
|
|
// UNDONE: Comment about the recently dead player here?
|
|
|
|
SetFollowTarget( NULL );
|
|
|
|
}
|
|
|
|
else if ( ShouldFollow() )
|
|
|
|
{
|
|
|
|
int result = SCHED_NONE;
|
|
|
|
|
|
|
|
result = SelectScheduleManagePosition();
|
|
|
|
if ( result != SCHED_NONE )
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = SelectScheduleFollowPoints();
|
|
|
|
if ( result != SCHED_NONE )
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = SelectScheduleMoveToFormation();
|
|
|
|
if ( result != SCHED_NONE )
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if ( HasCondition ( COND_NO_PRIMARY_AMMO ) && HaveSequenceForActivity( GetOuter()->TranslateActivity( ACT_RUN_AIM ) ) )
|
|
|
|
return SCHED_HIDE_AND_RELOAD;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( PlayerIsPushing() )
|
|
|
|
return SCHED_MOVE_AWAY;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Should not have landed here. Follow target ent must have been destroyed
|
|
|
|
NotifyChangeBehaviorStatus();
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( HasCondition( COND_TARGET_MOVED_FROM_MARK ) )
|
|
|
|
{
|
|
|
|
m_TargetMonitor.SetMark( m_hFollowTarget, m_FollowNavGoal.targetMoveTolerance * 0.5 );
|
|
|
|
}
|
|
|
|
|
|
|
|
return FollowCallBaseSelectSchedule();
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
int CAI_FollowBehavior::TranslateSchedule( int scheduleType )
|
|
|
|
{
|
|
|
|
switch( scheduleType )
|
|
|
|
{
|
|
|
|
case SCHED_FOLLOWER_IDLE_STAND:
|
|
|
|
// If we have an enemy, at least face them!
|
|
|
|
if ( GetEnemy() )
|
|
|
|
return SCHED_FOLLOWER_COMBAT_FACE;
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SCHED_IDLE_STAND:
|
|
|
|
{
|
|
|
|
if ( ShouldMoveToFollowTarget() && !IsFollowGoalInRange( GetGoalRange(), GetGoalZRange(), GetGoalFlags() ) )
|
|
|
|
{
|
|
|
|
return SCHED_MOVE_TO_FACE_FOLLOW_TARGET;
|
|
|
|
}
|
|
|
|
if ( HasFollowPoint() && !ShouldIgnoreFollowPointFacing() )
|
|
|
|
return SCHED_FOLLOWER_GO_TO_WAIT_POINT;
|
|
|
|
|
|
|
|
// If we have an enemy, at least face them!
|
|
|
|
if ( GetEnemy() )
|
|
|
|
return SCHED_FOLLOWER_COMBAT_FACE;
|
|
|
|
|
|
|
|
return SCHED_FOLLOWER_IDLE_STAND;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SCHED_COMBAT_STAND:
|
|
|
|
case SCHED_ALERT_STAND:
|
|
|
|
{
|
|
|
|
if ( ShouldMoveToFollowTarget() && !IsFollowGoalInRange( GetGoalRange(), GetGoalZRange(), GetGoalFlags() ) )
|
|
|
|
{
|
|
|
|
return SCHED_MOVE_TO_FACE_FOLLOW_TARGET;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SCHED_TARGET_FACE:
|
|
|
|
{
|
|
|
|
if ( ( ShouldMoveToFollowTarget() || m_bFirstFacing ) && !IsFollowGoalInRange( GetGoalRange(), GetGoalZRange(), GetGoalFlags() ) )
|
|
|
|
{
|
|
|
|
return SCHED_MOVE_TO_FACE_FOLLOW_TARGET;
|
|
|
|
}
|
|
|
|
if ( HasFollowPoint() && !ShouldIgnoreFollowPointFacing() )
|
|
|
|
return SCHED_FOLLOWER_GO_TO_WAIT_POINT;
|
|
|
|
if ( !m_TargetMonitor.IsMarkSet() )
|
|
|
|
m_TargetMonitor.SetMark( m_hFollowTarget, m_FollowNavGoal.targetMoveTolerance );
|
|
|
|
return SCHED_FACE_FOLLOW_TARGET; // @TODO (toml 03-03-03): should select a facing sched
|
|
|
|
}
|
|
|
|
|
|
|
|
case SCHED_TARGET_CHASE:
|
|
|
|
{
|
|
|
|
return SCHED_FOLLOW;
|
|
|
|
}
|
|
|
|
|
|
|
|
// SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK just tells the NPC to chase their enemy, so
|
|
|
|
// forbid this unless the destination is acceptable within the parameters of the follow behavior.
|
|
|
|
case SCHED_CHASE_ENEMY:
|
|
|
|
case SCHED_ESTABLISH_LINE_OF_FIRE_FALLBACK:
|
|
|
|
{
|
|
|
|
if ( IsChaseGoalInRange() == false )
|
|
|
|
return SCHED_FOLLOWER_IDLE_STAND;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SCHED_RANGE_ATTACK1:
|
|
|
|
{
|
|
|
|
if ( GetOuter()->GetShotRegulator()->IsInRestInterval() )
|
|
|
|
{
|
|
|
|
if ( GetEnemy() )
|
|
|
|
return SCHED_FOLLOWER_COMBAT_FACE;
|
|
|
|
|
|
|
|
return SCHED_FOLLOWER_IDLE_STAND; // @TODO (toml 07-02-03): Should do something more tactically sensible
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SCHED_CHASE_ENEMY_FAILED:
|
|
|
|
{
|
|
|
|
if (HasMemory(bits_MEMORY_INCOVER))
|
|
|
|
{
|
|
|
|
// Make sure I don't get too far from the player
|
|
|
|
if ( GetFollowTarget() )
|
|
|
|
{
|
|
|
|
float fDist = (GetLocalOrigin() - GetFollowTarget()->GetAbsOrigin()).Length();
|
|
|
|
if (fDist > 500)
|
|
|
|
{
|
|
|
|
return SCHED_FOLLOW;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case SCHED_MOVE_AWAY_FAIL:
|
|
|
|
{
|
|
|
|
return SCHED_FOLLOWER_MOVE_AWAY_FAIL;
|
|
|
|
}
|
|
|
|
case SCHED_MOVE_AWAY_END:
|
|
|
|
{
|
|
|
|
return SCHED_FOLLOWER_MOVE_AWAY_END;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return BaseClass::TranslateSchedule( scheduleType );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::OnStartSchedule( int scheduleType )
|
|
|
|
{
|
|
|
|
if ( !IsRunning() && HasFollowPoint() )
|
|
|
|
{
|
|
|
|
ClearHintNode( 0.5 );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !m_TargetMonitor.IsMarkSet() && !IsCurScheduleFollowSchedule() )
|
|
|
|
{
|
|
|
|
m_TargetMonitor.SetMark( m_hFollowTarget, m_FollowNavGoal.targetMoveTolerance );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::GetFollowTargetViewLoc( Vector *pResult )
|
|
|
|
{
|
|
|
|
if ( !dynamic_cast<CPointEntity *>(m_hFollowTarget.Get()) )
|
|
|
|
{
|
|
|
|
trace_t tr;
|
|
|
|
Vector vecStart, vecDir;
|
|
|
|
|
|
|
|
ASSERT( m_hFollowTarget != NULL );
|
|
|
|
|
|
|
|
vecStart = m_hFollowTarget->EyePosition();
|
|
|
|
|
|
|
|
CBasePlayer *pPlayer;
|
|
|
|
|
|
|
|
pPlayer = dynamic_cast<CBasePlayer *>(m_hFollowTarget.Get());
|
|
|
|
|
|
|
|
if( pPlayer )
|
|
|
|
{
|
|
|
|
// Follow target is a player.
|
|
|
|
pPlayer->EyeVectors( &vecDir, NULL, NULL );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Not a player.
|
|
|
|
m_hFollowTarget->GetVectors( &vecDir, NULL, NULL );
|
|
|
|
}
|
|
|
|
|
|
|
|
AI_TraceLOS( vecStart, vecStart + vecDir * 8192, m_hFollowTarget, &tr );
|
|
|
|
|
|
|
|
*pResult = tr.endpos;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
*pResult = m_hFollowTarget->GetAbsOrigin();
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::ValidateFaceTarget( Vector *pFaceTarget )
|
|
|
|
{
|
|
|
|
if ( *pFaceTarget == vec3_invalid )
|
|
|
|
{
|
|
|
|
if ( m_hFollowTarget != NULL )
|
|
|
|
{
|
|
|
|
*pFaceTarget = m_hFollowTarget->GetAbsOrigin();
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector testPoint = *pFaceTarget - GetAbsOrigin();
|
|
|
|
testPoint.z = 0;
|
|
|
|
VectorNormalize( testPoint );
|
|
|
|
testPoint *= 48;
|
|
|
|
testPoint += GetOuter()->EyePosition();
|
|
|
|
|
|
|
|
trace_t tr;
|
|
|
|
AI_TraceLine( GetOuter()->EyePosition(), testPoint, MASK_BLOCKLOS, m_hFollowTarget, COLLISION_GROUP_NONE, &tr );
|
|
|
|
|
|
|
|
if ( tr.fraction < 1.0 )
|
|
|
|
{
|
|
|
|
*pFaceTarget = m_hFollowTarget->GetAbsOrigin();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::FindCoverFromEnemyAtFollowTarget( float coverRadius, Vector *pResult )
|
|
|
|
{
|
|
|
|
CBaseEntity *pEntity = GetEnemy();
|
|
|
|
|
|
|
|
return GetOuter()->FindCoverPosInRadius( pEntity, m_FollowNavGoal.position, coverRadius, pResult );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::StartTask( const Task_t *pTask )
|
|
|
|
{
|
|
|
|
AI_PROFILE_SCOPE( CAI_FollowBehavior_StartTask );
|
|
|
|
|
|
|
|
switch ( pTask->iTask )
|
|
|
|
{
|
|
|
|
case TASK_RANGE_ATTACK1:
|
|
|
|
BaseClass::StartTask( pTask );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TASK_GET_PATH_TO_FOLLOW_POSITION:
|
|
|
|
{
|
|
|
|
if ( !UpdateFollowPosition() )
|
|
|
|
{
|
|
|
|
TaskFail(FAIL_NO_TARGET);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_TargetMonitor.SetMark( m_hFollowTarget, m_FollowNavGoal.targetMoveTolerance );
|
|
|
|
m_bMovingToCover = false;
|
|
|
|
GetOuter()->m_vInterruptSavePosition = vec3_invalid;
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_CANT_FOLLOW:
|
|
|
|
{
|
|
|
|
SetFollowTarget( NULL, true );
|
|
|
|
TaskComplete();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_FOLLOWER_FACE_TACTICAL:
|
|
|
|
case TASK_FACE_FOLLOW_TARGET:
|
|
|
|
{
|
|
|
|
if ( !m_TimeBeforeSpreadFacing.Expired() )
|
|
|
|
{
|
|
|
|
m_TimeNextSpreadFacing.Reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector faceTarget = vec3_invalid;
|
|
|
|
bool bFollowingPoint = ( dynamic_cast<CPointEntity *>(m_hFollowTarget.Get()) != NULL );
|
|
|
|
if ( GetNpcState() == NPC_STATE_COMBAT )
|
|
|
|
{
|
|
|
|
if( gpGlobals->curtime - GetOuter()->GetEnemyLastTimeSeen() < 5.0 )
|
|
|
|
{
|
|
|
|
faceTarget = GetEnemyLKP();
|
|
|
|
}
|
|
|
|
else if ( !bFollowingPoint )
|
|
|
|
{
|
|
|
|
GetFollowTargetViewLoc( &faceTarget );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if ( m_hFollowTarget && !bFollowingPoint )
|
|
|
|
{
|
|
|
|
if ( m_bFirstFacing && m_hFollowTarget->IsPlayer() )
|
|
|
|
{
|
|
|
|
faceTarget = m_hFollowTarget->GetAbsOrigin();
|
|
|
|
}
|
|
|
|
else if ( m_TimeNextSpreadFacing.Expired() )
|
|
|
|
{
|
|
|
|
m_TimeNextSpreadFacing.Reset();
|
|
|
|
|
|
|
|
bool bIsEpisodicVitalAlly;
|
|
|
|
|
|
|
|
#ifdef HL2_DLL
|
|
|
|
bIsEpisodicVitalAlly = (hl2_episodic.GetBool() && GetOuter()->Classify() == CLASS_PLAYER_ALLY_VITAL);
|
|
|
|
#else
|
|
|
|
bIsEpisodicVitalAlly = false;
|
|
|
|
#endif//HL2_DLL
|
|
|
|
|
|
|
|
if( bIsEpisodicVitalAlly )
|
|
|
|
{
|
|
|
|
faceTarget = m_hFollowTarget->GetAbsOrigin();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int roll = random->RandomInt(1, 4);
|
|
|
|
if ( roll == 1 )
|
|
|
|
{
|
|
|
|
GetFollowTargetViewLoc( &faceTarget );
|
|
|
|
}
|
|
|
|
else if ( roll == 2 )
|
|
|
|
{
|
|
|
|
faceTarget = m_hFollowTarget->GetAbsOrigin();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Fan out and face to cover all directions.
|
|
|
|
int count = g_AIFollowManager.CountFollowersInGroup( GetOuter() );
|
|
|
|
|
|
|
|
if( count > 0 )
|
|
|
|
{
|
|
|
|
// Slice up the directions among followers and leader. ( +1 because we count the leader!)
|
|
|
|
float flSlice = 360.0 / (count + 1);
|
|
|
|
|
|
|
|
// Add one to slots so then are 1 to N instead of 0 to N - 1.
|
|
|
|
int slot = random->RandomInt( 0, count );
|
|
|
|
|
|
|
|
QAngle angle = m_hFollowTarget->GetAbsAngles();
|
|
|
|
|
|
|
|
// split up the remaining angles among followers in my group.
|
|
|
|
angle.y = UTIL_AngleMod( angle.y + ( flSlice * slot ) );
|
|
|
|
|
|
|
|
Vector vecDir;
|
|
|
|
AngleVectors( angle, &vecDir );
|
|
|
|
|
|
|
|
faceTarget = GetOuter()->GetAbsOrigin() + vecDir * 128;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Stay where we are
|
|
|
|
TaskComplete();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
m_bFirstFacing = false;
|
|
|
|
|
|
|
|
if ( ValidateFaceTarget( &faceTarget ) )
|
|
|
|
{
|
|
|
|
Assert( faceTarget != vec3_invalid );
|
|
|
|
|
|
|
|
if ( !GetOuter()->FInAimCone( faceTarget ) )
|
|
|
|
{
|
|
|
|
GetMotor()->SetIdealYawToTarget( faceTarget, 30 );
|
|
|
|
GetOuter()->SetTurnActivity();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
TaskComplete();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ChainStartTask( TASK_FACE_REASONABLE );
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_MOVE_TO_FOLLOW_POSITION:
|
|
|
|
{
|
|
|
|
if ( m_hFollowTarget == NULL)
|
|
|
|
{
|
|
|
|
TaskFail(FAIL_NO_TARGET);
|
|
|
|
}
|
|
|
|
else if ( (m_hFollowTarget->GetAbsOrigin() - GetAbsOrigin()).Length() < 1 )
|
|
|
|
{
|
|
|
|
TaskComplete();
|
|
|
|
}
|
|
|
|
else if ( !GetNavigator()->IsGoalActive() )
|
|
|
|
{
|
|
|
|
TaskFail(FAIL_NO_ROUTE);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_vFollowMoveAnchor = GetAbsOrigin();
|
|
|
|
m_CurrentFollowActivity = ACT_INVALID;
|
|
|
|
m_RepathOnFollowTimer.Force();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_SET_FOLLOW_TARGET_MARK:
|
|
|
|
{
|
|
|
|
if ( m_hFollowTarget == NULL)
|
|
|
|
{
|
|
|
|
TaskFail(FAIL_NO_TARGET);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
FollowMsg( "TASK_SET_FOLLOW_TARGET_MARK\n" );
|
|
|
|
m_TargetMonitor.SetMark( m_hFollowTarget, m_FollowNavGoal.targetMoveTolerance );
|
|
|
|
TaskComplete();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_SET_FOLLOW_DELAY:
|
|
|
|
{
|
|
|
|
m_FollowDelay.Start( pTask->flTaskData );
|
|
|
|
TaskComplete();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_FIND_COVER_FROM_ENEMY:
|
|
|
|
{
|
|
|
|
CBaseEntity *pLeader = GetFollowTarget();
|
|
|
|
if ( pLeader )
|
|
|
|
{
|
|
|
|
Vector coverPos = vec3_invalid;
|
|
|
|
float coverRadius = MIN( GetOuter()->CoverRadius(), m_FollowNavGoal.coverTolerance );
|
|
|
|
|
|
|
|
if ( FindCoverFromEnemyAtFollowTarget( coverRadius, &coverPos ) )
|
|
|
|
{
|
|
|
|
AI_NavGoal_t goal(GOALTYPE_COVER, coverPos, ACT_RUN, AIN_HULL_TOLERANCE, AIN_DEF_FLAGS);
|
|
|
|
GetNavigator()->SetGoal( goal );
|
|
|
|
|
|
|
|
GetOuter()->m_flMoveWaitFinished = gpGlobals->curtime + pTask->flTaskData;
|
|
|
|
TaskComplete();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
TaskFail(FAIL_NO_COVER);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
BaseClass::StartTask( pTask );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_GET_PATH_TO_FOLLOW_POINT:
|
|
|
|
{
|
|
|
|
ChainStartTask( TASK_GET_PATH_TO_HINTNODE, ShouldIgnoreFollowPointFacing() );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_ARRIVE_AT_FOLLOW_POINT:
|
|
|
|
{
|
|
|
|
if ( GetHintNode() && !ShouldIgnoreFollowPointFacing() )
|
|
|
|
ChainStartTask( TASK_FACE_HINTNODE, 0 );
|
|
|
|
else
|
|
|
|
TaskComplete();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_SET_FOLLOW_POINT_STAND_SCHEDULE:
|
|
|
|
{
|
|
|
|
if ( GetHintNode() && !ShouldIgnoreFollowPointFacing() )
|
|
|
|
{
|
|
|
|
float distSqToPoint = (GetHintNode()->GetAbsOrigin() - GetAbsOrigin()).LengthSqr();
|
|
|
|
if ( distSqToPoint < WAIT_HINT_MIN_DIST )
|
|
|
|
{
|
|
|
|
GetOuter()->SetSchedule( SCHED_FOLLOWER_STAND_AT_WAIT_POINT );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GetHintNode()->Unlock();
|
|
|
|
SetHintNode( NULL );
|
|
|
|
m_TimeBlockUseWaitPoint.Reset();
|
|
|
|
TaskFail("Couldn't get to wait node." );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GetOuter()->SetSchedule( SCHED_FACE_FOLLOW_TARGET );
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_BEGIN_STAND_AT_WAIT_POINT:
|
|
|
|
{
|
|
|
|
if ( !m_TargetMonitor.IsMarkSet() && IsFollowPointInRange() )
|
|
|
|
m_TargetMonitor.SetMark( m_hFollowTarget, m_FollowNavGoal.targetMoveTolerance );
|
|
|
|
if ( GetHintNode() && !ShouldIgnoreFollowPointFacing() )
|
|
|
|
ChainStartTask( TASK_FACE_HINTNODE, 0 );
|
|
|
|
else
|
|
|
|
TaskComplete();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
BaseClass::StartTask( pTask );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::RunTask( const Task_t *pTask )
|
|
|
|
{
|
|
|
|
switch( pTask->iTask )
|
|
|
|
{
|
|
|
|
case TASK_GET_PATH_TO_FOLLOW_POSITION:
|
|
|
|
{
|
|
|
|
switch( GetOuter()->GetTaskInterrupt() )
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
{
|
|
|
|
if ( GetEnemy() )
|
|
|
|
{
|
|
|
|
Assert( GetOuter()->m_vInterruptSavePosition == vec3_invalid );
|
|
|
|
Vector coverPos = vec3_invalid;
|
|
|
|
float coverRadius = MIN( (float)12*12, m_FollowNavGoal.coverTolerance );
|
|
|
|
if ( FindCoverFromEnemyAtFollowTarget( coverRadius, &coverPos ) )
|
|
|
|
{
|
|
|
|
GetOuter()->m_vInterruptSavePosition = coverPos;
|
|
|
|
}
|
|
|
|
GetOuter()->TaskInterrupt();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// Fall through...
|
|
|
|
|
|
|
|
case 1:
|
|
|
|
{
|
|
|
|
if ( GetOuter()->m_vInterruptSavePosition != vec3_invalid )
|
|
|
|
{
|
|
|
|
AI_NavGoal_t goal(GOALTYPE_COVER, GetOuter()->m_vInterruptSavePosition, ACT_RUN, AIN_HULL_TOLERANCE, AIN_DEF_FLAGS);
|
|
|
|
if ( GetNavigator()->SetGoal( goal, AIN_NO_PATH_TASK_FAIL ) )
|
|
|
|
{
|
|
|
|
TaskComplete();
|
|
|
|
m_bMovingToCover = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GetOuter()->TaskInterrupt();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
// Fall through...
|
|
|
|
}
|
|
|
|
|
|
|
|
case 2:
|
|
|
|
{
|
|
|
|
Assert( !m_bMovingToCover );
|
|
|
|
Vector vGoalPosition;
|
|
|
|
if ( HasFollowPoint() && IsFollowPointInRange() )
|
|
|
|
vGoalPosition = GetFollowPoint();
|
|
|
|
else
|
|
|
|
vGoalPosition = GetGoalPosition();
|
|
|
|
|
|
|
|
AI_NavGoal_t goal( vGoalPosition, AIN_DEF_ACTIVITY, GetGoalTolerance() );
|
|
|
|
if ( !m_hFollowTarget->GetParent() || !m_hFollowTarget->GetParent()->GetServerVehicle() )
|
|
|
|
{
|
|
|
|
goal.pTarget = m_hFollowTarget;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
goal.pTarget = m_hFollowTarget->GetParent();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool bSuccess = true;
|
|
|
|
if ( !GetNavigator()->SetGoal( goal, AIN_NO_PATH_TASK_FAIL ) )
|
|
|
|
{
|
|
|
|
const Vector &vTarget = GetFollowTarget()->WorldSpaceCenter();
|
|
|
|
Vector vToGoal = vGoalPosition - vTarget;
|
|
|
|
if ( vToGoal.Length2DSqr() > 6*12 )
|
|
|
|
{
|
|
|
|
goal.dest = vTarget + vToGoal * 0.5;
|
|
|
|
if ( !GetNavigator()->SetGoal( goal, AIN_NO_PATH_TASK_FAIL ) )
|
|
|
|
{
|
|
|
|
bSuccess = false;
|
|
|
|
m_FollowDelay.Start( 2.0, 5.0 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
bSuccess = false;
|
|
|
|
m_FollowDelay.Start( 2.0, 5.0 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !bSuccess )
|
|
|
|
{
|
|
|
|
m_bFollowNavFailed = true;
|
|
|
|
TaskFail( FAIL_NO_ROUTE );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
TaskComplete();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_FOLLOWER_FACE_TACTICAL:
|
|
|
|
case TASK_FACE_FOLLOW_TARGET:
|
|
|
|
{
|
|
|
|
ChainRunTask( TASK_FACE_REASONABLE );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_MOVE_TO_FOLLOW_POSITION:
|
|
|
|
{
|
|
|
|
if ( m_hFollowTarget == NULL )
|
|
|
|
{
|
|
|
|
TaskFail(FAIL_NO_TARGET);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ( m_bMovingToCover )
|
|
|
|
{
|
|
|
|
ChainRunTask( TASK_WAIT_FOR_MOVEMENT );
|
|
|
|
NoteSuccessfulFollow();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Re-evaluate when you think your finished, or the target has moved too far
|
|
|
|
if ( !UpdateFollowPosition() )
|
|
|
|
{
|
|
|
|
TaskFail(FAIL_NO_TARGET);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( ShouldUseFollowPoints() && ai_follow_use_points_when_moving.GetBool() )
|
|
|
|
{
|
|
|
|
if ( HasFollowPoint() )
|
|
|
|
{
|
|
|
|
if ( !IsFollowPointInRange() )
|
|
|
|
{
|
|
|
|
ClearFollowPoint();
|
|
|
|
GetNavigator()->SetArrivalDirection( vec3_origin );
|
|
|
|
GetNavigator()->SetArrivalActivity( ACT_INVALID );
|
|
|
|
m_TimeBlockUseWaitPoint.Reset();
|
|
|
|
m_TimeCheckForWaitPoint.Reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( GetNavigator()->GetNavType() != NAV_JUMP && !HasFollowPoint() && m_pInterruptWaitPoint )
|
|
|
|
{
|
|
|
|
SetFollowPoint( m_pInterruptWaitPoint );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ClearFollowPoint();
|
|
|
|
if ( GetNavigator()->IsGoalActive() )
|
|
|
|
{
|
|
|
|
GetNavigator()->SetArrivalDirection( vec3_origin );
|
|
|
|
GetNavigator()->SetArrivalActivity( ACT_INVALID );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !GetNavigator()->IsGoalActive() )
|
|
|
|
{
|
|
|
|
// What this probably means is that the navigation failed but within tolerance
|
|
|
|
// So for now, just call it good and block another attempt for a bit
|
|
|
|
TaskComplete();
|
|
|
|
if ( !IsFollowPointInRange() )
|
|
|
|
ClearFollowPoint();
|
|
|
|
if ( !IsFollowGoalInRange( m_FollowNavGoal.tolerance, GetGoalZRange(), GetGoalFlags() ) )
|
|
|
|
m_FollowDelay.Start( 0.25, 0.75 );
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_TargetMonitor.SetMark( GetFollowTarget(), m_FollowNavGoal.targetMoveTolerance );
|
|
|
|
m_bTargetUnreachable = false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !HasFollowPoint() )
|
|
|
|
{
|
|
|
|
float range = GetGoalRange();
|
|
|
|
|
|
|
|
Vector vVelocity =- GetFollowTarget()->GetSmoothedVelocity();
|
|
|
|
bool bDoSlowdown = ( vVelocity.LengthSqr() < Square(4*12) );
|
|
|
|
if ( bDoSlowdown )
|
|
|
|
{
|
|
|
|
range += GetMotor()->MinStoppingDist(12) - 12;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( IsFollowGoalInRange( range, GetGoalZRange(), GetGoalFlags() ) )
|
|
|
|
{
|
|
|
|
m_TimeBeforeSpreadFacing.Reset();
|
|
|
|
TaskComplete();
|
|
|
|
GetNavigator()->StopMoving( !bDoSlowdown ); // Stop moving
|
|
|
|
m_TargetMonitor.SetMark( GetFollowTarget(), m_FollowNavGoal.targetMoveTolerance );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update the nav goal if needed
|
|
|
|
if ( m_RepathOnFollowTimer.Expired() )
|
|
|
|
{
|
|
|
|
if ( (GetNavigator()->GetGoalPos() - GetGoalPosition()).LengthSqr() > Square( m_FollowNavGoal.repathOnRouteTolerance ) )
|
|
|
|
{
|
|
|
|
if ( GetNavigator()->GetNavType() != NAV_JUMP )
|
|
|
|
{
|
|
|
|
m_RepathOnFollowTimer.Set( .5 );
|
|
|
|
if ( !GetNavigator()->UpdateGoalPos( GetGoalPosition() ) )
|
|
|
|
{
|
|
|
|
bool bSuccess = false;
|
|
|
|
const Vector &vTarget = GetFollowTarget()->WorldSpaceCenter();
|
|
|
|
Vector vToGoal = GetGoalPosition() - vTarget;
|
|
|
|
if ( vToGoal.Length2DSqr() > 6*12 )
|
|
|
|
{
|
|
|
|
if ( GetNavigator()->UpdateGoalPos( vTarget + vToGoal * 0.5 ) )
|
|
|
|
{
|
|
|
|
bSuccess = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !bSuccess )
|
|
|
|
{
|
|
|
|
TaskFail(FAIL_NO_ROUTE);
|
|
|
|
m_bTargetUnreachable = true;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
NoteSuccessfulFollow();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const Vector &vFollowPoint = GetFollowPoint();
|
|
|
|
if ( GetNavigator()->GetGoalPos() != vFollowPoint )
|
|
|
|
{
|
|
|
|
if ( !GetNavigator()->UpdateGoalPos( vFollowPoint ) )
|
|
|
|
{
|
|
|
|
TaskFail(FAIL_NO_ROUTE);
|
|
|
|
m_bTargetUnreachable = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
NoteSuccessfulFollow();
|
|
|
|
|
|
|
|
if ( !ShouldIgnoreFollowPointFacing() )
|
|
|
|
GetNavigator()->SetArrivalDirection( GetHintNode()->GetDirection() );
|
|
|
|
if ( GetHintNode()->HintActivityName() != NULL_STRING )
|
|
|
|
{
|
|
|
|
Activity hintActivity = (Activity)CAI_BaseNPC::GetActivityID( STRING(GetHintNode()->HintActivityName()) );
|
|
|
|
if ( hintActivity != ACT_INVALID )
|
|
|
|
{
|
|
|
|
GetNavigator()->SetArrivalActivity( GetOuter()->GetHintActivity(GetHintNode()->HintType(), hintActivity ) );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
int iSequence = GetOuter()->LookupSequence(STRING(GetHintNode()->HintActivityName()));
|
|
|
|
if ( iSequence != ACT_INVALID )
|
|
|
|
{
|
|
|
|
GetNavigator()->SetArrivalSequence( iSequence );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set the appropriate activity based on an overlapping range
|
|
|
|
// overlap the range to prevent oscillation
|
|
|
|
// BUGBUG: this is checking linear distance (ie. through walls) and not path distance or even visibility
|
|
|
|
|
|
|
|
// Never stop running once started
|
|
|
|
if ( m_CurrentFollowActivity != ACT_RUN )
|
|
|
|
{
|
|
|
|
float distToTargetSq = ( GetNavigator()->GetGoalPos() - GetLocalOrigin() ).Length2DSqr();
|
|
|
|
|
|
|
|
// Pick the right movement activity.
|
|
|
|
Activity followActivity = ( distToTargetSq < Square(m_FollowNavGoal.walkTolerance) && GetOuter()->GetState() != NPC_STATE_COMBAT ) ? ACT_WALK : ACT_RUN;
|
|
|
|
|
|
|
|
// If we're supposed to have LOS, run to catch up
|
|
|
|
if ( m_FollowNavGoal.flags & AIFF_REQUIRE_LOS_OUTSIDE_COMBAT )
|
|
|
|
{
|
|
|
|
if ( !GetOuter()->GetSenses()->DidSeeEntity( m_hFollowTarget ) )
|
|
|
|
{
|
|
|
|
followActivity = ACT_RUN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( followActivity != m_CurrentFollowActivity )
|
|
|
|
{
|
|
|
|
m_CurrentFollowActivity = followActivity;
|
|
|
|
GetNavigator()->SetMovementActivity(followActivity);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( ( m_vFollowMoveAnchor - GetAbsOrigin() ).LengthSqr() > Square( 15.0 * 12.0 ) )
|
|
|
|
{
|
|
|
|
m_vFollowMoveAnchor = GetAbsOrigin();
|
|
|
|
NoteSuccessfulFollow();
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_ARRIVE_AT_FOLLOW_POINT:
|
|
|
|
{
|
|
|
|
ChainRunTask( TASK_FACE_HINTNODE, 0 );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case TASK_BEGIN_STAND_AT_WAIT_POINT:
|
|
|
|
{
|
|
|
|
ChainRunTask( TASK_FACE_HINTNODE, 0 );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
|
|
|
BaseClass::RunTask( pTask );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::TaskComplete( bool fIgnoreSetFailedCondition )
|
|
|
|
{
|
|
|
|
const Task_t *pTask = GetCurTask();
|
|
|
|
if ( pTask->iTask == TASK_MOVE_TO_FOLLOW_POSITION || pTask->iTask == TASK_GET_PATH_TO_FOLLOW_POSITION )
|
|
|
|
NoteSuccessfulFollow();
|
|
|
|
BaseClass::TaskComplete( fIgnoreSetFailedCondition );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::BuildScheduleTestBits()
|
|
|
|
{
|
|
|
|
BaseClass::BuildScheduleTestBits();
|
|
|
|
bool bIsTakeCover = false;
|
|
|
|
bool bIsHideAndReload = false;
|
|
|
|
bool bIsReload = false;
|
|
|
|
bool bIgnoreMovedMark = false;
|
|
|
|
|
|
|
|
if ( ( GetOuter()->ConditionInterruptsCurSchedule( COND_GIVE_WAY ) ||
|
|
|
|
GetOuter()->ConditionInterruptsCurSchedule( COND_IDLE_INTERRUPT ) ||
|
|
|
|
( bIsHideAndReload = IsCurSchedule(SCHED_HIDE_AND_RELOAD ) ) == true ||
|
|
|
|
( bIsReload = IsCurSchedule(SCHED_RELOAD ) ) == true ||
|
|
|
|
IsCurSchedule(SCHED_STANDOFF ) ||
|
|
|
|
( bIsTakeCover = IsCurSchedule(SCHED_TAKE_COVER_FROM_ENEMY ) ) == true ||
|
|
|
|
IsCurSchedule(SCHED_COMBAT_FACE ) ||
|
|
|
|
IsCurSchedule(SCHED_ALERT_FACE ) ||
|
|
|
|
IsCurSchedule(SCHED_COMBAT_STAND ) ||
|
|
|
|
IsCurSchedule(SCHED_ALERT_STAND) ) ||
|
|
|
|
IsCurSchedule(SCHED_ALERT_FACE_BESTSOUND ) )
|
|
|
|
{
|
|
|
|
#ifdef HL2_EPISODIC
|
|
|
|
if( IsCurSchedule(SCHED_RELOAD, false) && GetOuter()->Classify() == CLASS_PLAYER_ALLY_VITAL )
|
|
|
|
{
|
|
|
|
// Alyx and Barney do not stop reloading because the player has moved.
|
|
|
|
// Citizens and other regular allies do.
|
|
|
|
bIgnoreMovedMark = true;
|
|
|
|
}
|
|
|
|
#endif//HL2_EPISODIC
|
|
|
|
|
|
|
|
if( !bIgnoreMovedMark )
|
|
|
|
{
|
|
|
|
GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal( COND_TARGET_MOVED_FROM_MARK ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !bIsTakeCover && !bIsHideAndReload && !bIsReload )
|
|
|
|
GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal( COND_FOLLOW_DELAY_EXPIRED) );
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add logic for NPCs not able to move and shoot
|
|
|
|
if ( hl2_episodic.GetBool() )
|
|
|
|
{
|
|
|
|
if ( IsCurScheduleFollowSchedule() && GetOuter()->ShouldMoveAndShoot() == false )
|
|
|
|
{
|
|
|
|
GetOuter()->SetCustomInterruptCondition( COND_CAN_RANGE_ATTACK1 );
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HL2_EPISODIC
|
|
|
|
// In Alyx darkness mode, break on the player turning their flashlight off
|
|
|
|
if ( HL2GameRules()->IsAlyxInDarknessMode() )
|
|
|
|
{
|
|
|
|
if ( IsCurSchedule(SCHED_FOLLOW, false) || IsCurSchedule(SCHED_MOVE_TO_FACE_FOLLOW_TARGET, false) ||
|
|
|
|
IsCurSchedule(SCHED_FACE_FOLLOW_TARGET, false) )
|
|
|
|
{
|
|
|
|
GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal( COND_FOLLOW_PLAYER_IS_NOT_LIT ) );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif // HL2_EPISODIC
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( GetNpcState() == NPC_STATE_COMBAT && IsCurScheduleFollowSchedule() )
|
|
|
|
{
|
|
|
|
GetOuter()->ClearCustomInterruptCondition( COND_LIGHT_DAMAGE );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
Activity CAI_FollowBehavior::NPC_TranslateActivity( Activity activity )
|
|
|
|
{
|
|
|
|
if ( activity == ACT_IDLE && HasFollowPoint() && GetHintNode()->HintActivityName() != NULL_STRING )
|
|
|
|
{
|
|
|
|
return GetOuter()->GetHintActivity(GetHintNode()->HintType(), (Activity)CAI_BaseNPC::GetActivityID( STRING(GetHintNode()->HintActivityName()) ) );
|
|
|
|
}
|
|
|
|
return BaseClass::NPC_TranslateActivity( activity );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::IsCurScheduleFollowSchedule()
|
|
|
|
{
|
|
|
|
int curScheduleId = ( GetOuter()->GetCurSchedule() ) ? GetOuter()->GetCurSchedule()->GetId() : SCHED_NONE;
|
|
|
|
if ( curScheduleId >= GetClassScheduleIdSpace()->ScheduleLocalToGlobal( SCHED_FOLLOWER_MOVE_AWAY_FAIL ) &&
|
|
|
|
curScheduleId <= GetClassScheduleIdSpace()->ScheduleLocalToGlobal( SCHED_FOLLOWER_STAND_AT_WAIT_POINT ) )
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::IsCurTaskContinuousMove()
|
|
|
|
{
|
|
|
|
const Task_t *pCurTask = GetCurTask();
|
|
|
|
if ( pCurTask && pCurTask->iTask == TASK_MOVE_TO_FOLLOW_POSITION )
|
|
|
|
return true;
|
|
|
|
return BaseClass::IsCurTaskContinuousMove();
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::OnMovementFailed()
|
|
|
|
{
|
|
|
|
float acceptDist = m_FollowNavGoal.range;
|
|
|
|
if ( m_FollowNavGoal.tolerance > acceptDist )
|
|
|
|
acceptDist = m_FollowNavGoal.tolerance;
|
|
|
|
|
|
|
|
if ( GetNpcState() == NPC_STATE_COMBAT )
|
|
|
|
{
|
|
|
|
if ( m_FollowNavGoal.coverTolerance > acceptDist )
|
|
|
|
acceptDist = m_FollowNavGoal.coverTolerance;
|
|
|
|
if (m_FollowNavGoal.enemyLOSTolerance > acceptDist )
|
|
|
|
acceptDist = m_FollowNavGoal.enemyLOSTolerance;
|
|
|
|
}
|
|
|
|
|
|
|
|
float flZRange = GetGoalZRange();
|
|
|
|
if ( GetGoalZRange() == -1 )
|
|
|
|
{
|
|
|
|
flZRange = GetHullHeight() * 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( IsFollowGoalInRange( acceptDist * 1.5, flZRange, GetGoalFlags() ) )
|
|
|
|
m_bTargetUnreachable = true;
|
|
|
|
else
|
|
|
|
m_FollowDelay.Start();
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowBehavior::OnMovementComplete()
|
|
|
|
{
|
|
|
|
if ( !IsCurSchedule(SCHED_FOLLOWER_GO_TO_WAIT_POINT) )
|
|
|
|
m_TimeBeforeSpreadFacing.Reset();
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_TimeBeforeSpreadFacing.Force();
|
|
|
|
m_TimeNextSpreadFacing.Force();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::FValidateHintType( CAI_Hint *pHint )
|
|
|
|
{
|
|
|
|
if ( pHint->HintType() == HINT_FOLLOW_WAIT_POINT )
|
|
|
|
{
|
|
|
|
if ( GetFollowTarget() && GetFollowTarget()->FVisible( pHint->GetAbsOrigin() + Vector( 0, 0, 0.1 ) ) )
|
|
|
|
return true;
|
|
|
|
else
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return BaseClass::FValidateHintType( pHint );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::IsValidCover( const Vector &vLocation, CAI_Hint const *pHint )
|
|
|
|
{
|
|
|
|
if ( (vLocation - m_FollowNavGoal.position).LengthSqr() > Square( m_FollowNavGoal.coverTolerance + 0.1 ) )
|
|
|
|
return false;
|
|
|
|
return BaseClass::IsValidCover( vLocation, pHint );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::IsValidShootPosition( const Vector &vLocation, CAI_Node *pNode, CAI_Hint const *pHint )
|
|
|
|
{
|
|
|
|
if ( (vLocation - m_FollowNavGoal.position).LengthSqr() > Square( m_FollowNavGoal.enemyLOSTolerance + 0.1 ) )
|
|
|
|
return false;
|
|
|
|
return BaseClass::IsValidShootPosition( vLocation, pNode, pHint );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowBehavior::ShouldAlwaysThink()
|
|
|
|
{
|
|
|
|
return ( m_hFollowTarget && m_hFollowTarget->IsPlayer() );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// CAI_FollowGoal
|
|
|
|
//
|
|
|
|
// Purpose: A level tool to control the follow behavior. Use is not required
|
|
|
|
// in order to use behavior.
|
|
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
BEGIN_DATADESC( CAI_FollowGoal )
|
|
|
|
DEFINE_KEYFIELD( m_iFormation, FIELD_INTEGER, "Formation" ),
|
|
|
|
|
|
|
|
#ifdef HL2_EPISODIC
|
|
|
|
DEFINE_INPUTFUNC( FIELD_VOID, "OutsideTransition", InputOutsideTransition ),
|
|
|
|
#endif
|
|
|
|
END_DATADESC()
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
LINK_ENTITY_TO_CLASS( ai_goal_follow, CAI_FollowGoal );
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowGoal::EnableGoal( CAI_BaseNPC *pAI )
|
|
|
|
{
|
|
|
|
CAI_FollowBehavior *pBehavior;
|
|
|
|
if ( !pAI->GetBehavior( &pBehavior ) )
|
|
|
|
return;
|
|
|
|
|
|
|
|
CBaseEntity *pGoalEntity = GetGoalEntity();
|
|
|
|
if ( !pGoalEntity && AI_IsSinglePlayer() )
|
|
|
|
{
|
|
|
|
if ( pAI->IRelationType(UTIL_GetLocalPlayer()) == D_LI )
|
|
|
|
{
|
|
|
|
pGoalEntity = UTIL_GetLocalPlayer();
|
|
|
|
SetGoalEntity( pGoalEntity );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( pGoalEntity )
|
|
|
|
pBehavior->SetFollowGoal( this );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowGoal::DisableGoal( CAI_BaseNPC *pAI )
|
|
|
|
{
|
|
|
|
CAI_FollowBehavior *pBehavior;
|
|
|
|
if ( !pAI || !pAI->GetBehavior( &pBehavior ) )
|
|
|
|
return;
|
|
|
|
|
|
|
|
pBehavior->ClearFollowGoal( this );
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
#ifdef HL2_EPISODIC
|
|
|
|
void CAI_FollowGoal::InputOutsideTransition( inputdata_t &inputdata )
|
|
|
|
{
|
|
|
|
EnterDormant();
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// CAI_FollowManager
|
|
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
//
|
|
|
|
// Purpose: Formation definitions
|
|
|
|
//
|
|
|
|
|
|
|
|
// @TODO (toml 11-21-03): rework follow so we don't have to have class specifc formations in this file
|
|
|
|
|
|
|
|
struct AI_FollowSlot_t
|
|
|
|
{
|
|
|
|
int priority;
|
|
|
|
|
|
|
|
TableVector position;
|
|
|
|
float positionVariability;
|
|
|
|
|
|
|
|
float rangeMin;
|
|
|
|
float rangeMax;
|
|
|
|
|
|
|
|
float Zrange;
|
|
|
|
|
|
|
|
float tolerance;
|
|
|
|
|
|
|
|
// @Q (toml 02-28-03): facing?
|
|
|
|
};
|
|
|
|
|
|
|
|
struct AI_FollowFormation_t
|
|
|
|
{
|
|
|
|
const char * pszName;
|
|
|
|
unsigned flags;
|
|
|
|
int nSlots;
|
|
|
|
|
|
|
|
// Range within which can exit formation to seek a follow point
|
|
|
|
float followPointTolerance;
|
|
|
|
|
|
|
|
// Distance target must move to reset formation
|
|
|
|
float targetMoveTolerance;
|
|
|
|
|
|
|
|
// Distance from current move goal target must move to force a repathfind
|
|
|
|
float repathOnRouteTolerance;
|
|
|
|
|
|
|
|
// Distance from target within which should walk, not run to formation
|
|
|
|
float walkTolerance;
|
|
|
|
|
|
|
|
// Distance within which can exit formation to seek cover
|
|
|
|
float coverTolerance;
|
|
|
|
|
|
|
|
// Distance within which can exit formation to seek LOS to enemy
|
|
|
|
float enemyLOSTolerance;
|
|
|
|
|
|
|
|
// Distance within which can exit formation to chase enemy
|
|
|
|
float chaseEnemyTolerance;
|
|
|
|
|
|
|
|
AI_FollowSlot_t * pSlots;
|
|
|
|
};
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
static AI_FollowSlot_t g_SimpleFollowFormationSlots[] =
|
|
|
|
{
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 96, 120, -1, 128 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static AI_FollowFormation_t g_SimpleFollowFormation =
|
|
|
|
{
|
|
|
|
"Simple",
|
|
|
|
AIFF_DEFAULT | AIFF_USE_FOLLOW_POINTS,
|
|
|
|
ARRAYSIZE(g_SimpleFollowFormationSlots),
|
|
|
|
168, // followPointTolerance
|
|
|
|
36, // targetMoveTolerance
|
|
|
|
60, // repathOnRouteTolerance
|
|
|
|
190, // walkTolerance
|
|
|
|
300, // coverTolerance
|
|
|
|
300, // enemyLOSTolerance
|
|
|
|
300, // chaseEnemyTolerance
|
|
|
|
g_SimpleFollowFormationSlots,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
static AI_FollowSlot_t g_WideFollowFormationSlots[] =
|
|
|
|
{
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 240, -1, 128 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static AI_FollowFormation_t g_WideFollowFormation =
|
|
|
|
{
|
|
|
|
"Wide",
|
|
|
|
AIFF_DEFAULT | AIFF_USE_FOLLOW_POINTS,
|
|
|
|
ARRAYSIZE(g_WideFollowFormationSlots),
|
|
|
|
168, // followPointTolerance
|
|
|
|
72, // targetMoveTolerance
|
|
|
|
60, // repathOnRouteTolerance
|
|
|
|
190, // walkTolerance
|
|
|
|
600, // coverTolerance
|
|
|
|
600, // enemyLOSTolerance
|
|
|
|
600, // chaseEnemyTolerance
|
|
|
|
g_WideFollowFormationSlots,
|
|
|
|
};
|
|
|
|
|
|
|
|
//---------------------------------------------
|
|
|
|
// Antlion use very loose following criteria
|
|
|
|
|
|
|
|
static AI_FollowSlot_t g_AntlionFollowFormationSlots[] =
|
|
|
|
{
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 150, 250, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 150, 250, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 150, 250, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 150, 250, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 150, 250, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 150, 250, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 150, 250, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 150, 250, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 150, 250, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 150, 250, -1, 128 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static AI_FollowFormation_t g_AntlionFollowFormation =
|
|
|
|
{
|
|
|
|
"Antlion",
|
|
|
|
AIFF_DEFAULT | AIFF_USE_FOLLOW_POINTS,
|
|
|
|
ARRAYSIZE(g_AntlionFollowFormationSlots),
|
|
|
|
168, // followPointTolerance
|
|
|
|
36, // targetMoveTolerance
|
|
|
|
60, // repathOnRouteTolerance
|
|
|
|
190, // walkTolerance
|
|
|
|
1024, // coverTolerance
|
|
|
|
1024, // enemyLOSTolerance
|
|
|
|
1024, // chaseEnemyTolerance
|
|
|
|
g_AntlionFollowFormationSlots,
|
|
|
|
};
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
#define COMMANDER_TOLERANCE (13.0 * 1.415)
|
|
|
|
|
|
|
|
static AI_FollowSlot_t g_CommanderFollowFormationSlots[] =
|
|
|
|
{
|
|
|
|
{ 2, { 0, 0, 0 }, 0, COMMANDER_TOLERANCE, COMMANDER_TOLERANCE, -1, 48 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, COMMANDER_TOLERANCE, COMMANDER_TOLERANCE, -1, 48 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, COMMANDER_TOLERANCE, COMMANDER_TOLERANCE, -1, 48 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, COMMANDER_TOLERANCE, COMMANDER_TOLERANCE, -1, 48 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static AI_FollowFormation_t g_CommanderFollowFormation =
|
|
|
|
{
|
|
|
|
"Commander",
|
|
|
|
AIFF_DEFAULT | AIFF_USE_FOLLOW_POINTS,
|
|
|
|
ARRAYSIZE(g_CommanderFollowFormationSlots),
|
|
|
|
168, // followPointTolerance
|
|
|
|
6, // targetMoveTolerance
|
|
|
|
60, // repathOnRouteTolerance
|
|
|
|
12, // walkTolerance
|
|
|
|
300, // coverTolerance
|
|
|
|
300, // enemyLOSTolerance
|
|
|
|
300, // chaseEnemyTolerance
|
|
|
|
g_CommanderFollowFormationSlots,
|
|
|
|
};
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
static AI_FollowSlot_t g_TightFollowFormationSlots[] =
|
|
|
|
{
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 0, 0, -1, 48 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 0, 0, -1, 48 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 0, 0, -1, 48 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 0, 0, -1, 48 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static AI_FollowFormation_t g_TightFollowFormation =
|
|
|
|
{
|
|
|
|
"Tight",
|
|
|
|
AIFF_DEFAULT | AIFF_USE_FOLLOW_POINTS,
|
|
|
|
ARRAYSIZE(g_CommanderFollowFormationSlots),
|
|
|
|
48, // followPointTolerance
|
|
|
|
6, // targetMoveTolerance
|
|
|
|
60, // repathOnRouteTolerance
|
|
|
|
12, // walkTolerance
|
|
|
|
300, // coverTolerance
|
|
|
|
32, // enemyLOSTolerance
|
|
|
|
32, // chaseEnemyTolerance
|
|
|
|
g_TightFollowFormationSlots,
|
|
|
|
};
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
static AI_FollowSlot_t g_MediumFollowFormationSlots[] =
|
|
|
|
{
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 156, 156, -1, 128 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static AI_FollowFormation_t g_MediumFollowFormation =
|
|
|
|
{
|
|
|
|
"Medium",
|
|
|
|
AIFF_DEFAULT | AIFF_USE_FOLLOW_POINTS,
|
|
|
|
ARRAYSIZE(g_MediumFollowFormationSlots),
|
|
|
|
168, // followPointTolerance
|
|
|
|
36, // targetMoveTolerance
|
|
|
|
60, // repathOnRouteTolerance
|
|
|
|
190, // walkTolerance
|
|
|
|
300, // coverTolerance
|
|
|
|
300, // enemyLOSTolerance
|
|
|
|
300, // chaseEnemyTolerance
|
|
|
|
g_MediumFollowFormationSlots,
|
|
|
|
};
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
static AI_FollowSlot_t g_SidekickFollowFormationSlots[] =
|
|
|
|
{
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static AI_FollowFormation_t g_SidekickFollowFormation =
|
|
|
|
{
|
|
|
|
"Sidekick",
|
|
|
|
AIFF_DEFAULT | AIFF_USE_FOLLOW_POINTS | AIFF_REQUIRE_LOS_OUTSIDE_COMBAT,
|
|
|
|
ARRAYSIZE(g_SidekickFollowFormationSlots),
|
|
|
|
168, // followPointTolerance
|
|
|
|
36, // targetMoveTolerance
|
|
|
|
60, // repathOnRouteTolerance
|
|
|
|
190, // walkTolerance
|
|
|
|
300, // coverTolerance
|
|
|
|
300, // enemyLOSTolerance
|
|
|
|
300, // chaseEnemyTolerance
|
|
|
|
g_SidekickFollowFormationSlots,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
// Used for hunters following striders
|
|
|
|
//-------------------------------------
|
|
|
|
static AI_FollowSlot_t g_HunterFollowFormationSlots[] =
|
|
|
|
{
|
|
|
|
{ 3, { 480, -240, -400 }, 0, 48, 64, 1000, 60 },
|
|
|
|
{ 3, { 480, 240, -400 }, 0, 48, 64, 1000, 60 },
|
|
|
|
{ 2, { 480, 0, -400 }, 0, 48, 64, 1000, 60 },
|
|
|
|
{ 1, { -240, 0, -400 }, 0, 48, 64, 1000, 60 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static AI_FollowFormation_t g_HunterFollowFormation =
|
|
|
|
{
|
|
|
|
"Hunter",
|
|
|
|
AIFF_DEFAULT | AIFF_USE_FOLLOW_POINTS,
|
|
|
|
ARRAYSIZE(g_HunterFollowFormationSlots),
|
|
|
|
48, // followPointTolerance
|
|
|
|
48, // targetMoveTolerance
|
|
|
|
60,//180, // repathOnRouteTolerance
|
|
|
|
0, // walkTolerance
|
|
|
|
960, // coverTolerance
|
|
|
|
960, // enemyLOSTolerance
|
|
|
|
1920, // chaseEnemyTolerance
|
|
|
|
g_HunterFollowFormationSlots,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
static AI_FollowSlot_t g_VortigauntFollowFormationSlots[] =
|
|
|
|
{
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
{ 1, { 0, 0, 0 }, 0, 120, 160, 256, 128 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static AI_FollowFormation_t g_VortigauntFollowFormation =
|
|
|
|
{
|
|
|
|
"Vortigaunt",
|
|
|
|
AIFF_DEFAULT | AIFF_USE_FOLLOW_POINTS | AIFF_REQUIRE_LOS_OUTSIDE_COMBAT,
|
|
|
|
ARRAYSIZE(g_VortigauntFollowFormationSlots),
|
|
|
|
168, // followPointTolerance
|
|
|
|
36, // targetMoveTolerance
|
|
|
|
60, // repathOnRouteTolerance
|
|
|
|
190, // walkTolerance
|
|
|
|
300, // coverTolerance
|
|
|
|
(50*12), // enemyLOSTolerance
|
|
|
|
(50*12), // chaseEnemyTolerance
|
|
|
|
g_VortigauntFollowFormationSlots,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// NOTE: these must correspond with the AI_Formations_t enumeration in AI_Behavior_Follow.h!!
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
AI_FollowFormation_t *g_AI_Formations[] =
|
|
|
|
{
|
|
|
|
&g_SimpleFollowFormation,
|
|
|
|
&g_WideFollowFormation,
|
|
|
|
&g_AntlionFollowFormation,
|
|
|
|
&g_CommanderFollowFormation,
|
|
|
|
&g_TightFollowFormation,
|
|
|
|
&g_MediumFollowFormation,
|
|
|
|
&g_SidekickFollowFormation,
|
|
|
|
&g_HunterFollowFormation,
|
|
|
|
&g_VortigauntFollowFormation,
|
|
|
|
};
|
|
|
|
|
|
|
|
AI_FollowFormation_t *AIGetFormation( AI_Formations_t formation )
|
|
|
|
{
|
|
|
|
if ( formation < 0 )
|
|
|
|
formation = (AI_Formations_t)0;
|
|
|
|
else if ( formation >= ARRAYSIZE( g_AI_Formations ) )
|
|
|
|
formation = (AI_Formations_t)(ARRAYSIZE( g_AI_Formations ) - 1 );
|
|
|
|
|
|
|
|
return g_AI_Formations[formation];
|
|
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowManager::AddFollower( CBaseEntity *pTarget, CAI_BaseNPC *pFollower, AI_Formations_t formation, AI_FollowManagerInfoHandle_t *pHandle )
|
|
|
|
{
|
|
|
|
AI_FollowGroup_t *pGroup = FindCreateGroup( pTarget, formation );
|
|
|
|
int slot = FindBestSlot( pGroup );
|
|
|
|
|
|
|
|
if ( slot != -1 )
|
|
|
|
{
|
|
|
|
MEM_ALLOC_CREDIT();
|
|
|
|
|
|
|
|
AI_FollowSlot_t *pSlot = &pGroup->pFormation->pSlots[slot];
|
|
|
|
|
|
|
|
intp i = pGroup->followers.AddToTail( );
|
|
|
|
|
|
|
|
AI_Follower_t *iterNode = &pGroup->followers[i];
|
|
|
|
iterNode->hFollower = pFollower;
|
|
|
|
iterNode->slot = slot;
|
|
|
|
iterNode->pGroup = pGroup;
|
|
|
|
|
|
|
|
pGroup->slotUsage.Set( slot );
|
|
|
|
CalculateFieldsFromSlot( pSlot, &iterNode->navInfo );
|
|
|
|
|
|
|
|
pHandle->m_hFollower = i;
|
|
|
|
pHandle->m_pGroup = pGroup;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
pHandle->m_hFollower = 0;
|
|
|
|
pHandle->m_pGroup = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowManager::CalcFollowPosition( AI_FollowManagerInfoHandle_t& hInfo, AI_FollowNavInfo_t *pNavInfo )
|
|
|
|
{
|
|
|
|
if ( hInfo.m_pGroup && hInfo.m_hFollower )
|
|
|
|
{
|
|
|
|
AI_FollowGroup_t *pGroup = hInfo.m_pGroup;
|
|
|
|
Assert( pGroup->hFollowTarget.Get() );
|
|
|
|
CBaseEntity *pTarget = pGroup->hFollowTarget;
|
|
|
|
|
|
|
|
AI_Follower_t *iterNode = &pGroup->followers[hInfo.m_hFollower];
|
|
|
|
if ( iterNode->navInfo.position != vec3_origin )
|
|
|
|
{
|
|
|
|
QAngle angles = pTarget->GetLocalAngles();
|
|
|
|
angles.x = angles.z = 0;
|
|
|
|
|
|
|
|
matrix3x4_t fRotateMatrix;
|
|
|
|
AngleMatrix(angles, fRotateMatrix);
|
|
|
|
|
|
|
|
VectorRotate( iterNode->navInfo.position, fRotateMatrix, pNavInfo->position);
|
|
|
|
pNavInfo->position += pTarget->WorldSpaceCenter();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
pNavInfo->position = iterNode->navInfo.position + pTarget->WorldSpaceCenter();
|
|
|
|
}
|
|
|
|
|
|
|
|
pNavInfo->tolerance = iterNode->navInfo.tolerance;
|
|
|
|
pNavInfo->range = iterNode->navInfo.range;
|
|
|
|
pNavInfo->Zrange = iterNode->navInfo.Zrange;
|
|
|
|
pNavInfo->flags = pGroup->pFormation->flags;
|
|
|
|
pNavInfo->followPointTolerance = pGroup->pFormation->followPointTolerance;
|
|
|
|
pNavInfo->targetMoveTolerance = pGroup->pFormation->targetMoveTolerance;
|
|
|
|
pNavInfo->repathOnRouteTolerance = pGroup->pFormation->repathOnRouteTolerance;
|
|
|
|
pNavInfo->walkTolerance = pGroup->pFormation->walkTolerance;
|
|
|
|
pNavInfo->coverTolerance = pGroup->pFormation->coverTolerance;
|
|
|
|
pNavInfo->enemyLOSTolerance = pGroup->pFormation->enemyLOSTolerance;
|
|
|
|
pNavInfo->chaseEnemyTolerance = pGroup->pFormation->chaseEnemyTolerance;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
bool CAI_FollowManager::RedistributeSlots( AI_FollowGroup_t *pGroup )
|
|
|
|
{
|
|
|
|
bool result = false;
|
|
|
|
|
|
|
|
CUtlRBTree<CBaseEntity *> movedFollowers;
|
|
|
|
SetDefLessFunc( movedFollowers );
|
|
|
|
|
|
|
|
const Vector &originFollowed = pGroup->hFollowTarget->GetAbsOrigin();
|
|
|
|
int bestSlot;
|
|
|
|
|
|
|
|
while ( ( bestSlot = FindBestSlot( pGroup ) ) != -1 && ((int)movedFollowers.Count() < pGroup->followers.Count()) )
|
|
|
|
{
|
|
|
|
AI_FollowSlot_t * pSlot = &pGroup->pFormation->pSlots[bestSlot];
|
|
|
|
Vector slotPos = originFollowed + pSlot->position;
|
|
|
|
intp h = pGroup->followers.Head();
|
|
|
|
intp hBest = pGroup->followers.InvalidIndex();
|
|
|
|
float distSqBest = FLT_MAX;
|
|
|
|
|
|
|
|
while ( h != pGroup->followers.InvalidIndex() )
|
|
|
|
{
|
|
|
|
AI_Follower_t *p = &pGroup->followers[h];
|
|
|
|
|
|
|
|
if ( movedFollowers.Find( p->hFollower ) == movedFollowers.InvalidIndex() &&
|
|
|
|
( p->slot == -1 || pSlot->priority > pGroup->pFormation->pSlots[p->slot].priority ) )
|
|
|
|
{
|
|
|
|
float distSqCur = ( p->hFollower->GetAbsOrigin() - slotPos ).LengthSqr();
|
|
|
|
if ( distSqCur < distSqBest )
|
|
|
|
{
|
|
|
|
hBest = h;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
h = pGroup->followers.Next( h );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( hBest == pGroup->followers.InvalidIndex() )
|
|
|
|
break;
|
|
|
|
|
|
|
|
AI_Follower_t *pBest = &pGroup->followers[hBest];
|
|
|
|
if ( pBest->slot != -1 )
|
|
|
|
{
|
|
|
|
pGroup->slotUsage.Clear( pBest->slot );
|
|
|
|
}
|
|
|
|
pBest->slot = bestSlot;
|
|
|
|
CalculateFieldsFromSlot( pSlot, &pBest->navInfo );
|
|
|
|
pGroup->slotUsage.Set( bestSlot );
|
|
|
|
movedFollowers.Insert( pBest->hFollower );
|
|
|
|
result = true;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowManager::ChangeFormation( AI_FollowManagerInfoHandle_t& hInfo, AI_Formations_t formation )
|
|
|
|
{
|
|
|
|
if ( !hInfo.m_pGroup || !hInfo.m_hFollower )
|
|
|
|
return;
|
|
|
|
|
|
|
|
AI_FollowGroup_t *pGroup = hInfo.m_pGroup;
|
|
|
|
AI_FollowFormation_t *pNewFormation = AIGetFormation( formation );
|
|
|
|
if ( pNewFormation == pGroup->pFormation )
|
|
|
|
return;
|
|
|
|
|
|
|
|
intp h = pGroup->followers.Head();
|
|
|
|
|
|
|
|
while ( h != pGroup->followers.InvalidIndex() )
|
|
|
|
{
|
|
|
|
CAI_FollowBehavior *pFollowBehavior;
|
|
|
|
|
|
|
|
AI_Follower_t *p = &pGroup->followers[h];
|
|
|
|
p->slot = -1;
|
|
|
|
p->hFollower->GetBehavior( &pFollowBehavior );
|
|
|
|
Assert( pFollowBehavior );
|
|
|
|
if ( pFollowBehavior )
|
|
|
|
{
|
|
|
|
pFollowBehavior->m_params.formation = formation;
|
|
|
|
pFollowBehavior->m_TargetMonitor.ClearMark();
|
|
|
|
pFollowBehavior->SetCondition( CAI_FollowBehavior::COND_TARGET_MOVED_FROM_MARK );
|
|
|
|
pFollowBehavior->m_bTargetUnreachable = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
h = pGroup->followers.Next( h );
|
|
|
|
}
|
|
|
|
|
|
|
|
pGroup->slotUsage.ClearAll();
|
|
|
|
pGroup->pFormation = pNewFormation;
|
|
|
|
pGroup->slotUsage.Resize( pGroup->pFormation->nSlots );
|
|
|
|
|
|
|
|
RedistributeSlots( pGroup );
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
h = pGroup->followers.Head();
|
|
|
|
while ( h != pGroup->followers.InvalidIndex() )
|
|
|
|
{
|
|
|
|
AI_Follower_t *p = &pGroup->followers[h];
|
|
|
|
Assert( p->slot != -1 );
|
|
|
|
h = pGroup->followers.Next( h );
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowManager::RemoveFollower( AI_FollowManagerInfoHandle_t& hInfo )
|
|
|
|
{
|
|
|
|
if ( hInfo.m_pGroup && hInfo.m_hFollower )
|
|
|
|
{
|
|
|
|
AI_FollowGroup_t *pGroup = hInfo.m_pGroup;
|
|
|
|
AI_Follower_t* iterNode = &pGroup->followers[hInfo.m_hFollower];
|
|
|
|
|
|
|
|
intp slot = iterNode->slot;
|
|
|
|
pGroup->slotUsage.Clear( slot );
|
|
|
|
pGroup->followers.Remove( hInfo.m_hFollower );
|
|
|
|
if ( pGroup->followers.Count() == 0 )
|
|
|
|
{
|
|
|
|
RemoveGroup( pGroup );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if ( pGroup->hFollowTarget != NULL ) // NULL on level unload
|
|
|
|
{
|
|
|
|
RedistributeSlots( pGroup );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
int CAI_FollowManager::FindBestSlot( AI_FollowGroup_t *pGroup )
|
|
|
|
{
|
|
|
|
// @TODO (toml 02-28-03): crude placeholder
|
|
|
|
int nSlots = pGroup->pFormation->nSlots;
|
|
|
|
|
|
|
|
int best = -1;
|
|
|
|
int bestPriority = -1;
|
|
|
|
|
|
|
|
for ( int i = 0; i < nSlots; i++ )
|
|
|
|
{
|
|
|
|
if ( !pGroup->slotUsage.IsBitSet( i ) && pGroup->pFormation->pSlots[i].priority > bestPriority )
|
|
|
|
{
|
|
|
|
bestPriority = pGroup->pFormation->pSlots[i].priority;
|
|
|
|
best = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return best;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowManager::CalculateFieldsFromSlot( AI_FollowSlot_t *pSlot, AI_FollowNavInfo_t *pFollowerInfo )
|
|
|
|
{
|
|
|
|
// @TODO (toml 02-28-03): placeholder. Force break if someone tries to actually use
|
|
|
|
Assert( pSlot->positionVariability == 0.0 );
|
|
|
|
//Assert( pSlot->tolerance == AIN_DEF_TOLERANCE );
|
|
|
|
|
|
|
|
pFollowerInfo->position = pSlot->position;
|
|
|
|
pFollowerInfo->range = random->RandomFloat( pSlot->rangeMin, pSlot->rangeMax );
|
|
|
|
pFollowerInfo->Zrange = pSlot->Zrange;
|
|
|
|
pFollowerInfo->tolerance = pSlot->tolerance;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
AI_FollowGroup_t *CAI_FollowManager::FindCreateGroup( CBaseEntity *pTarget, AI_Formations_t formation )
|
|
|
|
{
|
|
|
|
AI_FollowGroup_t *pGroup = FindGroup( pTarget );
|
|
|
|
|
|
|
|
if ( !pGroup )
|
|
|
|
{
|
|
|
|
{
|
|
|
|
MEM_ALLOC_CREDIT();
|
|
|
|
pGroup = new AI_FollowGroup_t;
|
|
|
|
}
|
|
|
|
|
|
|
|
pGroup->pFormation = AIGetFormation( formation );
|
|
|
|
pGroup->slotUsage.Resize( pGroup->pFormation->nSlots );
|
|
|
|
pGroup->hFollowTarget = pTarget;
|
|
|
|
|
|
|
|
m_groups.AddToHead( pGroup );
|
|
|
|
}
|
|
|
|
|
|
|
|
return pGroup;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
void CAI_FollowManager::RemoveGroup( AI_FollowGroup_t *pGroup )
|
|
|
|
{
|
|
|
|
for ( int i = 0; i < m_groups.Count(); i++ )
|
|
|
|
{
|
|
|
|
if ( m_groups[i] == pGroup )
|
|
|
|
{
|
|
|
|
delete m_groups[i];
|
|
|
|
m_groups.FastRemove(i);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
AI_FollowGroup_t *CAI_FollowManager::FindGroup( CBaseEntity *pTarget )
|
|
|
|
{
|
|
|
|
for ( int i = 0; i < m_groups.Count(); i++ )
|
|
|
|
{
|
|
|
|
if ( m_groups[i]->hFollowTarget == pTarget )
|
|
|
|
return m_groups[i];
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------
|
|
|
|
|
|
|
|
AI_FollowGroup_t *CAI_FollowManager::FindFollowerGroup( CBaseEntity *pFollower )
|
|
|
|
{
|
|
|
|
for ( int i = 0; i < m_groups.Count(); i++ )
|
|
|
|
{
|
|
|
|
intp h = m_groups[i]->followers.Head();
|
|
|
|
while( h != m_groups[i]->followers.InvalidIndex() )
|
|
|
|
{
|
|
|
|
AI_Follower_t *p = &m_groups[i]->followers[h];
|
|
|
|
if ( p->hFollower.Get() == pFollower )
|
|
|
|
return m_groups[i];
|
|
|
|
h = m_groups[i]->followers.Next( h );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
AI_BEGIN_CUSTOM_SCHEDULE_PROVIDER(CAI_FollowBehavior)
|
|
|
|
|
|
|
|
DECLARE_TASK(TASK_CANT_FOLLOW)
|
|
|
|
DECLARE_TASK(TASK_FACE_FOLLOW_TARGET)
|
|
|
|
DECLARE_TASK(TASK_MOVE_TO_FOLLOW_POSITION)
|
|
|
|
DECLARE_TASK(TASK_GET_PATH_TO_FOLLOW_POSITION)
|
|
|
|
DECLARE_TASK(TASK_SET_FOLLOW_TARGET_MARK)
|
|
|
|
DECLARE_TASK(TASK_FOLLOWER_FACE_TACTICAL)
|
|
|
|
DECLARE_TASK(TASK_SET_FOLLOW_DELAY)
|
|
|
|
DECLARE_TASK(TASK_GET_PATH_TO_FOLLOW_POINT)
|
|
|
|
DECLARE_TASK(TASK_ARRIVE_AT_FOLLOW_POINT)
|
|
|
|
DECLARE_TASK(TASK_BEGIN_STAND_AT_WAIT_POINT)
|
|
|
|
DECLARE_TASK(TASK_SET_FOLLOW_POINT_STAND_SCHEDULE)
|
|
|
|
|
|
|
|
DECLARE_CONDITION(COND_TARGET_MOVED_FROM_MARK)
|
|
|
|
DECLARE_CONDITION(COND_FOUND_WAIT_POINT)
|
|
|
|
DECLARE_CONDITION(COND_FOLLOW_DELAY_EXPIRED)
|
|
|
|
DECLARE_CONDITION(COND_FOLLOW_TARGET_VISIBLE)
|
|
|
|
DECLARE_CONDITION(COND_FOLLOW_TARGET_NOT_VISIBLE)
|
|
|
|
DECLARE_CONDITION(COND_FOLLOW_WAIT_POINT_INVALID)
|
|
|
|
DECLARE_CONDITION(COND_FOLLOW_PLAYER_IS_LIT)
|
|
|
|
DECLARE_CONDITION(COND_FOLLOW_PLAYER_IS_NOT_LIT)
|
|
|
|
|
|
|
|
//=========================================================
|
|
|
|
// > SCHED_FOLLOWER_MOVE_AWAY_END
|
|
|
|
//=========================================================
|
|
|
|
DEFINE_SCHEDULE
|
|
|
|
(
|
|
|
|
SCHED_FOLLOWER_MOVE_AWAY_END,
|
|
|
|
|
|
|
|
" Tasks"
|
|
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_FOLLOWER_MOVE_AWAY_FAIL "
|
|
|
|
" TASK_STOP_MOVING 0"
|
|
|
|
" TASK_FACE_FOLLOW_TARGET 0"
|
|
|
|
" TASK_SET_FOLLOW_DELAY 2"
|
|
|
|
""
|
|
|
|
" Interrupts"
|
|
|
|
" COND_PLAYER_PUSHING"
|
|
|
|
)
|
|
|
|
|
|
|
|
//=========================================================
|
|
|
|
// > SCHED_FOLLOWER_MOVE_AWAY_FAIL
|
|
|
|
//=========================================================
|
|
|
|
DEFINE_SCHEDULE
|
|
|
|
(
|
|
|
|
SCHED_FOLLOWER_MOVE_AWAY_FAIL,
|
|
|
|
|
|
|
|
" Tasks"
|
|
|
|
" TASK_STOP_MOVING 0"
|
|
|
|
" TASK_FACE_FOLLOW_TARGET 0"
|
|
|
|
" TASK_SET_FOLLOW_DELAY 2"
|
|
|
|
""
|
|
|
|
" Interrupts"
|
|
|
|
" COND_PLAYER_PUSHING"
|
|
|
|
)
|
|
|
|
|
|
|
|
//=========================================================
|
|
|
|
// > SCHED_FOLLOW
|
|
|
|
//=========================================================
|
|
|
|
DEFINE_SCHEDULE
|
|
|
|
(
|
|
|
|
SCHED_FOLLOW,
|
|
|
|
|
|
|
|
" Tasks"
|
|
|
|
" TASK_GET_PATH_TO_FOLLOW_POSITION 0"
|
|
|
|
" TASK_MOVE_TO_FOLLOW_POSITION 0"
|
|
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
|
|
" TASK_SET_SCHEDULE SCHEDULE:SCHED_TARGET_FACE "
|
|
|
|
""
|
|
|
|
" Interrupts"
|
|
|
|
" COND_NEW_ENEMY"
|
|
|
|
" COND_LIGHT_DAMAGE"
|
|
|
|
" COND_HEAVY_DAMAGE"
|
|
|
|
" COND_HEAR_DANGER"
|
|
|
|
" COND_PROVOKED"
|
|
|
|
" COND_PLAYER_PUSHING"
|
|
|
|
" COND_BETTER_WEAPON_AVAILABLE"
|
|
|
|
);
|
|
|
|
|
|
|
|
//=========================================================
|
|
|
|
// > SCHED_MOVE_TO_FACE_FOLLOW_TARGET
|
|
|
|
//=========================================================
|
|
|
|
DEFINE_SCHEDULE
|
|
|
|
(
|
|
|
|
SCHED_MOVE_TO_FACE_FOLLOW_TARGET,
|
|
|
|
|
|
|
|
" Tasks"
|
|
|
|
// " TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
|
|
// " TASK_FACE_FOLLOW_TARGET 0"
|
|
|
|
// " TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
|
|
" TASK_SET_SCHEDULE SCHEDULE:SCHED_FOLLOW"
|
|
|
|
""
|
|
|
|
" Interrupts"
|
|
|
|
" COND_NEW_ENEMY"
|
|
|
|
" COND_LIGHT_DAMAGE"
|
|
|
|
" COND_HEAVY_DAMAGE"
|
|
|
|
" COND_HEAR_DANGER"
|
|
|
|
" COND_PROVOKED"
|
|
|
|
" COND_PLAYER_PUSHING"
|
|
|
|
)
|
|
|
|
|
|
|
|
//=========================================================
|
|
|
|
// > SCHED_FACE_FOLLOW_TARGET
|
|
|
|
//=========================================================
|
|
|
|
DEFINE_SCHEDULE
|
|
|
|
(
|
|
|
|
SCHED_FACE_FOLLOW_TARGET,
|
|
|
|
|
|
|
|
" Tasks"
|
|
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
|
|
" TASK_FACE_FOLLOW_TARGET 0"
|
|
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
|
|
" TASK_SET_SCHEDULE SCHEDULE:SCHED_FOLLOWER_IDLE_STAND "
|
|
|
|
""
|
|
|
|
" Interrupts"
|
|
|
|
" COND_NEW_ENEMY"
|
|
|
|
" COND_LIGHT_DAMAGE"
|
|
|
|
" COND_HEAVY_DAMAGE"
|
|
|
|
" COND_HEAR_DANGER"
|
|
|
|
" COND_PROVOKED"
|
|
|
|
" COND_PLAYER_PUSHING"
|
|
|
|
" COND_GIVE_WAY"
|
|
|
|
)
|
|
|
|
|
|
|
|
//=========================================================
|
|
|
|
// > SCHED_FOLLOWER_GO_TO_WAIT_POINT
|
|
|
|
//=========================================================
|
|
|
|
DEFINE_SCHEDULE
|
|
|
|
(
|
|
|
|
SCHED_FOLLOWER_GO_TO_WAIT_POINT,
|
|
|
|
|
|
|
|
" Tasks"
|
|
|
|
" TASK_LOCK_HINTNODE 0 " // this will fail the schedule if no hint node or not already lockable
|
|
|
|
" TASK_SET_FAIL_SCHEDULE SCHEDULE:SCHED_FOLLOWER_GO_TO_WAIT_POINT_FAIL"
|
|
|
|
" TASK_SET_TOLERANCE_DISTANCE 4"
|
|
|
|
" TASK_GET_PATH_TO_FOLLOW_POINT 0"
|
|
|
|
" TASK_SET_FOLLOW_TARGET_MARK 0"
|
|
|
|
" TASK_WALK_PATH 0"
|
|
|
|
" TASK_WAIT_FOR_MOVEMENT 0"
|
|
|
|
" TASK_ARRIVE_AT_FOLLOW_POINT 0"
|
|
|
|
" TASK_SET_FOLLOW_POINT_STAND_SCHEDULE 0"
|
|
|
|
|
|
|
|
""
|
|
|
|
" Interrupts"
|
|
|
|
" COND_NEW_ENEMY"
|
|
|
|
" COND_LIGHT_DAMAGE"
|
|
|
|
" COND_HEAVY_DAMAGE"
|
|
|
|
" COND_HEAR_DANGER"
|
|
|
|
" COND_PROVOKED"
|
|
|
|
" COND_PLAYER_PUSHING"
|
|
|
|
" COND_TARGET_MOVED_FROM_MARK"
|
|
|
|
)
|
|
|
|
|
|
|
|
//=========================================================
|
|
|
|
// > SCHED_FOLLOWER_GO_TO_WAIT_POINT_FAIL
|
|
|
|
//=========================================================
|
|
|
|
DEFINE_SCHEDULE
|
|
|
|
(
|
|
|
|
SCHED_FOLLOWER_GO_TO_WAIT_POINT_FAIL,
|
|
|
|
|
|
|
|
" Tasks"
|
|
|
|
" TASK_CLEAR_HINTNODE .5"
|
|
|
|
" TASK_SET_FOLLOW_DELAY 1"
|
|
|
|
""
|
|
|
|
" Interrupts"
|
|
|
|
)
|
|
|
|
|
|
|
|
//=========================================================
|
|
|
|
// > SCHED_FOLLOWER_STAND_AT_WAIT_POINT
|
|
|
|
//=========================================================
|
|
|
|
DEFINE_SCHEDULE
|
|
|
|
(
|
|
|
|
SCHED_FOLLOWER_STAND_AT_WAIT_POINT,
|
|
|
|
|
|
|
|
" Tasks"
|
|
|
|
" TASK_BEGIN_STAND_AT_WAIT_POINT 0"
|
|
|
|
" TASK_PLAY_HINT_ACTIVITY 0"
|
|
|
|
" TASK_SET_SCHEDULE SCHEDULE:SCHED_FOLLOWER_STAND_AT_WAIT_POINT "
|
|
|
|
""
|
|
|
|
" Interrupts"
|
|
|
|
" COND_NEW_ENEMY"
|
|
|
|
" COND_LIGHT_DAMAGE"
|
|
|
|
" COND_HEAVY_DAMAGE"
|
|
|
|
" COND_HEAR_DANGER"
|
|
|
|
" COND_PROVOKED"
|
|
|
|
" COND_PLAYER_PUSHING"
|
|
|
|
" COND_TARGET_MOVED_FROM_MARK"
|
|
|
|
" COND_GIVE_WAY"
|
|
|
|
" COND_FOLLOW_WAIT_POINT_INVALID"
|
|
|
|
// " COND_IDLE_INTERRUPT"
|
|
|
|
)
|
|
|
|
|
|
|
|
DEFINE_SCHEDULE
|
|
|
|
(
|
|
|
|
SCHED_FOLLOWER_IDLE_STAND,
|
|
|
|
|
|
|
|
" Tasks"
|
|
|
|
" TASK_STOP_MOVING 0"
|
|
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
|
|
// " TASK_SET_FOLLOW_TARGET_MARK 0"
|
|
|
|
" TASK_WAIT 2.5"
|
|
|
|
" TASK_FACE_FOLLOW_TARGET 0"
|
|
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
|
|
" TASK_WAIT 3"
|
|
|
|
""
|
|
|
|
" Interrupts"
|
|
|
|
" COND_NEW_ENEMY"
|
|
|
|
" COND_SEE_FEAR"
|
|
|
|
" COND_CAN_RANGE_ATTACK1"
|
|
|
|
" COND_NO_PRIMARY_AMMO"
|
|
|
|
" COND_LIGHT_DAMAGE"
|
|
|
|
" COND_HEAVY_DAMAGE"
|
|
|
|
" COND_SMELL"
|
|
|
|
" COND_PROVOKED"
|
|
|
|
" COND_GIVE_WAY"
|
|
|
|
" COND_HEAR_DANGER"
|
|
|
|
" COND_HEAR_COMBAT"
|
|
|
|
" COND_HEAR_BULLET_IMPACT"
|
|
|
|
" COND_PLAYER_PUSHING"
|
|
|
|
" COND_TARGET_MOVED_FROM_MARK"
|
|
|
|
" COND_FOLLOW_DELAY_EXPIRED"
|
|
|
|
" COND_FOUND_WAIT_POINT"
|
|
|
|
" COND_IDLE_INTERRUPT"
|
|
|
|
" COND_BETTER_WEAPON_AVAILABLE"
|
|
|
|
)
|
|
|
|
|
|
|
|
DEFINE_SCHEDULE
|
|
|
|
(
|
|
|
|
SCHED_FOLLOWER_COMBAT_FACE,
|
|
|
|
|
|
|
|
" Tasks"
|
|
|
|
" TASK_STOP_MOVING 0"
|
|
|
|
" TASK_SET_ACTIVITY ACTIVITY:ACT_IDLE"
|
|
|
|
" TASK_FACE_ENEMY 0"
|
|
|
|
""
|
|
|
|
" Interrupts"
|
|
|
|
" COND_NEW_ENEMY"
|
|
|
|
" COND_SEE_FEAR"
|
|
|
|
" COND_CAN_RANGE_ATTACK1"
|
|
|
|
" COND_CAN_RANGE_ATTACK2"
|
|
|
|
" COND_CAN_MELEE_ATTACK1"
|
|
|
|
" COND_CAN_MELEE_ATTACK2"
|
|
|
|
" COND_NO_PRIMARY_AMMO"
|
|
|
|
" COND_LIGHT_DAMAGE"
|
|
|
|
" COND_HEAVY_DAMAGE"
|
|
|
|
" COND_SMELL"
|
|
|
|
" COND_PROVOKED"
|
|
|
|
" COND_GIVE_WAY"
|
|
|
|
" COND_HEAR_DANGER"
|
|
|
|
" COND_HEAR_COMBAT"
|
|
|
|
" COND_HEAR_BULLET_IMPACT"
|
|
|
|
" COND_PLAYER_PUSHING"
|
|
|
|
" COND_TARGET_MOVED_FROM_MARK"
|
|
|
|
" COND_FOLLOW_DELAY_EXPIRED"
|
|
|
|
" COND_FOUND_WAIT_POINT"
|
|
|
|
" COND_BETTER_WEAPON_AVAILABLE"
|
|
|
|
)
|
|
|
|
|
|
|
|
AI_END_CUSTOM_SCHEDULE_PROVIDER()
|
|
|
|
|
|
|
|
//=============================================================================
|