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.

212 lines
8.1 KiB

5 years ago
// NextBotIntentionInterface.h
// Interface for intentional thinking
// Author: Michael Booth, April 2005
//========= Copyright Valve Corporation, All rights reserved. ============//
#ifndef _NEXT_BOT_INTENTION_INTERFACE_H_
#define _NEXT_BOT_INTENTION_INTERFACE_H_
#include "NextBotComponentInterface.h"
#include "NextBotContextualQueryInterface.h"
class INextBot;
//
// Insert this macro in your INextBot-derived class declaration to
// create a IIntention-derived class that handles the bookkeeping
// of instantiating a Behavior with an initial Action and updating it.
//
#define DECLARE_INTENTION_INTERFACE( Actor ) \
\
class Actor##Intention : public IIntention \
{ \
public: \
Actor##Intention( Actor *me ); \
virtual ~Actor##Intention(); \
virtual void Reset( void ); \
virtual void Update( void ); \
virtual INextBotEventResponder *FirstContainedResponder( void ) const { return m_behavior; } \
virtual INextBotEventResponder *NextContainedResponder( INextBotEventResponder *current ) const { return NULL; } \
private: \
Behavior< Actor > *m_behavior; \
}; \
\
public: virtual IIntention *GetIntentionInterface( void ) const { return m_intention; } \
private: Actor##Intention *m_intention; \
public:
//
// Use this macro to create the implementation code for the IIntention-derived class
// declared above. Since this requires InitialAction, it must occur after
// that Action has been declared, so it can be new'd here.
//
#define IMPLEMENT_INTENTION_INTERFACE( Actor, InitialAction ) \
Actor::Actor##Intention::Actor##Intention( Actor *me ) : IIntention( me ) { m_behavior = new Behavior< Actor >( new InitialAction ); } \
Actor::Actor##Intention::~Actor##Intention() { delete m_behavior; } \
void Actor::Actor##Intention::Reset( void ) { delete m_behavior; m_behavior = new Behavior< Actor >( new InitialAction ); } \
void Actor::Actor##Intention::Update( void ) { m_behavior->Update( static_cast< Actor * >( GetBot() ), GetUpdateInterval() ); }
//
// Use this macro in the constructor of your bot to allocate the IIntention-derived class
//
#define ALLOCATE_INTENTION_INTERFACE( Actor ) { m_intention = new Actor##Intention( this ); }
//
// Use this macro in the destructor of your bot to deallocate the IIntention-derived class
//
#define DEALLOCATE_INTENTION_INTERFACE { if ( m_intention ) delete m_intention; }
//----------------------------------------------------------------------------------------------------------------
/**
* The interface for intentional thinking.
* The assumption is that this is a container for one or more concurrent Behaviors.
* The "primary" Behavior is the FirstContainedResponder, and so on.
* IContextualQuery requests are prioritized in contained responder order, such that the first responder
* that returns a definitive answer is accepted. WITHIN a given responder (ie: a Behavior), the deepest child
* Behavior in the active stack is asked first, then its parent, and so on, allowing the most specific active
* Behavior to override the query responses of its more general parent Behaviors.
*/
class IIntention : public INextBotComponent, public IContextualQuery
{
public:
IIntention( INextBot *bot ) : INextBotComponent( bot ) { }
virtual ~IIntention() { }
virtual void Reset( void ) { INextBotComponent::Reset(); } // reset to initial state
virtual void Update( void ) { } // update internal state
// IContextualQuery propagation --------------------------------
virtual QueryResultType ShouldPickUp( const INextBot *me, CBaseEntity *item ) const; // if the desired item was available right now, should we pick it up?
virtual QueryResultType ShouldHurry( const INextBot *me ) const; // are we in a hurry?
virtual QueryResultType ShouldRetreat( const INextBot *me ) const; // is it time to retreat?
virtual QueryResultType ShouldAttack( const INextBot *me, const CKnownEntity *them ) const; // should we attack "them"?
virtual QueryResultType IsHindrance( const INextBot *me, CBaseEntity *blocker ) const; // return true if we should wait for 'blocker' that is across our path somewhere up ahead.
virtual Vector SelectTargetPoint( const INextBot *me, const CBaseCombatCharacter *subject ) const; // given a subject, return the world space position we should aim at
virtual QueryResultType IsPositionAllowed( const INextBot *me, const Vector &pos ) const; // is the a place we can be?
virtual const CKnownEntity * SelectMoreDangerousThreat( const INextBot *me,
const CBaseCombatCharacter *subject, // the subject of the danger
const CKnownEntity *threat1,
const CKnownEntity *threat2 ) const; // return the more dangerous of the two threats, or NULL if we have no opinion
// NOTE: As further queries are added, update the Behavior class to propagate them
};
inline QueryResultType IIntention::ShouldPickUp( const INextBot *me, CBaseEntity *item ) const
{
for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
{
const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
if ( query )
{
// return the response of the first responder that gives a definitive answer
QueryResultType result = query->ShouldPickUp( me, item );
if ( result != ANSWER_UNDEFINED )
{
return result;
}
}
}
return ANSWER_UNDEFINED;
}
inline QueryResultType IIntention::ShouldHurry( const INextBot *me ) const
{
for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
{
const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
if ( query )
{
// return the response of the first responder that gives a definitive answer
QueryResultType result = query->ShouldHurry( me );
if ( result != ANSWER_UNDEFINED )
{
return result;
}
}
}
return ANSWER_UNDEFINED;
}
inline QueryResultType IIntention::ShouldRetreat( const INextBot *me ) const
{
for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
{
const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
if ( query )
{
// return the response of the first responder that gives a definitive answer
QueryResultType result = query->ShouldRetreat( me );
if ( result != ANSWER_UNDEFINED )
{
return result;
}
}
}
return ANSWER_UNDEFINED;
}
inline QueryResultType IIntention::ShouldAttack( const INextBot *me, const CKnownEntity *them ) const
{
for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
{
const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
if ( query )
{
// return the response of the first responder that gives a definitive answer
QueryResultType result = query->ShouldAttack( me, them );
if ( result != ANSWER_UNDEFINED )
{
return result;
}
}
}
return ANSWER_UNDEFINED;
}
inline QueryResultType IIntention::IsHindrance( const INextBot *me, CBaseEntity *blocker ) const
{
for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
{
const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
if ( query )
{
// return the response of the first responder that gives a definitive answer
QueryResultType result = query->IsHindrance( me, blocker );
if ( result != ANSWER_UNDEFINED )
{
return result;
}
}
}
return ANSWER_UNDEFINED;
}
inline QueryResultType IIntention::IsPositionAllowed( const INextBot *me, const Vector &pos ) const
{
for ( INextBotEventResponder *sub = FirstContainedResponder(); sub; sub = NextContainedResponder( sub ) )
{
const IContextualQuery *query = dynamic_cast< const IContextualQuery * >( sub );
if ( query )
{
// return the response of the first responder that gives a definitive answer
QueryResultType result = query->IsPositionAllowed( me, pos );
if ( result != ANSWER_UNDEFINED )
{
return result;
}
}
}
return ANSWER_UNDEFINED;
}
#endif // _NEXT_BOT_INTENTION_INTERFACE_H_