// NextBotBodyInterface.h
// Control and information about the bot's body state (posture, animation state, etc)
// Author: Michael Booth, April 2006
//========= Copyright Valve Corporation, All rights reserved. ============//
#ifndef _NEXT_BOT_BODY_INTERFACE_H_
#define _NEXT_BOT_BODY_INTERFACE_H_
#include "animation.h"
#include "NextBotComponentInterface.h"
class INextBot;
struct animevent_t;
//----------------------------------------------------------------------------------------------------------------
/**
* The interface for control and information about the bot's body state (posture, animation state, etc)
*/
class IBody : public INextBotComponent
{
public:
IBody( INextBot *bot ) : INextBotComponent( bot ) { }
virtual ~IBody() { }
virtual void Reset( void ) { INextBotComponent::Reset(); } // reset to initial state
virtual void Update( void ) { } // update internal state
/**
* Move the bot to a new position.
* If the body is not currently movable or if it
* is in a motion-controlled animation activity
* the position will not be changed and false will be returned.
*/
virtual bool SetPosition( const Vector &pos );
virtual const Vector &GetEyePosition( void ) const; // return the eye position of the bot in world coordinates
virtual const Vector &GetViewVector( void ) const; // return the view unit direction vector in world coordinates
enum LookAtPriorityType
{
BORING,
INTERESTING, // last known enemy location, dangerous sound location
IMPORTANT, // a danger
CRITICAL, // an active threat to our safety
MANDATORY // nothing can interrupt this look at - two simultaneous look ats with this priority is an error
};
virtual void AimHeadTowards( const Vector &lookAtPos,
LookAtPriorityType priority = BORING,
float duration = 0.0f,
INextBotReply *replyWhenAimed = NULL,
const char *reason = NULL ); // aim the bot's head towards the given goal
virtual void AimHeadTowards( CBaseEntity *subject,
LookAtPriorityType priority = BORING,
float duration = 0.0f,
INextBotReply *replyWhenAimed = NULL,
const char *reason = NULL ); // continually aim the bot's head towards the given subject
virtual bool IsHeadAimingOnTarget( void ) const; // return true if the bot's head has achieved its most recent lookat target
virtual bool IsHeadSteady( void ) const; // return true if head is not rapidly turning to look somewhere else
virtual float GetHeadSteadyDuration( void ) const; // return the duration that the bot's head has not been rotating
virtual float GetHeadAimSubjectLeadTime( void ) const; // return how far into the future we should predict our moving subject's position to aim at when tracking subject look-ats
virtual float GetHeadAimTrackingInterval( void ) const; // return how often we should sample our target's position and velocity to update our aim tracking, to allow realistic slop in tracking
virtual void ClearPendingAimReply( void ) { } // clear out currently pending replyWhenAimed callback
virtual float GetMaxHeadAngularVelocity( void ) const; // return max turn rate of head in degrees/second
enum ActivityType
{
MOTION_CONTROLLED_XY = 0x0001, // XY position and orientation of the bot is driven by the animation.
MOTION_CONTROLLED_Z = 0x0002, // Z position of the bot is driven by the animation.
ACTIVITY_UNINTERRUPTIBLE= 0x0004, // activity can't be changed until animation finishes
ACTIVITY_TRANSITORY = 0x0008, // a short animation that takes over from the underlying animation momentarily, resuming it upon completion
ENTINDEX_PLAYBACK_RATE = 0x0010, // played back at different rates based on entindex
};
/**
* Begin an animation activity, return false if we cant do that right now.
*/
virtual bool StartActivity( Activity act, unsigned int flags = 0 );
virtual int SelectAnimationSequence( Activity act ) const; // given an Activity, select and return a specific animation sequence within it
virtual Activity GetActivity( void ) const; // return currently animating activity
virtual bool IsActivity( Activity act ) const; // return true if currently animating activity matches the given one
virtual bool HasActivityType( unsigned int flags ) const; // return true if currently animating activity has any of the given flags
enum PostureType
{
STAND,
CROUCH,
SIT,
CRAWL,
LIE
};
virtual void SetDesiredPosture( PostureType posture ) { } // request a posture change
virtual PostureType GetDesiredPosture( void ) const; // get posture body is trying to assume
virtual bool IsDesiredPosture( PostureType posture ) const; // return true if body is trying to assume this posture
virtual bool IsInDesiredPosture( void ) const; // return true if body's actual posture matches its desired posture
virtual PostureType GetActualPosture( void ) const; // return body's current actual posture
virtual bool IsActualPosture( PostureType posture ) const; // return true if body is actually in the given posture
virtual bool IsPostureMobile( void ) const; // return true if body's current posture allows it to move around the world
virtual bool IsPostureChanging( void ) const; // return true if body's posture is in the process of changing to new posture
/**
* "Arousal" is the level of excitedness/arousal/anxiety of the body.
* Is changes instantaneously to avoid complex interactions with posture transitions.
*/
enum ArousalType
{
NEUTRAL,
ALERT,
INTENSE
};
virtual void SetArousal( ArousalType arousal ) { } // arousal level change
virtual ArousalType GetArousal( void ) const; // get arousal level
virtual bool IsArousal( ArousalType arousal ) const; // return true if body is at this arousal level
virtual float GetHullWidth( void ) const; // width of bot's collision hull in XY plane
virtual float GetHullHeight( void ) const; // height of bot's current collision hull based on posture
virtual float GetStandHullHeight( void ) const; // height of bot's collision hull when standing
virtual float GetCrouchHullHeight( void ) const; // height of bot's collision hull when crouched
virtual const Vector &GetHullMins( void ) const; // return current collision hull minimums based on actual body posture
virtual const Vector &GetHullMaxs( void ) const; // return current collision hull maximums based on actual body posture
virtual unsigned int GetSolidMask( void ) const; // return the bot's collision mask (hack until we get a general hull trace abstraction here or in the locomotion interface)
virtual unsigned int GetCollisionGroup( void ) const;
};
inline bool IBody::IsHeadSteady( void ) const
{
return true;
}
inline float IBody::GetHeadSteadyDuration( void ) const
{
return 0.0f;
}
inline float IBody::GetHeadAimSubjectLeadTime( void ) const
{
return 0.0f;
}
inline float IBody::GetHeadAimTrackingInterval( void ) const
{
return 0.0f;
}
inline float IBody::GetMaxHeadAngularVelocity( void ) const
{
return 1000.0f;
}
inline bool IBody::StartActivity( Activity act, unsigned int flags )
{
return false;
}
inline int IBody::SelectAnimationSequence( Activity act ) const
{
return 0;
}
inline Activity IBody::GetActivity( void ) const
{
return ACT_INVALID;
}
inline bool IBody::IsActivity( Activity act ) const
{
return false;
}
inline bool IBody::HasActivityType( unsigned int flags ) const
{
return false;
}
inline IBody::PostureType IBody::GetDesiredPosture( void ) const
{
return IBody::STAND;
}
inline bool IBody::IsDesiredPosture( PostureType posture ) const
{
return true;
}
inline bool IBody::IsInDesiredPosture( void ) const
{
return true;
}
inline IBody::PostureType IBody::GetActualPosture( void ) const
{
return IBody::STAND;
}
inline bool IBody::IsActualPosture( PostureType posture ) const
{
return true;
}
inline bool IBody::IsPostureMobile( void ) const
{
return true;
}
inline bool IBody::IsPostureChanging( void ) const
{
return false;
}
inline IBody::ArousalType IBody::GetArousal( void ) const
{
return IBody::NEUTRAL;
}
inline bool IBody::IsArousal( ArousalType arousal ) const
{
return true;
}
//---------------------------------------------------------------------------------------------------------------------------
/**
* Width of bot's collision hull in XY plane
*/
inline float IBody::GetHullWidth( void ) const
{
return 26.0f;
}
//---------------------------------------------------------------------------------------------------------------------------
/**
* Height of bot's current collision hull based on posture
*/
inline float IBody::GetHullHeight( void ) const
{
switch( GetActualPosture() )
{
case LIE:
return 16.0f;
case SIT:
case CROUCH:
return GetCrouchHullHeight();
case STAND:
default:
return GetStandHullHeight();
}
}
//---------------------------------------------------------------------------------------------------------------------------
/**
* Height of bot's collision hull when standing
*/
inline float IBody::GetStandHullHeight( void ) const
{
return 68.0f;
}
//---------------------------------------------------------------------------------------------------------------------------
/**
* Height of bot's collision hull when crouched
*/
inline float IBody::GetCrouchHullHeight( void ) const
{
return 32.0f;
}
//---------------------------------------------------------------------------------------------------------------------------
/**
* Return current collision hull minimums based on actual body posture
*/
inline const Vector &IBody::GetHullMins( void ) const
{
static Vector hullMins;
hullMins.x = -GetHullWidth()/2.0f;
hullMins.y = hullMins.x;
hullMins.z = 0.0f;
return hullMins;
}
//---------------------------------------------------------------------------------------------------------------------------
/**
* Return current collision hull maximums based on actual body posture
*/
inline const Vector &IBody::GetHullMaxs( void ) const
{
static Vector hullMaxs;
hullMaxs.x = GetHullWidth()/2.0f;
hullMaxs.y = hullMaxs.x;
hullMaxs.z = GetHullHeight();
return hullMaxs;
}
inline unsigned int IBody::GetSolidMask( void ) const
{
return MASK_NPCSOLID;
}
inline unsigned int IBody::GetCollisionGroup( void ) const
{
return COLLISION_GROUP_NONE;
}
#endif // _NEXT_BOT_BODY_INTERFACE_H_