path: root/game/shared/tf/tf_robot_destruction_robot.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: The robots for use in the Robot Destruction TF2 game mode.
//
//=========================================================================//
#ifndef ROBOT_DESTRUCTION_ROBOT_H
#define ROBOT_DESTRUCTION_ROBOT_H
#pragma once

#include "cbase.h"

#ifdef GAME_DLL
	#include "tf_shareddefs.h"
	#include "pathtrack.h"
	#include "NextBotGroundLocomotion.h"
	#include "NextBotIntentionInterface.h"
	#include "NextBotBehavior.h"
	#include "NextBot.h"
	#include "../server/NextBot/Path/NextBotPathFollow.h"
	#include "../server/NextBot/Path/NextBotPath.h"
	#include "../server/tf/halloween/headless_hatman_body.h"
	#include "tf_obj_dispenser.h"
#else
	#include "c_obj_dispenser.h"
#endif

#ifdef CLIENT_DLL
	#define CTFRobotDestruction_Robot C_TFRobotDestruction_Robot
	#define CRobotDispenser C_RobotDispenser
#endif

#include "props_shared.h"

enum eRobotType
{
	ROBOT_TYPE_FRUSTUM = 0,
	ROBOT_TYPE_SPHERE,
	ROBOT_TYPE_KING,

	NUM_ROBOT_TYPES
};

enum eRobotUIState
{
	ROBOT_STATE_INACIVE = 0,
	ROBOT_STATE_ACTIVE,
	ROBOT_STATE_DEAD,
	ROBOT_STATE_SHIELDED,

	NUM_ROBOT_STATES
};

struct RobotData_t
{
public:
	enum EStringDataKey_t
	{
		MODEL_KEY = 0,
		DAMAGED_MODEL_KEY,
		HURT_SOUND_KEY,
		DEATH_SOUND_KEY,
		COLLIDE_SOUND_KEY,
		IDLE_SOUND_KEY
	};

	enum EFloatDataKey_t
	{
		HEALTH_BAR_OFFSET_KEY
	};

	RobotData_t( const char* pszModelName
			   , const char* pszDamagedModelName
			   , const char *pszHurtSound
			   , const char *pszDeathSound
			   , const char *pszCollideSound
			   , const char *pszIdleSound
			   , float flHealthBarOffset )
	{
		m_stringMap.SetLessFunc( DefLessFunc(int) );
		m_floatMap.SetLessFunc( DefLessFunc(int) );
		m_stringMap.Insert( MODEL_KEY, pszModelName );
		m_stringMap.Insert( DAMAGED_MODEL_KEY, pszDamagedModelName );
		m_stringMap.Insert( HURT_SOUND_KEY, pszHurtSound );
		m_stringMap.Insert( DEATH_SOUND_KEY, pszDeathSound );
		m_stringMap.Insert( COLLIDE_SOUND_KEY, pszCollideSound );
		m_stringMap.Insert( IDLE_SOUND_KEY, pszIdleSound );
		m_floatMap.Insert( HEALTH_BAR_OFFSET_KEY, flHealthBarOffset );
	}

	const char* GetStringData( EStringDataKey_t key ) const
	{
		return GetData< const char * >( m_stringMap, (int)key );
	}

	float GetFloatData( EFloatDataKey_t key ) const
	{
		return GetData< float >( m_floatMap, (int)key );
	}

	void Precache();

private:

	template< typename T >
	T GetData( const CUtlMap< int, T >& map, int nKey ) const
	{
		int nIndex = map.Find( nKey );
		if ( nIndex != map.InvalidIndex() )
		{
			return map.Element( nIndex );
		}

		AssertMsg1( 0, "No entry for key %d", nKey );
		return T(0);
	}

	CUtlMap< int, const char * > m_stringMap;
	CUtlMap< int, float > m_floatMap;
};

class CTFRobotDestruction_Robot;

#ifdef GAME_DLL

struct RobotSpawnData_t
{
	RobotSpawnData_t()
		: m_eType( ROBOT_TYPE_FRUSTUM )
		, m_nRobotHealth( 100 )
		, m_nPoints( 0 )
		, m_nNumGibs( 0 )
		, m_pszPathName( NULL )
		, m_pszGroupName( NULL )
	{}

