First version of the SOurce SDK 2013

1 files changed, 318 insertions, 0 deletions

diff --git a/mp/src/game/server/hl2/ai_behavior_actbusy.h b/mp/src/game/server/hl2/ai_behavior_actbusy.h
new file mode 100644
index 00000000..bfb5c17a
--- /dev/null
+++ b/mp/src/game/server/hl2/ai_behavior_actbusy.h
@@ -0,0 +1,318 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//

+//

+// Purpose: 

+//

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

+

+#ifndef AI_BEHAVIOR_ACTBUSY_H

+#define AI_BEHAVIOR_ACTBUSY_H

+#ifdef _WIN32

+#pragma once

+#endif

+

+#include "ai_behavior.h"

+#include "ai_goalentity.h"

+

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

+enum

+{

+	ACTBUSY_TYPE_DEFAULT = 0,

+	ACTBUSY_TYPE_COMBAT,

+};

+

+enum busyinterrupt_t

+{

+	BA_INT_NONE,		// Nothing breaks us out of this

+	BA_INT_DANGER,		// Only danger signals interrupts this busy anim. The player will be ignored.

+	BA_INT_PLAYER,		// The Player's presence interrupts this busy anim

+	BA_INT_AMBUSH,		// We're waiting to ambush enemies. Don't break on danger sounds in front of us.

+	BA_INT_COMBAT,		// Only break out if we're shot at.

+	BA_INT_ZOMBIESLUMP,	// Zombies who are slumped on the ground.

+	BA_INT_SIEGE_DEFENSE,

+};

+

+enum busyanimparts_t

+{

+	BA_BUSY,

+	BA_ENTRY,

+	BA_EXIT,

+

+	BA_MAX_ANIMS,

+};

+

+struct busyanim_t

+{

+	string_t			iszName;

+	Activity			iActivities[BA_MAX_ANIMS];

+	string_t			iszSequences[BA_MAX_ANIMS];

+	string_t			iszSounds[BA_MAX_ANIMS];

+	float				flMinTime;		// Min time spent in this busy animation

+	float				flMaxTime;		// Max time spent in this busy animation. 0 means continue until interrupted.

+	busyinterrupt_t		iBusyInterruptType;

+	bool				bUseAutomovement;

+};

+

+struct busysafezone_t

+{

+	Vector	vecMins;

+	Vector	vecMaxs;

+};

+

+#define NO_MAX_TIME -1

+

+class CAI_ActBusyGoal;

+

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

+// Purpose: 

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

+class CAI_ActBusyBehavior : public CAI_SimpleBehavior

