1

game/server/NextBot/NextBotInterface.h

@@ -0,0 +1,302 @@
+// NextBotInterface.h
+// Interface for NextBot
+// Author: Michael Booth, May 2006
+//========= Copyright Valve Corporation, All rights reserved. ============//
+
+#ifndef _NEXT_BOT_INTERFACE_H_
+#define _NEXT_BOT_INTERFACE_H_
+
+#include "NextBot/NextBotKnownEntity.h"
+#include "NextBotComponentInterface.h"
+#include "NextBotLocomotionInterface.h"
+#include "NextBotBodyInterface.h"
+#include "NextBotIntentionInterface.h"
+#include "NextBotVisionInterface.h"
+#include "NextBotDebug.h"
+
+class CBaseCombatCharacter;
+class PathFollower;
+
+//----------------------------------------------------------------------------------------------------------------
+/**
+ * A general purpose filter interface for various bot systems
+ */
+class INextBotFilter
+{
+public:
+	virtual bool IsSelected( const CBaseEntity *candidate ) const = 0;			// return true if this entity passes the filter
+};
+
+
+//----------------------------------------------------------------------------------------------------------------
+class INextBot : public INextBotEventResponder
+{
+public:
+	INextBot( void );
+	virtual ~INextBot();
+
+	int GetBotId() const;
+
+	bool BeginUpdate();
+	void EndUpdate();
+
+	virtual void Reset( void );										// (EXTEND) reset to initial state
+	virtual void Update( void );									// (EXTEND) update internal state
+	virtual void Upkeep( void );									// (EXTEND) lightweight update guaranteed to occur every server tick
+
+	void FlagForUpdate( bool b = true );
+	bool IsFlaggedForUpdate();
+	int GetTickLastUpdate() const;
+	void SetTickLastUpdate( int );
+
+	virtual bool IsRemovedOnReset( void ) const { return true; }	// remove this bot when the NextBot manager calls Reset
+
+	virtual CBaseCombatCharacter *GetEntity( void ) const	= 0;
+	virtual class NextBotCombatCharacter *GetNextBotCombatCharacter( void ) const	{ return NULL; }
+
+#ifdef TERROR
+	virtual class SurvivorBot *MySurvivorBotPointer() const { return NULL; }
+#endif
+
+	// interfaces are never NULL - return base no-op interfaces at a minimum
+	virtual ILocomotion *	GetLocomotionInterface( void ) const;
+	virtual IBody *			GetBodyInterface( void ) const;
+	virtual IIntention *	GetIntentionInterface( void ) const;
+	virtual IVision *		GetVisionInterface( void ) const;
+
+	/**
+	 * Attempt to change the bot's position. Return true if successful.
+	 */
+	virtual bool SetPosition( const Vector &pos );
+	virtual const Vector &GetPosition( void ) const;				// get the global position of the bot
+
+	/**
+	 * Friend/enemy/neutral queries
+	 */
+	virtual bool IsEnemy( const CBaseEntity *them ) const;			// return true if given entity is our enemy
+	virtual bool IsFriend( const CBaseEntity *them ) const;			// return true if given entity is our friend
+	virtual bool IsSelf( const CBaseEntity *them ) const;			// return true if 'them' is actually me
+
+	/**
+	 * Can we climb onto this entity?
+	 */	
+	virtual bool IsAbleToClimbOnto( const CBaseEntity *object ) const;
+
+	/**
+	 * Can we break this entity?
+	 */	
+	virtual bool IsAbleToBreak( const CBaseEntity *object ) const;
+
+	/**
+	 * Sometimes we want to pass through other NextBots. OnContact() will always
+	 * be invoked, but collision resolution can be skipped if this
+	 * method returns false.
+	 */
+	virtual bool IsAbleToBlockMovementOf( const INextBot *botInMotion ) const	{ return true; }
+
+	/**
+	 * Should we ever care about noticing physical contact with this entity?
+	 */
+	virtual bool ShouldTouch( const CBaseEntity *object ) const		{ return true; }
+
+	/**
+	 * This immobile system is used to track the global state of "am I actually moving or not".
+	 * The OnStuck() event is only emitted when following a path, and paths can be recomputed, etc.
+	 */
+	virtual bool IsImmobile( void ) const;					// return true if we haven't moved in awhile
+	virtual float GetImmobileDuration( void ) const;		// how long have we been immobile
+	virtual void ClearImmobileStatus( void );		
+	virtual float GetImmobileSpeedThreshold( void ) const;	// return units/second below which this actor is considered "immobile"
+
+	/**
+	 * Get the last PathFollower we followed. This method gives other interfaces a
+	 * single accessor to the most recent Path being followed by the myriad of 
+	 * different PathFollowers used in the various behaviors the bot may be doing.
+	 */
+	virtual const PathFollower *GetCurrentPath( void ) const;
+	virtual void SetCurrentPath( const PathFollower *path );
+	virtual void NotifyPathDestruction( const PathFollower *path );		// this PathFollower is going away, which may or may not be ours
+
+	// between distance utility methods
+	virtual bool IsRangeLessThan( CBaseEntity *subject, float range ) const;
+	virtual bool IsRangeLessThan( const Vector &pos, float range ) const;
+	virtual bool IsRangeGreaterThan( CBaseEntity *subject, float range ) const;
+	virtual bool IsRangeGreaterThan( const Vector &pos, float range ) const;
+	virtual float GetRangeTo( CBaseEntity *subject ) const;
+	virtual float GetRangeTo( const Vector &pos ) const;
+	virtual float GetRangeSquaredTo( CBaseEntity *subject ) const;
+	virtual float GetRangeSquaredTo( const Vector &pos ) const;
+
+	// event propagation
+	virtual INextBotEventResponder *FirstContainedResponder( void ) const;
+	virtual INextBotEventResponder *NextContainedResponder( INextBotEventResponder *current ) const;
+
+	virtual bool IsDebugging( unsigned int type ) const;		// return true if this bot is debugging any of the given types
+	virtual const char *GetDebugIdentifier( void ) const;		// return the name of this bot for debugging purposes
+	virtual bool IsDebugFilterMatch( const char *name ) const;	// return true if we match the given debug symbol
+	virtual void DisplayDebugText( const char *text ) const;	// show a line of text on the bot in the world
+	void DebugConColorMsg( NextBotDebugType debugType, const Color &color, PRINTF_FORMAT_STRING const char *fmt, ... );
+
+	enum {
+		MAX_NEXTBOT_DEBUG_HISTORY = 100,
+		MAX_NEXTBOT_DEBUG_LINE_LENGTH = 256,
+	};
+	struct NextBotDebugLineType
+	{
+		NextBotDebugType debugType;
+		char data[ MAX_NEXTBOT_DEBUG_LINE_LENGTH ];
+	};
+	void GetDebugHistory( unsigned int type, CUtlVector< const NextBotDebugLineType * > *lines ) const;	// build a vector of debug history of the given types
+	//------------------------------------------------------------------------------
+
+
+private:
+	friend class INextBotComponent;
+	void RegisterComponent( INextBotComponent *comp );		// components call this to register themselves with the bot that contains them
+	INextBotComponent *m_componentList;						// the first component
+
+	const PathFollower *m_currentPath;						// the path we most recently followed
+
+	int m_id;
+	bool m_bFlaggedForUpdate;
+	int m_tickLastUpdate;
+
+	unsigned int m_debugType;
+	mutable int m_debugDisplayLine;
+
+	Vector m_immobileAnchor;
+	CountdownTimer m_immobileCheckTimer;
+	IntervalTimer m_immobileTimer;
+	void UpdateImmobileStatus( void );
+
+	mutable ILocomotion *m_baseLocomotion;
+	mutable IBody		*m_baseBody;
+	mutable IIntention	*m_baseIntention;
+	mutable IVision		*m_baseVision;
+	//mutable IAttention	*m_baseAttention;
+
+	// Debugging info
+	void ResetDebugHistory( void );
+	CUtlVector< NextBotDebugLineType * > m_debugHistory;
+};
+
+
+inline const PathFollower *INextBot::GetCurrentPath( void ) const
+{
+	return m_currentPath;
+}
+
+inline void INextBot::SetCurrentPath( const PathFollower *path )
+{
+	m_currentPath = path;
+}
+
+inline void INextBot::NotifyPathDestruction( const PathFollower *path )
+{
+	if ( m_currentPath == path )
+		m_currentPath = NULL;
+}
+
+
+inline ILocomotion *INextBot::GetLocomotionInterface( void ) const
+{
+	// these base interfaces are lazy-allocated (instead of being fully instanced classes) for two reasons:
+	// 1) so the memory is only used if needed
+	// 2) so the component is registered properly
+	if ( m_baseLocomotion == NULL )
+	{
+		m_baseLocomotion = new ILocomotion( const_cast< INextBot * >( this ) );
+	}
+
+	return m_baseLocomotion;
+}
+
+inline IBody *INextBot::GetBodyInterface( void ) const
+{
+	if ( m_baseBody == NULL )
+	{
+		m_baseBody = new IBody( const_cast< INextBot * >( this ) );
+	}
+
+	return m_baseBody;
+}
+
+inline IIntention *INextBot::GetIntentionInterface( void ) const
+{
+	if ( m_baseIntention == NULL )
+	{
+		m_baseIntention = new IIntention( const_cast< INextBot * >( this ) );
+	}
+
+	return m_baseIntention;
+}
+
+inline IVision *INextBot::GetVisionInterface( void ) const
+{
+	if ( m_baseVision == NULL )
+	{
+		m_baseVision = new IVision( const_cast< INextBot * >( this ) );
+	}
+
+	return m_baseVision;
+}
+
+inline int INextBot::GetBotId() const
+{
+	return m_id;
+}
+
+inline void INextBot::FlagForUpdate( bool b )
+{
+	m_bFlaggedForUpdate = b;
+}
+
+inline bool INextBot::IsFlaggedForUpdate()
+{
+	return m_bFlaggedForUpdate;
+}
+
+inline int INextBot::GetTickLastUpdate() const
+{
+	return m_tickLastUpdate;
+}
+
+inline void INextBot::SetTickLastUpdate( int tick )
+{
+	m_tickLastUpdate = tick;
+}
+
+inline bool INextBot::IsImmobile( void ) const
+{
+	return m_immobileTimer.HasStarted();
+}
+
+inline float INextBot::GetImmobileDuration( void ) const
+{
+	return m_immobileTimer.GetElapsedTime();
+}
+
+inline void INextBot::ClearImmobileStatus( void )
+{
+	m_immobileTimer.Invalidate();
+	m_immobileAnchor = GetEntity()->GetAbsOrigin();
+}
+
+inline float INextBot::GetImmobileSpeedThreshold( void ) const
+{
+	return 30.0f;
+}
+
+inline INextBotEventResponder *INextBot::FirstContainedResponder( void ) const
+{
+	return m_componentList;
+}
+
+
+inline INextBotEventResponder *INextBot::NextContainedResponder( INextBotEventResponder *current ) const
+{
+	return static_cast< INextBotComponent * >( current )->m_nextComponent;
+}
+
+
+#endif // _NEXT_BOT_INTERFACE_H_