NextBotBodyInterface.h

// 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_