1HEADmaster

1 files changed, 1080 insertions, 0 deletions

diff --git a/game/server/tf/bot/tf_bot.h b/game/server/tf/bot/tf_bot.h
new file mode 100644
index 0000000..62be222
--- /dev/null
+++ b/game/server/tf/bot/tf_bot.h
@@ -0,0 +1,1080 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+// tf_bot.h
+// Team Fortress NextBot
+// Michael Booth, February 2009
+
+#ifndef TF_BOT_H
+#define TF_BOT_H
+
+#include "Player/NextBotPlayer.h"
+#include "../nav_mesh/tf_nav_mesh.h"
+#include "tf_bot_vision.h"
+#include "tf_bot_body.h"
+#include "tf_bot_locomotion.h"
+#include "tf_player.h"
+#include "tf_bot_squad.h"
+#include "bot/map_entities/tf_bot_proxy.h"
+#include "tf_gamerules.h"
+#include "entity_capture_flag.h"
+#include "func_capture_zone.h"
+#include "nav_entities.h"
+#include "utlstack.h"
+
+#define TF_BOT_TYPE	1337
+
+class CTriggerAreaCapture;
+class CTFBotActionPoint;
+class CObjectSentrygun;
+class CTFBotGenerator;
+
+extern void BotGenerateAndWearItem( CTFPlayer *pBot, const char *itemName );
+
+//----------------------------------------------------------------------------
+// These must remain in sync with the bot_generator's spawnflags in tf.fgd:
+#define TFBOT_IGNORE_ENEMY_SCOUTS		0x0001
+#define TFBOT_IGNORE_ENEMY_SOLDIERS		0x0002
+#define TFBOT_IGNORE_ENEMY_PYROS		0x0004
+#define TFBOT_IGNORE_ENEMY_DEMOMEN		0x0008
+#define TFBOT_IGNORE_ENEMY_HEAVIES		0x0010
+#define TFBOT_IGNORE_ENEMY_MEDICS		0x0020
+#define TFBOT_IGNORE_ENEMY_ENGINEERS	0x0040
+#define TFBOT_IGNORE_ENEMY_SNIPERS		0x0080
+#define TFBOT_IGNORE_ENEMY_SPIES		0x0100
+#define TFBOT_IGNORE_ENEMY_SENTRY_GUNS	0x0200
+#define TFBOT_IGNORE_SCENARIO_GOALS		0x0400
+
+#define TFBOT_ALL_BEHAVIOR_FLAGS		0xFFFF
+
+#define TFBOT_MVM_MAX_PATH_LENGTH		0.0f // 7000.0f			// in MvM, all pathfinds are limited to this (0 == no limit)
+
+
+//----------------------------------------------------------------------------
+class CTFBot: public NextBotPlayer< CTFPlayer >, public CGameEventListener
+{
+public:
+	DECLARE_CLASS( CTFBot, NextBotPlayer< CTFPlayer > );
+
+	CTFBot();
+	virtual ~CTFBot();
+
+	virtual void		Spawn();
+	virtual void		FireGameEvent( IGameEvent *event );
+	virtual void		Event_Killed( const CTakeDamageInfo &info );
+	virtual void		PhysicsSimulate( void );
+	virtual void		Touch( CBaseEntity *pOther );
+	virtual void		AvoidPlayers( CUserCmd *pCmd );				// some game types allow players to pass through each other, this method pushes them apart
+	virtual void		UpdateOnRemove( void );
+	virtual int			ShouldTransmit( const CCheckTransmitInfo *pInfo ) OVERRIDE;
+	virtual void		ChangeTeam( int iTeamNum, bool bAutoTeam, bool bSilent, bool bAutoBalance = false ) OVERRIDE;
+	virtual bool		ShouldGib( const CTakeDamageInfo &info ) OVERRIDE;
+
+	virtual int			DrawDebugTextOverlays(void);
+
+	virtual bool IsAllowedToPickUpFlag( void ) const;
+
+	virtual void		InitClass( void );				// set health/etc 
+	void				ModifyMaxHealth( int nNewMaxHealth, bool bSetCurrentHealth = true, bool bAllowModelScaling = true );
+
+	virtual int GetBotType( void ) const;				// return a unique int representing the type of bot instance this is
+
+	virtual CTFNavArea *GetLastKnownArea( void ) const		{ return static_cast< CTFNavArea * >( BaseClass::GetLastKnownArea() ); }		// return the last nav area the player occupied - NULL if unknown
+
+	// NextBotPlayer
+	static CBasePlayer *AllocatePlayerEntity( edict_t *pEdict, const char *playerName );
+
+	virtual void PressFireButton( float duration = -1.0f ) OVERRIDE;
+	virtual void PressAltFireButton( float duration = -1.0f ) OVERRIDE;
+	virtual void PressSpecialFireButton( float duration = -1.0f ) OVERRIDE;
+
+	// INextBot
+	virtual CTFBotLocomotion	*GetLocomotionInterface( void ) const	{ return m_locomotor; }
+	virtual CTFBotBody			*GetBodyInterface( void ) const			{ return m_body; }
+	virtual CTFBotVision		*GetVisionInterface( void ) const		{ return m_vision; }
+	DECLARE_INTENTION_INTERFACE( CTFBot );
+
+	virtual bool IsDormantWhenDead( void ) const;			// should this player-bot continue to update itself when dead (respawn logic, etc)
+
+	virtual void OnWeaponFired( CBaseCombatCharacter *whoFired, CBaseCombatWeapon *weapon );		// when someone fires their weapon
+
+	virtual bool IsDebugFilterMatch( const char *name ) const;	// return true if we match the given debug symbol
+
+	virtual int	GetAllowedTauntPartnerTeam() const OVERRIDE { return GetTeamNumber(); }
+
+	// CTFBot specific
+	CTeamControlPoint *GetMyControlPoint( void ) const;				// return point we want to capture, or need to defend
+	void ClearMyControlPoint( void );
+	bool WasPointJustLost( void ) const;							// return true if we just lost territory recently
+	bool AreAllPointsUncontestedSoFar( void ) const;				// return true if no enemy has contested any point yet
+	bool IsPointBeingCaptured( CTeamControlPoint *point ) const;	// return true if the given point is being captured
+	bool IsAnyPointBeingCaptured( void ) const;						// return true if any point is being captured
+	bool IsNearPoint( CTeamControlPoint *point ) const;				// return true if we are within a short travel distance of the current point
+	float GetTimeLeftToCapture( void ) const;						// return time left to capture the point before we lose the game
+
+	CCaptureFlag *GetFlagToFetch( void ) const;						// return flag we want to fetch
+	CCaptureZone *GetFlagCaptureZone( void ) const;					// return capture zone for our flag(s)
+
+	struct SniperSpotInfo
+	{
+		CTFNavArea *m_vantageArea;
+		Vector m_vantageSpot;
+
+		CTFNavArea *m_theaterArea;
+		Vector m_theaterSpot;
+
+		float m_range;
+		float m_advantage;				// the difference in how long it takes us to reach our vantage spot vs them to reach the theater spot
+	};
+
+	void AccumulateSniperSpots( void );									// find good sniping spots and store them
+	const CUtlVector< SniperSpotInfo > *GetSniperSpots( void ) const;	// return vector of good sniping positions
+	bool HasSniperSpots( void ) const;
+	void ClearSniperSpots( void );
+
+	// search outwards from startSearchArea and collect all reachable objects from the given list that pass the given filter
+	void SelectReachableObjects( const CUtlVector< CHandle< CBaseEntity > > &candidateObjectVector, CUtlVector< CHandle< CBaseEntity > > *selectedObjectVector, const INextBotFilter &filter, CNavArea *startSearchArea, float maxRange = 2000.0f ) const;
+	CBaseEntity *FindClosestReachableObject( const char *objectName, CNavArea *from, float maxRange = 2000.0f ) const;
+
+	CTFNavArea *GetSpawnArea( void ) const;							// get area where we spawned in
+
+	bool IsAmmoLow( void ) const;
+	bool IsAmmoFull( void ) const;
+
+	void UpdateLookingAroundForEnemies( void );						// update our view to keep an eye on enemies, and where enemies come from
+
+	#define LOOK_FOR_FRIENDS false
+	#define LOOK_FOR_ENEMIES true
+	void UpdateLookingAroundForIncomingPlayers( bool lookForEnemies );	// update our view to watch where friends or enemies will be coming from
+	void StartLookingAroundForEnemies( void );						// enable updating view for enemy searching
+	void StopLookingAroundForEnemies( void );						// disable updating view for enemy searching
+
+	void SetAttentionFocus( CBaseEntity *focusOn );					// restrict bot's attention to only this entity (or radius around this entity) to the exclusion of everything else
+	void ClearAttentionFocus( void );								// remove attention focus restrictions
+	bool IsAttentionFocused( void ) const;
+	bool IsAttentionFocusedOn( CBaseEntity *who ) const;
+
+	void DelayedThreatNotice( CHandle< CBaseEntity > who, float noticeDelay );	// notice the given threat after the given number of seconds have elapsed
+	void UpdateDelayedThreatNotices( void );
+
+	CTFNavArea *FindVantagePoint( float maxTravelDistance = 2000.0f ) const;	// return a nearby area where we can see a member of the enemy team
+
+	const char *GetNextSpawnClassname( void ) const;
+
+	float GetThreatDanger( CBaseCombatCharacter *who ) const;		// return perceived danger of threat (0=none, 1=immediate deadly danger)
+	float GetMaxAttackRange( void ) const;							// return the max range at which we can effectively attack
+	float GetDesiredAttackRange( void ) const;						// return the ideal range at which we can effectively attack
+
+	bool EquipRequiredWeapon( void );								// if we're required to equip a specific weapon, do it.
+	void EquipBestWeaponForThreat( const CKnownEntity *threat );	// equip the best weapon we have to attack the given threat
+	bool EquipLongRangeWeapon( void );								// equip a weapon that can damage far-away targets
+
+	void PushRequiredWeapon( CTFWeaponBase *weapon );				// force us to equip and use this weapon until popped off the required stack
+	void PopRequiredWeapon( void );									// pop top required weapon off of stack and discard
+
+	#define MY_CURRENT_GUN NULL										// can be passed as weapon to following queries
+	bool IsCombatWeapon( CTFWeaponBase *weapon ) const;				// return true if given weapon can be used to attack
+	bool IsHitScanWeapon( CTFWeaponBase *weapon ) const;			// return true if given weapon is a "hitscan" weapon (scattered tracelines with instant damage)
+	bool IsContinuousFireWeapon( CTFWeaponBase *weapon ) const;		// return true if given weapon "sprays" bullets/fire/etc continuously (ie: not individual rockets/etc)
+	bool IsExplosiveProjectileWeapon( CTFWeaponBase *weapon ) const;// return true if given weapon launches explosive projectiles with splash damage
+	bool IsBarrageAndReloadWeapon( CTFWeaponBase *weapon ) const;	// return true if given weapon has small clip and long reload cost (ie: rocket launcher, etc)
+	bool IsQuietWeapon( CTFWeaponBase *weapon ) const;				// return true if given weapon doesn't make much sound when used (ie: spy knife, etc)
+
+	bool IsEnvironmentNoisy( void ) const;							// return true if there are/have been loud noises (ie: non-quiet weapons) nearby very recently
+
+	enum WeaponRestrictionType
+	{
+		ANY_WEAPON		= 0,
+		MELEE_ONLY		= 0x0001,
+		PRIMARY_ONLY	= 0x0002,
+		SECONDARY_ONLY	= 0x0004,
+	};
+	void ClearWeaponRestrictions( void );
+	void SetWeaponRestriction( int restrictionFlags );
+	bool HasWeaponRestriction( int restrictionFlags ) const;
+	bool IsWeaponRestricted( CTFWeaponBase *weapon ) const;
+
+	bool ShouldFireCompressionBlast( void );
+
+	bool IsLineOfFireClear( const Vector &where ) const;			// return true if a weapon has no obstructions along the line from our eye to the given position
+	bool IsLineOfFireClear( CBaseEntity *who ) const;				// return true if a weapon has no obstructions along the line from our eye to the given entity
+	bool IsLineOfFireClear( const Vector &from, const Vector &to ) const;			// return true if a weapon has no obstructions along the line between the given points
+	bool IsLineOfFireClear( const Vector &from, CBaseEntity *who ) const;			// return true if a weapon has no obstructions along the line between the given point and entity
+
+	bool IsEntityBetweenTargetAndSelf( CBaseEntity *other, CBaseEntity *target );	// return true if "other" is positioned inbetween us and "target"
+
+	class SuspectedSpyInfo_t
+	{
+	public:
+		bool IsCurrentlySuspected();
+		void Suspect(); // The verb form of the word, not the noun.
+		bool TestForRealizing();
+		CHandle< CTFPlayer > m_suspectedSpy;
+
+	private:
+
+		
+		CUtlVector< int > m_touchTimes;
+	};
+
+	bool IsKnownSpy( CTFPlayer *player ) const;				// return true if we are sure this player actually is an enemy spy
+	SuspectedSpyInfo_t* IsSuspectedSpy( CTFPlayer *player );			// return true if we suspect this player might be an enemy spy
+	void SuspectSpy( CTFPlayer *player );					// note that this player might be a spy
+	void RealizeSpy( CTFPlayer *player );					// note that this player *IS* a spy
+	void ForgetSpy( CTFPlayer *player );					// remove player from spy suspect system
+	void StopSuspectingSpy( CTFPlayer *pPlayer );
+
+	CTFPlayer *GetClosestHumanLookingAtMe( int team = TEAM_ANY ) const;	// return the nearest human player on the given team who is looking directly at me
+
+	enum AttributeType
+	{
+		REMOVE_ON_DEATH				= 1<<0,					// kick bot from server when killed
+		AGGRESSIVE					= 1<<1,					// in MvM mode, push for the cap point
+		IS_NPC						= 1<<2,					// a non-player support character
+		SUPPRESS_FIRE				= 1<<3,
+		DISABLE_DODGE				= 1<<4,
+		BECOME_SPECTATOR_ON_DEATH	= 1<<5,					// move bot to spectator team when killed
+		QUOTA_MANANGED				= 1<<6,					// managed by the bot quota in CTFBotManager 
+		RETAIN_BUILDINGS			= 1<<7,					// don't destroy this bot's buildings when it disconnects
+		SPAWN_WITH_FULL_CHARGE		= 1<<8,					// all weapons start with full charge (ie: uber)
+		ALWAYS_CRIT					= 1<<9,					// always fire critical hits
+		IGNORE_ENEMIES				= 1<<10,
+		HOLD_FIRE_UNTIL_FULL_RELOAD	= 1<<11,				// don't fire our barrage weapon until it is full reloaded (rocket launcher, etc)
+		PRIORITIZE_DEFENSE			= 1<<12,				// bot prioritizes defending when possible
+		ALWAYS_FIRE_WEAPON			= 1<<13,				// constantly fire our weapon
+		TELEPORT_TO_HINT			= 1<<14,				// bot will teleport to hint target instead of walking out from the spawn point
+		MINIBOSS					= 1<<15,				// is miniboss?
+		USE_BOSS_HEALTH_BAR			= 1<<16,				// should I use boss health bar?
+		IGNORE_FLAG					= 1<<17,				// don't pick up flag/bomb
+		AUTO_JUMP					= 1<<18,				// auto jump
+		AIR_CHARGE_ONLY				= 1<<19,				// demo knight only charge in the air
+		PREFER_VACCINATOR_BULLETS	= 1<<20,				// When using the vaccinator, prefer to use the bullets shield
+		PREFER_VACCINATOR_BLAST		= 1<<21,				// When using the vaccinator, prefer to use the blast shield
+		PREFER_VACCINATOR_FIRE		= 1<<22,				// When using the vaccinator, prefer to use the fire shield
+		BULLET_IMMUNE				= 1<<23,				// Has a shield that makes the bot immune to bullets
+		BLAST_IMMUNE				= 1<<24,				// "" blast
+		FIRE_IMMUNE					= 1<<25,				// "" fire
+		PARACHUTE					= 1<<26,				// demo/soldier parachute when falling
+		PROJECTILE_SHIELD			= 1<<27,				// medic projectile shield
+	};
+	void SetAttribute( int attributeFlag );
+	void ClearAttribute( int attributeFlag );
+	void ClearAllAttributes();
+	bool HasAttribute( int attributeFlag ) const;
+
+	enum DifficultyType
+	{
+		UNDEFINED = -1,
+		EASY = 0,
+		NORMAL = 1,
+		HARD = 2,
+		EXPERT = 3,
+
+		NUM_DIFFICULTY_LEVELS
+	};
+	DifficultyType GetDifficulty( void ) const;
+	void SetDifficulty( DifficultyType difficulty );
+	bool IsDifficulty( DifficultyType skill ) const;
+
+	void SetHomeArea( CTFNavArea *area );
+	CTFNavArea *GetHomeArea( void ) const;
+
+	CObjectSentrygun *GetEnemySentry( void ) const;			// if we've been attacked/killed by an enemy sentry, this will return it, otherwise NULL
+	void RememberEnemySentry( CObjectSentrygun *sentry, const Vector &injurySpot );
+	const Vector &GetSpotWhereEnemySentryLastInjuredMe( void ) const;
+
+	void SetActionPoint( CTFBotActionPoint *point );
+	CTFBotActionPoint *GetActionPoint( void ) const;
+
+	bool HasProxy( void ) const;
+	void SetProxy( CTFBotProxy *proxy );					// attach this bot to a bot_proxy entity for map I/O communications
+	CTFBotProxy *GetProxy( void ) const;
+
+	bool HasSpawner( void ) const;
+	void SetSpawner( CTFBotGenerator *spawner );
+	CTFBotGenerator *GetSpawner( void ) const;
+
+	void JoinSquad( CTFBotSquad *squad );					// become a member of the given squad
+	void LeaveSquad( void );								// leave our current squad
+	void DeleteSquad( void );
+	bool IsInASquad( void ) const;
+	bool IsSquadmate( CTFPlayer *who ) const;				// return true if given bot is in my squad
+	CTFBotSquad *GetSquad( void ) const;					// return squad we are in, or NULL
+	float GetSquadFormationError( void ) const;				// return normalized error term where 0 = in formation position and 1 = completely out of position
+	void SetSquadFormationError( float error );
+	bool HasBrokenFormation( void ) const;					// return true if this bot is far out of formation, or has no path back
+	void SetBrokenFormation( bool state );
+
+	float TransientlyConsistentRandomValue( float period = 10.0f, int seedValue = 0 ) const;		// compute a pseudo random value (0-1) that stays consistent for the given period of time, but changes unpredictably each period
+
+	void SetBehaviorFlag( unsigned int flags );
+	void ClearBehaviorFlag( unsigned int flags );
+	bool IsBehaviorFlagSet( unsigned int flags ) const;
+
+	bool FindSplashTarget( CBaseEntity *target, float maxSplashRadius, Vector *splashTarget ) const;
+
+	void GiveRandomItem( loadout_positions_t loadoutPosition );
+
+	enum MissionType
+	{
+		NO_MISSION = 0,
+		MISSION_SEEK_AND_DESTROY,		// focus on finding and killing enemy players
+		MISSION_DESTROY_SENTRIES,		// focus on finding and destroying enemy sentry guns (and buildings)
+		MISSION_SNIPER,					// maintain teams of snipers harassing the enemy
+		MISSION_SPY,					// maintain teams of spies harassing the enemy
+		MISSION_ENGINEER,				// maintain engineer nests for harassing the enemy
+		MISSION_REPROGRAMMED,			// MvM: robot has been hacked and will do bad things to their team
+	};
+	#define MISSION_DOESNT_RESET_BEHAVIOR_SYSTEM false
+	void SetMission( MissionType mission, bool resetBehaviorSystem = true );
+	void SetPrevMission( MissionType mission );
+	MissionType GetMission( void ) const;
+	MissionType GetPrevMission( void ) const;
+	bool HasMission( MissionType mission ) const;
+	bool IsOnAnyMission( void ) const;
+	void SetMissionTarget( CBaseEntity *target );
+	CBaseEntity *GetMissionTarget( void ) const;
+	void SetMissionString( CUtlString string );
+	CUtlString *GetMissionString( void );
+
+	void SetTeleportWhere( const CUtlStringList& teleportWhereName );
+	const CUtlStringList& GetTeleportWhere();
+	void ClearTeleportWhere();
+
+	void SetScaleOverride( float fScale );
+
+	void SetMaxVisionRangeOverride( float range );
+	float GetMaxVisionRangeOverride( void ) const;
+
+	void DisguiseAsMemberOfEnemyTeam( void );		// set Spy disguise to be a class that someone on the enemy team is actually using
+	CBaseObject *GetNearestKnownSappableTarget( void );
+
+	void ClearTags( void );
+	void AddTag( const char *tag );
+	void RemoveTag( const char *tag );
+	bool HasTag( const char *tag );
+
+	Action< CTFBot > *OpportunisticallyUseWeaponAbilities( void );
+
+	CTFPlayer *SelectRandomReachableEnemy( void );	// mostly for MvM - pick a random enemy player that is not in their spawn room
+
+	float GetDesiredPathLookAheadRange( void ) const;	// different sized bots used different lookahead distances
+
+	void StartIdleSound( void );
+	void StopIdleSound( void );
+
+	bool ShouldQuickBuild() const { return m_bForceQuickBuild; }
+	void SetShouldQuickBuild( bool bShouldQuickBuild ) { m_bForceQuickBuild = bShouldQuickBuild; }
+
+	void SetAutoJump( float flAutoJumpMin, float flAutoJumpMax ) { m_flAutoJumpMin = flAutoJumpMin; m_flAutoJumpMax = flAutoJumpMax; }
+	bool ShouldAutoJump();
+
+	void SetFlagTarget( CCaptureFlag* pFlag );
+	CCaptureFlag* GetFlagTarget() const { return m_hFollowingFlagTarget; }
+	bool HasFlagTaget() const { return m_hFollowingFlagTarget != NULL; }
+
+	struct EventChangeAttributes_t
+	{
+		EventChangeAttributes_t()
+		{
+			Reset();
+		}
+
+		EventChangeAttributes_t( const EventChangeAttributes_t& copy )
+		{
+			Reset();
+
+			m_eventName = copy.m_eventName;
+
+			m_skill = copy.m_skill;
+			m_weaponRestriction = copy.m_weaponRestriction;
+			m_mission = copy.m_mission;
+			m_prevMission = copy.m_prevMission;
+			m_attributeFlags = copy.m_attributeFlags;
+			m_maxVisionRange = copy.m_maxVisionRange;
+
+			for ( int i=0; i<copy.m_items.Count(); ++i )
+			{
+				m_items.CopyAndAddToTail( copy.m_items[i] );
+			}
+
+			m_itemsAttributes = copy.m_itemsAttributes;
+			m_characterAttributes = copy.m_characterAttributes;
+
+			for ( int i=0; i<copy.m_tags.Count(); ++i )
+			{
+				m_tags.CopyAndAddToTail( copy.m_tags[i] );
+			}
+		}
+
+		void Reset()
+		{
+			m_eventName = "default";
+			
+			m_skill = CTFBot::EASY;
+			m_weaponRestriction = CTFBot::ANY_WEAPON;
+			m_mission = CTFBot::NO_MISSION;
+			m_prevMission = m_mission;
+			m_attributeFlags = 0;
+			m_maxVisionRange = -1.f;
+
+			m_items.RemoveAll();
+			
+			m_itemsAttributes.RemoveAll();
+			m_characterAttributes.RemoveAll();
+			m_tags.RemoveAll();
+		}
+
+		CUtlString m_eventName;
+
+		DifficultyType m_skill;
+		WeaponRestrictionType m_weaponRestriction;
+		MissionType m_mission;
+		MissionType m_prevMission;
+		int m_attributeFlags;
+		float m_maxVisionRange;
+
+		CUtlStringList m_items;
+
+		struct item_attributes_t
+		{
+			CUtlString m_itemName;
+			CCopyableUtlVector< static_attrib_t > m_attributes;
+		};
+		CUtlVector< item_attributes_t > m_itemsAttributes;
+		CUtlVector< static_attrib_t >	m_characterAttributes;
+		CUtlStringList m_tags;
+	};
+	void ClearEventChangeAttributes() { m_eventChangeAttributes.RemoveAll(); }
+	void AddEventChangeAttributes( const EventChangeAttributes_t* newEvent );
+	const EventChangeAttributes_t* GetEventChangeAttributes( const char* pszEventName ) const;
+	void OnEventChangeAttributes( const CTFBot::EventChangeAttributes_t* pEvent );
+
+	void AddItem( const char* pszItemName );
+
+	int GetUberHealthThreshold();
+	float GetUberDeployDelayDuration();
+
+private:
+	CTFBotLocomotion	*m_locomotor;
+	CTFBotBody			*m_body;
+	CTFBotVision		*m_vision;
+
+	CountdownTimer m_lookAtEnemyInvasionAreasTimer;
+
+	CTFNavArea *m_spawnArea;			// where we spawned
+	CountdownTimer m_justLostPointTimer;
+	
+	int m_weaponRestrictionFlags;
+	int m_attributeFlags;
+	DifficultyType m_difficulty;
+
+	CTFNavArea *m_homeArea;
+
+	CHandle< CTFBotActionPoint > m_actionPoint;
+	CHandle< CTFBotProxy > m_proxy;
+	CHandle< CTFBotGenerator > m_spawner;
+
+	CTFBotSquad *m_squad;
+	bool m_didReselectClass;
+
+	CHandle< CObjectSentrygun > m_enemySentry;
+	Vector m_spotWhereEnemySentryLastInjuredMe;			// the last position where I was injured by an enemy sentry
+
+	CUtlVector< SuspectedSpyInfo_t* > m_suspectedSpyVector;
+	CUtlVector< CHandle< CTFPlayer > > m_knownSpyVector;
+
+	CUtlVector< SniperSpotInfo > m_sniperSpotVector;	// collection of good sniping spots for the current objective
+
+	CUtlVector< CTFNavArea * > m_sniperVantageAreaVector;
+	CUtlVector< CTFNavArea * > m_sniperTheaterAreaVector;
+
+	CBaseEntity *m_snipingGoalEntity;					// the entity we are guarding (control point, payload cart)
+	Vector m_lastSnipingGoalEntityPosition;
+
+	void SetupSniperSpotAccumulation( void );			// do internal setup when control point changes
+	CountdownTimer m_retrySniperSpotSetupTimer;
+
+	bool m_isLookingAroundForEnemies;
+
+	unsigned int m_behaviorFlags;						// spawnflags from the bot_generator that spawned us
+	CUtlVector< CFmtStr > m_tags;
+
+	CHandle< CBaseEntity > m_attentionFocusEntity;
+
+	CTeamControlPoint *SelectPointToCapture( CUtlVector< CTeamControlPoint * > *captureVector ) const;
+	CTeamControlPoint *SelectPointToDefend( CUtlVector< CTeamControlPoint * > *defendVector ) const;
+	mutable CHandle< CTeamControlPoint > m_myControlPoint;
+	mutable CountdownTimer m_evaluateControlPointTimer;
+
+	float m_fModelScaleOverride;
+
+	MissionType m_mission;
+	MissionType m_prevMission;
+
+	CHandle< CBaseEntity > m_missionTarget;
+	CUtlString m_missionString;
+
+	CUtlStack< CHandle<CTFWeaponBase> > m_requiredWeaponStack;	// if non-empty, bot must equip the weapon on top of the stack
+
+	CountdownTimer m_noisyTimer;
+
+	struct DelayedNoticeInfo
+	{
+		CHandle< CBaseEntity > m_who;
+		float m_when;
+	};
+	CUtlVector< DelayedNoticeInfo > m_delayedNoticeVector;
+
+	float m_maxVisionRangeOverride;
+
+	CountdownTimer m_opportunisticTimer;
+	
+	CSoundPatch *m_pIdleSound;
+
+	float m_squadFormationError;
+	bool m_hasBrokenFormation;
+
+	CUtlStringList m_teleportWhereName;	// spawn name an engineer mission teleporter will override
+	bool m_bForceQuickBuild;
+
+	float m_flAutoJumpMin;
+	float m_flAutoJumpMax;
+	CountdownTimer m_autoJumpTimer;
+
+	CHandle< CCaptureFlag > m_hFollowingFlagTarget;
+
+	CUtlVector< const EventChangeAttributes_t* > m_eventChangeAttributes;
+};
+
+
+inline void CTFBot::SetTeleportWhere( const CUtlStringList& teleportWhereName )
+{
+	// deep copy strings
+	for ( int i=0; i<teleportWhereName.Count(); ++i )
+	{
+		m_teleportWhereName.CopyAndAddToTail( teleportWhereName[i] );
+	}
+}
+
+inline const CUtlStringList& CTFBot::GetTeleportWhere()
+{
+	return m_teleportWhereName;
+}
+
+inline void CTFBot::ClearTeleportWhere()
+{
+	m_teleportWhereName.RemoveAll();
+}
+
+inline void CTFBot::SetMissionString( CUtlString string )
+{
+	m_missionString = string;
+}
+
+inline CUtlString *CTFBot::GetMissionString( void )
+{
+	return &m_missionString;
+}
+
+inline void CTFBot::SetMissionTarget( CBaseEntity *target )
+{
+	m_missionTarget = target;
+}
+
+inline CBaseEntity *CTFBot::GetMissionTarget( void ) const
+{
+	return m_missionTarget;
+}
+
+inline float CTFBot::GetSquadFormationError( void ) const
+{
+	return m_squadFormationError;
+}
+
+inline void CTFBot::SetSquadFormationError( float error )
+{
+	m_squadFormationError = error;
+}
+
+inline bool CTFBot::HasBrokenFormation( void ) const
+{
+	return m_hasBrokenFormation;
+}
+
+inline void CTFBot::SetBrokenFormation( bool state )
+{
+	m_hasBrokenFormation = state;
+}
+
+inline void CTFBot::SetMaxVisionRangeOverride( float range )
+{
+	m_maxVisionRangeOverride = range;
+}
+
+inline float CTFBot::GetMaxVisionRangeOverride( void ) const
+{
+	return m_maxVisionRangeOverride;
+}
+
+inline void CTFBot::SetBehaviorFlag( unsigned int flags )
+{
+	m_behaviorFlags |= flags;
+}
+
+inline void CTFBot::ClearBehaviorFlag( unsigned int flags )
+{
+	m_behaviorFlags &= ~flags;
+}
+
+inline bool CTFBot::IsBehaviorFlagSet( unsigned int flags ) const
+{
+	return ( m_behaviorFlags & flags ) ? true : false;
+}
+
+inline void CTFBot::StartLookingAroundForEnemies( void )
+{
+	m_isLookingAroundForEnemies = true;
+}
+
+inline void CTFBot::StopLookingAroundForEnemies( void )
+{
+	m_isLookingAroundForEnemies = false;
+}
+
+inline int CTFBot::GetBotType( void ) const
+{
+	return TF_BOT_TYPE;
+}
+
+inline void CTFBot::RememberEnemySentry( CObjectSentrygun *sentry, const Vector &injurySpot )
+{
+	m_enemySentry = sentry;
+	m_spotWhereEnemySentryLastInjuredMe = injurySpot;
+}
+
+inline CObjectSentrygun *CTFBot::GetEnemySentry( void ) const
+{
+	return m_enemySentry;
+}
+
+inline const Vector &CTFBot::GetSpotWhereEnemySentryLastInjuredMe( void ) const
+{
+	return m_spotWhereEnemySentryLastInjuredMe;
+}
+
+inline CTFBot::DifficultyType CTFBot::GetDifficulty( void ) const
+{
+	return m_difficulty;
+}
+
+inline void CTFBot::SetDifficulty( CTFBot::DifficultyType difficulty )
+{
+	m_difficulty = difficulty;
+
+	m_nBotSkill = m_difficulty;
+}
+
+inline bool CTFBot::IsDifficulty( DifficultyType skill ) const
+{
+	return skill == m_difficulty;
+}
+
+inline bool CTFBot::HasProxy( void ) const
+{
+	return m_proxy == NULL ? false : true;
+}
+
+inline void CTFBot::SetProxy( CTFBotProxy *proxy )
+{
+	m_proxy = proxy;
+}
+
+inline CTFBotProxy *CTFBot::GetProxy( void ) const
+{
+	return m_proxy;
+}
+
+inline bool CTFBot::HasSpawner( void ) const
+{
+	return m_spawner == NULL ? false : true;
+}
+
+inline void CTFBot::SetSpawner( CTFBotGenerator *spawner )
+{
+	m_spawner = spawner;
+}
+
+inline CTFBotGenerator *CTFBot::GetSpawner( void ) const
+{
+	return m_spawner;
+}
+
+inline void CTFBot::SetActionPoint( CTFBotActionPoint *point )
+{
+	m_actionPoint = point;
+}
+
+inline CTFBotActionPoint *CTFBot::GetActionPoint( void ) const
+{
+	return m_actionPoint;
+}
+
+inline bool CTFBot::IsInASquad( void ) const
+{
+	return m_squad == NULL ? false : true;
+}
+
+inline CTFBotSquad *CTFBot::GetSquad( void ) const
+{
+	return m_squad;
+}
+
+inline void CTFBot::SetHomeArea( CTFNavArea *area )
+{
+	m_homeArea = area;
+}
+
+inline CTFNavArea *CTFBot::GetHomeArea( void ) const
+{
+	return m_homeArea;
+}
+
+inline void CTFBot::ClearWeaponRestrictions( void )
+{
+	m_weaponRestrictionFlags = 0;
+}
+
+inline void CTFBot::SetWeaponRestriction( int restrictionFlags )
+{
+	m_weaponRestrictionFlags |= restrictionFlags;
+}
+
+inline bool CTFBot::HasWeaponRestriction( int restrictionFlags ) const
+{
+	return m_weaponRestrictionFlags & restrictionFlags ? true : false;
+}
+
+inline void CTFBot::SetAttribute( int attributeFlag )
+{
+	m_attributeFlags |= attributeFlag;
+}
+
+inline void CTFBot::ClearAttribute( int attributeFlag )
+{
+	m_attributeFlags &= ~attributeFlag;
+}
+
+inline void CTFBot::ClearAllAttributes()
+{
+	m_attributeFlags = 0;
+}
+
+inline bool CTFBot::HasAttribute( int attributeFlag ) const
+{
+	return m_attributeFlags & attributeFlag ? true : false;
+}
+
+inline CTFNavArea *CTFBot::GetSpawnArea( void ) const
+{
+	return m_spawnArea;
+}
+
+inline bool CTFBot::WasPointJustLost( void ) const
+{
+	return m_justLostPointTimer.HasStarted() && !m_justLostPointTimer.IsElapsed();
+}
+
+inline const CUtlVector< CTFBot::SniperSpotInfo > *CTFBot::GetSniperSpots( void ) const
+{
+	return &m_sniperSpotVector;
+}
+
+inline bool CTFBot::HasSniperSpots( void ) const
+{
+	return m_sniperSpotVector.Count() > 0 ? true : false;
+}
+
+inline CTFBot::MissionType CTFBot::GetMission( void ) const
+{
+	return m_mission;
+}
+
+inline void CTFBot::SetPrevMission( MissionType mission )
+{
+	m_prevMission = mission;
+}
+
+inline CTFBot::MissionType CTFBot::GetPrevMission( void ) const
+{
+	return m_prevMission;
+}
+
+inline bool CTFBot::HasMission( MissionType mission ) const
+{
+	return m_mission == mission ? true : false;
+}
+
+inline bool CTFBot::IsOnAnyMission( void ) const
+{
+	return m_mission == NO_MISSION ? false : true;
+}
+
+inline void CTFBot::SetScaleOverride( float fScale )
+{
+	m_fModelScaleOverride = fScale;
+
+	SetModelScale( m_fModelScaleOverride > 0.0f ? m_fModelScaleOverride : 1.0f );
+}
+
+inline bool CTFBot::IsEnvironmentNoisy( void ) const
+{
+	return !m_noisyTimer.IsElapsed();
+}
+
+//---------------------------------------------------------------------------------------------
+inline CTFBot *ToTFBot( CBaseEntity *pEntity )
+{
+	if ( !pEntity || !pEntity->IsPlayer() || !ToTFPlayer( pEntity )->IsBotOfType( TF_BOT_TYPE ) )
+		return NULL;
+
+	Assert( "***IMPORTANT!!! DONT IGNORE ME!!!***" && dynamic_cast< CTFBot * >( pEntity ) != 0 );
+
+	return static_cast< CTFBot * >( pEntity );
+}
+
+
+//---------------------------------------------------------------------------------------------
+inline const CTFBot *ToTFBot( const CBaseEntity *pEntity )
+{
+	if ( !pEntity || !pEntity->IsPlayer() || !ToTFPlayer( const_cast< CBaseEntity * >( pEntity ) )->IsBotOfType( TF_BOT_TYPE ) )
+		return NULL;
+
+	Assert( "***IMPORTANT!!! DONT IGNORE ME!!!***" && dynamic_cast< const CTFBot * >( pEntity ) != 0 );
+
+	return static_cast< const CTFBot * >( pEntity );
+}
+
+
+//--------------------------------------------------------------------------------------------------------------
+/**
+ * Functor used with NavAreaBuildPath()
+ */
+class CTFBotPathCost : public IPathCost
+{
+public:
+	CTFBotPathCost( CTFBot *me, RouteType routeType )
+	{
+		m_me = me;
+		m_routeType = routeType;
+		m_stepHeight = me->GetLocomotionInterface()->GetStepHeight();
+		m_maxJumpHeight = me->GetLocomotionInterface()->GetMaxJumpHeight();
+		m_maxDropHeight = me->GetLocomotionInterface()->GetDeathDropHeight();
+	}
+
+	virtual float operator()( CNavArea *baseArea, CNavArea *fromArea, const CNavLadder *ladder, const CFuncElevator *elevator, float length ) const
+	{
+		VPROF_BUDGET( "CTFBotPathCost::operator()", "NextBot" );
+
+		CTFNavArea *area = (CTFNavArea *)baseArea;
+
+		if ( fromArea == NULL )
+		{
+			// first area in path, no cost
+			return 0.0f;
+		}
+		else
+		{
+			if ( !m_me->GetLocomotionInterface()->IsAreaTraversable( area ) )
+			{
+				return -1.0f;
+			}
+
+			// in training, avoid capturing the point until the human trainee does so
+			if ( TFGameRules()->IsInTraining() && 
+				 area->HasAttributeTF( TF_NAV_CONTROL_POINT ) && 
+				 !m_me->IsAnyPointBeingCaptured() &&
+				 !m_me->IsPlayerClass( TF_CLASS_ENGINEER ) )	// allow engineers to path so they can test travel distance for sentry placement
+			{
+				return -1.0f;
+			}
+
+			// don't path through enemy spawn rooms
+			if ( ( m_me->GetTeamNumber() == TF_TEAM_RED && area->HasAttributeTF( TF_NAV_SPAWN_ROOM_BLUE ) ) ||
+				 ( m_me->GetTeamNumber() == TF_TEAM_BLUE && area->HasAttributeTF( TF_NAV_SPAWN_ROOM_RED ) ) )
+			{
+				if ( !TFGameRules()->RoundHasBeenWon() )
+				{
+					return -1.0f;
+				}
+			}
+
+			// compute distance traveled along path so far
+			float dist;
+
+			if ( ladder )
+			{
+				dist = ladder->m_length;
+			}
+			else if ( length > 0.0 )
+			{
+				dist = length;
+			}
+			else
+			{
+				dist = ( area->GetCenter() - fromArea->GetCenter() ).Length();
+			}
+
+
+			// check height change
+			float deltaZ = fromArea->ComputeAdjacentConnectionHeightChange( area );
+
+			if ( deltaZ >= m_stepHeight )
+			{
+				if ( deltaZ >= m_maxJumpHeight )
+				{
+					// too high to reach
+					return -1.0f;
+				}
+
+				// jumping is slower than flat ground
+				const float jumpPenalty = 2.0f;
+				dist *= jumpPenalty;
+			}
+			else if ( deltaZ < -m_maxDropHeight )
+			{
+				// too far to drop
+				return -1.0f;
+			}
+
+			// add a random penalty unique to this character so they choose different routes to the same place
+			float preference = 1.0f;
+
+			if ( m_routeType == DEFAULT_ROUTE && !m_me->IsMiniBoss() ) 
+			{
+				// this term causes the same bot to choose different routes over time,
+				// but keep the same route for a period in case of repaths
+				int timeMod = (int)( gpGlobals->curtime / 10.0f ) + 1;
+				preference = 1.0f + 50.0f * ( 1.0f + FastCos( (float)( m_me->GetEntity()->entindex() * area->GetID() * timeMod ) ) );
+			}
+
+			if ( m_routeType == SAFEST_ROUTE )
+			{
+				// avoid combat areas
+				if ( area->IsInCombat() )
+				{
+					const float combatDangerCost = 4.0f;
+					dist *= combatDangerCost * area->GetCombatIntensity();
+				}
+
+				// if this area exposes us to enemy sentry fire, avoid it
+				const float sentryDangerCost = 5.0f;
+				if ( ( m_me->GetTeamNumber() == TF_TEAM_RED && area->HasAttributeTF( TF_NAV_BLUE_SENTRY_DANGER ) ) ||
+					 ( m_me->GetTeamNumber() == TF_TEAM_BLUE && area->HasAttributeTF( TF_NAV_RED_SENTRY_DANGER ) ) )
+				{
+					dist *= sentryDangerCost;
+				}
+			}
+
+			if ( m_me->IsPlayerClass( TF_CLASS_SPY ) )
+			{
+				int enemyTeam = GetEnemyTeam( m_me->GetTeamNumber() );
+
+				// Since spies can get right up to enemy buildings, avoid them.
+				for ( int oit = 0; oit < IBaseObjectAutoList::AutoList().Count(); ++oit )
+				{
+					CBaseObject *enemyObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[ oit ] );
+
+					if ( ( enemyObj->ObjectType() == OBJ_SENTRYGUN ) &&
+						( enemyObj->GetTeamNumber() == enemyTeam ) )
+					{
+						enemyObj->UpdateLastKnownArea();
+
+						if ( enemyObj->GetLastKnownArea() == area )
+						{
+							// There is an enemy building in this area - avoid it as a spy.
+							const float enemyBuildingCost = 10.0f;
+							dist *= enemyBuildingCost;
+						}
+					}
+				}
+
+				// Spies avoid teammates, since they draw attention and gunfire.
+				const float teammateCost = 10.0f;
+				dist += dist * teammateCost * area->GetPlayerCount( m_me->GetTeamNumber() );
+
+				// We shouldn't be getting NaNs here. It will be handled when we return, but ideally
+				//  it should be fixed here and not just worked around in NavAreaBuildPath.
+				DebuggerBreakOnNaN_StagingOnly( dist );
+			}
+
+			float cost = ( dist * preference );
+
+			if ( area->HasAttributes( NAV_MESH_FUNC_COST ) )
+			{
+				cost *= area->ComputeFuncNavCost( m_me );
+				DebuggerBreakOnNaN_StagingOnly( cost );
+			}
+
+			return cost + fromArea->GetCostSoFar();
+		}
+	}
+
+	CTFBot *m_me;
+	RouteType m_routeType;
+	float m_stepHeight;
+	float m_maxJumpHeight;
+	float m_maxDropHeight;
+};
+
+
+//---------------------------------------------------------------------------------------------
+class CClosestTFPlayer
+{
+public:
+	CClosestTFPlayer( const Vector &where, int team = TEAM_ANY )
+	{
+		m_where = where;
+		m_closeRangeSq = FLT_MAX;
+		m_closePlayer = NULL;
+		m_team = team;
+	}
+
+	CClosestTFPlayer( CBaseEntity *entity, int team = TEAM_ANY )
+	{
+		m_where = entity->WorldSpaceCenter();
+		m_closeRangeSq = FLT_MAX;
+		m_closePlayer = NULL;
+		m_team = team;
+	}
+
+	bool operator() ( CBasePlayer *player )
+	{
+		if ( !player->IsAlive() )
+			return true;
+
+		if ( player->GetTeamNumber() != TF_TEAM_RED && player->GetTeamNumber() != TF_TEAM_BLUE )
+			return true;
+
+		if ( m_team != TEAM_ANY && player->GetTeamNumber() != m_team )
+			return true;
+
+		CTFBot *bot = ToTFBot( player );
+		if ( bot && bot->HasAttribute( CTFBot::IS_NPC ) )
+			return true;
+
+		float rangeSq = ( m_where - player->GetAbsOrigin() ).LengthSqr();
+		if ( rangeSq < m_closeRangeSq )
+		{
+			m_closeRangeSq = rangeSq;
+			m_closePlayer = player;
+		}
+		return true;
+	}
+
+	Vector m_where;
+	float m_closeRangeSq;
+	CBasePlayer *m_closePlayer;
+	int m_team;
+};
+
+
+#endif // TF_BOT_H