+{

+	DECLARE_CLASS( CAI_ActBusyBehavior, CAI_SimpleBehavior );

+public:

+	DECLARE_DATADESC();

+	CAI_ActBusyBehavior();

+

+	enum

+	{

+		// Schedules

+		SCHED_ACTBUSY_START_BUSYING = BaseClass::NEXT_SCHEDULE,

+		SCHED_ACTBUSY_BUSY,

+		SCHED_ACTBUSY_STOP_BUSYING,

+		SCHED_ACTBUSY_LEAVE,

+		SCHED_ACTBUSY_TELEPORT_TO_BUSY,

+		NEXT_SCHEDULE,

+		

+		// Tasks

+		TASK_ACTBUSY_PLAY_BUSY_ANIM = BaseClass::NEXT_TASK,

+		TASK_ACTBUSY_PLAY_ENTRY,

+		TASK_ACTBUSY_PLAY_EXIT,

+		TASK_ACTBUSY_TELEPORT_TO_BUSY,

+		TASK_ACTBUSY_WALK_PATH_TO_BUSY,

+		TASK_ACTBUSY_GET_PATH_TO_ACTBUSY,

+		TASK_ACTBUSY_VERIFY_EXIT,

+		NEXT_TASK,

+		

+		// Conditions

+		COND_ACTBUSY_LOST_SEE_ENTITY = BaseClass::NEXT_CONDITION,

+		COND_ACTBUSY_AWARE_OF_ENEMY_IN_SAFE_ZONE,

+		COND_ACTBUSY_ENEMY_TOO_CLOSE,

+		NEXT_CONDITION,

+	};

+	

+	virtual const char *GetName() {	return "ActBusy"; }

+

+	void	Enable( CAI_ActBusyGoal *pGoal, float flRange, bool bVisibleOnly );

+	void	OnRestore();

+	void	SetBusySearchRange( float flRange );

+	void	Disable( void );

+	void	ForceActBusy( CAI_ActBusyGoal *pGoal, CAI_Hint *pHintNode = NULL, float flMaxTime = NO_MAX_TIME, bool bVisibleOnly = false, bool bTeleportToBusy = false, bool bUseNearestBusy = false, CBaseEntity *pSeeEntity = NULL, Activity activity = ACT_INVALID );

+	void	ForceActBusyLeave( bool bVisibleOnly = false );

+	void	StopBusying( void );

+	bool	IsStopBusying();

+	CAI_Hint *FindActBusyHintNode( void );

+	CAI_Hint *FindCombatActBusyHintNode( void );

+	CAI_Hint *FindCombatActBusyTeleportHintNode( void );

+	bool	CanSelectSchedule( void );

+	bool	IsCurScheduleOverridable( void );

+	bool	ShouldIgnoreSound( CSound *pSound );

+	void	OnFriendDamaged( CBaseCombatCharacter *pSquadmate, CBaseEntity *pAttacker );

+	int		OnTakeDamage_Alive( const CTakeDamageInfo &info );

+	void	GatherConditions( void );

+	void	BuildScheduleTestBits( void );

+	void	EndScheduleSelection( void );

+	Activity NPC_TranslateActivity( Activity nActivity );

+	void	HandleAnimEvent( animevent_t *pEvent );

+	void	CheckAndCleanupOnExit( void );

+	bool	FValidateHintType( CAI_Hint *pHint );

+	bool	ActBusyNodeStillActive( void );

+	bool	IsMovingToBusy( void ) { return m_bMovingToBusy; }

+	bool	IsEnabled( void ) { return m_bEnabled; }

+	float	GetReasonableFacingDist( void ) { return 0; }	// Actbusy ignores reasonable facing

+	bool	IsInterruptable( void );

+	bool	ShouldPlayerAvoid( void );

+	void	SetUseRenderBounds( bool bUseBounds ) { m_bUseRenderBoundsForCollision = bUseBounds; }

+	void	ComputeAndSetRenderBounds();

+	bool	CanFlinch( void );

+	bool	CanRunAScriptedNPCInteraction( bool bForced );

+	void	OnScheduleChange();

+	bool	QueryHearSound( CSound *pSound );

+	void	OnSeeEntity( CBaseEntity *pEntity );

+	bool	NeedsToPlayExitAnim() { return m_bNeedsToPlayExitAnim; }

+

+	// Returns true if the current NPC is acting busy, or moving to an actbusy

+	bool	IsActive( void );

+	// Returns true if the current NPC is actually acting busy (i.e. inside an act busy anim)

+	bool	IsInsideActBusy( void ) { return m_bBusy; }

+

+	// Combat act busy stuff

+	bool	IsCombatActBusy();

+	void 	CollectSafeZoneVolumes( CAI_ActBusyGoal *pActBusyGoal );

+	bool	IsInSafeZone( CBaseEntity *pEntity );

+	int		CountEnemiesInSafeZone();

+

+private:

+	virtual int		SelectSchedule( void );

+	int				SelectScheduleForLeaving( void );

+	int				SelectScheduleWhileNotBusy( int iBase );

+	int				SelectScheduleWhileBusy( void );

+	virtual void	StartTask( const Task_t *pTask );

+	virtual void	RunTask( const Task_t *pTask );

+	void			NotifyBusyEnding( void );

+	bool			HasAnimForActBusy( int iActBusy, busyanimparts_t AnimPart );

+	bool			PlayAnimForActBusy( busyanimparts_t AnimPart );

+	void			PlaySoundForActBusy( busyanimparts_t AnimPart ); 

+

+private:

+	bool			m_bEnabled;

+	bool			m_bForceActBusy;

+	Activity		m_ForcedActivity;

+	bool			m_bTeleportToBusy;

+	bool			m_bUseNearestBusy;

+	bool			m_bLeaving;

+	bool			m_bVisibleOnly;

+	bool			m_bUseRenderBoundsForCollision;

+	float			m_flForcedMaxTime;

+	bool			m_bBusy;

+	bool			m_bMovingToBusy;

+	bool			m_bNeedsToPlayExitAnim;

+	float			m_flNextBusySearchTime;	

+	float			m_flEndBusyAt;

+	float			m_flBusySearchRange;

+	bool			m_bInQueue;

+	int				m_iCurrentBusyAnim;

+	CHandle<CAI_ActBusyGoal> m_hActBusyGoal;

+	bool			m_bNeedToSetBounds;

+	EHANDLE			m_hSeeEntity;

+	float			m_fTimeLastSawSeeEntity;

+	bool			m_bExitedBusyToDueLostSeeEntity;

+	bool			m_bExitedBusyToDueSeeEnemy;

+

+	int				m_iNumConsecutivePathFailures; // Count how many times we failed to find a path to a node, so we can consider teleporting.

+	bool			m_bAutoFireWeapon;

+	float			m_flDeferUntil;

+	int				m_iNumEnemiesInSafeZone;

+

+	CUtlVector<busysafezone_t>m_SafeZones;

+

+	DEFINE_CUSTOM_SCHEDULE_PROVIDER;

+};

