1HEADmaster

1 files changed, 2437 insertions, 0 deletions

diff --git a/game/server/tf/tf_bot_temp.cpp b/game/server/tf/tf_bot_temp.cpp
new file mode 100644
index 0000000..ea58bc2
--- /dev/null
+++ b/game/server/tf/tf_bot_temp.cpp
@@ -0,0 +1,2437 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// Purpose: Basic BOT handling.
+//
+// $Workfile:     $
+// $Date:         $
+//
+//-----------------------------------------------------------------------------
+// $Log: $
+//
+// $NoKeywords: $
+//=============================================================================
+
+#include "cbase.h"
+#include "player.h"
+#include "tf_player.h"
+#include "tf_gamerules.h"
+#include "in_buttons.h"
+#include "movehelper_server.h"
+#include "tf_playerclass_shared.h"
+#include "datacache/imdlcache.h"
+#include "serverbenchmark_base.h"
+#include "econ_entity_creation.h"
+#include "nav_mesh.h"
+#include "nav_pathfind.h"
+#include "tf_team.h"
+#include "tf_obj.h"
+#include "player.h"
+
+#ifdef STAGING_ONLY
+#include "econ_item_system.h"
+#endif // STAGING_ONLY
+
+void InitBotTrig( void );
+void ClientPutInServer( edict_t *pEdict, const char *playername );
+void Bot_Think( CTFPlayer *pBot );
+
+ConVar bot_debug( "bot_debug", "0", FCVAR_CHEAT, "Bot debugging." );
+#define DbgBotMsg( pszMsg ) \
+	do \
+	{  \
+		if ( bot_debug.GetBool() ) \
+			DevMsg( "[Bot] %s", static_cast<const char *>(pszMsg) ); \
+	} while (0)
+
+
+ConVar bot_forcefireweapon( "bot_forcefireweapon", "", 0, "Force bots with the specified weapon to fire." );
+ConVar bot_forceattack( "bot_forceattack", "0", 0, "When on, all bots fire their guns." );
+ConVar bot_forceattack2( "bot_forceattack2", "0", 0, "When firing, use attack2." );
+ConVar bot_forceattack_down( "bot_forceattack_down", "1", 0, "When firing, don't tap fire, hold it down." );
+ConVar bot_changeclass( "bot_changeclass", "0", 0, "Force all bots to change to the specified class." );
+ConVar bot_dontmove( "bot_dontmove", "0", FCVAR_CHEAT );
+ConVar bot_saveme( "bot_saveme", "0", FCVAR_CHEAT );
+static ConVar bot_mimic_inverse( "bot_mimic_inverse", "0", 0, "Bot uses usercmd of player by index." );
+static ConVar bot_mimic_yaw_offset( "bot_mimic_yaw_offset", "180", 0, "Offsets the bot yaw." );
+ConVar bot_selectweaponslot( "bot_selectweaponslot", "-1", FCVAR_CHEAT, "set to weapon slot that bot should switch to." );
+ConVar bot_randomnames( "bot_randomnames", "0", FCVAR_CHEAT );
+ConVar bot_jump( "bot_jump", "0", FCVAR_CHEAT, "Force all bots to repeatedly jump." );
+ConVar bot_crouch( "bot_crouch", "0", FCVAR_CHEAT, "Force all bots to crouch." );
+
+ConVar bot_nav_turnspeed( "bot_nav_turnspeed", "5", FCVAR_CHEAT, "Rate at which bots turn to face their targets." );
+ConVar bot_nav_wpdistance( "bot_nav_wpdistance", "16", FCVAR_CHEAT, "Distance to a waypoint within which a bot considers as having reached it." );
+ConVar bot_nav_wpdeceldistance( "bot_nav_wpdeceldistance", "128", FCVAR_CHEAT, "Distance to a waypoint to which a bot starts to decelerate to reach it." );
+ConVar bot_nav_simplifypaths( "bot_nav_simplifypaths", "1", FCVAR_CHEAT, "If set, bots will skip waypoints if they already see the waypoint post." );
+ConVar bot_nav_useoffsetpaths( "bot_nav_useoffsetpaths", "1", FCVAR_CHEAT, "If set, bots will generate waypoints on both sides of portals between waypoints when building paths." );
+ConVar bot_nav_offsetpathinset( "bot_nav_offsetpathinset", "20", FCVAR_CHEAT, "Distance into an area that waypoints should be generated when pathfinding through portals." );
+ConVar bot_nav_usefeelers( "bot_nav_usefeelers", "1", FCVAR_CHEAT, "If set, bots will extend feelers to their sides to find & avoid upcoming collisions." );
+ConVar bot_nav_recomputetime( "bot_nav_recomputetime", "0.5", FCVAR_CHEAT, "Delay before bots recompute their path to targets that have moved when moving to them." );
+
+ConVar bot_com_meleerange( "bot_com_meleerange", "80", FCVAR_CHEAT, "Distance to a target that a melee bot wants to be within to attack." );
+ConVar bot_com_wpnrange( "bot_com_wpnrange", "400", FCVAR_CHEAT, "Distance to a target that a ranged bot wants to be within to attack." );
+ConVar bot_com_viewrange( "bot_com_viewrange", "2000", FCVAR_CHEAT, "Distance within which bots looking for any enemies will find them." );
+
+extern ConVar bot_mimic;
+extern ConVar sv_usercmd_custom_random_seed;
+
+// Utility function to get the specified bot from the command arguments
+void GetBotsFromCommand( const CCommand &args, int iArgsRequired, const char *pszUsage, CUtlVector< CTFPlayer* > *botVector )
+{
+	if ( !botVector)
+		return;
+
+	if ( args.ArgC() < iArgsRequired )
+	{
+		Msg( "Too few parameters. %s\n", pszUsage );
+		return;
+	}
+
+	const char *pszBotName = args[1];
+
+	if ( FStrEq( pszBotName, "all" ) )
+	{
+		CUtlVector< CTFPlayer* > playerVector;
+		CollectPlayers( &playerVector );
+		for ( int i=0; i<playerVector.Count(); ++i )
+		{
+			if ( playerVector[i]->IsFakeClient() )
+			{
+				botVector->AddToTail( playerVector[i] );
+			}
+		}
+		return;
+	}
+
+	// get the bot's player object
+	CTFPlayer *pBot = ToTFPlayer( UTIL_PlayerByName( pszBotName ) );
+	if ( !pBot || !pBot->IsFakeClient() )
+	{
+		Msg( "No bot with name %s\n", args[1] );
+		return;
+	}
+
+	botVector->AddToTail( pBot );
+}
+
+static int BotNumber = 1;
+static int g_iNextBotTeam = -1;
+static int g_iNextBotClass = -1;
+
+//===================================================================================================================
+// Purpose: Mapmaker bot control entity. Used by mapmakers to add & script bot behaviors.
+class CTFBotController : public CPointEntity 
+{
+	DECLARE_CLASS( CTFBotController, CPointEntity );
+public:
+	DECLARE_DATADESC();
+
+	// Input.
+	void InputCreateBot( inputdata_t &inputdata );
+	void InputRespawnBot( inputdata_t &inputdata );
+	void InputBotAddCommandMoveToEntity( inputdata_t &inputdata );
+	void InputBotAddCommandAttackEntity( inputdata_t &inputdata );
+	void InputBotAddCommandSwitchWeapon( inputdata_t &inputdata );
+	void InputBotAddCommandDefend( inputdata_t &inputdata );
+	void InputBotSetIgnoreHumans( inputdata_t &inputdata );
+	void InputBotPreventMovement( inputdata_t &inputdata );
+	void InputBotClearQueue( inputdata_t &inputdata );
+
+public:
+	COutputEvent			m_outputOnCommandFinished;	// Fired when the entity is done respawning the players.
+	CHandle<CTFPlayer>		m_hBot;
+	string_t				m_iszBotName;
+	int						m_iBotClass;
+};
+
+enum botcommands_t
+{
+	BC_NONE,
+	BC_MOVETO_ENTITY,
+	BC_MOVETO_POINT,
+	BC_ATTACK,
+	BC_SWITCH_WEAPON,
+	BC_DEFEND,
+};
+
+typedef struct botdata_t
+{
+	CHandle<CTFPlayer>	m_hBot;
+
+	bool			backwards;
+
+	float			nextturntime;
+	bool			lastturntoright;
+
+	float			nextstrafetime;
+	float			sidemove;
+
+	QAngle			forwardAngle;
+	QAngle			lastAngles;
+	
+	float			m_flJoinTeamTime;
+	int				m_WantedTeam;
+	int				m_WantedClass;
+
+	bool			m_bChoseWeapon;
+
+	bool			m_bWasDead;
+	float			m_flDeadTime;
+
+	//------------------------------------------------------
+	// Input into the next command
+	unsigned short	buttons;
+
+	//------------------------------------------------------
+	// Base thinking
+	void Bot_AliveThink( QAngle *vecAngles, Vector *vecMove );
+	void Bot_AliveWeaponThink( QAngle *vecAngles, Vector *vecMove );
+	void Bot_AliveMovementThink( QAngle *vecAngles, Vector *vecMove );
+	void Bot_AliveMovementThink_ExtendFeelers( QAngle *vecAngles, Vector *vecMove, Vector *vecCurVelocity );
+	void Bot_DeadThink( QAngle *vecAngles, Vector *vecMove );
+
+	void Bot_ItemTestingThink( QAngle *vecAngles, Vector *vecMove );
+
+	//------------------------------------------------------
+	// Navigation
+	bool FindPathTo( Vector vecTarget );
+	bool ComputePathPositions( void );
+	bool UpdatePath( void );
+	void AdvancePath( void )
+	{
+		m_iPathIndex++;
+
+		if ( m_iPathIndex >= m_iPathLength )
+		{
+			if ( RunningMovementCommand() )
+			{
+				// We're not done if we're moving to an entity
+				if ( !CommandHasATarget() && ShouldFinishCommandOnArrival() )
+				{
+					ResetPath();
+					FinishCommand();
+				}
+				else
+				{
+					// We finished our path, so find another one.
+					m_flRecomputePathAt = 0;
+					if ( !UpdatePath() )
+					{
+						FinishCommand();
+					}
+				}
+			}
+		}
+	}
+	bool HasPath( void )
+	{
+		return (m_iPathLength > 0);
+	}
+
+	void ResetPath( void )
+	{
+		m_iPathIndex = 0;
+		m_iPathLength = 0;
+	}
+
+	Vector					m_vecFaceToTarget;
+	enum { MAX_PATH_LENGTH = 256 };
+	struct ConnectInfo
+	{
+		CNavArea			*area;										///< the area along the path
+		NavTraverseType		how;										///< how to enter this area from the previous one
+		Vector				pos;										///< our movement goal position at this point in the path
+		float				flOffset;
+	};
+	ConnectInfo				m_path[MAX_PATH_LENGTH];
+	int						m_iPathLength;
+	int						m_iPathIndex;
+	CNavArea				*m_lastKnownArea;
+	float					m_flRecomputePathAt;
+	Vector					m_vecLastPathTarget;
+
+	//------------------------------------------------------
+	// Sensing
+	void					SetIgnoreHumans( bool bIgnore ) { m_bIgnoreHumans = bIgnore; }
+	void					SetFrozen( bool bFrozen ) { if ( bFrozen ) m_hBot->AddEFlags( EFL_BOT_FROZEN ); else m_hBot->RemoveEFlags( EFL_BOT_FROZEN );  }
+	bool					FindEnemyTarget( void );
+	bool					ValidTargetPlayer( CTFPlayer *pPlayer, const Vector &vecStart, const Vector &vecEnd );
+	bool					ValidTargetObject( CBaseObject *pObject, const Vector &vecStart, const Vector &vecEnd );
+
+	EHANDLE					m_hEnemy;
+	bool					m_bIgnoreHumans;
+
+	//------------------------------------------------------
+	// Command Queue
+	void UpdatePlanForCommand( void );
+	void StartNewCommand( void );
+	void FinishCommand( void );
+	void RunAttackPlan( void );
+	void RunDefendPlan( void );
+
+	void AddAttackCommand( CBaseEntity *pTarget );
+	void AddMoveToCommand( CBaseEntity *pTarget, Vector vecTarget );
+	void AddSwitchWeaponCommand( int iSlot );
+	void AddDefendCommand( float flRange );
+	void ClearQueue( void );
+
+	bool RunningMovementCommand( void );
+	bool CommandHasATarget( void );
+	bool ShouldFinishCommandOnArrival( void );
+
+	CBaseEntity *GetCommandTarget( void ) { return m_Commands.Count() ? m_Commands[0].pTarget : NULL; }
+	Vector GetCommandPosition( void ) { return m_Commands.Count() ? m_Commands[0].vecTarget : vec3_origin; }
+
+	struct CommandInfo
+	{
+		botcommands_t		iCommand;
+		EHANDLE				pTarget;
+		Vector				vecTarget;
+		float				flData;
+	};
+	CUtlVector<CommandInfo>	m_Commands;
+	bool					m_bStartedCommand;
+	CHandle<CTFBotController>	m_hBotController;
+} botdata_t;
+
+static botdata_t g_BotData[ MAX_PLAYERS ];
+
+inline botdata_t *BotData( CBasePlayer *pBot )
+{
+	return &g_BotData[ pBot->entindex() - 1 ];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Create a new Bot and put it in the game.
+// Output : Pointer to the new Bot, or NULL if there's no free clients.
+//-----------------------------------------------------------------------------
+CBasePlayer *BotPutInServer( bool bTargetDummy, bool bFrozen, int iTeam, int iClass, const char *pszCustomName )
+{
+	InitBotTrig();
+
+	g_iNextBotTeam = iTeam;
+	g_iNextBotClass = iClass;
+
+	char botname[ 64 ];
+	if ( pszCustomName && pszCustomName[0] )
+	{
+		Q_strncpy( botname, pszCustomName, sizeof( botname ) );
+	}
+	else if ( bot_randomnames.GetBool() )
+	{
+		switch( g_pServerBenchmark->RandomInt(0,5) )
+		{
+		case 0: Q_snprintf( botname, sizeof( botname ), "Bot" ); break;
+		case 1: Q_snprintf( botname, sizeof( botname ), "This is a medium Bot" ); break;
+		case 2: Q_snprintf( botname, sizeof( botname ), "This is a super long bot name that is too long for the game to allow" ); break;
+		case 3: Q_snprintf( botname, sizeof( botname ), "Another bot" ); break;
+		case 4: Q_snprintf( botname, sizeof( botname ), "Yet more Bot names, medium sized" ); break;
+		default: Q_snprintf( botname, sizeof( botname ), "B" ); break;
+		}
+	}
+	else
+	{
+		Q_snprintf( botname, sizeof( botname ), "Bot%02i", BotNumber );
+	}
+
+	edict_t *pEdict = engine->CreateFakeClient( botname );
+	if (!pEdict)
+	{
+		Msg( "Failed to create Bot.\n");
+		return NULL;
+	}
+
+	// Allocate a CBasePlayer for the bot, and call spawn
+	//ClientPutInServer( pEdict, botname );
+	CTFPlayer *pPlayer = ((CTFPlayer *)CBaseEntity::Instance( pEdict ));
+	pPlayer->ClearFlags();
+	pPlayer->AddFlag( FL_CLIENT | FL_FAKECLIENT );
+	pPlayer->SetPlayerType( CTFPlayer::TEMP_BOT );
+
+	if ( bFrozen )
+	{
+		pPlayer->AddEFlags( EFL_BOT_FROZEN );
+	}
+
+	if ( bTargetDummy )
+	{
+		pPlayer->SetTargetDummy();
+	}
+
+	BotNumber++;
+
+	botdata_t *pBot = BotData(pPlayer);
+	pBot->m_hBot = pPlayer;
+	pBot->m_bWasDead = false;
+	pBot->m_WantedTeam = iTeam;
+	pBot->m_WantedClass = iClass;
+	pBot->m_bChoseWeapon = false;
+	pBot->m_flJoinTeamTime = gpGlobals->curtime + 0.3;
+	pBot->m_vecFaceToTarget.Zero();
+	pBot->m_lastKnownArea = NULL;
+	pBot->m_flRecomputePathAt = 0;
+	pBot->ResetPath();
+	pBot->m_bIgnoreHumans = false;
+	pBot->m_bStartedCommand = false;
+
+	return pPlayer;
+}
+
+//-----------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_kick, "Remove a bot by name, or an entire team (\"red\" or \"blue\"), or all bots (\"all\").", FCVAR_CHEAT )
+{
+	// Listenserver host or rcon access only!
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	if ( args.ArgC() != 2 )
+	{
+		DevMsg( "%s <bot name>, \"red\", \"blue\", or \"all\"\n", args.Arg(0) );
+		return;
+	}
+
+	for( int i = 1; i <= gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if ( !player )
+			continue;
+
+		if ( FNullEnt( player->edict() ) )
+			continue;
+
+		if ( player->GetFlags() & FL_FAKECLIENT )
+		{
+			if ( FStrEq( args.Arg( 1 ), "all" ) || 
+				  FStrEq( args.Arg( 1 ), player->GetPlayerName() ) ||
+				( FStrEq( args.Arg( 1 ), "red" ) && player->GetTeamNumber() == TF_TEAM_RED ) ||
+				( FStrEq( args.Arg( 1 ), "blue" ) && player->GetTeamNumber() == TF_TEAM_BLUE ) )
+			{
+				engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", player->GetUserID() ) );
+			}
+		}
+	}
+}
+
+// Handler for the "bot" command.
+CON_COMMAND_F( bot, "Add a bot.", FCVAR_NONE )
+{
+	// Listenserver host or rcon access only!
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	// Allow bots in item testing mode
+	if ( !sv_cheats->GetBool() && !TFGameRules()->IsInItemTestingMode() )
+		return;
+
+	//CDODPlayer *pPlayer = CDODPlayer::Instance( UTIL_GetCommandClientIndex() );
+
+	// The bot command uses switches like command-line switches.
+	// -count <count> tells how many bots to spawn.
+	// -team <index> selects the bot's team. Default is -1 which chooses randomly.
+	//	Note: if you do -team !, then it 
+	// -class <index> selects the bot's class. Default is -1 which chooses randomly.
+	// -frozen prevents the bots from running around when they spawn in.
+	// -name sets the bot's name
+	// -targetdummy sets their health to 1,000,000.  Useful for testing damage via hud_damagemeter.
+	// -teleport teleports the bot to the location the player is pointing at
+
+	// Look at -count.
+	int count = args.FindArgInt( "-count", 1 );
+	count = clamp( count, 1, 16 );
+
+	if ( args.FindArg( "-all" ) )
+	{
+		count = 9;
+	}
+
+	// Look at -frozen.
+	bool bFrozen = !!args.FindArg( "-frozen" );
+	bool bTargetDummy = !!args.FindArg( "-targetdummy" );
+	bool bTeleport = !!args.FindArg( "-teleport" );
+		
+	// Ok, spawn all the bots.
+	while ( --count >= 0 )
+	{
+		// What class do they want?
+		int iClass = g_pServerBenchmark->RandomInt( 1, TF_CLASS_COUNT-2 ); // -2 so we skip the Civilian class
+		char const *pVal = args.FindArg( "-class" );
+		if ( pVal )
+		{
+			for ( int i=1; i < TF_CLASS_COUNT_ALL; i++ )
+			{
+				if ( !Q_stricmp(pVal, g_aPlayerClassNames_NonLocalized[i] ) )
+				{
+					iClass = i;
+					break;
+				}
+			}
+		}
+		if ( args.FindArg( "-all" ) )
+		{
+			iClass = 9 - count ;
+		}
+
+		int iTeam = TEAM_UNASSIGNED;
+		pVal = args.FindArg( "-team" );
+		if ( pVal )
+		{
+			if ( stricmp( pVal, "red" ) == 0 )
+			{
+				iTeam = TF_TEAM_RED;
+			}
+			else if ( stricmp( pVal, "spectator" ) == 0 )
+			{
+				iTeam = TEAM_SPECTATOR;
+			}
+			else if ( stricmp( pVal, "random" ) == 0 )
+			{
+				iTeam = g_pServerBenchmark->RandomInt( 0, 100 ) < 50 ? TF_TEAM_BLUE : TF_TEAM_RED;
+			}
+			else
+			{
+				iTeam = TF_TEAM_BLUE;
+			}
+		}
+
+		char const *pName = args.FindArg( "-name" );
+
+		CBasePlayer *pTemp = BotPutInServer( bTargetDummy, bFrozen, iTeam, iClass, pName );
+
+		if ( bTeleport && pTemp )
+		{
+			CTFPlayer *pBot = ToTFPlayer( pTemp );
+			CBasePlayer *pPlayer = UTIL_GetCommandClient();
+			if ( pPlayer && pBot )
+			{
+				trace_t tr;
+				Vector forward;
+
+				pPlayer->EyeVectors( &forward );
+				UTIL_TraceLine( pPlayer->EyePosition(),
+					pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_NPCSOLID, 
+					pPlayer, COLLISION_GROUP_NONE, &tr );
+
+				if ( tr.fraction != 1.0 )
+				{
+					botdata_t *pBotData = BotData( pBot );
+					if ( pBotData )
+					{
+						pBotData->m_flJoinTeamTime = gpGlobals->curtime - 0.1;
+					}
+
+					const char *pszTeam = "auto";
+					switch ( pBotData->m_WantedTeam )
+					{
+					case TF_TEAM_RED:
+						pszTeam = "red";
+						break;
+					case TF_TEAM_BLUE:
+						pszTeam = "blue";
+						break;
+					case TEAM_SPECTATOR:
+						pszTeam = "spectator";
+						break;
+					default:
+						pszTeam = "auto";
+						break;
+					}
+					pBot->HandleCommand_JoinTeam( pszTeam );
+
+					const char *pszClassname = ( pBotData->m_WantedClass == TF_CLASS_RANDOM ) ? "random" : GetPlayerClassData( pBotData->m_WantedClass )->m_szClassName;
+					pBot->HandleCommand_JoinClass( pszClassname );
+
+					pBot->ForceRespawn();
+					pBot->Teleport( &tr.endpos, NULL, NULL );
+				}
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------------------------------
+CON_COMMAND_F( bot_hurt, "Hurt a bot by team, or all bots (\"all\").", FCVAR_GAMEDLL )
+{
+	// Listenserver host or rcon access only!
+	if ( !UTIL_IsCommandIssuedByServerAdmin() )
+		return;
+
+	if ( args.ArgC() < 2 )
+	{
+		DevMsg( "%s (-team <red/blue/all>>) (-name <name>) (-damage <int>) (-burn)\n", args.Arg(0) );
+		return;
+	}
+
+	int nDamage = 50;
+	const char* pszDamage = args.FindArg( "-damage" );
+	if( pszDamage )
+	{
+		nDamage = atoi(pszDamage);
+	}
+
+	bool bBurn = args.FindArg( "-burn" ) != nullptr;
+
+	// Figure out which team if specified
+	int iTeam = TEAM_UNASSIGNED;
+	const char* pVal = args.FindArg( "-team" );
+	if ( pVal )
+	{
+		if ( stricmp( pVal, "red" ) == 0 )
+		{
+			iTeam = TF_TEAM_RED;
+		}
+		else if ( stricmp( pVal, "blue" ) == 0 )
+		{
+			iTeam = TF_TEAM_BLUE;
+		}
+		else if ( stricmp( pVal, "all" ) == 0 )
+		{
+			iTeam = TEAM_ANY;
+		}
+		else
+		{
+			iTeam = TEAM_ANY;
+		}
+	}
+
+	// Get the name if the put one in
+	pVal = args.FindArg( "-name" );
+	const char *pPlayerName = "";
+	if( pVal )
+	{
+		pPlayerName = pVal;
+	}
+
+	for( int i=1; i<=gpGlobals->maxClients; ++i )
+	{
+		CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
+
+		if ( !player )
+			continue;
+
+		if ( FNullEnt( player->edict() ) )
+			continue;
+
+		if ( player->GetFlags() & FL_FAKECLIENT )
+		{
+			if ( iTeam == TEAM_ANY ||
+				 FStrEq( pPlayerName, player->GetPlayerName() ) ||
+				 ( player->GetTeamNumber() == iTeam ) ||
+				 ( player->GetTeamNumber() == iTeam ) )
+			{
+				player->m_iHealth -= nDamage;
+
+				if ( bBurn )
+				{
+					CTFPlayer *pBot = ToTFPlayer( player );
+					pBot->m_Shared.Burn( nullptr, nullptr, 10.0f );
+				}
+			}
+		}
+	}
+}
+
+inline bool isTempBot( CTFPlayer* pPlayer )
+{
+	return ( pPlayer && ( pPlayer->GetFlags() & FL_FAKECLIENT ) && pPlayer->GetPlayerType() == CTFPlayer::TEMP_BOT );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Run through all the Bots in the game and let them think.
+//-----------------------------------------------------------------------------
+void Bot_RunAll( void )
+{
+	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
+
+		if ( isTempBot( pPlayer ) && pPlayer->MyNextBotPointer() == NULL )
+		{
+			Bot_Think( pPlayer );
+		}
+	}
+}
+
+bool RunMimicCommand( CUserCmd& cmd )
+{
+	if ( bot_mimic.GetInt() <= 0 )
+		return false;
+
+	if ( bot_mimic.GetInt() > gpGlobals->maxClients )
+		return false;
+
+	
+	CBasePlayer *pPlayer = UTIL_PlayerByIndex( bot_mimic.GetInt()  );
+	if ( !pPlayer )
+		return false;
+
+	if ( !pPlayer->GetLastUserCommand() )
+		return false;
+
+	cmd = *pPlayer->GetLastUserCommand();
+	cmd.viewangles[YAW] += bot_mimic_yaw_offset.GetFloat();
+
+	if ( bot_mimic_inverse.GetBool() )
+	{
+		cmd.forwardmove *= -1;
+		cmd.sidemove *= -1;
+	}
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Simulates a single frame of movement for a player
+// Input  : *fakeclient - 
+//			*viewangles - 
+//			forwardmove - 
+//			sidemove - 
+//			upmove - 
+//			buttons - 
+//			impulse - 
+//			msec - 
+// Output : 	virtual void
+//-----------------------------------------------------------------------------
+static void RunPlayerMove( CTFPlayer *fakeclient, const QAngle& viewangles, float forwardmove, float sidemove, float upmove, unsigned short buttons, byte impulse, float frametime )
+{
+	if ( !fakeclient )
+		return;
+
+	CUserCmd cmd;
+
+	// Store off the globals.. they're gonna get whacked
+	float flOldFrametime = gpGlobals->frametime;
+	float flOldCurtime = gpGlobals->curtime;
+
+	float flTimeBase = gpGlobals->curtime + gpGlobals->frametime - frametime;
+	fakeclient->SetTimeBase( flTimeBase );
+
+	Q_memset( &cmd, 0, sizeof( cmd ) );
+
+	if ( !RunMimicCommand( cmd ) )
+	{
+		VectorCopy( viewangles, cmd.viewangles );
+		cmd.forwardmove = forwardmove;
+		cmd.sidemove = sidemove;
+		cmd.upmove = upmove;
+		cmd.buttons = buttons;
+		cmd.impulse = impulse;
+		cmd.random_seed = g_pServerBenchmark->RandomInt( 0, 0x7fffffff );
+		if ( sv_usercmd_custom_random_seed.GetBool() )
+		{
+			float fltTimeNow = float( Plat_FloatTime() * 1000.0 );
+			cmd.server_random_seed = *reinterpret_cast<int*>( (char*)&fltTimeNow );
+		}
+		else
+		{
+			cmd.server_random_seed = cmd.random_seed;
+		}
+	}
+
+	if ( bot_dontmove.GetBool() )
+	{
+		cmd.forwardmove = 0;
+		cmd.sidemove = 0;
+		cmd.upmove = 0;
+	}
+	else
+	{
+		float flStunAmount = fakeclient->m_Shared.GetAmountStunned( TF_STUN_MOVEMENT );
+		if ( flStunAmount )
+		{
+			cmd.forwardmove *= (1.0 - flStunAmount);
+			cmd.sidemove *= (1.0 - flStunAmount);
+		}
+	}
+
+	if ( fakeclient->m_Shared.IsControlStunned() || fakeclient->m_Shared.IsLoserStateStunned() )
+	{
+		cmd.weaponselect = 0;
+		cmd.buttons = 0;
+		if ( fakeclient->m_Shared.IsControlStunned() )
+		{
+			cmd.forwardmove = 0;
+			cmd.sidemove = 0;
+			cmd.upmove = 0;
+		}
+	}
+
+	MoveHelperServer()->SetHost( fakeclient );
+	fakeclient->PlayerRunCommand( &cmd, MoveHelperServer() );
+
+	// save off the last good usercmd
+	fakeclient->SetLastUserCommand( cmd );
+
+	// Clear out any fixangle that has been set
+	fakeclient->pl.fixangle = FIXANGLE_NONE;
+
+	// Restore the globals..
+	gpGlobals->frametime = flOldFrametime;
+	gpGlobals->curtime = flOldCurtime;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Run this Bot's AI for one frame.
+//-----------------------------------------------------------------------------
+void Bot_Think( CTFPlayer *pBot )
+{
+	// Make sure we stay being a bot
+	pBot->AddFlag( FL_FAKECLIENT );
+
+	botdata_t *botdata = BotData(pBot);
+
+	Vector vecMove( 0, 0, 0 );
+	byte  impulse = 0;
+	float frametime = gpGlobals->frametime;
+	QAngle vecViewAngles = pBot->EyeAngles();
+	botdata->buttons = 0;
+
+	MDLCACHE_CRITICAL_SECTION();
+
+	// Create some random values
+	if ( pBot->GetTeamNumber() == TEAM_UNASSIGNED && gpGlobals->curtime > botdata->m_flJoinTeamTime )
+	{
+		const char *pszTeam = NULL;
+		switch ( botdata->m_WantedTeam )
+		{
+		case TF_TEAM_RED:
+			pszTeam = "red";
+			break;
+		case TF_TEAM_BLUE:
+			pszTeam = "blue";
+			break;
+		case TEAM_SPECTATOR:
+			pszTeam = "spectator";
+			break;
+		default:
+			pszTeam = "auto";
+			break;
+		}
+		pBot->HandleCommand_JoinTeam( pszTeam );
+	}
+	else if ( pBot->GetTeamNumber() != TEAM_UNASSIGNED && pBot->GetPlayerClass()->IsClass( TF_CLASS_UNDEFINED ) )
+	{
+		// If they're on a team but haven't picked a class, choose a random class..
+		const char *pszClassname = ( botdata->m_WantedClass == TF_CLASS_RANDOM ) ? "random" : GetPlayerClassData( botdata->m_WantedClass )->m_szClassName;
+		pBot->HandleCommand_JoinClass( pszClassname );
+	}
+	else if ( pBot->IsAlive() && (pBot->GetSolid() == SOLID_BBOX) )
+	{
+		botdata->Bot_AliveThink( &vecViewAngles, &vecMove );
+	}
+	else
+	{
+		botdata->Bot_DeadThink( &vecViewAngles, &vecMove );
+	}
+
+	RunPlayerMove( pBot, vecViewAngles, vecMove[0], vecMove[1], vecMove[2], botdata->buttons, impulse, frametime );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle the Bot AI for a live bot
+//-----------------------------------------------------------------------------
+void botdata_t::Bot_AliveThink( QAngle *vecAngles, Vector *vecMove )
+{
+	trace_t trace;
+
+	m_bWasDead = false;
+
+	// In item testing mode, we run custom logic
+	if ( TFGameRules()->IsInItemTestingMode() )
+	{
+		Bot_ItemTestingThink( vecAngles, vecMove );
+		return;
+	}
+
+	UpdatePlanForCommand();
+	Bot_AliveMovementThink( vecAngles, vecMove );
+	Bot_AliveWeaponThink( vecAngles, vecMove );
+
+	// Miscellaneous
+	if ( bot_saveme.GetInt() > 0 )
+	{
+		m_hBot->SaveMe();
+		bot_saveme.SetValue( bot_saveme.GetInt() - 1 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle movement
+//-----------------------------------------------------------------------------
+void botdata_t::Bot_AliveMovementThink( QAngle *vecAngles, Vector *vecMove )
+{
+	if ( m_hBot->IsEFlagSet(EFL_BOT_FROZEN) )
+	{
+		(*vecMove)[0] = 0;
+		(*vecMove)[1] = 0;
+		(*vecMove)[2] = 0;
+		return;
+	}
+
+	if ( bot_jump.GetBool() && m_hBot->GetFlags() & FL_ONGROUND )
+	{
+		buttons |= IN_JUMP;
+	}
+
+	if ( bot_crouch.GetBool() )
+	{
+		buttons |= IN_DUCK;
+	}
+
+	// If we don't have a faceto target, but we're moving to a waypoint, look at that.
+	Vector vecFaceTo = m_vecFaceToTarget;
+	if ( vecFaceTo == vec3_origin )
+	{
+		if ( m_hEnemy )
+		{
+			vecFaceTo = m_hEnemy->EyePosition();
+		}
+		else if ( GetCommandTarget() )
+		{
+			vecFaceTo = GetCommandTarget()->EyePosition();
+		}
+		else if ( HasPath() )
+		{
+			vecFaceTo = m_path[ m_iPathIndex ].pos;
+			vecFaceTo[2] = m_hBot->EyePosition()[2];
+		}
+	}
+	// Should we face something?
+	if ( vecFaceTo != vec3_origin )
+	{
+		Vector vecViewTarget = (vecFaceTo - m_hBot->EyePosition());
+		VectorNormalize(vecViewTarget);
+		QAngle vecTargetViewAngles;
+		VectorAngles( vecViewTarget, Vector(0,0,1), vecTargetViewAngles );
+		(*vecAngles)[YAW] = ApproachAngle( vecTargetViewAngles[YAW], (*vecAngles)[YAW], bot_nav_turnspeed.GetFloat() );
+	}
+
+	// Are we moving to a waypoint?
+	if ( HasPath() )
+	{
+		m_lastKnownArea = TheNavMesh->GetNavArea( m_hBot->GetAbsOrigin() );
+		if ( !UpdatePath() )
+		{
+			FinishCommand();
+			return;
+		}
+
+		if ( !m_Commands.Count() )
+			return;
+
+		float flDistance = bot_nav_wpdistance.GetFloat();
+		CBaseEntity *pTargetEnt = m_Commands[0].pTarget;
+
+		// We might run into our target entity earlier. 
+		if ( CommandHasATarget() && ShouldFinishCommandOnArrival() )
+		{
+			float flEntDistance = pTargetEnt->BoundingRadius() + flDistance;
+			flEntDistance *= flEntDistance;
+			if ( (pTargetEnt->GetAbsOrigin() - m_hBot->GetAbsOrigin()).Length2DSqr() < flEntDistance )
+			{
+				ResetPath();
+				FinishCommand();
+				return;
+			}
+		}
+
+		// Have we reached the next waypoint?
+		flDistance *= flDistance;
+		if ( (m_path[ m_iPathIndex ].pos - m_hBot->GetAbsOrigin()).Length2DSqr() < flDistance )
+		{
+			AdvancePath();
+		}
+		else if ( bot_nav_simplifypaths.GetBool() )
+		{
+			// If we can see our next waypoint already, stop moving to this one
+			while ( m_iPathLength >= (m_iPathIndex+1) &&
+				m_iPathIndex < (m_iPathLength - 1) &&
+				m_hBot->FVisible( m_path[ m_iPathIndex+1 ].pos ) )
+			{
+				AdvancePath();
+			}
+		}
+
+		if ( bot_debug.GetInt() == 1 )
+		{
+			for ( int i = 0; i < m_iPathLength-1; i++ )
+			{
+				NDebugOverlay::Line( m_path[i].pos, m_path[i+1].pos, 0, i == m_iPathIndex ? 255 : 64, 0, true, 0.1 );
+				NDebugOverlay::Box( m_path[i].pos, -Vector(3,3,3), Vector(3,3,3), 0, i == m_iPathIndex ? 255 : 64, 0, 0, 0.1 );	
+			}
+		}
+
+		Vector vecTarget = m_path[ m_iPathIndex ].pos;
+		Vector vecDesiredVelocity = (vecTarget - m_hBot->GetAbsOrigin());
+		if ( bot_nav_usefeelers.GetBool() && m_iPathIndex < (m_iPathLength - 1) )
+		{
+			Bot_AliveMovementThink_ExtendFeelers( vecAngles, vecMove, &vecDesiredVelocity );
+		}
+		flDistance = VectorNormalize( vecDesiredVelocity );
+
+		// If we're approaching our last waypoint, decelerate to the point.
+		if ( m_iPathLength == 1 )
+		{
+			float flDecelDistance = bot_nav_wpdeceldistance.GetFloat();
+			float flSpeed = MIN( m_hBot->MaxSpeed() * (flDistance / flDecelDistance), m_hBot->MaxSpeed() );
+			vecDesiredVelocity *= flSpeed;
+		}
+		else
+		{
+			vecDesiredVelocity *= m_hBot->MaxSpeed();
+		}
+
+		if ( bot_debug.GetInt() == 10 )
+		{
+			NDebugOverlay::HorzArrow( m_hBot->GetAbsOrigin(), m_hBot->GetAbsOrigin() + vecDesiredVelocity, 3, 255, 0, 0, 0, true, 0.1 );
+		}
+
+		// Convert the velocity into forward/sidemove
+		Vector vecForward, vecRight;
+		AngleVectors( *vecAngles, &vecForward, &vecRight, NULL );
+		(*vecMove)[0] = DotProduct( vecForward, vecDesiredVelocity );
+		(*vecMove)[1] = DotProduct( vecRight, vecDesiredVelocity );
+	}
+}
+
+//------------------------------------------------------------------------------------------------------------
+#define COS_TABLE_SIZE 256
+static float cosTable[ COS_TABLE_SIZE ];
+static bool bBotTrigInitted = false;
+
+void InitBotTrig( void )
+{
+	if ( bBotTrigInitted )
+		return;
+	bBotTrigInitted = true;
+	for( int i=0; i<COS_TABLE_SIZE; ++i )
+	{
+		float angle = (float)(2.0f * M_PI * i / (float)(COS_TABLE_SIZE-1));
+		cosTable[i] = (float)cos( angle ); 
+	}
+}
+
+float BotCOS( float angle )
+{
+	angle = AngleNormalizePositive( angle );
+	int i = (int)( angle * (COS_TABLE_SIZE-1) / 360.0f );
+	return cosTable[i];
+}
+
+float BotSIN( float angle )
+{
+	angle = AngleNormalizePositive( angle - 90 );
+	int i = (int)( angle * (COS_TABLE_SIZE-1) / 360.0f );
+	return cosTable[i];
+}
+
+// Find "simple" ground height, treating current nav area as part of the floor
+bool GetSimpleGroundHeightWithFloor( CNavArea *pArea, const Vector &pos, float *height, Vector *normal )
+{
+	if (TheNavMesh->GetSimpleGroundHeight( pos, height, normal ))
+	{
+		// our current nav area also serves as a ground polygon
+		if ( pArea && pArea->IsOverlapping( pos ))
+		{
+			*height = MAX( (*height), pArea->GetZ( pos ) );
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+//--------------------------------------------------------------------------------------------------------------
+// Purpose: Fire feelers out to either side and steer to avoid collisions
+//--------------------------------------------------------------------------------------------------------------
+void botdata_t::Bot_AliveMovementThink_ExtendFeelers( QAngle *vecAngles, Vector *vecMove, Vector *vecCurVelocity )
+{
+	VectorNormalize( *vecCurVelocity );
+
+	float flForwardAngle = UTIL_VecToYaw( *vecCurVelocity );
+
+	Vector dir( BotCOS( flForwardAngle ), BotSIN( flForwardAngle ), 0.0f );
+	Vector lat( -dir.y, dir.x, 0.0f );
+
+	const float feelerOffset = 20.0f;
+	const float feelerLengthRun = 50.0f;	// 100 - too long for tight hallways (cs_747)
+	const float feelerHeight = StepHeight + 0.1f;	// if obstacle is lower than StepHeight, we'll walk right over it
+
+	// Feelers must follow floor slope
+	float ground;
+	Vector normal;
+	Vector eye = m_hBot->EyePosition();
+	if (GetSimpleGroundHeightWithFloor( m_lastKnownArea, eye, &ground, &normal ) == false)
+		return;
+
+	// get forward vector along floor
+	dir = CrossProduct( lat, normal );
+
+	// correct the sideways vector
+	lat = CrossProduct( dir, normal );
+
+	Vector feet = m_hBot->GetAbsOrigin();
+	feet.z += feelerHeight;
+
+	Vector from = feet + feelerOffset * lat;
+	Vector to = from + feelerLengthRun * dir;
+
+	bool leftClear = IsWalkableTraceLineClear( from, to, WALK_THRU_DOORS | WALK_THRU_BREAKABLES );
+	if ( bot_debug.GetInt() == 3 )
+	{
+		NDebugOverlay::Line( from, to, leftClear ? 0 : 255, leftClear ? 255 : 0, 0, true, 0.1 );
+	}
+
+	from = feet - feelerOffset * lat;
+	to = from + feelerLengthRun * dir;
+
+	bool rightClear = IsWalkableTraceLineClear( from, to, WALK_THRU_DOORS | WALK_THRU_BREAKABLES );
+	if ( bot_debug.GetInt() == 3 )
+	{
+		NDebugOverlay::Line( from, to, rightClear ? 0 : 255, rightClear ? 255 : 0, 0, true, 0.1 );
+	}
+
+	Vector vecDebug;
+	if ( bot_debug.GetInt() == 3 && (!leftClear || !rightClear) )
+	{
+		vecDebug = (*vecCurVelocity * 100);
+		NDebugOverlay::Line( m_hBot->GetAbsOrigin(), m_hBot->GetAbsOrigin() + vecDebug, 0, 0, 255, true, 0.1 );
+	}
+
+	const float avoidRange = 300.0f;		// 50, 300
+	if (!rightClear)
+	{
+		if (leftClear)
+		{
+			// right hit, left clear - veer left
+			*vecCurVelocity = (*vecCurVelocity * avoidRange) + avoidRange * lat;
+		}
+	}
+	else if (!leftClear)
+	{
+		// right clear, left hit - veer right
+		*vecCurVelocity = (*vecCurVelocity * avoidRange) - avoidRange * lat;
+	}
+
+	if ( bot_debug.GetInt() == 3 && (!leftClear || !rightClear) )
+	{
+		vecDebug = (*vecCurVelocity);
+		VectorNormalize( vecDebug );
+		vecDebug *= 100;
+		NDebugOverlay::Line( m_hBot->GetAbsOrigin(), m_hBot->GetAbsOrigin() + vecDebug, 64, 64, 255, true, 0.1 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle weapon switching / firing
+//-----------------------------------------------------------------------------
+void botdata_t::Bot_AliveWeaponThink( QAngle *vecAngles, Vector *vecMove )
+{
+	if ( bot_selectweaponslot.GetInt() >= 0 )
+	{
+		int slot = bot_selectweaponslot.GetInt();
+
+		CBaseCombatWeapon *pWpn = m_hBot->Weapon_GetSlot( slot );
+
+		if ( pWpn )
+		{
+			m_hBot->Weapon_Switch( pWpn );
+		}
+
+		bot_selectweaponslot.SetValue( -1 );
+	}
+
+	const char *pszWeapon = bot_forcefireweapon.GetString();
+	if ( (pszWeapon && pszWeapon[0]) || g_pServerBenchmark->IsBenchmarkRunning() )
+	{
+		// If bots are being forced to fire a weapon, see if I have it
+		// Manually look through weapons to ignore subtype			
+		CBaseCombatWeapon *pWeapon = NULL;
+
+		if ( g_pServerBenchmark->IsBenchmarkRunning() )
+		{
+			if ( !m_bChoseWeapon )
+			{
+				m_bChoseWeapon = true;
+
+				// Choose any weapon out of the available ones.
+				CUtlVector<CBaseCombatWeapon*> weapons;
+				for (int i=0;i<MAX_WEAPONS;i++) 
+				{
+					if ( m_hBot->GetWeapon(i) )
+					{
+						weapons.AddToTail( m_hBot->GetWeapon( i ) );
+					}
+				}
+
+				if ( weapons.Count() > 0 )
+				{
+					pWeapon = weapons[ g_pServerBenchmark->RandomInt( 0, weapons.Count() - 1 ) ];
+				}
+			}
+		}
+		else
+		{
+			// Look for a specific weapon name here.
+			for (int i=0;i<MAX_WEAPONS;i++) 
+			{
+				if ( m_hBot->GetWeapon(i) && FClassnameIs( m_hBot->GetWeapon(i), pszWeapon ) )
+				{
+					pWeapon = m_hBot->GetWeapon(i);
+					break;
+				}
+			}
+		}
+
+		if ( pWeapon )
+		{
+			// Switch to it if we don't have it out
+			CBaseCombatWeapon *pActiveWeapon = m_hBot->GetActiveWeapon();
+
+			// Switch?
+			if ( pActiveWeapon != pWeapon )
+			{
+				m_hBot->Weapon_Switch( pWeapon );
+			}
+			else
+			{
+				// Start firing
+				// Some weapons require releases, so randomise firing
+				if ( bot_forceattack_down.GetBool() || (g_pServerBenchmark->RandomFloat(0.0,1.0) > 0.5) )
+				{
+					buttons |= IN_ATTACK;
+				}
+
+				if ( bot_forceattack2.GetBool() )
+				{
+					buttons |= IN_ATTACK2;
+				}
+			}
+		}
+	}
+
+	if ( bot_forceattack.GetInt() )
+	{
+		if ( bot_forceattack_down.GetBool() || (g_pServerBenchmark->RandomFloat(0.0,1.0) > 0.5) )
+		{
+			buttons |= bot_forceattack2.GetBool() ? IN_ATTACK2 : IN_ATTACK;
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle the Bot AI for a dead bot
+//-----------------------------------------------------------------------------
+void botdata_t::Bot_DeadThink( QAngle *vecAngles, Vector *vecMove )
+{
+	// Wait for Reinforcement wave
+	if ( !m_hBot->IsAlive() )
+	{
+		if ( m_bWasDead )
+		{
+			// Wait for a few seconds before respawning.
+			if ( gpGlobals->curtime - m_flDeadTime > 3 )
+			{
+				// Respawn the bot
+				buttons |= IN_JUMP;
+			}
+		}
+		else
+		{
+			// Start a timer to respawn them in a few seconds.
+			m_bWasDead = true;
+			m_flDeadTime = gpGlobals->curtime;
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: sends the specified command from a bot
+//------------------------------------------------------------------------------
+void cc_bot_sendcommand( const CCommand &args )
+{
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 3, "Usage: bot_command <bot name> <command string...>", &botVector );
+	if ( botVector.IsEmpty() )
+		return;
+
+	const char *commandline = args.GetCommandString();
+
+	// find the rest of the command line past the bot index
+	commandline = strstr( commandline, args[2] );
+	Assert( commandline );
+
+	int iSize = Q_strlen(commandline) + 1;
+	char *pBuf = (char *)malloc(iSize);
+	Q_snprintf( pBuf, iSize, "%s", commandline );
+
+	if ( pBuf[iSize-2] == '"' )
+	{
+		pBuf[iSize-2] = '\0';
+	}
+
+	// make a command object with the intended command line
+	CCommand command;
+	command.Tokenize( pBuf );
+
+	// send the command
+	FOR_EACH_VEC( botVector, i )
+	{
+		TFGameRules()->ClientCommand( botVector[i], command );
+	}
+}
+static ConCommand bot_sendcommand( "bot_command", cc_bot_sendcommand, "<bot id> <command string...>.  Sends specified command on behalf of specified bot", FCVAR_CHEAT );
+
+//------------------------------------------------------------------------------
+// Purpose: Kill the specified bot
+//------------------------------------------------------------------------------
+void cc_bot_kill( const CCommand &args )
+{
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 2, "Usage: bot_kill <bot name>", &botVector );
+	if ( botVector.IsEmpty() )
+		return;
+
+	FOR_EACH_VEC( botVector, i )
+	{
+		botVector[i]->CommitSuicide();
+	}
+}
+
+static ConCommand bot_kill( "bot_kill", cc_bot_kill, "Kills a bot. Usage: bot_kill <bot name>", FCVAR_CHEAT );
+
+//------------------------------------------------------------------------------
+// Purpose: Force all bots to swap teams
+//------------------------------------------------------------------------------
+CON_COMMAND_F( bot_changeteams, "Make all bots change teams", FCVAR_CHEAT )
+{
+	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
+
+		if ( isTempBot( pPlayer ) )
+		{
+			int iTeam = pPlayer->GetTeamNumber();			
+			if ( TF_TEAM_BLUE == iTeam || TF_TEAM_RED == iTeam )
+			{
+				// toggle team between red & blue
+				pPlayer->ChangeTeam( TF_TEAM_BLUE + TF_TEAM_RED - iTeam );
+			}			
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: Refill all bot ammo counts
+//------------------------------------------------------------------------------
+CON_COMMAND_F( bot_refill, "Refill all bot ammo counts", FCVAR_CHEAT )
+{
+	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
+	{
+		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
+
+		if ( isTempBot( pPlayer ) )
+		{
+			pPlayer->GiveAmmo( 1000, TF_AMMO_PRIMARY );
+			pPlayer->GiveAmmo( 1000, TF_AMMO_SECONDARY );
+			pPlayer->GiveAmmo( 1000, TF_AMMO_METAL );
+			pPlayer->TakeHealth( 999, DMG_GENERIC );
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: Deliver lethal damage from the player to the specified bot
+//------------------------------------------------------------------------------
+CON_COMMAND_F( bot_whack, "Deliver lethal damage from player to specified bot. Usage: bot_whack <bot name>", FCVAR_CHEAT )
+{
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 2, "Usage: bot_whack <bot name>", &botVector );
+	if ( botVector.IsEmpty() )
+		return;
+
+	CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_GetCommandClient() );
+	FOR_EACH_VEC( botVector, i )
+	{
+		CTakeDamageInfo info( botVector[i], pTFPlayer, 1000, DMG_BULLET );
+		info.SetInflictor( pTFPlayer->GetActiveTFWeapon() );
+		botVector[i]->TakeDamage( info );
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: Force the specified bot to teleport to the specified position
+//------------------------------------------------------------------------------
+CON_COMMAND_F( bot_teleport, "Teleport the specified bot to the specified position & angles.\n\tFormat: bot_teleport <bot name> <X> <Y> <Z> <Pitch> <Yaw> <Roll>", FCVAR_CHEAT )
+{
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 8, "Usage: bot_teleport <bot name> <X> <Y> <Z> <Pitch> <Yaw> <Roll>", &botVector );
+	if ( botVector.IsEmpty() )
+		return;
+
+	Vector vecPos( atof(args[2]), atof(args[3]), atof(args[4]) );
+	QAngle vecAng( atof(args[5]), atof(args[6]), atof(args[7]) );
+	FOR_EACH_VEC( botVector, i )
+	{
+		botVector[i]->Teleport( &vecPos, &vecAng, NULL );
+	}
+	
+}
+
+//------------------------------------------------------------------------------
+// Purpose: Force the specified bot to create & equip an item
+//------------------------------------------------------------------------------
+void BotGenerateAndWearItem( CTFPlayer *pBot, const char *itemName )
+{
+	if ( !pBot )
+		return;
+
+	CItemSelectionCriteria criteria;
+	criteria.SetItemLevel( AE_USE_SCRIPT_VALUE );
+	criteria.SetQuality( AE_USE_SCRIPT_VALUE );
+	criteria.BAddCondition( "name", k_EOperator_String_EQ, itemName, true );
+
+	CBaseEntity *pItem = ItemGeneration()->GenerateRandomItem( &criteria, pBot->GetAbsOrigin(), vec3_angle );
+	if ( pItem )
+	{
+		// If it's a weapon, remove the current one, and give us this one.
+		CBaseEntity	*pExisting = pBot->Weapon_OwnsThisType(pItem->GetClassname());
+		if ( pExisting )
+		{
+			CBaseCombatWeapon *pWpn = dynamic_cast<CBaseCombatWeapon *>(pExisting);
+			pBot->Weapon_Detach( pWpn );
+			UTIL_Remove( pExisting );
+		}
+
+		// Fake global id
+		static int s_nFakeID = 1;
+		static_cast<CEconEntity*>(pItem)->GetAttributeContainer()->GetItem()->SetItemID( s_nFakeID++ );
+
+		DispatchSpawn( pItem );
+		static_cast<CEconEntity*>(pItem)->GiveTo( pBot );
+
+		pBot->PostInventoryApplication();
+	}
+	else
+	{
+#ifdef STAGING_ONLY
+		extern ConVar tf_bot_use_items;
+		if ( !tf_bot_use_items.GetInt() )
+#endif
+		{
+			Msg( "Failed to create an item named %s\n", itemName );
+		}
+	}
+}
+
+void BotGenerateAndWearItem( CTFPlayer *pBot, CEconItemView *pItem )
+{
+	int iClass = pBot->GetPlayerClass()->GetClassIndex();
+	int iItemSlot = pItem->GetStaticData()->GetLoadoutSlot( iClass );
+	CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase*>( pBot->GetEntityForLoadoutSlot( iItemSlot ) );
+
+	// we need to force translating the name here.
+	// GiveNamedItem will not translate if we force creating the item
+	const char *pTranslatedWeaponName = TranslateWeaponEntForClass( pItem->GetStaticData()->GetItemClass(), iClass );
+	CTFWeaponBase *pNewItem = dynamic_cast<CTFWeaponBase*>( pBot->GiveNamedItem( pTranslatedWeaponName, 0, pItem, true ) );
+	if ( pNewItem )
+	{
+		CTFWeaponBuilder *pBuilder = dynamic_cast<CTFWeaponBuilder*>( (CBaseEntity*)pNewItem );
+		if ( pBuilder )
+		{
+			pBuilder->SetSubType( pBot->GetPlayerClass()->GetData()->m_aBuildable[0] );
+		}
+
+		// make sure we removed our current weapon				
+		if ( pWeapon )
+		{
+			pBot->Weapon_Detach( pWeapon );
+			UTIL_Remove( pWeapon );
+		}
+
+		pNewItem->MarkAttachedEntityAsValidated();
+		pNewItem->GiveTo( pBot );
+	}
+	else
+	{
+		BotGenerateAndWearItem( pBot, pItem->GetItemDefinition()->GetDefinitionName() );
+	}
+}
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void BotMirrorPlayerClassAndItems( CTFPlayer *pBot, CTFPlayer *pPlayer )
+{
+	if ( !pBot || !pPlayer )
+		return;
+
+	// Force them to be our class
+	if ( pPlayer->GetPlayerClass()->GetClassIndex() != pBot->GetPlayerClass()->GetClassIndex() )
+	{
+		pBot->AllowInstantSpawn();
+		pBot->HandleCommand_JoinClass( pPlayer->GetPlayerClass()->GetName() );
+	}
+
+	int nLastSlot = LOADOUT_POSITION_MISC2;
+
+#ifdef STAGING_ONLY
+	//nLastSlot = LOADOUT_POSITION_MISC10;
+#endif // STAGING_ONLY
+
+	pBot->RemoveAllItems( false );
+
+	for ( int i = 0; i <= nLastSlot; ++i )
+	{
+		CEconItemView *pPlayerItem = pPlayer->GetLoadoutItem( pPlayer->GetPlayerClass()->GetClassIndex(), i );
+		if ( !pPlayerItem )
+			continue;
+
+		BotGenerateAndWearItem( pBot, pPlayerItem );
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose:
+//------------------------------------------------------------------------------
+CON_COMMAND_F( bot_mirror, "Forces the specified bot to be the same class, and use the same items, as you.", FCVAR_CHEAT )
+{
+	CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_GetCommandClient() );
+	if ( !pTFPlayer )
+		return;
+
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 2, "Usage: bot_mirror <bot name>, or bot_mirror all", &botVector );
+	FOR_EACH_VEC( botVector, i )
+	{
+		BotMirrorPlayerClassAndItems( botVector[i], pTFPlayer );
+	}
+}
+
+#ifdef STAGING_ONLY
+//------------------------------------------------------------------------------
+// Purpose: Force the specified bot to create & equip an item
+//------------------------------------------------------------------------------
+void cc_bot_equip( const CCommand &args )
+{
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 3, "Usage: bot_equip <bot name> <item name>", &botVector );
+	
+	FOR_EACH_VEC( botVector, i )
+	{
+		BotGenerateAndWearItem( botVector[i], args[2] );
+	}
+}
+static ConCommand bot_equip("bot_equip", cc_bot_equip, "Generate an item and have the bot equip it.\n\tFormat: bot_equip <bot name> <item name>", FCVAR_CHEAT );
+
+//------------------------------------------------------------------------------
+// Purpose: Force the specified bot to disguise themselves. Needed because the disguise command is clientside.
+//------------------------------------------------------------------------------
+void cc_bot_disguise( const CCommand &args )
+{
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 4, "Usage: bot_disguise <bot name> <team> <class>", &botVector );
+	
+	FOR_EACH_VEC( botVector, i )
+	{
+		if ( botVector[i]->CanDisguise() )
+		{
+			// intercepting the team value and reassigning what gets passed into Disguise()
+			// because the team numbers in the client menu don't match the #define values for the teams
+			botVector[i]->m_Shared.Disguise( Q_atoi( args[2] ), Q_atoi( args[3] ) ); 
+		}
+	}
+}
+static ConCommand bot_disguise("bot_disguise", cc_bot_disguise, "Force the specified bot to disguise themselves.\n\tFormat: bot_disguise <bot name> <team> <class>", FCVAR_CHEAT );
+
+//------------------------------------------------------------------------------
+// Purpose: Force the specified bot to taunt with specific taunt name
+//------------------------------------------------------------------------------
+void cc_bot_taunt( const CCommand &args )
+{
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 3, "Usage: bot_taunt <bot name> <taunt_name>", &botVector );
+	
+	if ( botVector.IsEmpty() )
+		return;
+
+	const char *pszTauntName = args.ArgS() + V_strlen( args[1] ) + 1;
+
+	CEconItemDefinition *pItemDef = ItemSystem()->GetStaticDataForItemByName( pszTauntName );
+	if ( !pItemDef )
+	{
+		Msg( "bot_taunt: failed to find taunt name <%s>\n", pszTauntName );
+		return;
+	}
+
+	static CEconItemView item;
+	item.SetItemDefIndex( pItemDef->GetDefinitionIndex() );
+	item.SetItemQuality( pItemDef->GetQuality() );
+	item.SetInitialized( true );
+	
+	FOR_EACH_VEC( botVector, i )
+	{
+		botVector[i]->PlayTauntSceneFromItem( &item );
+	}
+}
+static ConCommand bot_taunt("bot_taunt", cc_bot_taunt, "Force the specified bot to taunt with specific taunt name.\n\tFormat: bot_taunt <bot name> <taunt_name>", FCVAR_CHEAT );
+
+
+#endif // STAGING_ONLY
+
+//------------------------------------------------------------------------------
+// Purpose: Force the specified bot to select a weapon in the specified slot
+//------------------------------------------------------------------------------
+CON_COMMAND_F( cc_bot_selectweapon, "Force a bot to select a weapon in a slot. Usage: bot_selectweapon <bot name> <weapon slot>", FCVAR_CHEAT )
+{
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 3, "Usage: bot_selectweapon <bot name> <weapon slot>", &botVector );
+	if ( botVector.IsEmpty() )
+		return;
+
+	int slot = atoi( args[2] );
+
+	FOR_EACH_VEC( botVector, i )
+	{
+		CBaseCombatWeapon *pWpn = botVector[i]->Weapon_GetSlot( slot );
+		if ( pWpn )
+		{
+			botVector[i]->Weapon_Switch( pWpn );
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: Force the specified bot to drop all his gear.
+//------------------------------------------------------------------------------
+CON_COMMAND_F( bot_drop, "Force the specified bot to drop his active weapon. Usage: bot_drop <bot name>", FCVAR_CHEAT )
+{
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 2, "Usage: bot_drop <bot name>", &botVector );
+	
+	FOR_EACH_VEC( botVector, i )
+	{
+		CBaseCombatWeapon* pWpn = botVector[i]->GetActiveWeapon();
+		if ( pWpn )
+		{
+			UTIL_Remove( pWpn );
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: Force the specified bot to move to the point under your crosshair
+//------------------------------------------------------------------------------
+CON_COMMAND_F( bot_moveto, "Force the specified bot to move to the point under your crosshair. Usage: bot_moveto <bot name>", FCVAR_CHEAT )
+{
+	CUtlVector< CTFPlayer* > botVector;
+	GetBotsFromCommand( args, 2, "Usage: bot_moveto <bot name>", &botVector );
+	if ( botVector.IsEmpty() )
+		return;
+
+	CBasePlayer *pPlayer = UTIL_GetCommandClient();
+	trace_t tr;
+	Vector forward;
+	pPlayer->EyeVectors( &forward );
+	UTIL_TraceLine( pPlayer->EyePosition(), pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_SOLID, pPlayer, COLLISION_GROUP_NONE, &tr );
+	if ( tr.fraction != 1.0 )
+	{
+		FOR_EACH_VEC( botVector, i )
+		{
+			botdata_t *botdata = BotData( botVector[i] );
+			botdata->FindPathTo( tr.endpos );
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+bool botdata_t::FindPathTo( Vector vecTarget )
+{
+	m_flRecomputePathAt = gpGlobals->curtime + bot_nav_recomputetime.GetFloat();
+	m_vecLastPathTarget = vecTarget;
+
+	ShortestPathCost cost;
+	CNavArea *pCurrentArea = TheNavMesh->GetNavArea( m_hBot->GetAbsOrigin() );
+	if ( !pCurrentArea )
+	{
+		Warning( "Bot '%s' not on the nav mesh.\n", m_hBot->GetPlayerName() );
+		return false;
+	}
+
+	CNavArea *pTargetArea = TheNavMesh->GetNavArea( vecTarget );
+	if ( !pTargetArea )
+	{
+		Warning( "Bot '%s' tried to move to a point that isn't on the nav mesh (%.2f %.2f %.2f).\n", m_hBot->GetPlayerName(), vecTarget.x, vecTarget.y, vecTarget.z );
+		return false;
+	}
+
+	// If the path stays within a single area, build a single waypoint and we're done.
+	if ( pTargetArea == pCurrentArea )
+	{
+		m_path[0].pos = vecTarget;
+		m_path[0].area = pCurrentArea;
+		m_path[0].how = NUM_TRAVERSE_TYPES;
+		m_iPathLength = 1;
+		m_iPathIndex = 0;
+		return true;
+	}
+
+	if ( NavAreaBuildPath( pCurrentArea, pTargetArea, &vecTarget, cost ) == false )
+	{
+		Warning( "Bot '%s' couldn't find a path from nav mesh %d to nav mesh %d.\n", m_hBot->GetPlayerName(), pCurrentArea->GetID(), pTargetArea->GetID() );
+		return false;
+	}
+
+	m_iPathIndex = 0;
+
+	// Count the number of areas in the path
+	int count = 0;
+	CNavArea *area;
+	for( area = pTargetArea; area; area = area->GetParent() )
+	{
+		++count;
+	}
+
+	bool bUseOffsetPaths = bot_nav_useoffsetpaths.GetBool();
+	if ( bUseOffsetPaths )
+	{
+		count = (count * 2) - 1;
+	}
+	m_iPathLength = count;
+
+	// Move the areas into our path
+	for( area = pTargetArea; count && area; area = area->GetParent() )
+	{
+		--count;
+		m_path[ count ].area = area;
+		m_path[ count ].how = area->GetParentHow();
+		m_path[ count ].flOffset = bUseOffsetPaths ? -bot_nav_offsetpathinset.GetFloat() : 0;
+
+		if ( bUseOffsetPaths && count >= 1 )
+		{
+			--count;
+			m_path[ count ].area = m_path[ count+1 ].area;
+			m_path[ count ].how = m_path[ count+1 ].how;
+			m_path[ count ].flOffset = m_path[ count+1 ].flOffset * -1;
+		}
+	}
+
+	if ( !ComputePathPositions() )
+	{
+		ResetPath();
+		return false;
+	}
+
+	// append path end position
+	m_path[ m_iPathLength ].area = pTargetArea;
+	m_path[ m_iPathLength ].pos = vecTarget;
+	m_path[ m_iPathLength ].how = NUM_TRAVERSE_TYPES;
+	m_path[ m_iPathLength ].flOffset = 0;
+	++m_iPathLength;
+	return true;
+}
+
+//------------------------------------------------------------------------------
+// Purpose: Given a path of areas, compute waypoints along the path
+//------------------------------------------------------------------------------
+bool botdata_t::ComputePathPositions( void )
+{
+	if (m_iPathLength == 0)
+		return false;
+
+	m_path[0].pos = m_hBot->GetAbsOrigin();//m_path[0].area->GetCenter();
+	m_path[0].how = NUM_TRAVERSE_TYPES;
+
+	for( int i=1; i<m_iPathLength; ++i )
+	{
+		const ConnectInfo *from = &m_path[ i-1 ];
+		ConnectInfo *to = &m_path[ i ];
+		Vector vecFrom = from->pos;
+
+		if ( to->flOffset < 0 && i >= 2 )
+		{
+			from = &m_path[ i-2 ];
+		}
+
+		from->area->ComputeClosestPointInPortal( to->area, (NavDirType)to->how, from->pos, &to->pos );
+		to->pos.z = from->area->GetZ( to->pos );
+
+		if ( to->flOffset )
+		{
+			// Create a waypoint just inside our current area
+			AddDirectionVector( &to->pos, (NavDirType)to->how, -to->flOffset );
+		}
+
+		if ( bot_debug.GetInt() == 2 )
+		{
+			NDebugOverlay::HorzArrow( vecFrom, to->pos, 3, 0, 96, 0, 0, true, 10.0 );
+		}
+	}
+
+	return true;
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+bool botdata_t::UpdatePath( void )
+{
+	// If we're going to an entity, make sure it hasn't moved.
+	if ( CommandHasATarget() )
+	{
+		if ( m_flRecomputePathAt < gpGlobals->curtime && m_Commands[0].pTarget )
+		{
+			Vector vecNewTarget = m_Commands[0].pTarget->GetAbsOrigin();
+			if ( (m_vecLastPathTarget - vecNewTarget).LengthSqr() > (50 * 50) )
+				return FindPathTo( vecNewTarget );
+		}
+	}
+	return true;
+}
+
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void botdata_t::UpdatePlanForCommand( void )
+{
+	if ( !m_Commands.Count() )
+		return;
+
+	if ( !m_bStartedCommand )
+	{
+		StartNewCommand();
+		m_bStartedCommand = true;
+	}
+
+	switch ( m_Commands[0].iCommand )
+	{
+	case BC_ATTACK:
+		{
+			RunAttackPlan();
+		}
+		break;
+	case BC_MOVETO_ENTITY:
+		{
+			if ( !HasPath() )
+			{
+				if ( FindPathTo( m_Commands[0].pTarget->GetAbsOrigin() ) == false )
+				{
+					FinishCommand();
+				}
+			}
+		}
+		break;
+	case BC_MOVETO_POINT:
+		{
+			if ( !HasPath() )
+			{
+				if ( FindPathTo( GetCommandPosition() ) == false )
+				{
+					FinishCommand();
+				}
+			}
+		}
+		break;
+	case BC_SWITCH_WEAPON:
+		{
+			CBaseCombatWeapon *pWpn = m_hBot->Weapon_GetSlot( (int)m_Commands[0].flData );
+			if ( pWpn )
+			{
+				m_hBot->Weapon_Switch( pWpn );
+			}
+			FinishCommand();
+		}
+		break;
+	case BC_DEFEND:
+		{
+			RunDefendPlan();
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void botdata_t::RunAttackPlan( void )
+{
+	CBaseEntity *pEnt = GetCommandTarget();
+	if ( !pEnt )
+		return;
+
+	if ( !pEnt->IsAlive() )
+	{
+		FinishCommand();
+		return;
+	}
+
+	bool bCanSeeTarget = m_hBot->FVisible( pEnt );
+	bool bNeedsAPath = !bCanSeeTarget;
+
+	if ( bCanSeeTarget )
+	{
+		float flDistance = (pEnt->GetAbsOrigin() - m_hBot->GetAbsOrigin()).LengthSqr();
+
+		// If it's a melee weapon, we need to close. Otherwise, stay at a nice looking distance.
+		if ( m_hBot->GetActiveTFWeapon() && m_hBot->GetActiveTFWeapon()->IsMeleeWeapon()  )
+		{
+			float flRange = bot_com_meleerange.GetFloat();
+			flRange *= flRange;
+			bNeedsAPath = ( flDistance > flRange );
+			if ( !bNeedsAPath )
+			{
+				buttons |= IN_ATTACK;
+			}
+		}
+		else
+		{
+			float flRange = bot_com_wpnrange.GetFloat();
+			flRange *= flRange;
+			bNeedsAPath = ( flDistance > (500 * 500) );
+			buttons |= IN_ATTACK;
+		}
+	}
+
+	if ( bNeedsAPath && !HasPath() )
+	{
+		if ( FindPathTo( m_Commands[0].pTarget->GetAbsOrigin() ) == false )
+		{
+			FinishCommand();
+			return;
+		}
+	}
+	else if ( !bNeedsAPath && HasPath() )
+	{
+		ResetPath();
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void botdata_t::RunDefendPlan( void )
+{
+	if ( bot_debug.GetInt() == 5 )
+	{
+		NDebugOverlay::Line( m_hBot->GetAbsOrigin(), GetCommandPosition(), 0, 128, 0, true, 0.1 );
+	}
+
+	if ( !FindEnemyTarget() )
+	{
+		if ( !HasPath() )
+		{
+			// If we're far from our defend point, move back to it.
+			float flDistance = (GetCommandPosition() - m_hBot->GetAbsOrigin()).LengthSqr();
+			if ( flDistance > (32*32) )
+			{
+				if ( FindPathTo( GetCommandPosition() ) == false )
+				{
+					// Can't get back to our defend position
+					FinishCommand();
+					return;
+				}
+			}
+		}
+		return;
+	}
+
+	Assert( m_hEnemy.Get() );
+
+	if ( bot_debug.GetInt() == 5 )
+	{
+		NDebugOverlay::Line( m_hBot->GetAbsOrigin(), m_hEnemy->GetAbsOrigin(), 255, 0, 0, true, 0.1 );
+	}
+
+	// We've got an enemy.
+	float flDefendRange = m_Commands[0].flData * m_Commands[0].flData;
+	float flDistanceToEnemy = (m_hEnemy->GetAbsOrigin() - m_hBot->GetAbsOrigin()).LengthSqr();
+	float flDistanceToEnemyFromDefend = (m_hEnemy->GetAbsOrigin() - GetCommandPosition()).LengthSqr();
+
+	bool bNeedsAPath = false;
+
+	// If it's a melee weapon, we need to close. Otherwise, stay at a nice looking distance.
+	if ( m_hBot->GetActiveTFWeapon() && m_hBot->GetActiveTFWeapon()->IsMeleeWeapon()  )
+	{
+		// We can only close if we're allowed to move to the target's distance.
+		if ( flDistanceToEnemyFromDefend <= flDefendRange )
+		{
+			float flRange = bot_com_meleerange.GetFloat();
+			flRange *= flRange;
+			bNeedsAPath = ( flDistanceToEnemy > flRange );
+			if ( !bNeedsAPath )
+			{
+				buttons |= IN_ATTACK;
+			}
+		}
+	}
+	else
+	{
+		buttons |= IN_ATTACK;
+	}
+
+	if ( bNeedsAPath && !HasPath() )
+	{
+		FindPathTo( m_hEnemy->GetAbsOrigin() );
+	}
+	else if ( !bNeedsAPath && HasPath() )
+	{
+		ResetPath();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Look for a target
+//-----------------------------------------------------------------------------
+bool botdata_t::FindEnemyTarget( void )
+{
+	Vector vecEyePosition = m_hBot->EyePosition();
+
+	// find the enemy team
+	int iEnemyTeam = ( m_hBot->GetTeamNumber() == TF_TEAM_BLUE ) ? TF_TEAM_RED : TF_TEAM_BLUE;
+	CTFTeam *pTeam = TFTeamMgr()->GetTeam( iEnemyTeam );
+	if ( !pTeam )
+		return false;
+
+	// If we have an enemy get his minimum distance to check against.
+	Vector vecSegment;
+	Vector vecTargetCenter;
+	float flMinDist2 = bot_com_viewrange.GetFloat();
+	flMinDist2 *= flMinDist2;
+	CBaseEntity *pTargetCurrent = NULL;
+	CBaseEntity *pTargetOld = m_hEnemy;
+	float flOldTargetDist2 = FLT_MAX;
+
+	// Try to target players first, then objects.  However, if the enemy held was an object it will continue
+	// to try and attack it first.
+	int nTeamCount = pTeam->GetNumPlayers();
+	for ( int iPlayer = 0; iPlayer < nTeamCount; ++iPlayer )
+	{
+		CTFPlayer *pTargetPlayer = static_cast<CTFPlayer*>( pTeam->GetPlayer( iPlayer ) );
+		if ( pTargetPlayer == NULL )
+			continue;
+
+		// Make sure the player is alive.
+		if ( !pTargetPlayer->IsAlive() )
+			continue;
+
+		if ( pTargetPlayer->GetFlags() & FL_NOTARGET )
+			continue;
+
+		vecTargetCenter = pTargetPlayer->GetAbsOrigin();
+		vecTargetCenter += pTargetPlayer->GetViewOffset();
+		VectorSubtract( vecTargetCenter, vecEyePosition, vecSegment );
+		float flDist2 = vecSegment.LengthSqr();
+
+		// Check to see if the target is closer than the already validated target.
+		if ( flDist2 > flMinDist2 )
+			continue;
+
+		// It is closer, check to see if the target is valid.
+		if ( ValidTargetPlayer( pTargetPlayer, vecEyePosition, vecTargetCenter ) )
+		{
+			flMinDist2 = flDist2;
+			pTargetCurrent = pTargetPlayer;
+
+			// Store the current target distance if we come across it
+			if ( pTargetPlayer == pTargetOld )
+			{
+				flOldTargetDist2 = flDist2;
+			}
+		}
+	}
+
+	// If we already have a target, don't check objects.
+	if ( pTargetCurrent == NULL )
+	{
+		int nTeamObjectCount = pTeam->GetNumObjects();
+		for ( int iObject = 0; iObject < nTeamObjectCount; ++iObject )
+		{
+			CBaseObject *pTargetObject = pTeam->GetObject( iObject );
+			if ( !pTargetObject )
+				continue;
+
+			vecTargetCenter = pTargetObject->GetAbsOrigin();
+			vecTargetCenter += pTargetObject->GetViewOffset();
+			VectorSubtract( vecTargetCenter, vecEyePosition, vecSegment );
+			float flDist2 = vecSegment.LengthSqr();
+
+			// Store the current target distance if we come across it
+			if ( pTargetObject == pTargetOld )
+			{
+				flOldTargetDist2 = flDist2;
+			}
+
+			// Check to see if the target is closer than the already validated target.
+			if ( flDist2 > flMinDist2 )
+				continue;
+
+			// It is closer, check to see if the target is valid.
+			if ( ValidTargetObject( pTargetObject, vecEyePosition, vecTargetCenter ) )
+			{
+				flMinDist2 = flDist2;
+				pTargetCurrent = pTargetObject;
+			}
+		}
+	}
+
+	// We have a target.
+	if ( pTargetCurrent )
+	{
+		if ( pTargetCurrent != pTargetOld )
+		{
+			// flMinDist2 is the new target's distance
+			// flOldTargetDist2 is the old target's distance
+			// Don't switch unless the new target is closer by some percentage
+			if ( flMinDist2 < ( flOldTargetDist2 * 0.75f ) )
+			{
+				m_hEnemy = pTargetCurrent;
+			}
+		}
+		return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool botdata_t::ValidTargetPlayer( CTFPlayer *pPlayer, const Vector &vecStart, const Vector &vecEnd )
+{
+	if ( m_bIgnoreHumans && !pPlayer->IsFakeClient() )
+		return false;
+
+	// Keep shooting at spies that go invisible after we acquire them as a target.
+	if ( pPlayer->m_Shared.GetPercentInvisible() > 0.5 )
+		return false;
+
+	// Keep shooting at spies that disguise after we acquire them as at a target.
+	if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pPlayer->m_Shared.GetDisguiseTeam() == m_hBot->GetTeamNumber() && pPlayer != m_hEnemy )
+		return false;
+
+	// Not across water boundary.
+	if ( ( m_hBot->GetWaterLevel() == 0 && pPlayer->GetWaterLevel() >= 3 ) || ( m_hBot->GetWaterLevel() == 3 && pPlayer->GetWaterLevel() <= 0 ) )
+		return false;
+
+	// Ray trace!!!
+	return m_hBot->FVisible( pPlayer, MASK_SHOT | CONTENTS_GRATE );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool botdata_t::ValidTargetObject( CBaseObject *pObject, const Vector &vecStart, const Vector &vecEnd )
+{
+	// Ignore objects being placed, they are not real objects yet.
+	if ( pObject->IsPlacing() )
+		return false;
+
+	// Ignore sappers.
+	if ( pObject->MustBeBuiltOnAttachmentPoint() )
+		return false;
+
+	// Not across water boundary.
+	if ( ( m_hBot->GetWaterLevel() == 0 && pObject->GetWaterLevel() >= 3 ) || ( m_hBot->GetWaterLevel() == 3 && pObject->GetWaterLevel() <= 0 ) )
+		return false;
+
+	if ( pObject->GetObjectFlags() & OF_DOESNT_HAVE_A_MODEL )
+		return false;
+
+	// Ray trace.
+	return m_hBot->FVisible( pObject, MASK_SHOT | CONTENTS_GRATE );
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void botdata_t::StartNewCommand( void )
+{
+	switch ( m_Commands[0].iCommand )
+	{
+	case BC_DEFEND:
+		{
+			// Mark our current position as the point we're defending
+			m_Commands[0].vecTarget = m_hBot->GetAbsOrigin();
+		}
+		break;
+
+	case BC_ATTACK:
+	case BC_MOVETO_ENTITY:
+	case BC_MOVETO_POINT:
+	case BC_SWITCH_WEAPON:
+	default:
+		break;
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void botdata_t::FinishCommand( void )
+{
+	if ( m_Commands.Count() > 0 )
+	{
+		m_hBotController->m_outputOnCommandFinished.FireOutput( m_hBot, m_hBot );
+		m_Commands.Remove(0);
+	}
+	m_bStartedCommand = false;
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void botdata_t::AddAttackCommand( CBaseEntity *pTarget )
+{
+	int iIndex = m_Commands.AddToTail();
+	m_Commands[iIndex].iCommand = BC_ATTACK;
+	m_Commands[iIndex].pTarget = pTarget;
+	m_Commands[iIndex].vecTarget = vec3_origin;
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void botdata_t::AddMoveToCommand( CBaseEntity *pTarget, Vector vecTarget )
+{
+	int iIndex = m_Commands.AddToTail();
+	m_Commands[iIndex].iCommand = pTarget ? BC_MOVETO_ENTITY : BC_MOVETO_POINT;
+	m_Commands[iIndex].pTarget = pTarget;
+	m_Commands[iIndex].vecTarget = vecTarget;
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void botdata_t::AddSwitchWeaponCommand( int iSlot )
+{
+	int iIndex = m_Commands.AddToTail();
+	m_Commands[iIndex].iCommand = BC_SWITCH_WEAPON;
+	m_Commands[iIndex].flData = iSlot;
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void botdata_t::AddDefendCommand( float flRange )
+{
+	int iIndex = m_Commands.AddToTail();
+	m_Commands[iIndex].iCommand = BC_DEFEND;
+	m_Commands[iIndex].flData = flRange;
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void botdata_t::ClearQueue( void )
+{
+	FinishCommand();
+	m_Commands.Purge();
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+bool botdata_t::RunningMovementCommand( void )
+{
+	if ( m_Commands.Count() )
+		return ( m_Commands[0].iCommand == BC_MOVETO_ENTITY || m_Commands[0].iCommand == BC_MOVETO_POINT );
+	return false;
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+bool botdata_t::CommandHasATarget( void )
+{
+	return ( m_Commands.Count() && (m_Commands[0].iCommand == BC_MOVETO_ENTITY || m_Commands[0].iCommand == BC_ATTACK) );
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+bool botdata_t::ShouldFinishCommandOnArrival( void )
+{
+	return ( m_Commands.Count() && (m_Commands[0].iCommand == BC_MOVETO_ENTITY || m_Commands[0].iCommand == BC_MOVETO_POINT) );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle movement
+//-----------------------------------------------------------------------------
+void botdata_t::Bot_ItemTestingThink( QAngle *vecAngles, Vector *vecMove )
+{
+	switch ( TFGameRules()->ItemTesting_GetBotAnim() )
+	{
+	default:
+	case TI_BOTANIM_IDLE:
+		break;
+
+	case TI_BOTANIM_CROUCH:
+		buttons |= IN_DUCK;
+		break;
+
+	case TI_BOTANIM_RUN:
+		break;
+
+	case TI_BOTANIM_CROUCH_WALK:
+		buttons |= IN_DUCK;
+		break;
+
+	case TI_BOTANIM_JUMP:
+		if ( m_hBot->GetFlags() & FL_ONGROUND )
+		{
+			buttons |= IN_JUMP;
+		}
+		break;
+	}
+
+	if ( TFGameRules()->ItemTesting_GetBotForceFire() )
+	{
+		// Hack to make them not fire faster than the anims being played?
+		//if ( !m_hBot->GetAnimState()->IsGestureSlotActive( GESTURE_SLOT_ATTACK_AND_RELOAD ) )
+		buttons |= IN_ATTACK;
+	}
+
+	if ( TFGameRules()->ItemTesting_GetBotTurntable() )
+	{
+		(*vecAngles)[YAW] += (1.0f * TFGameRules()->ItemTesting_GetBotAnimSpeed());
+		if ( (*vecAngles)[YAW] > 360 )
+		{
+			(*vecAngles)[YAW] = 0;
+		}
+	}
+
+	(*vecMove)[0] = 0;
+	(*vecMove)[1] = 0;
+	(*vecMove)[2] = 0;
+}
+
+//===================================================================================================================
+// Purpose: Mapmaker bot control entity. Used by mapmakers to add & script bot behaviors.
+BEGIN_DATADESC( CTFBotController )
+	DEFINE_KEYFIELD( m_iszBotName, FIELD_STRING, "bot_name" ),
+	DEFINE_KEYFIELD( m_iBotClass, FIELD_INTEGER, "bot_class" ),
+
+	DEFINE_INPUTFUNC( FIELD_VOID, "CreateBot", InputCreateBot ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "RespawnBot", InputRespawnBot ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "AddCommandMoveToEntity", InputBotAddCommandMoveToEntity ),
+	DEFINE_INPUTFUNC( FIELD_STRING, "AddCommandAttackEntity", InputBotAddCommandAttackEntity ),
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "AddCommandSwitchWeapon", InputBotAddCommandSwitchWeapon ),
+	DEFINE_INPUTFUNC( FIELD_FLOAT, "AddCommandDefend", InputBotAddCommandDefend ),
+	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetIgnoreHumans", InputBotSetIgnoreHumans ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "PreventMovement", InputBotPreventMovement ),
+	DEFINE_INPUTFUNC( FIELD_VOID, "ClearQueue", InputBotClearQueue ),
+
+	DEFINE_OUTPUT( m_outputOnCommandFinished, "OnCommandFinished" ),
+END_DATADESC()
+
+LINK_ENTITY_TO_CLASS( bot_controller, CTFBotController );
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void CTFBotController::InputCreateBot( inputdata_t &inputdata )
+{
+	m_hBot = ToTFPlayer( BotPutInServer( false, false, GetTeamNumber(), m_iBotClass ? m_iBotClass : TF_CLASS_RANDOM, STRING(m_iszBotName) ) );
+	if ( m_hBot )
+	{
+		BotData(m_hBot)->m_hBotController = this;
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void CTFBotController::InputRespawnBot( inputdata_t &inputdata )
+{
+	if ( !m_hBot->GetPlayerClass() || m_hBot->GetPlayerClass()->GetClassIndex() == TF_CLASS_UNDEFINED )
+	{
+		// Allow them to spawn instantly when they do choose
+		m_hBot->AllowInstantSpawn();
+		return;
+	}
+
+	m_hBot->ForceRespawn();
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void CTFBotController::InputBotAddCommandMoveToEntity( inputdata_t &inputdata )
+{
+	const char *pszEntName = inputdata.value.String();
+	if ( pszEntName && pszEntName[0] )
+	{
+		CBaseEntity *pEnt = gEntList.FindEntityByName( NULL, pszEntName );
+		if ( pEnt )
+		{
+			BotData(m_hBot)->AddMoveToCommand( pEnt, vec3_origin );
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void CTFBotController::InputBotAddCommandAttackEntity( inputdata_t &inputdata )
+{
+	const char *pszEntName = inputdata.value.String();
+	if ( pszEntName && pszEntName[0] )
+	{
+		CBaseEntity *pEnt = gEntList.FindEntityByName( NULL, pszEntName );
+		if ( pEnt )
+		{
+			BotData(m_hBot)->AddAttackCommand( pEnt );
+		}
+	}
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void CTFBotController::InputBotAddCommandSwitchWeapon( inputdata_t &inputdata )
+{
+	BotData(m_hBot)->AddSwitchWeaponCommand( inputdata.value.Int() );
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void CTFBotController::InputBotAddCommandDefend( inputdata_t &inputdata )
+{
+	BotData(m_hBot)->AddDefendCommand( inputdata.value.Float() );
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void CTFBotController::InputBotSetIgnoreHumans( inputdata_t &inputdata )
+{
+	BotData(m_hBot)->SetIgnoreHumans( inputdata.value.Int() > 0 );
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void CTFBotController::InputBotPreventMovement( inputdata_t &inputdata )
+{
+	BotData(m_hBot)->SetFrozen( inputdata.value.Bool() );
+}
+
+//------------------------------------------------------------------------------
+// Purpose: 
+//------------------------------------------------------------------------------
+void CTFBotController::InputBotClearQueue( inputdata_t &inputdata )
+{
+	BotData(m_hBot)->ClearQueue();
+}
+