2008-09-15 01:00:17 -05:00
//========= Copyright <20> 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
# ifndef AI_BEHAVIOR_H
# define AI_BEHAVIOR_H
# include "ai_component.h"
# include "ai_basenpc.h"
# include "ai_default.h"
# include "AI_Criteria.h"
# include "networkvar.h"
# ifdef DEBUG
2008-09-15 01:33:59 -05:00
# ifdef _MSC_VER
2008-09-15 01:00:17 -05:00
# pragma warning(push)
2008-09-15 01:33:59 -05:00
# endif
2008-09-15 01:00:17 -05:00
# include <typeinfo>
2008-09-15 01:33:59 -05:00
# ifdef _MSC_VER
2008-09-15 01:00:17 -05:00
# pragma warning(pop)
# pragma warning(disable:4290)
# endif
2008-09-15 01:33:59 -05:00
# endif
2008-09-15 01:00:17 -05:00
# if defined( _WIN32 )
# pragma once
# endif
//-----------------------------------------------------------------------------
// CAI_Behavior...
//
// Purpose: The core component that defines a behavior in an NPC by selecting
// schedules and running tasks
//
// Intended to be used as an organizational tool as well as a way
// for various NPCs to share behaviors without sharing an inheritance
// relationship, and without cramming those behaviors into the base
// NPC class.
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Purpose: Base class defines interface to behaviors and provides bridging
// methods
//-----------------------------------------------------------------------------
class IBehaviorBackBridge ;
//-------------------------------------
abstract_class CAI_BehaviorBase : public CAI_Component
{
DECLARE_CLASS ( CAI_BehaviorBase , CAI_Component )
public :
CAI_BehaviorBase ( CAI_BaseNPC * pOuter = NULL )
: CAI_Component ( pOuter ) ,
m_pBackBridge ( NULL )
{
}
virtual const char * GetName ( ) = 0 ;
virtual bool KeyValue ( const char * szKeyName , const char * szValue )
{
return false ;
}
bool IsRunning ( ) { Assert ( GetOuter ( ) ) ; return ( GetOuter ( ) - > GetRunningBehavior ( ) = = this ) ; }
virtual bool CanSelectSchedule ( ) { return true ; }
virtual void BeginScheduleSelection ( ) { }
virtual void EndScheduleSelection ( ) { }
void SetBackBridge ( IBehaviorBackBridge * pBackBridge )
{
Assert ( m_pBackBridge = = NULL | | pBackBridge = = NULL ) ;
m_pBackBridge = pBackBridge ;
}
void BridgePrecache ( ) { Precache ( ) ; }
void BridgeSpawn ( ) { Spawn ( ) ; }
void BridgeUpdateOnRemove ( ) { UpdateOnRemove ( ) ; }
void BridgeEvent_Killed ( const CTakeDamageInfo & info ) { Event_Killed ( info ) ; }
void BridgeCleanupOnDeath ( CBaseEntity * pCulprit , bool bFireDeathOutput ) { CleanupOnDeath ( pCulprit , bFireDeathOutput ) ; }
void BridgeOnChangeHintGroup ( string_t oldGroup , string_t newGroup ) { OnChangeHintGroup ( oldGroup , newGroup ) ; }
void BridgeGatherConditions ( ) { GatherConditions ( ) ; }
void BridgePrescheduleThink ( ) { PrescheduleThink ( ) ; }
void BridgeOnScheduleChange ( ) { OnScheduleChange ( ) ; }
void BridgeOnStartSchedule ( int scheduleType ) ;
int BridgeSelectSchedule ( ) ;
bool BridgeSelectFailSchedule ( int failedSchedule , int failedTask , AI_TaskFailureCode_t taskFailCode , int * pResult ) ;
bool BridgeStartTask ( const Task_t * pTask ) ;
bool BridgeRunTask ( const Task_t * pTask ) ;
bool BridgeAimGun ( void ) ;
int BridgeTranslateSchedule ( int scheduleType ) ;
bool BridgeGetSchedule ( int localScheduleID , CAI_Schedule * * ppResult ) ;
bool BridgeTaskName ( int taskID , const char * * ) ;
Activity BridgeNPC_TranslateActivity ( Activity activity ) ;
void BridgeBuildScheduleTestBits ( ) { BuildScheduleTestBits ( ) ; }
bool BridgeIsCurTaskContinuousMove ( bool * pResult ) ;
void BridgeOnMovementFailed ( ) { OnMovementFailed ( ) ; }
void BridgeOnMovementComplete ( ) { OnMovementComplete ( ) ; }
float BridgeGetDefaultNavGoalTolerance ( ) ;
bool BridgeFValidateHintType ( CAI_Hint * pHint , bool * pResult ) ;
bool BridgeIsValidEnemy ( CBaseEntity * pEnemy ) ;
CBaseEntity * BridgeBestEnemy ( ) ;
bool BridgeIsValidCover ( const Vector & vLocation , CAI_Hint const * pHint ) ;
bool BridgeIsValidShootPosition ( const Vector & vLocation , CAI_Node * pNode , CAI_Hint const * pHint ) ;
float BridgeGetMaxTacticalLateralMovement ( void ) ;
bool BridgeShouldIgnoreSound ( CSound * pSound ) ;
bool BridgeIsInterruptable ( void ) ;
bool BridgeShouldPlayerAvoid ( void ) ;
int BridgeOnTakeDamage_Alive ( const CTakeDamageInfo & info ) ;
float BridgeGetReasonableFacingDist ( void ) ;
bool BridgeShouldAlwaysThink ( bool * pResult ) ;
void BridgeOnChangeActiveWeapon ( CBaseCombatWeapon * pOldWeapon , CBaseCombatWeapon * pNewWeapon ) ;
void BridgeOnRestore ( ) ;
virtual bool BridgeSpeakMapmakerInterruptConcept ( string_t iszConcept ) ;
bool BridgeCanFlinch ( void ) ;
bool BridgeIsCrouching ( void ) ;
bool BridgeIsCrouchedActivity ( Activity activity ) ;
bool BridgeQueryHearSound ( CSound * pSound ) ;
bool BridgeCanRunAScriptedNPCInteraction ( bool bForced ) ;
Activity BridgeGetFlinchActivity ( bool bHeavyDamage , bool bGesture ) ;
bool BridgeOnCalcBaseMove ( AILocalMoveGoal_t * pMoveGoal , float distClear , AIMoveResult_t * pResult ) ;
virtual void GatherConditions ( ) ;
virtual void GatherConditionsNotActive ( ) { return ; } // Override this and your behavior will call this in place of GatherConditions() when your behavior is NOT the active one.
virtual void OnUpdateShotRegulator ( ) { }
virtual CAI_ClassScheduleIdSpace * GetClassScheduleIdSpace ( ) ;
virtual int DrawDebugTextOverlays ( int text_offset ) ;
virtual int Save ( ISave & save ) ;
virtual int Restore ( IRestore & restore ) ;
static void SaveBehaviors ( ISave & save , CAI_BehaviorBase * pCurrentBehavior , CAI_BehaviorBase * * ppBehavior , int nBehaviors ) ;
static int RestoreBehaviors ( IRestore & restore , CAI_BehaviorBase * * ppBehavior , int nBehaviors ) ; // returns index of "current" behavior, or -1
protected :
int GetNpcState ( ) { return GetOuter ( ) - > m_NPCState ; }
virtual void Precache ( ) { }
virtual void Spawn ( ) { }
virtual void UpdateOnRemove ( ) { }
virtual void Event_Killed ( const CTakeDamageInfo & info ) { }
virtual void CleanupOnDeath ( CBaseEntity * pCulprit , bool bFireDeathOutput ) { }
virtual void PrescheduleThink ( ) ;
virtual void OnScheduleChange ( ) ;
virtual void OnStartSchedule ( int scheduleType ) ;
virtual int SelectSchedule ( ) ;
virtual int SelectFailSchedule ( int failedSchedule , int failedTask , AI_TaskFailureCode_t taskFailCode ) ;
virtual void StartTask ( const Task_t * pTask ) ;
virtual void RunTask ( const Task_t * pTask ) ;
virtual void AimGun ( void ) ;
virtual int TranslateSchedule ( int scheduleType ) ;
virtual CAI_Schedule * GetSchedule ( int schedule ) ;
virtual const char * GetSchedulingErrorName ( ) ;
virtual void BuildScheduleTestBits ( ) { }
bool IsCurSchedule ( int schedId , bool fIdeal = true ) ;
CAI_Hint * GetHintNode ( ) { return GetOuter ( ) - > GetHintNode ( ) ; }
const CAI_Hint * GetHintNode ( ) const { return GetOuter ( ) - > GetHintNode ( ) ; }
void SetHintNode ( CAI_Hint * pHintNode ) { GetOuter ( ) - > SetHintNode ( pHintNode ) ; }
void ClearHintNode ( float reuseDelay = 0.0 ) { GetOuter ( ) - > ClearHintNode ( reuseDelay ) ; }
protected :
// Used by derived classes to chain a task to a task that might not be the
// one they are currently handling:
void ChainStartTask ( int task , float taskData = 0 ) ;
void ChainRunTask ( int task , float taskData = 0 ) ;
protected :
virtual Activity NPC_TranslateActivity ( Activity activity ) ;
virtual bool IsCurTaskContinuousMove ( ) ;
virtual void OnMovementFailed ( ) { } ;
virtual void OnMovementComplete ( ) { } ;
virtual float GetDefaultNavGoalTolerance ( ) ;
virtual bool FValidateHintType ( CAI_Hint * pHint ) ;
virtual bool IsValidEnemy ( CBaseEntity * pEnemy ) ;
virtual CBaseEntity * BestEnemy ( ) ;
virtual bool IsValidCover ( const Vector & vLocation , CAI_Hint const * pHint ) ;
virtual bool IsValidShootPosition ( const Vector & vLocation , CAI_Node * pNode , CAI_Hint const * pHint ) ;
virtual float GetMaxTacticalLateralMovement ( void ) ;
virtual bool ShouldIgnoreSound ( CSound * pSound ) ;
virtual bool IsInterruptable ( void ) ;
virtual int OnTakeDamage_Alive ( const CTakeDamageInfo & info ) ;
virtual float GetReasonableFacingDist ( void ) ;
virtual bool ShouldPlayerAvoid ( void ) ;
virtual bool CanFlinch ( void ) ;
virtual bool IsCrouching ( void ) ;
virtual bool IsCrouchedActivity ( Activity activity ) ;
virtual bool QueryHearSound ( CSound * pSound ) ;
virtual bool CanRunAScriptedNPCInteraction ( bool bForced ) ;
virtual Activity GetFlinchActivity ( bool bHeavyDamage , bool bGesture ) ;
virtual bool OnCalcBaseMove ( AILocalMoveGoal_t * pMoveGoal , float distClear , AIMoveResult_t * pResult ) ;
virtual bool ShouldAlwaysThink ( ) ;
virtual void OnChangeActiveWeapon ( CBaseCombatWeapon * pOldWeapon , CBaseCombatWeapon * pNewWeapon ) { } ;
virtual bool SpeakMapmakerInterruptConcept ( string_t iszConcept ) { return false ; } ;
virtual void OnRestore ( ) { } ;
bool NotifyChangeBehaviorStatus ( bool fCanFinishSchedule = false ) ;
bool HaveSequenceForActivity ( Activity activity ) { return GetOuter ( ) - > HaveSequenceForActivity ( activity ) ; }
//---------------------------------
string_t GetHintGroup ( ) { return GetOuter ( ) - > GetHintGroup ( ) ; }
void ClearHintGroup ( ) { GetOuter ( ) - > ClearHintGroup ( ) ; }
void SetHintGroup ( string_t name ) { GetOuter ( ) - > SetHintGroup ( name ) ; }
virtual void OnChangeHintGroup ( string_t oldGroup , string_t newGroup ) { }
//
// These allow derived classes to implement custom schedules
//
static CAI_GlobalScheduleNamespace * GetSchedulingSymbols ( ) { return CAI_BaseNPC : : GetSchedulingSymbols ( ) ; }
static bool LoadSchedules ( ) { return true ; }
virtual bool IsBehaviorSchedule ( int scheduleType ) { return false ; }
CAI_Navigator * GetNavigator ( ) { return GetOuter ( ) - > GetNavigator ( ) ; }
CAI_Motor * GetMotor ( ) { return GetOuter ( ) - > GetMotor ( ) ; }
CAI_TacticalServices * GetTacticalServices ( ) { return GetOuter ( ) - > GetTacticalServices ( ) ; }
bool m_fOverrode ;
IBehaviorBackBridge * m_pBackBridge ;
DECLARE_DATADESC ( ) ;
} ;
//-----------------------------------------------------------------------------
// Purpose: Template provides provides back bridge to owning class and
// establishes namespace settings
//-----------------------------------------------------------------------------
template < class NPC_CLASS = CAI_BaseNPC , const int ID_SPACE_OFFSET = 100000 >
class CAI_Behavior : public CAI_ComponentWithOuter < NPC_CLASS , CAI_BehaviorBase >
{
public :
DECLARE_CLASS_NOFRIEND ( CAI_Behavior , NPC_CLASS ) ;
enum
{
NEXT_TASK = ID_SPACE_OFFSET ,
NEXT_SCHEDULE = ID_SPACE_OFFSET ,
NEXT_CONDITION = ID_SPACE_OFFSET
} ;
void SetCondition ( int condition )
{
if ( condition > = ID_SPACE_OFFSET & & condition < ID_SPACE_OFFSET + 10000 ) // it's local to us
condition = GetClassScheduleIdSpace ( ) - > ConditionLocalToGlobal ( condition ) ;
2008-09-15 01:33:59 -05:00
this - > GetOuter ( ) - > SetCondition ( condition ) ;
2008-09-15 01:00:17 -05:00
}
bool HasCondition ( int condition )
{
if ( condition > = ID_SPACE_OFFSET & & condition < ID_SPACE_OFFSET + 10000 ) // it's local to us
condition = GetClassScheduleIdSpace ( ) - > ConditionLocalToGlobal ( condition ) ;
2008-09-15 01:33:59 -05:00
return this - > GetOuter ( ) - > HasCondition ( condition ) ;
2008-09-15 01:00:17 -05:00
}
bool HasInterruptCondition ( int condition )
{
if ( condition > = ID_SPACE_OFFSET & & condition < ID_SPACE_OFFSET + 10000 ) // it's local to us
condition = GetClassScheduleIdSpace ( ) - > ConditionLocalToGlobal ( condition ) ;
2008-09-15 01:33:59 -05:00
return this - > GetOuter ( ) - > HasInterruptCondition ( condition ) ;
2008-09-15 01:00:17 -05:00
}
void ClearCondition ( int condition )
{
if ( condition > = ID_SPACE_OFFSET & & condition < ID_SPACE_OFFSET + 10000 ) // it's local to us
condition = GetClassScheduleIdSpace ( ) - > ConditionLocalToGlobal ( condition ) ;
2008-09-15 01:33:59 -05:00
this - > GetOuter ( ) - > ClearCondition ( condition ) ;
2008-09-15 01:00:17 -05:00
}
protected :
CAI_Behavior ( NPC_CLASS * pOuter = NULL )
: CAI_ComponentWithOuter < NPC_CLASS , CAI_BehaviorBase > ( pOuter )
{
}
static CAI_GlobalScheduleNamespace * GetSchedulingSymbols ( )
{
return NPC_CLASS : : GetSchedulingSymbols ( ) ;
}
virtual CAI_ClassScheduleIdSpace * GetClassScheduleIdSpace ( )
{
2008-09-15 01:33:59 -05:00
return this - > GetOuter ( ) - > GetClassScheduleIdSpace ( ) ;
2008-09-15 01:00:17 -05:00
}
static CAI_ClassScheduleIdSpace & AccessClassScheduleIdSpaceDirect ( )
{
return NPC_CLASS : : AccessClassScheduleIdSpaceDirect ( ) ;
}
private :
virtual bool IsBehaviorSchedule ( int scheduleType ) { return ( scheduleType > = ID_SPACE_OFFSET & & scheduleType < ID_SPACE_OFFSET + 10000 ) ; }
} ;
//-----------------------------------------------------------------------------
// Purpose: Some bridges a little more complicated to allow behavior to see
// what base class would do or control order in which it's donw
//-----------------------------------------------------------------------------
abstract_class IBehaviorBackBridge
{
public :
virtual void BackBridge_GatherConditions ( ) = 0 ;
virtual int BackBridge_SelectSchedule ( ) = 0 ;
virtual int BackBridge_TranslateSchedule ( int scheduleType ) = 0 ;
virtual Activity BackBridge_NPC_TranslateActivity ( Activity activity ) = 0 ;
virtual bool BackBridge_IsValidEnemy ( CBaseEntity * pEnemy ) = 0 ;
virtual CBaseEntity * BackBridge_BestEnemy ( void ) = 0 ;
virtual bool BackBridge_IsValidCover ( const Vector & vLocation , CAI_Hint const * pHint ) = 0 ;
virtual bool BackBridge_IsValidShootPosition ( const Vector & vLocation , CAI_Node * pNode , CAI_Hint const * pHint ) = 0 ;
virtual float BackBridge_GetMaxTacticalLateralMovement ( void ) = 0 ;
virtual bool BackBridge_ShouldIgnoreSound ( CSound * pSound ) = 0 ;
virtual bool BackBridge_IsInterruptable ( void ) = 0 ;
virtual bool BackBridge_ShouldPlayerAvoid ( void ) = 0 ;
virtual int BackBridge_OnTakeDamage_Alive ( const CTakeDamageInfo & info ) = 0 ;
virtual float BackBridge_GetDefaultNavGoalTolerance ( ) = 0 ;
virtual float BackBridge_GetReasonableFacingDist ( void ) = 0 ;
virtual bool BackBridge_CanFlinch ( void ) = 0 ;
virtual bool BackBridge_IsCrouching ( void ) = 0 ;
virtual bool BackBridge_IsCrouchedActivity ( Activity activity ) = 0 ;
virtual bool BackBridge_QueryHearSound ( CSound * pSound ) = 0 ;
virtual bool BackBridge_CanRunAScriptedNPCInteraction ( bool bForced ) = 0 ;
virtual Activity BackBridge_GetFlinchActivity ( bool bHeavyDamage , bool bGesture ) = 0 ;
virtual bool BackBridge_OnCalcBaseMove ( AILocalMoveGoal_t * pMoveGoal , float distClear , AIMoveResult_t * pResult ) = 0 ;
//-------------------------------------
} ;
//-----------------------------------------------------------------------------
// Purpose: The common instantiation of the above template
//-----------------------------------------------------------------------------
typedef CAI_Behavior < > CAI_SimpleBehavior ;
//-----------------------------------------------------------------------------
// Purpose: Base class for AIs that want to act as a host for CAI_Behaviors
// NPCs aren't required to use this, but probably want to.
//-----------------------------------------------------------------------------
template < class BASE_NPC >
class CAI_BehaviorHost : public BASE_NPC ,
private IBehaviorBackBridge
{
public :
DECLARE_CLASS_NOFRIEND ( CAI_BehaviorHost , BASE_NPC ) ;
CAI_BehaviorHost ( )
: m_pCurBehavior ( NULL )
{
# ifdef DEBUG
m_fDebugInCreateBehaviors = false ;
# endif
}
void CleanupOnDeath ( CBaseEntity * pCulprit = NULL , bool bFireDeathOutput = true ) ;
virtual int Save ( ISave & save ) ;
virtual int Restore ( IRestore & restore ) ;
virtual bool CreateComponents ( ) ;
// Automatically called during entity construction, derived class calls AddBehavior()
virtual bool CreateBehaviors ( ) { return true ; }
// forces movement and sets a new schedule
virtual bool ScheduledMoveToGoalEntity ( int scheduleType , CBaseEntity * pGoalEntity , Activity movementActivity ) ;
virtual bool ScheduledFollowPath ( int scheduleType , CBaseEntity * pPathStart , Activity movementActivity ) ;
virtual void ForceSelectedGo ( CBaseEntity * pPlayer , const Vector & targetPos , const Vector & traceDir , bool bRun ) ;
virtual void ForceSelectedGoRandom ( void ) ;
// Bridges
void Precache ( ) ;
void NPCInit ( ) ;
void UpdateOnRemove ( ) ;
void Event_Killed ( const CTakeDamageInfo & info ) ;
void GatherConditions ( ) ;
void PrescheduleThink ( ) ;
int SelectSchedule ( ) ;
void KeepRunningBehavior ( ) ;
int SelectFailSchedule ( int failedSchedule , int failedTask , AI_TaskFailureCode_t taskFailCode ) ;
void OnScheduleChange ( ) ;
void OnStartSchedule ( int scheduleType ) ;
int TranslateSchedule ( int scheduleType ) ;
void StartTask ( const Task_t * pTask ) ;
void RunTask ( const Task_t * pTask ) ;
void AimGun ( void ) ;
CAI_Schedule * GetSchedule ( int localScheduleID ) ;
const char * TaskName ( int taskID ) ;
void BuildScheduleTestBits ( ) ;
void OnChangeHintGroup ( string_t oldGroup , string_t newGroup ) ;
Activity NPC_TranslateActivity ( Activity activity ) ;
bool IsCurTaskContinuousMove ( ) ;
void OnMovementFailed ( ) ;
void OnMovementComplete ( ) ;
bool FValidateHintType ( CAI_Hint * pHint ) ;
float GetDefaultNavGoalTolerance ( ) ;
bool IsValidEnemy ( CBaseEntity * pEnemy ) ;
CBaseEntity * BestEnemy ( void ) ;
bool IsValidCover ( const Vector & vLocation , CAI_Hint const * pHint ) ;
bool IsValidShootPosition ( const Vector & vLocation , CAI_Node * pNode , CAI_Hint const * pHint ) ;
float GetMaxTacticalLateralMovement ( void ) ;
bool ShouldIgnoreSound ( CSound * pSound ) ;
bool IsInterruptable ( void ) ;
bool ShouldPlayerAvoid ( void ) ;
int OnTakeDamage_Alive ( const CTakeDamageInfo & info ) ;
float GetReasonableFacingDist ( void ) ;
bool CanFlinch ( void ) ;
bool IsCrouching ( void ) ;
bool IsCrouchedActivity ( Activity activity ) ;
bool QueryHearSound ( CSound * pSound ) ;
bool CanRunAScriptedNPCInteraction ( bool bForced ) ;
Activity GetFlinchActivity ( bool bHeavyDamage , bool bGesture ) ;
bool OnCalcBaseMove ( AILocalMoveGoal_t * pMoveGoal , float distClear , AIMoveResult_t * pResult ) ;
bool ShouldAlwaysThink ( ) ;
void OnChangeActiveWeapon ( CBaseCombatWeapon * pOldWeapon , CBaseCombatWeapon * pNewWeapon ) ;
virtual bool SpeakMapmakerInterruptConcept ( string_t iszConcept ) ;
void OnRestore ( ) ;
void ModifyOrAppendCriteria ( AI_CriteriaSet & set ) ;
//---------------------------------
virtual bool OnBehaviorChangeStatus ( CAI_BehaviorBase * pBehavior , bool fCanFinishSchedule ) ;
virtual void OnChangeRunningBehavior ( CAI_BehaviorBase * pOldBehavior , CAI_BehaviorBase * pNewBehavior ) ;
protected :
void AddBehavior ( CAI_BehaviorBase * pBehavior ) ;
bool BehaviorSelectSchedule ( ) ;
virtual bool ShouldBehaviorSelectSchedule ( CAI_BehaviorBase * pBehavior ) { return true ; }
bool IsRunningBehavior ( ) const ;
CAI_BehaviorBase * GetRunningBehavior ( ) ;
CAI_BehaviorBase * DeferSchedulingToBehavior ( CAI_BehaviorBase * pNewBehavior ) ;
void ChangeBehaviorTo ( CAI_BehaviorBase * pNewBehavior ) ;
CAI_Schedule * GetNewSchedule ( ) ;
CAI_Schedule * GetFailSchedule ( ) ;
private :
void BackBridge_GatherConditions ( ) ;
int BackBridge_SelectSchedule ( ) ;
int BackBridge_TranslateSchedule ( int scheduleType ) ;
Activity BackBridge_NPC_TranslateActivity ( Activity activity ) ;
bool BackBridge_IsValidEnemy ( CBaseEntity * pEnemy ) ;
CBaseEntity * BackBridge_BestEnemy ( void ) ;
bool BackBridge_IsValidCover ( const Vector & vLocation , CAI_Hint const * pHint ) ;
bool BackBridge_IsValidShootPosition ( const Vector & vLocation , CAI_Node * pNode , CAI_Hint const * pHint ) ;
float BackBridge_GetMaxTacticalLateralMovement ( void ) ;
bool BackBridge_ShouldIgnoreSound ( CSound * pSound ) ;
bool BackBridge_IsInterruptable ( void ) ;
bool BackBridge_ShouldPlayerAvoid ( void ) ;
int BackBridge_OnTakeDamage_Alive ( const CTakeDamageInfo & info ) ;
float BackBridge_GetDefaultNavGoalTolerance ( ) ;
float BackBridge_GetReasonableFacingDist ( void ) ;
bool BackBridge_CanFlinch ( void ) ;
bool BackBridge_IsCrouching ( void ) ;
bool BackBridge_IsCrouchedActivity ( Activity activity ) ;
bool BackBridge_QueryHearSound ( CSound * pSound ) ;
bool BackBridge_CanRunAScriptedNPCInteraction ( bool bForced ) ;
Activity BackBridge_GetFlinchActivity ( bool bHeavyDamage , bool bGesture ) ;
bool BackBridge_OnCalcBaseMove ( AILocalMoveGoal_t * pMoveGoal , float distClear , AIMoveResult_t * pResult ) ;
CAI_BehaviorBase * * AccessBehaviors ( ) ;
int NumBehaviors ( ) ;
CAI_BehaviorBase * m_pCurBehavior ;
CUtlVector < CAI_BehaviorBase * > m_Behaviors ;
bool m_bCalledBehaviorSelectSchedule ;
# ifdef DEBUG
bool m_fDebugInCreateBehaviors ;
# endif
} ;
//-----------------------------------------------------------------------------
// The first frame a behavior begins schedule selection, it won't have had it's GatherConditions()
// called. To fix this, BeginScheduleSelection() manually calls the new behavior's GatherConditions(),
// but sets this global so that the baseclass GatherConditions() isn't called as well.
extern bool g_bBehaviorHost_PreventBaseClassGatherConditions ;
//-----------------------------------------------------------------------------
inline void CAI_BehaviorBase : : BridgeOnStartSchedule ( int scheduleType )
{
int localId = AI_IdIsGlobal ( scheduleType ) ? GetClassScheduleIdSpace ( ) - > ScheduleGlobalToLocal ( scheduleType ) : scheduleType ;
OnStartSchedule ( localId ) ;
}
//-------------------------------------
inline int CAI_BehaviorBase : : BridgeSelectSchedule ( )
{
int result = SelectSchedule ( ) ;
if ( IsBehaviorSchedule ( result ) )
return GetClassScheduleIdSpace ( ) - > ScheduleLocalToGlobal ( result ) ;
return result ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeSelectFailSchedule ( int failedSchedule , int failedTask , AI_TaskFailureCode_t taskFailCode , int * pResult )
{
m_fOverrode = true ;
int result = SelectFailSchedule ( failedSchedule , failedTask , taskFailCode ) ;
if ( m_fOverrode )
{
if ( result ! = SCHED_NONE )
{
if ( IsBehaviorSchedule ( result ) )
* pResult = GetClassScheduleIdSpace ( ) - > ScheduleLocalToGlobal ( result ) ;
else
* pResult = result ;
return true ;
}
Warning ( " An AI behavior is in control but has no recommended schedule \n " ) ;
}
return false ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeStartTask ( const Task_t * pTask )
{
m_fOverrode = true ;
StartTask ( pTask ) ;
return m_fOverrode ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeRunTask ( const Task_t * pTask )
{
m_fOverrode = true ;
RunTask ( pTask ) ;
return m_fOverrode ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeAimGun ( void )
{
m_fOverrode = true ;
AimGun ( ) ;
return m_fOverrode ;
}
//-------------------------------------
inline void CAI_BehaviorBase : : ChainStartTask ( int task , float taskData )
{
Task_t tempTask = { task , taskData } ;
bool fPrevOverride = m_fOverrode ;
GetOuter ( ) - > StartTask ( ( const Task_t * ) & tempTask ) ;
m_fOverrode = fPrevOverride ; ;
}
//-------------------------------------
inline void CAI_BehaviorBase : : ChainRunTask ( int task , float taskData )
{
Task_t tempTask = { task , taskData } ;
bool fPrevOverride = m_fOverrode ;
GetOuter ( ) - > RunTask ( ( const Task_t * ) & tempTask ) ;
m_fOverrode = fPrevOverride ; ;
}
//-------------------------------------
inline int CAI_BehaviorBase : : BridgeTranslateSchedule ( int scheduleType )
{
int localId = AI_IdIsGlobal ( scheduleType ) ? GetClassScheduleIdSpace ( ) - > ScheduleGlobalToLocal ( scheduleType ) : scheduleType ;
int result = TranslateSchedule ( localId ) ;
return result ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeGetSchedule ( int localScheduleID , CAI_Schedule * * ppResult )
{
* ppResult = GetSchedule ( localScheduleID ) ;
return ( * ppResult ! = NULL ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeTaskName ( int taskID , const char * * ppResult )
{
if ( AI_IdIsLocal ( taskID ) )
{
* ppResult = GetSchedulingSymbols ( ) - > TaskIdToSymbol ( GetClassScheduleIdSpace ( ) - > TaskLocalToGlobal ( taskID ) ) ;
return ( * ppResult ! = NULL ) ;
}
return false ;
}
//-------------------------------------
inline Activity CAI_BehaviorBase : : BridgeNPC_TranslateActivity ( Activity activity )
{
return NPC_TranslateActivity ( activity ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeIsCurTaskContinuousMove ( bool * pResult )
{
bool fPrevOverride = m_fOverrode ;
m_fOverrode = true ;
* pResult = IsCurTaskContinuousMove ( ) ;
bool result = m_fOverrode ;
m_fOverrode = fPrevOverride ;
return result ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeFValidateHintType ( CAI_Hint * pHint , bool * pResult )
{
bool fPrevOverride = m_fOverrode ;
m_fOverrode = true ;
* pResult = FValidateHintType ( pHint ) ;
bool result = m_fOverrode ;
m_fOverrode = fPrevOverride ;
return result ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeIsValidEnemy ( CBaseEntity * pEnemy )
{
return IsValidEnemy ( pEnemy ) ;
}
//-------------------------------------
inline CBaseEntity * CAI_BehaviorBase : : BridgeBestEnemy ( )
{
return BestEnemy ( ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeIsValidCover ( const Vector & vLocation , CAI_Hint const * pHint )
{
return IsValidCover ( vLocation , pHint ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeIsValidShootPosition ( const Vector & vLocation , CAI_Node * pNode , CAI_Hint const * pHint )
{
return IsValidShootPosition ( vLocation , pNode , pHint ) ;
}
//-------------------------------------
inline float CAI_BehaviorBase : : BridgeGetMaxTacticalLateralMovement ( void )
{
return GetMaxTacticalLateralMovement ( ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeShouldIgnoreSound ( CSound * pSound )
{
return ShouldIgnoreSound ( pSound ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeIsInterruptable ( void )
{
return IsInterruptable ( ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeCanFlinch ( void )
{
return CanFlinch ( ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeIsCrouching ( void )
{
return IsCrouching ( ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeIsCrouchedActivity ( Activity activity )
{
return IsCrouchedActivity ( activity ) ;
}
inline bool CAI_BehaviorBase : : BridgeQueryHearSound ( CSound * pSound )
{
return QueryHearSound ( pSound ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeCanRunAScriptedNPCInteraction ( bool bForced )
{
return CanRunAScriptedNPCInteraction ( bForced ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeShouldPlayerAvoid ( void )
{
return ShouldPlayerAvoid ( ) ;
}
//-------------------------------------
inline int CAI_BehaviorBase : : BridgeOnTakeDamage_Alive ( const CTakeDamageInfo & info )
{
return OnTakeDamage_Alive ( info ) ;
}
//-------------------------------------
inline float CAI_BehaviorBase : : BridgeGetReasonableFacingDist ( void )
{
return GetReasonableFacingDist ( ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeShouldAlwaysThink ( bool * pResult )
{
bool fPrevOverride = m_fOverrode ;
m_fOverrode = true ;
* pResult = ShouldAlwaysThink ( ) ;
bool result = m_fOverrode ;
m_fOverrode = fPrevOverride ;
return result ;
}
//-------------------------------------
inline void CAI_BehaviorBase : : BridgeOnChangeActiveWeapon ( CBaseCombatWeapon * pOldWeapon , CBaseCombatWeapon * pNewWeapon )
{
OnChangeActiveWeapon ( pOldWeapon , pNewWeapon ) ;
}
//-------------------------------------
inline bool CAI_BehaviorBase : : BridgeSpeakMapmakerInterruptConcept ( string_t iszConcept )
{
return SpeakMapmakerInterruptConcept ( iszConcept ) ;
}
//-------------------------------------
inline void CAI_BehaviorBase : : BridgeOnRestore ( )
{
OnRestore ( ) ;
}
//-------------------------------------
inline float CAI_BehaviorBase : : BridgeGetDefaultNavGoalTolerance ( )
{
return GetDefaultNavGoalTolerance ( ) ;
}
//-----------------------------------------------------------------------------
inline Activity CAI_BehaviorBase : : BridgeGetFlinchActivity ( bool bHeavyDamage , bool bGesture )
{
return GetFlinchActivity ( bHeavyDamage , bGesture ) ;
}
//-----------------------------------------------------------------------------
inline bool CAI_BehaviorBase : : BridgeOnCalcBaseMove ( AILocalMoveGoal_t * pMoveGoal , float distClear , AIMoveResult_t * pResult )
{
return OnCalcBaseMove ( pMoveGoal , distClear , pResult ) ;
}
//-----------------------------------------------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : CleanupOnDeath ( CBaseEntity * pCulprit , bool bFireDeathOutput )
{
DeferSchedulingToBehavior ( NULL ) ;
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
m_Behaviors [ i ] - > BridgeCleanupOnDeath ( pCulprit , bFireDeathOutput ) ;
}
BaseClass : : CleanupOnDeath ( pCulprit , bFireDeathOutput ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : GatherConditions ( )
{
// Iterate over behaviors and call GatherConditionsNotActive() on each behavior
// not currently active.
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
if ( m_Behaviors [ i ] ! = m_pCurBehavior )
{
m_Behaviors [ i ] - > GatherConditionsNotActive ( ) ;
}
}
if ( m_pCurBehavior )
m_pCurBehavior - > BridgeGatherConditions ( ) ;
else
BaseClass : : GatherConditions ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : BackBridge_GatherConditions ( )
{
if ( g_bBehaviorHost_PreventBaseClassGatherConditions )
return ;
BaseClass : : GatherConditions ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : OnScheduleChange ( )
{
if ( m_pCurBehavior )
m_pCurBehavior - > BridgeOnScheduleChange ( ) ;
BaseClass : : OnScheduleChange ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : OnStartSchedule ( int scheduleType )
{
if ( m_pCurBehavior )
m_pCurBehavior - > BridgeOnStartSchedule ( scheduleType ) ;
BaseClass : : OnStartSchedule ( scheduleType ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline int CAI_BehaviorHost < BASE_NPC > : : BackBridge_SelectSchedule ( )
{
return BaseClass : : SelectSchedule ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BehaviorSelectSchedule ( )
{
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
if ( m_Behaviors [ i ] - > CanSelectSchedule ( ) & & ShouldBehaviorSelectSchedule ( m_Behaviors [ i ] ) )
{
DeferSchedulingToBehavior ( m_Behaviors [ i ] ) ;
return true ;
}
}
DeferSchedulingToBehavior ( NULL ) ;
return false ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : IsRunningBehavior ( ) const
{
return ( m_pCurBehavior ! = NULL ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline CAI_BehaviorBase * CAI_BehaviorHost < BASE_NPC > : : GetRunningBehavior ( )
{
return m_pCurBehavior ;
}
//-------------------------------------
template < class BASE_NPC >
inline CAI_Schedule * CAI_BehaviorHost < BASE_NPC > : : GetNewSchedule ( )
{
m_bCalledBehaviorSelectSchedule = false ;
CAI_Schedule * pResult = BaseClass : : GetNewSchedule ( ) ;
if ( ! m_bCalledBehaviorSelectSchedule & & m_pCurBehavior )
DeferSchedulingToBehavior ( NULL ) ;
return pResult ;
}
//-------------------------------------
template < class BASE_NPC >
inline CAI_Schedule * CAI_BehaviorHost < BASE_NPC > : : GetFailSchedule ( )
{
m_bCalledBehaviorSelectSchedule = false ;
CAI_Schedule * pResult = BaseClass : : GetFailSchedule ( ) ;
if ( ! m_bCalledBehaviorSelectSchedule & & m_pCurBehavior )
DeferSchedulingToBehavior ( NULL ) ;
return pResult ;
}
//------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : ChangeBehaviorTo ( CAI_BehaviorBase * pNewBehavior )
{
bool change = ( m_pCurBehavior ! = pNewBehavior ) ;
CAI_BehaviorBase * pOldBehavior = m_pCurBehavior ;
m_pCurBehavior = pNewBehavior ;
if ( change )
{
if ( m_pCurBehavior )
{
m_pCurBehavior - > BeginScheduleSelection ( ) ;
g_bBehaviorHost_PreventBaseClassGatherConditions = true ;
m_pCurBehavior - > GatherConditions ( ) ;
g_bBehaviorHost_PreventBaseClassGatherConditions = false ;
}
if ( pOldBehavior )
{
pOldBehavior - > EndScheduleSelection ( ) ;
2008-09-15 01:33:59 -05:00
this - > VacateStrategySlot ( ) ;
2008-09-15 01:00:17 -05:00
}
OnChangeRunningBehavior ( pOldBehavior , pNewBehavior ) ;
}
}
//-------------------------------------
template < class BASE_NPC >
inline CAI_BehaviorBase * CAI_BehaviorHost < BASE_NPC > : : DeferSchedulingToBehavior ( CAI_BehaviorBase * pNewBehavior )
{
CAI_BehaviorBase * pOldBehavior = m_pCurBehavior ;
ChangeBehaviorTo ( pNewBehavior ) ;
return pOldBehavior ;
}
//-------------------------------------
template < class BASE_NPC >
inline int CAI_BehaviorHost < BASE_NPC > : : BackBridge_TranslateSchedule ( int scheduleType )
{
return BaseClass : : TranslateSchedule ( scheduleType ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline int CAI_BehaviorHost < BASE_NPC > : : TranslateSchedule ( int scheduleType )
{
if ( m_pCurBehavior )
{
return m_pCurBehavior - > BridgeTranslateSchedule ( scheduleType ) ;
}
return BaseClass : : TranslateSchedule ( scheduleType ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : PrescheduleThink ( )
{
BaseClass : : PrescheduleThink ( ) ;
if ( m_pCurBehavior )
m_pCurBehavior - > BridgePrescheduleThink ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline int CAI_BehaviorHost < BASE_NPC > : : SelectSchedule ( )
{
m_bCalledBehaviorSelectSchedule = true ;
if ( m_pCurBehavior )
{
return m_pCurBehavior - > BridgeSelectSchedule ( ) ;
}
return BaseClass : : SelectSchedule ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : KeepRunningBehavior ( )
{
if ( m_pCurBehavior )
m_bCalledBehaviorSelectSchedule = true ;
}
//-------------------------------------
template < class BASE_NPC >
inline int CAI_BehaviorHost < BASE_NPC > : : SelectFailSchedule ( int failedSchedule , int failedTask , AI_TaskFailureCode_t taskFailCode )
{
m_bCalledBehaviorSelectSchedule = true ;
int result = 0 ;
if ( m_pCurBehavior & & m_pCurBehavior - > BridgeSelectFailSchedule ( failedSchedule , failedTask , taskFailCode , & result ) )
return result ;
return BaseClass : : SelectFailSchedule ( failedSchedule , failedTask , taskFailCode ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : StartTask ( const Task_t * pTask )
{
if ( m_pCurBehavior & & m_pCurBehavior - > BridgeStartTask ( pTask ) )
return ;
BaseClass : : StartTask ( pTask ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : RunTask ( const Task_t * pTask )
{
if ( m_pCurBehavior & & m_pCurBehavior - > BridgeRunTask ( pTask ) )
return ;
BaseClass : : RunTask ( pTask ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : AimGun ( void )
{
if ( m_pCurBehavior & & m_pCurBehavior - > BridgeAimGun ( ) )
return ;
BaseClass : : AimGun ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline CAI_Schedule * CAI_BehaviorHost < BASE_NPC > : : GetSchedule ( int localScheduleID )
{
CAI_Schedule * pResult ;
if ( m_pCurBehavior & & m_pCurBehavior - > BridgeGetSchedule ( localScheduleID , & pResult ) )
return pResult ;
return BaseClass : : GetSchedule ( localScheduleID ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline const char * CAI_BehaviorHost < BASE_NPC > : : TaskName ( int taskID )
{
const char * pszResult = NULL ;
if ( m_pCurBehavior & & m_pCurBehavior - > BridgeTaskName ( taskID , & pszResult ) )
return pszResult ;
return BaseClass : : TaskName ( taskID ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : BuildScheduleTestBits ( )
{
if ( m_pCurBehavior )
m_pCurBehavior - > BridgeBuildScheduleTestBits ( ) ;
BaseClass : : BuildScheduleTestBits ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : OnChangeHintGroup ( string_t oldGroup , string_t newGroup )
{
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
m_Behaviors [ i ] - > BridgeOnChangeHintGroup ( oldGroup , newGroup ) ;
}
BaseClass : : OnChangeHintGroup ( oldGroup , newGroup ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline Activity CAI_BehaviorHost < BASE_NPC > : : BackBridge_NPC_TranslateActivity ( Activity activity )
{
return BaseClass : : NPC_TranslateActivity ( activity ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline Activity CAI_BehaviorHost < BASE_NPC > : : NPC_TranslateActivity ( Activity activity )
{
if ( m_pCurBehavior )
{
return m_pCurBehavior - > BridgeNPC_TranslateActivity ( activity ) ;
}
return BaseClass : : NPC_TranslateActivity ( activity ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : IsCurTaskContinuousMove ( )
{
bool result = false ;
if ( m_pCurBehavior & & m_pCurBehavior - > BridgeIsCurTaskContinuousMove ( & result ) )
return result ;
return BaseClass : : IsCurTaskContinuousMove ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : OnMovementFailed ( )
{
if ( m_pCurBehavior )
m_pCurBehavior - > BridgeOnMovementFailed ( ) ;
BaseClass : : OnMovementFailed ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : OnMovementComplete ( )
{
if ( m_pCurBehavior )
m_pCurBehavior - > BridgeOnMovementComplete ( ) ;
BaseClass : : OnMovementComplete ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline float CAI_BehaviorHost < BASE_NPC > : : GetDefaultNavGoalTolerance ( )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeGetDefaultNavGoalTolerance ( ) ;
return BaseClass : : GetDefaultNavGoalTolerance ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline float CAI_BehaviorHost < BASE_NPC > : : BackBridge_GetDefaultNavGoalTolerance ( )
{
return BaseClass : : GetDefaultNavGoalTolerance ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : FValidateHintType ( CAI_Hint * pHint )
{
bool result = false ;
if ( m_pCurBehavior & & m_pCurBehavior - > BridgeFValidateHintType ( pHint , & result ) )
return result ;
return BaseClass : : FValidateHintType ( pHint ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_IsValidEnemy ( CBaseEntity * pEnemy )
{
return BaseClass : : IsValidEnemy ( pEnemy ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline CBaseEntity * CAI_BehaviorHost < BASE_NPC > : : BackBridge_BestEnemy ( void )
{
return BaseClass : : BestEnemy ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_IsValidCover ( const Vector & vLocation , CAI_Hint const * pHint )
{
return BaseClass : : IsValidCover ( vLocation , pHint ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_IsValidShootPosition ( const Vector & vLocation , CAI_Node * pNode , CAI_Hint const * pHint )
{
return BaseClass : : IsValidShootPosition ( vLocation , pNode , pHint ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline float CAI_BehaviorHost < BASE_NPC > : : BackBridge_GetMaxTacticalLateralMovement ( void )
{
return BaseClass : : GetMaxTacticalLateralMovement ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_ShouldIgnoreSound ( CSound * pSound )
{
return BaseClass : : ShouldIgnoreSound ( pSound ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_IsInterruptable ( void )
{
return BaseClass : : IsInterruptable ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_CanFlinch ( void )
{
return BaseClass : : CanFlinch ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_IsCrouching ( void )
{
return BaseClass : : IsCrouching ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_IsCrouchedActivity ( Activity activity )
{
return BaseClass : : IsCrouchedActivity ( activity ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_QueryHearSound ( CSound * pSound )
{
return BaseClass : : QueryHearSound ( pSound ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_CanRunAScriptedNPCInteraction ( bool bForced )
{
return BaseClass : : CanRunAScriptedNPCInteraction ( bForced ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_ShouldPlayerAvoid ( void )
{
return BaseClass : : ShouldPlayerAvoid ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline int CAI_BehaviorHost < BASE_NPC > : : BackBridge_OnTakeDamage_Alive ( const CTakeDamageInfo & info )
{
return BaseClass : : OnTakeDamage_Alive ( info ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline float CAI_BehaviorHost < BASE_NPC > : : BackBridge_GetReasonableFacingDist ( void )
{
return BaseClass : : GetReasonableFacingDist ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline Activity CAI_BehaviorHost < BASE_NPC > : : BackBridge_GetFlinchActivity ( bool bHeavyDamage , bool bGesture )
{
return BaseClass : : GetFlinchActivity ( bHeavyDamage , bGesture ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : BackBridge_OnCalcBaseMove ( AILocalMoveGoal_t * pMoveGoal , float distClear , AIMoveResult_t * pResult )
{
return BaseClass : : OnCalcBaseMove ( pMoveGoal , distClear , pResult ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : IsValidEnemy ( CBaseEntity * pEnemy )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeIsValidEnemy ( pEnemy ) ;
return BaseClass : : IsValidEnemy ( pEnemy ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline CBaseEntity * CAI_BehaviorHost < BASE_NPC > : : BestEnemy ( )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeBestEnemy ( ) ;
return BaseClass : : BestEnemy ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : ShouldAlwaysThink ( )
{
bool result = false ;
if ( m_pCurBehavior & & m_pCurBehavior - > BridgeShouldAlwaysThink ( & result ) )
return result ;
return BaseClass : : ShouldAlwaysThink ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : OnChangeActiveWeapon ( CBaseCombatWeapon * pOldWeapon , CBaseCombatWeapon * pNewWeapon )
{
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
m_Behaviors [ i ] - > BridgeOnChangeActiveWeapon ( pOldWeapon , pNewWeapon ) ;
}
BaseClass : : OnChangeActiveWeapon ( pOldWeapon , pNewWeapon ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : SpeakMapmakerInterruptConcept ( string_t iszConcept )
{
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
if ( m_Behaviors [ i ] - > BridgeSpeakMapmakerInterruptConcept ( iszConcept ) )
return true ;
}
return false ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : OnRestore ( )
{
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
m_Behaviors [ i ] - > BridgeOnRestore ( ) ;
}
BaseClass : : OnRestore ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : IsValidCover ( const Vector & vLocation , CAI_Hint const * pHint )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeIsValidCover ( vLocation , pHint ) ;
return BaseClass : : IsValidCover ( vLocation , pHint ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : IsValidShootPosition ( const Vector & vLocation , CAI_Node * pNode , CAI_Hint const * pHint )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeIsValidShootPosition ( vLocation , pNode , pHint ) ;
return BaseClass : : IsValidShootPosition ( vLocation , pNode , pHint ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline float CAI_BehaviorHost < BASE_NPC > : : GetMaxTacticalLateralMovement ( void )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeGetMaxTacticalLateralMovement ( ) ;
return BaseClass : : GetMaxTacticalLateralMovement ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : ShouldIgnoreSound ( CSound * pSound )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeShouldIgnoreSound ( pSound ) ;
return BaseClass : : ShouldIgnoreSound ( pSound ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : IsInterruptable ( void )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeIsInterruptable ( ) ;
return BaseClass : : IsInterruptable ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : CanFlinch ( void )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeCanFlinch ( ) ;
return BaseClass : : CanFlinch ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : IsCrouching ( void )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeIsCrouching ( ) ;
return BaseClass : : IsCrouching ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : IsCrouchedActivity ( Activity activity )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeIsCrouchedActivity ( activity ) ;
return BaseClass : : IsCrouchedActivity ( activity ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : QueryHearSound ( CSound * pSound )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeQueryHearSound ( pSound ) ;
return BaseClass : : QueryHearSound ( pSound ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : CanRunAScriptedNPCInteraction ( bool bForced )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeCanRunAScriptedNPCInteraction ( bForced ) ;
return BaseClass : : CanRunAScriptedNPCInteraction ( bForced ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : ShouldPlayerAvoid ( void )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeShouldPlayerAvoid ( ) ;
return BaseClass : : ShouldPlayerAvoid ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline int CAI_BehaviorHost < BASE_NPC > : : OnTakeDamage_Alive ( const CTakeDamageInfo & info )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeOnTakeDamage_Alive ( info ) ;
return BaseClass : : OnTakeDamage_Alive ( info ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline float CAI_BehaviorHost < BASE_NPC > : : GetReasonableFacingDist ( void )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeGetReasonableFacingDist ( ) ;
return BaseClass : : GetReasonableFacingDist ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : Precache ( )
{
BaseClass : : Precache ( ) ;
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
m_Behaviors [ i ] - > BridgePrecache ( ) ;
}
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : ScheduledMoveToGoalEntity ( int scheduleType , CBaseEntity * pGoalEntity , Activity movementActivity )
{
// If a behavior is active, we need to stop running it
ChangeBehaviorTo ( NULL ) ;
return BaseClass : : ScheduledMoveToGoalEntity ( scheduleType , pGoalEntity , movementActivity ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : ScheduledFollowPath ( int scheduleType , CBaseEntity * pPathStart , Activity movementActivity )
{
// If a behavior is active, we need to stop running it
ChangeBehaviorTo ( NULL ) ;
return BaseClass : : ScheduledFollowPath ( scheduleType , pPathStart , movementActivity ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : ForceSelectedGo ( CBaseEntity * pPlayer , const Vector & targetPos , const Vector & traceDir , bool bRun )
{
// If a behavior is active, we need to stop running it
ChangeBehaviorTo ( NULL ) ;
BaseClass : : ForceSelectedGo ( pPlayer , targetPos , traceDir , bRun ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : ForceSelectedGoRandom ( void )
{
// If a behavior is active, we need to stop running it
ChangeBehaviorTo ( NULL ) ;
BaseClass : : ForceSelectedGoRandom ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : NPCInit ( )
{
BaseClass : : NPCInit ( ) ;
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
m_Behaviors [ i ] - > BridgeSpawn ( ) ;
}
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : UpdateOnRemove ( )
{
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
m_Behaviors [ i ] - > BridgeUpdateOnRemove ( ) ;
}
BaseClass : : UpdateOnRemove ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : Event_Killed ( const CTakeDamageInfo & info )
{
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
m_Behaviors [ i ] - > BridgeEvent_Killed ( info ) ;
}
BaseClass : : Event_Killed ( info ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline Activity CAI_BehaviorHost < BASE_NPC > : : GetFlinchActivity ( bool bHeavyDamage , bool bGesture )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeGetFlinchActivity ( bHeavyDamage , bGesture ) ;
return BaseClass : : GetFlinchActivity ( bHeavyDamage , bGesture ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : OnCalcBaseMove ( AILocalMoveGoal_t * pMoveGoal , float distClear , AIMoveResult_t * pResult )
{
if ( m_pCurBehavior )
return m_pCurBehavior - > BridgeOnCalcBaseMove ( pMoveGoal , distClear , pResult ) ;
return BaseClass : : OnCalcBaseMove ( pMoveGoal , distClear , pResult ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : OnBehaviorChangeStatus ( CAI_BehaviorBase * pBehavior , bool fCanFinishSchedule )
{
if ( pBehavior = = GetRunningBehavior ( ) & & ! pBehavior - > CanSelectSchedule ( ) & & ! fCanFinishSchedule )
{
DeferSchedulingToBehavior ( NULL ) ;
return true ;
}
return false ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : OnChangeRunningBehavior ( CAI_BehaviorBase * pOldBehavior , CAI_BehaviorBase * pNewBehavior )
{
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : AddBehavior ( CAI_BehaviorBase * pBehavior )
{
# ifdef DEBUG
Assert ( m_Behaviors . Find ( pBehavior ) = = m_Behaviors . InvalidIndex ( ) ) ;
Assert ( m_fDebugInCreateBehaviors ) ;
for ( int i = 0 ; i < m_Behaviors . Count ( ) ; i + + )
{
Assert ( typeid ( * m_Behaviors [ i ] ) ! = typeid ( * pBehavior ) ) ;
}
# endif
m_Behaviors . AddToTail ( pBehavior ) ;
pBehavior - > SetOuter ( this ) ;
pBehavior - > SetBackBridge ( this ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline CAI_BehaviorBase * * CAI_BehaviorHost < BASE_NPC > : : AccessBehaviors ( )
{
if ( m_Behaviors . Count ( ) )
return m_Behaviors . Base ( ) ;
return NULL ;
}
//-------------------------------------
template < class BASE_NPC >
inline int CAI_BehaviorHost < BASE_NPC > : : NumBehaviors ( )
{
return m_Behaviors . Count ( ) ;
}
//-------------------------------------
template < class BASE_NPC >
inline int CAI_BehaviorHost < BASE_NPC > : : Save ( ISave & save )
{
int result = BaseClass : : Save ( save ) ;
if ( result )
CAI_BehaviorBase : : SaveBehaviors ( save , m_pCurBehavior , AccessBehaviors ( ) , NumBehaviors ( ) ) ;
return result ;
}
//-------------------------------------
template < class BASE_NPC >
inline int CAI_BehaviorHost < BASE_NPC > : : Restore ( IRestore & restore )
{
int result = BaseClass : : Restore ( restore ) ;
if ( result )
{
int iCurrent = CAI_BehaviorBase : : RestoreBehaviors ( restore , AccessBehaviors ( ) , NumBehaviors ( ) ) ;
if ( iCurrent ! = - 1 )
m_pCurBehavior = AccessBehaviors ( ) [ iCurrent ] ;
else
m_pCurBehavior = NULL ;
}
return result ;
}
//-------------------------------------
template < class BASE_NPC >
inline bool CAI_BehaviorHost < BASE_NPC > : : CreateComponents ( )
{
if ( BaseClass : : CreateComponents ( ) )
{
# ifdef DEBUG
m_fDebugInCreateBehaviors = true ;
# endif
bool result = CreateBehaviors ( ) ;
# ifdef DEBUG
m_fDebugInCreateBehaviors = false ;
# endif
return result ;
}
return false ;
}
//-------------------------------------
template < class BASE_NPC >
inline void CAI_BehaviorHost < BASE_NPC > : : ModifyOrAppendCriteria ( AI_CriteriaSet & set )
{
BaseClass : : ModifyOrAppendCriteria ( set ) ;
// Append active behavior name
if ( GetRunningBehavior ( ) )
{
set . AppendCriteria ( " active_behavior " , GetRunningBehavior ( ) - > GetName ( ) ) ;
}
}
//-----------------------------------------------------------------------------
# endif // AI_BEHAVIOR_H