+

+

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

+// Purpose: A level tool to control the actbusy behavior.

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

+class CAI_ActBusyGoal : public CAI_GoalEntity

+{

+	DECLARE_CLASS( CAI_ActBusyGoal, CAI_GoalEntity );

+public:

+	CAI_ActBusyGoal()

+	{

+		// Support legacy maps, where this value used to be set from a constant (with a value of 1).

+		// Now designers can specify whatever they want in Hammer. Take care of old maps by setting

+		// this in the constructor. (sjb)

+		m_flSeeEntityTimeout = 1;

+	}

+

+	virtual void NPCMovingToBusy( CAI_BaseNPC *pNPC );

+	virtual void NPCAbortedMoveTo( CAI_BaseNPC *pNPC );

+	virtual void NPCStartedBusy( CAI_BaseNPC *pNPC );

+	virtual void NPCStartedLeavingBusy( CAI_BaseNPC *pNPC );

+	virtual void NPCFinishedBusy( CAI_BaseNPC *pNPC );

+	virtual void NPCLeft( CAI_BaseNPC *pNPC );

+	virtual void NPCLostSeeEntity( CAI_BaseNPC *pNPC );

+	virtual void NPCSeeEnemy( CAI_BaseNPC *pNPC );

+

+	int GetType() { return m_iType; }

+	bool IsCombatActBusyTeleportAllowed()	{ return m_bAllowCombatActBusyTeleport; }

+

+protected:

+	CAI_ActBusyBehavior *GetBusyBehaviorForNPC( const char *pszActorName, CBaseEntity *pActivator, CBaseEntity *pCaller, const char *sInputName );

+	CAI_ActBusyBehavior *GetBusyBehaviorForNPC( CBaseEntity *pEntity, const char *sInputName );

+

+	void		 EnableGoal( CAI_BaseNPC *pAI );

+

+	// Inputs

+	virtual void InputActivate( inputdata_t &inputdata );

+	virtual void InputDeactivate( inputdata_t &inputdata );

+	void		 InputSetBusySearchRange( inputdata_t &inputdata );

+	void		 InputForceNPCToActBusy( inputdata_t &inputdata );

+	void		 InputForceThisNPCToActBusy( inputdata_t &inputdata );

+	void		 InputForceThisNPCToLeave( inputdata_t &inputdata );

+

+	DECLARE_DATADESC();

+

+protected:

+	float			m_flBusySearchRange;

+	bool			m_bVisibleOnly;

+	int				m_iType;

+	bool			m_bAllowCombatActBusyTeleport;

+

+public:

+	// Let the actbusy behavior query these so we don't have to duplicate the data.

+	string_t		m_iszSeeEntityName;

+	float			m_flSeeEntityTimeout;

+	string_t		m_iszSafeZoneVolume;

+	int				m_iSightMethod;

+

+protected:

+	COutputEHANDLE	m_OnNPCStartedBusy;

+	COutputEHANDLE	m_OnNPCFinishedBusy;

+	COutputEHANDLE	m_OnNPCLeft;

+	COutputEHANDLE	m_OnNPCLostSeeEntity;

+	COutputEHANDLE	m_OnNPCSeeEnemy;

+};

