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

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

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

#pragma warning( disable : 4530 )					// STL uses exceptions, but we are not compiling with them - ignore warning

#include "cbase.h"

#include "cs_bot.h"
#include "nav_area.h"
#include "cs_gamerules.h"
#include "shared_util.h"
#include "keyvalues.h"
#include "tier0/icommandline.h"
#include "fmtstr.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#ifdef _WIN32
#pragma warning (disable:4701)				// disable warning that variable *may* not be initialized 
#endif

CBotManager *TheBots = NULL;

bool CCSBotManager::m_isMapDataLoaded = false;

int g_nClientPutInServerOverrides = 0;


void DrawOccupyTime( void );
ConVar bot_show_occupy_time( "bot_show_occupy_time", "0", FCVAR_GAMEDLL | FCVAR_CHEAT, "Show when each nav area can first be reached by each team." );

void DrawBattlefront( void );
ConVar bot_show_battlefront( "bot_show_battlefront", "0", FCVAR_GAMEDLL | FCVAR_CHEAT, "Show areas where rushing players will initially meet." );

int UTIL_CSSBotsInGame( void );

ConVar bot_join_delay( "bot_join_delay", "0", FCVAR_GAMEDLL, "Prevents bots from joining the server for this many seconds after a map change." );
ConVar bot_join_in_warmup( "bot_join_in_warmup", "1", FCVAR_GAMEDLL, "Prevents bots from joining the server while warmup phase is active." );

ConVar throttle_expensive_ai( "throttle_expensive_ai", IsGameConsole() ? "1" : "0" );

extern ConVar mp_guardian_target_site;
/**
 * Determine whether bots can be used or not
 */
inline bool AreBotsAllowed()
{
	// If they pass in -nobots, don't allow bots.  This is for people who host servers, to
	// allow them to disallow bots to enforce CPU limits.
	const char *nobots = CommandLine()->CheckParm( "-nobots" );
	if ( nobots )
	{
		return false;
	}

	return true;
}


//--------------------------------------------------------------------------------------------------------------
void InstallBotControl( void )
{
	if ( TheBots != NULL )
		delete TheBots;

	TheBots = new CCSBotManager;
}


//--------------------------------------------------------------------------------------------------------------
void RemoveBotControl( void )
{
	if ( TheBots != NULL )
		delete TheBots;

	TheBots = NULL;
}


//--------------------------------------------------------------------------------------------------------------
CBasePlayer* ClientPutInServerOverride_Bot( edict_t *pEdict, const char *playername )
{
	CBasePlayer *pPlayer = TheBots->AllocateAndBindBotEntity( pEdict );
	if ( pPlayer )
	{
		pPlayer->SetPlayerName( playername );
	}
	++g_nClientPutInServerOverrides;

	return pPlayer;
}

//--------------------------------------------------------------------------------------------------------------
// Constructor
CCSBotManager::CCSBotManager()
{
	m_zoneCount = 0;
	SetLooseBomb( NULL );
	m_serverActive = false;

	m_isBombPlanted = false;
	m_bombDefuser = NULL;
	m_roundStartTimestamp = 0.0f;

	m_eventListenersEnabled = true;
	m_commonEventListeners.AddToTail( &m_PlayerFootstepEvent );
	m_commonEventListeners.AddToTail( &m_PlayerRadioEvent );
	m_commonEventListeners.AddToTail( &m_PlayerFallDamageEvent );
	m_commonEventListeners.AddToTail( &m_BombBeepEvent );
	m_commonEventListeners.AddToTail( &m_DoorMovingEvent );
	m_commonEventListeners.AddToTail( &m_BreakPropEvent );
	m_commonEventListeners.AddToTail( &m_BreakBreakableEvent );
	m_commonEventListeners.AddToTail( &m_WeaponFireEvent );
	m_commonEventListeners.AddToTail( &m_WeaponFireOnEmptyEvent );
	m_commonEventListeners.AddToTail( &m_WeaponReloadEvent );
	m_commonEventListeners.AddToTail( &m_WeaponZoomEvent );
	m_commonEventListeners.AddToTail( &m_BulletImpactEvent );
	m_commonEventListeners.AddToTail( &m_GrenadeBounceEvent );
	m_commonEventListeners.AddToTail( &m_NavBlockedEvent );

	TheBotPhrases = new BotPhraseManager;
	TheBotProfiles = new BotProfileManager;

	m_nNumExpensiveOperationsThisFrame = 0;
}