	RobotSpawnData_t &operator=( const RobotSpawnData_t& rhs )
	{
		m_eType = rhs.m_eType;
		m_nRobotHealth = rhs.m_nRobotHealth;
		m_nPoints = rhs.m_nPoints;
		m_nNumGibs = rhs.m_nNumGibs;
		m_pszPathName = rhs.m_pszPathName;
		m_pszGroupName = rhs.m_pszGroupName;

		return *this;
	}

	eRobotType m_eType;
	int m_nRobotHealth;
	int m_nPoints;
	int m_nNumGibs;
	const char *m_pszPathName;
	const char *m_pszGroupName;
};

//----------------------------------------------------------------------------
class CRobotLocomotion : public NextBotGroundLocomotion
{
public:
	CRobotLocomotion( INextBot *bot ) : NextBotGroundLocomotion( bot ) { }
	virtual ~CRobotLocomotion() { }

	virtual float GetGroundSpeed() const OVERRIDE;
	virtual float GetRunSpeed( void ) const OVERRIDE;			// get maximum running speed
	virtual float GetStepHeight( void ) const OVERRIDE;				// if delta Z is greater than this, we have to jump to get up
	virtual float GetMaxJumpHeight( void ) const OVERRIDE;			// return maximum height of a jump

	virtual bool ShouldCollideWith( const CBaseEntity *object ) const OVERRIDE;

private:
	virtual float GetMaxYawRate( void ) const OVERRIDE;				// return max rate of yaw rotation
};


//----------------------------------------------------------------------------
class CRobotIntention : public IIntention
{
public:
	CRobotIntention( class CTFRobotDestruction_Robot *me );
	virtual ~CRobotIntention();

	virtual void Reset( void ) OVERRIDE;
	virtual void Update( void ) OVERRIDE;

	virtual QueryResultType			IsPositionAllowed( const INextBot *me, const Vector &pos ) const OVERRIDE;	// is the a place we can be?

	virtual INextBotEventResponder *FirstContainedResponder( void ) const OVERRIDE  { return m_behavior; }
	virtual INextBotEventResponder *NextContainedResponder( INextBotEventResponder *current ) const OVERRIDE { return NULL; }

private:
	Behavior< CTFRobotDestruction_Robot > *m_behavior;
};

//---------------------------------------------------------------------------------------------
class CRobotBehavior : public Action< CTFRobotDestruction_Robot >
{
public:
	virtual Action< CTFRobotDestruction_Robot > *InitialContainedAction( CTFRobotDestruction_Robot *me ) OVERRIDE;
	virtual ActionResult< CTFRobotDestruction_Robot >	OnStart( CTFRobotDestruction_Robot *me, Action< CTFRobotDestruction_Robot > *priorAction ) OVERRIDE;
	virtual ActionResult< CTFRobotDestruction_Robot >	Update( CTFRobotDestruction_Robot *me, float interval ) OVERRIDE;
	virtual EventDesiredResult< CTFRobotDestruction_Robot > OnInjured( CTFRobotDestruction_Robot *me, const CTakeDamageInfo &info );
	EventDesiredResult< CTFRobotDestruction_Robot > OnContact( CTFRobotDestruction_Robot *me, CBaseEntity *pOther, CGameTrace *result = NULL );
	virtual const char *GetName( void ) const	{ return "RobotBehavior"; }		// return name of this action

private:
	CountdownTimer m_SpeakTimer;
	CountdownTimer m_IdleSpeakTimer;
};
#endif

class CRobotDispenser : 
#ifdef GAME_DLL
	public CObjectDispenser
#else
	public C_ObjectDispenser
