1HEADmaster

1 files changed, 872 insertions, 0 deletions

diff --git a/game/server/tf/bot/tf_bot_manager.cpp b/game/server/tf/bot/tf_bot_manager.cpp
new file mode 100644
index 0000000..6ead184
--- /dev/null
+++ b/game/server/tf/bot/tf_bot_manager.cpp
@@ -0,0 +1,872 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//----------------------------------------------------------------------------------------------------------------
+// tf_bot_manager.cpp
+// Team Fortress NextBotManager
+// Tom Bui, February 2010
+//----------------------------------------------------------------------------------------------------------------
+
+#include "cbase.h"
+#include "tf_bot_manager.h"
+
+#include "Player/NextBotPlayer.h"
+#include "team.h"
+#include "tf_bot.h"
+#include "tf_gamerules.h"
+#include "bot/map_entities/tf_bot_hint.h"
+#include "bot/map_entities/tf_bot_hint_sentrygun.h"
+#include "bot/map_entities/tf_bot_hint_teleporter_exit.h"
+
+
+//----------------------------------------------------------------------------------------------------------------
+
+// Creates and sets CTFBotManager as the NextBotManager singleton
+static CTFBotManager sTFBotManager;
+
+extern ConVar tf_bot_force_class;
+ConVar tf_bot_difficulty( "tf_bot_difficulty", "1", FCVAR_NONE, "Defines the skill of bots joining the game.  Values are: 0=easy, 1=normal, 2=hard, 3=expert." );
+ConVar tf_bot_quota( "tf_bot_quota", "0", FCVAR_NONE, "Determines the total number of tf bots in the game." );
+ConVar tf_bot_quota_mode( "tf_bot_quota_mode", "normal", FCVAR_NONE, "Determines the type of quota.\nAllowed values: 'normal', 'fill', and 'match'.\nIf 'fill', the server will adjust bots to keep N players in the game, where N is bot_quota.\nIf 'match', the server will maintain a 1:N ratio of humans to bots, where N is bot_quota." );
+ConVar tf_bot_join_after_player( "tf_bot_join_after_player", "1", FCVAR_NONE, "If nonzero, bots wait until a player joins before entering the game." );
+ConVar tf_bot_auto_vacate( "tf_bot_auto_vacate", "1", FCVAR_NONE, "If nonzero, bots will automatically leave to make room for human players." );
+ConVar tf_bot_offline_practice( "tf_bot_offline_practice", "0", FCVAR_NONE, "Tells the server that it is in offline practice mode." );
+ConVar tf_bot_melee_only( "tf_bot_melee_only", "0", FCVAR_GAMEDLL, "If nonzero, TFBots will only use melee weapons" );
+
+extern const char *GetRandomBotName( void );
+extern void CreateBotName( int iTeam, int iClassIndex, CTFBot::DifficultyType skill, char* pBuffer, int iBufferSize );
+
+static bool UTIL_KickBotFromTeam( int kickTeam )
+{
+	int i;
+
+	// try to kick a dead bot first
+	for ( i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
+		CTFBot* pBot = dynamic_cast<CTFBot*>(pPlayer);
+
+		if (pBot == NULL)
+			continue;
+
+		if ( pBot->HasAttribute( CTFBot::QUOTA_MANANGED ) == false )
+			continue;
+
+		if ( ( pPlayer->GetFlags() & FL_FAKECLIENT ) == 0 )
+			continue;
+
+		if ( !pPlayer->IsAlive() && pPlayer->GetTeamNumber() == kickTeam )
+		{
+			// its a bot on the right team - kick it
+			engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", pPlayer->GetUserID() ) );
+
+			return true;
+		}
+	}
+
+	// no dead bots, kick any bot on the given team
+	for ( i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
+		CTFBot* pBot = dynamic_cast<CTFBot*>(pPlayer);
+
+		if (pBot == NULL)
+			continue;
+
+		if ( pBot->HasAttribute( CTFBot::QUOTA_MANANGED ) == false )
+			continue;
+
+		if ( ( pPlayer->GetFlags() & FL_FAKECLIENT ) == 0 )
+			continue;
+
+		if (pPlayer->GetTeamNumber() == kickTeam)
+		{
+			// its a bot on the right team - kick it
+			engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", pPlayer->GetUserID() ) );
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+//----------------------------------------------------------------------------------------------------------------
+
+CTFBotManager::CTFBotManager()
+	: NextBotManager()
+	, m_flNextPeriodicThink( 0 )
+{
+	NextBotManager::SetInstance( this );
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+CTFBotManager::~CTFBotManager()
+{
+	NextBotManager::SetInstance( NULL );
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::OnMapLoaded( void )
+{
+	NextBotManager::OnMapLoaded();
+
+	ClearStuckBotData();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::OnRoundRestart( void )
+{
+	NextBotManager::OnRoundRestart();
+
+	// clear all hint ownership
+	CTFBotHint *hint = NULL;
+	while( ( hint = (CTFBotHint *)( gEntList.FindEntityByClassname( hint, "func_tfbot_hint" ) ) ) != NULL )
+	{
+		hint->SetOwnerEntity( NULL );
+	}
+
+	CTFBotHintSentrygun *sentryHint = NULL;
+	while( ( sentryHint = (CTFBotHintSentrygun *)( gEntList.FindEntityByClassname( sentryHint, "bot_hint_sentrygun" ) ) ) != NULL )
+	{
+		sentryHint->SetOwnerEntity( NULL );
+	}
+
+	CTFBotHintTeleporterExit *teleporterHint = NULL;
+	while( ( teleporterHint = (CTFBotHintTeleporterExit *)( gEntList.FindEntityByClassname( teleporterHint, "bot_hint_teleporter_exit" ) ) ) != NULL )
+	{
+		teleporterHint->SetOwnerEntity( NULL );
+	}
+
+
+#ifdef TF_CREEP_MODE
+	m_creepExperience[ TF_TEAM_RED ] = 0;
+	m_creepExperience[ TF_TEAM_BLUE ] = 0;
+#endif
+
+	m_isMedeivalBossScenarioSetup = false;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::Update()
+{
+	MaintainBotQuota();
+
+	DrawStuckBotData();
+
+#ifdef TF_CREEP_MODE
+	UpdateCreepWaves();
+#endif
+
+	NextBotManager::Update();
+}
+
+
+#ifdef TF_CREEP_MODE
+ConVar tf_creep_initial_delay( "tf_creep_initial_delay", "30" );
+ConVar tf_creep_wave_interval( "tf_creep_wave_interval", "30" );
+ConVar tf_creep_wave_count( "tf_creep_wave_count", "3" );
+ConVar tf_creep_class( "tf_creep_class", "heavyweapons" );
+ConVar tf_creep_level_up( "tf_creep_level_up", "6" );
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::UpdateCreepWaves()
+{
+	if ( !TFGameRules()->IsCreepWaveMode() )
+		return;
+
+	if ( TFGameRules()->RoundHasBeenWon() )
+	{
+		// no more creep waves - game is over
+		return;
+	}
+
+	if ( TFGameRules()->InSetup() || TFGameRules()->State_Get() == GR_STATE_STARTGAME || TFGameRules()->State_Get() == GR_STATE_PREROUND )
+	{
+		// no creeps at start of round
+		m_creepWaveTimer.Start( tf_creep_initial_delay.GetFloat() );
+
+		// delete all creeps
+		for( int i=1; i<=gpGlobals->maxClients; ++i )
+		{
+			CBasePlayer *player = static_cast< CBasePlayer * >( UTIL_PlayerByIndex( i ) );
+
+			if ( !player )
+				continue;
+
+			if ( FNullEnt( player->edict() ) )
+				continue;
+
+			CTFBot *creep = ToTFBot( player );
+			if ( !creep || !creep->HasAttribute( CTFBot::IS_NPC ) )
+				continue;
+
+			engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", player->GetUserID() ) );
+		}
+
+		return;
+	}	
+
+	if ( m_creepWaveTimer.IsElapsed() )
+	{
+		m_creepWaveTimer.Start( tf_creep_wave_interval.GetFloat() );
+
+		SpawnCreepWave( TF_TEAM_RED );
+		SpawnCreepWave( TF_TEAM_BLUE );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::SpawnCreepWave( int team )
+{
+	CTFBotSquad *squad = new CTFBotSquad;
+
+	for( int i=0; i<tf_creep_wave_count.GetInt(); ++i )
+	{
+		SpawnCreep( team, squad );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::SpawnCreep( int team, CTFBotSquad *squad )
+{
+	CTFBot *bot = NextBotCreatePlayerBot< CTFBot >( "Creep" );
+
+	if ( !bot ) 
+		return;
+
+	bot->SetAttribute( CTFBot::IS_NPC );
+	bot->HandleCommand_JoinTeam( team == TF_TEAM_RED ? "red" : "blue" );
+	bot->SetDifficulty( CTFBot::NORMAL );
+	bot->HandleCommand_JoinClass( tf_creep_class.GetString() );
+	bot->JoinSquad( squad );
+	bot->AddGlowEffect();
+	//BotGenerateAndWearItem( bot, "Honest Halo" );
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::OnCreepKilled( CTFPlayer *killer )
+{
+	CTFBot *bot = ToTFBot( killer );
+	if ( bot && bot->HasAttribute( CTFBot::IS_NPC ) )
+		return;
+
+	++m_creepExperience[ killer->GetTeamNumber() ];
+
+/*
+	int xp = m_creepExperience[ killer->GetTeamNumber() ];
+	int level = xp / tf_creep_level_up.GetInt();
+	int left = xp % tf_creep_level_up.GetInt();
+
+	char text[256];
+	Q_snprintf( text, sizeof(text), "%s killed a creep. %s team LVL = %d+%d/%d\n", 
+				killer->GetPlayerName(), 
+				killer->GetTeamNumber() == TF_TEAM_RED ? "Red" : "Blue", 
+				level+1, left, tf_creep_level_up.GetInt() );
+
+	UTIL_ClientPrintAll( HUD_PRINTTALK, text );
+*/
+
+	UTIL_ClientPrintAll( HUD_PRINTTALK, "%s killed a creep" );
+}
+
+#endif // TF_CREEP_MODE
+
+//----------------------------------------------------------------------------------------------------------------
+bool CTFBotManager::RemoveBotFromTeamAndKick( int nTeam )
+{
+	CUtlVector< CTFPlayer* > vecCandidates;
+
+	// Gather potential candidates
+	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
+
+		if ( pPlayer == NULL )
+			continue;
+
+		if ( FNullEnt( pPlayer->edict() ) )
+			continue;
+
+		if ( !pPlayer->IsConnected() )
+			continue;
+
+		CTFBot* pBot = dynamic_cast<CTFBot*>( pPlayer );
+		if ( pBot && pBot->HasAttribute( CTFBot::QUOTA_MANANGED ) )
+		{
+			if ( pBot->GetTeamNumber() == nTeam )
+			{
+				vecCandidates.AddToTail( pPlayer );
+			}
+		}
+	}
+	
+	CTFPlayer *pVictim = NULL;
+	if ( vecCandidates.Count() > 0 )
+	{
+		// first look for bots that are currently dead
+		FOR_EACH_VEC( vecCandidates, i )
+		{
+			CTFPlayer *pPlayer = vecCandidates[i];
+			if ( pPlayer && !pPlayer->IsAlive() )
+			{
+				pVictim = pPlayer;
+				break;
+			}
+		}
+
+		// if we didn't fine one, try to kick anyone on the team
+		if ( !pVictim )
+		{
+			FOR_EACH_VEC( vecCandidates, i )
+			{
+				CTFPlayer *pPlayer = vecCandidates[i];
+				if ( pPlayer )
+				{
+					pVictim = pPlayer;
+					break;
+				}
+			}
+		}
+	}
+
+	if ( pVictim )
+	{
+		if ( pVictim->IsAlive() )
+		{
+			pVictim->CommitSuicide();
+		}
+		pVictim->ForceChangeTeam( TEAM_UNASSIGNED ); // skipping TEAM_SPECTATOR because some servers don't allow spectators
+		UTIL_KickBotFromTeam( TEAM_UNASSIGNED );
+		return true;
+	}
+
+	return false;
+}
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::MaintainBotQuota()
+{
+	if ( TheNavMesh->IsGenerating() )
+		return;
+
+	if ( g_fGameOver )
+		return;
+
+	// new players can't spawn immediately after the round has been going for some time
+	if ( !TFGameRules() )
+		return;
+
+	// training mode controls the bots
+	if ( TFGameRules()->IsInTraining() )
+		return;
+
+	// if it is not time to do anything...
+	if ( gpGlobals->curtime < m_flNextPeriodicThink )
+		return;
+
+	// think every quarter second
+	m_flNextPeriodicThink = gpGlobals->curtime + 0.25f;
+
+	// don't add bots until local player has been registered, to make sure he's player ID #1
+	if ( !engine->IsDedicatedServer() )
+	{
+		CBasePlayer *pPlayer = UTIL_GetListenServerHost();
+		if ( !pPlayer )
+			return;
+	}
+
+	// We want to balance based on who's playing on game teams not necessary who's on team spectator, etc.
+	int nConnectedClients = 0;
+	int nTFBots = 0;
+	int nTFBotsOnGameTeams = 0;
+	int nNonTFBotsOnGameTeams = 0;
+	int nSpectators = 0;
+	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
+
+		if ( pPlayer == NULL )
+			continue;
+
+		if ( FNullEnt( pPlayer->edict() ) )
+			continue;
+
+		if ( !pPlayer->IsConnected() )
+			continue;
+
+		CTFBot* pBot = dynamic_cast<CTFBot*>( pPlayer );
+		if ( pBot && pBot->HasAttribute( CTFBot::QUOTA_MANANGED ) )
+		{
+			nTFBots++;
+			if ( pPlayer->GetTeamNumber() == TF_TEAM_RED || pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
+			{
+				nTFBotsOnGameTeams++;
+			}
+		}
+		else
+		{
+			if ( pPlayer->GetTeamNumber() == TF_TEAM_RED || pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
+			{
+				nNonTFBotsOnGameTeams++;
+			}
+			else if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR )
+			{
+				nSpectators++;
+			}
+		}
+
+		nConnectedClients++;
+	}
+
+	int desiredBotCount = tf_bot_quota.GetInt();
+	int nTotalNonTFBots = nConnectedClients - nTFBots;
+
+	if ( FStrEq( tf_bot_quota_mode.GetString(), "fill" ) )
+	{
+		desiredBotCount = MAX( 0, desiredBotCount - nNonTFBotsOnGameTeams );
+	}
+	else if ( FStrEq( tf_bot_quota_mode.GetString(), "match" ) )
+	{
+		// If bot_quota_mode is 'match', we want the number of bots to be bot_quota * total humans
+		desiredBotCount = (int)MAX( 0, tf_bot_quota.GetFloat() * nNonTFBotsOnGameTeams );
+	}
+
+	// wait for a player to join, if necessary
+	if ( tf_bot_join_after_player.GetBool() )
+	{
+		if ( ( nNonTFBotsOnGameTeams == 0 ) && ( nSpectators == 0 ) )
+		{
+			desiredBotCount = 0;
+		}
+	}
+
+	// if bots will auto-vacate, we need to keep one slot open to allow players to join
+	if ( tf_bot_auto_vacate.GetBool() )
+	{
+		desiredBotCount = MIN( desiredBotCount, gpGlobals->maxClients - nTotalNonTFBots - 1 );
+	}
+	else
+	{
+		desiredBotCount = MIN( desiredBotCount, gpGlobals->maxClients - nTotalNonTFBots );
+	}
+
+	// add bots if necessary
+	if ( desiredBotCount > nTFBotsOnGameTeams )
+	{
+		// don't try to add a bot if it would unbalance
+		if ( !TFGameRules()->WouldChangeUnbalanceTeams( TF_TEAM_BLUE, TEAM_UNASSIGNED ) ||
+			 !TFGameRules()->WouldChangeUnbalanceTeams( TF_TEAM_RED, TEAM_UNASSIGNED ) )
+		{
+			CTFBot *pBot = GetAvailableBotFromPool();
+			if ( pBot == NULL )
+			{
+				pBot = NextBotCreatePlayerBot< CTFBot >( GetRandomBotName() );
+			}
+			if ( pBot )
+			{
+				pBot->SetAttribute( CTFBot::QUOTA_MANANGED );
+
+				// join a team before we pick our class, since we use our teammates to decide what class to be
+				pBot->HandleCommand_JoinTeam( "auto" );
+
+				const char *classname = FStrEq( tf_bot_force_class.GetString(), "" ) ? pBot->GetNextSpawnClassname() : tf_bot_force_class.GetString();
+				pBot->HandleCommand_JoinClass( classname );
+
+				// give the bot a proper name
+				char name[256];
+				CTFBot::DifficultyType skill = pBot->GetDifficulty();
+				CreateBotName( pBot->GetTeamNumber(), pBot->GetPlayerClass()->GetClassIndex(), skill, name, sizeof( name ) );
+				engine->SetFakeClientConVarValue( pBot->edict(), "name", name );
+				
+				// Keep track of any bots we add during a match
+				CMatchInfo *pMatchInfo = GTFGCClientSystem()->GetMatch();
+				if ( pMatchInfo )
+				{
+					pMatchInfo->m_nBotsAdded++;
+				}
+			}
+		}
+	}
+	else if ( desiredBotCount < nTFBotsOnGameTeams )
+	{
+		// kick a bot to maintain quota
+		
+		// first remove any unassigned bots
+		if ( UTIL_KickBotFromTeam( TEAM_UNASSIGNED ) )
+			return;
+
+		int kickTeam;
+
+		CTeam *pRed = GetGlobalTeam( TF_TEAM_RED );
+		CTeam *pBlue = GetGlobalTeam( TF_TEAM_BLUE );
+
+		// remove from the team that has more players
+		if ( pBlue->GetNumPlayers() > pRed->GetNumPlayers() )
+		{
+			kickTeam = TF_TEAM_BLUE;
+		}
+		else if ( pBlue->GetNumPlayers() < pRed->GetNumPlayers() )
+		{
+			kickTeam = TF_TEAM_RED;
+		}
+		// remove from the team that's winning
+		else if ( pBlue->GetScore() > pRed->GetScore() )
+		{
+			kickTeam = TF_TEAM_BLUE;
+		}
+		else if ( pBlue->GetScore() < pRed->GetScore() )
+		{
+			kickTeam = TF_TEAM_RED;
+		}
+		else
+		{
+			// teams and scores are equal, pick a team at random
+			kickTeam = (RandomInt( 0, 1 ) == 0) ? TF_TEAM_BLUE : TF_TEAM_RED;
+		}
+
+		// attempt to kick a bot from the given team
+		if ( UTIL_KickBotFromTeam( kickTeam ) )
+			return;
+
+		// if there were no bots on the team, kick a bot from the other team
+		UTIL_KickBotFromTeam( kickTeam == TF_TEAM_BLUE ? TF_TEAM_RED : TF_TEAM_BLUE );
+	}
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+bool CTFBotManager::IsAllBotTeam( int iTeam )
+{
+	CTeam *pTeam = GetGlobalTeam( iTeam );
+	if ( pTeam == NULL )
+	{
+		return false;
+	}
+
+	// check to see if any players on the team are humans
+	for ( int i = 0, n = pTeam->GetNumPlayers(); i < n; ++i )
+	{
+		CTFPlayer *pPlayer = ToTFPlayer( pTeam->GetPlayer( i ) );
+		if ( pPlayer == NULL )
+		{
+			continue;
+		}
+		if ( pPlayer->IsBot() == false )
+		{
+			return false;
+		}
+	}
+
+	// if we made it this far, then they must all be bots!
+	if ( pTeam->GetNumPlayers() != 0 )
+	{
+		return true;
+	}
+
+	// okay, this is a bit trickier...
+	// if there are no people on this team, then we need to check the "assigned" human team
+	return TFGameRules()->GetAssignedHumanTeam() != iTeam;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::SetIsInOfflinePractice(bool bIsInOfflinePractice)
+{
+	tf_bot_offline_practice.SetValue( bIsInOfflinePractice ? 1 : 0 );
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+bool CTFBotManager::IsInOfflinePractice() const
+{
+	return tf_bot_offline_practice.GetInt() != 0;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+bool CTFBotManager::IsMeleeOnly() const
+{
+	return tf_bot_melee_only.GetBool();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::RevertOfflinePracticeConvars()
+{
+	tf_bot_quota.Revert();
+	tf_bot_quota_mode.Revert();
+	tf_bot_auto_vacate.Revert();
+	tf_bot_difficulty.Revert();
+	tf_bot_offline_practice.Revert();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::LevelShutdown()
+{
+	m_flNextPeriodicThink = 0.0f;
+	if ( IsInOfflinePractice() )
+	{
+		RevertOfflinePracticeConvars();
+		SetIsInOfflinePractice( false );
+	}		
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+CTFBot* CTFBotManager::GetAvailableBotFromPool()
+{
+	for ( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
+		CTFBot* pBot = dynamic_cast<CTFBot*>(pPlayer);
+
+		if (pBot == NULL)
+			continue;
+
+		if ( ( pBot->GetFlags() & FL_FAKECLIENT ) == 0 )
+			continue;
+
+		if ( pBot->GetTeamNumber() == TEAM_SPECTATOR || pBot->GetTeamNumber() == TEAM_UNASSIGNED )
+		{
+			pBot->ClearAttribute( CTFBot::QUOTA_MANANGED );
+			return pBot;
+		}
+	}
+	return NULL;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::OnForceAddedBots( int iNumAdded )
+{
+	tf_bot_quota.SetValue( tf_bot_quota.GetInt() + iNumAdded );
+	m_flNextPeriodicThink = gpGlobals->curtime + 1.0f;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::OnForceKickedBots( int iNumKicked )
+{
+	tf_bot_quota.SetValue( MAX( tf_bot_quota.GetInt() - iNumKicked, 0 ) );
+	// allow time for the bots to be kicked
+	m_flNextPeriodicThink = gpGlobals->curtime + 2.0f;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+CTFBotManager &TheTFBots( void )
+{
+	return static_cast<CTFBotManager&>( TheNextBots() );
+}
+
+
+
+//----------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( tf_bot_debug_stuck_log, "Given a server logfile, visually display bot stuck locations.", FCVAR_GAMEDLL | FCVAR_CHEAT )
+{
+	// Listenserver host or rcon access only!
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	if ( args.ArgC() < 2 )
+	{
+		DevMsg( "%s <logfilename>\n", args.Arg(0) );
+		return;
+	}
+
+	FileHandle_t file = filesystem->Open( args.Arg(1), "r", "GAME" );
+
+	const int maxBufferSize = 1024;
+	char buffer[ maxBufferSize ];
+
+	char logMapName[ maxBufferSize ];
+	logMapName[0] = '\000';
+
+	TheTFBots().ClearStuckBotData();
+
+	if ( file )
+	{
+		int line = 0;
+		while( !filesystem->EndOfFile( file ) )
+		{
+			filesystem->ReadLine( buffer, maxBufferSize, file );
+			++line;
+
+			strtok( buffer, ":" );
+			strtok( NULL, ":" );
+			strtok( NULL, ":" );
+			char *first = strtok( NULL, " " );
+
+			if ( !first )
+				continue;
+
+			if ( !strcmp( first, "Loading" ) )
+			{
+				// L 08/08/2012 - 15:10:47: Loading map "mvm_coaltown"
+				strtok( NULL, " " );
+				char *mapname = strtok( NULL, "\"" );
+
+				if ( mapname )
+				{
+					strcpy( logMapName, mapname );
+					Warning( "*** Log file from map '%s'\n", mapname );
+				}
+			}
+			else if ( first[0] == '\"' )
+			{
+				// might be a player ID
+
+				char *playerClassname = &first[1];
+
+				char *nameEnd = playerClassname;
+				while( *nameEnd != '\000' && *nameEnd != '<' )
+					++nameEnd;
+				*nameEnd = '\000';
+
+				char *botIDString = ++nameEnd;
+				char *IDEnd = botIDString;
+				while( *IDEnd != '\000' && *IDEnd != '>' )
+					++IDEnd;
+				*IDEnd = '\000';
+
+				int botID = atoi( botIDString );
+
+				char *second = strtok( NULL, " " );
+				if ( second && !strcmp( second, "stuck" ) )
+				{
+					CStuckBot *stuckBot = TheTFBots().FindOrCreateStuckBot( botID, playerClassname );
+
+					CStuckBotEvent *stuckEvent = new CStuckBotEvent;
+
+
+					// L 08/08/2012 - 15:15:05: "Scout<53><BOT><Blue>" stuck (position "-180.61 2471.29 216.04") (duration "2.52") L 08/08/2012 - 15:15:05:    path_goal ( "-180.61 2471.29 216.04" )
+					strtok( NULL, " (\"" );	// (position
+
+					stuckEvent->m_stuckSpot.x = (float)atof( strtok( NULL, " )\"" ) );
+					stuckEvent->m_stuckSpot.y = (float)atof( strtok( NULL, " )\"" ) );
+					stuckEvent->m_stuckSpot.z = (float)atof( strtok( NULL, " )\"" ) );
+
+					strtok( NULL, ") (\"" );
+					stuckEvent->m_stuckDuration = (float)atof( strtok( NULL, "\"" ) );
+
+					strtok( NULL, ") (\"-L0123456789/:" );	// path_goal
+
+					char *goal = strtok( NULL, ") (\"" );
+
+					if ( goal && strcmp( goal, "NULL" ) )
+					{
+						stuckEvent->m_isGoalValid = true;
+
+						stuckEvent->m_goalSpot.x = (float)atof( goal );
+						stuckEvent->m_goalSpot.y = (float)atof( strtok( NULL, ") (\"" ) );
+						stuckEvent->m_goalSpot.z = (float)atof( strtok( NULL, ") (\"" ) );
+					}
+					else
+					{
+						stuckEvent->m_isGoalValid = false;
+					}
+
+					stuckBot->m_stuckEventVector.AddToTail( stuckEvent );
+				}
+			}
+		}
+
+		filesystem->Close( file );
+	}
+	else
+	{
+		Warning( "Can't open file '%s'\n", args.Arg(1) );
+	}
+
+	//TheTFBots().DrawStuckBotData();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------------------------------------
+CON_COMMAND_F( tf_bot_debug_stuck_log_clear, "Clear currently loaded bot stuck data", FCVAR_GAMEDLL | FCVAR_CHEAT )
+{
+	// Listenserver host or rcon access only!
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	TheTFBots().ClearStuckBotData();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+// for parsing and debugging stuck bot server logs
+void CTFBotManager::ClearStuckBotData()
+{
+	m_stuckBotVector.PurgeAndDeleteElements();
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+// for parsing and debugging stuck bot server logs
+CStuckBot *CTFBotManager::FindOrCreateStuckBot( int id, const char *playerClass )
+{
+	for( int i=0; i<m_stuckBotVector.Count(); ++i )
+	{
+		CStuckBot *stuckBot = m_stuckBotVector[i];
+
+		if ( stuckBot->IsMatch( id, playerClass ) )
+		{
+			return stuckBot;
+		}
+	}
+
+	// new instance of a stuck bot
+	CStuckBot *newStuckBot = new CStuckBot( id, playerClass );
+	m_stuckBotVector.AddToHead( newStuckBot );
+
+	return newStuckBot;
+}
+
+
+//----------------------------------------------------------------------------------------------------------------
+void CTFBotManager::DrawStuckBotData( float deltaT )
+{
+	if ( engine->IsDedicatedServer() )
+		return;
+
+	if ( !m_stuckDisplayTimer.IsElapsed() )
+		return;
+
+	m_stuckDisplayTimer.Start( deltaT );
+
+	CBasePlayer *player = UTIL_GetListenServerHost();
+	if ( player == NULL )
+		return;
+
+// 	Vector forward;
+// 	AngleVectors( player->EyeAngles(), &forward );
+
+	for( int i=0; i<m_stuckBotVector.Count(); ++i )
+	{
+		for( int j=0; j<m_stuckBotVector[i]->m_stuckEventVector.Count(); ++j )
+		{
+			m_stuckBotVector[i]->m_stuckEventVector[j]->Draw( deltaT );
+		}
+
+		for( int j=0; j<m_stuckBotVector[i]->m_stuckEventVector.Count()-1; ++j )
+		{
+			NDebugOverlay::HorzArrow( m_stuckBotVector[i]->m_stuckEventVector[j]->m_stuckSpot, 
+									  m_stuckBotVector[i]->m_stuckEventVector[j+1]->m_stuckSpot,
+									  3, 100, 0, 255, 255, true, deltaT );
+		}
+
+		NDebugOverlay::Text( m_stuckBotVector[i]->m_stuckEventVector[0]->m_stuckSpot, CFmtStr( "%s(#%d)", m_stuckBotVector[i]->m_name, m_stuckBotVector[i]->m_id ), false, deltaT );
+	}
+}
+
+