const CCSBotManager::Zone* Helper_GetZoneForPlaceName( const char* szName )
{
	Place pl = TheNavMesh->NameToPlace( szName );
	for ( int i = 0; i < TheCSBots()->GetZoneCount(); ++i )
	{
		if ( !TheCSBots()->GetZone( i ) )
			continue;

		for ( int j = 0; j < CCSBotManager::MAX_ZONE_NAV_AREAS; ++j )
		{
			if ( !TheCSBots()->GetZone( i )->m_area[ j ] )
				continue;

			if ( TheCSBots()->GetZone( i )->m_area[ j ]->GetPlace() == pl )
			{
				return TheCSBots()->GetZone( i );
			}
		}
	}
	return NULL;
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Invoked when a new round begins
 */
void CCSBotManager::RestartRound( void )
{
	// extend
	CBotManager::RestartRound();

	SetLooseBomb( NULL );
	m_isBombPlanted = false;

	if ( CSGameRules()->IsPlayingGunGameTRBomb() )
	{
		// push to plant the bomb quickly in this game mode
		m_earliestBombPlantTimestamp = gpGlobals->curtime + RandomFloat( 0.0f, 10.0f );
	}
	else
	{
		m_earliestBombPlantTimestamp = gpGlobals->curtime + RandomFloat( 10.0f, 30.0f ); // 60
	}
	m_bombDefuser = NULL;

	ResetRadioMessageTimestamps();

	m_lastSeenEnemyTimestamp = -9999.9f;

	m_roundStartTimestamp = gpGlobals->curtime + mp_freezetime.GetFloat();

	// randomly decide if defensive team wants to "rush" as a whole
	const float defenseRushChance = 33.3f;	// 25.0f;
	m_isDefenseRushing = (RandomFloat( 0.0f, 100.0f ) <= defenseRushChance) ? true : false;

	if ( CSGameRules()->IsPlayingCoopGuardian() && mp_guardian_target_site.GetInt() >= 0 )
	{
		m_isDefenseRushing = 0;
		m_earliestBombPlantTimestamp = 0;
		m_eTStrat = k_ETStrat_Rush;
		m_iTerroristTargetSite = mp_guardian_target_site.GetInt();

		/*
		// Choose random strat if there are no humans on team
		if ( UTIL_HumansOnTeam( TEAM_TERRORIST ) == 0 )
		{
			m_eTStrat = k_ETStrat_Rush;
			m_iTerroristTargetSite = RandomInt( 0, 1 );
		}
		if ( UTIL_HumansOnTeam( TEAM_CT ) == 0 )
		{
			m_eCTStrat = k_ECTStrat_StackSite;
			m_iCTPrioritySite = RandomInt( 0, 1 );
		}
		*/
	}

	TheBotPhrases->OnRoundRestart();

	m_isRoundOver = false;
}

//--------------------------------------------------------------------------------------------------------------

void UTIL_DrawBox( Extent *extent, int lifetime, int red, int green, int blue )
{
	int darkRed = red/2;
	int darkGreen = green/2;
	int darkBlue = blue/2;

	Vector v[8];
	v[0].x = extent->lo.x; v[0].y = extent->lo.y; v[0].z = extent->lo.z;
	v[1].x = extent->hi.x; v[1].y = extent->lo.y; v[1].z = extent->lo.z;
	v[2].x = extent->hi.x; v[2].y = extent->hi.y; v[2].z = extent->lo.z;
	v[3].x = extent->lo.x; v[3].y = extent->hi.y; v[3].z = extent->lo.z;
	v[4].x = extent->lo.x; v[4].y = extent->lo.y; v[4].z = extent->hi.z;
	v[5].x = extent->hi.x; v[5].y = extent->lo.y; v[5].z = extent->hi.z;
	v[6].x = extent->hi.x; v[6].y = extent->hi.y; v[6].z = extent->hi.z;
	v[7].x = extent->lo.x; v[7].y = extent->hi.y; v[7].z = extent->hi.z;

	static int edge[] = 
	{
		1, 2, 3, 4, -1,
		5, 6, 7, 8, -5,
		1, -5,
		2, -6,
		3, -7,
		4, -8,
		0
	};

	Vector from, to;
	bool restart = true;
	for( int i=0; edge[i] != 0; ++i )
	{
		if (restart)
		{
			to = v[ edge[i]-1 ];
			restart = false;
			continue;
		}
		
		from = to;

		int index = edge[i];
		if (index < 0)
		{
			restart = true;
			index = -index;
		}

		to = v[ index-1 ];

		NDebugOverlay::Line( from, to, darkRed, darkGreen, darkBlue, true, 0.1f );
		NDebugOverlay::Line( from, to, red, green, blue, false, 0.15f );
	}
}

//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::EnableEventListeners( bool enable )
{
	if ( m_eventListenersEnabled == enable )
	{
		return;
	}

	m_eventListenersEnabled = enable;

	// enable/disable the most frequent event listeners, to improve performance when no bots are present.
	for ( int i=0; i<m_commonEventListeners.Count(); ++i )
	{
		if ( enable )
		{
			gameeventmanager->AddListener( m_commonEventListeners[i], m_commonEventListeners[i]->GetEventName(), true );
		}
		else
		{
			gameeventmanager->RemoveListener( m_commonEventListeners[i] );
		}
	}
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Called each frame
 */
void CCSBotManager::StartFrame( void )
{
	m_nNumExpensiveOperationsThisFrame = 0;

	if ( engine->IsPaused() )
		return;

	if ( !AreBotsAllowed() )
	{
		EnableEventListeners( false );
		return;
	}

	// EXTEND
	CBotManager::StartFrame();

	if ( !CSGameRules()->IsSwitchingTeamsAtRoundReset() )
	{
		// Maintain the bot quota only if the game is not currently switching teams at halftime
		MaintainBotQuota();
	}
	EnableEventListeners( UTIL_CSSBotsInGame() > 0 );

	// debug zone extent visualization
	if (cv_bot_debug.GetInt() == 5)
	{
		for( int z=0; z<m_zoneCount; ++z )
		{
			Zone *zone = &m_zone[z];

			if ( zone->m_isBlocked )
			{
				UTIL_DrawBox( &zone->m_extent, 1, 255, 0, 200 );
			}
			else
			{
				UTIL_DrawBox( &zone->m_extent, 1, 255, 100, 0 );
			}
		}
	}

	if (bot_show_occupy_time.GetBool())
	{
		DrawOccupyTime();
	}

	if (bot_show_battlefront.GetBool())
	{
		DrawBattlefront();
	}

	if ( m_checkTransientAreasTimer.IsElapsed() && !nav_edit.GetBool() )
	{
		CUtlVector< CNavArea * >& transientAreas = TheNavMesh->GetTransientAreas();
		for ( int i=0; i<transientAreas.Count(); ++i )
		{
			CNavArea *area = transientAreas[i];
			if ( area->GetAttributes() & NAV_MESH_TRANSIENT )
			{
				area->UpdateBlocked();
			}
		}

		m_checkTransientAreasTimer.Start( 2.0f );
	}
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Return true if the bot can use this weapon
 */
bool CCSBotManager::IsWeaponUseable( const CWeaponCSBase *weapon ) const
{
	if (weapon == NULL)
		return false;

	if (weapon->IsA( WEAPON_C4 ))
		return true;

	if ((!AllowShotguns() && weapon->IsKindOf( WEAPONTYPE_SHOTGUN )) ||
		(!AllowMachineGuns() && weapon->IsKindOf( WEAPONTYPE_MACHINEGUN )) || 
		(!AllowRifles() && weapon->IsKindOf( WEAPONTYPE_RIFLE )) || 
		(!AllowShotguns() && weapon->IsKindOf( WEAPONTYPE_SHOTGUN )) || 
		(!AllowSnipers() && weapon->IsKindOf( WEAPONTYPE_SNIPER_RIFLE )) || 
		(!AllowSubMachineGuns() && weapon->IsKindOf( WEAPONTYPE_SUBMACHINEGUN )) || 
		(!AllowPistols() && weapon->IsKindOf( WEAPONTYPE_PISTOL )) ||
		(!AllowGrenades() && weapon->IsKindOf( WEAPONTYPE_GRENADE )))
	{
		return false;
	}

	return true;
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Return true if this player is on "defense"
 */
bool CCSBotManager::IsOnDefense( const CCSPlayer *player ) const
{
	switch (GetScenario())
	{
		case SCENARIO_DEFUSE_BOMB:
			return (player->GetTeamNumber() == TEAM_CT);

		case SCENARIO_RESCUE_HOSTAGES:
			return (player->GetTeamNumber() == TEAM_TERRORIST);

		case SCENARIO_ESCORT_VIP:
			return (player->GetTeamNumber() == TEAM_TERRORIST);
	}

	return false;
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Return true if this player is on "offense"
 */
bool CCSBotManager::IsOnOffense( const CCSPlayer *player ) const
{
	return !IsOnDefense( player );
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Invoked when a map has just been loaded
 */
void CCSBotManager::ServerActivate( void )
{
	m_isMapDataLoaded = false;

	// load the database of bot radio chatter
	TheBotPhrases->Reset();
	TheBotPhrases->Initialize( "BotChatter.db", 0 );

	TheBotProfiles->Reset();
	TheBotProfiles->FindVoiceBankIndex( "BotChatter.db" ); // make sure default voice bank is first
	const char *filename;
	if ( false ) // g_engfuncs.pfnIsCareerMatch() )
	{
		filename = "MissionPacks/BotPackList.db";
	}
	else
	{
		filename = "BotPackList.db";
	}

	// read in the list of bot profile DBs
	FileHandle_t file = filesystem->Open( filename, "r" );
	if ( !file )
	{
		if ( CSGameRules()->IsPlayingCoopMission() )
			TheBotProfiles->Init( "BotProfileCoop.db" );
		else
			TheBotProfiles->Init( "BotProfile.db" );
	}
	else
	{
		int dataLength = filesystem->Size( filename );
		if ( dataLength > 0 )
		{
			char *dataPointer = new char[ dataLength + 1 ];
			int nDataReadSize = filesystem->Read( dataPointer, dataLength, file );
			if ( nDataReadSize > 0 )
			{
				dataPointer[nDataReadSize] = '\0';

				const char *dataFile = SharedParse( dataPointer );
				const char *token;

				while ( dataFile )
				{
					token = SharedGetToken();
					char *clone = CloneString( token );
					TheBotProfiles->Init( clone );
					delete[] clone;
					dataFile = SharedParse( dataFile );
				}

				delete [] dataPointer;
			}
		}
		filesystem->Close( file );
	}

	// Now that we've parsed all the profiles, we have a list of the voice banks they're using.
	// Go back and parse the custom voice speakables.
	const BotProfileManager::VoiceBankList *voiceBanks = TheBotProfiles->GetVoiceBanks();
	for ( int i=1; i<voiceBanks->Count(); ++i )
	{
		TheBotPhrases->Initialize( (*voiceBanks)[i], i );
	}

	// tell the Navigation Mesh system what CS spawn points are named
	if ( CSGameRules()->IsPlayingCoopMission() )
	{
		TheNavMesh->SetPlayerSpawnName( "info_enemy_terrorist_spawn" );
	}
	else
	{
		TheNavMesh->SetPlayerSpawnName( "info_player_terrorist" );
	}

	ExtractScenarioData();

	RestartRound();

	TheBotPhrases->OnMapChange();

	m_serverActive = true;
}


void CCSBotManager::ServerDeactivate( void )
{
	m_serverActive = false;
}

void CCSBotManager::ClientDisconnect( CBaseEntity *entity )
{
/*
	if ( FBitSet( entity->GetFlags(), FL_FAKECLIENT ) )
	{
		FREE_PRIVATE( entity );
	}
*/

	/*
	// make sure voice feedback is turned off
	CBasePlayer *pPlayer = (CBasePlayer *)CBaseEntity::Instance( pEntity );
	if ( pPlayer && pPlayer->IsBot() )
	{
		CCSBot *pBot = static_cast<CCSBot *>(pPlayer);
		if (pBot)
		{
			pBot->EndVoiceFeedback( true );
		}
	}
	*/
}



//--------------------------------------------------------------------------------------------------------------
/**
* Parses out bot name/template/etc params from the current ConCommand
*/
void BotArgumentsFromArgv( const CCommand &args, const char **name, CSWeaponType *weaponType, BotDifficultyType *difficulty, int *team = NULL, bool *all = NULL )
{
	static char s_name[MAX_PLAYER_NAME_LENGTH];

	s_name[0] = 0;
	*name = s_name;
	*difficulty = NUM_DIFFICULTY_LEVELS;
	if ( team )
	{
		*team = TEAM_UNASSIGNED;
	}
	if ( all )
	{
		*all = false;
	}

	*weaponType = WEAPONTYPE_UNKNOWN;

	for ( int arg=1; arg<args.ArgC(); ++arg )
	{
		bool found = false;

		const char *token = args[arg];
		if ( all && FStrEq( token, "all" ) )
		{
			*all = true;
			found = true;
		}
		else if ( team && FStrEq( token, "t" ) )
		{
			*team = TEAM_TERRORIST;
			found = true;
		}
		else if ( team && FStrEq( token, "ct" ) )
		{
			*team = TEAM_CT;
			found = true;
		}

		for( int i=0; i<NUM_DIFFICULTY_LEVELS && !found; ++i )
		{
			if (!stricmp( BotDifficultyName[i], token ))
			{
				*difficulty = (BotDifficultyType)i;
				found = true;
			}
		}

		if ( !found )
		{
			*weaponType = WeaponClassFromString( token );
			if ( *weaponType != WEAPONTYPE_UNKNOWN )
			{
				found = true;
			}
		}

		if ( !found )
		{
			Q_strncpy( s_name, token, sizeof( s_name ) );
		}
	}
}


//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_place, "bot_place - Places a bot from the map at where the local player is pointing.", FCVAR_GAMEDLL | FCVAR_CHEAT )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	uint nTeamMask = 0;

	for ( int i = 1; i < args.ArgC(); ++i )
	{
		if ( !V_strcmp( args.Arg( i ), "t" ) )
			nTeamMask |= 1 << TEAM_TERRORIST;
		else if ( !V_strcmp( args.Arg( i ), "ct" ) )
			nTeamMask |= 1 << TEAM_CT;
	}
	if ( !nTeamMask )
		nTeamMask = 0xFFFFFFFF;

	TheCSBots()->BotPlaceCommand(nTeamMask);
}


//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_add, "bot_add <t|ct> <type> <difficulty> <name> - Adds a bot matching the given criteria.", FCVAR_GAMEDLL )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	const char *name;
	BotDifficultyType difficulty;
	CSWeaponType weaponType;
	int team;
	BotArgumentsFromArgv( args, &name, &weaponType, &difficulty, &team );
	TheCSBots()->BotAddCommand( team, FROM_CONSOLE, name, weaponType, difficulty );
}


//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_add_t, "bot_add_t <type> <difficulty> <name> - Adds a terrorist bot matching the given criteria.", FCVAR_GAMEDLL )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	const char *name;
	BotDifficultyType difficulty;
	CSWeaponType weaponType;
	BotArgumentsFromArgv( args, &name, &weaponType, &difficulty );
	TheCSBots()->BotAddCommand( TEAM_TERRORIST, FROM_CONSOLE, name, weaponType, difficulty );
}


//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_add_ct, "bot_add_ct <type> <difficulty> <name> - Adds a Counter-Terrorist bot matching the given criteria.", FCVAR_GAMEDLL )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	const char *name;
	BotDifficultyType difficulty;
	CSWeaponType weaponType;
	BotArgumentsFromArgv( args, &name, &weaponType, &difficulty );
	TheCSBots()->BotAddCommand( TEAM_CT, FROM_CONSOLE, name, weaponType, difficulty );
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Collects all bots matching the given criteria (player name, profile template name, difficulty, and team)
 */
class CollectBots
{
public:
	CollectBots( const char *name, CSWeaponType weaponType, BotDifficultyType difficulty, int team )
	{
		m_name = name;
		m_difficulty = difficulty;
		m_team = team;
		m_weaponType = weaponType;
	}

	bool operator() ( CBasePlayer *player )
	{
		if ( !player->IsBot() )
		{
			return true;
		}

		CCSBot *bot = dynamic_cast< CCSBot * >(player);
		if ( !bot || !bot->GetProfile() )
		{
			return true;
		}

		if ( m_name && *m_name )
		{
			// accept based on name
			if ( FStrEq( m_name, bot->GetProfile()->GetName() ) )
			{
				m_bots.RemoveAll();
				m_bots.AddToTail( bot );
				return false;
			}

			// Reject based on profile template name
			if ( !bot->GetProfile()->InheritsFrom( m_name ) )
			{
				return true;
			}
		}

		// reject based on difficulty
		if ( m_difficulty != NUM_DIFFICULTY_LEVELS )
		{
			if ( !bot->GetProfile()->IsDifficulty( m_difficulty ) )
			{
				return true;
			}
		}

		// reject based on team
		if ( m_team == TEAM_CT || m_team == TEAM_TERRORIST )
		{
			if ( bot->GetTeamNumber() != m_team )
			{
				return true;
			}
		}

		// reject based on weapon preference
		if ( m_weaponType != WEAPONTYPE_UNKNOWN )
		{
			if ( !bot->GetProfile()->GetWeaponPreferenceCount() )
			{
				return true;
			}

			if ( m_weaponType != WeaponClassFromWeaponID( (CSWeaponID)bot->GetProfile()->GetWeaponPreference( 0 ) ) )
			{
				return true;
			}
		}

		// A match!
		m_bots.AddToTail( bot );

		return true;
	}

	CUtlVector< CCSBot * > m_bots;

private:
	const char *m_name;
	CSWeaponType m_weaponType;
	BotDifficultyType m_difficulty;
	int m_team;
};

//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_kill, "bot_kill <all> <t|ct> <type> <difficulty> <name> - Kills a specific bot, or all bots, matching the given criteria.", FCVAR_GAMEDLL | FCVAR_CHEAT )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	const char *name;
	BotDifficultyType difficulty;
	CSWeaponType weaponType;
	int team;
	bool all;

	BotArgumentsFromArgv( args, &name, &weaponType, &difficulty, &team, &all );
	if ( (!name || !*name) && team == TEAM_UNASSIGNED && difficulty == NUM_DIFFICULTY_LEVELS )
	{
		all = true;
	}

	CollectBots collector( name, weaponType, difficulty, team );
	ForEachPlayer( collector );

	for ( int i=0; i<collector.m_bots.Count(); ++i )
	{
		CCSBot *bot = collector.m_bots[i];
		if ( !bot->IsAlive() )
			continue;

		bot->CommitSuicide();
		
		if ( !all )
		{
			return;
		}
	}
}


//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_kick, "bot_kick <all> <t|ct> <type> <difficulty> <name> - Kicks a specific bot, or all bots, matching the given criteria.", FCVAR_GAMEDLL )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	const char *name;
	BotDifficultyType difficulty;
	CSWeaponType weaponType;
	int team;
	bool all;

	BotArgumentsFromArgv( args, &name, &weaponType, &difficulty, &team, &all );
	if ( (!name || !*name) && team == TEAM_UNASSIGNED && difficulty == NUM_DIFFICULTY_LEVELS )
	{
		all = true;
	}

	CollectBots collector( name, weaponType, difficulty, team );
	ForEachPlayer( collector );

	for ( int i=0; i<collector.m_bots.Count(); ++i )
	{
		CCSBot *bot = collector.m_bots[i];
		engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", engine->GetPlayerUserId( bot->edict() ) ) );
		if ( !all )
		{
			// adjust bot quota so kicked bot is not immediately added back in
			int newQuota = cv_bot_quota.GetInt() - 1;
			cv_bot_quota.SetValue( clamp( newQuota, 0, cv_bot_quota.GetInt() ) );
			return;
		}
	}

	// adjust bot quota so kicked bot is not immediately added back in
	if ( all && (!name || !*name) && team == TEAM_UNASSIGNED && difficulty == NUM_DIFFICULTY_LEVELS )
	{
		cv_bot_quota.SetValue( 0 );
	}
	else
	{
		int newQuota = cv_bot_quota.GetInt() - collector.m_bots.Count();
		cv_bot_quota.SetValue( clamp( newQuota, 0, cv_bot_quota.GetInt() ) );
	}
}


//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_knives_only, "Restricts the bots to only using knives", FCVAR_GAMEDLL )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	cv_bot_allow_pistols.SetValue( 0 );
	cv_bot_allow_shotguns.SetValue( 0 );
	cv_bot_allow_sub_machine_guns.SetValue( 0 );
	cv_bot_allow_rifles.SetValue( 0 );
	cv_bot_allow_machine_guns.SetValue( 0 );
	cv_bot_allow_grenades.SetValue( 0 );
	cv_bot_allow_snipers.SetValue( 0 );
#ifdef CS_SHIELD_ENABLED
	cv_bot_allow_shield.SetValue( 0 );
#endif // CS_SHIELD_ENABLED
}