#endif
{
#ifdef GAME_DLL
	DECLARE_CLASS( CRobotDispenser, CObjectDispenser )
#else
	DECLARE_CLASS( CRobotDispenser, C_ObjectDispenser )
#endif
	DECLARE_NETWORKCLASS();
	DECLARE_DATADESC();
public:
#ifdef GAME_DLL
	CRobotDispenser();

	virtual void Spawn( void ) OVERRIDE;
	virtual void OnGoActive( void ) OVERRIDE;
	virtual void GetControlPanelInfo( int nPanelIndex, const char *&pPanelName ) OVERRIDE;
	virtual void SetModel( const char *pModel ) OVERRIDE;
	virtual float GetDispenserRadius( void ) OVERRIDE { return 128; }
	virtual float GetHealRate() const OVERRIDE { return 5.f; }

	virtual int DispenseMetal( CTFPlayer * ) OVERRIDE { return 0; }
	virtual bool DispenseAmmo( CTFPlayer * ) OVERRIDE { return false; }

private:

	virtual void PlayActiveSound() OVERRIDE { /*DO NOTHING*/ }
#endif
};

class CTFRobotDestruction_RobotAnimController
{
public:
	CTFRobotDestruction_RobotAnimController( CTFRobotDestruction_Robot *pOuter );
	void Update();
	void Impulse( const Vector& vecImpulse );
private:
	void Approach( Vector& vecIn, const Vector& vecTarget, float flRate );
	void GetPoseParams();

	Vector m_vecOldOrigin;
	Vector m_vecLean;
	Vector m_vecImpulse;
	CTFRobotDestruction_Robot *m_pOuter;
	
	struct PoseParams_t
	{
		int m_nMoveX;
		int m_nMoveY;
	} m_poseParams;
};

#ifdef GAME_DLL
	typedef NextBotCombatCharacter RobotBaseClass;
#else
	typedef CBaseCombatCharacter RobotBaseClass;
#endif

class CTFRobotDestruction_Robot : public RobotBaseClass
#ifdef CLIENT_DLL
	, public CGameEventListener
#endif
{
	DECLARE_DATADESC();
	DECLARE_CLASS( CTFRobotDestruction_Robot, RobotBaseClass )
	DECLARE_NETWORKCLASS();
public:

	CTFRobotDestruction_Robot( void );
	virtual ~CTFRobotDestruction_Robot( void );
	static void StaticPrecache( void );
	virtual void Precache( void ) OVERRIDE;

	virtual void Spawn( void ) OVERRIDE;
	virtual bool ShouldCollide( int collisionGroup, int contentsMask ) const OVERRIDE;
#ifdef CLIENT_DLL
	virtual float GetHealthBarHeightOffset( void ) const OVERRIDE;
	virtual void OnDataChanged( DataUpdateType_t type ) OVERRIDE;
	virtual int	GetHealth( void ) const OVERRIDE { return m_iHealth; }
	virtual int	GetMaxHealth( void ) const OVERRIDE { return m_iMaxHealth; }
	virtual bool IsHealthBarVisible( void ) const OVERRIDE { return true; }
	virtual void UpdateClientSideAnimation( void ) OVERRIDE;
	virtual void FireGameEvent( IGameEvent *event ) OVERRIDE;
	virtual CStudioHdr* OnNewModel() OVERRIDE;
	virtual void FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options ) OVERRIDE;
	void UpdateDamagedEffects( void );
#else
	virtual void HandleAnimEvent( animevent_t *pEvent ) OVERRIDE;
	virtual bool IsRemovedOnReset( void ) const { return false; }
	virtual void UpdateOnRemove( void ) OVERRIDE;
	virtual void Event_Killed( const CTakeDamageInfo &info ) OVERRIDE;
	virtual int OnTakeDamage( const CTakeDamageInfo &info ) OVERRIDE;
	virtual void TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator ) OVERRIDE;
	virtual void UpdateAnimsThink( void );
	
	void RepairSelfThink( void );
	bool GetShieldedState( void ) const { return m_bShielded; }
	CPathTrack *GetNextPath( void ) const { return m_hNextPath; }
	void ArriveAtPath( void );
	void SetRobotSpawnData( const RobotSpawnData_t& data ) { m_spawnData = data; m_eType = data.m_eType; }
	const RobotSpawnData_t &GetRobotSpawnData() const { return m_spawnData; }
	void SetGroup( class CTFRobotDestruction_RobotGroup* pGroup ) { m_hGroup.Set( pGroup ); }
	void SetSpawn( class CTFRobotDestruction_RobotSpawn* pSpawn ) { m_hSpawn.Set( pSpawn ); }
	void EnableUber( void );
	void DisableUber( void );

	// INextBot
	virtual CRobotIntention	*GetIntentionInterface( void ) const		{ return m_intention; }
	virtual CRobotLocomotion	*GetLocomotionInterface( void ) const	{ return m_locomotor; }
	virtual CHeadlessHatmanBody	*GetBodyInterface( void ) const			{ return m_body; }
	void SetNewActivity( Activity activity );
	void SetIsPanicked( bool bPanicked ) { m_bIsPanicked = bPanicked; }
	bool GetIsPanicked( void ) const { return m_bIsPanicked; }

	//Inputs
	void InputStopAndUseComputer( inputdata_t &inputdata );
