303 lines
9.3 KiB
C++
303 lines
9.3 KiB
C++
// 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_
|