//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_pistols_only, "Restricts the bots to only using pistols", FCVAR_GAMEDLL )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	cv_bot_allow_pistols.SetValue( 1 );
	cv_bot_allow_shotguns.SetValue( 0 );
	cv_bot_allow_sub_machine_guns.SetValue( 0 );
	cv_bot_allow_rifles.SetValue( 0 );
	cv_bot_allow_machine_guns.SetValue( 0 );
	cv_bot_allow_grenades.SetValue( 0 );
	cv_bot_allow_snipers.SetValue( 0 );
#ifdef CS_SHIELD_ENABLED
	cv_bot_allow_shield.SetValue( 0 );
#endif // CS_SHIELD_ENABLED
}


//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_snipers_only, "Restricts the bots to only using sniper rifles", FCVAR_GAMEDLL )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	cv_bot_allow_pistols.SetValue( 0 );
	cv_bot_allow_shotguns.SetValue( 0 );
	cv_bot_allow_sub_machine_guns.SetValue( 0 );
	cv_bot_allow_rifles.SetValue( 0 );
	cv_bot_allow_machine_guns.SetValue( 0 );
	cv_bot_allow_grenades.SetValue( 0 );
	cv_bot_allow_snipers.SetValue( 1 );
#ifdef CS_SHIELD_ENABLED
	cv_bot_allow_shield.SetValue( 0 );
#endif // CS_SHIELD_ENABLED
}


//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_all_weapons, "Allows the bots to use all weapons", FCVAR_GAMEDLL )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	cv_bot_allow_pistols.SetValue( 1 );
	cv_bot_allow_shotguns.SetValue( 1 );
	cv_bot_allow_sub_machine_guns.SetValue( 1 );
	cv_bot_allow_rifles.SetValue( 1 );
	cv_bot_allow_machine_guns.SetValue( 1 );
	cv_bot_allow_grenades.SetValue( 1 );
	cv_bot_allow_snipers.SetValue( 1 );
#ifdef CS_SHIELD_ENABLED
	cv_bot_allow_shield.SetValue( 1 );
#endif // CS_SHIELD_ENABLED
}

//--------------------------------------------------------------------------------------------------------------
static void BotGotoArea( CNavArea *pArea )
{
	if ( !pArea )
		return;

	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
	{
		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );

		if (player == NULL)
			continue;

		if (player->IsBot())
		{
			CCSBot *bot = dynamic_cast<CCSBot *>( player );

			if ( bot )
			{
				bot->MoveTo( pArea->GetCenter(), FASTEST_ROUTE );
			}

			break;
		}
	}
}

//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_goto_mark, "Sends a bot to the marked nav area (useful for testing navigation meshes)", FCVAR_GAMEDLL | FCVAR_CHEAT )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	// tell the first bot we find to go to our marked area
	BotGotoArea( TheNavMesh->GetMarkedArea() );
}

//--------------------------------------------------------------------------------------------------------------
CON_COMMAND_F( bot_goto_selected, "Sends a bot to the selected nav area (useful for testing navigation meshes)", FCVAR_GAMEDLL | FCVAR_CHEAT )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	// tell the first bot we find to go to our selected area
	BotGotoArea( TheNavMesh->GetSelectedArea() );
}

//--------------------------------------------------------------------------------------------------------------
#if 0
CON_COMMAND_F( bot_memory_usage, "Reports on the bots' memory usage", FCVAR_GAMEDLL )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	Msg( "Memory usage:\n" );

	Msg( "  %d bytes per bot\n", sizeof(CCSBot) );

	Msg( "  %d Navigation Areas @ %d bytes each = %d bytes\n", 
					TheNavMesh->GetNavAreaCount(),
					sizeof( CNavArea ),
					TheNavMesh->GetNavAreaCount() * sizeof( CNavArea ) );

	Msg( "  %d Hiding Spots @ %d bytes each = %d bytes\n", 
					TheHidingSpotList.Count(),
					sizeof( HidingSpot ),
					TheHidingSpotList.Count() * sizeof( HidingSpot ) );

/*
	unsigned int encounterMem = 0;
	FOR_EACH_LL( TheNavAreaList, it )
	{
		CNavArea *area = TheNavAreaList[ it ];

		FOR_EACH_LL( area->m_spotEncounterList, it )
		{
			SpotEncounter *se = area->m_spotEncounterList[ it ];

			encounterMem += sizeof( SpotEncounter );
			encounterMem += se->spotList.Count() * sizeof( SpotOrder );
		}
	}

	Msg( "  Encounter Spot data = %d bytes\n", encounterMem );
*/
}
#endif


bool CCSBotManager::ServerCommand( const char *cmd )
{
	return false;
}