private:

	void PlayDeathEffects( void );
	void ModifyDamage( CTakeDamageInfo *info ) const;
	void SpewBars( int nNumToSpew );
	void SpewBarsThink( void );
	void SelfDestructThink( void );
	void SpewGibs( void );
#endif
private:

	int							m_iHealth;
	int							m_iMaxHealth;
	CUtlVector<breakmodel_t>	m_aGibs;
	CUtlVector<breakmodel_t>	m_aSpawnProps;
	CTFRobotDestruction_RobotAnimController m_animController;
	CNetworkVar( bool, m_bShielded );
	CNetworkVar( eRobotType, m_eType );
#ifdef CLIENT_DLL
	HPARTICLEFFECT	m_hDamagedParticleEffect;
#else
	CRobotDispenser				*m_pDispenser;
	RobotSpawnData_t			m_spawnData;
	CHandle< CPathTrack >		m_hNextPath;
	int							m_nPointsSpewed;
	IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_iHealth );
	CHandle< CTFRobotDestruction_RobotGroup > m_hGroup;
	CHandle< CTFRobotDestruction_RobotSpawn > m_hSpawn;

	CRobotIntention *m_intention;
	CRobotLocomotion *m_locomotor;
	CHeadlessHatmanBody *m_body;
	bool m_bIsPanicked;
#endif
};

#ifdef GAME_DLL
//--------------------------------------------------------------------------------------------------------------
class CRobotPathCost : public IPathCost
{
public:
	CRobotPathCost( CTFRobotDestruction_Robot *me )
	{
		m_me = me;
	}

	// return the cost (weighted distance between) of moving from "fromArea" to "area", or -1 if the move is not allowed
	virtual float operator()( CNavArea *area, CNavArea *fromArea, const CNavLadder *ladder, const CFuncElevator *elevator, float length ) const
	{
		if ( fromArea == NULL )
		{
			// first area in path, no cost
			return 0.0f;
		}
		else
		{
			if ( !m_me->GetLocomotionInterface()->IsAreaTraversable( area ) )
			{
				// our locomotor says we can't move here
				return -1.0f;
			}

			// compute distance traveled along path so far
			float dist;

			if ( ladder )
			{
				dist = ladder->m_length;
			}
			else if ( length > 0.0 )
			{
				// optimization to avoid recomputing length
				dist = length;
			}
			else
			{
				dist = ( area->GetCenter() - fromArea->GetCenter() ).Length();
			}

			// check height change
			float deltaZ = fromArea->ComputeAdjacentConnectionHeightChange( area );
			if ( deltaZ >= m_me->GetLocomotionInterface()->GetStepHeight() )
			{
				if ( deltaZ >= m_me->GetLocomotionInterface()->GetMaxJumpHeight() )
				{
					// too high to reach
					return -1.0f;
				}

				// jumping is slower than flat ground
				const float jumpPenalty = 5.0f;
				dist += jumpPenalty * dist;
			}
			else if ( deltaZ < -m_me->GetLocomotionInterface()->GetDeathDropHeight() )
			{
				// too far to drop
				return -1.0f;
			}

			return dist + fromArea->GetCostSoFar();
		}
	}

	CTFRobotDestruction_Robot *m_me;
};
#endif // GAME_DLL
#endif // ROBOT_DESTRUCTION_ROBOT_H