+

+// Maximum number of nodes allowed in an actbusy queue

+#define MAX_QUEUE_NODES		20

+

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

+// Purpose: A level tool to control the actbusy behavior to create NPC queues 

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

+class CAI_ActBusyQueueGoal : public CAI_ActBusyGoal

+{

+	DECLARE_CLASS( CAI_ActBusyQueueGoal, CAI_ActBusyGoal );

+public:

+	virtual void Spawn( void );

+	virtual void DrawDebugGeometryOverlays( void );

+	virtual void NPCMovingToBusy( CAI_BaseNPC *pNPC );

+	virtual void NPCStartedBusy( CAI_BaseNPC *pNPC );

+	virtual void NPCAbortedMoveTo( CAI_BaseNPC *pNPC );

+	virtual void NPCFinishedBusy( CAI_BaseNPC *pNPC );

+	virtual void NPCStartedLeavingBusy( CAI_BaseNPC *pNPC );

+

+	virtual void InputActivate( inputdata_t &inputdata );

+	void		 InputPlayerStartedBlocking( inputdata_t &inputdata );

+	void		 InputPlayerStoppedBlocking( inputdata_t &inputdata );

+	void		 InputMoveQueueUp( inputdata_t &inputdata );

+

+	void		 PushNPCBackInQueue( CAI_BaseNPC *pNPC, int iStartingNode );

+	void		 RemoveNPCFromQueue( CAI_BaseNPC *pNPC );

+	void		 RecalculateQueueCount( void );

+	void		 QueueThink( void );

+  	void		 MoveQueueUp( void );

+  	void		 MoveQueueUpThink( void );

+	bool		 NodeIsOccupied( int i );

+	CAI_BaseNPC			*GetNPCOnNode( int iNode );

+	CAI_ActBusyBehavior *GetQueueBehaviorForNPC( CAI_BaseNPC	*pNPC );

+

+	DECLARE_DATADESC();

+

+private:

+	int						m_iCurrentQueueCount;

+	CHandle<CAI_Hint>		m_hNodes[ MAX_QUEUE_NODES ];

+	bool					m_bPlayerBlockedNodes[ MAX_QUEUE_NODES ];

+	EHANDLE					m_hExitNode;

+	EHANDLE					m_hExitingNPC;

+	bool					m_bForceReachFront;

+

+	// Read from mapdata

+	string_t		m_iszNodes[ MAX_QUEUE_NODES ];

+	string_t		m_iszExitNode;

+

+	// Outputs

+	COutputInt		m_OnQueueMoved;

+	COutputEHANDLE	m_OnNPCLeftQueue;

+	COutputEHANDLE	m_OnNPCStartedLeavingQueue;

+};

+

+#endif // AI_BEHAVIOR_ACTBUSY_H