bool CCSBotManager::ClientCommand( CBasePlayer *player, const CCommand &args )
{
	return false;
}


/**
 * Process the "bot_add" console command
 */
bool CCSBotManager::BotAddCommand( int team, bool isFromConsole, const char *profileName, CSWeaponType weaponType, BotDifficultyType difficulty )
{
	if ( !TheNavMesh->IsLoaded() )
	{
		// [msmith] We don't want to run nav mesh generation if we're on a console.
		if ( IsGameConsole() )
		{
			DevWarning("Cannot add bot!  No nav mesh found for this map!");
			return false;
		}

		// If there isn't a Navigation Mesh in memory, create one
		if ( !TheNavMesh->IsGenerating() )
		{
			if ( !m_isMapDataLoaded )
			{
				TheNavMesh->BeginGeneration();
				m_isMapDataLoaded = true;
			}
			return false;
		}
	}

	// dont allow bots to join if the Navigation Mesh is being generated
	if (TheNavMesh->IsGenerating())
		return false;

	const BotProfile *profile = NULL;

	if ( !isFromConsole )
	{
		profileName = NULL;
		difficulty = GetDifficultyLevel();
	}
	else
	{
		if ( difficulty == NUM_DIFFICULTY_LEVELS )
		{
			difficulty = GetDifficultyLevel();
		}

		// if team not specified, check bot_join_team cvar for preference
		if (team == TEAM_UNASSIGNED)
		{
			if (!stricmp( cv_bot_join_team.GetString(), "T" ))
				team = TEAM_TERRORIST;
			else if (!stricmp( cv_bot_join_team.GetString(), "CT" ))
				team = TEAM_CT;
			else
				team = CSGameRules()->SelectDefaultTeam();
		}
	}

	if ( profileName && *profileName )
	{
		// in career, ignore humans, since we want to add anyway
		bool ignoreHumans = CSGameRules()->IsCareer();
		if (UTIL_IsNameTaken( profileName, ignoreHumans ))
		{
			if ( isFromConsole )
			{
				Msg( "Error - %s is already in the game.\n", profileName );
			}
			return true;
		}

		// try to add a bot by name
		profile = TheBotProfiles->GetProfile( profileName, team );
		if ( !profile )
		{
			// try to add a bot by template
			profile = TheBotProfiles->GetProfileMatchingTemplate( profileName, team, difficulty, CSGameRules()->GetMatchDevice() );
			if ( !profile )
			{
				if ( isFromConsole )
				{
					Msg( "Error - no profile for '%s' exists.\n", profileName );
				}
				return true;
			}
		}
	}
	else
	{
		// if team not specified, check bot_join_team cvar for preference
		if (team == TEAM_UNASSIGNED)
		{
			if (!stricmp( cv_bot_join_team.GetString(), "T" ))
				team = TEAM_TERRORIST;
			else if (!stricmp( cv_bot_join_team.GetString(), "CT" ))
				team = TEAM_CT;
			else
			{
				if ( CSGameRules()->IsPlayingCooperativeGametype() )
				{
					team = UTIL_HumansOnTeam( TEAM_CT ) > 0 ? TEAM_TERRORIST : TEAM_CT;
#if defined ( DBGFLAG_ASSERT )
					if ( UTIL_HumansOnTeam( team ) > 0 )
					{
						Assert( ( UTIL_HumansOnTeam( TEAM_TERRORIST ) ^ UTIL_HumansOnTeam( TEAM_CT ) ) ); // No humans on opposing teams in coop
					}
#endif
				}
				else
				{
					team = CSGameRules()->SelectDefaultTeam();
				}
			}
		}

		if ( !isFromConsole && !profileName && ( weaponType == WEAPONTYPE_UNKNOWN ) && CSGameRules() && CSGameRules()->IsPlayingCooperativeGametype() )
		{
			//
			// Ensure that we have a sniper profile on the bot team for cooperative game
			//
			int numSniperBots = 0;
			for ( int i = 1; i <= gpGlobals->maxClients; ++i )
			{
				CCSBot *player = dynamic_cast< CCSBot * >( UTIL_PlayerByIndex( i ) );
				if ( player == NULL )
					continue;

				const BotProfile *pExistingBotProfile = player->GetProfile();
				if ( !pExistingBotProfile )
					continue;
				if ( !pExistingBotProfile->GetWeaponPreferenceCount() )
					continue;
				if ( WeaponClassFromWeaponID( pExistingBotProfile->GetWeaponPreference( 0 ) ) == WEAPONTYPE_SNIPER_RIFLE )
				{	// found a bot who will buy a sniper rifle guaranteed
					++ numSniperBots;
				}
			}

			int minNumSniperBots = 1;
			if ( CSGameRules()->IsPlayingCoopGuardian() )
			{
				extern ConVar mp_guardian_special_weapon_needed;
				char const *szWepShortName = mp_guardian_special_weapon_needed.GetString();
				if ( szWepShortName && *szWepShortName && V_strcmp( szWepShortName, "any" ) )
				{
					CSWeaponID csWeaponIdGuardianRequired = AliasToWeaponID( szWepShortName );
					if ( ( csWeaponIdGuardianRequired != WEAPON_NONE ) &&
						( WeaponClassFromWeaponID( csWeaponIdGuardianRequired ) == WEAPONTYPE_SNIPER_RIFLE ) )
					{
						++ minNumSniperBots;
					}
				}
			}
			if ( numSniperBots < minNumSniperBots )
				profile = TheBotProfiles->GetRandomProfile( difficulty, team, WEAPONTYPE_SNIPER_RIFLE );
		}
		if ( !profile )
			profile = TheBotProfiles->GetRandomProfile( difficulty, team, weaponType );

		if (profile == NULL)
		{
			if ( isFromConsole )
			{
				Msg( "All bot profiles at this difficulty level are in use.\n" );
			}
			return true;
		}
	}

	if (team == TEAM_UNASSIGNED || team == TEAM_SPECTATOR)
	{
		if ( isFromConsole )
		{
			Msg( "Could not add bot to the game: The game is full\n" );
		}
		return false;
	}

	if (CSGameRules()->TeamFull( team ))
	{
		if ( isFromConsole )
		{
			Msg( "Could not add bot to the game: Team is full\n" );
		}
		return false;
	}

	if (CSGameRules()->TeamStacked( team, TEAM_UNASSIGNED ))
	{
		if ( isFromConsole )
		{
			Msg( "Could not add bot to the game: Team is stacked (to disable this check, set mp_autoteambalance to zero, increase mp_limitteams, and restart the round).\n" );
		}
		return false;
	}

	// create the actual bot
	CCSBot *bot = CreateBot<CCSBot>( profile, team );

	if (bot == NULL)
	{
		if ( isFromConsole )
		{
			Msg( "Error: CreateBot() failed.\n" );
		}
		return false;
	}

	if (isFromConsole)
	{
		// increase the bot quota to account for manually added bot
		cv_bot_quota.SetValue( cv_bot_quota.GetInt() + 1 );
	}

	//
	// In Queued Matchmaking mode bots are always taking spots of humans
	// find a human that is not yet connected and use that human's stats
	// TODO: <vitaliy> this would allow bots to take over humans
	//
	if ( 0 && CSGameRules() && CSGameRules()->IsQueuedMatchmaking() && CSGameRules()->m_mapQueuedMatchmakingPlayersData.Count() )
	{
		CUtlVector< uint32 > arrConnectedHumans;
		for ( int i = 1; i <= gpGlobals->maxClients; ++i )
		{
			CCSPlayer *pHuman = dynamic_cast<CCSPlayer *>(UTIL_PlayerByIndex( i ));
			if ( pHuman )
			{
				uint32 uiAccountId = pHuman->GetHumanPlayerAccountID();
				if ( uiAccountId )
					arrConnectedHumans.AddToTail( uiAccountId );
			}
		}

		FOR_EACH_MAP( CSGameRules()->m_mapQueuedMatchmakingPlayersData, idxQueuedPlayer )
		{
			CCSGameRules::CQMMPlayerData_t &qmmPlayerData = * CSGameRules()->m_mapQueuedMatchmakingPlayersData.Element( idxQueuedPlayer );
			if ( arrConnectedHumans.Find( qmmPlayerData.m_uiPlayerAccountId ) != arrConnectedHumans.InvalidIndex() )
				continue;	// such human is already connected
			
			bool bThisPlayerIsFirstTeam = ( qmmPlayerData.m_iDraftIndex < 5 );
			bool bTeamsArePlayingSwitchedSides = CSGameRules() ? CSGameRules()->AreTeamsPlayingSwitchedSides() : false;

			// Force team according to queue reservation
			int nThisHumanTeam = ( bThisPlayerIsFirstTeam == !bTeamsArePlayingSwitchedSides ) ? TEAM_CT : TEAM_TERRORIST;
			if ( nThisHumanTeam != team )
				continue;

			// Otherwise let's take over this human!
			bot->SetHumanPlayerAccountID( qmmPlayerData.m_uiPlayerAccountId );
			engine->SetFakeClientConVarValue( bot->edict(), "name", CFmtStr( "BOT %u", qmmPlayerData.m_uiPlayerAccountId ).Access() );
		}
	}

	return true;
}

/**
 * Process the "bot_place" console command
 */
