csgo/cstrike15_src/game/server/cstrike15/bot/cs_bot_manager.h

//========= Copyright � 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

// Author: Michael S. Booth ([email protected]), 2003

#ifndef CS_CONTROL_H
#define CS_CONTROL_H


#include "bot_manager.h"
#include "nav_area.h"
#include "bot_util.h"
#include "bot_profile.h"
#include "cs_shareddefs.h"
#include "cs_player.h"

extern ConVar mp_friendlyfire;
extern ConVar throttle_expensive_ai;

class CBasePlayerWeapon;

/**
 * Given one team, return the other
 */
inline int OtherTeam( int team )
{
	return (team == TEAM_TERRORIST) ? TEAM_CT : TEAM_TERRORIST;
}

class CCSBotManager;

// accessor for CS-specific bots
inline CCSBotManager *TheCSBots( void )
{
	return reinterpret_cast< CCSBotManager * >( TheBots );
}

//--------------------------------------------------------------------------------------------------------------
class BotEventInterface : public IGameEventListener2
{
public:
	virtual const char *GetEventName( void ) const = 0;
};

//--------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------
/**
 * Macro to set up an OnEventClass() in TheCSBots.
 */
#define DECLARE_BOTMANAGER_EVENT_LISTENER( BotManagerSingleton, EventClass, EventName ) \
	public: \
	virtual void On##EventClass( IGameEvent *data ); \
	private: \
	class EventClass##Event : public BotEventInterface \
	{ \
		bool m_enabled; \
	public: \
		EventClass##Event( void ) \
		{ \
			gameeventmanager->AddListener( this, #EventName, true ); \
			m_enabled = true; \
		} \
		~EventClass##Event( void ) \
		{ \
			if ( m_enabled ) gameeventmanager->RemoveListener( this ); \
		} \
		virtual const char *GetEventName( void ) const \
		{ \
			return #EventName; \
		} \
		void Enable( bool enable ) \
		{ \
			m_enabled = enable; \
			if ( enable ) \
				gameeventmanager->AddListener( this, #EventName, true ); \
			else \
				gameeventmanager->RemoveListener( this ); \
		} \
		bool IsEnabled( void ) const { return m_enabled; } \
		void FireGameEvent( IGameEvent *event ) \
		{ \
			BotManagerSingleton()->On##EventClass( event ); \
		} \
		int GetEventDebugID( void ) \
		{ \
			return EVENT_DEBUG_ID_INIT; \
		} \
	}; \
	EventClass##Event m_##EventClass##Event;


//--------------------------------------------------------------------------------------------------------------
#define DECLARE_CSBOTMANAGER_EVENT_LISTENER( EventClass, EventName ) DECLARE_BOTMANAGER_EVENT_LISTENER( TheCSBots, EventClass, EventName )


//--------------------------------------------------------------------------------------------------------------
/**
 * Macro to propogate an event from the bot manager to all bots
 */
// @kutta: changed dynamic_cast -> static_cast; what other bot types can there be?
#define CCSBOTMANAGER_ITERATE_BOTS( Callback, arg1 ) \
	{ \
		for ( int idx = 1; idx <= gpGlobals->maxClients; ++idx ) \
		{ \
			CBasePlayer *player = UTIL_PlayerByIndex( idx ); \
			if (player == NULL) continue; \
			if (!player->IsBot()) continue; \
			CCSBot *bot = static_cast< CCSBot * >(player); \
			bot->Callback( arg1 ); \
		} \
	}


//--------------------------------------------------------------------------------------------------------------
//
// The manager for Counter-Strike specific bots
//
class CCSBotManager : public CBotManager
{
public:
	CCSBotManager();

	virtual CBasePlayer *AllocateBotEntity( void );			///< factory method to allocate the appropriate entity for the bot

	virtual void ClientDisconnect( CBaseEntity *entity );
	virtual bool ClientCommand( CBasePlayer *player, const CCommand &args );

	virtual void ServerActivate( void );
	virtual void ServerDeactivate( void );
	virtual bool ServerCommand( const char *cmd );
	bool IsServerActive( void ) const { return m_serverActive; }

	virtual void RestartRound( void );						///< (EXTEND) invoked when a new round begins
	virtual void StartFrame( void );						///< (EXTEND) called each frame

	virtual unsigned int GetPlayerPriority( CBasePlayer *player ) const;	///< return priority of player (0 = max pri)
	virtual bool IsImportantPlayer( CCSPlayer *player ) const;				///< return true if player is important to scenario (VIP, bomb carrier, etc)

	void ExtractScenarioData( void );							///< search the map entities to determine the game scenario and define important zones

	// difficulty levels -----------------------------------------------------------------------------------------
	static BotDifficultyType GetDifficultyLevel( void )		
	{
		static ConVarRef sv_mmqueue_reservation( "sv_mmqueue_reservation" );
		if ( sv_mmqueue_reservation.GetString()[0] == 'Q' && CSGameRules() && !CSGameRules()->IsPlayingCooperativeGametype() )
			return BOT_EASY;	// Queue matchmaking always subs people with easy bots
		if (cv_bot_difficulty.GetFloat() < 0.9f)
			return BOT_EASY;
		if (cv_bot_difficulty.GetFloat() < 1.9f)
			return BOT_NORMAL;
		if (cv_bot_difficulty.GetFloat() < 2.9f)
			return BOT_HARD;

		return BOT_EXPERT;
	}

	// the supported game scenarios ------------------------------------------------------------------------------
	enum GameScenarioType
	{
		SCENARIO_DEATHMATCH,
		SCENARIO_DEFUSE_BOMB,
		SCENARIO_RESCUE_HOSTAGES,
		SCENARIO_ESCORT_VIP
	};
	GameScenarioType GetScenario( void ) const		{ return m_gameScenario; }

	// "zones" ---------------------------------------------------------------------------------------------------
	// depending on the game mode, these are bomb zones, rescue zones, etc.

	enum { MAX_ZONES = 4 };										///< max # of zones in a map
	enum { MAX_ZONE_NAV_AREAS = 16 };							///< max # of nav areas in a zone
	struct Zone
	{
		CBaseEntity *m_entity;									///< the map entity
		CNavArea *m_area[ MAX_ZONE_NAV_AREAS ];					///< nav areas that overlap this zone
		int m_areaCount;
		Vector m_center;
		bool m_isLegacy;										///< if true, use pev->origin and 256 unit radius as zone
		int m_index;
		bool m_isBlocked;
		Extent m_extent;
	};

	const Zone *GetZone( int i ) const				{ return ( ( i >= 0 ) && ( i < m_zoneCount ) ) ? ( &m_zone[i] ) : NULL; }
	const Zone *GetZone( const Vector &pos ) const;				///< return the zone that contains the given position
	const Zone *GetClosestZone( const Vector &pos ) const;		///< return the closest zone to the given position
	const Zone *GetClosestZone( const CBaseEntity *entity ) const;	///< return the closest zone to the given entity
	int GetZoneCount( void ) const					{ return m_zoneCount; }
	void CheckForBlockedZones( void );


	const Vector *GetRandomPositionInZone( const Zone *zone ) const;	///< return a random position inside the given zone
	CNavArea *GetRandomAreaInZone( const Zone *zone ) const;			///< return a random area inside the given zone

	/**
	 * Return the zone closest to the given position, using the given cost heuristic
	 */
	template< typename CostFunctor >
	const Zone *GetClosestZone( CNavArea *startArea, CostFunctor costFunc, float *travelDistance = NULL ) const
	{
		const Zone *closeZone = NULL;
		float closeDist = 99999999.9f;

		if (startArea == NULL)
			return NULL;

		for( int i=0; i<m_zoneCount; ++i )
		{
			if (m_zone[i].m_areaCount == 0)
				continue;

			if ( m_zone[i].m_isBlocked )
				continue;

			// just use the first overlapping nav area as a reasonable approximation
			float dist = NavAreaTravelDistance( startArea, m_zone[i].m_area[0], costFunc );

			if (dist >= 0.0f && dist < closeDist)
			{
				closeZone = &m_zone[i];
				closeDist = dist;
			}
		}

		if (travelDistance)
			*travelDistance = closeDist;

		return closeZone;
	}

	/// pick a zone at random and return it
	const Zone *GetRandomZone( void ) const
	{
		if (m_zoneCount == 0)
			return NULL;

		int i;
		CUtlVector< const Zone * > unblockedZones;
		for ( i=0; i<m_zoneCount; ++i )
		{
			if ( m_zone[i].m_isBlocked )
				continue;

			unblockedZones.AddToTail( &(m_zone[i]) );
		}

		if ( unblockedZones.Count() == 0 )
			return NULL;

		return unblockedZones[ RandomInt( 0, unblockedZones.Count()-1 ) ];
	}


	/// returns a random spawn point for the given team (no arg means use both team spawnpoints)
	CBaseEntity *GetRandomSpawn( int team = TEAM_MAXCOUNT ) const;


	bool IsBombPlanted( void ) const			{ return m_isBombPlanted; }			///< returns true if bomb has been planted
	float GetBombPlantTimestamp( void ) const	{ return m_bombPlantTimestamp; }	///< return time bomb was planted
	bool IsTimeToPlantBomb( void ) const;											///< return true if it's ok to try to plant bomb
	CCSPlayer *GetBombDefuser( void ) const		{ return m_bombDefuser; }			///< return the player currently defusing the bomb, or NULL
	float GetBombTimeLeft( void ) const;											///< get the time remaining before the planted bomb explodes
	CBaseEntity *GetLooseBomb( void )			{ return m_looseBomb; }				///< return the bomb if it is loose on the ground
	CNavArea *GetLooseBombArea( void ) const	{ return m_looseBombArea; }			///< return area that bomb is in/near
	void SetLooseBomb( CBaseEntity *bomb );

	enum ETStrat
	{
		k_ETStrat_Rush,			// Hit the target site asap
		k_ETStrat_Slow,			// Spend time at initial engagement spots, move in if time is low or if team gets a kill
		k_ETStrat_Fake,			// One player goes to the site not being hit

		k_ETStrat_Count,
	};
	ETStrat GetTStrat( void ) const { return m_eTStrat; }
	int GetTerroristTargetSite( void ) const { return m_iTerroristTargetSite; }


	enum ECTStrat
	{
		k_ECTStrat_GuardRandomSite,		// Used for testing
		k_ECTStrat_212,					// 2 each site, one aggressive mid
		k_ECTStrat_StackSite,			// 4 on priority site, 1 alternate site

		k_ECTStrat_Count,
	};
	ECTStrat GetCTStrat( void ) const { return m_eCTStrat; }
	int GetCTPrioritySite( void ) const { return m_iCTPrioritySite; }


	float GetRadioMessageTimestamp( RadioType event, int teamID ) const;			///< return the last time the given radio message was sent for given team
	float GetRadioMessageInterval( RadioType event, int teamID ) const;				///< return the interval since the last time this message was sent
	void SetRadioMessageTimestamp( RadioType event, int teamID );
	void ResetRadioMessageTimestamps( void );

	float GetLastSeenEnemyTimestamp( void ) const	{ return m_lastSeenEnemyTimestamp; }	///< return the last time anyone has seen an enemy
	void SetLastSeenEnemyTimestamp( void ) 			{ m_lastSeenEnemyTimestamp = gpGlobals->curtime; }

	float GetRoundStartTime( void ) const			{ return m_roundStartTimestamp; }
	float GetElapsedRoundTime( void ) const			{ return gpGlobals->curtime - m_roundStartTimestamp; }	///< return the elapsed time since the current round began

	bool AllowRogues( void ) const					{ return cv_bot_allow_rogues.GetBool(); }
	bool AllowPistols( void ) const					{ return cv_bot_allow_pistols.GetBool(); }
	bool AllowShotguns( void ) const				{ return cv_bot_allow_shotguns.GetBool(); }
	bool AllowSubMachineGuns( void ) const			{ return cv_bot_allow_sub_machine_guns.GetBool(); }
	bool AllowRifles( void ) const					{ return cv_bot_allow_rifles.GetBool(); }
	bool AllowMachineGuns( void ) const				{ return cv_bot_allow_machine_guns.GetBool(); }
	bool AllowGrenades( void ) const				{ return cv_bot_allow_grenades.GetBool(); }
	bool AllowSnipers( void ) const					{ return cv_bot_allow_snipers.GetBool(); }
#ifdef CS_SHIELD_ENABLED
	bool AllowTacticalShield( void ) const			{ return cv_bot_allow_shield.GetBool(); }
#else
	bool AllowTacticalShield( void ) const			{ return false; }
#endif // CS_SHIELD_ENABLED

	bool AllowFriendlyFireDamage( void ) const		{ return mp_friendlyfire.GetBool(); }

	bool IsWeaponUseable( const CWeaponCSBase *weapon ) const;	///< return true if the bot can use this weapon

	bool IsDefenseRushing( void ) const				{ return m_isDefenseRushing; }		///< returns true if defense team has "decided" to rush this round
	bool IsOnDefense( const CCSPlayer *player ) const;		///< return true if this player is on "defense"
	bool IsOnOffense( const CCSPlayer *player ) const;		///< return true if this player is on "offense"

	bool IsRoundOver( void ) const					{ return m_isRoundOver; }		///< return true if the round has ended

	#define FROM_CONSOLE true
	bool BotAddCommand( int team, bool isFromConsole = false, const char *profileName = NULL, CSWeaponType weaponType = WEAPONTYPE_UNKNOWN, BotDifficultyType difficulty = NUM_DIFFICULTY_LEVELS );	///< process the "bot_add" console command
	
	bool BotPlaceCommand( uint nTeamMask = 0xFFFFFFFF ); //Moves a bot at the location under the cursor.  For perf and lighting testing.

	// Called to mark that an expensive operation has happened this frame, used for budgeting/throttling AI
	void OnExpensiveBotOperation() { m_nNumExpensiveOperationsThisFrame ++; }
	// Query to see if we have exceeded our per-frame budget for "expensive" AI operations
	bool AllowedToDoExpensiveBotOperationThisFrame() { return !throttle_expensive_ai.GetBool() || m_nNumExpensiveOperationsThisFrame < 1; }

	void ForceMaintainBotQuota( void ) { MaintainBotQuota(); }

private:
	enum SkillType { LOW, AVERAGE, HIGH, RANDOM };

	void MaintainBotQuota( void );

	static bool m_isMapDataLoaded;							///< true if we've attempted to load map data
	bool m_serverActive;									///< true between ServerActivate() and ServerDeactivate()

	GameScenarioType m_gameScenario;						///< what kind of game are we playing

	Zone m_zone[ MAX_ZONES ];							
	int m_zoneCount;

	bool m_isBombPlanted;									///< true if bomb has been planted
	float m_bombPlantTimestamp;								///< time bomb was planted
	float m_earliestBombPlantTimestamp;						///< don't allow planting until after this time has elapsed
	CHandle<CCSPlayer> m_bombDefuser;						///< the player currently defusing a bomb
	EHANDLE m_looseBomb;									///< will be non-NULL if bomb is loose on the ground
	CNavArea *m_looseBombArea;								///< area that bomb is is/near

	bool m_isRoundOver;										///< true if the round has ended

	CountdownTimer m_checkTransientAreasTimer;				///< when elapsed, all transient nav areas should be checked for blockage

	float m_radioMsgTimestamp[ RADIO_END - RADIO_START_1 ][ 2 ];

	float m_lastSeenEnemyTimestamp;
	float m_roundStartTimestamp;							///< the time when the current round began

	bool m_isDefenseRushing;								///< whether defensive team is rushing this round or not

	int m_nNumExpensiveOperationsThisFrame;

	// Cooperative mode vars
	ETStrat m_eTStrat;										// Current plan for T
	int m_iTerroristTargetSite;								// Bomb site Ts are planing to plant at

	ECTStrat m_eCTStrat;									// Current plan for CT
	int m_iCTPrioritySite;									// Guess at which site will be attacked

	// Event Handlers --------------------------------------------------------------------------------------------
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( PlayerFootstep,		player_footstep )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( PlayerRadio,			player_radio )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( PlayerDeath,			player_death )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( PlayerFallDamage,		player_falldamage )

	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombPickedUp,			bomb_pickup )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombPlanted,			bomb_planted )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombBeep,				bomb_beep )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombDefuseBegin,		bomb_begindefuse )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombDefused,			bomb_defused )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombDefuseAbort,		bomb_abortdefuse )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BombExploded,			bomb_exploded )

	DECLARE_CSBOTMANAGER_EVENT_LISTENER( RoundEnd,				round_end )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( RoundStart,			round_start )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( RoundFreezeEnd,		round_freeze_end )

	DECLARE_CSBOTMANAGER_EVENT_LISTENER( DoorMoving,			door_moving )

	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BreakProp,				break_prop )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BreakBreakable,		break_breakable )

	DECLARE_CSBOTMANAGER_EVENT_LISTENER( HostageFollows,		hostage_follows )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( HostageRescuedAll,		hostage_rescued_all )

	DECLARE_CSBOTMANAGER_EVENT_LISTENER( WeaponFire,			weapon_fire )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( WeaponFireOnEmpty,		weapon_fire_on_empty )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( WeaponReload,			weapon_reload )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( WeaponZoom,			weapon_zoom )

	DECLARE_CSBOTMANAGER_EVENT_LISTENER( BulletImpact,			bullet_impact )

	DECLARE_CSBOTMANAGER_EVENT_LISTENER( HEGrenadeDetonate,		hegrenade_detonate )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( FlashbangDetonate,		flashbang_detonate )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( SmokeGrenadeDetonate,	smokegrenade_detonate )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( MolotovDetonate,		molotov_detonate )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( DecoyDetonate,			decoy_detonate )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( DecoyFiring,			decoy_firing )
	DECLARE_CSBOTMANAGER_EVENT_LISTENER( GrenadeBounce,			grenade_bounce )

	DECLARE_CSBOTMANAGER_EVENT_LISTENER( NavBlocked,			nav_blocked )

	DECLARE_CSBOTMANAGER_EVENT_LISTENER( ServerShutdown,		server_shutdown )

	CUtlVector< BotEventInterface * > m_commonEventListeners;	// These event listeners fire often, and can be disabled for performance gains when no bots are present.
	bool m_eventListenersEnabled;
	void EnableEventListeners( bool enable );
};

inline CBasePlayer *CCSBotManager::AllocateBotEntity( void )
{
	return static_cast<CBasePlayer *>( CreateEntityByName( "cs_bot" ) );
}

inline bool CCSBotManager::IsTimeToPlantBomb( void ) const
{
	return (gpGlobals->curtime >= m_earliestBombPlantTimestamp);
}

inline const CCSBotManager::Zone *CCSBotManager::GetClosestZone( const CBaseEntity *entity ) const
{
	if (entity == NULL)
		return NULL;

	Vector centroid = entity->GetAbsOrigin();
	centroid.z += HalfHumanHeight;
	return GetClosestZone( centroid );
}

#endif