d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
153 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: ae8b73626e
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ae8b73626e'
${ noResults }
source-engine/game/server/hl2/ai_behavior_actbusy.cpp

3151 lines
96 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "ai_behavior_actbusy.h"
#include "ai_navigator.h"
#include "ai_hint.h"
#include "ai_behavior_follow.h"
#include "KeyValues.h"
#include "filesystem.h"
#include "eventqueue.h"
#include "ai_playerally.h"
#include "SoundEmitterSystem/isoundemittersystembase.h"
#include "entityblocker.h"
#include "npcevent.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#define ACTBUSY_SEE_ENTITY_TIMEOUT 1.0f
#define ACTBUSY_COMBAT_PLAYER_MAX_DIST 720.0f // NPCs in combat actbusy should try to stay within this distance of the player.
ConVar ai_actbusy_search_time( "ai_actbusy_search_time","10.0" );
ConVar ai_debug_actbusy( "ai_debug_actbusy", "0", FCVAR_CHEAT, "Used to debug actbusy behavior. Usage:\n\
1: Constantly draw lines from NPCs to the actbusy nodes they've chosen to actbusy at.\n\
2: Whenever an NPC makes a decision to use an actbusy, show which actbusy they've chosen.\n\
3: Selected NPCs (with npc_select) will report why they're not choosing actbusy nodes.\n\
4: Display debug output of actbusy logic.\n\
5: Display safe zone volumes and info.\n\
");
// Anim events
static int AE_ACTBUSY_WEAPON_FIRE_ON;
static int AE_ACTBUSY_WEAPON_FIRE_OFF;
BEGIN_DATADESC( CAI_ActBusyBehavior )
DEFINE_FIELD( m_bEnabled, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bForceActBusy, FIELD_BOOLEAN ),
DEFINE_CUSTOM_FIELD( m_ForcedActivity, ActivityDataOps() ),
DEFINE_FIELD( m_bTeleportToBusy, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bUseNearestBusy, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bLeaving, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bVisibleOnly, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bUseRenderBoundsForCollision, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flForcedMaxTime, FIELD_FLOAT ),
DEFINE_FIELD( m_bBusy, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bMovingToBusy, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bNeedsToPlayExitAnim, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flNextBusySearchTime, FIELD_TIME ),
DEFINE_FIELD( m_flEndBusyAt, FIELD_TIME ),
DEFINE_FIELD( m_flBusySearchRange, FIELD_FLOAT ),
DEFINE_FIELD( m_bInQueue, FIELD_BOOLEAN ),
DEFINE_FIELD( m_iCurrentBusyAnim, FIELD_INTEGER ),
DEFINE_FIELD( m_hActBusyGoal, FIELD_EHANDLE ),
DEFINE_FIELD( m_bNeedToSetBounds, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hSeeEntity, FIELD_EHANDLE ),
DEFINE_FIELD( m_fTimeLastSawSeeEntity, FIELD_TIME ),
DEFINE_FIELD( m_bExitedBusyToDueLostSeeEntity, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bExitedBusyToDueSeeEnemy, FIELD_BOOLEAN ),
DEFINE_FIELD( m_iNumConsecutivePathFailures, FIELD_INTEGER ),
DEFINE_FIELD( m_bAutoFireWeapon, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flDeferUntil, FIELD_TIME ),
DEFINE_FIELD( m_iNumEnemiesInSafeZone, FIELD_INTEGER ),
END_DATADESC();
enum
{
ACTBUSY_SIGHT_METHOD_FULL = 0, // LOS and Viewcone
ACTBUSY_SIGHT_METHOD_LOS_ONLY,
};
//=============================================================================
//-----------------------------------------------------------------------------
// Purpose: Gamesystem that parses the act busy anim file
//-----------------------------------------------------------------------------
class CActBusyAnimData : public CAutoGameSystem
{
public:
CActBusyAnimData( void ) : CAutoGameSystem( "CActBusyAnimData" )
{
}
// Inherited from IAutoServerSystem
virtual void LevelInitPostEntity( void );
virtual void LevelShutdownPostEntity( void );
// Read in the data from the anim data file
void ParseAnimDataFile( void );
// Parse a keyvalues section into an act busy anim
bool ParseActBusyFromKV( busyanim_t *pAnim, KeyValues *pSection );
// Purpose: Returns the index of the busyanim data for the specified activity or sequence
int FindBusyAnim( Activity iActivity, const char *pSequence );
busyanim_t *GetBusyAnim( int iIndex ) { return &m_ActBusyAnims[iIndex]; }
protected:
CUtlVector<busyanim_t> m_ActBusyAnims;
};
CActBusyAnimData g_ActBusyAnimDataSystem;
//-----------------------------------------------------------------------------
// Inherited from IAutoServerSystem
//-----------------------------------------------------------------------------
void CActBusyAnimData::LevelInitPostEntity( void )
{
ParseAnimDataFile();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CActBusyAnimData::LevelShutdownPostEntity( void )
{
m_ActBusyAnims.Purge();
}
//-----------------------------------------------------------------------------
// Clear out the stats + their history
//-----------------------------------------------------------------------------
void CActBusyAnimData::ParseAnimDataFile( void )
{
KeyValues *pKVAnimData = new KeyValues( "ActBusyAnimDatafile" );
if ( pKVAnimData->LoadFromFile( filesystem, "scripts/actbusy.txt" ) )
{
// Now try and parse out each act busy anim
KeyValues *pKVAnim = pKVAnimData->GetFirstSubKey();
while ( pKVAnim )
{
// Create a new anim and add it to our list
int index = m_ActBusyAnims.AddToTail();
busyanim_t *pAnim = &m_ActBusyAnims[index];
if ( !ParseActBusyFromKV( pAnim, pKVAnim ) )
{
m_ActBusyAnims.Remove( index );
}
pKVAnim = pKVAnim->GetNextKey();
}
}
pKVAnimData->deleteThis();
}
//-----------------------------------------------------------------------------
// Purpose: Parse a keyvalues section into the prop
//-----------------------------------------------------------------------------
bool CActBusyAnimData::ParseActBusyFromKV( busyanim_t *pAnim, KeyValues *pSection )
{
pAnim->iszName = AllocPooledString( pSection->GetName() );
// Activities
pAnim->iActivities[BA_BUSY] = (Activity)CAI_BaseNPC::GetActivityID( pSection->GetString( "busy_anim", "ACT_INVALID" ) );
pAnim->iActivities[BA_ENTRY] = (Activity)CAI_BaseNPC::GetActivityID( pSection->GetString( "entry_anim", "ACT_INVALID" ) );
pAnim->iActivities[BA_EXIT] = (Activity)CAI_BaseNPC::GetActivityID( pSection->GetString( "exit_anim", "ACT_INVALID" ) );
// Sequences
pAnim->iszSequences[BA_BUSY] = AllocPooledString( pSection->GetString( "busy_sequence", NULL ) );
pAnim->iszSequences[BA_ENTRY] = AllocPooledString( pSection->GetString( "entry_sequence", NULL ) );
pAnim->iszSequences[BA_EXIT] = AllocPooledString( pSection->GetString( "exit_sequence", NULL ) );
// Sounds
pAnim->iszSounds[BA_BUSY] = AllocPooledString( pSection->GetString( "busy_sound", NULL ) );
pAnim->iszSounds[BA_ENTRY] = AllocPooledString( pSection->GetString( "entry_sound", NULL ) );
pAnim->iszSounds[BA_EXIT] = AllocPooledString( pSection->GetString( "exit_sound", NULL ) );
// Times
pAnim->flMinTime = pSection->GetFloat( "min_time", 10.0 );
pAnim->flMaxTime = pSection->GetFloat( "max_time", 20.0 );
pAnim->bUseAutomovement = pSection->GetInt( "use_automovement", 0 ) != 0;
const char *sInterrupt = pSection->GetString( "interrupts", "BA_INT_DANGER" );
if ( !strcmp( sInterrupt, "BA_INT_PLAYER" ) )
{
pAnim->iBusyInterruptType = BA_INT_PLAYER;
}
else if ( !strcmp( sInterrupt, "BA_INT_DANGER" ) )
{
pAnim->iBusyInterruptType = BA_INT_DANGER;
}
else if ( !strcmp( sInterrupt, "BA_INT_AMBUSH" ) )
{
pAnim->iBusyInterruptType = BA_INT_AMBUSH;
}
else if ( !strcmp( sInterrupt, "BA_INT_COMBAT" ) )
{
pAnim->iBusyInterruptType = BA_INT_COMBAT;
}
else if ( !strcmp( sInterrupt, "BA_INT_ZOMBIESLUMP" ))
{
pAnim->iBusyInterruptType = BA_INT_ZOMBIESLUMP;
}
else if ( !strcmp( sInterrupt, "BA_INT_SIEGE_DEFENSE" ))
{
pAnim->iBusyInterruptType = BA_INT_SIEGE_DEFENSE;
}
else
{
pAnim->iBusyInterruptType = BA_INT_NONE;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the busyanim data for the specified activity
//-----------------------------------------------------------------------------
int CActBusyAnimData::FindBusyAnim( Activity iActivity, const char *pSequence )
{
int iCount = m_ActBusyAnims.Count();
for ( int i = 0; i < iCount; i++ )
{
busyanim_t *pBusyAnim = &m_ActBusyAnims[i];
Assert( pBusyAnim );
if ( pSequence && pBusyAnim->iszName != NULL_STRING && !Q_stricmp( STRING(pBusyAnim->iszName), pSequence ) )
return i;
if ( iActivity != ACT_INVALID && pBusyAnim->iActivities[BA_BUSY] == iActivity )
return i;
}
if ( pSequence )
{
Warning("Specified '%s' as a busy anim name, and it's not in the act busy anim list.\n", pSequence );
}
else if ( iActivity != ACT_INVALID )
{
Warning("Tried to use Activity %d as a busy anim, and it's not in the act busy anim list.\n", iActivity );
}
return -1;
}
//=============================================================================================================
//=============================================================================================================
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CAI_ActBusyBehavior::CAI_ActBusyBehavior()
{
// Disabled by default. Enabled by map entity.
m_bEnabled = false;
m_bUseRenderBoundsForCollision = false;
m_flDeferUntil = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::Enable( CAI_ActBusyGoal *pGoal, float flRange, bool bVisibleOnly )
{
NotifyBusyEnding();
if ( pGoal )
{
m_hActBusyGoal = pGoal;
}
m_bEnabled = true;
m_bBusy = false;
m_bMovingToBusy = false;
m_bNeedsToPlayExitAnim = false;
m_bLeaving = false;
m_flNextBusySearchTime = gpGlobals->curtime + ai_actbusy_search_time.GetFloat();
m_flEndBusyAt = 0;
m_bVisibleOnly = bVisibleOnly;
m_bInQueue = dynamic_cast<CAI_ActBusyQueueGoal*>(m_hActBusyGoal.Get()) != NULL;
m_ForcedActivity = ACT_INVALID;
m_hSeeEntity = NULL;
m_bExitedBusyToDueLostSeeEntity = false;
m_bExitedBusyToDueSeeEnemy = false;
m_iNumConsecutivePathFailures = 0;
SetBusySearchRange( flRange );
if ( ai_debug_actbusy.GetInt() == 4 )
{
Msg("ACTBUSY: behavior enabled on NPC %s (%s)\n", GetOuter()->GetClassname(), GetOuter()->GetDebugName() );
}
if( IsCombatActBusy() )
{
CollectSafeZoneVolumes( pGoal );
}
// Robin: Due to ai goal entities delaying their EnableGoal call on each
// of their target Actors, NPCs that are spawned with active actbusies
// will have their SelectSchedule() called before their behavior has been
// enabled. To fix this, if we're enabled while in a schedule that can be
// overridden, immediately act busy.
if ( IsCurScheduleOverridable() )
{
// Force search time to be now.
m_flNextBusySearchTime = gpGlobals->curtime;
GetOuter()->ClearSchedule( "Enabling act busy" );
}
ClearCondition( COND_ACTBUSY_AWARE_OF_ENEMY_IN_SAFE_ZONE );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::OnRestore()
{
if ( m_bEnabled && m_hActBusyGoal != NULL && IsCombatActBusy() )
{
CollectSafeZoneVolumes( m_hActBusyGoal );
}
BaseClass::OnRestore();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::SetBusySearchRange( float flRange )
{
m_flBusySearchRange = flRange;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::Disable( void )
{
if ( ai_debug_actbusy.GetInt() == 4 )
{
Msg("ACTBUSY: behavior disabled on NPC %s (%s)\n", GetOuter()->GetClassname(), GetOuter()->GetDebugName() );
}
if ( m_bEnabled )
{
SetCondition( COND_PROVOKED );
}
StopBusying();
m_bEnabled = false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::ForceActBusy( CAI_ActBusyGoal *pGoal, CAI_Hint *pHintNode, float flMaxTime, bool bVisibleOnly, bool bTeleportToBusy, bool bUseNearestBusy, CBaseEntity *pSeeEntity, Activity activity )
{
Assert( !m_bLeaving );
if ( m_bNeedsToPlayExitAnim )
{
// If we hit this, the mapmaker's told this NPC to actbusy somewhere while it's still in an actbusy.
// Right now, we don't support this. We could support it with a bit of work.
if ( HasAnimForActBusy( m_iCurrentBusyAnim, BA_EXIT ) )
{
Warning("ACTBUSY: %s(%s) was told to actbusy while inside an actbusy that needs to exit first. IGNORING.\n", GetOuter()->GetDebugName(), GetOuter()->GetClassname() );
return;
}
}
if ( ai_debug_actbusy.GetInt() == 4 )
{
Msg("ACTBUSY: ForceActBusy on NPC %s (%s): ", GetOuter()->GetClassname(), GetOuter()->GetDebugName() );
if ( pHintNode )
{
Msg("Hintnode %s", pHintNode->GetDebugName());
}
else
{
Msg("No Hintnode specified");
}
Msg("\n");
}
Enable( pGoal, m_flBusySearchRange, bVisibleOnly );
m_bForceActBusy = true;
m_flForcedMaxTime = flMaxTime;
m_bTeleportToBusy = bTeleportToBusy;
m_bUseNearestBusy = bUseNearestBusy;
m_ForcedActivity = activity;
m_hSeeEntity = pSeeEntity;
if ( pHintNode )
{
if ( GetHintNode() && GetHintNode() != pHintNode )
{
GetHintNode()->Unlock();
}
if ( pHintNode->Lock( GetOuter() ) )
{
SetHintNode( pHintNode );
}
}
SetCondition( COND_PROVOKED );
}
//-----------------------------------------------------------------------------
// Purpose: Force the NPC to find an exit node and leave
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::ForceActBusyLeave( bool bVisibleOnly )
{
if ( ai_debug_actbusy.GetInt() == 4 )
{
Msg("ACTBUSY: ForceActBusyLeave on NPC %s (%s)\n", GetOuter()->GetClassname(), GetOuter()->GetDebugName() );
}
Enable( NULL, m_flBusySearchRange, bVisibleOnly );
m_bForceActBusy = true;
m_bLeaving = true;
m_ForcedActivity = ACT_INVALID;
m_hSeeEntity = NULL;
SetCondition( COND_PROVOKED );
}
//-----------------------------------------------------------------------------
// Purpose: Break the NPC out of the current busy state, but don't disable busying
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::StopBusying( void )
{
if ( !GetOuter() )
return;
// Make sure we turn this off unconditionally!
m_bAutoFireWeapon = false;
if ( ai_debug_actbusy.GetInt() == 4 )
{
Msg("ACTBUSY: StopBusying on NPC %s (%s)\n", GetOuter()->GetClassname(), GetOuter()->GetDebugName() );
}
if ( m_bBusy || m_bMovingToBusy )
{
SetCondition( COND_PROVOKED );
}
m_flEndBusyAt = gpGlobals->curtime;
m_bForceActBusy = false;
m_bTeleportToBusy = false;
m_bUseNearestBusy = false;
m_bLeaving = false;
m_bMovingToBusy = false;
m_ForcedActivity = ACT_INVALID;
m_hSeeEntity = NULL;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::IsStopBusying()
{
return IsCurSchedule(SCHED_ACTBUSY_STOP_BUSYING);
}
//-----------------------------------------------------------------------------
// Purpose: Find a general purpose, suitable Hint Node for me to Act Busy.
//-----------------------------------------------------------------------------
CAI_Hint *CAI_ActBusyBehavior::FindActBusyHintNode()
{
Assert( !IsCombatActBusy() );
int iBits = bits_HINT_NODE_USE_GROUP;
if ( m_bVisibleOnly )
{
iBits |= bits_HINT_NODE_VISIBLE;
}
if ( ai_debug_actbusy.GetInt() == 3 && GetOuter()->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT )
{
iBits |= bits_HINT_NODE_REPORT_FAILURES;
}
if ( m_bUseNearestBusy )
{
iBits |= bits_HINT_NODE_NEAREST;
}
else
{
iBits |= bits_HINT_NODE_RANDOM;
}
CAI_Hint *pNode = CAI_HintManager::FindHint( GetOuter(), HINT_WORLD_WORK_POSITION, iBits, m_flBusySearchRange );
return pNode;
}
//-----------------------------------------------------------------------------
// Purpose: Find a node for me to combat act busy.
//
// Right now, all of this work assumes the actbusier is a player ally and
// wants to fight near the player a'la Alyx in ep2_outland_10.
//-----------------------------------------------------------------------------
CAI_Hint *CAI_ActBusyBehavior::FindCombatActBusyHintNode()
{
Assert( IsCombatActBusy() );
CBasePlayer *pPlayer = AI_GetSinglePlayer();
if( !pPlayer )
return NULL;
CHintCriteria criteria;
// Ok, find a hint node THAT:
// -Is in my hint group
// -Is Visible (if specified by designer)
// -Is Closest to me (if specified by designer)
// -The player can see
// -Is within the accepted max dist from player
int iBits = bits_HINT_NODE_USE_GROUP;
if ( m_bVisibleOnly )
iBits |= bits_HINT_NODE_VISIBLE;
if ( ai_debug_actbusy.GetInt() == 3 && GetOuter()->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT )
iBits |= bits_HINT_NODE_REPORT_FAILURES;
if ( m_bUseNearestBusy )
iBits |= bits_HINT_NODE_NEAREST;
else
iBits |= bits_HINT_NODE_RANDOM;
iBits |= bits_HAS_EYEPOSITION_LOS_TO_PLAYER;
criteria.AddHintType( HINT_WORLD_WORK_POSITION );
criteria.SetFlag( iBits );
criteria.AddIncludePosition( pPlayer->GetAbsOrigin(), ACTBUSY_COMBAT_PLAYER_MAX_DIST );
CAI_Hint *pNode = CAI_HintManager::FindHint( GetOuter(), criteria );
return pNode;
}
//-----------------------------------------------------------------------------
// Purpose: Find a suitable combat actbusy node to teleport to. That is, find
// one that the player is not going to see me appear at.
//-----------------------------------------------------------------------------
CAI_Hint *CAI_ActBusyBehavior::FindCombatActBusyTeleportHintNode()
{
Assert( IsCombatActBusy() );
CBasePlayer *pPlayer = AI_GetSinglePlayer();
if( !pPlayer )
return NULL;
CHintCriteria criteria;
// Ok, find a hint node THAT:
// -Is in my hint group
// -The player CAN NOT see so that they don't see me teleport
int iBits = bits_HINT_NODE_USE_GROUP;
if ( ai_debug_actbusy.GetInt() == 3 && GetOuter()->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT )
iBits |= bits_HINT_NODE_REPORT_FAILURES;
iBits |= bits_HINT_NODE_RANDOM;
iBits |= bits_HINT_NODE_NOT_VISIBLE_TO_PLAYER;
criteria.AddHintType( HINT_WORLD_WORK_POSITION );
criteria.SetFlag( iBits );
criteria.AddIncludePosition( pPlayer->GetAbsOrigin(), ACTBUSY_COMBAT_PLAYER_MAX_DIST * 1.1f );
CAI_Hint *pNode = CAI_HintManager::FindHint( GetOuter(), criteria );
return pNode;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::FValidateHintType( CAI_Hint *pHint )
{
if ( pHint->HintType() != HINT_WORLD_WORK_POSITION && pHint->HintType() != HINT_NPC_EXIT_POINT )
return false;
// If the node doesn't want to be teleported to, we need to check for clear
const char *pSequenceOrActivity = STRING(pHint->HintActivityName());
const char *cSpace = strchr( pSequenceOrActivity, ' ' );
if ( cSpace )
{
if ( !Q_strncmp( cSpace+1, "teleport", 8 ) )
{
// Node is a teleport node, so it's good
return true;
}
}
// Check for clearance
trace_t tr;
AI_TraceHull( pHint->GetAbsOrigin(), pHint->GetAbsOrigin(), GetOuter()->WorldAlignMins(), GetOuter()->WorldAlignMaxs(), MASK_SOLID, GetOuter(), COLLISION_GROUP_NONE, &tr );
if ( tr.fraction == 1.0 )
return true;
// Report failures
if ( ai_debug_actbusy.GetInt() == 3 && GetOuter()->m_debugOverlays & OVERLAY_NPC_SELECTED_BIT )
{
NDebugOverlay::Text( pHint->GetAbsOrigin(), "Node isn't clear.", false, 60 );
NDebugOverlay::Box( pHint->GetAbsOrigin(), GetOuter()->WorldAlignMins(), GetOuter()->WorldAlignMaxs(), 255,0,0, 8, 2.0 );
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::CanSelectSchedule( void )
{
// Always active when we're busy
if ( m_bBusy || m_bForceActBusy || m_bNeedsToPlayExitAnim )
return true;
if ( !m_bEnabled )
return false;
if ( m_flDeferUntil > gpGlobals->curtime )
return false;
if ( CountEnemiesInSafeZone() > 0 )
{
// I have enemies left in the safe zone. Actbusy isn't appropriate.
// I should be off fighting them.
return false;
}
if ( !IsCurScheduleOverridable() )
return false;
// Don't select actbusy if we're not going to search for a node anyway
return (m_flNextBusySearchTime < gpGlobals->curtime);
}
//-----------------------------------------------------------------------------
// Purpose: Return true if the current schedule is one that ActBusy is allowed to override
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::IsCurScheduleOverridable( void )
{
if( IsCombatActBusy() )
{
// The whole point of a combat actbusy is that it can run in any state (including combat)
// the only exception is SCRIPT (sjb)
return (GetOuter()->GetState() != NPC_STATE_SCRIPT);
}
// Act busies are not valid inside of a vehicle
if ( GetOuter()->IsInAVehicle() )
return false;
// Only if we're about to idle (or SCHED_NONE to catch newly spawned guys)
return ( IsCurSchedule( SCHED_IDLE_STAND ) || IsCurSchedule( SCHED_NONE ) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pSound -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::ShouldIgnoreSound( CSound *pSound )
{
// If we're busy in an actbusy anim that's an ambush, stay mum as long as we can
if ( m_bBusy )
{
busyanim_t *pBusyAnim = g_ActBusyAnimDataSystem.GetBusyAnim( m_iCurrentBusyAnim );
if( pBusyAnim && pBusyAnim->iBusyInterruptType == BA_INT_ZOMBIESLUMP )
{
// Slumped zombies are deaf.
return true;
}
if ( pBusyAnim && ( ( pBusyAnim->iBusyInterruptType == BA_INT_AMBUSH ) || ( pBusyAnim->iBusyInterruptType == BA_INT_COMBAT ) ) )
{
/*
// Robin: First version ignored sounds in front of the NPC.
Vector vecToSound = (pSound->GetSoundReactOrigin() - GetAbsOrigin());
vecToSound.z = 0;
VectorNormalize( vecToSound );
Vector facingDir = GetOuter()->EyeDirection2D();
if ( DotProduct( vecToSound, facingDir ) > 0 )
return true;
*/
// Ignore sounds that aren't visible
if ( !GetOuter()->FVisible( pSound->GetSoundReactOrigin() ) )
return true;
}
}
return BaseClass::ShouldIgnoreSound( pSound );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::OnFriendDamaged( CBaseCombatCharacter *pSquadmate, CBaseEntity *pAttacker )
{
if( IsCombatActBusy() && pSquadmate->IsPlayer() && IsInSafeZone( pAttacker ) )
{
SetCondition( COND_ACTBUSY_AWARE_OF_ENEMY_IN_SAFE_ZONE ); // Break the actbusy, if we're running it.
m_flDeferUntil = gpGlobals->curtime + 4.0f; // Stop actbusying and go deal with that enemy!!
}
BaseClass::OnFriendDamaged( pSquadmate, pAttacker );
}
//-----------------------------------------------------------------------------
// Purpose: Count the number of enemies of mine that are inside my safe zone
// volume.
//
// NOTE: We keep this count to prevent the NPC re-entering combat
// actbusy whilst too many enemies are present in the safe zone.
// This count does not automatically alert the NPC that there are
// enemies in the safe zone.
// You must set COND_ACTBUSY_AWARE_OF_ENEMY_IN_SAFE_ZONE to let
// the NPC know.
//-----------------------------------------------------------------------------
int CAI_ActBusyBehavior::CountEnemiesInSafeZone()
{
if( !IsCombatActBusy() )
{
return 0;
}
// Grovel the AI list and count the enemies in the zone. By enemies, I mean
// anyone that I would fight if I saw.
CAI_BaseNPC ** ppAIs = g_AI_Manager.AccessAIs();
int nAIs = g_AI_Manager.NumAIs();
int count = 0;
for ( int i = 0; i < nAIs; i++ )
{
if( GetOuter()->IRelationType(ppAIs[i]) < D_LI )
{
if( IsInSafeZone(ppAIs[i]) )
{
count++;
}
}
}
return count;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CAI_ActBusyBehavior::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
if( IsCombatActBusy() && info.GetAttacker() && IsInSafeZone( info.GetAttacker() ) )
{
SetCondition( COND_ACTBUSY_AWARE_OF_ENEMY_IN_SAFE_ZONE ); // Break the actbusy, if we're running it.
m_flDeferUntil = gpGlobals->curtime + 4.0f; // Stop actbusying and go deal with that enemy!!
}
return BaseClass::OnTakeDamage_Alive( info );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::GatherConditions( void )
{
// Clear this condition before we call up, since the look sensing code will run and
// set this condition if it is relevant.
if( !IsCurSchedule(SCHED_ACTBUSY_BUSY, false) )
{
// Only clear this condition when we aren't busying. We want it to be sticky
// during that time so that schedule selection works properly (sjb)
ClearCondition( COND_ACTBUSY_ENEMY_TOO_CLOSE );
}
BaseClass::GatherConditions();
bool bCheckLOS = true;
bool bCheckFOV = true;
if( m_hActBusyGoal && m_hActBusyGoal->m_iSightMethod == ACTBUSY_SIGHT_METHOD_LOS_ONLY )
{
bCheckFOV = false;
}
// If we have a see entity, make sure we can still see it
if ( m_hSeeEntity && m_bBusy )
{
if ( (!bCheckFOV||GetOuter()->FInViewCone(m_hSeeEntity)) && GetOuter()->QuerySeeEntity(m_hSeeEntity) && (!bCheckLOS||GetOuter()->FVisible(m_hSeeEntity)) )
{
m_fTimeLastSawSeeEntity = gpGlobals->curtime;
ClearCondition( COND_ACTBUSY_LOST_SEE_ENTITY );
}
else if( m_hActBusyGoal )
{
float fDelta = gpGlobals->curtime - m_fTimeLastSawSeeEntity;
if( fDelta >= m_hActBusyGoal->m_flSeeEntityTimeout )
{
SetCondition( COND_ACTBUSY_LOST_SEE_ENTITY );
m_hActBusyGoal->NPCLostSeeEntity( GetOuter() );
if( IsCombatActBusy() && (GetOuter()->Classify() == CLASS_PLAYER_ALLY_VITAL && m_hSeeEntity->IsPlayer()) )
{
// Defer any actbusying for several seconds. This serves as a heuristic for waiting
// for the player to settle after moving out of the room. This helps Alyx pick a more
// pertinent Actbusy near the player's new location.
m_flDeferUntil = gpGlobals->curtime + 4.0f;
}
}
}
}
else
{
ClearCondition( COND_ACTBUSY_LOST_SEE_ENTITY );
}
// If we're busy, ignore sounds depending on our actbusy break rules
if ( m_bBusy )
{
busyanim_t *pBusyAnim = g_ActBusyAnimDataSystem.GetBusyAnim( m_iCurrentBusyAnim );
if ( pBusyAnim )
{
switch( pBusyAnim->iBusyInterruptType )
{
case BA_INT_DANGER:
break;
case BA_INT_AMBUSH:
break;
case BA_INT_ZOMBIESLUMP:
{
ClearCondition( COND_HEAR_PLAYER );
ClearCondition( COND_SEE_ENEMY );
ClearCondition( COND_NEW_ENEMY );
CBasePlayer *pPlayer = UTIL_PlayerByIndex(1);
if( pPlayer )
{
float flDist = pPlayer->GetAbsOrigin().DistTo( GetAbsOrigin() );
if( flDist <= 60 )
{
StopBusying();
}
}
}
break;
case BA_INT_COMBAT:
// Ignore the player unless he shoots at us
ClearCondition( COND_HEAR_PLAYER );
ClearCondition( COND_SEE_ENEMY );
ClearCondition( COND_NEW_ENEMY );
break;
case BA_INT_PLAYER:
// Clear all but player.
ClearCondition( COND_HEAR_DANGER );
ClearCondition( COND_HEAR_COMBAT );
ClearCondition( COND_HEAR_WORLD );
ClearCondition( COND_HEAR_BULLET_IMPACT );
break;
case BA_INT_SIEGE_DEFENSE:
ClearCondition( COND_HEAR_PLAYER );
ClearCondition( COND_SEE_ENEMY );
ClearCondition( COND_NEW_ENEMY );
ClearCondition( COND_HEAR_COMBAT );
ClearCondition( COND_HEAR_WORLD );
ClearCondition( COND_HEAR_BULLET_IMPACT );
break;
case BA_INT_NONE:
// Clear all
ClearCondition( COND_HEAR_DANGER );
ClearCondition( COND_HEAR_COMBAT );
ClearCondition( COND_HEAR_WORLD );
ClearCondition( COND_HEAR_BULLET_IMPACT );
ClearCondition( COND_HEAR_PLAYER );
break;
default:
break;
}
}
}
if( m_bAutoFireWeapon && random->RandomInt(0, 5) <= 3 )
{
CBaseCombatWeapon *pWeapon = GetOuter()->GetActiveWeapon();
if( pWeapon )
{
pWeapon->Operator_ForceNPCFire( GetOuter(), false );
}
}
if( ai_debug_actbusy.GetInt() == 5 )
{
// Visualize them there Actbusy safe volumes
for( int i = 0 ; i < m_SafeZones.Count() ; i++ )
{
busysafezone_t *pSafeZone = &m_SafeZones[i];
Vector vecBoxOrigin = (pSafeZone->vecMins + pSafeZone->vecMaxs) * 0.5f;
Vector vecBoxMins = vecBoxOrigin - pSafeZone->vecMins;
Vector vecBoxMaxs = vecBoxOrigin - pSafeZone->vecMaxs;
NDebugOverlay::Box( vecBoxOrigin, vecBoxMins, vecBoxMaxs, 255, 0, 255, 64, 0.2f );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::EndScheduleSelection( void )
{
NotifyBusyEnding();
CheckAndCleanupOnExit();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : nActivity -
//-----------------------------------------------------------------------------
Activity CAI_ActBusyBehavior::NPC_TranslateActivity( Activity nActivity )
{
// Find out what the base class wants to do with the activity
Activity nNewActivity = BaseClass::NPC_TranslateActivity( nActivity );
if( nActivity == ACT_RUN )
{
// FIXME: Forcing STIMULATED here is illegal if the entity doesn't support it as an activity
CAI_PlayerAlly *pAlly = dynamic_cast<CAI_PlayerAlly*>(GetOuter());
if ( pAlly )
return ACT_RUN_STIMULATED;
}
// Else stay with the base class' decision.
return nNewActivity;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::HandleAnimEvent( animevent_t *pEvent )
{
if( pEvent->event == AE_ACTBUSY_WEAPON_FIRE_ON )
{
m_bAutoFireWeapon = true;
return;
}
else if( pEvent->event == AE_ACTBUSY_WEAPON_FIRE_OFF )
{
m_bAutoFireWeapon = false;
return;
}
return BaseClass::HandleAnimEvent( pEvent );
}
//-----------------------------------------------------------------------------
// Purpose: Actbusy's ending, ensure we haven't left NPC in broken state.
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::CheckAndCleanupOnExit( void )
{
if ( m_bNeedsToPlayExitAnim && !GetOuter()->IsMarkedForDeletion() && GetOuter()->IsAlive() )
{
Warning("NPC %s(%s) left actbusy without playing exit anim.\n", GetOuter()->GetDebugName(), GetOuter()->GetClassname() );
m_bNeedsToPlayExitAnim = false;
}
GetOuter()->RemoveFlag( FL_FLY );
// If we're supposed to use render bounds while inside the busy anim, restore normal now
if ( m_bUseRenderBoundsForCollision )
{
GetOuter()->SetHullSizeNormal( true );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::BuildScheduleTestBits( void )
{
BaseClass::BuildScheduleTestBits();
// When going to an actbusy, we can't be interrupted during the entry anim
if ( IsCurSchedule(SCHED_ACTBUSY_START_BUSYING) )
{
if ( GetOuter()->GetTask()->iTask == TASK_ACTBUSY_PLAY_ENTRY )
return;
GetOuter()->SetCustomInterruptCondition( COND_PROVOKED );
if( IsCombatActBusy() )
{
GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal(COND_ACTBUSY_ENEMY_TOO_CLOSE) );
}
}
// If we're in a queue, or leaving, we have no extra conditions
if ( m_bInQueue || IsCurSchedule( SCHED_ACTBUSY_LEAVE ) )
return;
// If we're not busy, or we're exiting a busy, we have no extra conditions
if ( !m_bBusy || IsCurSchedule( SCHED_ACTBUSY_STOP_BUSYING ) )
return;
busyanim_t *pBusyAnim = g_ActBusyAnimDataSystem.GetBusyAnim( m_iCurrentBusyAnim );
if ( pBusyAnim )
{
switch( pBusyAnim->iBusyInterruptType )
{
case BA_INT_ZOMBIESLUMP:
{
GetOuter()->SetCustomInterruptCondition( COND_LIGHT_DAMAGE );
GetOuter()->SetCustomInterruptCondition( COND_HEAVY_DAMAGE );
}
break;
case BA_INT_SIEGE_DEFENSE:
{
GetOuter()->SetCustomInterruptCondition( COND_HEAR_DANGER );
GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal(COND_ACTBUSY_AWARE_OF_ENEMY_IN_SAFE_ZONE) );
GetOuter()->SetCustomInterruptCondition( GetClassScheduleIdSpace()->ConditionLocalToGlobal(COND_ACTBUSY_ENEMY_TOO_CLOSE) );
}
break;
case BA_INT_AMBUSH:
case BA_INT_DANGER:
{
GetOuter()->SetCustomInterruptCondition( COND_LIGHT_DAMAGE );
GetOuter()->SetCustomInterruptCondition( COND_HEAVY_DAMAGE );
GetOuter()->SetCustomInterruptCondition( COND_HEAR_DANGER );
GetOuter()->SetCustomInterruptCondition( COND_HEAR_COMBAT );
GetOuter()->SetCustomInterruptCondition( COND_HEAR_BULLET_IMPACT );
GetOuter()->SetCustomInterruptCondition( COND_NEW_ENEMY );
GetOuter()->SetCustomInterruptCondition( COND_SEE_ENEMY );
GetOuter()->SetCustomInterruptCondition( COND_PLAYER_ADDED_TO_SQUAD );
GetOuter()->SetCustomInterruptCondition( COND_RECEIVED_ORDERS );
break;
}
case BA_INT_PLAYER:
{
GetOuter()->SetCustomInterruptCondition( COND_LIGHT_DAMAGE );
GetOuter()->SetCustomInterruptCondition( COND_HEAVY_DAMAGE );
GetOuter()->SetCustomInterruptCondition( COND_HEAR_DANGER );
GetOuter()->SetCustomInterruptCondition( COND_HEAR_COMBAT );
GetOuter()->SetCustomInterruptCondition( COND_HEAR_BULLET_IMPACT );
GetOuter()->SetCustomInterruptCondition( COND_NEW_ENEMY );
GetOuter()->SetCustomInterruptCondition( COND_PLAYER_ADDED_TO_SQUAD );
GetOuter()->SetCustomInterruptCondition( COND_RECEIVED_ORDERS );
// The player can interrupt us
GetOuter()->SetCustomInterruptCondition( COND_SEE_PLAYER );
break;
}
case BA_INT_COMBAT:
{
GetOuter()->SetCustomInterruptCondition( COND_LIGHT_DAMAGE );
GetOuter()->SetCustomInterruptCondition( COND_HEAVY_DAMAGE );
GetOuter()->SetCustomInterruptCondition( COND_HEAR_DANGER );
break;
}
case BA_INT_NONE:
break;
default:
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CAI_ActBusyBehavior::SelectScheduleForLeaving( void )
{
// Are we already near an exit node?
if ( GetHintNode() )
{
if ( GetHintNode()->HintType() == HINT_NPC_EXIT_POINT )
{
// Are we near it? If so, we're done. If not, move to it.
if ( UTIL_DistApprox( GetHintNode()->GetAbsOrigin(), GetAbsOrigin() ) < 64 )
{
if ( !GetOuter()->IsMarkedForDeletion() )
{
CBaseEntity *pOwner = GetOuter()->GetOwnerEntity();
if ( pOwner )
{
pOwner->DeathNotice( GetOuter() );
GetOuter()->SetOwnerEntity( NULL );
}
GetOuter()->SetThink( &CBaseEntity::SUB_Remove); //SUB_Remove) ; //GetOuter()->SUB_Remove );
GetOuter()->SetNextThink( gpGlobals->curtime + 0.1 );
if ( m_hActBusyGoal )
{
m_hActBusyGoal->NPCLeft( GetOuter() );
}
}
return SCHED_IDLE_STAND;
}
return SCHED_ACTBUSY_LEAVE;
}
else
{
// Clear the node, it's no use to us
GetHintNode()->NPCStoppedUsing( GetOuter() );
GetHintNode()->Unlock();
SetHintNode( NULL );
}
}
// Find an exit node
CHintCriteria hintCriteria;
hintCriteria.SetHintType( HINT_NPC_EXIT_POINT );
hintCriteria.SetFlag( bits_HINT_NODE_RANDOM | bits_HINT_NODE_CLEAR | bits_HINT_NODE_USE_GROUP );
CAI_Hint *pNode = CAI_HintManager::FindHintRandom( GetOuter(), GetOuter()->GetAbsOrigin(), hintCriteria );
if ( pNode )
{
SetHintNode( pNode );
return SCHED_ACTBUSY_LEAVE;
}
// We've been told to leave, but we can't find an exit node. What to do?
return SCHED_IDLE_STAND;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CAI_ActBusyBehavior::SelectScheduleWhileNotBusy( int iBase )
{
// Randomly act busy (unless we're being forced, in which case we should search immediately)
if ( m_bForceActBusy || m_flNextBusySearchTime < gpGlobals->curtime )
{
// If we're being forced, think again quickly
if ( m_bForceActBusy || IsCombatActBusy() )
{
m_flNextBusySearchTime = gpGlobals->curtime + 2.0;
}
else
{
m_flNextBusySearchTime = gpGlobals->curtime + RandomFloat(ai_actbusy_search_time.GetFloat(), ai_actbusy_search_time.GetFloat()*2);
}
// We may already have a node
bool bForceTeleport = false;
CAI_Hint *pNode = GetHintNode();
if ( !pNode )
{
if( IsCombatActBusy() )
{
if ( m_hActBusyGoal->IsCombatActBusyTeleportAllowed() && m_iNumConsecutivePathFailures >= 2 && !AI_GetSinglePlayer()->FInViewCone(GetOuter()) )
{
// Looks like I've tried several times to find a path to a valid hint node and
// haven't been able to. This means I'm on a patch of node graph that simply
// does not connect to any hint nodes that match my criteria. So try to find
// a node that's safe to teleport to. (sjb) ep2_outland_10 (Alyx)
// (Also, I must not be in the player's viewcone)
pNode = FindCombatActBusyTeleportHintNode();
bForceTeleport = true;
}
else
{
pNode = FindCombatActBusyHintNode();
}
}
else
{
pNode = FindActBusyHintNode();
}
}
if ( pNode )
{
// Ensure we've got a sequence for the node
const char *pSequenceOrActivity = STRING(pNode->HintActivityName());
Activity iNodeActivity;
int iBusyAnim;
// See if the node specifies that we should teleport to it
const char *cSpace = strchr( pSequenceOrActivity, ' ' );
if ( cSpace )
{
if ( !Q_strncmp( cSpace+1, "teleport", 8 ) )
{
m_bTeleportToBusy = true;
}
char sActOrSeqName[512];
Q_strncpy( sActOrSeqName, pSequenceOrActivity, (cSpace-pSequenceOrActivity)+1 );
iNodeActivity = (Activity)CAI_BaseNPC::GetActivityID( sActOrSeqName );
iBusyAnim = g_ActBusyAnimDataSystem.FindBusyAnim( iNodeActivity, sActOrSeqName );
}
else
{
iNodeActivity = (Activity)CAI_BaseNPC::GetActivityID( pSequenceOrActivity );
iBusyAnim = g_ActBusyAnimDataSystem.FindBusyAnim( iNodeActivity, pSequenceOrActivity );
}
// Does this NPC have the activity or sequence for this node?
if ( HasAnimForActBusy( iBusyAnim, BA_BUSY ) )
{
if ( HasCondition(COND_ACTBUSY_LOST_SEE_ENTITY) )
{
// We've lost our see entity, which means we can't continue.
if ( m_bForceActBusy )
{
// We were being told to act busy, which we can't do now that we've lost the see entity.
// Abort, and assume that the mapmaker will make us retry.
StopBusying();
}
return iBase;
}
m_iCurrentBusyAnim = iBusyAnim;
if ( m_iCurrentBusyAnim == -1 )
return iBase;
if ( ai_debug_actbusy.GetInt() == 4 )
{
Msg("ACTBUSY: NPC %s (%s) found Actbusy node %s \n", GetOuter()->GetClassname(), GetOuter()->GetDebugName(), pNode->GetDebugName() );
}
if ( GetHintNode() )
{
GetHintNode()->Unlock();
}
SetHintNode( pNode );
if ( GetHintNode() && GetHintNode()->Lock( GetOuter() ) )
{
if ( ai_debug_actbusy.GetInt() == 2 )
{
// Show which actbusy we're moving towards
NDebugOverlay::Line( GetOuter()->WorldSpaceCenter(), pNode->GetAbsOrigin(), 0, 255, 0, true, 5.0 );
NDebugOverlay::Box( pNode->GetAbsOrigin(), GetOuter()->WorldAlignMins(), GetOuter()->WorldAlignMaxs(), 0, 255, 0, 64, 5.0 );
}
// Let our act busy know we're moving to a node
if ( m_hActBusyGoal )
{
m_hActBusyGoal->NPCMovingToBusy( GetOuter() );
}
m_bMovingToBusy = true;
if( m_hActBusyGoal && m_hActBusyGoal->m_iszSeeEntityName != NULL_STRING )
{
// Set the see entity Handle if we have one.
m_hSeeEntity.Set( gEntList.FindEntityByName(NULL, m_hActBusyGoal->m_iszSeeEntityName) );
}
// At this point we know we're starting.
ClearCondition( COND_ACTBUSY_AWARE_OF_ENEMY_IN_SAFE_ZONE );
// If we're supposed to teleport, do that instead
if ( m_bTeleportToBusy )
{
return SCHED_ACTBUSY_TELEPORT_TO_BUSY;
}
else if( bForceTeleport )
{
// We found a place to go, so teleport there and forget that we ever had trouble.
m_iNumConsecutivePathFailures = 0;
return SCHED_ACTBUSY_TELEPORT_TO_BUSY;
}
return SCHED_ACTBUSY_START_BUSYING;
}
}
}
else
{
// WE DIDN'T FIND A NODE!
if( IsCombatActBusy() )
{
// Don't try again right away, not enough state will have changed.
// Just go do something useful for a few seconds.
m_flNextBusySearchTime = gpGlobals->curtime + 10.0;
}
}
}
return SCHED_NONE;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CAI_ActBusyBehavior::SelectScheduleWhileBusy( void )
{
// Are we supposed to stop on our current actbusy, but stay in the actbusy state?
if ( !ActBusyNodeStillActive() || (m_flEndBusyAt && gpGlobals->curtime >= m_flEndBusyAt) )
{
if ( ai_debug_actbusy.GetInt() == 4 )
{
Msg("ACTBUSY: NPC %s (%s) ending actbusy.\n", GetOuter()->GetClassname(), GetOuter()->GetDebugName() );
}
StopBusying();
return SCHED_ACTBUSY_STOP_BUSYING;
}
if( IsCombatActBusy() && (HasCondition(COND_ACTBUSY_AWARE_OF_ENEMY_IN_SAFE_ZONE) || HasCondition(COND_ACTBUSY_ENEMY_TOO_CLOSE)) )
{
return SCHED_ACTBUSY_STOP_BUSYING;
}
return SCHED_ACTBUSY_BUSY;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CAI_ActBusyBehavior::SelectSchedule()
{
int iBase = BaseClass::SelectSchedule();
// Only do something if the base ai doesn't want to do anything
if ( !IsCombatActBusy() && !m_bForceActBusy && iBase != SCHED_IDLE_STAND )
{
// If we're busy, we need to get out of it first
if ( m_bBusy )
return SCHED_ACTBUSY_STOP_BUSYING;
CheckAndCleanupOnExit();
return iBase;
}
// If we're supposed to be leaving, find a leave node and exit
if ( m_bLeaving )
return SelectScheduleForLeaving();
// NPCs should not be busy if the actbusy behaviour has been disabled, or if they've received player squad commands
bool bShouldNotBeBusy = (!m_bEnabled || HasCondition( COND_PLAYER_ADDED_TO_SQUAD ) || HasCondition( COND_RECEIVED_ORDERS ) );
if ( bShouldNotBeBusy )
{
if ( !GetOuter()->IsMarkedForDeletion() && GetOuter()->IsAlive() )
return SCHED_ACTBUSY_STOP_BUSYING;
}
else
{
if ( m_bBusy )
return SelectScheduleWhileBusy();
// I'm not busy, and I'm supposed to be
int schedule = SelectScheduleWhileNotBusy( iBase );
if ( schedule != SCHED_NONE )
return schedule;
}
CheckAndCleanupOnExit();
return iBase;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::ActBusyNodeStillActive( void )
{
if ( !GetHintNode() )
return false;
return ( GetHintNode()->IsDisabled() == false );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::IsInterruptable( void )
{
if ( IsActive() )
return false;
return BaseClass::IsInterruptable();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::CanFlinch( void )
{
if ( m_bNeedsToPlayExitAnim )
return false;
return BaseClass::CanFlinch();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::CanRunAScriptedNPCInteraction( bool bForced )
{
// Prevent interactions during actbusy modes
if ( IsActive() )
return false;
return BaseClass::CanRunAScriptedNPCInteraction( bForced );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::OnScheduleChange()
{
if( IsCurSchedule(SCHED_ACTBUSY_BUSY, false) )
{
if( HasCondition(COND_SEE_ENEMY) )
{
m_bExitedBusyToDueSeeEnemy = true;
}
if( HasCondition(COND_ACTBUSY_LOST_SEE_ENTITY) )
{
m_bExitedBusyToDueLostSeeEntity = true;
}
}
BaseClass::OnScheduleChange();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::QueryHearSound( CSound *pSound )
{
// Ignore friendly created combat sounds while in an actbusy.
// Fixes friendly NPCs going in & out of actbusies when the
// player fires shots at their feet.
if ( pSound->IsSoundType( SOUND_COMBAT ) || pSound->IsSoundType( SOUND_BULLET_IMPACT ) )
{
if ( GetOuter()->IRelationType( pSound->m_hOwner ) == D_LI )
return false;
}
return BaseClass::QueryHearSound( pSound );
}
//-----------------------------------------------------------------------------
// Purpose: Because none of the startbusy schedules break on COND_NEW_ENEMY
// we have to do this distance check against all enemy NPCs we
// see as we're traveling to an ACTBUSY node
//-----------------------------------------------------------------------------
#define ACTBUSY_ENEMY_TOO_CLOSE_DIST_SQR Square(240) // 20 feet
void CAI_ActBusyBehavior::OnSeeEntity( CBaseEntity *pEntity )
{
BaseClass::OnSeeEntity( pEntity );
if( IsCombatActBusy() && GetOuter()->IRelationType(pEntity) < D_LI )
{
if( pEntity->GetAbsOrigin().DistToSqr( GetAbsOrigin() ) <= ACTBUSY_ENEMY_TOO_CLOSE_DIST_SQR )
{
SetCondition( COND_ACTBUSY_ENEMY_TOO_CLOSE );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::ShouldPlayerAvoid( void )
{
if( IsCombatActBusy() )
{
// Alyx is only allowed to push if she's getting into or out of an actbusy
// animation. She isn't allowed to shove you around while she's running around
if ( IsCurSchedule(SCHED_ACTBUSY_START_BUSYING) )
{
if ( GetCurTask() && GetCurTask()->iTask == TASK_ACTBUSY_PLAY_ENTRY )
return true;
}
else if ( IsCurSchedule(SCHED_ACTBUSY_STOP_BUSYING) )
{
if ( GetCurTask() && GetCurTask()->iTask == TASK_ACTBUSY_PLAY_EXIT )
return true;
}
}
else
{
if ( IsCurSchedule ( SCHED_ACTBUSY_START_BUSYING ) )
{
if ( ( GetCurTask() && GetCurTask()->iTask == TASK_WAIT_FOR_MOVEMENT ) || GetOuter()->GetTask()->iTask == TASK_ACTBUSY_PLAY_ENTRY )
return true;
}
else if ( IsCurSchedule(SCHED_ACTBUSY_STOP_BUSYING) )
{
if ( GetCurTask() && GetCurTask()->iTask == TASK_ACTBUSY_PLAY_EXIT )
return true;
}
}
return BaseClass::ShouldPlayerAvoid();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::ComputeAndSetRenderBounds()
{
Vector mins, maxs;
if ( GetOuter()->ComputeHitboxSurroundingBox( &mins, &maxs ) )
{
UTIL_SetSize( GetOuter(), mins - GetAbsOrigin(), maxs - GetAbsOrigin());
if ( GetOuter()->VPhysicsGetObject() )
{
GetOuter()->SetupVPhysicsHull();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if the current NPC is acting busy, or moving to an actbusy
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::IsActive( void )
{
return ( m_bBusy || m_bForceActBusy || m_bNeedsToPlayExitAnim || m_bLeaving );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::IsCombatActBusy()
{
if( m_hActBusyGoal != NULL )
return (m_hActBusyGoal->GetType() == ACTBUSY_TYPE_COMBAT);
return false;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::CollectSafeZoneVolumes( CAI_ActBusyGoal *pActBusyGoal )
{
// Reset these, so we don't use a volume from a previous actbusy goal.
m_SafeZones.RemoveAll();
if( pActBusyGoal->m_iszSafeZoneVolume != NULL_STRING )
{
CBaseEntity *pVolume = gEntList.FindEntityByName( NULL, pActBusyGoal->m_iszSafeZoneVolume );
while( pVolume != NULL )
{
busysafezone_t newSafeZone;
pVolume->CollisionProp()->WorldSpaceAABB( &newSafeZone.vecMins, &newSafeZone.vecMaxs );
m_SafeZones.AddToTail( newSafeZone );
pVolume = gEntList.FindEntityByName( pVolume, pActBusyGoal->m_iszSafeZoneVolume );
}
}
if( ai_debug_actbusy.GetInt() == 5 )
{
Msg( "Actbusy collected %d safe zones\n", m_SafeZones.Count() );
}
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::IsInSafeZone( CBaseEntity *pEntity )
{
Vector vecLocation = pEntity->WorldSpaceCenter();
for( int i = 0 ; i < m_SafeZones.Count() ; i++ )
{
busysafezone_t *pSafeZone = &m_SafeZones[i];
if( vecLocation.x > pSafeZone->vecMins.x &&
vecLocation.y > pSafeZone->vecMins.y &&
vecLocation.z > pSafeZone->vecMins.z &&
vecLocation.x < pSafeZone->vecMaxs.x &&
vecLocation.y < pSafeZone->vecMaxs.y &&
vecLocation.z < pSafeZone->vecMaxs.z )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if this NPC has the anims required to use the specified actbusy hint
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::HasAnimForActBusy( int iActBusy, busyanimparts_t AnimPart )
{
if ( iActBusy == -1 )
return false;
busyanim_t *pBusyAnim = g_ActBusyAnimDataSystem.GetBusyAnim( iActBusy );
if ( !pBusyAnim )
return false;
// Try and play the sequence first
if ( pBusyAnim->iszSequences[AnimPart] != NULL_STRING )
return (GetOuter()->LookupSequence( (char*)STRING(pBusyAnim->iszSequences[AnimPart]) ) != ACTIVITY_NOT_AVAILABLE);
// Try and play the activity second
if ( pBusyAnim->iActivities[AnimPart] != ACT_INVALID )
return GetOuter()->HaveSequenceForActivity( pBusyAnim->iActivities[AnimPart] );
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Play the sound associated with the specified part of the current actbusy, if any
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::PlaySoundForActBusy( busyanimparts_t AnimPart )
{
busyanim_t *pBusyAnim = g_ActBusyAnimDataSystem.GetBusyAnim( m_iCurrentBusyAnim );
if ( !pBusyAnim )
return;
// Play the sound
if ( pBusyAnim->iszSounds[AnimPart] != NULL_STRING )
{
// See if we can treat it as a game sound name
CSoundParameters params;
if ( GetOuter()->GetParametersForSound( STRING(pBusyAnim->iszSounds[AnimPart]), params, STRING(GetOuter()->GetModelName()) ) )
{
CPASAttenuationFilter filter( GetOuter() );
GetOuter()->EmitSound( filter, GetOuter()->entindex(), params );
}
else
{
// Assume it's a response concept, and try to speak it
CAI_Expresser *pExpresser = GetOuter()->GetExpresser();
if ( pExpresser )
{
const char *concept = STRING(pBusyAnim->iszSounds[AnimPart]);
// Must be able to speak the concept
if ( !pExpresser->IsSpeaking() && pExpresser->CanSpeakConcept( concept ) )
{
pExpresser->Speak( concept );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Play a sequence or activity for the current actbusy
//-----------------------------------------------------------------------------
bool CAI_ActBusyBehavior::PlayAnimForActBusy( busyanimparts_t AnimPart )
{
busyanim_t *pBusyAnim = g_ActBusyAnimDataSystem.GetBusyAnim( m_iCurrentBusyAnim );
if ( !pBusyAnim )
return false;
// Try and play the sequence first
if ( pBusyAnim->iszSequences[AnimPart] != NULL_STRING )
{
GetOuter()->SetSequenceByName( (char*)STRING(pBusyAnim->iszSequences[AnimPart]) );
GetOuter()->SetIdealActivity( ACT_DO_NOT_DISTURB );
return true;
}
// Try and play the activity second
if ( pBusyAnim->iActivities[AnimPart] != ACT_INVALID )
{
GetOuter()->SetIdealActivity( pBusyAnim->iActivities[AnimPart] );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::StartTask( const Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_ACTBUSY_PLAY_BUSY_ANIM:
{
// If we're not enabled here, it's due to the actbusy being deactivated during
// the NPC's entry animation. We can't abort in the middle of the entry, so we
// arrive here with a disabled actbusy behaviour. Exit gracefully.
if ( !m_bEnabled )
{
TaskComplete();
return;
}
// Set the flag to remind the code to recompute the NPC's box from render bounds.
// This is used to delay the process so that we don't get a box built from render bounds
// when a character is still interpolating to their busy pose.
m_bNeedToSetBounds = true;
// Get the busyanim for the specified activity
busyanim_t *pBusyAnim = g_ActBusyAnimDataSystem.GetBusyAnim( m_iCurrentBusyAnim );
// We start "flying" so we don't collide with the world, in case the level
// designer has us sitting on a chair, etc.
if( !pBusyAnim || !pBusyAnim->bUseAutomovement )
{
GetOuter()->AddFlag( FL_FLY );
}
GetOuter()->SetGroundEntity( NULL );
// Fail if we're not on the node & facing the correct way
// We only do this check if we're still moving to the busy. This will only
// be true if there was no entry animation for this busy. We do it this way
// because the entry code contains this same check, and so we assume we're
// valid even if we're off now, because some entry animations move the
// character off the node.
if ( m_bMovingToBusy )
{
if ( UTIL_DistApprox( GetHintNode()->GetAbsOrigin(), GetAbsOrigin() ) > 16 || !GetOuter()->FacingIdeal() )
{
TaskFail( "Not correctly on hintnode" );
m_flEndBusyAt = gpGlobals->curtime;
return;
}
}
m_bMovingToBusy = false;
if ( !ActBusyNodeStillActive() )
{
TaskFail( FAIL_NO_HINT_NODE );
return;
}
// Have we just started using this node?
if ( !m_bBusy )
{
m_bBusy = true;
GetHintNode()->NPCStartedUsing( GetOuter() );
if ( m_hActBusyGoal )
{
m_hActBusyGoal->NPCStartedBusy( GetOuter() );
}
if ( pBusyAnim )
{
float flMaxTime = pBusyAnim->flMaxTime;
float flMinTime = pBusyAnim->flMinTime;
// Mapmaker input may have specified it's own max time
if ( m_bForceActBusy && m_flForcedMaxTime != NO_MAX_TIME )
{
flMaxTime = m_flForcedMaxTime;
// Don't let non-unlimited time amounts be less than the mintime
if ( flMaxTime && flMaxTime < flMinTime )
{
flMinTime = flMaxTime;
}
}
// If we have no max time, or we're in a queue, we loop forever.
if ( !flMaxTime || m_bInQueue )
{
m_flEndBusyAt = 0;
GetOuter()->SetWait( 99999 );
}
else
{
float flTime = RandomFloat(flMinTime, flMaxTime);
m_flEndBusyAt = gpGlobals->curtime + flTime;
GetOuter()->SetWait( flTime );
}
}
}
// Start playing the act busy
PlayAnimForActBusy( BA_BUSY );
PlaySoundForActBusy( BA_BUSY );
// Now that we're busy, we don't need to be forced anymore
m_bForceActBusy = false;
m_bTeleportToBusy = false;
m_bUseNearestBusy = false;
m_ForcedActivity = ACT_INVALID;
// If we're supposed to use render bounds while inside the busy anim, do so
if ( m_bUseRenderBoundsForCollision )
{
ComputeAndSetRenderBounds();
}
}
break;
case TASK_ACTBUSY_PLAY_ENTRY:
{
// We start "flying" so we don't collide with the world, in case the level
// designer has us sitting on a chair, etc.
// Get the busyanim for the specified activity
busyanim_t *pBusyAnim = g_ActBusyAnimDataSystem.GetBusyAnim( m_iCurrentBusyAnim );
// We start "flying" so we don't collide with the world, in case the level
// designer has us sitting on a chair, etc.
if( !pBusyAnim || !pBusyAnim->bUseAutomovement )
{
GetOuter()->AddFlag( FL_FLY );
}
GetOuter()->SetGroundEntity( NULL );
m_bMovingToBusy = false;
m_bNeedsToPlayExitAnim = HasAnimForActBusy( m_iCurrentBusyAnim, BA_EXIT );
if ( !ActBusyNodeStillActive() )
{
TaskFail( FAIL_NO_HINT_NODE );
return;
}
// Fail if we're not on the node & facing the correct way
if ( UTIL_DistApprox( GetHintNode()->GetAbsOrigin(), GetAbsOrigin() ) > 16 || !GetOuter()->FacingIdeal() )
{
m_bBusy = false;
TaskFail( "Not correctly on hintnode" );
return;
}
PlaySoundForActBusy( BA_ENTRY );
// Play the entry animation. If it fails, we don't have an entry anim, so complete immediately.
if ( !PlayAnimForActBusy( BA_ENTRY ) )
{
TaskComplete();
}
}
break;
case TASK_ACTBUSY_VERIFY_EXIT:
{
// NPC's that changed their bounding box must ensure that they can restore their regular box
// before they exit their actbusy. This task is designed to delay until that time if necessary.
if( !m_bUseRenderBoundsForCollision )
{
// Don't bother if we didn't alter our BBox.
TaskComplete();
break;
}
// Set up a timer to check immediately.
GetOuter()->SetWait( 0 );
}
break;
case TASK_ACTBUSY_PLAY_EXIT:
{
// If we're supposed to use render bounds while inside the busy anim, restore normal now
if ( m_bUseRenderBoundsForCollision )
{
GetOuter()->SetHullSizeNormal( true );
}
if ( m_hActBusyGoal )
{
m_hActBusyGoal->NPCStartedLeavingBusy( GetOuter() );
}
PlaySoundForActBusy( BA_EXIT );
// Play the exit animation. If it fails, we don't have an entry anim, so complete immediately.
if ( !PlayAnimForActBusy( BA_EXIT ) )
{
m_bNeedsToPlayExitAnim = false;
GetOuter()->RemoveFlag( FL_FLY );
NotifyBusyEnding();
TaskComplete();
}
}
break;
case TASK_ACTBUSY_TELEPORT_TO_BUSY:
{
if ( !ActBusyNodeStillActive() )
{
TaskFail( FAIL_NO_HINT_NODE );
return;
}
Vector vecAbsOrigin = GetHintNode()->GetAbsOrigin();
QAngle vecAbsAngles = GetHintNode()->GetAbsAngles();
GetOuter()->Teleport( &vecAbsOrigin, &vecAbsAngles, NULL );
GetOuter()->GetMotor()->SetIdealYaw( vecAbsAngles.y );
TaskComplete();
}
break;
case TASK_ACTBUSY_WALK_PATH_TO_BUSY:
{
// If we have a forced activity, use that. Otherwise, walk.
if ( m_ForcedActivity != ACT_INVALID && m_ForcedActivity != ACT_RESET )
{
GetNavigator()->SetMovementActivity( m_ForcedActivity );
// Cover is void once I move
Forget( bits_MEMORY_INCOVER );
TaskComplete();
}
else
{
if( IsCombatActBusy() )
{
ChainStartTask( TASK_RUN_PATH );
}
else
{
ChainStartTask( TASK_WALK_PATH );
}
}
break;
}
case TASK_ACTBUSY_GET_PATH_TO_ACTBUSY:
{
ChainStartTask( TASK_GET_PATH_TO_HINTNODE );
if ( !HasCondition(COND_TASK_FAILED) )
{
// We successfully built a path, so stop counting consecutive failures.
m_iNumConsecutivePathFailures = 0;
// Set the arrival sequence for the actbusy to be the busy sequence, if we don't have an entry animation
busyanim_t *pBusyAnim = g_ActBusyAnimDataSystem.GetBusyAnim( m_iCurrentBusyAnim );
if ( pBusyAnim && pBusyAnim->iszSequences[BA_ENTRY] == NULL_STRING && pBusyAnim->iActivities[BA_ENTRY] == ACT_INVALID )
{
// Try and play the sequence first
if ( pBusyAnim->iszSequences[BA_BUSY] != NULL_STRING )
{
GetNavigator()->SetArrivalSequence( GetOuter()->LookupSequence( STRING(pBusyAnim->iszSequences[BA_BUSY]) ) );
}
else if ( pBusyAnim->iActivities[BA_BUSY] != ACT_INVALID )
{
// Try and play the activity second
GetNavigator()->SetArrivalActivity( pBusyAnim->iActivities[BA_BUSY] );
}
}
else
{
// Robin: Set the arrival sequence / activity to be the entry animation.
if ( pBusyAnim->iszSequences[BA_ENTRY] != NULL_STRING )
{
GetNavigator()->SetArrivalSequence( GetOuter()->LookupSequence( STRING(pBusyAnim->iszSequences[BA_ENTRY]) ) );
}
else if ( pBusyAnim->iActivities[BA_ENTRY] != ACT_INVALID )
{
// Try and play the activity second
GetNavigator()->SetArrivalActivity( pBusyAnim->iActivities[BA_ENTRY] );
}
}
}
else
{
m_iNumConsecutivePathFailures++;
if ( ai_debug_actbusy.GetInt() == 1 )
{
if ( GetHintNode() )
{
// Show which actbusy we're moving towards
NDebugOverlay::Line( GetOuter()->WorldSpaceCenter(), GetHintNode()->GetAbsOrigin(), 255, 0, 0, true, 1.0 );
}
}
}
break;
}
default:
BaseClass::StartTask( pTask);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::RunTask( const Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_WAIT_FOR_MOVEMENT:
{
// Ensure the hint node hasn't been disabled
if ( IsCurSchedule( SCHED_ACTBUSY_START_BUSYING ) )
{
if ( !ActBusyNodeStillActive() )
{
TaskFail(FAIL_NO_HINT_NODE);
return;
}
}
if ( ai_debug_actbusy.GetInt() == 1 )
{
if ( GetHintNode() )
{
// Show which actbusy we're moving towards
NDebugOverlay::Line( GetOuter()->WorldSpaceCenter(), GetHintNode()->GetAbsOrigin(), 0, 255, 0, true, 0.2 );
}
}
BaseClass::RunTask( pTask );
break;
}
case TASK_ACTBUSY_PLAY_BUSY_ANIM:
{
if( m_bUseRenderBoundsForCollision )
{
if( GetOuter()->IsSequenceFinished() && m_bNeedToSetBounds )
{
ComputeAndSetRenderBounds();
m_bNeedToSetBounds = false;
}
}
if( IsCombatActBusy() )
{
if( GetEnemy() != NULL && !HasCondition(COND_ENEMY_OCCLUDED) )
{
// Break a combat actbusy if an enemy gets very close.
// I'll probably go to hell for not doing this with conditions like I should. (sjb)
float flDistSqr = GetAbsOrigin().DistToSqr( GetEnemy()->GetAbsOrigin() );
if( flDistSqr < Square(12.0f * 15.0f) )
{
// End now.
m_flEndBusyAt = gpGlobals->curtime;
TaskComplete();
return;
}
}
}
GetOuter()->AutoMovement();
// Stop if the node's been disabled
if ( !ActBusyNodeStillActive() || GetOuter()->IsWaitFinished() )
{
TaskComplete();
}
else
{
CAI_PlayerAlly *pAlly = dynamic_cast<CAI_PlayerAlly*>(GetOuter());
if ( pAlly )
{
pAlly->SelectInterjection();
}
if( HasCondition(COND_ACTBUSY_LOST_SEE_ENTITY) )
{
StopBusying();
TaskComplete();
}
}
break;
}
case TASK_ACTBUSY_PLAY_ENTRY:
{
GetOuter()->AutoMovement();
if ( !ActBusyNodeStillActive() || GetOuter()->IsSequenceFinished() )
{
TaskComplete();
}
}
break;
case TASK_ACTBUSY_VERIFY_EXIT:
{
if( GetOuter()->IsWaitFinished() )
{
// Trace my normal hull over this spot to see if I'm able to stand up right now.
trace_t tr;
CTraceFilterOnlyNPCsAndPlayer filter( GetOuter(), COLLISION_GROUP_NONE );
UTIL_TraceHull( GetOuter()->GetAbsOrigin(), GetOuter()->GetAbsOrigin(), NAI_Hull::Mins( HULL_HUMAN ), NAI_Hull::Maxs( HULL_HUMAN ), MASK_NPCSOLID, &filter, &tr );
if( tr.startsolid )
{
// Blocked. Try again later.
GetOuter()->SetWait( 1.0f );
}
else
{
// Put an entity blocker here for a moment until I get into my bounding box.
CBaseEntity *pBlocker = CEntityBlocker::Create( GetOuter()->GetAbsOrigin(), NAI_Hull::Mins( HULL_HUMAN ), NAI_Hull::Maxs( HULL_HUMAN ), GetOuter(), true );
g_EventQueue.AddEvent( pBlocker, "Kill", 1.0, GetOuter(), GetOuter() );
TaskComplete();
}
}
}
break;
case TASK_ACTBUSY_PLAY_EXIT:
{
GetOuter()->AutoMovement();
if ( GetOuter()->IsSequenceFinished() )
{
m_bNeedsToPlayExitAnim = false;
GetOuter()->RemoveFlag( FL_FLY );
NotifyBusyEnding();
TaskComplete();
}
}
break;
default:
BaseClass::RunTask( pTask);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyBehavior::NotifyBusyEnding( void )
{
// Be sure to disable autofire
m_bAutoFireWeapon = false;
// Clear the hintnode if we're done with it
if ( GetHintNode() )
{
if ( m_bBusy || m_bMovingToBusy )
{
GetHintNode()->NPCStoppedUsing( GetOuter() );
}
GetHintNode()->Unlock();
if( IsCombatActBusy() )
{
// Don't allow anyone to use this node for a bit. This is so the tactical position
// doesn't get re-occupied the moment I leave it.
GetHintNode()->DisableForSeconds( random->RandomFloat( 10, 15) );
}
SetHintNode( NULL );
}
// Then, if we were busy, stop being busy
if ( m_bBusy )
{
m_bBusy = false;
if ( m_hActBusyGoal )
{
m_hActBusyGoal->NPCFinishedBusy( GetOuter() );
if ( m_bExitedBusyToDueLostSeeEntity )
{
m_hActBusyGoal->NPCLostSeeEntity( GetOuter() );
m_bExitedBusyToDueLostSeeEntity = false;
}
if ( m_bExitedBusyToDueSeeEnemy )
{
m_hActBusyGoal->NPCSeeEnemy( GetOuter() );
m_bExitedBusyToDueSeeEnemy = false;
}
}
}
else if ( m_bMovingToBusy && m_hActBusyGoal )
{
// Or if we were just on our way to be busy, let the goal know
m_hActBusyGoal->NPCAbortedMoveTo( GetOuter() );
}
// Don't busy again for a while
m_flEndBusyAt = 0;
if( IsCombatActBusy() )
{
// Actbusy again soon. Real soon.
m_flNextBusySearchTime = gpGlobals->curtime;
}
else
{
m_flNextBusySearchTime = gpGlobals->curtime + (RandomFloat(ai_actbusy_search_time.GetFloat(), ai_actbusy_search_time.GetFloat()*2));
}
}
//-------------------------------------
AI_BEGIN_CUSTOM_SCHEDULE_PROVIDER( CAI_ActBusyBehavior )
DECLARE_CONDITION( COND_ACTBUSY_LOST_SEE_ENTITY )
DECLARE_CONDITION( COND_ACTBUSY_AWARE_OF_ENEMY_IN_SAFE_ZONE )
DECLARE_CONDITION( COND_ACTBUSY_ENEMY_TOO_CLOSE )
DECLARE_TASK( TASK_ACTBUSY_PLAY_BUSY_ANIM )
DECLARE_TASK( TASK_ACTBUSY_PLAY_ENTRY )
DECLARE_TASK( TASK_ACTBUSY_PLAY_EXIT )
DECLARE_TASK( TASK_ACTBUSY_TELEPORT_TO_BUSY )
DECLARE_TASK( TASK_ACTBUSY_WALK_PATH_TO_BUSY )
DECLARE_TASK( TASK_ACTBUSY_GET_PATH_TO_ACTBUSY )
DECLARE_TASK( TASK_ACTBUSY_VERIFY_EXIT )
DECLARE_ANIMEVENT( AE_ACTBUSY_WEAPON_FIRE_ON )
DECLARE_ANIMEVENT( AE_ACTBUSY_WEAPON_FIRE_OFF )
//---------------------------------
DEFINE_SCHEDULE
(
SCHED_ACTBUSY_START_BUSYING,
" Tasks"
" TASK_SET_TOLERANCE_DISTANCE 4"
" TASK_ACTBUSY_GET_PATH_TO_ACTBUSY 0"
" TASK_ACTBUSY_WALK_PATH_TO_BUSY 0"
" TASK_WAIT_FOR_MOVEMENT 0"
" TASK_STOP_MOVING 0"
" TASK_FACE_HINTNODE 0"
" TASK_ACTBUSY_PLAY_ENTRY 0"
" TASK_SET_SCHEDULE SCHEDULE:SCHED_ACTBUSY_BUSY"
""
" Interrupts"
" COND_ACTBUSY_LOST_SEE_ENTITY"
)
DEFINE_SCHEDULE
(
SCHED_ACTBUSY_BUSY,
" Tasks"
" TASK_ACTBUSY_PLAY_BUSY_ANIM 0"
""
" Interrupts"
" COND_PROVOKED"
)
DEFINE_SCHEDULE
(
SCHED_ACTBUSY_STOP_BUSYING,
" Tasks"
" TASK_ACTBUSY_VERIFY_EXIT 0"
" TASK_ACTBUSY_PLAY_EXIT 0"
" TASK_WAIT 0.1"
""
" Interrupts"
" COND_NO_CUSTOM_INTERRUPTS"
)
DEFINE_SCHEDULE
(
SCHED_ACTBUSY_LEAVE,
" Tasks"
" TASK_SET_TOLERANCE_DISTANCE 4"
" TASK_ACTBUSY_GET_PATH_TO_ACTBUSY 0"
" TASK_ACTBUSY_WALK_PATH_TO_BUSY 0"
" TASK_WAIT_FOR_MOVEMENT 0"
""
" Interrupts"
" COND_PROVOKED"
)
DEFINE_SCHEDULE
(
SCHED_ACTBUSY_TELEPORT_TO_BUSY,
" Tasks"
" TASK_ACTBUSY_TELEPORT_TO_BUSY 0"
" TASK_ACTBUSY_PLAY_ENTRY 0"
" TASK_SET_SCHEDULE SCHEDULE:SCHED_ACTBUSY_BUSY"
""
" Interrupts"
" COND_PROVOKED"
)
AI_END_CUSTOM_SCHEDULE_PROVIDER()
//==========================================================================================================
// ACT BUSY GOALS
//==========================================================================================================
//-----------------------------------------------------------------------------
// Purpose: A level tool to control the actbusy behavior.
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( ai_goal_actbusy, CAI_ActBusyGoal );
BEGIN_DATADESC( CAI_ActBusyGoal )
DEFINE_KEYFIELD( m_flBusySearchRange, FIELD_FLOAT, "busysearchrange" ),
DEFINE_KEYFIELD( m_bVisibleOnly, FIELD_BOOLEAN, "visibleonly" ),
DEFINE_KEYFIELD( m_iType, FIELD_INTEGER, "type" ),
DEFINE_KEYFIELD( m_bAllowCombatActBusyTeleport, FIELD_BOOLEAN, "allowteleport" ),
DEFINE_KEYFIELD( m_iszSeeEntityName, FIELD_STRING, "SeeEntity" ),
DEFINE_KEYFIELD( m_flSeeEntityTimeout, FIELD_FLOAT, "SeeEntityTimeout" ),
DEFINE_KEYFIELD( m_iszSafeZoneVolume, FIELD_STRING, "SafeZone" ),
DEFINE_KEYFIELD( m_iSightMethod, FIELD_INTEGER, "sightmethod" ),
// Inputs
DEFINE_INPUTFUNC( FIELD_FLOAT, "SetBusySearchRange", InputSetBusySearchRange ),
DEFINE_INPUTFUNC( FIELD_STRING, "ForceNPCToActBusy", InputForceNPCToActBusy ),
DEFINE_INPUTFUNC( FIELD_EHANDLE, "ForceThisNPCToActBusy", InputForceThisNPCToActBusy ),
DEFINE_INPUTFUNC( FIELD_EHANDLE, "ForceThisNPCToLeave", InputForceThisNPCToLeave ),
// Outputs
DEFINE_OUTPUT( m_OnNPCStartedBusy, "OnNPCStartedBusy" ),
DEFINE_OUTPUT( m_OnNPCFinishedBusy, "OnNPCFinishedBusy" ),
DEFINE_OUTPUT( m_OnNPCLeft, "OnNPCLeft" ),
DEFINE_OUTPUT( m_OnNPCLostSeeEntity, "OnNPCLostSeeEntity" ),
DEFINE_OUTPUT( m_OnNPCSeeEnemy, "OnNPCSeeEnemy" ),
END_DATADESC()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CAI_ActBusyBehavior *CAI_ActBusyGoal::GetBusyBehaviorForNPC( CBaseEntity *pEntity, const char *sInputName )
{
CAI_BaseNPC *pActor = dynamic_cast<CAI_BaseNPC*>(pEntity);
if ( !pActor )
{
Msg("ai_goal_actbusy input %s fired targeting an entity that isn't an NPC.\n", sInputName);
return NULL;
}
// Get the NPC's behavior
CAI_ActBusyBehavior *pBehavior;
if ( !pActor->GetBehavior( &pBehavior ) )
{
Msg("ai_goal_actbusy input %s fired on an NPC that doesn't support ActBusy behavior.\n", sInputName );
return NULL;
}
return pBehavior;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CAI_ActBusyBehavior *CAI_ActBusyGoal::GetBusyBehaviorForNPC( const char *pszActorName, CBaseEntity *pActivator, CBaseEntity *pCaller, const char *sInputName )
{
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, MAKE_STRING(pszActorName), NULL, pActivator, pCaller );
if ( !pEntity )
{
Msg("ai_goal_actbusy input %s fired targeting a non-existant entity (%s).\n", sInputName, pszActorName );
return NULL;
}
return GetBusyBehaviorForNPC( pEntity, sInputName );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::EnableGoal( CAI_BaseNPC *pAI )
{
BaseClass::EnableGoal( pAI );
// Now use this actor to lookup the Behavior
CAI_ActBusyBehavior *pBehavior;
if ( pAI->GetBehavior( &pBehavior ) )
{
// Some NPCs may already be active due to a ForceActBusy input.
if ( !pBehavior->IsEnabled() )
{
pBehavior->Enable( this, m_flBusySearchRange, m_bVisibleOnly );
}
}
else
{
DevMsg( "ActBusy goal entity activated for an NPC (%s) that doesn't have the ActBusy behavior\n", pAI->GetDebugName() );
return;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::InputActivate( inputdata_t &inputdata )
{
if ( ai_debug_actbusy.GetInt() == 4 )
{
Msg("ACTBUSY: Actbusy goal %s (%s) activated.\n", GetClassname(), GetDebugName() );
}
BaseClass::InputActivate( inputdata );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::InputDeactivate( inputdata_t &inputdata )
{
if ( ai_debug_actbusy.GetInt() == 4 )
{
Msg("ACTBUSY: Actbusy goal %s (%s) disabled.\n", GetClassname(), GetDebugName() );
}
BaseClass::InputDeactivate( inputdata );
for( int i = 0 ; i < NumActors() ; i++ )
{
CAI_BaseNPC *pActor = GetActor( i );
if ( pActor )
{
// Now use this actor to lookup the Behavior
CAI_ActBusyBehavior *pBehavior;
if ( pActor->GetBehavior( &pBehavior ) )
{
pBehavior->Disable();
}
else
{
DevMsg( "ActBusy goal entity deactivated for an NPC that doesn't have the ActBusy behavior\n" );
return;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::InputSetBusySearchRange( inputdata_t &inputdata )
{
m_flBusySearchRange = inputdata.value.Float();
for( int i = 0 ; i < NumActors() ; i++ )
{
CAI_BaseNPC *pActor = GetActor( i );
if ( pActor )
{
// Now use this actor to lookup the Behavior
CAI_ActBusyBehavior *pBehavior;
if ( pActor->GetBehavior( &pBehavior ) )
{
pBehavior->SetBusySearchRange( m_flBusySearchRange );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::InputForceNPCToActBusy( inputdata_t &inputdata )
{
char parseString[255];
Q_strncpy(parseString, inputdata.value.String(), sizeof(parseString));
CAI_Hint *pHintNode = NULL;
float flMaxTime = NO_MAX_TIME;
bool bTeleport = false;
bool bUseNearestBusy = false;
CBaseEntity *pSeeEntity = NULL;
// Get NPC name
char *pszParam = strtok(parseString," ");
CAI_ActBusyBehavior *pBehavior = GetBusyBehaviorForNPC( pszParam, inputdata.pActivator, inputdata.pCaller, "InputForceNPCToActBusy" );
if ( !pBehavior )
return;
// Wrapped this bugfix so that it doesn't break HL2.
bool bEpisodicBugFix = hl2_episodic.GetBool();
// Do we have a specified node too?
pszParam = strtok(NULL," ");
if ( pszParam )
{
// Find the specified hintnode
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, pszParam, NULL, inputdata.pActivator, inputdata.pCaller );
if ( pEntity )
{
pHintNode = dynamic_cast<CAI_Hint*>(pEntity);
if ( !pHintNode )
{
Msg("ai_goal_actbusy input ForceNPCToActBusy fired targeting an entity that isn't a hintnode.\n");
return;
}
if ( bEpisodicBugFix )
{
pszParam = strtok(NULL," ");
}
}
}
Activity activity = ACT_INVALID;
if ( !bEpisodicBugFix )
{
pszParam = strtok(NULL," ");
}
while ( pszParam )
{
// Teleport?
if ( !Q_strncmp( pszParam, "teleport", 8 ) )
{
bTeleport = true;
}
else if ( !Q_strncmp( pszParam, "nearest", 8 ) )
{
bUseNearestBusy = true;
}
else if ( !Q_strncmp( pszParam, "see:", 4 ) )
{
pSeeEntity = gEntList.FindEntityByName( NULL, pszParam+4 );
}
else if ( pszParam[0] == '$' )
{
// $ signs prepend custom movement sequences / activities
const char *pAnimName = pszParam+1;
// Try and resolve it as an activity name
activity = (Activity)ActivityList_IndexForName( pAnimName );
if ( activity == ACT_INVALID )
{
// Try it as sequence name
pBehavior->GetOuter()->m_iszSceneCustomMoveSeq = AllocPooledString( pAnimName );
activity = ACT_SCRIPT_CUSTOM_MOVE;
}
}
else
{
// Do we have a specified time?
flMaxTime = atof( pszParam );
}
pszParam = strtok(NULL," ");
}
if ( ai_debug_actbusy.GetInt() == 4 )
{
Msg("ACTBUSY: Actbusy goal %s (%s) ForceNPCToActBusy input with data: %s.\n", GetClassname(), GetDebugName(), parseString );
}
// Tell the NPC to immediately act busy
pBehavior->SetBusySearchRange( m_flBusySearchRange );
pBehavior->ForceActBusy( this, pHintNode, flMaxTime, m_bVisibleOnly, bTeleport, bUseNearestBusy, pSeeEntity, activity );
}
//-----------------------------------------------------------------------------
// Purpose: Force the passed in NPC to actbusy
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::InputForceThisNPCToActBusy( inputdata_t &inputdata )
{
CAI_ActBusyBehavior *pBehavior = GetBusyBehaviorForNPC( inputdata.value.Entity(), "InputForceThisNPCToActBusy" );
if ( !pBehavior )
return;
// Tell the NPC to immediately act busy
pBehavior->SetBusySearchRange( m_flBusySearchRange );
pBehavior->ForceActBusy( this );
}
//-----------------------------------------------------------------------------
// Purpose: Force the passed in NPC to walk to a point and vanish
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::InputForceThisNPCToLeave( inputdata_t &inputdata )
{
CAI_ActBusyBehavior *pBehavior = GetBusyBehaviorForNPC( inputdata.value.Entity(), "InputForceThisNPCToLeave" );
if ( !pBehavior )
return;
// Tell the NPC to find a leave point and move to it
pBehavior->SetBusySearchRange( m_flBusySearchRange );
pBehavior->ForceActBusyLeave();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::NPCMovingToBusy( CAI_BaseNPC *pNPC )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::NPCStartedBusy( CAI_BaseNPC *pNPC )
{
m_OnNPCStartedBusy.Set( pNPC, pNPC, this );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::NPCStartedLeavingBusy( CAI_BaseNPC *pNPC )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::NPCAbortedMoveTo( CAI_BaseNPC *pNPC )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::NPCFinishedBusy( CAI_BaseNPC *pNPC )
{
m_OnNPCFinishedBusy.Set( pNPC, pNPC, this );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::NPCLeft( CAI_BaseNPC *pNPC )
{
m_OnNPCLeft.Set( pNPC, pNPC, this );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::NPCLostSeeEntity( CAI_BaseNPC *pNPC )
{
m_OnNPCLostSeeEntity.Set( pNPC, pNPC, this );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CAI_ActBusyGoal::NPCSeeEnemy( CAI_BaseNPC *pNPC )
{
m_OnNPCSeeEnemy.Set( pNPC, pNPC, this );
}
//==========================================================================================================
// ACT BUSY QUEUE
//==========================================================================================================
//-----------------------------------------------------------------------------
// Purpose: A level tool to control the actbusy behavior to create NPC queues
//-----------------------------------------------------------------------------
LINK_ENTITY_TO_CLASS( ai_goal_actbusy_queue, CAI_ActBusyQueueGoal );
BEGIN_DATADESC( CAI_ActBusyQueueGoal )
// Keys
DEFINE_FIELD( m_iCurrentQueueCount, FIELD_INTEGER ),
DEFINE_ARRAY( m_hNodes, FIELD_EHANDLE, MAX_QUEUE_NODES ),
DEFINE_ARRAY( m_bPlayerBlockedNodes, FIELD_BOOLEAN, MAX_QUEUE_NODES ),
DEFINE_FIELD( m_hExitNode, FIELD_EHANDLE ),
DEFINE_FIELD( m_hExitingNPC, FIELD_EHANDLE ),
DEFINE_KEYFIELD( m_bForceReachFront, FIELD_BOOLEAN, "mustreachfront" ),
// DEFINE_ARRAY( m_iszNodes, FIELD_STRING, MAX_QUEUE_NODES ), // Silence Classcheck!
DEFINE_KEYFIELD( m_iszNodes[0], FIELD_STRING, "node01"),
DEFINE_KEYFIELD( m_iszNodes[1], FIELD_STRING, "node02"),
DEFINE_KEYFIELD( m_iszNodes[2], FIELD_STRING, "node03"),
DEFINE_KEYFIELD( m_iszNodes[3], FIELD_STRING, "node04"),
DEFINE_KEYFIELD( m_iszNodes[4], FIELD_STRING, "node05"),
DEFINE_KEYFIELD( m_iszNodes[5], FIELD_STRING, "node06"),
DEFINE_KEYFIELD( m_iszNodes[6], FIELD_STRING, "node07"),
DEFINE_KEYFIELD( m_iszNodes[7], FIELD_STRING, "node08"),
DEFINE_KEYFIELD( m_iszNodes[8], FIELD_STRING, "node09"),
DEFINE_KEYFIELD( m_iszNodes[9], FIELD_STRING, "node10"),
DEFINE_KEYFIELD( m_iszNodes[10], FIELD_STRING, "node11"),
DEFINE_KEYFIELD( m_iszNodes[11], FIELD_STRING, "node12"),
DEFINE_KEYFIELD( m_iszNodes[12], FIELD_STRING, "node13"),
DEFINE_KEYFIELD( m_iszNodes[13], FIELD_STRING, "node14"),
DEFINE_KEYFIELD( m_iszNodes[14], FIELD_STRING, "node15"),
DEFINE_KEYFIELD( m_iszNodes[15], FIELD_STRING, "node16"),
DEFINE_KEYFIELD( m_iszNodes[16], FIELD_STRING, "node17"),
DEFINE_KEYFIELD( m_iszNodes[17], FIELD_STRING, "node18"),
DEFINE_KEYFIELD( m_iszNodes[18], FIELD_STRING, "node19"),
DEFINE_KEYFIELD( m_iszNodes[19], FIELD_STRING, "node20"),
DEFINE_KEYFIELD( m_iszExitNode, FIELD_STRING, "node_exit"),
// Inputs
DEFINE_INPUTFUNC( FIELD_INTEGER, "PlayerStartedBlocking", InputPlayerStartedBlocking ),
DEFINE_INPUTFUNC( FIELD_INTEGER, "PlayerStoppedBlocking", InputPlayerStoppedBlocking ),
DEFINE_INPUTFUNC( FIELD_VOID, "MoveQueueUp", InputMoveQueueUp ),
// Outputs
DEFINE_OUTPUT( m_OnQueueMoved, "OnQueueMoved" ),
DEFINE_OUTPUT( m_OnNPCLeftQueue, "OnNPCLeftQueue" ),
DEFINE_OUTPUT( m_OnNPCStartedLeavingQueue, "OnNPCStartedLeavingQueue" ),
DEFINE_THINKFUNC( QueueThink ),
DEFINE_THINKFUNC( MoveQueueUpThink ),
END_DATADESC()
#define QUEUE_THINK_CONTEXT "ActBusyQueueThinkContext"
#define QUEUE_MOVEUP_THINK_CONTEXT "ActBusyQueueMoveUpThinkContext"
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::Spawn( void )
{
BaseClass::Spawn();
RegisterThinkContext( QUEUE_MOVEUP_THINK_CONTEXT );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::DrawDebugGeometryOverlays( void )
{
BaseClass::DrawDebugGeometryOverlays();
// Debug for reservers
for ( int i = 0; i < MAX_QUEUE_NODES; i++ )
{
if ( !m_hNodes[i] )
continue;
if ( m_bPlayerBlockedNodes[i] )
{
NDebugOverlay::Box( m_hNodes[i]->GetAbsOrigin(), -Vector(5,5,5), Vector(5,5,5), 255, 0, 0, 0, 0.1 );
}
else
{
NDebugOverlay::Box( m_hNodes[i]->GetAbsOrigin(), -Vector(5,5,5), Vector(5,5,5), 255, 255, 255, 0, 0.1 );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::InputActivate( inputdata_t &inputdata )
{
if ( !IsActive() )
{
// Find all our nodes
for ( int i = 0; i < MAX_QUEUE_NODES; i++ )
{
if ( m_iszNodes[i] == NULL_STRING )
{
m_hNodes[i] = NULL;
continue;
}
CBaseEntity *pEntity = gEntList.FindEntityByName( NULL, m_iszNodes[i] );
if ( !pEntity )
{
Warning( "Unable to find ai_goal_actbusy_queue %s's node %d: %s\n", STRING(GetEntityName()), i, STRING(m_iszNodes[i]) );
UTIL_Remove( this );
return;
}
m_hNodes[i] = dynamic_cast<CAI_Hint*>(pEntity);
if ( !m_hNodes[i] )
{
Warning( "ai_goal_actbusy_queue %s's node %d: '%s' is not an ai_hint.\n", STRING(GetEntityName()), i, STRING(m_iszNodes[i]) );
UTIL_Remove( this );
return;
}
// Disable all but the first node
if ( i == 0 )
{
m_hNodes[i]->SetDisabled( false );
}
else
{
m_hNodes[i]->SetDisabled( true );
}
}
// Find the exit node
m_hExitNode = gEntList.FindEntityByName( NULL, m_iszExitNode );
if ( !m_hExitNode )
{
Warning( "Unable to find ai_goal_actbusy_queue %s's exit node: %s\n", STRING(GetEntityName()), STRING(m_iszExitNode) );
UTIL_Remove( this );
return;
}
RecalculateQueueCount();
SetContextThink( &CAI_ActBusyQueueGoal::QueueThink, gpGlobals->curtime + 5, QUEUE_THINK_CONTEXT );
}
BaseClass::InputActivate( inputdata );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : iCount -
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::RecalculateQueueCount( void )
{
// First, find the highest unused node in the queue
int iCount = 0;
for ( int i = 0; i < MAX_QUEUE_NODES; i++ )
{
if ( NodeIsOccupied(i) || m_bPlayerBlockedNodes[i] )
{
iCount = i+1;
}
}
//Msg("Count: %d (OLD %d)\n", iCount, m_iCurrentQueueCount );
// Queue hasn't changed?
if ( iCount == m_iCurrentQueueCount )
return;
for ( int i = 0; i < MAX_QUEUE_NODES; i++ )
{
if ( m_hNodes[i] )
{
// Disable nodes beyond 1 past the end of the queue
if ( i > iCount )
{
m_hNodes[i]->SetDisabled( true );
}
else
{
m_hNodes[i]->SetDisabled( false );
// To prevent NPCs outside the queue moving directly to nodes within the queue, only
// have the entry node be a valid actbusy node.
if ( i == iCount )
{
m_hNodes[i]->SetHintType( HINT_WORLD_WORK_POSITION );
}
else
{
m_hNodes[i]->SetHintType( HINT_NONE );
}
}
}
}
m_iCurrentQueueCount = iCount;
m_OnQueueMoved.Set( m_iCurrentQueueCount, this, this);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::InputPlayerStartedBlocking( inputdata_t &inputdata )
{
int iNode = inputdata.value.Int() - 1;
Assert( iNode >= 0 && iNode < MAX_QUEUE_NODES );
m_bPlayerBlockedNodes[iNode] = true;
/*
// First, find all NPCs heading to points in front of the player's blocked spot
for ( int i = 0; i < iNode; i++ )
{
CAI_BaseNPC *pNPC = GetNPCOnNode(i);
if ( !pNPC )
continue;
CAI_ActBusyBehavior *pBehavior = GetQueueBehaviorForNPC( pNPC );
if ( pBehavior->IsMovingToBusy() )
{
// We may be ahead of the player in the queue, which means we can safely
// be left alone to reach the node. Make sure we're not closer to it than the player is
float flPlayerDistToNode = (inputdata.pActivator->GetAbsOrigin() - m_hNodes[i]->GetAbsOrigin()).LengthSqr();
if ( (pNPC->GetAbsOrigin() - m_hNodes[i]->GetAbsOrigin()).LengthSqr() < flPlayerDistToNode )
continue;
// We're an NPC heading to a node past the player, and yet the player's in our way.
pBehavior->StopBusying();
}
}
*/
// If an NPC was heading towards this node, tell him to go elsewhere
CAI_BaseNPC *pNPC = GetNPCOnNode(iNode);
PushNPCBackInQueue( pNPC, iNode );
RecalculateQueueCount();
}
//-----------------------------------------------------------------------------
// Purpose: Find a node back in the queue to move to, and push all NPCs beyond that backwards
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::PushNPCBackInQueue( CAI_BaseNPC *pNPC, int iStartingNode )
{
// Push this guy back, and tell everyone behind him to move back too, until we find a gap
while ( pNPC )
{
CAI_ActBusyBehavior *pBehavior = GetQueueBehaviorForNPC( pNPC );
pBehavior->StopBusying();
// Find any node farther back in the queue that isn't player blocked
for ( int iNext = iStartingNode+1; iNext < MAX_QUEUE_NODES; iNext++ )
{
if ( !m_bPlayerBlockedNodes[iNext] )
{
// Kick off any NPCs on the node we're about to steal
CAI_BaseNPC *pTargetNPC = GetNPCOnNode(iNext);
if ( pTargetNPC )
{
CAI_ActBusyBehavior *pTargetBehavior = GetQueueBehaviorForNPC( pTargetNPC );
pTargetBehavior->StopBusying();
}
// Force the NPC to move up to the empty slot
pBehavior->ForceActBusy( this, m_hNodes[iNext] );
// Now look for a spot for the npc who's spot we've just stolen
pNPC = pTargetNPC;
iStartingNode = iNext;
break;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::InputPlayerStoppedBlocking( inputdata_t &inputdata )
{
int iNode = inputdata.value.Int() - 1;
Assert( iNode >= 0 && iNode < MAX_QUEUE_NODES );
m_bPlayerBlockedNodes[iNode] = false;
RecalculateQueueCount();
MoveQueueUp();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::InputMoveQueueUp( inputdata_t &inputdata )
{
// Find the first NPC in the queue
CAI_BaseNPC *pNPC = NULL;
for ( int i = 0; i < MAX_QUEUE_NODES; i++ )
{
pNPC = GetNPCOnNode(i);
if ( pNPC )
{
CAI_ActBusyBehavior *pBehavior = GetQueueBehaviorForNPC( pNPC );
// If we're still en-route, we're only allowed to leave if the queue
// is allowed to send NPCs away that haven't reached the front.
if ( !pBehavior->IsMovingToBusy() || !m_bForceReachFront )
break;
pNPC = NULL;
}
// If queue members have to reach the front of the queue,
// break after trying the first node.
if ( m_bForceReachFront )
break;
}
// Did we find an NPC?
if ( pNPC )
{
// Make them leave the actbusy
CAI_ActBusyBehavior *pBehavior = GetQueueBehaviorForNPC( pNPC );
pBehavior->Disable();
m_hExitingNPC = pNPC;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::NPCMovingToBusy( CAI_BaseNPC *pNPC )
{
BaseClass::NPCMovingToBusy( pNPC );
RecalculateQueueCount();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::NPCStartedBusy( CAI_BaseNPC *pNPC )
{
BaseClass::NPCStartedBusy( pNPC );
MoveQueueUp();
}
//-----------------------------------------------------------------------------
// Purpose: Start a short timer that'll clean up holes in the queue
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::MoveQueueUp( void )
{
// Find the node the NPC has arrived at, and tell the guy behind him to move forward
if ( GetNextThink( QUEUE_MOVEUP_THINK_CONTEXT ) < gpGlobals->curtime )
{
float flTime = gpGlobals->curtime + RandomFloat( 0.3, 0.5 );
SetContextThink( &CAI_ActBusyQueueGoal::MoveQueueUpThink, flTime, QUEUE_MOVEUP_THINK_CONTEXT );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::MoveQueueUpThink( void )
{
// Find empty holes in the queue, and move NPCs past them forward
for ( int iEmptyNode = 0; iEmptyNode < (MAX_QUEUE_NODES-1); iEmptyNode++ )
{
if ( !NodeIsOccupied(iEmptyNode) && !m_bPlayerBlockedNodes[iEmptyNode] )
{
// Look for NPCs farther down the queue, but not on the other side of a player
for ( int iNext = iEmptyNode+1; iNext < MAX_QUEUE_NODES; iNext++ )
{
// Is the player blocking this node? If so, we're done
if ( m_bPlayerBlockedNodes[iNext] )
break;
CAI_BaseNPC *pNPC = GetNPCOnNode(iNext);
if ( pNPC )
{
CAI_ActBusyBehavior *pBehavior = GetQueueBehaviorForNPC( pNPC );
// Force the NPC to move up to the empty slot
pBehavior->ForceActBusy( this, m_hNodes[iEmptyNode] );
break;
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::NPCAbortedMoveTo( CAI_BaseNPC *pNPC )
{
BaseClass::NPCAbortedMoveTo( pNPC );
RemoveNPCFromQueue( pNPC );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::NPCFinishedBusy( CAI_BaseNPC *pNPC )
{
BaseClass::NPCFinishedBusy( pNPC );
// If this NPC was at the head of the line, move him to the exit node
if ( m_hExitingNPC == pNPC )
{
pNPC->ScheduledMoveToGoalEntity( SCHED_IDLE_WALK, m_hExitNode, ACT_WALK );
m_OnNPCLeftQueue.Set( pNPC, pNPC, this );
m_hExitingNPC = NULL;
}
RemoveNPCFromQueue( pNPC );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pNPC -
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::NPCStartedLeavingBusy( CAI_BaseNPC *pNPC )
{
BaseClass::NPCStartedLeavingBusy( pNPC );
// If this NPC it at the head of the line, fire the output
if ( m_hExitingNPC == pNPC )
{
m_OnNPCStartedLeavingQueue.Set( pNPC, pNPC, this );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::RemoveNPCFromQueue( CAI_BaseNPC *pNPC )
{
RecalculateQueueCount();
// Find the node the NPC was heading to, and tell the guy behind him to move forward
MoveQueueUp();
}
//-----------------------------------------------------------------------------
// Purpose: Move the first NPC out of the queue
//-----------------------------------------------------------------------------
void CAI_ActBusyQueueGoal::QueueThink( void )
{
if ( !GetNPCOnNode(0) )
{
MoveQueueUp();
}
SetContextThink( &CAI_ActBusyQueueGoal::QueueThink, gpGlobals->curtime + 5, QUEUE_THINK_CONTEXT );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
inline bool CAI_ActBusyQueueGoal::NodeIsOccupied( int i )
{
return ( m_hNodes[i] && !m_hNodes[i]->IsDisabled() && m_hNodes[i]->IsLocked() );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : iNode -
// Output : CAI_BaseNPC
//-----------------------------------------------------------------------------
CAI_BaseNPC *CAI_ActBusyQueueGoal::GetNPCOnNode( int iNode )
{
if ( !m_hNodes[iNode] )
return NULL;
return dynamic_cast<CAI_BaseNPC *>(m_hNodes[iNode]->User());
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : iNode -
// Output : CAI_ActBusyBehavior
//-----------------------------------------------------------------------------
CAI_ActBusyBehavior *CAI_ActBusyQueueGoal::GetQueueBehaviorForNPC( CAI_BaseNPC *pNPC )
{
CAI_ActBusyBehavior *pBehavior;
pNPC->GetBehavior( &pBehavior );
Assert( pBehavior );
return pBehavior;
}