bool CCSBotManager::BotPlaceCommand( uint nTeamMask )
{
	static int lastBotPlaced = -1;

	int numBots = 0;	
	//Count the number of bots in the map.
	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
	{
		CCSBot *bot = dynamic_cast<CCSBot *>(UTIL_PlayerByIndex( i ));
		if ( NULL != bot )
		{
			numBots++;
		}
	}

	if ( numBots <= 0 )
	{
		Msg( "Error: bot_place needs at least one bot already in the map.\n" );
		return false;
	}

	// See which bot is the next one to be placed.
	int nextBotToPlace = (lastBotPlaced+1) % numBots;
	int botCount = 0;
	CCSPlayer *botToMove = NULL;
	for ( int i = 1; i <= gpGlobals->maxClients && botToMove == NULL; ++i )
	{
		CCSBot *bot = dynamic_cast<CCSBot *>(UTIL_PlayerByIndex( i ));
		if ( NULL != bot )
		{
			if ( nextBotToPlace == botCount )
			{
				if ( nTeamMask & ( 1u << bot->GetTeamNumber() ) )
				{
					botToMove = bot;
				}
				else
				{
					nextBotToPlace = ( nextBotToPlace + 1 ) % numBots;
				}
			}
			botCount++;
		}
	}
	lastBotPlaced = nextBotToPlace;

	CBasePlayer* localPlayer = UTIL_GetCommandClient();

	if ( NULL == localPlayer )
	{
		Msg( "Error: BotPlaceCommand() could not find a human player to move a bot to.\n" );
		return false;
	}
	if ( NULL == botToMove )
	{
		Msg( "Error: BotPlaceCommand() could not find a bot to move to player's location.\n" );
		return false;
	}

	Vector forward;
	localPlayer->EyeVectors( &forward, NULL, NULL );
	trace_t tr;
	UTIL_ClearTrace( tr );
	// trace forward from the eye
	Vector vEye = localPlayer->GetAbsOrigin() + localPlayer->GetViewOffset(), vTargetEye = vEye + ( forward * PLAYER_USE_RADIUS );
	UTIL_TraceLine( vEye, vTargetEye, CONTENTS_SOLID, localPlayer->GetRefEHandle().Get(), COLLISION_GROUP_NONE, &tr );
	if ( tr.DidHit() )
		vTargetEye = tr.endpos;

	UTIL_ClearTrace( tr );
	Vector vTargetOrigin = vTargetEye - localPlayer->GetViewOffset() - Vector( 0, 0, ( 0.03125 ) );
	UTIL_TraceLine( vTargetEye, vTargetOrigin, CONTENTS_SOLID, localPlayer->GetRefEHandle().Get(), COLLISION_GROUP_NONE, &tr );
	if ( tr.DidHit() )
	{
		vTargetOrigin = tr.endpos;
		vTargetOrigin.z += ( 0.03125 );
	}

	botToMove->SetAbsOrigin( vTargetOrigin  );

	return true;
}

int UTIL_CSSBotsInGame()
{
	int count = 0;

	for (int i = 1; i <= gpGlobals->maxClients; ++i )
	{
		CCSBot *player = dynamic_cast<CCSBot *>(UTIL_PlayerByIndex( i ));

		if ( player == NULL )
			continue;

		count++;
	}

	return count;
}

bool UTIL_CSSKickBotFromTeam( int kickTeam )
{
	int i;

	// try to kick a dead bot first
	for ( i = 1; i <= gpGlobals->maxClients; ++i )
	{
		CCSBot *player = dynamic_cast<CCSBot *>( UTIL_PlayerByIndex( i ) );

		if (player == NULL)
			continue;

		if (!player->IsAlive() && player->GetTeamNumber() == kickTeam)
		{
			// its a bot on the right team - kick it
			engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", engine->GetPlayerUserId( player->edict() ) ) );

			return true;
		}
	}

	// no dead bots, kick any bot on the given team
	for ( i = 1; i <= gpGlobals->maxClients; ++i )
	{
		CCSBot *player = dynamic_cast<CCSBot *>( UTIL_PlayerByIndex( i ) );

		if (player == NULL)
			continue;

		if (player->GetTeamNumber() == kickTeam)
		{
			// its a bot on the right team - kick it
			engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", engine->GetPlayerUserId( player->edict() ) ) );

			return true;
		}
	}

	return false;
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Keep a minimum quota of bots in the game
 */
void CCSBotManager::MaintainBotQuota( void )
{
	if ( !AreBotsAllowed() )
		return;

	if (TheNavMesh->IsGenerating())
		return;

	int totalHumansInGame = UTIL_HumansInGame();
	int humanPlayersInGame = UTIL_HumansInGame( IGNORE_SPECTATORS, IGNORE_UNASSIGNED );
	int spectatorPlayersInGame = UTIL_SpectatorsInGame();

	// don't add bots until local player has been registered, to make sure he's player ID #1
	if (!engine->IsDedicatedServer() && totalHumansInGame == 0)
		return;

	// new players can't spawn immediately after the round has been going for some time
	if ( !CSGameRules() || !TheCSBots() )
	{
		return;
	}

	int desiredBotCount = cv_bot_quota.GetInt();
	int botsInGame = UTIL_CSSBotsInGame();

	/// isRoundInProgress is true if the round has progressed far enough that new players will join as dead.
	bool isRoundInProgress = CSGameRules()->m_bFirstConnected &&
							 !TheCSBots()->IsRoundOver() &&
							 ( CSGameRules()->GetRoundElapsedTime() >= 20.0f );

	if ( FStrEq( cv_bot_quota_mode.GetString(), "fill" ) )
	{
		// If bot_quota_mode is 'fill', we want the number of bots and humans together to equal bot_quota
		// unless the round is already in progress, in which case we play with what we've been dealt
		// don't do this check in coop mission mode because we change the number every wave
		if ( !isRoundInProgress || CSGameRules()->IsPlayingCoopMission() )
		{
			desiredBotCount = MAX( 0, desiredBotCount - humanPlayersInGame + spectatorPlayersInGame );
		}
		else
		{
			desiredBotCount = botsInGame;
		}
	}
	else if ( FStrEq( cv_bot_quota_mode.GetString(), "match" ) )
	{
		// If bot_quota_mode is 'match', we want the number of bots to be bot_quota * total humans
		// unless the round is already in progress, in which case we play with what we've been dealt
		if ( !isRoundInProgress )
		{
			desiredBotCount = (int)MAX( 0, cv_bot_quota.GetFloat() * humanPlayersInGame );
		}
		else
		{
			desiredBotCount = botsInGame;
		}
	}

	// wait for a player to join, if necessary
	if (cv_bot_join_after_player.GetBool())
	{
		if ( humanPlayersInGame == 0 && spectatorPlayersInGame == 0 )
			desiredBotCount = 0;
	}

	// wait until the map has been loaded for a bit, to allow players to transition across
	// the transition without missing the pistol round
	if ( bot_join_delay.GetInt() > CSGameRules()->GetMapElapsedTime() )
	{
		desiredBotCount = 0;
	}

	// If the match is in warmup phase and we don't want any bots in warmup then don't have
	// the bots joining the match during warmup
	if ( !bot_join_in_warmup.GetBool() && CSGameRules()->IsWarmupPeriod() )
	{
		desiredBotCount = 0;
	}

	// if bots will auto-vacate, we need to keep one slot open to allow players to join
	if ( cv_bot_auto_vacate.GetBool() && !CSGameRules()->IsPlayingCoopMission() )
		desiredBotCount = MIN( desiredBotCount, gpGlobals->maxClients - (humanPlayersInGame + 1) );
	else
		desiredBotCount = MIN( desiredBotCount, gpGlobals->maxClients - humanPlayersInGame + spectatorPlayersInGame );

	// Try to balance teams, if we are in the first 20 seconds of a round and bots can join either team.
	if ( botsInGame > 0 && desiredBotCount == botsInGame && CSGameRules()->m_bFirstConnected )
	{
		if ( CSGameRules()->GetRoundElapsedTime() < 20.0f ) // new bots can still spawn during this time
		{
			if ( mp_autoteambalance.GetBool() )
			{
				int numAliveTerrorist;
				int numAliveCT;
				int numDeadTerrorist;
				int numDeadCT;
				CSGameRules()->InitializePlayerCounts( numAliveTerrorist, numAliveCT, numDeadTerrorist, numDeadCT );

				if ( !FStrEq( cv_bot_join_team.GetString(), "T" ) &&
					 !FStrEq( cv_bot_join_team.GetString(), "CT" ) )
				{
					if ( numAliveTerrorist > CSGameRules()->m_iNumCT + 1 )
					{
						if ( UTIL_KickBotFromTeam( TEAM_TERRORIST ) )
							return;
					}
					else if ( numAliveCT > CSGameRules()->m_iNumTerrorist + 1 )
					{
						if ( UTIL_KickBotFromTeam( TEAM_CT ) )
							return;
					}
				}
			}
		}
	}

	// add bots if necessary
	if (desiredBotCount > botsInGame)
	{
		// don't try to add a bot if all teams are full
		if ( !CSGameRules()->TeamFull( TEAM_TERRORIST ) || !CSGameRules()->TeamFull( TEAM_CT ) )
			TheCSBots()->BotAddCommand( TEAM_UNASSIGNED );
	}
	else if (desiredBotCount < botsInGame)
	{
		// kick a bot to maintain quota
		
		// first remove any unassigned bots
		if (UTIL_CSSKickBotFromTeam( TEAM_UNASSIGNED ))
			return;

		int kickTeam;

		CCSMatch* match = CSGameRules()->GetMatch();

		// remove from the team that has more players
		if (CSGameRules()->m_iNumTerrorist > CSGameRules()->m_iNumCT)
		{
			kickTeam = TEAM_TERRORIST;
		}
		else if (CSGameRules()->m_iNumTerrorist < CSGameRules()->m_iNumCT)
		{
			kickTeam = TEAM_CT;
		}

		// remove from the team that's winning				
		else if ( match && match->GetWinningTeam() == TEAM_TERRORIST )
		{
			kickTeam = TEAM_TERRORIST;
		}
		else if ( match && match->GetWinningTeam() == TEAM_CT )
		{
			kickTeam = TEAM_CT;
		}
		else
		{
			// teams and scores are equal, pick a team at random
			kickTeam = (RandomInt( 0, 1 ) == 0) ? TEAM_CT : TEAM_TERRORIST;
		}

		// attempt to kick a bot from the given team
		if (UTIL_CSSKickBotFromTeam( kickTeam ))
			return;

		// if there were no bots on the team, kick a bot from the other team
		if (kickTeam == TEAM_TERRORIST)
			UTIL_CSSKickBotFromTeam( TEAM_CT );
		else
			UTIL_CSSKickBotFromTeam( TEAM_TERRORIST );
	}
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Collect all nav areas that overlap the given zone
 */
class CollectOverlappingAreas
{
public:
	CollectOverlappingAreas( CCSBotManager::Zone *zone )
	{
		m_zone = zone;

		zone->m_areaCount = 0;
	}

	bool operator() ( CNavArea *area )
	{
		Extent areaExtent;
		area->GetExtent(&areaExtent);

		if (areaExtent.hi.x >= m_zone->m_extent.lo.x && areaExtent.lo.x <= m_zone->m_extent.hi.x &&
			areaExtent.hi.y >= m_zone->m_extent.lo.y && areaExtent.lo.y <= m_zone->m_extent.hi.y &&
			areaExtent.hi.z >= m_zone->m_extent.lo.z && areaExtent.lo.z <= m_zone->m_extent.hi.z)
		{
			// area overlaps m_zone
			m_zone->m_area[ m_zone->m_areaCount++ ] = area;
			if (m_zone->m_areaCount == CCSBotManager::MAX_ZONE_NAV_AREAS)
			{
				return false;
			}
		}

		return true;
	}

private:
	CCSBotManager::Zone *m_zone;
};


//--------------------------------------------------------------------------------------------------------------
/**
 * Search the map entities to determine the game scenario and define important zones.
 */
void CCSBotManager::ExtractScenarioData( void )
{
	if (!TheNavMesh->IsLoaded())
		return;

	m_zoneCount = 0;
	m_gameScenario = SCENARIO_DEATHMATCH;


	//
	// Search all entities in the map and set the game type and
	// store all zones (bomb target, etc).
	//
	CBaseEntity *entity;
	int i;
	for( i=1; i<gpGlobals->maxEntities; ++i )
	{
		entity = CBaseEntity::Instance( INDEXENT( i ) );

		if (entity == NULL)
			continue;

		bool found = false;
		bool isLegacy = false;

		if (FClassnameIs( entity, "func_bomb_target" ))
		{
			m_gameScenario = SCENARIO_DEFUSE_BOMB;
			found = true;
			isLegacy = false;
		}
		else if (FClassnameIs( entity, "info_bomb_target" ))
		{
			m_gameScenario = SCENARIO_DEFUSE_BOMB;
			found = true;
			isLegacy = true;
		}
		else if (FClassnameIs( entity, "func_hostage_rescue" ))
		{
			m_gameScenario = SCENARIO_RESCUE_HOSTAGES;
			found = true;
			isLegacy = false;
		}
		else if (FClassnameIs( entity, "info_hostage_rescue" ))
		{
			m_gameScenario = SCENARIO_RESCUE_HOSTAGES;
			found = true;
			isLegacy = true;
		}
		else if (FClassnameIs( entity, "hostage_entity" ))
		{
			// some very old maps (ie: cs_assault) use info_player_start
			// as rescue zones, so set the scenario if there are hostages
			// in the map
			m_gameScenario = SCENARIO_RESCUE_HOSTAGES;
		}
		else if (FClassnameIs( entity, "func_vip_safetyzone" ))
		{
			m_gameScenario = SCENARIO_ESCORT_VIP;
			found = true;
			isLegacy = false;
		}

		if (found)
		{
			if (m_zoneCount < MAX_ZONES)
			{
				Vector absmin, absmax;
				entity->CollisionProp()->WorldSpaceAABB( &absmin, &absmax );

				m_zone[ m_zoneCount ].m_isBlocked = false;
				m_zone[ m_zoneCount ].m_center = (isLegacy) ? entity->GetAbsOrigin() : (absmin + absmax)/2.0f;
				m_zone[ m_zoneCount ].m_isLegacy = isLegacy;
				m_zone[ m_zoneCount ].m_index = m_zoneCount;
				m_zone[ m_zoneCount++ ].m_entity = entity;
			}
			else
				Msg( "Warning: Too many zones, some will be ignored.\n" );
		}
	}

	//
	// If there are no zones and the scenario is hostage rescue,
	// use the info_player_start entities as rescue zones.
	//
	if (m_zoneCount == 0 && m_gameScenario == SCENARIO_RESCUE_HOSTAGES)
	{
		for( entity = gEntList.FindEntityByClassname( NULL, "info_player_start" );
			 entity && !FNullEnt( entity->edict() );
			 entity = gEntList.FindEntityByClassname( entity, "info_player_start" ) )
		{
			if (m_zoneCount < MAX_ZONES)
			{
				m_zone[ m_zoneCount ].m_isBlocked = false;
				m_zone[ m_zoneCount ].m_center = entity->GetAbsOrigin();
				m_zone[ m_zoneCount ].m_isLegacy = true;
				m_zone[ m_zoneCount ].m_index = m_zoneCount;
				m_zone[ m_zoneCount++ ].m_entity = entity;
			}
			else
			{
				Msg( "Warning: Too many zones, some will be ignored.\n" );
			}
		}
	}

	//
	// Collect nav areas that overlap each zone
	//
	for( i=0; i<m_zoneCount; ++i )
	{
		Zone *zone = &m_zone[i];

		if (zone->m_isLegacy)
		{
			const float legacyRange = 256.0f;
			zone->m_extent.lo.x = zone->m_center.x - legacyRange;
			zone->m_extent.lo.y = zone->m_center.y - legacyRange;
			zone->m_extent.lo.z = zone->m_center.z - legacyRange;
			zone->m_extent.hi.x = zone->m_center.x + legacyRange;
			zone->m_extent.hi.y = zone->m_center.y + legacyRange;
			zone->m_extent.hi.z = zone->m_center.z + legacyRange;
		}
		else
		{
			Vector absmin, absmax;
			zone->m_entity->CollisionProp()->WorldSpaceAABB( &absmin, &absmax );

			zone->m_extent.lo = absmin;
			zone->m_extent.hi = absmax;
		}

		// ensure Z overlap
		const float zFudge = 50.0f;
		zone->m_extent.lo.z -= zFudge;
		zone->m_extent.hi.z += zFudge;

		// build a list of nav areas that overlap this zone
		CollectOverlappingAreas collector( zone );
		TheNavMesh->ForAllAreas( collector );
	}
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Return the zone that contains the given position
 */
const CCSBotManager::Zone *CCSBotManager::GetZone( const Vector &pos ) const
{
	for( int z=0; z<m_zoneCount; ++z )
	{
		if (m_zone[z].m_extent.Contains( pos ))
		{
			return &m_zone[z];
		}
	}

	return NULL;
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Return the closest zone to the given position
 */
const CCSBotManager::Zone *CCSBotManager::GetClosestZone( const Vector &pos ) const
{
	const Zone *close = NULL;
	float closeRangeSq = 999999999.9f;

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

		float rangeSq = (m_zone[z].m_center - pos).LengthSqr();

		if (rangeSq < closeRangeSq)
		{
			closeRangeSq = rangeSq;
			close = &m_zone[z];
		}
	}

	return close;
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Return a random position inside the given zone
 */
const Vector *CCSBotManager::GetRandomPositionInZone( const Zone *zone ) const
{
	static Vector pos;

	if (zone == NULL)
		return NULL;

	if (zone->m_areaCount == 0)
		return NULL;

	// pick a random overlapping area
	CNavArea *area = GetRandomAreaInZone(zone);

	// pick a location inside both the nav area and the zone
	/// @todo Randomize this

	if (zone->m_isLegacy)
	{
		/// @todo It is possible that the radius might not overlap this area at all...
		area->GetClosestPointOnArea( zone->m_center, &pos );
	}
	else
	{
		Extent areaExtent;
		area->GetExtent(&areaExtent);
		Extent overlap;
		overlap.lo.x = MAX( areaExtent.lo.x, zone->m_extent.lo.x );
		overlap.lo.y = MAX( areaExtent.lo.y, zone->m_extent.lo.y );
		overlap.hi.x = MIN( areaExtent.hi.x, zone->m_extent.hi.x );
		overlap.hi.y = MIN( areaExtent.hi.y, zone->m_extent.hi.y );

		pos.x = (overlap.lo.x + overlap.hi.x)/2.0f;
		pos.y = (overlap.lo.y + overlap.hi.y)/2.0f;
		pos.z = area->GetZ( pos );
	}

	return &pos;
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Return a random area inside the given zone
 */
CNavArea *CCSBotManager::GetRandomAreaInZone( const Zone *zone ) const
{
	int areaCount = zone->m_areaCount;
	if( areaCount == 0 )
	{
		Assert( false && "CCSBotManager::GetRandomAreaInZone: No areas for this zone" );
		return NULL;
	}

	// Random, but weighted.  Jump areas score zero, since you aren't ever meant to stop on one of those.
	// Avoid areas score 1 to a normal area's 20 because pathfinding treats Avoid as a 20x penalty.
	int totalWeight = 0;
	for( int areaIndex = 0; areaIndex < areaCount; areaIndex++ )
	{
		CNavArea *currentArea = zone->m_area[areaIndex];
		if( currentArea->GetAttributes() & NAV_MESH_JUMP )
			totalWeight += 0;
		else if( currentArea->GetAttributes() & NAV_MESH_AVOID )
			totalWeight += 1;
		else
			totalWeight += 20;
	}

	if( totalWeight == 0 )
	{
		Assert( false && "CCSBotManager::GetRandomAreaInZone: No real areas for this zone" );
		return NULL;
	}

	int randomPick = RandomInt( 1, totalWeight );

	for( int areaIndex = 0; areaIndex < areaCount; areaIndex++ )
	{
		CNavArea *currentArea = zone->m_area[areaIndex];
		if( currentArea->GetAttributes() & NAV_MESH_JUMP )
			randomPick -= 0;
		else if( currentArea->GetAttributes() & NAV_MESH_AVOID )
			randomPick -= 1;
		else
			randomPick -= 20;

		if( randomPick <= 0 )
			return currentArea;
	}

	// Won't ever get here, but the compiler will cry without it.
	return zone->m_area[0];
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnServerShutdown( IGameEvent *event )
{
	if ( !engine->IsDedicatedServer() )
	{
		// Since we're a listenserver, save some config info for the next time we start up
		static const char *botVars[] =
		{
			"bot_quota",
			"bot_difficulty",
			"bot_chatter",
			"bot_prefix",
			"bot_join_team",
			"bot_defer_to_human_items",
			"bot_defer_to_human_goals",
#ifdef CS_SHIELD_ENABLED
			"bot_allow_shield",
#endif // CS_SHIELD_ENABLED
			"bot_join_after_player",
			"bot_allow_rogues",
			"bot_allow_pistols",
			"bot_allow_shotguns",
			"bot_allow_sub_machine_guns",
			"bot_allow_machine_guns",
			"bot_allow_rifles",
			"bot_allow_snipers",
			"bot_allow_grenades"
#if CS_CONTROLLABLE_BOTS_ENABLED
			"bot_controllable",
#endif	
		};
		
		KeyValues *data = new KeyValues( "ServerConfig" );

		// load the config data
		if (data)
		{
			data->LoadFromFile( filesystem, "ServerConfig.vdf", "GAME" );
			for ( int i=0; i<sizeof(botVars)/sizeof(botVars[0]); ++i )
			{
				const char *varName = botVars[i];
				if ( varName )
				{
					ConVar *var = cvar->FindVar( varName );
					if ( var )
					{
						data->SetString( varName, var->GetString() );
					}
				}
			}
			data->SaveToFile( filesystem, "ServerConfig.vdf", "GAME" );
			data->deleteThis();
		}
		return;
	}
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnPlayerFootstep( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnPlayerFootstep, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnPlayerRadio( IGameEvent *event )
{
	// if it's an Enemy Spotted radio, update our enemy spotted timestamp
	if ( event->GetInt( "slot" ) == RADIO_ENEMY_SPOTTED )
	{
		// to have some idea of when a human Player has seen an enemy
		SetLastSeenEnemyTimestamp();
	}

	CCSBOTMANAGER_ITERATE_BOTS( OnPlayerRadio, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnPlayerDeath( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnPlayerDeath, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnPlayerFallDamage( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnPlayerFallDamage, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnBombPickedUp( IGameEvent *event )
{
	// bomb no longer loose
	SetLooseBomb( NULL );

	CCSBOTMANAGER_ITERATE_BOTS( OnBombPickedUp, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnBombPlanted( IGameEvent *event )
{
	m_isBombPlanted = true;
	m_bombPlantTimestamp = gpGlobals->curtime;

	CCSBOTMANAGER_ITERATE_BOTS( OnBombPlanted, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnBombBeep( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnBombBeep, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnBombDefuseBegin( IGameEvent *event )
{
	m_bombDefuser = static_cast<CCSPlayer *>( UTIL_PlayerByUserId( event->GetInt( "userid" ) ) );

	CCSBOTMANAGER_ITERATE_BOTS( OnBombDefuseBegin, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnBombDefused( IGameEvent *event )
{
	m_isBombPlanted = false;
	m_bombDefuser = NULL;

	CCSBOTMANAGER_ITERATE_BOTS( OnBombDefused, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnBombDefuseAbort( IGameEvent *event )
{
	m_bombDefuser = NULL;

	CCSBOTMANAGER_ITERATE_BOTS( OnBombDefuseAbort, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnBombExploded( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnBombExploded, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnRoundEnd( IGameEvent *event )
{
	m_isRoundOver = true;

	CCSBOTMANAGER_ITERATE_BOTS( OnRoundEnd, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnRoundStart( IGameEvent *event )
{
	RestartRound();

	CCSBOTMANAGER_ITERATE_BOTS( OnRoundStart, event );
}


//--------------------------------------------------------------------------------------------------------------
static CBaseEntity * SelectSpawnSpot( const char *pEntClassName )
{
	CBaseEntity* pSpot = NULL;

	// Find the next spawn spot.
	pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );

	if ( pSpot == NULL ) // skip over the null point
		pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );

	CBaseEntity *pFirstSpot = pSpot;
	do 
	{
		if ( pSpot )
		{
			// check if pSpot is valid
			if ( pSpot->GetAbsOrigin() == Vector( 0, 0, 0 ) )
			{
				pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
				continue;
			}

			// if so, go to pSpot
			return pSpot;
		}
		// increment pSpot
		pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
	} while ( pSpot != pFirstSpot ); // loop if we're not back to the start

	return NULL;
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Pathfind from each zone to a spawn point to ensure it is valid.  Assumes that every spawn can pathfind to
 * every other spawn.
 */
void CCSBotManager::CheckForBlockedZones( void )
{
	CBaseEntity *pSpot = SelectSpawnSpot( "info_player_counterterrorist" );
	if ( !pSpot )
	{
		if ( CSGameRules()->IsPlayingCoopMission() )
		{
			pSpot = SelectSpawnSpot( "info_enemy_terrorist_spawn" );
		}
		else
		{
			pSpot = SelectSpawnSpot( "info_player_terrorist" );
		}
	}

	if ( !pSpot )
		return;

	Vector spawnPos = pSpot->GetAbsOrigin();
	CNavArea *spawnArea = TheNavMesh->GetNearestNavArea( spawnPos );
	if ( !spawnArea )
		return;

	ShortestPathCost costFunc;

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

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

		if ( cv_bot_debug.GetInt() == 5 )
		{
			if ( m_zone[i].m_isBlocked )
				DevMsg( "%.1f: Zone %d, area %d (%.0f %.0f %.0f) is blocked from spawn area %d (%.0f %.0f %.0f)\n",
					gpGlobals->curtime, i, m_zone[i].m_area[0]->GetID(),
					m_zone[i].m_area[0]->GetCenter().x, m_zone[i].m_area[0]->GetCenter().y, m_zone[i].m_area[0]->GetCenter().z,
					spawnArea->GetID(),
					spawnPos.x, spawnPos.y, spawnPos.z );
		}
	}
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnRoundFreezeEnd( IGameEvent *event )
{
	bool reenableEvents = m_NavBlockedEvent.IsEnabled();

	m_NavBlockedEvent.Enable( false ); // don't listen to nav_blocked events - there could be several, and we don't have bots pathing
	CUtlVector< CNavArea * >& transientAreas = TheNavMesh->GetTransientAreas();
	for ( int i=0; i<transientAreas.Count(); ++i )
	{
		CNavArea *area = transientAreas[i];
		if ( area->GetAttributes() & NAV_MESH_TRANSIENT )
		{
			area->UpdateBlocked();
		}
	}
	if ( reenableEvents )
	{
		m_NavBlockedEvent.Enable( true );
	}

	CheckForBlockedZones();
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnNavBlocked( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnNavBlocked, event );
	CheckForBlockedZones();
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnDoorMoving( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnDoorMoving, event );
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Check all nav areas inside the breakable's extent to see if players would now fall through
 */
class CheckAreasOverlappingBreakable
{
public:
	CheckAreasOverlappingBreakable( CBaseEntity *breakable )
	{
		m_breakable = breakable;
		ICollideable *collideable = breakable->GetCollideable();
		collideable->WorldSpaceSurroundingBounds( &m_breakableExtent.lo, &m_breakableExtent.hi );

		const float expand = 10.0f;
		m_breakableExtent.lo += Vector( -expand, -expand, -expand );
		m_breakableExtent.hi += Vector(  expand,  expand,  expand );
	}

	bool operator() ( CNavArea *area )
	{
		Extent areaExtent;
		area->GetExtent(&areaExtent);

		if (areaExtent.hi.x >= m_breakableExtent.lo.x && areaExtent.lo.x <= m_breakableExtent.hi.x &&
			areaExtent.hi.y >= m_breakableExtent.lo.y && areaExtent.lo.y <= m_breakableExtent.hi.y &&
			areaExtent.hi.z >= m_breakableExtent.lo.z && areaExtent.lo.z <= m_breakableExtent.hi.z)
		{
			// area overlaps the breakable
			area->CheckFloor( m_breakable );
		}

		return true;
	}

private:
	Extent m_breakableExtent;
	CBaseEntity *m_breakable;
};


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnBreakBreakable( IGameEvent *event )
{
	CBaseEntity *pEntity = UTIL_EntityByIndex( event->GetInt( "entindex" ) );

	AssertMsg( pEntity, "Bad Entity Index received" );

	if ( pEntity )
	{

		CheckAreasOverlappingBreakable collector( pEntity );
		TheNavMesh->ForAllAreas( collector );

		CCSBOTMANAGER_ITERATE_BOTS( OnBreakBreakable, event );
	}
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnBreakProp( IGameEvent *event )
{
	CBaseEntity *pEntity = UTIL_EntityByIndex( event->GetInt( "entindex" ) );

	AssertMsg( pEntity, "Bad Entity Index received" );

	if ( pEntity )
	{

		CheckAreasOverlappingBreakable collector( pEntity );
		TheNavMesh->ForAllAreas( collector );

		CCSBOTMANAGER_ITERATE_BOTS( OnBreakProp, event );
	}
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnHostageFollows( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnHostageFollows, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnHostageRescuedAll( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnHostageRescuedAll, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnWeaponFire( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnWeaponFire, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnWeaponFireOnEmpty( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnWeaponFireOnEmpty, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnWeaponReload( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnWeaponReload, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnWeaponZoom( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnWeaponZoom, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnBulletImpact( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnBulletImpact, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnHEGrenadeDetonate( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnHEGrenadeDetonate, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnFlashbangDetonate( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnFlashbangDetonate, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnSmokeGrenadeDetonate( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnSmokeGrenadeDetonate, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnMolotovDetonate( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnMolotovDetonate, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnDecoyDetonate( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnDecoyDetonate, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnDecoyFiring( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnDecoyFiring, event );
}


//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::OnGrenadeBounce( IGameEvent *event )
{
	CCSBOTMANAGER_ITERATE_BOTS( OnGrenadeBounce, event );
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Get the time remaining before the planted bomb explodes
 */
float CCSBotManager::GetBombTimeLeft( void ) const
{ 
	return (mp_c4timer.GetFloat() - (gpGlobals->curtime - m_bombPlantTimestamp));
}

//--------------------------------------------------------------------------------------------------------------
void CCSBotManager::SetLooseBomb( CBaseEntity *bomb )
{
	m_looseBomb = bomb;

	if (bomb)
	{
		m_looseBombArea = TheNavMesh->GetNearestNavArea( bomb->GetAbsOrigin() );
	}
	else
	{
		m_looseBombArea = NULL;
	}
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Return true if player is important to scenario (VIP, bomb carrier, etc)
 */
bool CCSBotManager::IsImportantPlayer( CCSPlayer *player ) const
{
	switch (GetScenario())
	{
		case SCENARIO_DEFUSE_BOMB:
		{
			if (player->GetTeamNumber() == TEAM_TERRORIST && player->HasC4())
				return true;

			/// @todo TEAM_CT's defusing the bomb are important

			return false;
		}

		case SCENARIO_ESCORT_VIP:
		{
			if (player->GetTeamNumber() == TEAM_CT && player->IsVIP())
				return true;

			return false;
		}

		case SCENARIO_RESCUE_HOSTAGES:
		{
			/// @todo TEAM_CT's escorting hostages are important
			return false;
		}
	}

	// everyone is equally important in a deathmatch
	return false;
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Return priority of player (0 = max pri)
 */
unsigned int CCSBotManager::GetPlayerPriority( CBasePlayer *player ) const
{
	const unsigned int lowestPriority = 0xFFFFFFFF;

	if (!player->IsPlayer())
		return lowestPriority;

	// human players have highest priority
	if (!player->IsBot())
		return 0;

	CCSBot *bot = dynamic_cast<CCSBot *>( player );

	if ( !bot )
		return 0;

	// bots doing something important for the current scenario have high priority
	switch (GetScenario())
	{
		case SCENARIO_DEFUSE_BOMB:
		{
			// the bomb carrier has high priority
			if (bot->GetTeamNumber() == TEAM_TERRORIST && bot->HasC4())
				return 1;

			break;
		}

		case SCENARIO_ESCORT_VIP:
		{
			// the VIP has high priority
			if (bot->GetTeamNumber() == TEAM_CT && bot->m_bIsVIP)
				return 1;

			break;
		}

		case SCENARIO_RESCUE_HOSTAGES:
		{
			// TEAM_CT's rescuing hostages have high priority
			if (bot->GetTeamNumber() == TEAM_CT && bot->GetHostageEscortCount())
				return 1;

			break;
		}
	}

	// everyone else is ranked by their unique ID (which cannot be zero)
	return 1 + bot->GetID();
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Returns a random spawn point for the given team (no arg means use both team spawnpoints)
 */
CBaseEntity *CCSBotManager::GetRandomSpawn( int team ) const
{
	CUtlVector< CBaseEntity * > spawnSet;
	CBaseEntity *spot;

	if (team == TEAM_TERRORIST || team == TEAM_MAXCOUNT)
	{
		const char* szTSpawnEntName = "info_player_terrorist";
		if ( CSGameRules()->IsPlayingCoopMission() )
			szTSpawnEntName = "info_enemy_terrorist_spawn";

		// collect T spawns
		for( spot = gEntList.FindEntityByClassname( NULL, szTSpawnEntName );
			 spot;
			 spot = gEntList.FindEntityByClassname( spot, szTSpawnEntName ) )
		{
			spawnSet.AddToTail( spot );			
		}
	}

	if (team == TEAM_CT || team == TEAM_MAXCOUNT)
	{
		// collect CT spawns
		for( spot = gEntList.FindEntityByClassname( NULL, "info_player_counterterrorist" );
			 spot;
			 spot = gEntList.FindEntityByClassname( spot, "info_player_counterterrorist" ) )
		{
			spawnSet.AddToTail( spot );			
		}
	}

	if (spawnSet.Count() == 0)
	{
		return NULL;
	}

	// select one at random
	int which = RandomInt( 0, spawnSet.Count()-1 );
	return spawnSet[ which ];
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Return the last time the given radio message was sent for given team
 * 'teamID' can be TEAM_CT or TEAM_TERRORIST
 */
float CCSBotManager::GetRadioMessageTimestamp( RadioType event, int teamID ) const
{
	int i = (teamID == TEAM_TERRORIST) ? 0 : 1;

	if (event > RADIO_START_1 && event < RADIO_END)
		return m_radioMsgTimestamp[ event - RADIO_START_1 ][ i ];

	return 0.0f;
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Return the interval since the last time this message was sent
 */
float CCSBotManager::GetRadioMessageInterval( RadioType event, int teamID ) const
{
	int i = (teamID == TEAM_TERRORIST) ? 0 : 1;

	if (event > RADIO_START_1 && event < RADIO_END)
		return gpGlobals->curtime - m_radioMsgTimestamp[ event - RADIO_START_1 ][ i ];

	return 99999999.9f;
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Set the given radio message timestamp.
 * 'teamID' can be TEAM_CT or TEAM_TERRORIST
 */
void CCSBotManager::SetRadioMessageTimestamp( RadioType event, int teamID )
{
	int i = (teamID == TEAM_TERRORIST) ? 0 : 1;

	if (event > RADIO_START_1 && event < RADIO_END)
		m_radioMsgTimestamp[ event - RADIO_START_1 ][ i ] = gpGlobals->curtime;
}

//--------------------------------------------------------------------------------------------------------------
/**
 * Reset all radio message timestamps
 */
void CCSBotManager::ResetRadioMessageTimestamps( void )
{
	for( int t=0; t<2; ++t )
	{
		for( int m=0; m<(RADIO_END - RADIO_START_1); ++m )
			m_radioMsgTimestamp[ m ][ t ] = 0.0f;
	}
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Display nav areas as they become reachable by each team
 */
void DrawOccupyTime( void )
{
	FOR_EACH_VEC( TheNavAreas, it )
	{
		CNavArea *area = TheNavAreas[ it ];

		int r, g, b;
		
		if (TheCSBots()->GetElapsedRoundTime() > area->GetEarliestOccupyTime( TEAM_TERRORIST ))
		{
			if (TheCSBots()->GetElapsedRoundTime() > area->GetEarliestOccupyTime( TEAM_CT ))
			{
				r = 255; g = 0; b = 255;
			}
			else
			{
				r = 255; g = 0; b = 0;
			}
		}
		else if (TheCSBots()->GetElapsedRoundTime() > area->GetEarliestOccupyTime( TEAM_CT ))
		{
			r = 0; g = 0; b = 255;
		}
		else
		{
			continue;
		}

		const Vector &nw = area->GetCorner( NORTH_WEST );
		const Vector &ne = area->GetCorner( NORTH_EAST );
		const Vector &sw = area->GetCorner( SOUTH_WEST );
		const Vector &se = area->GetCorner( SOUTH_EAST );

		NDebugOverlay::Line( nw, ne, r, g, b, true, 0.1f );		
		NDebugOverlay::Line( nw, sw, r, g, b, true, 0.1f );		
		NDebugOverlay::Line( se, sw, r, g, b, true, 0.1f );		
		NDebugOverlay::Line( se, ne, r, g, b, true, 0.1f );		
	}
}


//--------------------------------------------------------------------------------------------------------------
/**
 * Display areas where players will likely have initial battles
 */
void DrawBattlefront( void )
{
	const float epsilon = 1.0f;
	int r = 255, g = 50, b = 0;
	
	FOR_EACH_VEC( TheNavAreas, it )
	{
		CNavArea *area = TheNavAreas[ it ];

		if ( fabs(area->GetEarliestOccupyTime( TEAM_TERRORIST ) - area->GetEarliestOccupyTime( TEAM_CT )) > epsilon )
		{
			continue;
		}


		const Vector &nw = area->GetCorner( NORTH_WEST );
		const Vector &ne = area->GetCorner( NORTH_EAST );
		const Vector &sw = area->GetCorner( SOUTH_WEST );
		const Vector &se = area->GetCorner( SOUTH_EAST );

		NDebugOverlay::Line( nw, ne, r, g, b, true, 0.1f );		
		NDebugOverlay::Line( nw, sw, r, g, b, true, 0.1f );		
		NDebugOverlay::Line( se, sw, r, g, b, true, 0.1f );		
		NDebugOverlay::Line( se, ne, r, g, b, true, 0.1f );		
	}
}

//--------------------------------------------------------------------------------------------------------------
static bool CheckAreaAgainstAllZoneAreas(CNavArea *queryArea)
{
	// A marked area means they just want to double check this one spot
	int goalZoneCount = TheCSBots()->GetZoneCount();

	for( int zoneIndex = 0; zoneIndex < goalZoneCount; zoneIndex++ )
	{
		const CCSBotManager::Zone *currentZone = TheCSBots()->GetZone(zoneIndex);

		int zoneAreaCount = currentZone->m_areaCount;
		for( int areaIndex = 0; areaIndex < zoneAreaCount; areaIndex++ )
		{
			CNavArea *zoneArea = currentZone->m_area[areaIndex];
			// We need to be connected to every area in the zone, since we don't know what other code might pick for an area
			ShortestPathCost cost;
			if( NavAreaTravelDistance(queryArea, zoneArea, cost) == -1.0f )
			{
				Msg( "Area #%d is disconnected from goal area #%d.\n", 
					queryArea->GetID(), 
					zoneArea->GetID()
					);
				return false;
			}
		}

	}
	return true;
}

CON_COMMAND_F( nav_check_connectivity, "Checks to be sure every (or just the marked) nav area can get to every goal area for the map (hostages or bomb site).", FCVAR_CHEAT )
{
	//Nav command in here since very CS specific.

	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	if ( TheNavMesh->GetMarkedArea() )
	{
		CNavArea *markedArea = TheNavMesh->GetMarkedArea();
		bool fine = CheckAreaAgainstAllZoneAreas( markedArea );
		if( fine )
		{
			Msg( "Area #%d is connected to all goal areas.\n", markedArea->GetID() );
		}
	}
	else
	{
		// Otherwise, loop through every area, and make sure they can all get to the goal.
		float start = Plat_FloatTime();
		FOR_EACH_VEC( TheNavAreas, nit )
		{
			CheckAreaAgainstAllZoneAreas(TheNavAreas[ nit ]);
		}

		float end = Plat_FloatTime();
		float time = (end - start) * 1000.0f;
		Msg( "nav_check_connectivity took %2.2f ms\n", time );
	}
}