tf2/tf2_src/game/server/tf/tf_player.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:		Player for HL1.
//
// $NoKeywords: $
//=============================================================================

#include "cbase.h"
#include "tf_player.h"
#include "tf_gamerules.h"
#include "tf_gamestats.h"
#include "KeyValues.h"
#include "viewport_panel_names.h"
#include "client.h"
#include "team.h"
#include "tf_weaponbase.h"
#include "tf_client.h"
#include "tf_team.h"
#include "tf_viewmodel.h"
#include "tf_item.h"
#include "in_buttons.h"
#include "entity_capture_flag.h"
#include "effect_dispatch_data.h"
#include "te_effect_dispatch.h"
#include "game.h"
#include "tf_weapon_builder.h"
#include "tf_obj.h"
#include "tf_ammo_pack.h"
#include "datacache/imdlcache.h"
#include "particle_parse.h"
#include "props_shared.h"
#include "filesystem.h"
#include "toolframework_server.h"
#include "IEffects.h"
#include "func_respawnroom.h"
#include "networkstringtable_gamedll.h"
#include "team_control_point_master.h"
#include "tf_weapon_pda.h"
#include "sceneentity.h"
#include "fmtstr.h"
#include "tf_weapon_sniperrifle.h"
#include "tf_weapon_minigun.h"
#include "tf_weapon_fists.h"
#include "tf_weapon_shotgun.h"
#include "tf_weapon_lunchbox.h"
#include "tf_weapon_knife.h"
#include "tf_weapon_bottle.h"
#include "tf_weapon_sword.h"
#include "tf_weapon_grenade_pipebomb.h"
#include "tf_weapon_buff_item.h"
#include "tf_weapon_flamethrower.h"
#include "tf_projectile_flare.h"
#include "trigger_area_capture.h"
#include "triggers.h"
#include "tf_weapon_medigun.h"
#include "tf_weapon_invis.h"
#include "hl2orange.spa.h"
#include "te_tfblood.h"
#include "activitylist.h"
#include "cdll_int.h"
#include "econ_entity_creation.h"
#include "tf_weaponbase_gun.h"
#include "team_train_watcher.h"
#include "vgui/ILocalize.h"
#include "tier3/tier3.h"
#include "serverbenchmark_base.h"
#include "trains.h"
#include "tf_fx.h"
#include "recipientfilter.h"
#include "ilagcompensationmanager.h"
#include "dt_utlvector_send.h"
#include "tf_item_wearable.h"
#include "tf_item_powerup_bottle.h"
#include "nav_mesh/tf_nav_mesh.h"
#include "tier0/vprof.h"
#include "econ_gcmessages.h"
#include "tf_gcmessages.h"
#include "tf_obj_sentrygun.h"
#include "tf_weapon_shovel.h"
#include "bot/tf_bot.h"
#include "bot/tf_bot_manager.h"
#include "NextBotUtil.h"
#include "tf_wearable_item_demoshield.h"
#include "tier0/icommandline.h"
#include "entity_healthkit.h"
#include "choreoevent.h"
#include "minigames/tf_duel.h"
#include "tf_bot_temp.h"
#include "tf_objective_resource.h"
#include "tf_weapon_pipebomblauncher.h"
#include "func_achievement.h"
#include "halloween/merasmus/merasmus.h"
#include "inetchannel.h"
#include "tf_wearable_levelable_item.h"
#include "tf_weapon_jar.h"
#include "halloween/tf_weapon_spellbook.h"
#include "soundenvelope.h"
#include "tf_triggers.h"
#include "collisionutils.h"
#include "tf_taunt_prop.h"
#include "eventlist.h"
#include "entity_rune.h"
#include "entity_halloween_pickup.h"
#include "tf_gc_server.h"
#include "tf_logic_halloween_2014.h"
#include "tf_weapon_knife.h"
#include "tf_weapon_grapplinghook.h"
#include "tf_dropped_weapon.h"
#include "tf_passtime_logic.h"
#include "tf_weapon_passtime_gun.h"
#include "player_resource.h"
#include "tf_player_resource.h"
#include "gcsdk/gcclient_sharedobjectcache.h"
#include "tf_party.h"
#ifdef STAGING_ONLY
#include "tf_extra_map_entity.h"
#endif

#ifdef TF_RAID_MODE
#include "bot_npc/bot_npc_decoy.h"
#include "raid/tf_raid_logic.h"
#endif

#include "entity_currencypack.h"
#include "tf_mann_vs_machine_stats.h"
#include "player_vs_environment/tf_upgrades.h"
#include "player_vs_environment/tf_population_manager.h"
#include "tf_revive.h"
#include "tf_logic_halloween_2014.h"
#include "tf_logic_player_destruction.h"

// NVNT haptic utils
#include "haptics/haptic_utils.h"

#include "gc_clientsystem.h"

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

#pragma warning( disable: 4355 ) // disables ' 'this' : used in base member initializer list'

ConVar sv_motd_unload_on_dismissal( "sv_motd_unload_on_dismissal", "0", 0, "If enabled, the MOTD contents will be unloaded when the player closes the MOTD." );

#define DAMAGE_FORCE_SCALE_SELF				9
#define SCOUT_ADD_BIRD_ON_GIB_CHANCE		5
#define MEDIC_RELEASE_DOVE_COUNT			10

#define JUMP_MIN_SPEED	268.3281572999747f		

extern bool IsInCommentaryMode( void );
extern void SpawnClientsideFlyingBird( Vector &vecSpawn );

extern ConVar	sk_player_head;
extern ConVar	sk_player_chest;
extern ConVar	sk_player_stomach;
extern ConVar	sk_player_arm;
extern ConVar	sk_player_leg;

extern ConVar	tf_spy_invis_time;
extern ConVar	tf_spy_invis_unstealth_time;
extern ConVar	tf_stalematechangeclasstime;
extern ConVar	tf_gravetalk;

extern ConVar	tf_bot_quota_mode;
extern ConVar	tf_bot_quota;
extern ConVar	halloween_starting_souls;

float GetCurrentGravity( void );

float			m_flNextReflectZap = 0.f;

static CTFPlayer *gs_pRecursivePlayerCheck = NULL;

bool CTFPlayer::m_bTFPlayerNeedsPrecache = true;

static const char g_pszIdleKickString[] = "#TF_Idle_kicked";

EHANDLE g_pLastSpawnPoints[TF_TEAM_COUNT];

EHANDLE	g_hTestSub;

ConVar tf_playerstatetransitions( "tf_playerstatetransitions", "-2", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "tf_playerstatetransitions <ent index or -1 for all>. Show player state transitions." );
ConVar tf_playergib( "tf_playergib", "1", FCVAR_NOTIFY, "Allow player gibbing. 0: never, 1: normal, 2: always", true, 0, true, 2 );

ConVar tf_damageforcescale_other( "tf_damageforcescale_other", "6.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_damageforcescale_self_soldier_rj( "tf_damageforcescale_self_soldier_rj", "10.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_damageforcescale_self_soldier_badrj( "tf_damageforcescale_self_soldier_badrj", "5.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_damageforcescale_pyro_jump( "tf_damageforcescale_pyro_jump", "8.5", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_damagescale_self_soldier( "tf_damagescale_self_soldier", "0.60", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );


ConVar tf_damage_range( "tf_damage_range", "0.5", FCVAR_DEVELOPMENTONLY );
ConVar tf_damage_multiplier_blue( "tf_damage_multiplier_blue", "1.0", FCVAR_CHEAT, "All incoming damage to a blue player is multiplied by this value" );
ConVar tf_damage_multiplier_red( "tf_damage_multiplier_red", "1.0", FCVAR_CHEAT, "All incoming damage to a red player is multiplied by this value" );


ConVar tf_max_voice_speak_delay( "tf_max_voice_speak_delay", "1.5", FCVAR_DEVELOPMENTONLY, "Max time after a voice command until player can do another one" );

ConVar tf_allow_player_use( "tf_allow_player_use", "0", FCVAR_NOTIFY, "Allow players to execute +use while playing." );

ConVar tf_deploying_bomb_time( "tf_deploying_bomb_time", "1.90", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "Time to deploy bomb before the point of no return." );
ConVar tf_deploying_bomb_delay_time( "tf_deploying_bomb_delay_time", "0.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "Time to delay before deploying bomb." );

#ifdef TF_RAID_MODE
ConVar tf_raid_team_size( "tf_raid_team_size", "5", FCVAR_NOTIFY, "Max number of Raiders" );
ConVar tf_raid_respawn_safety_time( "tf_raid_respawn_safety_time", "1.5", FCVAR_NOTIFY, "Number of seconds of invulnerability after respawning" );
ConVar tf_raid_allow_class_change( "tf_raid_allow_class_change", "1", FCVAR_NOTIFY, "If nonzero, allow invaders to change their class after leaving the safe room" );
ConVar tf_raid_use_rescue_closets( "tf_raid_use_rescue_closets", "1", FCVAR_NOTIFY );
ConVar tf_raid_drop_healthkit_chance( "tf_raid_drop_healthkit_chance", "50" ); // , FCVAR_CHEAT );

ConVar tf_boss_battle_team_size( "tf_boss_battle_team_size", "5", FCVAR_NOTIFY, "Max number of players in Boss Battle mode" );
ConVar tf_boss_battle_respawn_safety_time( "tf_boss_battle_respawn_safety_time", "3", FCVAR_NOTIFY, "Number of seconds of invulnerability after respawning" );
ConVar tf_boss_battle_respawn_on_friends( "tf_boss_battle_respawn_on_friends", "1", FCVAR_NOTIFY );
#endif

ConVar tf_mvm_death_penalty( "tf_mvm_death_penalty", "0", FCVAR_NOTIFY | FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "How much currency players lose when dying" );
extern ConVar tf_populator_damage_multiplier;
extern ConVar tf_mvm_skill;

#ifdef STAGING_ONLY
ConVar tf_debug_ballistics( "tf_debug_ballistics", "0", FCVAR_CHEAT );
ConVar tf_debug_ballistic_targeting( "tf_debug_ballistic_targeting", "0", FCVAR_CHEAT );
ConVar tf_debug_ballistic_targeting_tolerance( "tf_debug_ballistic_targeting_tolerance", "5", FCVAR_CHEAT );
static Vector tf_debug_ballistic_target( 0, 0, 0 );

ConVar  tf_space_thrust_scout( "tf_space_thrust_scout", "40.0", FCVAR_CHEAT | FCVAR_REPLICATED, "How much thrust is added while holding jump" );
ConVar  tf_space_thrust_sniper( "tf_space_thrust_sniper", "34.0", FCVAR_CHEAT | FCVAR_REPLICATED, "How much thrust is added while holding jump" );
ConVar  tf_space_thrust_spy( "tf_space_thrust_spy", "35.0", FCVAR_CHEAT | FCVAR_REPLICATED, "How much thrust is added while holding jump" );
ConVar  tf_space_thrust_pyro( "tf_space_thrust_pyro", "35.0", FCVAR_CHEAT | FCVAR_REPLICATED, "How much thrust is added while holding jump" );
ConVar  tf_space_thrust_soldier( "tf_space_thrust_soldier", "33.0", FCVAR_CHEAT | FCVAR_REPLICATED, "How much thrust is added while holding jump" );
ConVar  tf_space_thrust_engy( "tf_space_thrust_engy", "35.0", FCVAR_CHEAT | FCVAR_REPLICATED, "How much thrust is added while holding jump" );
ConVar  tf_space_thrust_medic( "tf_space_thrust_medic", "37.0", FCVAR_CHEAT | FCVAR_REPLICATED, "How much thrust is added while holding jump" );
ConVar  tf_space_thrust_heavy( "tf_space_thrust_heavy", "33.0", FCVAR_CHEAT | FCVAR_REPLICATED, "How much thrust is added while holding jump" );
ConVar  tf_space_thrust_demo( "tf_space_thrust_demo", "33.0", FCVAR_CHEAT | FCVAR_REPLICATED, "How much thrust is added while holding jump" );
ConVar  tf_space_thrust_use_rate( "tf_space_thrust_use_rate", "2.0", FCVAR_CHEAT | FCVAR_REPLICATED, "How much fuel is used per tick" );
ConVar  tf_space_thrust_recharge_rate( "tf_space_thrust_recharge_rate", "0.5", FCVAR_CHEAT | FCVAR_REPLICATED, "How much fuel is recharged per tick" );
ConVar  tf_skip_intro_and_spectate( "tf_skip_intro_and_spectate", "0", FCVAR_REPLICATED, "Skip intro panels and start spectating." );
#endif

#ifdef STAGING_ONLY
ConVar tf_highfive_separation_forward( "tf_highfive_separation_forward", "0", FCVAR_CHEAT, "Forward distance between high five partners" );
ConVar tf_highfive_separation_right( "tf_highfive_separation_right", "0", FCVAR_CHEAT, "Right distance between high five partners" );
#else
ConVar tf_highfive_separation_forward( "tf_highfive_separation_forward", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "Forward distance between high five partners" );
ConVar tf_highfive_separation_right( "tf_highfive_separation_right", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "Right distance between high five partners" );
#endif

ConVar tf_highfive_max_range( "tf_highfive_max_range", "150", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "The farthest away a high five partner can be" );
ConVar tf_highfive_height_tolerance( "tf_highfive_height_tolerance", "12", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "The maximum height difference allowed for two high-fivers." );
ConVar tf_highfive_debug( "tf_highfive_debug", "0", FCVAR_NONE, "Turns on some console spew for debugging high five issues." );

ConVar tf_test_teleport_home_fx( "tf_test_teleport_home_fx", "0", FCVAR_CHEAT );

ConVar tf_halloween_giant_health_scale( "tf_halloween_giant_health_scale", "10", FCVAR_CHEAT );

ConVar tf_grapplinghook_los_force_detach_time( "tf_grapplinghook_los_force_detach_time", "1", FCVAR_CHEAT );
ConVar tf_powerup_max_charge_time( "tf_powerup_max_charge_time", "30", FCVAR_CHEAT );

extern ConVar tf_powerup_mode;
extern ConVar tf_mvm_buybacks_method;
extern ConVar tf_mvm_buybacks_per_wave;

#define TF_CANNONBALL_FORCE_SCALE	80.f
#define TF_CANNONBALL_FORCE_UPWARD	300.f

#ifdef STAGING_ONLY
void CC_tf_debug_ballistic_targeting_mark_target( const CCommand &args )
{
	CBasePlayer *player = UTIL_GetListenServerHost();
	if ( !player )
	{
		return;
	}

	Vector forward;
	AngleVectors( player->EyeAngles() + player->GetPunchAngle(), &forward );

	trace_t result;
	UTIL_TraceLine( player->EyePosition(), player->EyePosition() + 2000.0f * forward, MASK_SHOT, player, COLLISION_GROUP_NONE, &result );

	tf_debug_ballistic_target = result.endpos;
}
static ConCommand tf_debug_ballistic_targeting_mark_target( "tf_debug_ballistic_targeting_mark_target", CC_tf_debug_ballistic_targeting_mark_target, "Mark a spot for testing ballistic targeting.", FCVAR_CHEAT );

ConVar tf_infinite_ammo( "tf_infinite_ammo", "0", FCVAR_CHEAT );

extern ConVar tf_bountymode_currency_starting;
extern ConVar tf_bountymode_upgrades_wipeondeath;
extern ConVar tf_bountymode_currency_penalty_ondeath;
#endif // STAGING_ONLY

ConVar tf_halloween_unlimited_spells( "tf_halloween_unlimited_spells", "0", FCVAR_CHEAT );
extern ConVar tf_halloween_kart_boost_recharge;
extern ConVar tf_halloween_kart_boost_duration;

ConVar tf_halloween_kart_impact_force( "tf_halloween_kart_impact_force", "0.75f", FCVAR_CHEAT, "Impact force scaler" );
ConVar tf_halloween_kart_impact_damage( "tf_halloween_kart_impact_damage", "1.0f", FCVAR_CHEAT, "Impact damage scaler" );
ConVar tf_halloween_kart_impact_rate( "tf_halloween_kart_impact_rate", "0.5f", FCVAR_CHEAT, "rate of allowing impact damage" );
ConVar tf_halloween_kart_boost_impact_force( "tf_halloween_kart_boost_impact_force", "0.75f", FCVAR_CHEAT, "Impact force scaler on boosts" );
ConVar tf_halloween_kart_impact_bounds_scale( "tf_halloween_kart_impact_bounds_scale", "1.0f", FCVAR_CHEAT );
ConVar tf_halloween_kart_impact_feedback( "tf_halloween_kart_impact_feedback", "0.25f", FCVAR_CHEAT );
ConVar tf_halloween_kart_impact_lookahead( "tf_halloween_kart_impact_lookahead", "12.0f", FCVAR_CHEAT );
ConVar tf_halloween_kart_bomb_head_damage_scale( "tf_halloween_kart_bomb_head_damage_scale", "2", FCVAR_CHEAT );
ConVar tf_halloween_kart_bomb_head_impulse_scale( "tf_halloween_kart_bomb_head_impulse_scale", "2", FCVAR_CHEAT );
ConVar tf_halloween_kart_impact_air_scale( "tf_halloween_kart_impact_air_scale", "0.75f", FCVAR_CHEAT );
ConVar tf_halloween_kart_damage_to_force( "tf_halloween_kart_damage_to_force", "300.0f", FCVAR_CHEAT );
ConVar tf_halloween_kart_stun_duration_scale( "tf_halloween_kart_stun_duration_scale", "0.70f", FCVAR_CHEAT );
ConVar tf_halloween_kart_stun_amount( "tf_halloween_kart_stun_amount", "1.0f", FCVAR_CHEAT );
ConVar tf_halloween_kart_stun_enabled( "tf_halloween_kart_stun_enabled", "1", FCVAR_CHEAT );

ConVar tf_tauntcam_fov_override( "tf_tauntcam_fov_override", "0", FCVAR_CHEAT );

ConVar tf_nav_in_combat_range( "tf_nav_in_combat_range", "1000", FCVAR_CHEAT );

ConVar tf_halloween_kart_punting_ghost_force_scale( "tf_halloween_kart_punting_ghost_force_scale", "4", FCVAR_CHEAT );
ConVar tf_halloween_allow_ghost_hit_by_kart_delay( "tf_halloween_allow_ghost_hit_by_kart_delay", "0.5", FCVAR_CHEAT );

extern ConVar tf_feign_death_duration;
extern ConVar spec_freeze_time;
extern ConVar spec_freeze_traveltime;
extern ConVar sv_maxunlag;
extern ConVar tf_allow_taunt_switch;
extern ConVar weapon_medigun_chargerelease_rate;
extern ConVar tf_scout_energydrink_consume_rate;
extern ConVar tf_mm_trusted;
extern ConVar mp_spectators_restricted;
extern ConVar mp_teams_unbalance_limit;
extern ConVar tf_tournament_classchange_allowed;
extern ConVar tf_tournament_classchange_ready_allowed;
#if defined( _DEBUG ) || defined( STAGING_ONLY )
extern ConVar mp_developer;
#endif // _DEBUG || STAGING_ONLY 
#ifdef STAGING_ONLY
extern ConVar tf_skillrating_debug_bots_allowed;
#endif // STAGING_ONLY

extern CBaseEntity *FindPickerEntity( CBasePlayer *pPlayer );
extern bool CanScatterGunKnockBack( CTFWeaponBase *pWeapon, float flDamage, float flDistanceSq );

static const char *s_pszTauntRPSParticleNames[] =
{
	"rps_rock_red",
	"rps_paper_red",
	"rps_scissors_red",
	"rps_rock_red_win",
	"rps_paper_red_win",
	"rps_scissors_red_win",
	"rps_rock_blue",
	"rps_paper_blue",
	"rps_scissors_blue",
	"rps_rock_blue_win",
	"rps_paper_blue_win",
	"rps_scissors_blue_win"
};

// -------------------------------------------------------------------------------- //
// Player animation event. Sent to the client when a player fires, jumps, reloads, etc..
// -------------------------------------------------------------------------------- //

class CTEPlayerAnimEvent : public CBaseTempEntity
{
public:
	DECLARE_CLASS( CTEPlayerAnimEvent, CBaseTempEntity );
	DECLARE_SERVERCLASS();

	CTEPlayerAnimEvent( const char *name ) : CBaseTempEntity( name )
	{
		m_iPlayerIndex = TF_PLAYER_INDEX_NONE;
	}

	CNetworkVar( int, m_iPlayerIndex );
	CNetworkVar( int, m_iEvent );
	CNetworkVar( int, m_nData );
};

IMPLEMENT_SERVERCLASS_ST_NOBASE( CTEPlayerAnimEvent, DT_TEPlayerAnimEvent )
	SendPropInt( SENDINFO( m_iPlayerIndex ), 7, SPROP_UNSIGNED ),
	SendPropInt( SENDINFO( m_iEvent ), Q_log2( PLAYERANIMEVENT_COUNT ) + 1, SPROP_UNSIGNED ),
	// BUGBUG:  ywb  we assume this is either 0 or an animation sequence #, but it could also be an activity, which should fit within this limit, but we're not guaranteed.
	SendPropInt( SENDINFO( m_nData ), ANIMATION_SEQUENCE_BITS ),
END_SEND_TABLE()

static CTEPlayerAnimEvent g_TEPlayerAnimEvent( "PlayerAnimEvent" );

void TE_PlayerAnimEvent( CBasePlayer *pPlayer, PlayerAnimEvent_t event, int nData )
{
    Vector vecEyePos = pPlayer->EyePosition();
	CPVSFilter filter( vecEyePos );
	if ( !IsCustomPlayerAnimEvent( event ) && ( event != PLAYERANIMEVENT_SNAP_YAW ) && ( event != PLAYERANIMEVENT_VOICE_COMMAND_GESTURE ) )
	{
		// if prediction is off, alway send jump
		if ( !( ( event == PLAYERANIMEVENT_JUMP ) && ( FStrEq(engine->GetClientConVarValue( pPlayer->entindex(), "cl_predict" ), "0" ) ) ) )
		{
			filter.RemoveRecipient( pPlayer );
		}
	}

	Assert( pPlayer->entindex() >= 1 && pPlayer->entindex() <= MAX_PLAYERS );
	g_TEPlayerAnimEvent.m_iPlayerIndex = pPlayer->entindex();
	g_TEPlayerAnimEvent.m_iEvent = event;
	Assert( nData < (1<<ANIMATION_SEQUENCE_BITS) );
	Assert( (1<<ANIMATION_SEQUENCE_BITS) >= ActivityList_HighestIndex() );
	g_TEPlayerAnimEvent.m_nData = nData;
	g_TEPlayerAnimEvent.Create( filter, 0 );
}

//=================================================================================
//
// Ragdoll Entity
//
class CTFRagdoll : public CBaseAnimatingOverlay
{
public:

	DECLARE_CLASS( CTFRagdoll, CBaseAnimatingOverlay );
	DECLARE_SERVERCLASS();

	CTFRagdoll()
	{
		m_iPlayerIndex.Set( TF_PLAYER_INDEX_NONE );
		m_bGib = false;
		m_bBurning = false;
		m_bElectrocuted = false;
		m_bFeignDeath = false;
		m_bWasDisguised = false;
		m_bBecomeAsh = false;
		m_bOnGround = false;
		m_bCloaked = false;
		m_iDamageCustom = 0;
		m_bCritOnHardHit = false;
		m_vecRagdollOrigin.Init();
		m_vecRagdollVelocity.Init();
	}

	~CTFRagdoll()
	{
		// Destroy all of our attached wearables.
		for ( int i=0; i<m_hRagWearables.Count(); ++i )
		{
			if ( m_hRagWearables[i] )
			{
				m_hRagWearables[i]->Remove();
			}
		}
		m_hRagWearables.Purge();
	}

	// Transmit ragdolls to everyone.
	virtual int UpdateTransmitState()
	{
		UseClientSideAnimation();
		return SetTransmitState( FL_EDICT_ALWAYS );
	}

	CNetworkVar( int, m_iPlayerIndex );
	CNetworkVector( m_vecRagdollVelocity );
	CNetworkVector( m_vecRagdollOrigin );
	CNetworkVar( bool, m_bGib );
	CNetworkVar( bool, m_bBurning );
	CNetworkVar( bool, m_bElectrocuted );
	CNetworkVar( bool, m_bFeignDeath );
	CNetworkVar( bool, m_bWasDisguised );
	CNetworkVar( bool, m_bBecomeAsh );
	CNetworkVar( bool, m_bOnGround );
	CNetworkVar( bool, m_bCloaked );
	CNetworkVar( int, m_iDamageCustom );
	CNetworkVar( int, m_iTeam );
	CNetworkVar( int, m_iClass );
	CNetworkVar( bool, m_bGoldRagdoll );
	CNetworkVar( bool, m_bIceRagdoll );
	CNetworkVar( bool, m_bCritOnHardHit );
	CNetworkVar( float, m_flHeadScale );
	CNetworkVar( float, m_flTorsoScale );
	CNetworkVar( float, m_flHandScale );
	CUtlVector<CHandle<CEconWearable > > m_hRagWearables;
};

LINK_ENTITY_TO_CLASS( tf_ragdoll, CTFRagdoll );

IMPLEMENT_SERVERCLASS_ST_NOBASE( CTFRagdoll, DT_TFRagdoll )
	SendPropVector( SENDINFO( m_vecRagdollOrigin ), -1,  SPROP_COORD ),
	SendPropInt( SENDINFO( m_iPlayerIndex ), 7, SPROP_UNSIGNED ),
	SendPropVector	( SENDINFO(m_vecForce), -1, SPROP_NOSCALE ),
	SendPropVector( SENDINFO( m_vecRagdollVelocity ), 13, SPROP_ROUNDDOWN, -2048.0f, 2048.0f ),
	SendPropInt( SENDINFO( m_nForceBone ) ),
	SendPropBool( SENDINFO( m_bGib ) ),
	SendPropBool( SENDINFO( m_bBurning ) ),
	SendPropBool( SENDINFO( m_bElectrocuted ) ),
	SendPropBool( SENDINFO( m_bFeignDeath ) ),
	SendPropBool( SENDINFO( m_bWasDisguised ) ),
	SendPropBool( SENDINFO( m_bBecomeAsh ) ),
	SendPropBool( SENDINFO( m_bOnGround ) ),
	SendPropBool( SENDINFO( m_bCloaked ) ),
	SendPropInt( SENDINFO( m_iDamageCustom ) ),
	SendPropInt( SENDINFO( m_iTeam ), 3, SPROP_UNSIGNED ),
	SendPropInt( SENDINFO( m_iClass ), 4, SPROP_UNSIGNED ),			
	SendPropUtlVector( SENDINFO_UTLVECTOR( m_hRagWearables ), 8, SendPropEHandle( NULL, 0 ) ),
	SendPropBool( SENDINFO( m_bGoldRagdoll ) ),
	SendPropBool( SENDINFO( m_bIceRagdoll ) ),
	SendPropBool( SENDINFO( m_bCritOnHardHit ) ),
	SendPropFloat( SENDINFO( m_flHeadScale ) ),
	SendPropFloat( SENDINFO( m_flTorsoScale ) ),
	SendPropFloat( SENDINFO( m_flHandScale ) ),
END_SEND_TABLE()

// -------------------------------------------------------------------------------- //
// Tables.
// -------------------------------------------------------------------------------- //

//-----------------------------------------------------------------------------
// Purpose: Filters updates to a variable so that only non-local players see
// the changes.  This is so we can send a low-res origin to non-local players
// while sending a hi-res one to the local player.
// Input  : *pVarData - 
//			*pOut - 
//			objectID - 
//-----------------------------------------------------------------------------

void* SendProxy_SendNonLocalDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
{
	pRecipients->SetAllRecipients();
	pRecipients->ClearRecipient( objectID - 1 );
	return ( void * )pVarData;
}
REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendNonLocalDataTable );

//-----------------------------------------------------------------------------
// Purpose: SendProxy that converts the UtlVector list of objects to entindexes, where it's reassembled on the client
//-----------------------------------------------------------------------------
void SendProxy_PlayerObjectList( const SendProp *pProp, const void *pStruct, const void *pData, DVariant *pOut, int iElement, int objectID )
{
	CTFPlayer *pPlayer = (CTFPlayer*)pStruct;

	// If this fails, then SendProxyArrayLength_PlayerObjects didn't work.
	Assert( iElement < pPlayer->GetObjectCount() );

	CBaseObject *pObject = pPlayer->GetObject(iElement);

	EHANDLE hObject;
	hObject = pObject;

	SendProxy_EHandleToInt( pProp, pStruct, &hObject, pOut, iElement, objectID );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int SendProxyArrayLength_PlayerObjects( const void *pStruct, int objectID )
{
	CTFPlayer *pPlayer = (CTFPlayer*)pStruct;
	int iObjects = pPlayer->GetObjectCount();
	Assert( iObjects <= MAX_OBJECTS_PER_PLAYER );
	return iObjects;
}

//-----------------------------------------------------------------------------
// Purpose: Send to attached medics
//-----------------------------------------------------------------------------
void* SendProxy_SendHealersDataTable( const SendProp *pProp, const void *pStruct, const void *pVarData, CSendProxyRecipients *pRecipients, int objectID )
{
	CTFPlayer *pPlayer = (CTFPlayer*)pStruct;
	if ( pPlayer )
	{
		// Add attached medics
		for ( int i = 0; i < pPlayer->m_Shared.GetNumHealers(); i++ )
		{
			CTFPlayer *pMedic = ToTFPlayer( pPlayer->m_Shared.GetHealerByIndex( i ) );
			if ( !pMedic )
				continue;

			pRecipients->SetRecipient( pMedic->GetClientIndex() );
			return (void*)pVarData;
		}
	}

	return NULL;
}
REGISTER_SEND_PROXY_NON_MODIFIED_POINTER( SendProxy_SendHealersDataTable );

BEGIN_DATADESC( CTFPlayer )
	DEFINE_INPUTFUNC( FIELD_VOID, "IgnitePlayer", InputIgnitePlayer ),
	DEFINE_INPUTFUNC( FIELD_STRING, "SetCustomModel", InputSetCustomModel ),
	DEFINE_INPUTFUNC( FIELD_VECTOR, "SetCustomModelOffset", InputSetCustomModelOffset ),
	DEFINE_INPUTFUNC( FIELD_VECTOR, "SetCustomModelRotation", InputSetCustomModelRotation ),
	DEFINE_INPUTFUNC( FIELD_VOID, "ClearCustomModelRotation", InputClearCustomModelRotation ),
	DEFINE_INPUTFUNC( FIELD_BOOLEAN, "SetCustomModelRotates", InputSetCustomModelRotates ),
	DEFINE_INPUTFUNC( FIELD_BOOLEAN, "SetCustomModelVisibleToSelf", InputSetCustomModelVisibleToSelf ),
	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetForcedTauntCam", InputSetForcedTauntCam ),
	DEFINE_INPUTFUNC( FIELD_VOID, "ExtinguishPlayer", InputExtinguishPlayer ),
	DEFINE_INPUTFUNC( FIELD_FLOAT, "BleedPlayer", InputBleedPlayer ),
	DEFINE_INPUTFUNC( FIELD_VOID, "TriggerLootIslandAchievement", InputTriggerLootIslandAchievement ),
	DEFINE_INPUTFUNC( FIELD_VOID, "TriggerLootIslandAchievement2", InputTriggerLootIslandAchievement2 ),
	DEFINE_INPUTFUNC( FIELD_STRING,	"SpeakResponseConcept",	InputSpeakResponseConcept ),
	DEFINE_INPUTFUNC( FIELD_VOID, "RollRareSpell", InputRollRareSpell ),
	DEFINE_INPUTFUNC( FIELD_VOID, "RoundSpawn", InputRoundSpawn ),
END_DATADESC()

EXTERN_SEND_TABLE( DT_ScriptCreatedItem );

// specific to the local player
BEGIN_SEND_TABLE_NOBASE( CTFPlayer, DT_TFLocalPlayerExclusive )
	// send a hi-res origin to the local player for use in prediction
	SendPropVectorXY(SENDINFO(m_vecOrigin),               -1, SPROP_NOSCALE|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_OriginXY ),
	SendPropFloat   (SENDINFO_VECTORELEM(m_vecOrigin, 2), -1, SPROP_NOSCALE|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_OriginZ ),
	SendPropArray2( 
		SendProxyArrayLength_PlayerObjects,
		SendPropInt("player_object_array_element", 0, SIZEOF_IGNORE, NUM_NETWORKED_EHANDLE_BITS, SPROP_UNSIGNED, SendProxy_PlayerObjectList), 
		MAX_OBJECTS_PER_PLAYER, 
		0, 
		"player_object_array"
		),

	SendPropFloat( SENDINFO_VECTORELEM(m_angEyeAngles, 0), 8, SPROP_CHANGES_OFTEN, -90.0f, 90.0f ),		// No longer used by the local player, could be omitted. Preserved for backwards-compat for now.
//	SendPropAngle( SENDINFO_VECTORELEM(m_angEyeAngles, 1), 10, SPROP_CHANGES_OFTEN ),

	SendPropBool( SENDINFO( m_bIsCoaching ) ),
	SendPropEHandle( SENDINFO( m_hCoach ) ),
	SendPropEHandle( SENDINFO( m_hStudent ) ),

	SendPropInt( SENDINFO( m_nCurrency ), -1, SPROP_VARINT ),
	SendPropInt( SENDINFO( m_nExperienceLevel ), 7, SPROP_UNSIGNED ),
	SendPropInt( SENDINFO( m_nExperienceLevelProgress ), 7, SPROP_UNSIGNED ),
	SendPropBool( SENDINFO( m_bMatchSafeToLeave ) ),

END_SEND_TABLE()

// all players except the local player
BEGIN_SEND_TABLE_NOBASE( CTFPlayer, DT_TFNonLocalPlayerExclusive )
	// send a lo-res origin to other players
	SendPropVectorXY(SENDINFO(m_vecOrigin),               -1, SPROP_COORD_MP_LOWPRECISION|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_OriginXY ),
	SendPropFloat   (SENDINFO_VECTORELEM(m_vecOrigin, 2), -1, SPROP_COORD_MP_LOWPRECISION|SPROP_CHANGES_OFTEN, 0.0f, HIGH_DEFAULT, SendProxy_OriginZ ),

	SendPropFloat( SENDINFO_VECTORELEM(m_angEyeAngles, 0), 8, SPROP_CHANGES_OFTEN, -90.0f, 90.0f ),
	SendPropAngle( SENDINFO_VECTORELEM(m_angEyeAngles, 1), 10, SPROP_CHANGES_OFTEN ),

END_SEND_TABLE()

//-----------------------------------------------------------------------------
// Purpose: Sent to attached medics
//-----------------------------------------------------------------------------
BEGIN_SEND_TABLE_NOBASE( CTFPlayer, DT_TFSendHealersDataTable )
	SendPropInt( SENDINFO( m_nActiveWpnClip ), -1, SPROP_VARINT | SPROP_UNSIGNED ),
END_SEND_TABLE()

//============

LINK_ENTITY_TO_CLASS( player, CTFPlayer );
PRECACHE_REGISTER(player);

IMPLEMENT_SERVERCLASS_ST( CTFPlayer, DT_TFPlayer )
	SendPropExclude( "DT_BaseAnimating", "m_flPoseParameter" ),
	SendPropExclude( "DT_BaseAnimating", "m_flPlaybackRate" ),	
	SendPropExclude( "DT_BaseAnimating", "m_nSequence" ),
	SendPropExclude( "DT_BaseAnimating", "m_nBody" ),
	SendPropExclude( "DT_BaseEntity", "m_angRotation" ),
	SendPropExclude( "DT_BaseAnimatingOverlay", "overlay_vars" ),
	SendPropExclude( "DT_BaseEntity", "m_nModelIndex" ),
	SendPropExclude( "DT_BaseEntity", "m_vecOrigin" ),

	// cs_playeranimstate and clientside animation takes care of these on the client
	SendPropExclude( "DT_ServerAnimationData" , "m_flCycle" ),	
	SendPropExclude( "DT_AnimTimeMustBeFirst" , "m_flAnimTime" ),

	SendPropExclude( "DT_BaseFlex", "m_flexWeight" ),
	SendPropExclude( "DT_BaseFlex", "m_blinktoggle" ),
	SendPropExclude( "DT_BaseFlex", "m_viewtarget" ),

	SendPropBool(SENDINFO(m_bSaveMeParity)),
	SendPropBool(SENDINFO(m_bIsMiniBoss)),
	SendPropBool(SENDINFO(m_bIsABot)),
	SendPropInt( SENDINFO(m_nBotSkill), 3, SPROP_UNSIGNED ),

	// This will create a race condition will the local player, but the data will be the same so.....
	SendPropInt( SENDINFO( m_nWaterLevel ), 2, SPROP_UNSIGNED ),

	// Ragdoll.
	SendPropEHandle( SENDINFO( m_hRagdoll ) ),
	SendPropDataTable( SENDINFO_DT( m_PlayerClass ), &REFERENCE_SEND_TABLE( DT_TFPlayerClassShared ) ),
	SendPropDataTable( SENDINFO_DT( m_Shared ), &REFERENCE_SEND_TABLE( DT_TFPlayerShared ) ),
	SendPropEHandle(SENDINFO(m_hItem)),

	// Data that only gets sent to the local player
	SendPropDataTable( "tflocaldata", 0, &REFERENCE_SEND_TABLE(DT_TFLocalPlayerExclusive), SendProxy_SendLocalDataTable ),

	// Data that gets sent to all other players
	SendPropDataTable( "tfnonlocaldata", 0, &REFERENCE_SEND_TABLE(DT_TFNonLocalPlayerExclusive), SendProxy_SendNonLocalDataTable ),

	SendPropBool( SENDINFO( m_bAllowMoveDuringTaunt ) ),
	SendPropBool( SENDINFO( m_bIsReadyToHighFive ) ),
	SendPropEHandle( SENDINFO( m_hHighFivePartner ) ),
	SendPropInt( SENDINFO( m_nForceTauntCam ), 2, SPROP_UNSIGNED ),
	SendPropFloat( SENDINFO( m_flTauntYaw ), 0, SPROP_NOSCALE ),
	SendPropInt( SENDINFO( m_nActiveTauntSlot ) ),
	SendPropInt( SENDINFO( m_iTauntItemDefIndex ) ),
	SendPropFloat( SENDINFO( m_flCurrentTauntMoveSpeed ) ),
	SendPropFloat( SENDINFO( m_flVehicleReverseTime ) ),

	SendPropFloat( SENDINFO( m_flLastDamageTime ), 16, SPROP_ROUNDUP ),

	SendPropBool( SENDINFO( m_bInPowerPlay ) ),

	SendPropInt( SENDINFO( m_iSpawnCounter ) ),
	SendPropBool( SENDINFO( m_bArenaSpectator ) ),
	SendPropFloat( SENDINFO( m_flHeadScale ) ),
	SendPropFloat( SENDINFO( m_flTorsoScale ) ),
	SendPropFloat( SENDINFO( m_flHandScale ) ),

	SendPropBool( SENDINFO( m_bUseBossHealthBar ) ),

	SendPropBool( SENDINFO( m_bUsingVRHeadset ) ),

	SendPropBool( SENDINFO( m_bForcedSkin ) ),
	SendPropInt( SENDINFO( m_nForcedSkin ), ANIMATION_SKIN_BITS ),

	SendPropDataTable( SENDINFO_DT( m_AttributeManager ), &REFERENCE_SEND_TABLE(DT_AttributeManager) ),

	SendPropDataTable( "TFSendHealersDataTable", 0, &REFERENCE_SEND_TABLE( DT_TFSendHealersDataTable ), SendProxy_SendHealersDataTable ),

	SendPropFloat( SENDINFO( m_flKartNextAvailableBoost ) ),
	SendPropInt( SENDINFO( m_iKartHealth ) ),
	SendPropInt( SENDINFO( m_iKartState ) ),
	SendPropEHandle( SENDINFO( m_hGrapplingHookTarget ) ),
	SendPropEHandle( SENDINFO( m_hSecondaryLastWeapon ) ),
	SendPropBool( SENDINFO( m_bUsingActionSlot ) ),
	SendPropFloat( SENDINFO( m_flInspectTime ) ),
	SendPropInt( SENDINFO( m_iCampaignMedals ) ),
	SendPropInt( SENDINFO( m_iPlayerSkinOverride ) ),
END_SEND_TABLE()

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

void cc_CreatePredictionError_f()
{
	CBaseEntity *pEnt = CBaseEntity::Instance( 1 );
	pEnt->SetAbsOrigin( pEnt->GetAbsOrigin() + Vector( 63, 0, 0 ) );
}
ConCommand cc_CreatePredictionError( "CreatePredictionError", cc_CreatePredictionError_f, "Create a prediction error", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );

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

enum eCoachCommand
{
	kCoachCommand_Look = 1, // slot1
	kCoachCommand_Go,		// slot2
	kCoachCommand_Attack,
	kCoachCommand_Defend,
	kNumCoachCommands,
};

/**
 * Handles a command from the coach
 */
static void HandleCoachCommand( CTFPlayer *pPlayer, eCoachCommand command )
{
	if ( pPlayer && pPlayer->IsCoaching() && pPlayer->GetStudent() && command < kNumCoachCommands )
	{
		const float kMaxRateCoachCommands = 1.0f;
		float flLastCoachCommandDelta = gpGlobals->curtime - pPlayer->m_flLastCoachCommand;
		if ( flLastCoachCommandDelta < kMaxRateCoachCommands && flLastCoachCommandDelta > 0.0f )
		{
			return;
		}
		pPlayer->m_flLastCoachCommand = gpGlobals->curtime;
		IGameEvent *pEvent = gameeventmanager->CreateEvent( "show_annotation" );
		if ( pEvent )
		{
			Vector vForward;
 			AngleVectors( pPlayer->EyeAngles(), &vForward );

			trace_t	trace;
			CTraceFilterSimple filter( pPlayer->GetStudent(), COLLISION_GROUP_NONE );
			UTIL_TraceLine( pPlayer->EyePosition(), pPlayer->EyePosition() + vForward * MAX_TRACE_LENGTH, MASK_SOLID, &filter, &trace );

			CBaseEntity *pHitEntity = trace.m_pEnt && trace.m_pEnt->IsWorld() == false && trace.m_pEnt != pPlayer->GetStudent() ? trace.m_pEnt : NULL;
			pEvent->SetInt( "id", pPlayer->entindex() );
			pEvent->SetFloat( "worldPosX", trace.endpos.x );
			pEvent->SetFloat( "worldPosY", trace.endpos.y );
			pEvent->SetFloat( "worldPosZ", trace.endpos.z );
			pEvent->SetFloat( "worldNormalX", trace.plane.normal.x );
			pEvent->SetFloat( "worldNormalY", trace.plane.normal.y );
			pEvent->SetFloat( "worldNormalZ", trace.plane.normal.z );
			pEvent->SetFloat( "lifetime", 10.0f );
			if ( pHitEntity )
			{
				pEvent->SetInt( "follow_entindex", pHitEntity->entindex() );
			}
			pEvent->SetInt( "visibilityBitfield", ( 1 << pPlayer->entindex() | 1 << pPlayer->GetStudent()->entindex() ) );
			pEvent->SetBool( "show_distance", true );
			pEvent->SetBool( "show_effect", true );

			switch ( command )
			{
			case kCoachCommand_Attack:	
				pEvent->SetString( "text", pHitEntity ? "#TF_Coach_AttackThis" : "#TF_Coach_AttackHere" ); 
				pEvent->SetString( "play_sound", "coach/coach_attack_here.wav" );
				break;
			case kCoachCommand_Defend:	
				pEvent->SetString( "text", pHitEntity ? "#TF_Coach_DefendThis" : "#TF_Coach_DefendHere" ); 
				pEvent->SetString( "play_sound", "coach/coach_defend_here.wav" );
				break;
			case kCoachCommand_Look:	
				pEvent->SetString( "text", pHitEntity ? "#TF_Coach_LookAt" : "#TF_Coach_LookHere" ); 
				pEvent->SetString( "play_sound", "coach/coach_look_here.wav" );
				break;
			case kCoachCommand_Go:
				pEvent->SetString( "text", pHitEntity ? "#TF_Coach_GoToThis" : "#TF_Coach_GoHere" ); 
				pEvent->SetString( "play_sound", "coach/coach_go_here.wav" );
				break;
			}
			gameeventmanager->FireEvent( pEvent );
		}

	}
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFPlayer::CTFPlayer() 
{
	m_pAttributes = this;

	m_PlayerAnimState = CreateTFPlayerAnimState( this );

	SetArmorValue( 10 );

	m_hItem = NULL;
	m_hTauntScene = NULL;
	m_hTauntProp = NULL;

	UseClientSideAnimation();
	m_angEyeAngles.Init();
	m_pStateInfo = NULL;
	m_lifeState = LIFE_DEAD; // Start "dead".
	m_iMaxSentryKills = 0;
	m_flLastCoachCommand = 0;

	m_flNextTimeCheck = gpGlobals->curtime;
	m_flSpawnTime = 0;

	m_flWaterExitTime = 0;

	SetViewOffset( TF_PLAYER_VIEW_OFFSET );

	m_Shared.Init( this );

	m_iLastSkin = -1;

	m_bHudClassAutoKill = false;
	m_bMedigunAutoHeal = false;

	m_vecLastDeathPosition = Vector( FLT_MAX, FLT_MAX, FLT_MAX );

	SetDesiredPlayerClassIndex( TF_CLASS_UNDEFINED );

	SetContextThink( &CTFPlayer::TFPlayerThink, gpGlobals->curtime, "TFPlayerThink" );

	m_flLastAction = gpGlobals->curtime;
	m_flTimeInSpawn = 0;

	m_bInitTaunt = false;

	m_bSpeakingConceptAsDisguisedSpy = false;

	m_iPreviousteam = TEAM_UNASSIGNED;
	m_bArenaSpectator = false;

	m_bArenaIsAFK = false;
	m_bIsAFK = false;

	m_nDeployingBombState = TF_BOMB_DEPLOYING_NONE;

	m_flNextChangeClassTime = 0.0f;
	m_flNextChangeTeamTime = 0.0f;

	m_bScattergunJump = false;
	m_iOldStunFlags = 0;
	m_iLastWeaponSlot = 1;
	m_iNumberofDominations = 0;
	m_bFlipViewModels = false;
	m_iBlastJumpState = 0;
	m_flBlastJumpLandTime = 0;
	m_fMaxHealthTime = -1;
	m_iHealthBefore = 0;

	m_iTeamChanges = 0;
	m_iClassChanges = 0;

	m_hReviveMarker = NULL;

	// Bounty Mode
	m_nExperienceLevel = 1;
	m_nExperiencePoints = 0;
	m_nExperienceLevelProgress = 0;

	SetDefLessFunc( m_Cappers );		// Tracks victims for demo achievement

 	//=============================================================================
	// HPE_BEGIN:
	// [msmith]	Added a player type so we can distinguish between bots and humans.
	//============================================================================= 
	m_playerType = HUMAN_PLAYER;
	//=============================================================================
	// HPE_END
	//=============================================================================

	m_bIsTargetDummy = false;
	
	m_bCollideWithSentry = false;

	m_flCommentOnCarrying = 0;

	m_bIsReadyToHighFive = false;
	m_hHighFivePartner = NULL;
	m_nForceTauntCam = 0;
	m_bAllowMoveDuringTaunt = false;
	m_bTauntForceMoveForward = false;
	m_flTauntForceMoveForwardSpeed = 0.f;
	m_flTauntMoveAccelerationTime = 0.f;
	m_flTauntTurnSpeed = 0.f;
	m_flTauntTurnAccelerationTime = 0.f;
	m_bTauntMimic = false;
	m_bIsTauntInitiator = false;
	m_TauntEconItemView.Invalidate();
	m_iPreTauntWeaponSlot = -1;

	m_bIsCalculatingMaximumSpeed = false;

	m_flLastThinkTime = -1.f;

	m_nCurrency = 0;
	m_pWaveSpawnPopulator = NULL;
	m_flLastReadySoundTime = 0.f;

	m_damageRateArray = new int[ DPS_Period ];
	ResetDamagePerSecond();

	m_nActiveWpnClip.Set( 0 );
	m_nActiveWpnClipPrev = 0;
	m_flNextClipSendTime = 0;

	m_nCanPurchaseUpgradesCount = 0;

	m_flHeadScale = 1.f;
	m_flTorsoScale = 1.f;
	m_flHandScale = 1.f;

	m_bPendingMerasmusPlayerBombExplode = false;
	m_fLastBombHeadTimestamp = 0.0f;

	m_bIsSapping = false;
	m_iSappingEvent = TF_SAPEVENT_NONE;
	m_flSapStartTime = 0.00;

	m_bIsMiniBoss = false;

	m_bUseBossHealthBar = false;

	m_bUsingVRHeadset = false;

	m_bForcedSkin = false;
	m_nForcedSkin = 0;

	SetRespawnOverride( -1.f, NULL_STRING );

	m_qPreviousChargeEyeAngle.Init();

	m_vHalloweenKartPush.Zero();
	m_flHalloweenKartPushEventTime = 0.f;
	m_bCheckKartCollision = false;
	m_flHHHKartAttackTime = 0.f;
	m_flNextBonusDucksVOAllowedTime = 0.f;

	m_flGhostLastHitByKartTime = 0.f;

	m_flVehicleReverseTime = FLT_MAX;
	m_iCampaignMedals = 0;

	m_bPasstimeBallSlippery = false;
	m_flNextScorePointForPD = -1;

	m_iPlayerSkinOverride = 0;

	m_nPrevRoundTeamNum = TEAM_UNASSIGNED;
	m_flLastDamageResistSoundTime = -1.f;
	m_hLastDamageDoneEntity = NULL;
	
	m_mapCustomAttributes.SetLessFunc( UtlStringCaseInsensitiveLessFunc );

	SetDefLessFunc( m_PlayersExtinguished );

	m_flLastAutobalanceTime = 0.f;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ForcePlayerViewAngles( const QAngle& qTeleportAngles )
{
	CSingleUserRecipientFilter filter( this );

	UserMessageBegin( filter, "ForcePlayerViewAngles" );
	WRITE_BYTE( 0x01 ); // Reserved space for flags.
	WRITE_BYTE( entindex() );
	WRITE_ANGLES( qTeleportAngles );
	MessageEnd();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::SetGrapplingHookTarget( CBaseEntity *pTarget, bool bShouldBleed /*= false*/ )
{
	if ( pTarget )
	{
		// prevent fall damage after a successful hook
		m_Shared.AddCond( TF_COND_GRAPPLINGHOOK_SAFEFALL );
		m_Shared.AddCond( TF_COND_GRAPPLINGHOOK_LATCHED );
	}
	else
	{
		m_Shared.RemoveCond( TF_COND_GRAPPLINGHOOK_LATCHED );
	}

	CBaseEntity *pPreviousTarget = m_hGrapplingHookTarget;
	m_hGrapplingHookTarget = pTarget;
	
	if ( pTarget )
	{
		if ( pTarget->IsPlayer() )
		{
			CTFPlayer *pTargetPlayer = ToTFPlayer( pTarget );

			m_Shared.AddCond( TF_COND_GRAPPLED_TO_PLAYER );

			// make player bleed
			if ( bShouldBleed )
			{
				CTFGrapplingHook *pGrapplingHook = dynamic_cast< CTFGrapplingHook* >( GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
				if ( pGrapplingHook )
					pTargetPlayer->m_Shared.MakeBleed( this, pGrapplingHook, 0, TF_BLEEDING_DMG, true );

				pTargetPlayer->m_nHookAttachedPlayers++;
			}

			if ( !pTargetPlayer->m_Shared.InCond( TF_COND_GRAPPLINGHOOK_BLEEDING ) && pTargetPlayer->m_nHookAttachedPlayers > 0 )
			{
				pTargetPlayer->m_Shared.AddCond( TF_COND_GRAPPLINGHOOK_BLEEDING );
			}
			if ( !pTargetPlayer->m_Shared.InCond( TF_COND_GRAPPLED_BY_PLAYER ) && pTargetPlayer->m_nHookAttachedPlayers > 0 )
			{
				pTargetPlayer->m_Shared.AddCond( TF_COND_GRAPPLED_BY_PLAYER );
			}
		}

		m_flLastSeenHookTarget = gpGlobals->curtime;
	}
	else
	{
		if ( pPreviousTarget && pPreviousTarget->IsPlayer() )
		{
			CTFPlayer *pPreviousTargetPlayer = ToTFPlayer( pPreviousTarget );

			m_Shared.RemoveCond( TF_COND_GRAPPLED_TO_PLAYER );
			
			// try to remove bleeding from hook if there's one
			if ( pPreviousTargetPlayer->m_Shared.InCond( TF_COND_BLEEDING ) )
			{
				CTFGrapplingHook *pGrapplingHook = dynamic_cast< CTFGrapplingHook* >( GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
				if ( pGrapplingHook )
					pPreviousTargetPlayer->m_Shared.StopBleed( this, pGrapplingHook );
			}

			pPreviousTargetPlayer->m_nHookAttachedPlayers--;
			Assert( pPreviousTargetPlayer->m_nHookAttachedPlayers >= 0 );
			if ( pPreviousTargetPlayer->m_nHookAttachedPlayers == 0 )
			{
				pPreviousTargetPlayer->m_Shared.RemoveCond( TF_COND_GRAPPLINGHOOK_BLEEDING );
				pPreviousTargetPlayer->m_Shared.RemoveCond( TF_COND_GRAPPLED_BY_PLAYER );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::CanBeForcedToLaugh( void )
{
	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && IsBot() && ( GetTeamNumber() == TF_TEAM_PVE_INVADERS ) )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::TFPlayerThink()
{
	if ( m_pStateInfo && m_pStateInfo->pfnThink )
	{
		(this->*m_pStateInfo->pfnThink)();
	}

	if ( m_flSendPickupWeaponMessageTime != -1.f && gpGlobals->curtime >= m_flSendPickupWeaponMessageTime )
	{
		CSingleUserRecipientFilter filter( this );
		filter.MakeReliable();
		UserMessageBegin( filter, "PlayerPickupWeapon" );
		MessageEnd();

		m_flSendPickupWeaponMessageTime = -1.f;
	}

	// In doomsday event, kart can run over ghost to do stuff
	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
	{
		CUtlVector< CTFPlayer * > playerVector;
		CollectPlayers( &playerVector, TEAM_ANY, true );
		CUtlVector< CTFPlayer * > ghostVector;
		for ( int i=0; i<playerVector.Count(); ++i )
		{
			if ( playerVector[i] == this )
				continue;

			// touching ghost player?
			// we just check for radius of 100 and assume that we touch to avoid custom collision for ghost
			if ( playerVector[i]->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
			{
				if ( ( playerVector[i]->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr() < Square( 100 ) )
				{
					ghostVector.AddToTail( playerVector[i] );
				}
			}
		}

		for ( int i=0; i<ghostVector.Count(); ++i )
		{
			CTFPlayer *pGhost = ghostVector[i];
			
			// revive ghost on the same team
			if ( pGhost->GetTeamNumber() == GetTeamNumber() )
			{
				// Trace the ghosts bbox right where they are to see if they collide with enemy players
				trace_t trace;
				Ray_t ray;
				ray.Init( pGhost->GetAbsOrigin(), pGhost->GetAbsOrigin(), pGhost->GetPlayerMins(), pGhost->GetPlayerMaxs() );
				UTIL_TraceRay( ray, PlayerSolidMask(), pGhost, COLLISION_GROUP_PLAYER, &trace );

				// If our trace is clear, spawn that ghost
				if ( trace.fraction == 1.0f )
				{
					// Force the players kart angles to line up with our current ghost angles.
					// This should put us in the kart at the same direction we are currently looking.
					pGhost->ForcePlayerViewAngles( pGhost->GetAbsAngles() );

					pGhost->m_Shared.RemoveCond( TF_COND_HALLOWEEN_GHOST_MODE );
					pGhost->m_Shared.AddCond( TF_COND_HALLOWEEN_KART );
					pGhost->m_Shared.AddCond( TF_COND_HALLOWEEN_IN_HELL ); // keep you in hell to be able to respawn as ghost
					pGhost->m_Shared.AddCond( TF_COND_HALLOWEEN_QUICK_HEAL, 3, this );
					pGhost->EmitSound( "BumperCar.SpawnFromLava" );
					DispatchParticleEffect( "ghost_appearation", PATTACH_ABSORIGIN, pGhost );

					if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
					{
						// achievement for me!
						AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_DOOMSDAY_RESPAWN_TEAMMATES );

						IGameEvent *pEvent = gameeventmanager->CreateEvent( "respawn_ghost" );
						if ( pEvent )
						{
							pEvent->SetInt( "reviver", GetUserID() );
							pEvent->SetInt( "ghost", pGhost->GetUserID() );
							gameeventmanager->FireEvent( pEvent, true );
						}
					}
				}
			}
			else if ( tf_halloween_allow_ghost_hit_by_kart_delay.GetFloat() > 0 && gpGlobals->curtime - pGhost->m_flGhostLastHitByKartTime > tf_halloween_allow_ghost_hit_by_kart_delay.GetFloat() )
			{
				// punt off other team ghost
				float flImpactForce = GetLocalVelocity().Length();
				flImpactForce = MAX( 100.f, flImpactForce ); // add min force
				Vector vOffset = pGhost->WorldSpaceCenter() - WorldSpaceCenter();
				vOffset.z = 0;
				Vector vPuntDir = ( vOffset ).Normalized();
				vPuntDir.z = 0.5f;
				pGhost->ApplyAirBlastImpulse( tf_halloween_kart_punting_ghost_force_scale.GetFloat() * flImpactForce * vPuntDir );
				pGhost->EmitSound( "BumperCar.HitGhost" );
				pGhost->m_flGhostLastHitByKartTime = gpGlobals->curtime;
			}
		}
	}

	if ( TFGameRules() && TFGameRules()->IsUsingGrapplingHook() )
	{
		if ( IsUsingActionSlot() && GetActiveTFWeapon() && GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_GRAPPLINGHOOK )
		{
			CTFGrapplingHook *pGrapplingHook = dynamic_cast< CTFGrapplingHook* >( GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
			if ( pGrapplingHook )
			{
				Weapon_Switch( pGrapplingHook );
			}
		}

		CBaseEntity *pHookTarget = GetGrapplingHookTarget();
		if ( pHookTarget )
		{
			// detatch hook if the object's picked up
			if ( pHookTarget->IsBaseObject() )
			{
				CBaseObject *pObj = assert_cast< CBaseObject* >( pHookTarget );
				if ( pObj->IsCarried() )
				{
					SetGrapplingHookTarget( NULL );
					pHookTarget = NULL;
				}
			}

			// check if something is blocking the player from traveling to the hook target
			if ( pHookTarget )
			{
				trace_t tr;
				CTraceFilterLOS filter( this, COLLISION_GROUP_PLAYER_MOVEMENT, pHookTarget );
				UTIL_TraceLine( WorldSpaceCenter(), pHookTarget->WorldSpaceCenter(), MASK_PLAYERSOLID, &filter, &tr );
				if ( !tr.DidHit() )
				{
					m_flLastSeenHookTarget = gpGlobals->curtime;
				}
				else if ( gpGlobals->curtime - m_flLastSeenHookTarget > tf_grapplinghook_los_force_detach_time.GetFloat() )
				{
					// force to detach if the hooker lost sight of the target for sometime
					SetGrapplingHookTarget( NULL );
				}
			}
		}
	}

	UpdateCustomAttributes();

	// Time to finish the current random expression? Or time to pick a new one?
	if ( IsAlive() && !IsReadyToTauntWithPartner() && ( m_flNextSpeakWeaponFire < gpGlobals->curtime ) && m_flNextRandomExpressionTime >= 0 && gpGlobals->curtime > m_flNextRandomExpressionTime )
	{
		// Random expressions need to be cleared, because they don't loop. So if we
		// pick the same one again, we want to restart it.
		ClearExpression();
		m_iszExpressionScene = NULL_STRING;
		UpdateExpression();
	}

	if ( IsTaunting() )
	{
		if ( !m_strTauntSoundName.IsEmpty() && m_flTauntSoundTime > 0 && m_flTauntSoundTime <= gpGlobals->curtime )
		{
			EmitSound( m_strTauntSoundName.String() );
			m_flTauntSoundTime = 0.f;
		}

		if ( !m_strTauntSoundLoopName.IsEmpty() && m_flTauntSoundLoopTime > 0 && m_flTauntSoundLoopTime <= gpGlobals->curtime )
		{
			CReliableBroadcastRecipientFilter filter;
			UserMessageBegin( filter, "PlayerTauntSoundLoopStart" );
				WRITE_BYTE( entindex() );
				WRITE_STRING( m_strTauntSoundLoopName.String() );
			MessageEnd();

			m_flTauntSoundLoopTime = 0.f;
		}
		
		// play taunt outro
		if ( m_flTauntOutroTime > 0.f && m_flTauntOutroTime <= gpGlobals->curtime )
		{
			m_bAllowedToRemoveTaunt = true;
			float flDuration = PlayTauntOutroScene();
			m_flTauntRemoveTime = gpGlobals->curtime + flDuration;
			m_flTauntOutroTime = 0.f;
		}
	}

	// Halloween Hacks
	// Spell Casting on Attack1
	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
	{
		// Check if this is the spellbook so we can save off info to preserve weapon switching
		CTFSpellBook *pSpellBook = dynamic_cast<CTFSpellBook*>( GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
		if ( pSpellBook )
		{
			// cast Spell
			if ( m_nButtons & IN_ATTACK )
			{
				if ( pSpellBook )
				{
					pSpellBook->PrimaryAttack();
				}
			}
		}

		// Speed Boost
		if ( m_nButtons & IN_ATTACK2 )
		{
			if ( GetKartSpeedBoost() >= 1.0f )
			{
				m_flKartNextAvailableBoost = gpGlobals->curtime + tf_halloween_kart_boost_recharge.GetFloat();
				m_Shared.AddCond( TF_COND_HALLOWEEN_KART_DASH, tf_halloween_kart_boost_duration.GetFloat() );
			}
		}
	}

	CBaseEntity *pGroundEntity = GetGroundEntity();

	// We consider players "in air" if they have no ground entity and they're not in water.
	if ( pGroundEntity == NULL && GetWaterLevel() == WL_NotInWater )
	{
		if ( m_iLeftGroundHealth < 0 )
		{
			m_iLeftGroundHealth = GetHealth();
		}
	}
	else
	{
		m_iLeftGroundHealth = -1;
		if ( GetFlags() & FL_ONGROUND )
		{
			m_Shared.RemoveCond( TF_COND_KNOCKED_INTO_AIR );
		}

		if ( m_iBlastJumpState )
		{
			const char *pszEvent = NULL;

			if ( StickyJumped() )
			{
				pszEvent = "sticky_jump_landed";
			}
			else if ( RocketJumped() )
			{
				pszEvent = "rocket_jump_landed";
			}

			ClearBlastJumpState();

			if ( pszEvent )
			{
				IGameEvent * event = gameeventmanager->CreateEvent( pszEvent );
				if ( event )
				{
					event->SetInt( "userid", GetUserID() );
					gameeventmanager->FireEvent( event );
				}
			}
		}
	}

	if( IsTaunting() )
	{
		bool bStopTaunt = false;
		// if I'm not supposed to move during taunt
		// stop taunting if I lost my ground entity or was moved at all
		if ( !CanMoveDuringTaunt() )
		{
			bStopTaunt |= pGroundEntity == NULL;
			
			if ( m_TauntEconItemView.IsValid() && m_TauntEconItemView.GetStaticData()->GetTauntData()->ShouldStopTauntIfMoved() )
				bStopTaunt |= m_vecTauntStartPosition.DistToSqr( GetAbsOrigin() ) > 0.1f;
		}

		if ( !bStopTaunt  )
		{
			bStopTaunt |= ShouldStopTaunting();
		}

		if ( bStopTaunt )
		{
			CancelTaunt();
		}
	}

	if ( ( RocketJumped() || StickyJumped() ) && IsAlive() && m_bCreatedRocketJumpParticles == false )
	{
		const char *pEffectName = "rocketjump_smoke";
		DispatchParticleEffect( pEffectName, PATTACH_POINT_FOLLOW, this, "foot_L" );
		DispatchParticleEffect( pEffectName, PATTACH_POINT_FOLLOW, this, "foot_R" );
		m_bCreatedRocketJumpParticles = true;
	}

	if ( !m_bCollideWithSentry )
	{
		if ( IsPlayerClass( TF_CLASS_ENGINEER ) )
		{
			CBaseObject	*pSentry = GetObjectOfType( OBJ_SENTRYGUN );
			if ( !pSentry )
			{
				m_bCollideWithSentry = true;
			}
			else
			{
				if ( ( pSentry->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr() > 2500 )
				{
					m_bCollideWithSentry = true;
				}
			}
		}
		else
		{
			m_bCollideWithSentry = true;
		}
	}

	if ( gpGlobals->curtime > m_flCommentOnCarrying && (m_flCommentOnCarrying != 0.f) )
	{
		m_flCommentOnCarrying = 0.f;

		CBaseObject* pObj = m_Shared.GetCarriedObject();
		if ( pObj )
		{
			SpeakConceptIfAllowed( MP_CONCEPT_CARRYING_BUILDING, pObj->GetResponseRulesModifier() );
		}
	}

#ifdef TF_RAID_MODE
	CTFNavArea *area = (CTFNavArea *)GetLastKnownArea();
	if ( area && area->HasAttributeTF( TF_NAV_RESCUE_CLOSET ) )
	{
		// we're standing in a rescue closet and need a friend to let us out - call for help!
		SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_HELP );
	}
#endif

	// Wrenchmotron taunt effect
	if ( m_bIsTeleportingUsingEurekaEffect )
	{
		if ( m_teleportHomeFlashTimer.HasStarted() && m_teleportHomeFlashTimer.IsElapsed() )
		{
			m_teleportHomeFlashTimer.Invalidate();

			if ( !tf_test_teleport_home_fx.GetBool() )
			{
				// cover up the end of the taunt with a flash
				color32 colorHit = { 255, 255, 255, 255 };
				UTIL_ScreenFade( this, colorHit, 0.25f, 0.25f, FFADE_IN );
			}

			Vector origin = GetAbsOrigin();
			CPVSFilter filter( origin );

			UserMessageBegin( filter, "PlayerTeleportHomeEffect" );
				WRITE_BYTE( entindex() );
			MessageEnd();

			// DispatchParticleEffect( "drg_wrenchmotron_teleport", PATTACH_ABSORIGIN );

			switch( GetTeamNumber() )
			{
			case TF_TEAM_RED:
				TE_TFParticleEffect( filter, 0.0, "teleported_red", origin, vec3_angle );
				TE_TFParticleEffect( filter, 0.0, "player_sparkles_red", origin, vec3_angle, this, PATTACH_POINT );
				break;
			case TF_TEAM_BLUE:
				TE_TFParticleEffect( filter, 0.0, "teleported_blue", origin, vec3_angle );
				TE_TFParticleEffect( filter, 0.0, "player_sparkles_blue", origin, vec3_angle, this, PATTACH_POINT );
				break;
			default:
				break;
			}
		}

		// teleport home when taunt finishes
		if ( !IsTaunting() )
		{
			// drop the intel and any powerup we are carrying
			DropFlag();
			DropRune();

			EmitSound( "Building_Teleporter.Send" );
			m_bIsTeleportingUsingEurekaEffect = false;

			CObjectTeleporter* pTeleExit = assert_cast< CObjectTeleporter* >( GetObjectOfType( OBJ_TELEPORTER, MODE_TELEPORTER_EXIT ) );
			 
			// Check if they wanted to go to their teleporter AND their teleporter can accept them
			if ( m_eEurekaTeleportTarget == EUREKA_TELEPORT_TELEPORTER_EXIT && pTeleExit && ( pTeleExit->GetState() != TELEPORTER_STATE_BUILDING ) )
			{
				pTeleExit->RecieveTeleportingPlayer( this );
			}
			else
			{
				// Default to the spawn
				TFGameRules()->GetPlayerSpawnSpot( this );
			}
		}
	}

	// Send active weapon's clip state to attached medics
	bool bSendClipInfo = gpGlobals->curtime > m_flNextClipSendTime &&
						 m_Shared.GetNumHealers() &&
						 IsAlive();
	if ( bSendClipInfo )
	{
		CTFWeaponBase *pTFWeapon = GetActiveTFWeapon();
		if ( pTFWeapon )
		{
			int nClip = 0;

			if ( m_Shared.InCond( TF_COND_DISGUISED ) )
			{
				nClip = m_Shared.GetDisguiseAmmoCount();
			}
			else
			{
				nClip = pTFWeapon->UsesClipsForAmmo1() ? pTFWeapon->Clip1() : GetAmmoCount( pTFWeapon->GetPrimaryAmmoType() );
			}

			if ( nClip >= 0 && nClip != m_nActiveWpnClipPrev )
			{
				if ( nClip > 500 )
				{
					Warning( "Heal Target: ClipSize Data Limit Exceeded: %d (max 500)\n", nClip );
					nClip = MIN( nClip, 500 );
				}
				m_nActiveWpnClip.Set( nClip );
				m_nActiveWpnClipPrev = m_nActiveWpnClip;
				m_flNextClipSendTime = gpGlobals->curtime + 0.25f;
			}
		}
	}

	if ( GetPlayerClass()->GetClassIndex() == TF_CLASS_SPY && ( GetFlags() & FL_DUCKING ) && ( pGroundEntity != NULL ) )
	{
		int nDisguiseAsDispenserOnCrouch = 0;
		CALL_ATTRIB_HOOK_FLOAT( nDisguiseAsDispenserOnCrouch, disguise_as_dispenser_on_crouch );
		if ( nDisguiseAsDispenserOnCrouch != 0 )
		{
			m_Shared.AddCond( TF_COND_DISGUISED_AS_DISPENSER, 0.5f );
		}
	}

	// rune charge over time
	if ( m_Shared.CanRuneCharge() && !m_Shared.IsRuneCharged() )
	{
		float dt = gpGlobals->curtime - m_flLastRuneChargeUpdate;
		float flAdd = dt * 100.f / tf_powerup_max_charge_time.GetFloat();
		m_Shared.SetRuneCharge( m_Shared.GetRuneCharge() + flAdd );

		if (m_Shared.GetCarryingRuneType() == RUNE_SUPERNOVA && m_Shared.IsRuneCharged() )
		{
			ClientPrint( this, HUD_PRINTCENTER, "#TF_Powerup_Supernova_Deploy" );
		}
	}
	m_flLastRuneChargeUpdate = gpGlobals->curtime;

	// You can't touch a hooked target, so transmit plague when you get as close as you can
	if ( GetGrapplingHookTarget() && GetGrapplingHookTarget()->IsPlayer() && m_Shared.GetCarryingRuneType() == RUNE_PLAGUE )
	{
		CTFPlayer *pHookedPlayer = ToTFPlayer( GetGrapplingHookTarget() );

		float flDistSqrToTarget = GetAbsOrigin().DistToSqr( pHookedPlayer->GetAbsOrigin() );
		if ( flDistSqrToTarget < 8100 && !pHookedPlayer->m_Shared.InCond( TF_COND_PLAGUE ) &&
			!m_Shared.IsAlly( pHookedPlayer ) &&
			!pHookedPlayer->m_Shared.IsInvulnerable() && 
			pHookedPlayer->m_Shared.GetCarryingRuneType() != RUNE_RESIST )
		{
			pHookedPlayer->m_Shared.AddCond( TF_COND_PLAGUE, PERMANENT_CONDITION, this );
		}
	}

	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
	{
		// prevents player from standing on bot's head to block its movement.
		if ( pGroundEntity && pGroundEntity->IsPlayer() )
		{
			Vector vPush = GetAbsOrigin() - pGroundEntity->GetAbsOrigin();
			vPush.z = 0.f;
			vPush.NormalizeInPlace();
			vPush.z = 1.f;
			vPush *= 100.f;

			ApplyAbsVelocityImpulse( vPush );
		}
	}

	// Scale our head
	m_flHeadScale = Approach( GetDesiredHeadScale(), m_flHeadScale, GetHeadScaleSpeed() );

	// scale our torso
	m_flTorsoScale = Approach( GetDesiredTorsoScale(), m_flTorsoScale, GetTorsoScaleSpeed() );

	// scale our torso
	m_flHandScale = Approach( GetDesiredHandScale(), m_flHandScale, GetHandScaleSpeed() );

/*
#ifdef STAGING_ONLY
	if ( m_Shared.InCond( TF_COND_SPACE_GRAVITY ) )
	{
		// JetPack testing
		if ( m_nButtons & IN_JUMP && !( GetFlags() & FL_ONGROUND ) && m_Shared.GetSpaceJumpChargeMeter() > tf_space_thrust_use_rate.GetFloat() )
		{
			//mv->m_vecVelocity[2] += 10.0f;
			Vector vThrust = Vector(0,0,0);
			switch( GetPlayerClass()->GetClassIndex() )
			{
			case TF_CLASS_SCOUT :				vThrust.z = tf_space_thrust_scout.GetFloat();				break;
			case TF_CLASS_SNIPER :				vThrust.z = tf_space_thrust_sniper.GetFloat();				break;
			case TF_CLASS_SOLDIER :				vThrust.z = tf_space_thrust_soldier.GetFloat();				break;
			case TF_CLASS_DEMOMAN :				vThrust.z = tf_space_thrust_demo.GetFloat();				break;
			case TF_CLASS_MEDIC :				vThrust.z = tf_space_thrust_medic.GetFloat();				break;
			case TF_CLASS_HEAVYWEAPONS :		vThrust.z = tf_space_thrust_heavy.GetFloat();				break;
			case TF_CLASS_PYRO :				vThrust.z = tf_space_thrust_pyro.GetFloat();				break;
			case TF_CLASS_SPY :					vThrust.z = tf_space_thrust_spy.GetFloat();				break;
			case TF_CLASS_ENGINEER :			vThrust.z = tf_space_thrust_engy.GetFloat();				break;
			}

			ApplyAbsVelocityImpulse( vThrust );

			m_Shared.SetSpaceJumpChargeMeter( m_Shared.GetSpaceJumpChargeMeter() - tf_space_thrust_use_rate.GetFloat() );
		}
		else
		{
			if (  GetFlags() & FL_ONGROUND )
			{
				m_Shared.SetSpaceJumpChargeMeter( m_Shared.GetSpaceJumpChargeMeter() + tf_space_thrust_recharge_rate.GetFloat() );
			}
		}
	}
#endif
*/

	SetContextThink( &CTFPlayer::TFPlayerThink, gpGlobals->curtime, "TFPlayerThink" );
	m_flLastThinkTime = gpGlobals->curtime;
}

//-----------------------------------------------------------------------------
// Purpose: Returns a portion of health every think.
//-----------------------------------------------------------------------------
void CTFPlayer::RegenThink( void )
{
	if ( !IsAlive() )
		return;

	// Queue the next think
	SetContextThink( &CTFPlayer::RegenThink, gpGlobals->curtime + TF_REGEN_TIME, "RegenThink" );

	// if we're going in to this too often, quit out.
	if ( m_flLastHealthRegenAt + TF_REGEN_TIME > gpGlobals->curtime )
		return;

	bool bShowRegen = true;

	// Medic has a base regen amount
	if ( GetPlayerClass()->GetClassIndex() == TF_CLASS_MEDIC )
	{
		// Heal faster if we haven't been in combat for a while.
		float flTimeSinceDamage = gpGlobals->curtime - GetLastDamageReceivedTime();
		float flScale = RemapValClamped( flTimeSinceDamage, 5.0f, 10.0f, 1.0f, 2.0f );
		float flRegenAmt = TF_REGEN_AMOUNT;

		// If you are healing a hurt patient, increase your base regen
		CTFPlayer *pPatient = ToTFPlayer( MedicGetHealTarget() );
		if ( pPatient && pPatient->GetHealth() < pPatient->GetMaxHealth() )
		{
			// Double regen amount
			flRegenAmt += TF_REGEN_AMOUNT;
		}

		flRegenAmt *= flScale;

		// If the medic has this attribute, increase their regen.
		if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
		{
			int iHealingMastery = 0;
			CALL_ATTRIB_HOOK_INT( iHealingMastery, healing_mastery );
			if ( iHealingMastery )
			{
				float flPerc = RemapValClamped( (float)iHealingMastery, 1.f, 4.f, 1.25f, 2.f );
				flRegenAmt *= flPerc;
			}
		}

		m_flAccumulatedHealthRegen += flRegenAmt;

		bShowRegen = false;
	}

	// Other classes can be regenerated by items
	float flRegenAmount = 0;
	CALL_ATTRIB_HOOK_FLOAT( flRegenAmount, add_health_regen );
	if ( flRegenAmount )
	{
		float flTimeSinceDamage = gpGlobals->curtime - GetLastDamageReceivedTime();
		float flScale = 1.0f;
		// Ignore Scale for MvM, always give full regen
		if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
		{
			flScale = 1.0f;
		}
		else if ( flTimeSinceDamage < 5.0f )
		{
			flScale = 0.25f;
		}
		else
		{
			flScale = RemapValClamped( flTimeSinceDamage, 5.0f, 10.0f, 0.5f, 1.0f );
		}
		
		flRegenAmount *= flScale;
	}
	m_flAccumulatedHealthRegen += flRegenAmount;

// 	if ( m_Shared.InCond( TF_COND_HEALING_DEBUFF ) )
// 	{
// 		m_flAccumulatedHealthRegen *= 0.75f;
// 	}

	int nHealAmount = 0;
	if ( m_flAccumulatedHealthRegen >= 1.f )
	{
		nHealAmount = floor( m_flAccumulatedHealthRegen );
		if ( GetHealth() < GetMaxHealth() )
		{
			int nHealedAmount = TakeHealth( nHealAmount, DMG_GENERIC | DMG_IGNORE_DEBUFFS );
			if ( nHealedAmount > 0 )
			{
				IGameEvent *event = gameeventmanager->CreateEvent( "player_healed" );
				if ( event )
				{
					event->SetInt( "priority", 1 );	// HLTV event priority
					event->SetInt( "patient", GetUserID() );
					event->SetInt( "healer", GetUserID() );
					event->SetInt( "amount", nHealedAmount );
					gameeventmanager->FireEvent( event );
				}
			}
		}
	}
	else if ( m_flAccumulatedHealthRegen < -1.f )
	{
		nHealAmount = ceil( m_flAccumulatedHealthRegen );
		TakeDamage( CTakeDamageInfo( this, this, NULL, vec3_origin, WorldSpaceCenter(), nHealAmount * -1, DMG_GENERIC ) );
	}

	if ( GetHealth() < GetMaxHealth() && nHealAmount != 0 && bShowRegen )
	{
		IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
		if ( event )
		{
			event->SetInt( "amount", nHealAmount );
			event->SetInt( "entindex", entindex() );
			event->SetInt( "weapon_def_index", INVALID_ITEM_DEF_INDEX );
			gameeventmanager->FireEvent( event ); 
		}
	}

	m_flAccumulatedHealthRegen -= nHealAmount;
	m_flLastHealthRegenAt = gpGlobals->curtime;

	// Regenerate ammo 
	if ( m_flNextAmmoRegenAt < gpGlobals->curtime )
	{
		// We regen ammo every 5 seconds
		m_flNextAmmoRegenAt = gpGlobals->curtime + 5.0;

		flRegenAmount = 0;
		CALL_ATTRIB_HOOK_FLOAT( flRegenAmount, addperc_ammo_regen );

		if ( flRegenAmount )
		{
			RegenAmmoInternal( TF_AMMO_PRIMARY, flRegenAmount );
			RegenAmmoInternal( TF_AMMO_SECONDARY, flRegenAmount );
		}

		// Regenerate metal
		int iMetal = 0;
		CALL_ATTRIB_HOOK_INT( iMetal, add_metal_regen );

		if ( iMetal )
		{
			GiveAmmo( iMetal, TF_AMMO_METAL, true );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Returns a portion of health every think.
//-----------------------------------------------------------------------------
void CTFPlayer::RuneRegenThink( void )
{
	if ( !IsAlive() )
		return;

	// Queue the next think
	SetContextThink( &CTFPlayer::RuneRegenThink, gpGlobals->curtime + TF_REGEN_TIME_RUNE, "RuneRegenThink" );

	// if we're going in to this too often, quit out.
	if ( m_flLastRuneHealthRegenAt + TF_REGEN_TIME_RUNE > gpGlobals->curtime )
		return;

	int nRuneType = m_Shared.GetCarryingRuneType();
	if ( nRuneType == RUNE_NONE && !HasTheFlag() )
		return;

	// Regenerate health 
	float flAmount = 0.f;
	switch ( GetPlayerClass()->GetClassIndex() )
	{
	case TF_CLASS_SCOUT:
	case TF_CLASS_SPY:
		flAmount = 16;
		break;
	case TF_CLASS_SNIPER:
	case TF_CLASS_ENGINEER:
		flAmount = 14;
		break;
	case TF_CLASS_MEDIC:
	case TF_CLASS_DEMOMAN:
	case TF_CLASS_PYRO:
		flAmount = 12;
		break;
	case TF_CLASS_SOLDIER:
		flAmount = 10;
		break;
	case TF_CLASS_HEAVYWEAPONS:
		flAmount = 8;
		break;
	}
	if ( nRuneType == RUNE_REGEN )
	{
		m_flAccumulatedRuneHealthRegen += flAmount;
	}
	// King and buffed team mates get some health regeneration unless they have the plague
	else if ( ( nRuneType == RUNE_KING || m_Shared.InCond( TF_COND_KING_BUFFED ) ) && !m_Shared.InCond( TF_COND_PLAGUE ) )
	{
		flAmount *= 0.3;
		m_flAccumulatedRuneHealthRegen += flAmount;
	}
	// non powered up flag carriers get a small health regeneration
	else if ( HasTheFlag() && nRuneType == RUNE_NONE )
	{
		flAmount *= 0.1;
		m_flAccumulatedRuneHealthRegen += flAmount;
	}

	int nHealAmount = 0;
	if ( m_flAccumulatedRuneHealthRegen >= 1.0 )
	{
		nHealAmount = floor( m_flAccumulatedRuneHealthRegen );
		if ( GetHealth() < GetMaxHealth() )
		{
			TakeHealth( nHealAmount, DMG_GENERIC );
			int nHealedAmount = TakeHealth( nHealAmount, DMG_GENERIC );
			if ( nHealedAmount > 0 )
			{
				IGameEvent *event = gameeventmanager->CreateEvent( "player_healed" );
				if ( event )
				{
					event->SetInt("priority", 1);	// HLTV event priority
					event->SetInt("patient", GetUserID());
					event->SetInt( "healer", GetUserID() );
					event->SetInt( "amount", nHealedAmount );
					gameeventmanager->FireEvent( event );
				}
			}
		}
	}
	else if ( m_flAccumulatedRuneHealthRegen < -1.0 )
	{
		nHealAmount = ceil( m_flAccumulatedRuneHealthRegen );
		TakeDamage( CTakeDamageInfo( this, this, NULL, vec3_origin, WorldSpaceCenter(), nHealAmount * -1, DMG_GENERIC ) );
	}

	if ( GetHealth() < GetMaxHealth() && nHealAmount != 0 )
	{
		IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
		if ( event )
		{
			event->SetInt( "amount", nHealAmount );
			event->SetInt( "entindex", entindex() );
			event->SetInt( "weapon_def_index", INVALID_ITEM_DEF_INDEX );
			gameeventmanager->FireEvent( event );
		}
	}

	m_flAccumulatedRuneHealthRegen -= nHealAmount;
	m_flLastRuneHealthRegenAt = gpGlobals->curtime;

	// Regenerate ammo and metal
	if ( m_flNextRuneAmmoRegenAt < gpGlobals->curtime )
	{
		m_flNextRuneAmmoRegenAt = gpGlobals->curtime + 5;

		if ( nRuneType == RUNE_REGEN )
		{
			RegenAmmoInternal( TF_AMMO_PRIMARY, 0.5f );
			RegenAmmoInternal( TF_AMMO_SECONDARY, 0.5f );
			GiveAmmo( 200, TF_AMMO_METAL, true );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::RegenAmmoInternal( int iIndex, float flRegen )
{
	m_flAccumulatedAmmoRegens[iIndex] += flRegen;
	
	// As soon as we have enough accumulated to regen a single unit of ammo, do it.
	int iMaxAmmo = GetMaxAmmo(iIndex);
	int iAmmo = m_flAccumulatedAmmoRegens[iIndex] * iMaxAmmo;
	if ( iAmmo >= 1 )
	{
		GiveAmmo( iAmmo, iIndex, true );
		m_flAccumulatedAmmoRegens[iIndex] -= ((float)iAmmo / (float)iMaxAmmo);
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFPlayer::~CTFPlayer()
{
	delete [] m_damageRateArray;

	DestroyRagdoll();
	m_PlayerAnimState->Release();

	FOR_EACH_VEC( m_ItemsToTest, i )
	{
		int iDef = TESTITEM_DEFINITIONS_BEGIN_AT + m_ItemsToTest[i].scriptItem.GetItemDefIndex();
		ItemSystem()->GetItemSchema()->ItemTesting_DiscardTestDefinition( iDef );

		m_ItemsToTest[i].pKV->deleteThis();
		m_ItemsToTest[i].pKV = NULL;
	}

	if ( m_hReviveMarker )
	{
		UTIL_Remove( m_hReviveMarker );
		m_hReviveMarker = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFPlayer *CTFPlayer::CreatePlayer( const char *className, edict_t *ed )
{
	CTFPlayer::s_PlayerEdict = ed;
	return (CTFPlayer*)CreateEntityByName( className );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::UpdateTimers( void )
{
	m_Shared.ConditionThink();
	m_Shared.InvisibilityThink();
}

//-----------------------------------------------------------------------------
// Estimate where a projectile fired from the given weapon will initially hit (it may bounce on from there).
// NOTE: We should be able to directly compute this knowing initial velocity, angle, gravity, etc, 
// but I have been unable to find a formula that reproduces what our physics actually
// do.
//-----------------------------------------------------------------------------
Vector CTFPlayer::EstimateProjectileImpactPosition( CTFWeaponBaseGun *weapon )
{
	if ( !weapon )
	{
		return GetAbsOrigin();
	}

	const QAngle &angles = EyeAngles();

	float initVel = weapon->IsWeapon( TF_WEAPON_PIPEBOMBLAUNCHER ) ? 900.0f : weapon->GetProjectileSpeed();  
	CALL_ATTRIB_HOOK_FLOAT( initVel, mult_projectile_range );

	return EstimateProjectileImpactPosition( angles.x, angles.y, initVel );
}

//-----------------------------------------------------------------------------
// Estimate where a stickybomb projectile will hit,
// using given pitch, yaw, and weapon charge (0-1)
//-----------------------------------------------------------------------------
Vector CTFPlayer::EstimateStickybombProjectileImpactPosition( float pitch, float yaw, float charge )
{
	// estimate impact spot
	float initVel = charge * ( TF_PIPEBOMB_MAX_CHARGE_VEL - TF_PIPEBOMB_MIN_CHARGE_VEL ) + TF_PIPEBOMB_MIN_CHARGE_VEL;
	CALL_ATTRIB_HOOK_FLOAT( initVel, mult_projectile_range );

	return EstimateProjectileImpactPosition( pitch, yaw, initVel );
}

//-----------------------------------------------------------------------------
// Estimate where a projectile fired will initially hit (it may bounce on from there),
// using given pitch, yaw, and initial velocity.
//-----------------------------------------------------------------------------
Vector CTFPlayer::EstimateProjectileImpactPosition( float pitch, float yaw, float initVel )
{
	// copied from CTFWeaponBaseGun::FirePipeBomb()
	Vector vecForward, vecRight, vecUp;
	QAngle angles( pitch, yaw, 0.0f );
	AngleVectors( angles, &vecForward, &vecRight, &vecUp );

	// we will assume bots never flip viewmodels
	float fRight = 8.f;
	Vector vecSrc = Weapon_ShootPosition();
	vecSrc += vecForward * 16.0f + vecRight * fRight + vecUp * -6.0f;

	const float initVelScale = 0.9f;
	Vector vecVelocity = initVelScale * ( ( vecForward * initVel ) + ( vecUp * 200.0f ) );

	const float timeStep = 0.01f;
	const float maxTime = 5.0f;
								 
	Vector pos = vecSrc;
	Vector lastPos = pos;
	const float g = GetCurrentGravity();


	// compute forward facing unit vector in horiz plane
	Vector alongDir = vecForward;
	alongDir.z = 0.0f;
	alongDir.NormalizeInPlace();

	float alongVel = FastSqrt( vecVelocity.x * vecVelocity.x + vecVelocity.y * vecVelocity.y );

	trace_t trace;	
	NextBotTraceFilterIgnoreActors traceFilter( NULL, COLLISION_GROUP_NONE );

	float t;
	for( t = 0.0f; t < maxTime; t += timeStep )
	{
		float along = alongVel * t;
		float height = vecVelocity.z * t - 0.5f * g * t * t;

		pos.x = vecSrc.x + alongDir.x * along;
		pos.y = vecSrc.y + alongDir.y * along;
		pos.z = vecSrc.z + height;

		UTIL_TraceHull( lastPos, pos, -Vector(8,8,8), Vector(8,8,8), MASK_SOLID_BRUSHONLY, &traceFilter, &trace );

		if ( trace.DidHit() )
		{
#ifdef STAGING_ONLY
			if ( tf_debug_ballistics.GetBool() )
			{
				NDebugOverlay::Cross3D( trace.endpos, 10.0f, 100, 255, 0, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
			}
#endif
			break;
		}

#ifdef STAGING_ONLY
		if ( tf_debug_ballistics.GetBool() )
		{
			NDebugOverlay::Line( lastPos, pos, 0, 255, 0, false, NDEBUG_PERSIST_TILL_NEXT_SERVER );
		}
#endif

		lastPos = pos;
	}

	return trace.endpos;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::ProcessSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event )
{
	// TF Players only process scene events on the server while running taunts
	if ( !IsTaunting() )
		return false;

	// Only process sequences
	if ( event->GetType() != CChoreoEvent::SEQUENCE )
		return false;

	return BaseClass::ProcessSceneEvent( info, scene, event );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PreThink()
{
	// Update timers.
	UpdateTimers();

	// Pass through to the base class think.
	BaseClass::PreThink();

	// Reset bullet force accumulator, only lasts one frame, for ragdoll forces from multiple shots.
	m_vecTotalBulletForce = vec3_origin;

	CheckForIdle();

	ProcessSceneEvents();

	if ( TFGameRules()->IsInArenaMode() == true )
	{
		if ( TFGameRules()->State_Get() != GR_STATE_TEAM_WIN )
		{
			if ( GetTeamNumber() == TEAM_SPECTATOR )
			{
				m_Local.m_iHideHUD &= ~HIDEHUD_MISCSTATUS;
			}
		}
	}

	// Hype Decreases over time
	if ( IsPlayerClass( TF_CLASS_SCOUT ) )
	{
		float flHypeDecays = 0;
		CALL_ATTRIB_HOOK_FLOAT( flHypeDecays, hype_decays_over_time );

		if ( flHypeDecays != 0 )
		{
			// Loose hype over time
			float flHype = m_Shared.GetScoutHypeMeter();
			flHype = flHype - flHypeDecays;
			m_Shared.SetScoutHypeMeter( flHype );
			TeamFortress_SetSpeed();
		}
	}

#ifdef STAGING_ONLY 
	// show ballistic path for currently equipped weapon (ie: grenades)
	if ( tf_debug_ballistics.GetBool() )
	{
		CTFWeaponBaseGun *myWeapon = dynamic_cast< CTFWeaponBaseGun * >( m_Shared.GetActiveTFWeapon() );
		EstimateProjectileImpactPosition( myWeapon );
	}

	if ( tf_debug_ballistic_targeting.GetBool() )
	{
		CTFWeaponBaseGun *myWeapon = dynamic_cast< CTFWeaponBaseGun * >( m_Shared.GetActiveTFWeapon() );
		Vector hitPos = EstimateProjectileImpactPosition( myWeapon );

		Vector toEye = EyePosition() - hitPos;
		Vector toTarget = tf_debug_ballistic_target - hitPos;
		float error = toTarget.NormalizeInPlace();

		if ( error < 20.0f )
		{
			// on target
			NDebugOverlay::Cross3D( tf_debug_ballistic_target, 10.0f, 0, 255, 0, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
		}
		else
		{
			if ( DotProduct( toEye, toTarget ) > 0.0f )
			{
				// too far
				NDebugOverlay::Cross3D( tf_debug_ballistic_target, 10.0f, 0, 0, 255, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
				NDebugOverlay::VertArrow( tf_debug_ballistic_target, tf_debug_ballistic_target - Vector( 0, 0, error ), 10.0f, 0, 0, 255, 255, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
			}
			else
			{
				// too near
				NDebugOverlay::Cross3D( tf_debug_ballistic_target, 10.0f, 255, 0, 0, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
				NDebugOverlay::VertArrow( tf_debug_ballistic_target, tf_debug_ballistic_target + Vector( 0, 0, error ), 10.0f, 255, 0, 0, 255, true, NDEBUG_PERSIST_TILL_NEXT_SERVER );
			}
		}		
	}
#endif // STAGING_ONLY
}

ConVar mp_idledealmethod( "mp_idledealmethod", "1", FCVAR_GAMEDLL, "Deals with Idle Players. 1 = Sends them into Spectator mode then kicks them if they're still idle, 2 = Kicks them out of the game;" );
ConVar mp_idlemaxtime( "mp_idlemaxtime", "3", FCVAR_GAMEDLL, "Maximum time a player is allowed to be idle (in minutes)" );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::CheckForIdle( void )
{
	if ( m_afButtonLast != m_nButtons )
		m_flLastAction = gpGlobals->curtime;

	if ( mp_idledealmethod.GetInt() )
	{
		if ( IsHLTV() || IsReplay() )
			return;

		if ( IsFakeClient() )
			return;

		if ( IsCoaching() && GetStudent() != NULL )
			return;

		if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
			return;

		if ( TFGameRules()->State_Get() == GR_STATE_BETWEEN_RNDS )
			return;

		//Don't mess with the host on a listen server (probably one of us debugging something)
		if ( engine->IsDedicatedServer() == false && entindex() == 1 )
			return;

		if ( IsAutoKickDisabled() )
			return;

		const bool cbMoving = ( m_nButtons & ( IN_FORWARD | IN_BACK | IN_MOVELEFT | IN_MOVERIGHT ) ) != 0;

		m_bIsAFK = false;

		if ( !cbMoving && PointInRespawnRoom( this, WorldSpaceCenter() ) )
		{
			m_flTimeInSpawn += TICK_INTERVAL;
		}
		else
			m_flTimeInSpawn = 0;

		if ( TFGameRules()->IsInArenaMode() && tf_arena_use_queue.GetBool() == true )
		{
			if ( GetTeamNumber() == TEAM_SPECTATOR )
				return;

			if ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN && TFGameRules()->GetWinningTeam() != GetTeamNumber() )
			{
				if ( m_bArenaIsAFK )
				{
					m_bIsAFK = true;
					m_bArenaIsAFK = false;
				}
			}
		}
		else
		{
			// Cannot possibly get out of the spawn room in 0 seconds--so if the ConVar says 0, let's assume 30 seconds.
			float flIdleTime = Max( mp_idlemaxtime.GetFloat() * 60, 30.0f );

			if ( TFGameRules()->InStalemate() )
			{
				flIdleTime = mp_stalemate_timelimit.GetInt() * 0.5f;
			}

			m_bIsAFK = ( gpGlobals->curtime - m_flLastAction ) > flIdleTime
			        || ( m_flTimeInSpawn > flIdleTime ); 
		}
		
		if ( m_bIsAFK == true )
		{
			bool bKickPlayer = false;

			ConVarRef mp_allowspectators( "mp_allowspectators" );
			if ( ( mp_allowspectators.IsValid() && mp_allowspectators.GetBool() == false ) || ( TFGameRules()->IsInArenaMode() && tf_arena_use_queue.GetBool() ) )
			{
				// just kick the player if this server doesn't allow spectators
				bKickPlayer = true;
			}
			else if ( mp_idledealmethod.GetInt() == 1 )
			{
				if ( GetTeamNumber() < FIRST_GAME_TEAM )
				{
					bKickPlayer = true;
				}
				else
				{
					//First send them into spectator mode then kick him.
					ForceChangeTeam( TEAM_SPECTATOR );
					m_flLastAction = gpGlobals->curtime;
					m_flTimeInSpawn = 0;
					return;
				}
			}
			else if ( mp_idledealmethod.GetInt() == 2 )
			{
				bKickPlayer = true;
			}

			if ( bKickPlayer == true )
			{
				UTIL_ClientPrintAll( HUD_PRINTCONSOLE, "#game_idle_kick", GetPlayerName() );
				engine->ServerCommand( UTIL_VarArgs( "kickid %d %s\n", GetUserID(), g_pszIdleKickString ) );
				m_flLastAction = gpGlobals->curtime;
				m_flTimeInSpawn = 0;
			}
		}
	}
}

extern ConVar flashlight;

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFPlayer::FlashlightIsOn( void )
{
	return IsEffectActive( EF_DIMLIGHT );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::FlashlightTurnOn( void )
{
	if( flashlight.GetInt() > 0 && IsAlive() )
	{
		AddEffects( EF_DIMLIGHT );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::FlashlightTurnOff( void )
{
	if( IsEffectActive(EF_DIMLIGHT) )
	{
		RemoveEffects( EF_DIMLIGHT );
	}	
}

//-----------------------------------------------------------------------------
// Purpose: Update Halloween scenario effects on players.
//-----------------------------------------------------------------------------
void CTFPlayer::UpdateHalloween( void )
{
	// This is a push force
	if ( !m_vHalloweenKartPush.IsZero() )
	{
		if ( !m_Shared.InCond( TF_COND_INVULNERABLE_USER_BUFF ) )
		{		
			CPVSFilter filter( GetAbsOrigin() );
			TE_TFParticleEffect( filter, 0.0, "kart_impact_sparks", GetAbsOrigin(), vec3_angle, this, PATTACH_ABSORIGIN );

			float flStunDuration = m_vHalloweenKartPush.Length() / 1000.0f;
			if ( m_vHalloweenKartPush.LengthSqr() > 1000 * 1000 )
			{
				TE_TFParticleEffect( filter, 0.0, "kartimpacttrail", GetAbsOrigin(), vec3_angle, this, PATTACH_ABSORIGIN_FOLLOW );
				EmitSound( "BumperCar.BumpIntoAir" );
				EmitSound( "BumperCar.BumpHard" );
			}
			else
			{
				EmitSound( "BumperCar.Bump" );
			}

			if ( tf_halloween_kart_stun_enabled.GetBool() )
			{
				m_Shared.StunPlayer( flStunDuration * tf_halloween_kart_stun_duration_scale.GetFloat(), tf_halloween_kart_stun_amount.GetFloat(), TF_STUN_BOTH | TF_STUN_NO_EFFECTS );
			}

			if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART_DASH ) )
			{
				m_Shared.RemoveCond( TF_COND_HALLOWEEN_KART_DASH );
			}

			ApplyAirBlastImpulse( m_vHalloweenKartPush );
		}
		
		m_vHalloweenKartPush.Zero();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::AddHalloweenKartPushEvent( CTFPlayer *pOther, CBaseEntity *pInflictor, CBaseEntity *pWeapon, Vector vForce, int iDamage, int iDamageType /* = 0 */ )
{
	// Create a damage event so they can get credit for the kill
	//m_vHalloweenKartPushEventTime + 0.2 > gpGlobals->curtime &&
	if ( m_Shared.InCond( TF_COND_INVULNERABLE_USER_BUFF ) )
		return;

	// Ignore small forces
	float flForce = vForce.LengthSqr();
	if ( flForce < 100.0f )
		return;

	float flExtraMultiplier = 1.f;
	if ( pOther && pOther != this && pOther->m_Shared.InCond( TF_COND_HALLOWEEN_BOMB_HEAD ) )
	{
		iDamage *= tf_halloween_kart_bomb_head_damage_scale.GetFloat();
		flExtraMultiplier = tf_halloween_kart_bomb_head_impulse_scale.GetFloat();
		pOther->SetKartBombHeadTarget( pOther );
		pOther->m_Shared.RemoveCond( TF_COND_HALLOWEEN_BOMB_HEAD );
	}

	const float flCurrentKartKnockbackMultiplier =  GetKartKnockbackMultiplier( flExtraMultiplier );

	if ( pOther )
	{
		// Fake Damage
		IGameEvent * event = gameeventmanager->CreateEvent( "player_hurt" );
		if ( event )
		{
			int iKartDamageType = DMG_CLUB | DMG_PREVENT_PHYSICS_FORCE;
			if ( pOther != this && flCurrentKartKnockbackMultiplier * vForce.LengthSqr() > 1000 * 1000 )
			{
				iKartDamageType |= DMG_CRITICAL;
			}

			event->SetInt( "userid", GetUserID() );
			event->SetInt( "health", MAX( 0, m_iHealth ) );

			// HLTV event priority, not transmitted
			event->SetInt( "priority", 5 );
			event->SetInt( "damageamount", iDamage );

			// Hurt by another player.
			event->SetInt( "attacker", pOther->GetUserID() );
			event->SetInt( "custom", TF_DMG_CUSTOM_SUICIDE );
			event->SetBool( "crit", ( iKartDamageType & DMG_CRITICAL ) != 0 );
			event->SetBool( "allseecrit", ( iKartDamageType & DMG_CRITICAL ) != 0 );
			event->SetInt( "bonuseffect", (int)kBonusEffect_None );
			//
			gameeventmanager->FireEvent( event );
		}
		
		m_AchievementData.AddDamagerToHistory( pOther );
		m_AchievementData.AddPusherToHistory( pOther );
		//m_Shared.SetAssist( pOther );
	}

	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
	{
		m_iKartHealth += iDamage;
	}

	// HHH
	if ( TFGameRules()->IsIT( pOther ) )
	{
		// Tag! You're IT!
		TFGameRules()->SetIT( this );
	}

	if ( iDamageType == TF_DMG_CUSTOM_DECAPITATION_BOSS )
	{
		m_flHHHKartAttackTime = gpGlobals->curtime;
	}

	//m_vHalloweenKartPushEventTime = gpGlobals->curtime;
	float flImpulseScale = 1.0f;

	// m_flKartHealth might change by this point, calculate new knock back multiplier
	const float flNewKartKnockbackMultiplier = GetKartKnockbackMultiplier( flExtraMultiplier );

	// push other
	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
	{
		// If applying damage increase the force, otherwise its likely just a wall collision
		if ( iDamage > 0 )
		{
			vForce *= flImpulseScale * flNewKartKnockbackMultiplier;
			vForce.z *= ( ( flNewKartKnockbackMultiplier - 1.0f ) * 0.20f ) + 1.0f;

			// Decrease all forces if in the air
			if (!(GetFlags() & FL_ONGROUND) )
			{
				vForce *= tf_halloween_kart_impact_air_scale.GetFloat();
			}
		}
	}
	else
	{
		// Make non-karters take damage!
		vForce *= ( flImpulseScale * 2.0f );

		//ghostinfo.SetDamageCustom( TF_DMG_CUSTOM_KART );	
		// Create a damage event based on Speed
		float flDamage = vForce.Length() / 50.0f + RandomFloat( 3.0f, 7.0f );
		CTakeDamageInfo info;
		info.SetAttacker( pOther );
		info.SetInflictor( pOther );
		info.SetDamage( flDamage );
		info.SetDamageCustom( TF_DMG_CUSTOM_KART );
		info.SetDamagePosition( GetAbsOrigin() );
		int iKartDamageType = DMG_CLUB;
		if ( flDamage > 20 )
		{
			iKartDamageType |= DMG_CRITICAL;
		}
		info.SetDamageType( iKartDamageType );
		info.SetDamageForce( vForce );
		TakeDamage( info );
		return;
	}

	m_vHalloweenKartPush += vForce;

	// Dropped collection game tokens if hit hard enough and we're in the collection minigame
	if ( pOther && iDamage > 10 && CTFMinigameLogic::GetMinigameLogic() && CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame() && 
		CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame()->GetMinigameType() == CTFMiniGame::EMinigameType::MINIGAME_HALLOWEEN2014_COLLECTION )
	{
		CUtlVector< CTFPlayer* > vecEveryone;
		CollectPlayers( &vecEveryone );
		int nNumPlayers = vecEveryone.Count();

		// Drop tokens
		uint32 nNumToSpawn = ( iDamage / 5 ) + 1;
		nNumToSpawn = RemapValClamped( nNumPlayers, 8, 16, nNumToSpawn, 1 );

		if ( gpGlobals->curtime > m_flNextBonusDucksVOAllowedTime )
		{
			// Tell this user to play a "Bonus Ducks!" line. 
			CSingleUserRecipientFilter filter( pOther );
			UserMessageBegin( filter, "BonusDucks" );
				WRITE_BYTE( entindex() );
				WRITE_BYTE( false );
			MessageEnd();
		}

		while( nNumToSpawn-- )
		{
			CHalloweenPickup *pPickup = dynamic_cast< CHalloweenPickup * >( CreateEntityByName( "tf_halloween_pickup" ) );
			if (pPickup)
			{
				pPickup->m_nSkin = 2; // Golden skin
				pPickup->Precache();
				DispatchSpawn(pPickup);
				Vector vecRandom = RandomVector( -200.f, 200.f );
				vecRandom.z = RandomFloat( 300.f, 400.f );
				Vector vecDropVector = vecRandom + vForce * 0.2f;
				pPickup->DropSingleInstance( vecDropVector, this, 1.f, 1.f );

				pPickup->SetAbsOrigin( GetAbsOrigin() + Vector( 0.f, 0.f, 40.f ) );

				pPickup->Activate();
			}
		}
	}
	
	//DevMsg( "Kart Impact %fx,%fy,%fz - %f Base. %f Multiplayer, %f TotalForce, %d Damage, %i Class \n", 
	//	vForce.x, vForce.y, vForce.z, vForce.Length(), flNewKartKnockbackMultiplier, vForce.Length() * flNewKartKnockbackMultiplier, iDamage, GetPlayerClass()->GetClassIndex() );
	
	vForce.z = 0;
	vForce.NormalizeInPlace();
	DispatchParticleEffect( "kart_impact_sparks", GetAbsOrigin() + vForce * 24, GetAbsAngles() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::GetKartKnockbackMultiplier( float flExtraMultiplier /*= 1.f*/ ) const
{
	return flExtraMultiplier * ( 1.0f + (float)m_iKartHealth / tf_halloween_kart_damage_to_force.GetFloat() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ResetKartDamage() 
{ 
	m_iKartHealth = 0; 
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::CancelEurekaTeleport()
{
	m_bIsTeleportingUsingEurekaEffect = false;
	m_teleportHomeFlashTimer.Invalidate();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PostThink()
{
	BaseClass::PostThink();

	QAngle angles = GetLocalAngles();
	angles[PITCH] = 0;
	SetLocalAngles( angles );
	
	// Store the eye angles pitch so the client can compute its animation state correctly.
	m_angEyeAngles = EyeAngles();

    m_PlayerAnimState->Update( m_angEyeAngles[YAW], m_angEyeAngles[PITCH] );

	if ( m_flTauntAttackTime && m_flTauntAttackTime < gpGlobals->curtime )
	{
		m_flTauntAttackTime = 0;
		DoTauntAttack();
	}

	// if we are coaching, then capture events for adding annotations
	if ( m_bIsCoaching && m_hStudent )
	{
		if ( ( m_afButtonPressed & ( IN_ATTACK | IN_ATTACK2 ) ) != 0 )
		{
			if ( m_afButtonPressed & IN_ATTACK )
			{
				HandleCoachCommand( this, kCoachCommand_Attack );
			}
			else if ( m_afButtonPressed & IN_ATTACK2 )
			{
				HandleCoachCommand( this, kCoachCommand_Defend );
			}
		}
		if ( m_hStudent->GetTeamNumber() != TEAM_SPECTATOR )
		{
			// tether coach to student--if the coach gets too far, move them toward the student
			Vector vecTarget = m_hStudent->GetAbsOrigin();
			Vector vecDelta = GetAbsOrigin() - vecTarget;
			float flDistance = vecDelta.Length();
			const float kInchesToMeters = 0.0254f;
			const float kMetersToInches = 1.0f / kInchesToMeters;
			const float kMaxDistanceToStudent = 30;
			int distance = RoundFloatToInt( flDistance * kInchesToMeters );
			if ( distance > kMaxDistanceToStudent )
			{
				VectorNormalize( vecDelta );
				SetAbsOrigin( vecTarget + vecDelta * ( kMaxDistanceToStudent * kMetersToInches ) );
			}
		}
	}

	if ( TFGameRules()->IsMannVsMachineMode() )
	{
		// metal is free during setup time
		if ( TFGameRules()->IsQuickBuildTime() )
		{
			GiveAmmo( 1000, TF_AMMO_METAL, true );
		}

		// clamp maximum velocity to avoid sending mini-bosses into the stratosphere
		if ( GetTeamNumber() == TF_TEAM_PVE_INVADERS )
		{
			Vector ahead = GetAbsVelocity();
			float speed = ahead.NormalizeInPlace();

			const float velocityLimit = 1000.0f;
			if ( speed > velocityLimit )
			{
				speed = velocityLimit;
			}

			SetAbsVelocity( speed * ahead );
		}
	}

	UpdateHalloween();

#ifdef STAGING_ONLY
	m_Shared.DoRocketPack();
#endif // STAGING_ONLY
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PrecacheMvM()
{
	for ( int i = TF_FIRST_NORMAL_CLASS; i < TF_LAST_NORMAL_CLASS; ++i )
	{
		COMPILE_TIME_ASSERT( ARRAYSIZE( g_szBotModels ) == TF_LAST_NORMAL_CLASS );
		int iModelIndex = PrecacheModel( g_szBotModels[ i ] );
		PrecacheGibsForModel( iModelIndex );

		COMPILE_TIME_ASSERT( ARRAYSIZE( g_szBotBossModels ) == TF_LAST_NORMAL_CLASS );
		iModelIndex = PrecacheModel( g_szBotBossModels[ i ] );
		PrecacheGibsForModel( iModelIndex );
	}

	int iModelIndex = PrecacheModel( g_szBotBossSentryBusterModel );
	PrecacheGibsForModel( iModelIndex );

	PrecacheModel( "models/items/currencypack_small.mdl" );
	PrecacheModel( "models/items/currencypack_medium.mdl" );
	PrecacheModel( "models/items/currencypack_large.mdl" );

	PrecacheModel( "models/bots/tw2/boss_bot/twcarrier_addon.mdl" );

	PrecacheParticleSystem( "bot_impact_light" );
	PrecacheParticleSystem( "bot_impact_heavy" );
	PrecacheParticleSystem( "bot_death" );
	PrecacheParticleSystem( "bot_radio_waves" );

	PrecacheScriptSound( "MVM.BotStep" );
	PrecacheScriptSound( "MVM.GiantHeavyStep" );
	PrecacheScriptSound( "MVM.GiantSoldierStep" );
	PrecacheScriptSound( "MVM.GiantDemomanStep" );
	PrecacheScriptSound( "MVM.GiantScoutStep" );
	PrecacheScriptSound( "MVM.GiantPyroStep" );
	PrecacheScriptSound( "MVM.GiantHeavyLoop" );
	PrecacheScriptSound( "MVM.GiantSoldierLoop" );
	PrecacheScriptSound( "MVM.GiantDemomanLoop" );
	PrecacheScriptSound( "MVM.GiantScoutLoop" );
	PrecacheScriptSound( "MVM.GiantPyroLoop" );
	PrecacheScriptSound( "MVM.GiantHeavyExplodes" );
	PrecacheScriptSound( "MVM.GiantCommonExplodes" );
	PrecacheScriptSound( "MVM.SentryBusterExplode" );
	PrecacheScriptSound( "MVM.SentryBusterLoop" );
	PrecacheScriptSound( "MVM.SentryBusterIntro" );
	PrecacheScriptSound( "MVM.SentryBusterStep" );
	PrecacheScriptSound( "MVM.SentryBusterSpin" );
	PrecacheScriptSound( "MVM.DeployBombSmall" );
	PrecacheScriptSound( "MVM.DeployBombGiant" );
	PrecacheScriptSound( "Weapon_Upgrade.ExplosiveHeadshot" );
	PrecacheScriptSound( "Spy.MVM_Chuckle" );
	PrecacheScriptSound( "MVM.Robot_Engineer_Spawn" );
	PrecacheScriptSound( "MVM.Robot_Teleporter_Deliver" );
	PrecacheScriptSound( "MVM.MoneyPickup" );

	PrecacheMaterial( "effects/circle_nocull" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PrecacheKart()
{
	PrecacheModel( "models/player/items/taunts/bumpercar/parts/bumpercar.mdl" );
	PrecacheModel( "models/props_halloween/bumpercar_cage.mdl" );

	PrecacheScriptSound( "BumperCar.Spawn" );
	PrecacheScriptSound( "BumperCar.SpawnFromLava" );
	PrecacheScriptSound( "BumperCar.GoLoop" );
	PrecacheScriptSound( "BumperCar.Screech" );
	PrecacheScriptSound( "BumperCar.HitGhost" );
	PrecacheScriptSound( "BumperCar.Bump" );
	PrecacheScriptSound( "BumperCar.BumpHard" );
	PrecacheScriptSound( "BumperCar.BumpIntoAir" );
	PrecacheScriptSound( "BumperCar.SpeedBoostStart" );
	PrecacheScriptSound( "BumperCar.SpeedBoostStop" );
	PrecacheScriptSound( "BumperCar.Jump" );
	PrecacheScriptSound( "BumperCar.JumpLand" );
	PrecacheScriptSound( "sf14.Merasmus.DuckHunt.BonusDucks" );

	PrecacheParticleSystem( "kartimpacttrail" );
	PrecacheParticleSystem( "kart_dust_trail_red" );
	PrecacheParticleSystem( "kart_dust_trail_blue" );

	PrecacheParticleSystem( "kartdamage_4");
}

//-----------------------------------------------------------------------------
// Purpose: Precache the player models and player model gibs.
//-----------------------------------------------------------------------------
void CTFPlayer::PrecachePlayerModels( void )
{
	int i;
	for ( i = 0; i < TF_CLASS_COUNT_ALL; i++ )
	{
		const char *pszModel = GetPlayerClassData( i )->m_szModelName;
		if ( pszModel && pszModel[0] )
		{
			int iModel = PrecacheModel( pszModel );
			PrecacheGibsForModel( iModel );
		}

		pszModel = GetPlayerClassData( i )->m_szHandModelName;
		if ( pszModel && pszModel[0] )
		{
			PrecacheModel( pszModel );
		}

/*
		if ( !IsX360() )
		{
			// Precache the hardware facial morphed models as well.
			const char *pszHWMModel = GetPlayerClassData( i )->m_szHWMModelName;
			if ( pszHWMModel && pszHWMModel[0] )
			{
				PrecacheModel( pszHWMModel );
			}
		}
*/
	}
	
	// Always precache the silly gibs.
	for ( i = 4; i < ARRAYSIZE( g_pszBDayGibs ); ++i )
	{
		PrecacheModel( g_pszBDayGibs[i] );
	}

	if ( TFGameRules() && TFGameRules()->IsBirthday() )
	{
		for ( i = 0; i < 4/*ARRAYSIZE(g_pszBDayGibs)*/; i++ )
		{
			PrecacheModel( g_pszBDayGibs[i] );
		}
		PrecacheModel( "models/effects/bday_hat.mdl" );
	}
	if ( TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
	{
		PrecacheModel( "models/props_halloween/halloween_gift.mdl" );
		PrecacheModel( "models/props_halloween/ghost_no_hat.mdl" );
		PrecacheModel( "models/props_halloween/ghost_no_hat_red.mdl" );
	}

	// Precache player class sounds
	for ( i = TF_FIRST_NORMAL_CLASS; i < TF_CLASS_COUNT_ALL; ++i )
	{
		TFPlayerClassData_t *pData = GetPlayerClassData( i );

		for ( int i = 0; i < ARRAYSIZE( pData->m_szDeathSound ); ++i )
		{
			PrecacheScriptSound( pData->m_szDeathSound[ i ] ); 
		}
	}

#ifdef STAGING_ONLY
	PrecacheModel( "models/weapons/c_models/c_bread/c_bread_plainloaf.mdl" );
#endif

	COMPILE_TIME_ASSERT( TF_CALLING_CARD_MODEL_COUNT == ARRAYSIZE( g_pszDeathCallingCardModels ) );
	// Precache, Deliberatly skipping zero
	for ( i = 1; i < TF_CALLING_CARD_MODEL_COUNT; i++ )		
	{
		PrecacheModel( g_pszDeathCallingCardModels[i] );
	}

#ifdef STAGING_ONLY
	COMPILE_TIME_ASSERT( ARRAYSIZE( g_szPlayerRobotModels ) == TF_LAST_NORMAL_CLASS );
	for ( int i = TF_FIRST_NORMAL_CLASS; i < TF_LAST_NORMAL_CLASS; ++i )
	{
		PrecacheModel( g_szPlayerRobotModels[i] );
		//int iModelIndex = PrecacheModel( g_szPlayerRobotModels[i] );
		//PrecacheGibsForModel( iModelIndex );
	}
#endif // STAGING_ONLY
	
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PrecacheTFPlayer()
{
	VPROF_BUDGET( "CTFPlayer::PrecacheTFPlayer", VPROF_BUDGETGROUP_PLAYER );
	if( !m_bTFPlayerNeedsPrecache )
		return;

	m_bTFPlayerNeedsPrecache = false;

	// Precache the player models and gibs.
	PrecachePlayerModels();

	// Precache the player sounds.
	PrecacheScriptSound( "Player.Spawn" );
	PrecacheScriptSound( "TFPlayer.Pain" );
	PrecacheScriptSound( "TFPlayer.CritHit" );
	PrecacheScriptSound( "TFPlayer.CritHitMini" );
	PrecacheScriptSound( "TFPlayer.DoubleDonk" );
	PrecacheScriptSound( "TFPlayer.CritPain" );
	PrecacheScriptSound( "TFPlayer.CritDeath" );
	PrecacheScriptSound( "TFPlayer.FreezeCam" );
	PrecacheScriptSound( "TFPlayer.Drown" );
	PrecacheScriptSound( "TFPlayer.AttackerPain" );
	PrecacheScriptSound( "TFPlayer.SaveMe" );
	PrecacheScriptSound( "TFPlayer.CritBoostOn" );
	PrecacheScriptSound( "TFPlayer.CritBoostOff" );
	PrecacheScriptSound( "TFPlayer.Decapitated" );
	PrecacheScriptSound( "TFPlayer.ReCharged" );
	PrecacheScriptSound( "Camera.SnapShot" );
	PrecacheScriptSound( "TFPlayer.Dissolve" );

	PrecacheScriptSound( "Saxxy.TurnGold" );

	PrecacheScriptSound( "Icicle.TurnToIce" );
	PrecacheScriptSound( "Icicle.HitWorld" );
	PrecacheScriptSound( "Icicle.Melt" );

	PrecacheScriptSound( "DemoCharge.ChargeCritOn" );
	PrecacheScriptSound( "DemoCharge.ChargeCritOff" );
	PrecacheScriptSound( "DemoCharge.Charging" );

	PrecacheScriptSound( "TFPlayer.StunImpactRange" );
	PrecacheScriptSound( "TFPlayer.StunImpact" );
	PrecacheScriptSound( "Halloween.PlayerScream" );
	PrecacheScriptSound( "Halloween.PlayerEscapedUnderworld" );

	PrecacheScriptSound( "Game.YourTeamLost" );
	PrecacheScriptSound( "Game.YourTeamWon" );
	PrecacheScriptSound( "Game.SuddenDeath" );
	PrecacheScriptSound( "Game.Stalemate" );
	PrecacheScriptSound( "TV.Tune" );

	//This will be moved out once we do the announcer pass.
	PrecacheScriptSound( "Announcer.AM_FirstBloodRandom" );
	PrecacheScriptSound( "Announcer.AM_CapEnabledRandom" );
	PrecacheScriptSound( "Announcer.AM_RoundStartRandom" );
	PrecacheScriptSound( "Announcer.AM_FirstBloodFast" );
	PrecacheScriptSound( "Announcer.AM_FirstBloodFinally" );
	PrecacheScriptSound( "Announcer.AM_FlawlessVictoryRandom" );
	PrecacheScriptSound( "Announcer.AM_FlawlessDefeatRandom" );
	PrecacheScriptSound( "Announcer.AM_FlawlessVictory01" );
	PrecacheScriptSound( "Announcer.AM_TeamScrambleRandom" );
	PrecacheScriptSound( "Taunt.MedicHeroic" );
	PrecacheScriptSound( "Taunt.GuitarRiff" );

	// Dmg absorb sound
	PrecacheScriptSound( "Powerup.ReducedDamage" );

	// Tourney UI
	PrecacheScriptSound( "Tournament.PlayerReady" );

	PrecacheScriptSound( "Medic.AutoCallerAnnounce" );

#ifdef STAGING_ONLY
	// Killstreak sounds
	PrecacheScriptSound( "Announcer.KillStreak_Level1" );
	PrecacheScriptSound( "Announcer.KillStreak_Level2" );
	PrecacheScriptSound( "Announcer.KillStreak_Level3" );
	PrecacheScriptSound( "Announcer.KillStreak_Level4" );
	PrecacheScriptSound( "Game.KillStreak" );
#endif

	// Precache particle systems
	PrecacheParticleSystem( "crit_text" );
	PrecacheParticleSystem( "miss_text" );
	PrecacheParticleSystem( "cig_smoke" );
	PrecacheParticleSystem( "speech_mediccall" );
	PrecacheParticleSystem( "speech_mediccall_auto" );
	PrecacheParticleSystem( "speech_taunt_all" );
	PrecacheParticleSystem( "speech_taunt_red" );
	PrecacheParticleSystem( "speech_taunt_blue" );
	PrecacheParticleSystem( "player_recent_teleport_blue" );
	PrecacheParticleSystem( "player_recent_teleport_red" );
	PrecacheParticleSystem( "particle_nemesis_red" );
	PrecacheParticleSystem( "particle_nemesis_blue" );
	PrecacheParticleSystem( "spy_start_disguise_red" );
	PrecacheParticleSystem( "spy_start_disguise_blue" );
	PrecacheParticleSystem( "burningplayer_red" );
	PrecacheParticleSystem( "burningplayer_blue" );
	PrecacheParticleSystem( "burningplayer_rainbow" );
	PrecacheParticleSystem( "blood_spray_red_01" );
	PrecacheParticleSystem( "blood_spray_red_01_far" );
	PrecacheParticleSystem( "pyrovision_blood" );

	PrecacheParticleSystem( "water_blood_impact_red_01" );
	PrecacheParticleSystem( "blood_impact_red_01" );
	PrecacheParticleSystem( "water_playerdive" );
	PrecacheParticleSystem( "water_playeremerge" );
	PrecacheParticleSystem( "healthgained_red" );
	PrecacheParticleSystem( "healthgained_blu" );
	PrecacheParticleSystem( "healthgained_red_large" );
	PrecacheParticleSystem( "healthgained_blu_large" );
	PrecacheParticleSystem( "healthgained_red_giant" );
	PrecacheParticleSystem( "healthgained_blu_giant" );
	PrecacheParticleSystem( "critgun_weaponmodel_red" );
	PrecacheParticleSystem( "critgun_weaponmodel_blu" );
	PrecacheParticleSystem( "overhealedplayer_red_pluses" );
	PrecacheParticleSystem( "overhealedplayer_blue_pluses" );
	PrecacheParticleSystem( "highfive_red" );
	PrecacheParticleSystem( "highfive_blue" );
	PrecacheParticleSystem( "god_rays" );
	PrecacheParticleSystem( "bl_killtaunt" );
	PrecacheParticleSystem( "birthday_player_circling" );
	PrecacheParticleSystem( "drg_fiery_death" );
	PrecacheParticleSystem( "drg_wrenchmotron_teleport" );
	PrecacheParticleSystem( "taunt_flip_land_red" );
	PrecacheParticleSystem( "taunt_flip_land_blue" );
	PrecacheParticleSystem( "tfc_sniper_mist" );
	PrecacheParticleSystem( "dxhr_sniper_rail_blue" );
	PrecacheParticleSystem( "dxhr_sniper_rail_red" );
	PrecacheParticleSystem( "tfc_sniper_distortion_trail" );

	for ( int i=0; i<ARRAYSIZE( s_pszTauntRPSParticleNames ); ++i )
	{
		PrecacheParticleSystem( s_pszTauntRPSParticleNames[i] );
	}

	PrecacheParticleSystem( "blood_decap" );

	PrecacheParticleSystem( "xms_icicle_idle" );
	PrecacheParticleSystem( "xms_icicle_impact" );
	PrecacheParticleSystem( "xms_icicle_impact_dryice" );
	PrecacheParticleSystem( "xms_icicle_melt" );
	PrecacheParticleSystem( "xms_ornament_glitter" );
	PrecacheParticleSystem( "xms_ornament_smash_blue" );
	PrecacheParticleSystem( "xms_ornament_smash_red" );

	PrecacheParticleSystem( "drg_pomson_muzzleflash" );
	PrecacheParticleSystem( "drg_pomson_impact" );
	PrecacheParticleSystem( "drg_pomson_impact_drain" );

	PrecacheParticleSystem( "dxhr_arm_muzzleflash" );

	PrecacheModel( "effects/beam001_red.vmt" );
	PrecacheModel( "effects/beam001_blu.vmt" );
	PrecacheModel( "effects/beam001_white.vmt" );

	PrecacheScriptSound( "Weapon_Mantreads.Impact" );

	// Precache footstep override sounds.
	PrecacheScriptSound( "cleats_conc.StepLeft" );
	PrecacheScriptSound( "cleats_conc.StepRight" );
	PrecacheScriptSound( "cleats_dirt.StepLeft" );
	PrecacheScriptSound( "cleats_dirt.StepRight" );

	PrecacheScriptSound( "xmas.jingle" );
	PrecacheScriptSound( "xmas.jingle_higher" );

	PrecacheScriptSound( "PegLeg.StepRight" );

	// Halloween
	// Bombinomicon deaths
	PrecacheParticleSystem( "bombinomicon_burningdebris" );
	PrecacheParticleSystem( "bombinomicon_burningdebris_halloween" );

	PrecacheParticleSystem( "halloween_player_death_blue" );
	PrecacheParticleSystem( "halloween_player_death" );

	PrecacheScriptSound( "Bombinomicon.Explode" );

	PrecacheScriptSound( "Weapon_DRG_Wrench.Teleport" );
	PrecacheScriptSound( "Weapon_Pomson.Single" );
	PrecacheScriptSound( "Weapon_Pomson.SingleCrit" );
	PrecacheScriptSound( "Weapon_Pomson.Reload" );
	PrecacheScriptSound( "Weapon_Pomson.DrainedVictim" );

	PrecacheScriptSound( "BlastJump.Whistle" );

	PrecacheScriptSound( "Spy.TeaseVictim" );
	PrecacheScriptSound( "Demoman.CritDeath" );
	PrecacheScriptSound( "Heavy.Battlecry03" );

	PrecacheModel( "models/effects/resist_shield/resist_shield.mdl" );

	PrecacheModel( "models/props_mvm/mvm_revive_tombstone.mdl" );

	PrecacheScriptSound( "General.banana_slip" ); // Used for SodaPopper Hype Jumps

#ifdef STAGING_ONLY
	PrecacheScriptSound( "RD.SpaceGravityTransition" );
#endif // STAGING_ONLY

	PrecacheScriptSound( "Parachute_open" );
	PrecacheScriptSound( "Parachute_close" );

#ifdef STAGING_ONLY
	PrecacheScriptSound( "WeaponDNAGun.Transform" );
	PrecacheParticleSystem( "spy_stolen_smoke_blue" );
	PrecacheParticleSystem( "spy_stolen_smoke_red" );
#endif // STAGING_ONLY

	// precache the EOTL bomb cart replacements
	PrecacheModel( "models/props_trainyard/bomb_eotl_blue.mdl" );
	PrecacheModel( "models/props_trainyard/bomb_eotl_red.mdl" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::Precache()
{
	VPROF_BUDGET( "CTFPlayer::Precache", VPROF_BUDGETGROUP_PLAYER );
	
	/*
	Note: All TFPlayer specific must go inside PrecacheTFPlayer()
		  This assumes that we're loading all resources for any TF player class
		  The reason is to safe performance because tons of string compares is very EXPENSIVE!!!
		  The most offending function is PrecacheGibsForModel which re-parsing through KeyValues every time it's called
		  If you have any question, come talk to me (Bank)
	*/
	PrecacheTFPlayer();

	BaseClass::Precache();
}

//-----------------------------------------------------------------------------
// Purpose: Allow pre-frame adjustments on the player
//-----------------------------------------------------------------------------
ConVar sv_runcmds( "sv_runcmds", "1" );
void CTFPlayer::PlayerRunCommand( CUserCmd *ucmd, IMoveHelper *moveHelper )
{
	static bool bSeenSyncError = false;
	VPROF( "CTFPlayer::PlayerRunCommand" );

	if ( !sv_runcmds.GetInt() )
		return;

	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
	{
		m_Shared.CreateVehicleMove( gpGlobals->frametime, ucmd );
	}
	else if ( IsTaunting() || m_Shared.InCond( TF_COND_HALLOWEEN_THRILLER ) )
	{
		// For some taunts, it is critical that the player not move once they start
		if ( !CanMoveDuringTaunt() )
		{
			ucmd->forwardmove = 0;
			ucmd->upmove = 0;
			ucmd->sidemove = 0;
			ucmd->viewangles = pl.v_angle;
		}

		if ( tf_allow_taunt_switch.GetInt() == 0 && ucmd->weaponselect != 0 )
		{
			ucmd->weaponselect = 0;

			// FIXME: The client will have predicted the weapon switch and have
			// called Holster/Deploy which will make the wielded weapon
			// invisible on their end.
		}
	}

	BaseClass::PlayerRunCommand( ucmd, moveHelper );

	// try to play taunt remap on input after updating user command
	if ( IsTaunting() && m_flNextAllowTauntRemapInputTime >= 0.f && m_flNextAllowTauntRemapInputTime <= gpGlobals->curtime )
	{
		float flSceneDuration = PlayTauntRemapInputScene();
		if ( flSceneDuration > 0.f )
		{
			m_flNextAllowTauntRemapInputTime = gpGlobals->curtime + flSceneDuration;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsReadyToPlay( void )
{
	bool bRetVal = false;

	if ( GetTeamNumber() == TEAM_SPECTATOR && m_bArenaSpectator == true )
		return false;
		
	//=============================================================================
	// HPE_BEGIN:
	// [msmith]	We don't want to say that the player is ready if they're still
	//			a training video.
	//=============================================================================
	if ( TFGameRules() && TFGameRules()->IsInTraining() && tf_training_client_message.GetInt() == TRAINING_CLIENT_MESSAGE_WATCHING_INTRO_MOVIE )
		return false;
	//=============================================================================
	// HPE_END
	//=============================================================================

	if ( GetTeamNumber() > LAST_SHARED_TEAM )
	{
		if ( GetDesiredPlayerClassIndex() > TF_CLASS_UNDEFINED )
		{
			bRetVal = true;
		}
		else 
		{
			if ( TFGameRules() && TFGameRules()->IsInArenaMode() && tf_arena_force_class.GetBool() == true && tf_arena_use_queue.GetBool() == true )
			{
				bRetVal = true;
			}
		}
	}

	return bRetVal;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsReadyToSpawn( void )
{
	if ( IsClassMenuOpen() )
	{
		return false;
	}

#ifdef TF_RAID_MODE
	if ( GetTeamNumber() == TF_TEAM_RED )
	{
		if ( TFGameRules()->IsRaidMode() || TFGameRules()->IsBossBattleMode() )
		{
			// enemy bots never respawn - they are spawned by the population system
			return false;
		}
	}
#endif // TF_RAID_MODE

	// Medic attached to marker - delay
	if ( m_hReviveMarker && m_hReviveMarker->IsReviveInProgress() && ( StateGet() != TF_STATE_DYING ) )
	{
		return false;
	}

	// Map-makers can force players to have custom respawn times
	if ( GetRespawnTimeOverride() != -1.f && gpGlobals->curtime < GetDeathTime() + GetRespawnTimeOverride() )
		return false;

	return ( StateGet() != TF_STATE_DYING );
}

//-----------------------------------------------------------------------------
// Purpose: Return true if this player should be allowed to instantly spawn
//			when they next finish picking a class.
//-----------------------------------------------------------------------------
bool CTFPlayer::ShouldGainInstantSpawn( void )
{
	return ( GetPlayerClass()->GetClassIndex() == TF_CLASS_UNDEFINED || IsClassMenuOpen() );
}

//-----------------------------------------------------------------------------
// Purpose: Resets player scores
//-----------------------------------------------------------------------------
void CTFPlayer::ResetScores( void )
{
	m_Shared.ResetScores();
	CTF_GameStats.ResetPlayerStats( this );
	RemoveNemesisRelationships();
	MannVsMachineStats_ResetPlayerEvents( this );

	BaseClass::ResetScores();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InitialSpawn( void )
{
	BaseClass::InitialSpawn();

	m_AttributeManager.InitializeAttributes( this );
	m_AttributeManager.SetPlayer( this );
	m_AttributeList.SetManager( &m_AttributeManager );

	SetWeaponBuilder( NULL );

	ResetScores();
	StateEnter( TF_STATE_WELCOME );
	UpdateInventory( true );

	ResetAccumulatedSentryGunDamageDealt();
	ResetAccumulatedSentryGunKillCount();
	ResetDamagePerSecond();

	IGameEvent * event = gameeventmanager->CreateEvent( "player_initial_spawn" );
	if ( event )
	{
		event->SetInt( "index", entindex() );
		gameeventmanager->FireEvent( event );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Request this player's inventories from the steam backend
//-----------------------------------------------------------------------------
void CTFPlayer::UpdateOnRemove( void )
{
	BaseClass::UpdateOnRemove();

#if !defined(NO_STEAM)
	m_Inventory.RemoveListener( this );
#endif

}

//-----------------------------------------------------------------------------
// Purpose: Override Base ApplyAbsVelocityImpulse (BaseEntity) to apply potential item attributes
//-----------------------------------------------------------------------------
void CTFPlayer::ApplyAbsVelocityImpulse( const Vector &vecImpulse ) 
{
	// Check for Attributes (mult_aiming_knockback_resistance)
	Vector vecForce = vecImpulse;
	float flImpulseScale = 1.0f;
	if ( IsPlayerClass( TF_CLASS_SNIPER ) && m_Shared.InCond( TF_COND_AIMING ) )
	{		
		CALL_ATTRIB_HOOK_FLOAT( flImpulseScale, mult_aiming_knockback_resistance );
	}

	if ( m_Shared.InCond( TF_COND_HALLOWEEN_TINY ) && !m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
	{
		flImpulseScale *= 2.f;
	}

	// take extra force if you have a parachute deployed in x-y directions
	if ( m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) )
	{
		// don't allow parachute robot to get push in MvM
		float flHorizontalScale = TFGameRules()->IsMannVsMachineMode() && IsBot() ? 0.f : 1.5f;
		vecForce.x *= flHorizontalScale;
		vecForce.y *= flHorizontalScale;
	}

	CBaseMultiplayerPlayer::ApplyAbsVelocityImpulse( vecForce * flImpulseScale );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ApplyAirBlastImpulse( const Vector &vecImpulse )
{
	// Knockout powerup carriers are immune to airblast
	if ( m_Shared.GetCarryingRuneType() == RUNE_KNOCKOUT || m_Shared.InCond( TF_COND_MEGAHEAL ) )
		return;
	
	Vector vForce = vecImpulse;

	float flScale = 1.0f;
	CALL_ATTRIB_HOOK_FLOAT( flScale, airblast_vulnerability_multiplier );
	vForce *= flScale;

	// if on the ground, require min force to boost you off it
	if ( ( GetFlags() & FL_ONGROUND ) && ( vForce.z < JUMP_MIN_SPEED ) )
	{
		// Minimum value of vecForce.z
		vForce.z = JUMP_MIN_SPEED;
	}
	
	CALL_ATTRIB_HOOK_FLOAT( vForce.z, airblast_vertical_vulnerability_multiplier );

	RemoveFlag( FL_ONGROUND );
	m_Shared.AddCond( TF_COND_KNOCKED_INTO_AIR );

	ApplyAbsVelocityImpulse( vForce );
}

//-----------------------------------------------------------------------------
// Purpose: Go between for Setting Local Punch Impulses. Checks item attributes
// Use this instead of directly calling m_Local.m_vecPunchAngle.SetX( value );
//-----------------------------------------------------------------------------
bool CTFPlayer::ApplyPunchImpulseX ( float flImpulse ) 
{
	// Check for No Aim Flinch
	bool bFlinch = true;
	if ( IsPlayerClass( TF_CLASS_SNIPER ) && m_Shared.InCond( TF_COND_AIMING ) )
	{	
		CTFWeaponBase *pWeapon = GetActiveTFWeapon();
		if ( pWeapon && WeaponID_IsSniperRifle( pWeapon->GetWeaponID() ) )
		{
			CTFSniperRifle *pRifle = static_cast< CTFSniperRifle* >( pWeapon );
			if ( pRifle->IsFullyCharged() )
			{
				int iAimingNoFlinch = 0;
				CALL_ATTRIB_HOOK_INT( iAimingNoFlinch, aiming_no_flinch );
				if ( iAimingNoFlinch > 0 )
				{
					bFlinch = false;
				}
			}
		}
	}
	
	if ( bFlinch )
	{
		m_Local.m_vecPunchAngle.SetX( flImpulse );
	}

	return bFlinch;
}

//-----------------------------------------------------------------------------
// Purpose: Request this player's inventories from the steam backend
//-----------------------------------------------------------------------------
void CTFPlayer::UpdateInventory( bool bInit )
{
#if !defined(NO_STEAM)
	if ( IsFakeClient() )
		return;

	if ( bInit || !m_Inventory.GetSOC() )
	{
		if ( steamgameserverapicontext->SteamGameServer() )
		{
			CSteamID steamIDForPlayer;
			if ( GetSteamID( &steamIDForPlayer ) )
			{
				TFInventoryManager()->SteamRequestInventory( &m_Inventory, steamIDForPlayer, this );
			}
		}
	}

	// If we have an SOCache, we've got a connection to the GC
	bool bInvalid = true;
	if ( m_Inventory.GetSOC() )
	{
		bInvalid = m_Inventory.GetSOC()->BIsInitialized() == false;
	}
	m_Shared.SetLoadoutUnavailable( bInvalid );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Requests that the GC confirm that this player is supposed to have 
//			an SO cache on this gameserver and send it again if so.
//-----------------------------------------------------------------------------
void CTFPlayer::VerifySOCache()
{
#if !defined(NO_STEAM)
	if ( IsFakeClient() || IsHLTV() || IsReplay() )
		return;

	CSteamID steamIDForPlayer;
	GetSteamID( &steamIDForPlayer );

	if( steamIDForPlayer.BIndividualAccount() )
	{
		// if we didn't find an inventory ask the GC to refresh us
		GCSDK::CGCMsg<MsgGCVerifyCacheSubscription_t> msgVerifyCache( k_EMsgGCVerifyCacheSubscription );
		msgVerifyCache.Body().m_ulSteamID = steamIDForPlayer.ConvertToUint64();
		GCClientSystem()->BSendMessage( msgVerifyCache );
	}
	else
	{
		Msg( "Cannot verify load for invalid steam ID %s\n", steamIDForPlayer.Render() );
	}
#endif
}

#ifdef DEBUG
CON_COMMAND_F( verifyloadout, "Cause the server to verify the player's items on the server.", FCVAR_NONE )
{
	CTFPlayer *pPlayer = ToTFPlayer( UTIL_GetCommandClient() );
	if ( !pPlayer )
		return;

	pPlayer->VerifySOCache();
}
#endif // DEBUG

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int	CTFPlayer::ShouldTransmit( const CCheckTransmitInfo *pInfo )
{
	// always send information to student or client
	if ( pInfo->m_pClientEnt )
	{
		if ( m_hStudent && m_hStudent == CBaseEntity::Instance( pInfo->m_pClientEnt ) )
		{
			return FL_EDICT_ALWAYS;
		}
		else if ( m_hCoach && m_hCoach == CBaseEntity::Instance( pInfo->m_pClientEnt ) )
		{
			return FL_EDICT_ALWAYS;
		}
		else if ( TFGameRules() && TFGameRules()->IsPasstimeMode() )
		{
			// TODO it should be possible to restrict this further based on
			// the values of tf_passtime_player_reticles_friends/enemies
			return FL_EDICT_ALWAYS;
		}

		CBaseEntity *pRecipientEntity = CBaseEntity::Instance( pInfo->m_pClientEnt );
		if ( pRecipientEntity && pRecipientEntity->ShouldForceTransmitsForTeam( GetTeamNumber() ) )
			return FL_EDICT_ALWAYS;
	}

	return BaseClass::ShouldTransmit( pInfo );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::SetupVisibility( CBaseEntity *pViewEntity, unsigned char *pvs, int pvssize )
{
	// coach can only "see" what the student "sees"
	if ( m_bIsCoaching && m_hStudent )
	{
		Vector org;
		org = m_hStudent->EyePosition();

		engine->AddOriginToPVS( org );
	}
	else
	{
		BaseClass::SetupVisibility( pViewEntity, pvs, pvssize );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::Spawn()
{
	VPROF_BUDGET( "CTFPlayer::Spawn", VPROF_BUDGETGROUP_PLAYER );
	MDLCACHE_CRITICAL_SECTION();

	m_bIsABot = IsBot();

	if ( m_bIsABot && IsBotOfType( TF_BOT_TYPE ) )
	{
		m_nBotSkill = ToTFBot( this )->GetDifficulty();
	}
	else
	{
		m_nBotSkill = 0;
	}

	m_flSpawnTime = gpGlobals->curtime;

	SetModelScale( 1.0f );
	UpdateModel();

	SetMoveType( MOVETYPE_WALK );
	BaseClass::Spawn();

	// We have to clear this early, so that the sword knows its max health in ManageRegularWeapons below
	m_Shared.SetDecapitations( 0 );

	// Check the make sure we have our inventory each time we spawn
	UpdateInventory( false );

#ifndef NO_STEAM
	if( m_Shared.IsLoadoutUnavailable() )
	{
		VerifySOCache();
	}
#endif

	// Create our off hand viewmodel if necessary
	CreateViewModel( 1 );
	// Make sure it has no model set, in case it had one before
	GetViewModel(1)->SetModel( "" );

	// Kind of lame, but CBasePlayer::Spawn resets a lot of the state that we initially want on.
	// So if we're in the welcome state, call its enter function to reset 
	if ( m_Shared.InState( TF_STATE_WELCOME ) )
	{
		StateEnterWELCOME();
	}

	// If they were dead, then they're respawning. Put them in the active state.
	if ( m_Shared.InState( TF_STATE_DYING ) )
	{
		StateTransition( TF_STATE_ACTIVE );
	}

	// If they're spawning into the world as fresh meat, give them items and stuff.
	bool bMatchSummary = TFGameRules() && TFGameRules()->ShowMatchSummary();
	if ( m_Shared.InState( TF_STATE_ACTIVE ) || bMatchSummary )
	{
		// remove our disguise each time we spawn
		if ( m_Shared.InCond( TF_COND_DISGUISED ) )
		{
			m_Shared.RemoveDisguise();
		}

		if ( !bMatchSummary )
		{
			EmitSound( "Player.Spawn" );
		}
		InitClass();
		m_Shared.RemoveAllCond(); // Remove conc'd, burning, rotting, hallucinating, etc.

		// add team glows for a period of time after we respawn
		m_Shared.AddCond( TF_COND_TEAM_GLOWS, tf_spawn_glows_duration.GetInt() );

		UpdateSkin( GetTeamNumber() );

		// Prevent firing for a second so players don't blow their faces off
		SetNextAttack( gpGlobals->curtime + 1.0 );

		DoAnimationEvent( PLAYERANIMEVENT_SPAWN );

		// Force a taunt off, if we are still taunting, the condition should have been cleared above.
		StopTaunt();

		// turn on separation so players don't get stuck in each other when spawned
		m_Shared.SetSeparation( true );
		m_Shared.SetSeparationVelocity( vec3_origin );

		RemoveTeleportEffect();
	
		//If this is true it means I respawned without dying (changing class inside the spawn room) but doesn't necessarily mean that my healers have stopped healing me
		//This means that medics can still be linked to me but my health would not be affected since this condition is not set.
		//So instead of going and forcing every healer on me to stop healing we just set this condition back on. 
		//If the game decides I shouldn't be healed by someone (LOS, Distance, etc) they will break the link themselves like usual.
		if ( m_Shared.GetNumHealers() > 0 )
		{
			m_Shared.AddCond( TF_COND_HEALTH_BUFF );
		}

		if ( !m_bSeenRoundInfo )
		{
			if ( TFGameRules() && TFGameRules()->IsPasstimeMode() )
			{
				CSingleUserRecipientFilter filter( this );
				TFGameRules()->SendHudNotification( filter, HUD_NOTIFY_PASSTIME_HOWTO );
			}

			TFGameRules()->ShowRoundInfoPanel( this );
			m_bSeenRoundInfo = true;
		}

		if ( IsInCommentaryMode() && !IsFakeClient() )
		{
			// Player is spawning in commentary mode. Tell the commentary system.
			CBaseEntity *pEnt = NULL;
			variant_t emptyVariant;
			while ( (pEnt = gEntList.FindEntityByClassname( pEnt, "commentary_auto" )) != NULL )
			{
				pEnt->AcceptInput( "MultiplayerSpawned", this, this, emptyVariant, 0 );
			}
		}
	}

	CTF_GameStats.Event_PlayerSpawned( this );

	m_iSpawnCounter = !m_iSpawnCounter;
	m_bAllowInstantSpawn = false;

	m_Shared.SetSpyCloakMeter( 100.0f );
	m_Shared.SetScoutEnergyDrinkMeter( 100.0f );
	m_Shared.SetScoutHypeMeter( 0.0f );
	m_Shared.StopScoutHypeDrain();
	m_Shared.SetRageMeter( 0.0f );
	m_Shared.SetDemomanChargeMeter( 100.0f );

	m_Shared.ClearDamageEvents();
	m_AchievementData.ClearHistories();

	m_flLastDamageTime = 0.f;
	m_flLastDamageDoneTime = 0.f;
	m_iMaxSentryKills = 0;

	m_flNextVoiceCommandTime = gpGlobals->curtime;
	m_iVoiceSpamCounter = 0;

	ClearZoomOwner();
	SetFOV( this , 0 );

	SetViewOffset( GetClassEyeHeight() * GetModelScale() );

	RemoveAllScenesInvolvingActor( this );
	ClearExpression();
	m_flNextSpeakWeaponFire = gpGlobals->curtime;

	m_bInPowerPlay = false;

	// This makes the surrounding box always the same size as the standing collision box
	// helps with parts of the hitboxes that extend out of the crouching hitbox, eg with the
	// heavyweapons guy
	Vector mins = VEC_HULL_MIN;
	Vector maxs = VEC_HULL_MAX;
	CollisionProp()->SetSurroundingBoundsType( USE_SPECIFIED_BOUNDS, &mins, &maxs );

	m_iLeftGroundHealth = -1;
	m_iBlastJumpState = 0;
	m_bGoingFeignDeath = false;
	m_bTakenBlastDamageSinceLastMovement = false;

	ClearTauntAttack();
	m_hTauntItem = NULL;

	m_bArenaIsAFK = false;

	m_Shared.SetFeignDeathReady( false );

	m_bScattergunJump = false;
	m_iOldStunFlags = 0;

	m_flAccumulatedHealthRegen = 0;
	memset( m_flAccumulatedAmmoRegens, 0, sizeof(m_flAccumulatedAmmoRegens) );

	IGameEvent * event = gameeventmanager->CreateEvent( "player_spawn" );
	if ( event )
	{
		event->SetInt( "userid", GetUserID() );
		event->SetInt( "team", GetTeamNumber() );
		event->SetInt( "class", GetPlayerClass()->GetClassIndex() );

		gameeventmanager->FireEvent( event );
	}

#ifdef TF_RAID_MODE
	if ( TFGameRules()->IsRaidMode() && GetTeamNumber() == TF_TEAM_BLUE )
	{
		// raiders respawn invulnerable for a short time
		m_Shared.AddCond( TF_COND_INVULNERABLE, tf_raid_respawn_safety_time.GetFloat() );

		// friends glow
		AddGlowEffect();
	}

	if ( TFGameRules()->IsBossBattleMode() && GetTeamNumber() == TF_TEAM_BLUE )
	{
		// respawn invulnerable for a short time
		m_Shared.AddCond( TF_COND_INVULNERABLE, tf_boss_battle_respawn_safety_time.GetFloat() );
	}
#endif // TF_RAID_MODE

	m_bIsMissionEnemy = false;
	m_bIsSupportEnemy = false;
	m_bIsLimitedSupportEnemy = false;

	m_Shared.Spawn();

	m_bCollideWithSentry = false;
	m_calledForMedicTimer.Invalidate();
	m_placedSapperTimer.Invalidate();

	m_bIsReadyToHighFive = false;

	m_nForceTauntCam = 0;
	m_bAllowedToRemoveTaunt = true;

	m_purgatoryPainMultiplier = 1;
	m_purgatoryPainMultiplierTimer.Invalidate();

	m_bIsTeleportingUsingEurekaEffect = false;

	m_playerMovementStuckTimer.Invalidate();

	m_bIsMiniBoss = false;
	m_bUseBossHealthBar = false;

	m_hGrapplingHookTarget = NULL;
	m_nHookAttachedPlayers = 0;
	m_bUsingActionSlot = false;

	m_flInspectTime = 0.f;

	m_flSendPickupWeaponMessageTime = -1.f;

	SetRespawnOverride( -1.f, NULL_STRING );

	// Remove all powerups and add temporary invuln on spawn
	if ( TFGameRules()->IsPowerupMode() )
	{
		m_Shared.AddCond( TF_COND_INVULNERABLE_USER_BUFF, 8.f );
	}

	if ( TFGameRules() )
	{
		// It's halloween, and it's hell time.  Force this player to spawn in hell.
		if ( TFGameRules()->ArePlayersInHell() )
		{
			const char *pSpawnEntName = NULL;
			if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
			{
				pSpawnEntName = "hell_ghost_spawn";
			}
			else if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) && CTFMinigameLogic::GetMinigameLogic() )
			{
				CTFMiniGame *pActiveMinigame = CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame();
				if ( pActiveMinigame )
				{
					pSpawnEntName = pActiveMinigame->GetTeamSpawnPointName( GetTeamNumber() );
				}
			}

			if ( pSpawnEntName )
			{
				TFGameRules()->SpawnPlayerInHell( this, pSpawnEntName );
			}
		}
		TFGameRules()->OnPlayerSpawned( this );
	}

	if ( m_hReviveMarker )
	{
		UTIL_Remove( m_hReviveMarker );
		m_hReviveMarker = NULL;
	}

	// make sure we clear custom attributes that we added
	RemoveAllCustomAttributes();

#ifdef STAGING_ONLY
	// in MVM, scout can see glowing cash by default
	if ( TFGameRules()->IsMannVsMachineMode() )
	{
		int iClass = GetPlayerClass()->GetClassIndex();
		if ( iClass == TF_CLASS_SCOUT || iClass == TF_CLASS_SPY )
		{
			AddCustomAttribute( "mvm see cash through wall", 1.f );
		}
	}
#endif

	CTFPlayerResource *pResource = dynamic_cast<CTFPlayerResource *>( g_pPlayerResource );
	if ( pResource )
	{
		pResource->SetPlayerClassWhenKilled( entindex(), TF_CLASS_UNDEFINED );
	}

	if ( TFGameRules()->State_Get() == GR_STATE_BETWEEN_RNDS )
	{
		const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
		if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady )
		{
			TFGameRules()->PlayerReadyStatus_UpdatePlayerState( this, true );
		}
	}

	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	if ( pMatch )
	{
		CSteamID steamID;
		GetSteamID( &steamID );

		// This client entered a running match
		CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( steamID );
		if ( pMatchPlayer && TFGameRules() && TFGameRules()->State_Get() == GR_STATE_RND_RUNNING )
		{
			pMatchPlayer->bPlayed = true;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Removes all nemesis relationships between this player and others
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveNemesisRelationships()
{
	for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
	{
		CTFPlayer *pTemp = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pTemp && pTemp != this )
		{
			bool bRemove = false;

			if ( TFGameRules()->IsInArenaMode() == true )
			{
				if ( GetTeamNumber() != TEAM_SPECTATOR )
				{
					if ( InSameTeam( pTemp ) == true )
					{
						bRemove = true;
					}
				}

				if ( IsDisconnecting() == true )
				{
					bRemove = true;
				}
			}
			else
			{
				bRemove = true;
			}
			
			if ( bRemove == true )
			{
				// set this player to be not dominating anyone else
				m_Shared.SetPlayerDominated( pTemp, false );
				m_iNumberofDominations = 0;

				// set no one else to be dominating this player	
				bool bThisPlayerIsDominatingMe = m_Shared.IsPlayerDominatingMe( i );
				pTemp->m_Shared.SetPlayerDominated( this, false );
				if ( bThisPlayerIsDominatingMe )
				{
					int iDoms = pTemp->GetNumberofDominations();
					pTemp->SetNumberofDominations( iDoms - 1);
				}
			}
		}
	}	

	if ( TFGameRules()->IsInArenaMode() == false || IsDisconnecting() == true )
	{
		// reset the matrix of who has killed whom with respect to this player
		CTF_GameStats.ResetKillHistory( this );
	}

	IGameEvent *event = gameeventmanager->CreateEvent( "remove_nemesis_relationships" );
	if ( event )
	{
		event->SetInt( "player", entindex() );
		gameeventmanager->FireEvent( event );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::Regenerate( bool bRefillHealthAndAmmo /*= true*/ )
{
	// We may have been boosted over our max health. If we have, 
	// restore it after we reset out class values.
	int nOldMaxHealth = GetMaxHealth();
	int nOldHealth = GetHealth();
	bool bBoosted = ( nOldHealth > nOldMaxHealth || !bRefillHealthAndAmmo ) && ( nOldMaxHealth > 0 );

	int nAmmo[ TF_AMMO_COUNT ];
	if ( !bRefillHealthAndAmmo )
	{
		for ( int iAmmo = 0; iAmmo < TF_AMMO_COUNT; ++iAmmo )
		{
			nAmmo[ iAmmo ] = GetAmmoCount( iAmmo );
		}
	}
	
	m_bRegenerating = true;
	// This recomputes MaxHealth
	InitClass();
	m_bRegenerating = false;

	if ( bBoosted )
	{
		SetHealth( MAX( nOldHealth, GetMaxHealth() ) );
	}

	if ( bRefillHealthAndAmmo )
	{
		if ( m_Shared.InCond( TF_COND_BURNING ) )
		{
			m_Shared.RemoveCond( TF_COND_BURNING );
		}

		if ( m_Shared.InCond( TF_COND_URINE ) )
		{
			m_Shared.RemoveCond( TF_COND_URINE );
		}

		if ( m_Shared.InCond( TF_COND_MAD_MILK ) )
		{
			m_Shared.RemoveCond( TF_COND_MAD_MILK );
		}

		if ( m_Shared.InCond( TF_COND_BLEEDING ) )
		{
			m_Shared.RemoveCond( TF_COND_BLEEDING );
		}

		if ( m_Shared.InCond( TF_COND_ENERGY_BUFF ) )
		{
			m_Shared.RemoveCond( TF_COND_ENERGY_BUFF );

			if ( m_Shared.InCond( TF_COND_CANNOT_SWITCH_FROM_MELEE ) )
			{
				m_Shared.RemoveCond( TF_COND_CANNOT_SWITCH_FROM_MELEE );
			}
		}

		if ( m_Shared.InCond( TF_COND_PHASE ) )
		{
			m_Shared.RemoveCond( TF_COND_PHASE );
		}

		if ( m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) )
		{
			m_Shared.RemoveCond( TF_COND_PARACHUTE_DEPLOYED );
		}

		if ( m_Shared.InCond( TF_COND_PLAGUE ) )
		{
			m_Shared.RemoveCond( TF_COND_PLAGUE );
		}

#ifdef STAGING_ONLY
		if ( m_Shared.InCond( TF_COND_TRANQ_MARKED ) )
		{
			m_Shared.RemoveCond( TF_COND_TRANQ_MARKED );
		}
#endif // STAGING_ONLY

		m_Shared.SetSpyCloakMeter( 100.0f );
		m_Shared.SetScoutEnergyDrinkMeter( 100.0f );
		m_Shared.SetDemomanChargeMeter( 100.0f );
	}

	// Reset our first allowed fire time. This allows honorbound weapons to be switched away
	// from for a bit.
	m_Shared.m_flFirstPrimaryAttack = MAX( m_Shared.m_flFirstPrimaryAttack, gpGlobals->curtime + 1.0f );

	if ( bRefillHealthAndAmmo )
	{
		for ( int iAmmo = 0; iAmmo < TF_AMMO_COUNT; ++iAmmo )
		{
			if ( GetAmmoCount( iAmmo ) > GetMaxAmmo( iAmmo ) )
			{
				SetAmmoCount( GetMaxAmmo( iAmmo ), iAmmo );
			}
		}
	}
	else
	{
		for ( int iAmmo = 0; iAmmo < TF_AMMO_COUNT; ++iAmmo )
		{
			SetAmmoCount( nAmmo[ iAmmo ], iAmmo );
		}
	}

	IGameEvent *event = gameeventmanager->CreateEvent( "player_regenerate" );
	if ( event )
	{
		gameeventmanager->FireEvent( event );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::InitClass( void )
{
	SetArmorValue( GetPlayerClass()->GetMaxArmor() );

	// Init the anim movement vars
	m_PlayerAnimState->SetRunSpeed( GetPlayerClass()->GetMaxSpeed() );
	m_PlayerAnimState->SetWalkSpeed( GetPlayerClass()->GetMaxSpeed() * 0.5 );

	// Give default items for class.
	GiveDefaultItems();

	// Set initial health and armor based on class.
	// Do it after items have been delivered, so items can modify it
	SetMaxHealth( GetMaxHealth() );
	SetHealth( GetMaxHealth() );

	TeamFortress_SetSpeed();

#ifdef STAGING_ONLY
	int nForceRobotModel = 0;
	CALL_ATTRIB_HOOK_INT( nForceRobotModel, appear_as_mvm_robot );
	if ( nForceRobotModel != 0 )
	{
		int nClassIndex = ( GetPlayerClass() ? GetPlayerClass()->GetClassIndex() : TF_CLASS_UNDEFINED );
		GetPlayerClass()->SetCustomModel( g_szPlayerRobotModels[nClassIndex], USE_CLASS_ANIMATIONS );
		UpdateModel();
		SetBloodColor( DONT_BLEED );
	}
	else
	{
		GetPlayerClass()->SetCustomModel( NULL );
		UpdateModel();
		SetBloodColor( BLOOD_COLOR_RED );
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::CreateViewModel( int iViewModel )
{
	Assert( iViewModel >= 0 && iViewModel < MAX_VIEWMODELS );

	if ( GetViewModel( iViewModel ) )
		return;

	CTFViewModel *pViewModel = ( CTFViewModel * )CreateEntityByName( "tf_viewmodel" );
	if ( pViewModel )
	{
		pViewModel->SetAbsOrigin( GetAbsOrigin() );
		pViewModel->SetOwner( this );
		pViewModel->SetIndex( iViewModel );
		DispatchSpawn( pViewModel );
		pViewModel->FollowEntity( this, false );
		m_hViewModel.Set( iViewModel, pViewModel );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Gets the view model for the player's off hand
//-----------------------------------------------------------------------------
CBaseViewModel *CTFPlayer::GetOffHandViewModel()
{
	// off hand model is slot 1
	return GetViewModel( 1 );
}

//-----------------------------------------------------------------------------
// Purpose: Sends the specified animation activity to the off hand view model
//-----------------------------------------------------------------------------
void CTFPlayer::SendOffHandViewModelActivity( Activity activity )
{
	CBaseViewModel *pViewModel = GetOffHandViewModel();
	if ( pViewModel )
	{
		int sequence = pViewModel->SelectWeightedSequence( activity );
		pViewModel->SendViewModelMatchingSequence( sequence );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Set the player up with the default weapons, ammo, etc.
//-----------------------------------------------------------------------------
void CTFPlayer::GiveDefaultItems()
{
	// Get the player class data.
	TFPlayerClassData_t *pData = m_PlayerClass.GetData();
	if ( GetTeamNumber() == TEAM_SPECTATOR )
	{
		RemoveAllWeapons();
		return;
	}
	
	// Give weapons.
	ManageRegularWeapons( pData );

	if ( !TFGameRules() || !TFGameRules()->IsInMedievalMode() )
	{
		// Give a builder weapon for each object the playerclass is allowed to build
		ManageBuilderWeapons( pData );
	}

	// Weapons that added greater ammo than base require us to now fill the player up to max ammo
	for ( int iAmmo = 0; iAmmo < TF_AMMO_COUNT; ++iAmmo )
	{
		GiveAmmo( GetMaxAmmo(iAmmo), iAmmo, true, kAmmoSource_Resupply );
	}

	// Clear the player's banner buffs.
	m_Shared.RemoveCond( TF_COND_OFFENSEBUFF );
	m_Shared.RemoveCond( TF_COND_DEFENSEBUFF );
	m_Shared.RemoveCond( TF_COND_REGENONDAMAGEBUFF );
	m_Shared.RemoveCond( TF_COND_NOHEALINGDAMAGEBUFF );
	m_Shared.RemoveCond( TF_COND_DEFENSEBUFF_NO_CRIT_BLOCK );
	m_Shared.RemoveCond( TF_COND_DEFENSEBUFF_HIGH );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ManageBuilderWeapons( TFPlayerClassData_t *pData )
{
	// Collect all builders and validate them against the list of objects (below)
	CUtlVector< CTFWeaponBuilder* > vecBuilderDestroyList;
	for ( int i = 0; i < MAX_WEAPONS; ++i )
	{
		CTFWeaponBuilder *pBuilder = dynamic_cast< CTFWeaponBuilder* >( GetWeapon( i ) );
		if ( !pBuilder )
			continue;

		vecBuilderDestroyList.AddToTail( pBuilder );
	}

	CEconItemView *pLoadoutBuilderItemView = NULL;

	// Go through each object and see if we need to create or remove builders
	for ( int i = 0; i < OBJ_LAST; ++i )
	{
		if ( !GetPlayerClass()->CanBuildObject( i ) )
			continue;

		// TODO:  Need to add support for "n" builders, rather hard-wired for two.
		// Currently, the only class that uses more than one is the spy:
		// - BUILDER is OBJ_ATTACHMENT_SAPPER, which is invoked via weapon selection (see objects.txt).
		// - BUILDER2 is OBJ_SPY_TRAP, which is invoked via a build command from PDA3 (spy-specific).
#ifdef STAGING_ONLY
		int nLoadoutPos = ( GetObjectInfo( i )->m_bRequiresOwnBuilder ) ? LOADOUT_POSITION_BUILDING2 : LOADOUT_POSITION_BUILDING;
#else
		int nLoadoutPos = LOADOUT_POSITION_BUILDING;
#endif
		pLoadoutBuilderItemView = GetLoadoutItem( GetPlayerClass()->GetClassIndex(), nLoadoutPos, true );

		// Do we have a specific builder for this object?
		CTFWeaponBuilder *pBuilder = CTFPlayerSharedUtils::GetBuilderForObjectType( this, i );
		if ( pBuilder )
		{
			// We may have a different builder back-end item now.  If so, destroy and make a new one below.
			CEconItemView *pCurrentBuilderItemView = pBuilder->GetAttributeContainer()->GetItem();
			if ( pCurrentBuilderItemView == NULL || pLoadoutBuilderItemView == NULL || !ItemsMatch( pData, pCurrentBuilderItemView, pLoadoutBuilderItemView, pBuilder ) )
			{
				// Manually nuke the item from the weapon list here so that we don't find it 
				vecBuilderDestroyList.FindAndRemove( pBuilder );
				Weapon_Detach( pBuilder );
				UTIL_Remove( pBuilder );

				// Wrong builder item, so pretend we didn't find one
				pBuilder = NULL;
			}
		}
		else if ( !GetObjectInfo( i )->m_bRequiresOwnBuilder )
		{
			// Do we have a default builder, and an object that doesn't require a specific builder?
			pBuilder = CTFPlayerSharedUtils::GetBuilderForObjectType( this, -1 );
			if ( pBuilder )
			{
				// Flag it as supported by this builder (ugly, but necessary for legacy system)
				pBuilder->SetObjectTypeAsBuildable( i );
			}
		}
				
		// Is a new builder required?
		if ( !pBuilder || ( GetObjectInfo( i )->m_bRequiresOwnBuilder && !( CTFPlayerSharedUtils::GetBuilderForObjectType( this, i ) ) ) )
		{
			pBuilder = dynamic_cast< CTFWeaponBuilder* >( GiveNamedItem( "tf_weapon_builder", i, pLoadoutBuilderItemView ) );
			if ( pBuilder )
			{
				pBuilder->DefaultTouch( this );
			}
		}

		// Builder settings
		if ( pBuilder )
		{
			if ( m_bRegenerating == false )
			{
				pBuilder->WeaponReset();
			}

			pBuilder->GiveDefaultAmmo();
			pBuilder->ChangeTeam( GetTeamNumber() );
			pBuilder->SetObjectTypeAsBuildable( i );
			pBuilder->m_nSkin = GetTeamNumber() - 2;	// color the w_model to the team

			// Pull it out of the "destroy" list
			vecBuilderDestroyList.FindAndRemove( pBuilder );
		}
	}

	// Anything left should be destroyed
	FOR_EACH_VEC( vecBuilderDestroyList, i )
	{
		Assert( vecBuilderDestroyList[i] );

		Weapon_Detach( vecBuilderDestroyList[i] );
		UTIL_Remove( vecBuilderDestroyList[i] );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::ItemsMatch( TFPlayerClassData_t *pData, CEconItemView *pCurWeaponItem, CEconItemView *pNewWeaponItem, CTFWeaponBase *pWpnEntity )
{
	if ( !pNewWeaponItem || !pNewWeaponItem->IsValid() )
		return false;

	// If we already have a weapon in this slot but is not the same type, nuke it (changed classes)
	// We don't need to do this for non-base items because they've already been verified above.
	bool bHasNonBaseWeapon = pNewWeaponItem ? pNewWeaponItem->GetItemQuality() != AE_NORMAL : false;
	if ( bHasNonBaseWeapon )
	{
		// If the item isn't the one we're supposed to have, nuke it
		if ( pCurWeaponItem->GetItemID() != pNewWeaponItem->GetItemID() )
		{
			/*
			Msg("Removing %s because its global index (%d) doesn't match the loadout's (%d)\n", pWeapon->GetDebugName(), 
				pCurWeaponItem->GetItemID(),
				pNewWeaponItem->GetItemID() );
			*/
			return false;
		}

		// Some items create different entities when wielded by different classes. If so, we need to say
		// the items don't match so the item gets recreated as the right entity.
		if ( pWpnEntity )
		{
			const char *pszCurWeaponClass	   = pWpnEntity->GetClassname(),
					   *pszNewWeaponTransClass = TranslateWeaponEntForClass( pNewWeaponItem->GetStaticData()->GetItemClass(), GetPlayerClass()->GetClassIndex() );

			if ( !pszCurWeaponClass || !pszNewWeaponTransClass || Q_stricmp( pszCurWeaponClass, pszNewWeaponTransClass ) )
				return false;
		}
	}
	else
	{
		if ( pCurWeaponItem->GetItemQuality() != AE_NORMAL || (pCurWeaponItem->GetItemDefIndex() != pNewWeaponItem->GetItemDefIndex()) )
		{
			//Msg("Removing %s because it's not the right type for the class.\n", pWeapon->GetDebugName() );
			return false;
		}

		CSteamID ownerSteamID;
		GetSteamID( &ownerSteamID );

		// If the owner is not the same, then they're different as well. This catches
		// cases of stock items comparing
		if ( pCurWeaponItem->GetAccountID() != ownerSteamID.GetAccountID() )
		{
			return false;
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::ItemIsAllowed( CEconItemView *pItem )
{
	if ( !pItem || !pItem->GetStaticData() )
		return false;

	int iClass = GetPlayerClass()->GetClassIndex();
	int iSlot = pItem->GetStaticData()->GetLoadoutSlot(iClass);

	// Passtime hack to allow passtime gun
	if ( V_stristr( pItem->GetItemDefinition()->GetDefinitionName(), "passtime" ) )
	{
		return TFGameRules() && TFGameRules()->IsPasstimeMode();
	}

	// Holiday Restriction
	CEconItemDefinition* pData = pItem->GetStaticData();
	if ( TFGameRules() && pData && pData->GetHolidayRestriction() )
	{
		int iHolidayRestriction = UTIL_GetHolidayForString( pData->GetHolidayRestriction() );
		if ( iHolidayRestriction != kHoliday_None && !TFGameRules()->IsHolidayActive( iHolidayRestriction ) )
			return false;
	}

	if ( TFGameRules()->InStalemate() && mp_stalemate_meleeonly.GetBool() )
	{
		bool bMeleeOnlyAllowed = (iSlot == LOADOUT_POSITION_MELEE)
							  || (iClass == TF_CLASS_SPY && (iSlot == LOADOUT_POSITION_PDA || iSlot == LOADOUT_POSITION_PDA2));

		if ( !bMeleeOnlyAllowed )
			return false;
	}

	if ( TFGameRules()->IsInMedievalMode() )
	{
		bool bMedievalModeAllowed = false;

		// Allow all melee-class weapons, non-weapons, and the spy equipment.
		switch ( iSlot )
		{
		case LOADOUT_POSITION_MELEE:
		case LOADOUT_POSITION_HEAD:
		case LOADOUT_POSITION_MISC:
		case LOADOUT_POSITION_MISC2:
		case LOADOUT_POSITION_ACTION:
		case LOADOUT_POSITION_TAUNT:
		case LOADOUT_POSITION_TAUNT2:
		case LOADOUT_POSITION_TAUNT3:
		case LOADOUT_POSITION_TAUNT4:
		case LOADOUT_POSITION_TAUNT5:
		case LOADOUT_POSITION_TAUNT6:
		case LOADOUT_POSITION_TAUNT7:
		case LOADOUT_POSITION_TAUNT8:
#ifdef STAGING_ONLY
		case LOADOUT_POSITION_PDA3:
		case LOADOUT_POSITION_BUILDING2:
#endif
			bMedievalModeAllowed = true;
			break;

		case LOADOUT_POSITION_PDA:
		case LOADOUT_POSITION_PDA2:
			if ( iClass == TF_CLASS_SPY )
				bMedievalModeAllowed = true;
			break;
		}
		
		if ( !bMedievalModeAllowed )
		{
			static CSchemaAttributeDefHandle pAttrib_AllowedInMedievalMode( "allowed in medieval mode" );
			if ( !pItem->FindAttribute( pAttrib_AllowedInMedievalMode ) )
			{
				return false;
			}
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ManageRegularWeapons( TFPlayerClassData_t *pData )
{	
	// Reset ammo.
	RemoveAllAmmo();

	// Remove our disguise weapon.
	m_Shared.RemoveDisguiseWeapon();

	CUtlVector<const char *> precacheStrings;

	CBaseCombatWeapon* pCurrentWeapon = m_hActiveWeapon;

	// Give ammo. Must be done before weapons, so weapons know the player has ammo for them.
	for ( int iAmmo = 0; iAmmo < TF_AMMO_COUNT; ++iAmmo )
	{
		GiveAmmo( GetMaxAmmo(iAmmo), iAmmo, true, kAmmoSource_Resupply );
	}

	if ( IsX360() )
	{
		ManageRegularWeaponsLegacy( pData );
	}
	else
	{
		// Loop through our current wearables and ensure we're supposed to have them.
		ValidateWearables( pData );

		// Loop through all our current weapons, and ensure we're supposed to have them.
		ValidateWeapons( pData, true );

		// Create a copy of currently equipped items, if we equip something new report player loadout
		bool bItemsChanged = false;

		// Now Loop through our inventory for the current class, and give us any items we don't have.
		int iClass = GetPlayerClass()->GetClassIndex();
		if ( iClass > TF_CLASS_UNDEFINED && iClass < TF_CLASS_COUNT )
		{
			CSteamID ownerSteamID;
			GetSteamID( &ownerSteamID );

			for ( int i = 0; i < CLASS_LOADOUT_POSITION_COUNT; i++ )
			{
				// bots don't need the action slot item for MvM (canteen)
 				if ( ( i == LOADOUT_POSITION_ACTION ) && IsBot() && TFGameRules() && TFGameRules()->IsMannVsMachineMode() && ( GetTeamNumber() == TF_TEAM_PVE_INVADERS ) )
 					continue;

				m_EquippedLoadoutItemIndices[i] = LOADOUT_SLOT_USE_BASE_ITEM;

				// use base items in training mode
				CEconItemView *pItem = GetLoadoutItem( iClass, i, true );
				if ( !pItem || !pItem->IsValid() )
					continue;

				if ( !ItemIsAllowed( pItem ) )
					continue;

				// Only do this for taunts, because other items will be caught by the dynamic model loading system. 
				if ( IsTauntSlot( i ) )
				{
					tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s - Precaching taunts, etc", __FUNCTION__ );
					// This has to be done before the continue for "no_entity", because we're trying to precache taunts which
					// explicitly bail out there.
					precacheStrings.RemoveAll();
					pItem->GetItemDefinition()->GeneratePrecacheModelStrings( false, &precacheStrings );
					FOR_EACH_VEC( precacheStrings, iModel )
					{
						if ( precacheStrings[iModel] && ( *precacheStrings[iModel] ) )
						{
							PrecacheModel( precacheStrings[iModel], false );
						}
					}
				}

				m_EquippedLoadoutItemIndices[i] = pItem->GetItemID();

				Assert( pItem->GetStaticData()->GetItemClass() );
				if ( pItem->GetStaticData()->GetItemClass() && FStrEq( pItem->GetStaticData()->GetItemClass(), "no_entity" ) )
					continue;

				CTFWeaponBase *pCurrentWeaponOfType = NULL;
				bool bAlreadyHave = false;
				// Don't need to check weapons if it's a wearable-only slot
				if ( !IsWearableSlot(i) || pItem->GetItemDefinition()->IsActingAsAWeapon() )
				{
					// Weapon slot. Check out weapons to see if we have it.
					for ( int wpn = 0; wpn < MAX_WEAPONS; wpn++ )
					{
						CTFWeaponBase *pWeapon = (CTFWeaponBase *)GetWeapon(wpn);
						if ( !pWeapon )
							continue;

						if ( ItemsMatch( pData, pWeapon->GetAttributeContainer()->GetItem(), pItem, pWeapon ) )
						{
							pCurrentWeaponOfType = pWeapon;
							bAlreadyHave = true;
							break;
						}
					}
				}

				CEconWearable *pWearable = NULL;
				if ( !bAlreadyHave )
				{
					// We couldn't find a matching weapon. See if we have a matching wearable.
					for ( int wbl = 0; wbl < m_hMyWearables.Count(); wbl++ )
					{
						pWearable = m_hMyWearables[wbl];
						if ( !pWearable )
							continue;

						CEconItemView *pWearableView = pWearable->GetAttributeContainer()->GetItem();
						if ( ItemsMatch( pData, pWearableView, pItem ) )
						{
							bAlreadyHave = true;
							break;
						}
					}
				}

				if ( !bAlreadyHave && pItem->GetStaticData()->GetItemClass() )
				{
					CEconEntity *pNewItem = dynamic_cast<CEconEntity*>(GiveNamedItem( pItem->GetStaticData()->GetItemClass(), 0, pItem ));
					Assert( pNewItem );
					if ( pNewItem )
					{
						pNewItem->GetAttributeContainer()->GetItem()->SetOverrideAccountID( ownerSteamID.GetAccountID() );

						CTFWeaponBuilder *pBuilder = dynamic_cast<CTFWeaponBuilder*>( (CBaseEntity*)pNewItem );
						if ( pBuilder )
						{
							pBuilder->SetSubType( pData->m_aBuildable[0] );
						}

						CBaseCombatWeapon* pWeapon = dynamic_cast< CBaseCombatWeapon* >( pNewItem );
						if ( pWeapon )
						{
							pWeapon->SetSoundsEnabled( false );
						}
						
						pNewItem->GiveTo( this );

						if ( pWeapon )
						{
							pWeapon->SetSoundsEnabled( true );
						}
					}
				}
				else
				{
					if ( pCurrentWeaponOfType )
					{
						pCurrentWeaponOfType->UpdateExtraWearables();

						// We need to ensure all hands pointers are updated for all weapons.
						// Otherwise we could end up using animation sequences from the wrong class hands.
						pCurrentWeaponOfType->UpdateHands();
					}
				}

				bItemsChanged |= !bAlreadyHave;
			} // For each item in load out
		}

		if ( bItemsChanged )
		{
			CTF_GameStats.Event_PlayerLoadoutChanged( this, false );			
		}
		// We may have added weapons that make others invalid. Recheck.
		ValidateWeapons( pData, false );

		if ( m_hActiveWeapon.Get() != pCurrentWeapon && m_hActiveWeapon )
		{
			m_hActiveWeapon->WeaponSound( DEPLOY );
		}

		CSingleUserRecipientFilter filter( this );
		UserMessageBegin( filter, "PlayerLoadoutUpdated" );
			WRITE_BYTE( entindex() );
		MessageEnd();
	}


	// On equip, legacy source code will autoswitch to new weapons.
	// Instead of refactoring, we check here to see if we are allowed to have certain weapons switched to

	// TF2: Not allowed to have a actionslot item as last or active on regenerate / respawn
	// HACK Don't allow the parachute to be an active weapon
	CTFWeaponBase *pCurr = GetActiveTFWeapon();
	CTFWeaponBase *pPrev = dynamic_cast<CTFWeaponBase*>( GetLastWeapon() );
	if ( ( pCurr && pCurr->GetAttributeContainer()->GetItem()->GetEquippedPositionForClass( GetPlayerClass()->GetClassIndex() ) == LOADOUT_POSITION_ACTION )
	  || ( pPrev && pPrev->GetAttributeContainer()->GetItem()->GetEquippedPositionForClass( GetPlayerClass()->GetClassIndex() ) == LOADOUT_POSITION_ACTION )
	  || ( pCurr && pCurr->GetWeaponID() == TF_WEAPON_PARACHUTE )
	) {
		m_bRegenerating = false;
		m_iLastWeaponSlot = 0;
	}

	if ( m_bRegenerating == false )
	{
		bool bWepSwitched = false;
		if ( m_bRememberActiveWeapon && m_iActiveWeaponTypePriorToDeath )
		{
			CTFWeaponBase *pWeapon = Weapon_OwnsThisID( m_iActiveWeaponTypePriorToDeath );
			if ( pWeapon && pWeapon->GetAttributeContainer()->GetItem()->GetEquippedPositionForClass( GetPlayerClass()->GetClassIndex() ) != LOADOUT_POSITION_ACTION )
			{
				bWepSwitched = Weapon_Switch( pWeapon );
			}
		}
		
		if ( !bWepSwitched )
		{
			SetActiveWeapon( NULL );

			// Find a weapon to switch to, starting with primary.
			CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase*>( GetEntityForLoadoutSlot( LOADOUT_POSITION_PRIMARY ) );
			if ( !pWeapon || !pWeapon->CanBeSelected() || !Weapon_Switch( pWeapon ) )
			{
				pWeapon = dynamic_cast<CTFWeaponBase*>( GetEntityForLoadoutSlot( LOADOUT_POSITION_SECONDARY ) );
				if ( !pWeapon || pWeapon->CanBeSelected() || !Weapon_Switch( pWeapon ) )
				{
					pWeapon = dynamic_cast<CTFWeaponBase*>( GetEntityForLoadoutSlot( LOADOUT_POSITION_MELEE ) );
					Weapon_Switch( pWeapon );
				}
			}
		}

		if ( (m_iLastWeaponSlot == 0 || !m_bRememberLastWeapon) && !m_bRememberActiveWeapon )  
		{
			m_iLastWeaponSlot = 1;
		}

		if ( !Weapon_GetSlot( m_iLastWeaponSlot ) )
		{
			Weapon_SetLast( Weapon_GetSlot( TF_WPN_TYPE_MELEE ) );
		}
		else
		{
			Weapon_SetLast( Weapon_GetSlot( m_iLastWeaponSlot ) );
		}		
	}

	// Now make sure we don't have too much ammo. This can happen if an item has reduced our max ammo.
	for ( int iAmmo = 0; iAmmo < TF_AMMO_COUNT; ++iAmmo )
	{
		int iMax = GetMaxAmmo(iAmmo);
		if ( iMax < GetAmmoCount(iAmmo) )
		{
			RemoveAmmo( GetAmmoCount(iAmmo) - iMax, iAmmo );
		}
	}

	// If our max health dropped below current due to item changes, drop our current health.
	// If we're not being buffed, clamp it to max. Otherwise, clamp it to the max buffed health
	int iMaxHealth = m_Shared.InCond( TF_COND_HEALTH_BUFF ) ? m_Shared.GetMaxBuffedHealth() : GetMaxHealth();
	if ( m_iHealth > iMaxHealth )
	{
		// Modify health manually to prevent showing all the "you got hurt" UI. 
		m_iHealth = iMaxHealth;
	}

	if ( TFGameRules()->InStalemate() && mp_stalemate_meleeonly.GetBool() )
	{
		CBaseCombatWeapon *meleeWeapon = Weapon_GetSlot( TF_WPN_TYPE_MELEE );
		if ( meleeWeapon )
		{
			Weapon_Switch( meleeWeapon );
		}
	}

	// In testing mode, switch bots to the weapon being tested
	if ( TFGameRules()->IsInItemTestingMode() && IsFakeClient() )
	{
		// Our first player should be the human tester
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( 1 ) );
		if ( pPlayer && !pPlayer->IsFakeClient() )
		{
			// Loop through all the items we're testing
			FOR_EACH_VEC( pPlayer->m_ItemsToTest, i )
			{
				CEconItemView *pItem = &pPlayer->m_ItemsToTest[i].scriptItem;
				if ( !pItem )
					continue;

				int iSlot = pItem->GetStaticData()->GetLoadoutSlot( GetPlayerClass()->GetClassIndex() );
				if ( IsWearableSlot( iSlot ) )
					continue;

				CBaseCombatWeapon *pWeapon = Weapon_GetSlot( iSlot );
				if ( pWeapon )
				{
					Weapon_Switch( pWeapon );
					break;
				}
			}
		}
	}

	if ( TFGameRules() && TFGameRules()->IsPVEModeActive() && !IsBot() ) 
	{
		if (  m_Inventory.ClassLoadoutHasChanged( GetPlayerClass()->GetClassIndex() ) 
		   || ( m_bSwitchedClass )
		   || ( g_pPopulationManager && g_pPopulationManager->IsRestoringCheckpoint() ) )
		{
			ReapplyPlayerUpgrades();
		}

		// Calculate how much money is being used on active class / items
		int nSpending = 0;
		int iClass = GetPlayerClass()->GetClassIndex();
		CUtlVector< CUpgradeInfo > *upgrades = g_pPopulationManager->GetPlayerUpgradeHistory( this );
		if ( upgrades )
		{
			for( int u = 0; u < upgrades->Count(); ++u )
			{
				// Class Match, Check to see if we have this item equipped
				if ( iClass == upgrades->Element(u).m_iPlayerClass) 
				{
					// Player upgrade
					if ( upgrades->Element( u ).m_itemDefIndex == INVALID_ITEM_DEF_INDEX )
					{
						nSpending += upgrades->Element(u).m_nCost;
						continue;
					}

					// Item upgrade, look at equipment only not miscs or bottle
					for ( int itemIndex = 0; itemIndex <= LOADOUT_POSITION_PDA2; itemIndex++ )
					{
						CEconItemView *pItem = GetLoadoutItem( iClass, itemIndex, true );
						if ( upgrades->Element(u).m_itemDefIndex == pItem->GetItemDefIndex() )
						{
							nSpending += upgrades->Element(u).m_nCost;
							break;
						}
					}
				}
			}
		}

		CMannVsMachineStats *pStats = MannVsMachineStats_GetInstance();
		if ( pStats )
		{
			pStats->NotifyPlayerActiveUpgradeCosts( this, nSpending );
		}
	}

	PostInventoryApplication();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CEconItemView *CTFPlayer::GetLoadoutItem( int iClass, int iSlot, bool bReportWhitelistFails )
{
	if ( TFGameRules()->IsInItemTestingMode() )
	{
		CEconItemView *pItem = ItemTesting_GetTestItem( iClass, iSlot );
		if ( pItem )
			return pItem;
	}

	if ( TFGameRules()->IsInTraining() || TFGameRules()->IsInItemTestingMode() )
	{
		CTFInventoryManager *pInventoryManager = TFInventoryManager();
		return pInventoryManager->GetBaseItemForClass( iClass, iSlot );
	}

	CEconItemView *pItem = m_Inventory.GetItemInLoadout( iClass, iSlot );

	// Check to see if this item passes the tournament rules (in whitelist/or normal quality).
	// If it doesn't, we fall back to the base item for the loadout slot.
	if ( (pItem && pItem->IsValid()) && (pItem->GetItemQuality() != AE_NORMAL) && !pItem->GetStaticData()->IsAllowedInMatch() && TFGameRules()->IsInTournamentMode() )
	{
		if ( bReportWhitelistFails )
		{
			ClientPrint( this, HUD_PRINTNOTIFY, "#Item_BlacklistedInMatch", pItem->GetStaticData()->GetItemBaseName() );
		}

		pItem = TFInventoryManager()->GetBaseItemForClass( iClass, iSlot );
	}

	return pItem;
}

//-----------------------------------------------------------------------------
// Purpose: Handles pressing the use action slot item key.
//-----------------------------------------------------------------------------
void CTFPlayer::UseActionSlotItemPressed( void )
{
	m_bUsingActionSlot = true;

	if ( TryToPickupDroppedWeapon() )
		return;

	int iNoiseMaker = 0;
	CALL_ATTRIB_HOOK_INT( iNoiseMaker, enable_misc2_noisemaker );
	if ( iNoiseMaker )
	{
		DoNoiseMaker();
		return;
	}

	CBaseEntity *pActionSlotEntity = GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION );
	if ( !pActionSlotEntity )
		return;

	// get the equipped item and see what it is
	CTFPowerupBottle *pPowerupBottle = dynamic_cast< CTFPowerupBottle* >( pActionSlotEntity );
	if ( pPowerupBottle )
	{
		// @todo send event to clients so that they know what's going on
		pPowerupBottle->Use();
		return;
	}

	// is it a throwable?
	CTFThrowable *pThrowable = dynamic_cast< CTFThrowable* >( pActionSlotEntity );
	if ( pThrowable )
	{
		if ( !Weapon_ShouldSelectItem( pThrowable ) )
			return;

		if ( GetActiveWeapon() )
		{
			if ( !GetActiveWeapon()->CanHolster() )
				return;

			ResetAutoaim( );
		}

		// Check if this is the spellbook so we can save off info to preserve weapon switching
		CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( pThrowable );
		if ( pSpellBook )
		{
			if ( !pSpellBook->CanCastSpell( this ) )
			{
				// if no spell force a roll if cheat is active
				if ( tf_halloween_unlimited_spells.GetBool() && !pSpellBook->HasASpellWithCharges() )
				{
					pSpellBook->RollNewSpell( 0 );
				}
				else if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
				{
					// if I'm in a halloween Vehicle, cast the spell immediately
					//pSpellBook->CastKartSpell();
					pSpellBook->PrimaryAttack();
				}
				else
				{
					EmitSound_t params;
					params.m_flSoundTime = 0;
					params.m_pflSoundDuration = 0;
					params.m_pSoundName = "Player.DenyWeaponSelection";

					CSingleUserRecipientFilter filter( this );
					EmitSound( filter, entindex(), params );
				}
				return;
			}
			// Notify the spellbook of the current last used weapon
			pSpellBook->SaveLastWeapon( GetLastWeapon() );
		}
		// Equip it
		Weapon_Switch( pThrowable );
		return;
	}

	if ( TFGameRules() && TFGameRules()->IsUsingGrapplingHook() )
	{
		CTFGrapplingHook *pGrapplingHook = dynamic_cast< CTFGrapplingHook* >( pActionSlotEntity );
		if ( pGrapplingHook )
		{
			Weapon_Switch( pGrapplingHook );
			return;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handles releasing the use action slot item key.
//-----------------------------------------------------------------------------
void CTFPlayer::UseActionSlotItemReleased( void )
{
	m_bUsingActionSlot = false;

	if ( TFGameRules() && TFGameRules()->IsUsingGrapplingHook() )
	{
		// if we're using the hook, switch back to the last weapon
		if ( GetActiveTFWeapon() && GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_GRAPPLINGHOOK )
		{
			CBaseCombatWeapon *pLastWeapon = GetLastWeapon();
			if ( pLastWeapon && Weapon_CanSwitchTo( pLastWeapon ) )
			{
				Weapon_Switch( pLastWeapon );
			}
			else
			{
				// in case we failed to switch back to last weapon for some reason, just find the next best
				SwitchToNextBestWeapon( pLastWeapon );
			}

			return;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handles pressing the inspect key.
//-----------------------------------------------------------------------------
void CTFPlayer::InspectButtonPressed()
{
	m_flInspectTime = gpGlobals->curtime;
}

//-----------------------------------------------------------------------------
// Purpose: Handles releasing the inspect key.
//-----------------------------------------------------------------------------
void CTFPlayer::InspectButtonReleased()
{
	m_flInspectTime = 0.f;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::AddToSpyKnife( float value, bool force )
{
	CTFKnife *pWpn = (CTFKnife *)Weapon_OwnsThisID( TF_WEAPON_KNIFE );
	if ( !pWpn )
		return false;

	return pWpn->DecreaseRegenerationTime( value, force );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveAllItems()
{
	// Nuke items.
	for ( int i = 0; i < MAX_WEAPONS; i++ )
	{
		CTFWeaponBase *pWeapon = (CTFWeaponBase *)GetWeapon(i);
		if ( !pWeapon )
			continue;

		Weapon_Detach( pWeapon );
		UTIL_Remove( pWeapon );
	}

	// Nuke wearables.
	for ( int wbl = m_hMyWearables.Count()-1; wbl >= 0; wbl-- )
	{
		CEconWearable *pWearable = m_hMyWearables[wbl];
		Assert( pWearable );
		if ( !pWearable )
			continue;

		RemoveWearable( pWearable );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ValidateWeapons( TFPlayerClassData_t *pData, bool bResetWeapons )
{
	CSteamID steamIDForPlayer;
	GetSteamID( &steamIDForPlayer );

	bool bFoundBuffItem = false;

	bool bOverrideRemoval = false;
	if ( bResetWeapons && m_bForceItemRemovalOnRespawn )
	{
		bOverrideRemoval = true;
		m_bForceItemRemovalOnRespawn = false;
	}

	// Disable sounds for all weapons.  We're about to switch weapons MANY times,
	// and we don't want the deploy sounds to play for any of them, since none
	// of the deploys are actually visible to the player
	for ( int i = 0; i < MAX_WEAPONS; i++ )
	{
		CTFWeaponBase *pWeapon = (CTFWeaponBase *)GetWeapon(i);
		if ( !pWeapon )
			continue;

		pWeapon->SetSoundsEnabled( false );
	}

	for ( int i = 0; i < MAX_WEAPONS; i++ )
	{
		CTFWeaponBase *pWeapon = (CTFWeaponBase *)GetWeapon(i);
		if ( !pWeapon )
			continue;

		int iLoadoutSlot = pWeapon->GetAttributeContainer()->GetItem()->GetStaticData()->GetLoadoutSlot( GetPlayerClass()->GetClassIndex() );
		CEconItemView *pItem = GetLoadoutItem( GetPlayerClass()->GetClassIndex(), iLoadoutSlot );

		// See if gamerules says this item isn't allowed right now
		bool bForceRemoved = bOverrideRemoval || !ItemIsAllowed( pItem );

		if ( bForceRemoved || !ItemsMatch( pData, pWeapon->GetAttributeContainer()->GetItem(), pItem, pWeapon ) )
		{
			// we can't hold this weapon anymore, switch to the next best weapon before removing it
			if ( GetActiveTFWeapon() == pWeapon )
			{
				SwitchToNextBestWeapon( pWeapon );
			}

			// drop weapon that belongs to other player, unless we're not regenerating
			// which happens at round restart
			if ( !bForceRemoved && m_bRegenerating )
			{
				CEconItemView *pDroppedItem = pWeapon->GetAttributeContainer()->GetItem();
				CSteamID steamID;
				GetSteamID( &steamID );
				if ( pDroppedItem->GetAccountID() != steamID.GetAccountID() )
				{
					// Find the position and angle of the weapons so the "ammo box" matches.
					Vector vecPackOrigin;
					QAngle vecPackAngles;
					if( !CalculateAmmoPackPositionAndAngles( pWeapon, vecPackOrigin, vecPackAngles ) )
						return;

					CTFDroppedWeapon *pDroppedWeapon = CTFDroppedWeapon::Create( this, vecPackOrigin, vecPackAngles, pWeapon->GetWorldModel(), pDroppedItem );
					if ( pDroppedWeapon )
					{
						pDroppedWeapon->InitDroppedWeapon( this, pWeapon, false );
					}
				}
			}

			// We shouldn't have this weapon. Remove it.
			Weapon_Detach( pWeapon );
			UTIL_Remove( pWeapon );
		}
		else if ( bResetWeapons )
		{
			// We should have this weapon. Reset it.
			pWeapon->ChangeTeam( GetTeamNumber() );
			pWeapon->GiveDefaultAmmo();
			pWeapon->ClearKillComboCount();

			if ( m_bRegenerating == false )
			{
				pWeapon->WeaponReset();
			}
			else
			{
				pWeapon->WeaponRegenerate();
			}
		}

		int nBuffType = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, nBuffType, set_buff_type );

		if ( pWeapon->GetWeaponID() == TF_WEAPON_BUFF_ITEM || nBuffType )
		{
			bFoundBuffItem = true;
		}
	}

	// Reenable sounds for all weapons
	for ( int i = 0; i < MAX_WEAPONS; i++ )
	{
		CTFWeaponBase *pWeapon = (CTFWeaponBase *)GetWeapon(i);
		if ( !pWeapon )
			continue;

		pWeapon->SetSoundsEnabled( true );
	}

	// Prevent a rage exploit with changing items outside of a spawn room
	if ( ( IsPlayerClass( TF_CLASS_SOLDIER ) || IsPlayerClass( TF_CLASS_PYRO ) || IsPlayerClass( TF_CLASS_SNIPER ) ) && !bFoundBuffItem )
	{
		m_Shared.SetRageMeter( 0.0f );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ValidateWearables( TFPlayerClassData_t *pData )
{
	CSteamID steamIDForPlayer;
	GetSteamID( &steamIDForPlayer );

	bool bIsDisguisedSpy = IsPlayerClass( TF_CLASS_SPY ) && m_Shared.InCond( TF_COND_DISGUISED );

	// Need to move backwards because we'll be removing them as we find them.
	for ( int wbl = m_hMyWearables.Count()-1; wbl >= 0; wbl-- )
	{
		CEconWearable *pWearable = m_hMyWearables[wbl];
		Assert( pWearable );
		if ( !pWearable )
		{
			// Integrity is failing, remove NULLs
			m_hMyWearables.Remove( wbl );
			continue;
		}
			
		CTFWearable *pTFWearable = assert_cast< CTFWearable* >( pWearable );
		if ( bIsDisguisedSpy && pTFWearable->IsDisguiseWearable() )
			continue;

		bool itemMatch = false;		

		// If you are an extra wearable, just make sure your associated weapon is valid instead
		CBaseEntity *pEntity = pTFWearable->GetWeaponAssociatedWith();
		if ( pEntity )
		{
			CTFWeaponBase *pWeapon = assert_cast< CTFWeaponBase* >( pTFWearable->GetWeaponAssociatedWith() );

			int iLoadoutSlot = pWeapon->GetAttributeContainer()->GetItem()->GetStaticData()->GetLoadoutSlot( GetPlayerClass()->GetClassIndex() );
			if (iLoadoutSlot >= 0 )
			{
				CEconItemView *pItem = TFInventoryManager()->GetItemInLoadoutForClass( GetPlayerClass()->GetClassIndex(), iLoadoutSlot, &steamIDForPlayer );
				itemMatch |= ItemsMatch( pData, pWeapon->GetAttributeContainer()->GetItem(), pItem );
			}
		}
		else
		{
			// Regular Wearable
			int iLoadoutSlot = pWearable->GetAttributeContainer()->GetItem()->GetStaticData()->GetLoadoutSlot( GetPlayerClass()->GetClassIndex() );
			if ( iLoadoutSlot >= 0 )
			{
				CEconItemView *pItem = TFInventoryManager()->GetItemInLoadoutForClass( GetPlayerClass()->GetClassIndex(), iLoadoutSlot, &steamIDForPlayer );
				itemMatch |= ItemsMatch( pData, pWearable->GetAttributeContainer()->GetItem(), pItem );

				// Item says what slot it wants to be in, but Misc's and Taunts can be in multiple places, check against all
				bool bLoadoutMisc = iLoadoutSlot == LOADOUT_POSITION_MISC;
				bool bLoadoutTaunt = iLoadoutSlot == LOADOUT_POSITION_TAUNT;
				if ( bLoadoutMisc || bLoadoutTaunt ) 
				{
					for ( int i = LOADOUT_POSITION_INVALID + 1; i < CLASS_LOADOUT_POSITION_COUNT; i++ )
					{
						if ( ( bLoadoutMisc && IsMiscSlot( i ) ) || ( bLoadoutTaunt && IsTauntSlot( i ) ) )
						{
							pItem = TFInventoryManager()->GetItemInLoadoutForClass( GetPlayerClass()->GetClassIndex(), i, &steamIDForPlayer );
							itemMatch |= ItemsMatch( pData, pWearable->GetAttributeContainer()->GetItem(), pItem );
						}
					}
				}
			}
		}

		if ( !itemMatch || pWearable->GetTeamNumber() != GetTeamNumber() || m_bForceItemRemovalOnRespawn || m_bSwitchedClass )
		{
			if ( !pWearable->AlwaysAllow() )
			{
				// We shouldn't have this wearable. Remove it.
				RemoveWearable( pWearable );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PostInventoryApplication( void )
{
	m_Shared.RecalculatePlayerBodygroups();

	if ( m_Shared.InCond( TF_COND_DISGUISED ) )
	{
		// Using weapons lockers destroys our disguise weapon, so we might need a new one.
		m_Shared.DetermineDisguiseWeapon( false );
	}

	// Apply set bonuses.
	ApplySetBonuses();

	// Remove our disguise if we can't disguise.
	if ( !CanDisguise() )
	{
		RemoveDisguise();
	}

	// Notify the client.
	IGameEvent *event = gameeventmanager->CreateEvent( "post_inventory_application" );
	if ( event )
	{
		event->SetInt( "userid", GetUserID() );
		gameeventmanager->FireEvent( event ); 
	}

	// Iterate over all of our wearables
	int iPlayerSkinOverride = 0;
	for ( int i=0; i< GetNumWearables(); ++i )
	{
		CTFWearable *pWearable = dynamic_cast<CTFWearable *>( GetWearable( i ) );
		if ( pWearable == NULL || pWearable->IsDisguiseWearable() )
			continue;

		// Check if we have an item that activates the skin override we want
		// find first skin override
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pWearable, iPlayerSkinOverride, player_skin_override );
		if ( iPlayerSkinOverride != 0 ) // Zombie
		{
			break;
		}
	}
	m_iPlayerSkinOverride = iPlayerSkinOverride;

	m_Inventory.ClearClassLoadoutChangeTracking();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ManageRegularWeaponsLegacy( TFPlayerClassData_t *pData )
{
	CSteamID steamIDForPlayer;
	GetSteamID( &steamIDForPlayer );

	for ( int iWeapon = 0; iWeapon < TF_PLAYER_WEAPON_COUNT; ++iWeapon )
	{
		if ( pData->m_aWeapons[iWeapon] != TF_WEAPON_NONE )
		{
			int iWeaponID = pData->m_aWeapons[iWeapon];
			const char *pszWeaponName = WeaponIdToAlias( iWeaponID );

			CTFWeaponBase *pWeapon = (CTFWeaponBase *)GetWeapon( iWeapon );

			WEAPON_FILE_INFO_HANDLE	hWpnInfo = LookupWeaponInfoSlot( pszWeaponName );
			Assert( hWpnInfo != GetInvalidWeaponInfoHandle() );
			CTFWeaponInfo *pWeaponInfo = dynamic_cast<CTFWeaponInfo*>( GetFileWeaponInfoFromHandle( hWpnInfo ) );
			int iLoadoutSlot = pWeaponInfo->m_iWeaponType;

			// HACK: Convert engineer's second PDA to using the second pda slot
			if ( iWeaponID == TF_WEAPON_PDA_ENGINEER_DESTROY || iWeaponID == TF_WEAPON_INVIS )
			{
				iLoadoutSlot = LOADOUT_POSITION_PDA2;
			}

#ifdef STAGING_ONLY
			if ( iWeaponID == TF_WEAPON_PDA_SPY_BUILD )
			{
				iLoadoutSlot = LOADOUT_POSITION_PDA3;
			}
#endif

			// Do we have a custom weapon in this slot?
			CEconItemView *pItem = TFInventoryManager()->GetItemInLoadoutForClass( GetPlayerClass()->GetClassIndex(), iLoadoutSlot, &steamIDForPlayer );
			bool bHasNonBaseWeapon = pItem ? pItem->GetItemQuality() != AE_NORMAL : false;

			if ( pWeapon )
			{
				bool bShouldRemove = false;

				if ( pItem )
				{
					// If the item isn't the one we're supposed to have, nuke it
					if ( pWeapon->GetAttributeContainer()->GetItem()->GetItemID() != pItem->GetItemID() )
					{
						bShouldRemove = true;

						/*
						Msg("Removing %s because its global index (%d) doesn't match the loadout's (%d)\n", pWeapon->GetDebugName(), 
						pWeapon->GetAttributeContainer()->GetItem()->GetItemID(),
						pItem->GetItemID() );
						*/
					}
				}
				else
				{
					// We should have a base item in our loadout.
					if ( pWeapon->GetAttributeContainer()->GetItem()->GetItemQuality() != AE_NORMAL )
					{
						bShouldRemove = true;
						//Msg("Removing %s because it's a non-base item, and the loadout specifies a base item.\n", pWeapon->GetDebugName() );
					}
				}

				// If we already have a weapon in this slot but is not the same type, nuke it (changed classes)
				// We don't do this if the weapon in this slot isn't a base item, because items like the flaregun
				// don't have matching weaponIDs, yet they shouldn't be removed. The inventory system has already
				// ensured that the weapon is valid in this slot.
				if ( !bShouldRemove && pWeapon->GetWeaponID() != iWeaponID && !bHasNonBaseWeapon )
				{
					bShouldRemove = true;
					//Msg("Removing %s because it's not the right type for the class.\n", pWeapon->GetDebugName() );
				}

				if ( bShouldRemove )
				{
					Weapon_Detach( pWeapon );
					UTIL_Remove( pWeapon );
					pWeapon = NULL;
				}
			}

			if ( !bHasNonBaseWeapon )
			{
				pWeapon = dynamic_cast<CTFWeaponBase*>(Weapon_OwnsThisID( iWeaponID ));
			}

			if ( pWeapon )
			{
				Assert( pWeapon->GetAttributeContainer()->GetItem()->GetItemID() == ( pItem ? pItem->GetItemID() : INVALID_ITEM_ID ) );

				pWeapon->ChangeTeam( GetTeamNumber() );
				pWeapon->GiveDefaultAmmo();

				if ( m_bRegenerating == false )
				{
					pWeapon->WeaponReset();
				}

				//char tempstr[1024];
				//g_pVGuiLocalize->ConvertUnicodeToANSI( pWeapon->GetAttributeContainer()->GetItem()->GetItemName(), tempstr, sizeof(tempstr) );
				//Msg("Updated %s for %s\n", tempstr, GetPlayerName() );
			}
			else
			{
				CEconEntity* pNewItem = dynamic_cast<CEconEntity*>(GiveNamedItem( pszWeaponName, 0, pItem ));
				Assert( pNewItem );
				if ( pNewItem )
				{
					//char tempstr[1024];
					//g_pVGuiLocalize->ConvertUnicodeToANSI( pWeapon->GetAttributeContainer()->GetItem()->GetItemName(), tempstr, sizeof(tempstr) );
					//Msg("Created %s for %s\n", tempstr, GetPlayerName() );
					//pWeapon->DebugDescribe();

					pNewItem->GiveTo( this );
				}
			}
		}
		else
		{
			//I shouldn't have any weapons in this slot, so get rid of it
			CTFWeaponBase *pCarriedWeapon = (CTFWeaponBase *)GetWeapon( iWeapon );

			//Don't nuke builders since they will be nuked if we don't need them later.
			if ( pCarriedWeapon && pCarriedWeapon->GetWeaponID() != TF_WEAPON_BUILDER )
			{
				Weapon_Detach( pCarriedWeapon );
				UTIL_Remove( pCarriedWeapon );
			}
		}
	}

	// If we lack a primary or secondary weapon, start with our melee weapon ready.
	// This is for supporting new unlockables that take up weapon slots and leave our character with nothing to wield.
	int iMainWeaponCount = 0;
	CTFWeaponBase* pMeleeWeapon = NULL;
	for ( int i = 0; i < MAX_WEAPONS; i++ )
	{
		CTFWeaponBase *pWeapon = (CTFWeaponBase*) GetWeapon(i);

		if ( pWeapon == NULL )
			continue;

		if ( pWeapon->GetTFWpnData().m_iWeaponType == TF_WPN_TYPE_PRIMARY ||
			 pWeapon->GetTFWpnData().m_iWeaponType == TF_WPN_TYPE_SECONDARY )
		{
			++iMainWeaponCount;
		}
		else if ( pWeapon->GetTFWpnData().m_iWeaponType == TF_WPN_TYPE_MELEE )
		{
			pMeleeWeapon = pWeapon;
		}
	}
	if ( pMeleeWeapon && (iMainWeaponCount==0) )
	{
		Weapon_Switch( pMeleeWeapon );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Create and give the named item to the player. Then return it.
//-----------------------------------------------------------------------------
CBaseEntity	*CTFPlayer::GiveNamedItem( const char *pszName, int iSubType, const CEconItemView *pScriptItem, bool bForce )
{
	// We need to support players putting any shotgun into a shotgun slot, pistol into a pistol slot, etc.
	// For legacy reasons, different classes actually spawn different entities for their shotguns/pistols/etc.
	// To deal with this, we translate entities into the right one for the class we're playing.
	if ( !bForce )
	{
		// We don't do this if force is set, since a spy might be disguising as this character, etc.
		pszName = TranslateWeaponEntForClass( pszName, GetPlayerClass()->GetClassIndex() );
	}

	if ( !pszName )
		return NULL;

	// If I already own this type don't create one
	if ( Weapon_OwnsThisType(pszName, iSubType) && !bForce)
	{
		Assert(0);
		return NULL;
	}

	CBaseEntity *pItem = NULL;

	if ( pScriptItem )
	{
		// Generate a weapon directly from that item
		pItem = ItemGeneration()->GenerateItemFromScriptData( pScriptItem, GetLocalOrigin(), vec3_angle, pszName );
	}
	else
	{
		// Generate a base item of the specified type
		CItemSelectionCriteria criteria;
		criteria.SetQuality( AE_NORMAL );
		criteria.BAddCondition( "name", k_EOperator_String_EQ, pszName, true );
		pItem = ItemGeneration()->GenerateRandomItem( &criteria, GetAbsOrigin(), vec3_angle );
	}

	if ( pItem == NULL )
	{
		Msg( "Failed to generate base item: %s\n", pszName );
		return NULL;
	}

	pItem->AddSpawnFlags( SF_NORESPAWN );

	CBaseCombatWeapon *pWeapon = dynamic_cast<CBaseCombatWeapon*>( (CBaseEntity*)pItem );
	if ( pWeapon )
	{
		pWeapon->SetSubType( iSubType );
	}

	DispatchSpawn( pItem );

	if ( pItem != NULL && !(pItem->IsMarkedForDeletion()) ) 
	{
		pItem->Touch( this );
	}

	return pItem;
}

//-----------------------------------------------------------------------------
// Purpose: Destroy all attributes on this player that match the bSetBonuses flag
//-----------------------------------------------------------------------------
void CTFPlayer::RemovePlayerAttributes( bool bSetBonuses )
{
	const int iAttribs = m_AttributeList.GetNumAttributes();
	for ( int i = iAttribs-1; i >= 0; i-- )
	{
		const CEconItemAttribute *pAttrib = m_AttributeList.GetAttribute(i);
		const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinition( pAttrib->GetAttribIndex() );
		if ( !pAttrDef || (pAttrDef->BIsSetBonusAttribute() == bSetBonuses) )
		{
			m_AttributeList.RemoveAttributeByIndex( i );
		}
	}
	GetAttributeManager()->OnAttributeValuesChanged();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ApplySetBonuses( void )
{
	RemovePlayerAttributes( true );

	CUtlVector<const CEconItemSetDefinition *> pActiveSets;
	GetActiveSets( &pActiveSets );

	FOR_EACH_VEC( pActiveSets, set )
	{
		for ( int i = 0; i < pActiveSets[set]->m_iAttributes.Count(); i++ )
		{
			const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinition( pActiveSets[set]->m_iAttributes[i].m_iAttribDefIndex );	
			if ( pAttrDef )
			{
				Assert( pAttrDef->GetAttributeType() );
				Assert( pAttrDef->GetAttributeType()->BSupportsGameplayModificationAndNetworking() );		// is an assert instead of a check because we're in client code here -- this means someone set up a set with bad data
				Assert( pAttrDef->BIsSetBonusAttribute() );

				float flAttrValue = pActiveSets[set]->m_iAttributes[i].m_flValue;
				GetAttributeList()->SetRuntimeAttributeValue( pAttrDef, flAttrValue );
			}
		}
	}
}

#ifdef TF_RAID_MODE
//-----------------------------------------------------------------------------
// Return true if the given entity can be used by a dead Raider
// as a respawn point in Raid mode.
bool IsValidRaidRespawnTarget( CBaseEntity *entity )
{
	if ( !entity->IsPlayer() )
	{
		CObjectSentrygun *pSentry = dynamic_cast< CObjectSentrygun* >( entity );
		if ( pSentry && pSentry->GetTeamNumber() == TF_TEAM_BLUE )
		{
			if ( pSentry->GetOwner() && !pSentry->GetOwner()->IsBot() )
			{
				return true;
			}
		}

		return false;
	}

	if ( entity->GetTeamNumber() != TF_TEAM_BLUE )
		return false;

	CTFPlayer *player = ToTFPlayer( entity );
	CTFBot *bot = ToTFBot( player );
	return !bot || !bot->HasAttribute( CTFBot::IS_NPC );
}
#endif // TF_RAID_MODE

//-----------------------------------------------------------------------------
// Purpose: Find a spawn point for the player.
//-----------------------------------------------------------------------------
CBaseEntity* CTFPlayer::EntSelectSpawnPoint()
{
	CBaseEntity *pSpot = g_pLastSpawnPoints[ GetTeamNumber() ];
	const char *pSpawnPointName = "";

#ifdef TF_RAID_MODE
	if ( TFGameRules()->IsRaidMode() )
	{
		if ( GetTeamNumber() == TF_TEAM_BLUE )
		{
			// only spawn next to friends if the round is not restarting
			if ( TFGameRules()->State_Get() == GR_STATE_RND_RUNNING )
			{
				if ( tf_raid_use_rescue_closets.GetBool() )
				{
					// find a valid rescue closet to spawn into
					CBaseEntity *rescueSpawn = g_pRaidLogic->GetRescueRespawn();

					if ( rescueSpawn )
					{
						return rescueSpawn;
					}
				}
				else if ( tf_boss_battle_respawn_on_friends.GetBool() )
				{
					// the raiders are in the wild - respawn next to them
					float timeSinceInjured = -1.0f;
					CBaseEntity *respawnEntity = NULL;

					// if we are observing a friend, spawn into them
					CBaseEntity *watchEntity = GetObserverTarget();
					if ( watchEntity && IsValidRaidRespawnTarget( watchEntity ) )
					{
						respawnEntity = watchEntity;
					}
					else
					{
						// spawn on the least recently damaged friend
						CTeam *raidingTeam = GetGlobalTeam( TF_TEAM_BLUE );
						for( int i=0; i<raidingTeam->GetNumPlayers(); ++i )
						{
							CTFPlayer *buddy = (CTFPlayer *)raidingTeam->GetPlayer(i);

							// we can't use IsAlive(), because that has already been reset since
							// this code is mid-spawn.  Use m_Shared state instead.
							if ( buddy != this && buddy->m_Shared.InState( TF_STATE_ACTIVE ) && IsValidRaidRespawnTarget( buddy ) )
							{
								// pick the friend who has been hurt least recently
								if ( buddy->GetTimeSinceLastInjury( TF_TEAM_RED ) > timeSinceInjured )
								{
									timeSinceInjured = buddy->GetTimeSinceLastInjury( TF_TEAM_RED );
									respawnEntity = buddy;
								}
							}
						}
					}

					if ( respawnEntity )
					{
						CPVSFilter filter( respawnEntity->GetAbsOrigin() );
						TE_TFParticleEffect( filter, 0.0, "teleported_blue", respawnEntity->GetAbsOrigin(), vec3_angle );
						TE_TFParticleEffect( filter, 0.0, "player_sparkles_blue", respawnEntity->GetAbsOrigin(), vec3_angle, this, PATTACH_POINT );
						return respawnEntity;
					}
				}
			}
		}
	}
#endif // TF_RAID_MODE

	bool bMatchSummary = TFGameRules() && TFGameRules()->ShowMatchSummary();

	// See if the map is asking to force this player to spawn at a specific location
	if ( GetRespawnLocationOverride() && !bMatchSummary )
	{
		if ( SelectSpawnSpotByName( GetRespawnLocationOverride(), pSpot ) )
		{
			m_pSpawnPoint = dynamic_cast< CTFTeamSpawn* >( pSpot );		// Is this even used anymore?
			return pSpot;
		}
		
		// If the entity doesn't exist - or isn't valid - let the regular system handle it
	}

	switch( GetTeamNumber() )
	{
	case TF_TEAM_RED:
	case TF_TEAM_BLUE:
		{
			pSpawnPointName = "info_player_teamspawn";
			if ( SelectSpawnSpotByType( pSpawnPointName, pSpot ) )
			{
				g_pLastSpawnPoints[ GetTeamNumber() ] = pSpot;
			}
			else if ( pSpot )
			{
				int iClass = GetPlayerClass()->GetClassIndex();
				if ( iClass >= 0 && iClass < ARRAYSIZE( g_aPlayerClassNames ) )
				{
					Warning( "EntSelectSpawnPoint(): No valid spawns for class %s on team %i found, even though at least one spawn entity exists.\n", g_aPlayerClassNames[iClass], GetTeamNumber() );
				}
			}

			// need to save this for later so we can apply and modifiers to the armor and grenades...after the call to InitClass()
			m_pSpawnPoint = dynamic_cast<CTFTeamSpawn*>( pSpot );
			break;
		}
	case TEAM_SPECTATOR:
	case TEAM_UNASSIGNED:
	default:
		{
			pSpot = CBaseEntity::Instance( INDEXENT(0) );
			break;		
		}
	}

	if ( !pSpot )
	{
		Warning( "PutClientInServer: no %s on level\n", pSpawnPointName );
		return CBaseEntity::Instance( INDEXENT(0) );
	}

	return pSpot;
} 

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayer::SelectSpawnSpotByType( const char *pEntClassName, CBaseEntity* &pSpot )
{
	bool bMatchSummary = TFGameRules()->ShowMatchSummary();
	CBaseEntity *pMatchSummaryFallback = NULL;

	// Get an initial spawn point.
	pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
	if ( !pSpot )
	{
		// Sometimes the first spot can be NULL????
		pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
	}

	// First we try to find a spawn point that is fully clear. If that fails,
	// we look for a spawn point that's clear except for another players. We
	// don't collide with our team members, so we should be fine.
	bool bIgnorePlayers = false;
	// When dealing with a standard spawn ent, try to obey any class spawn flags
	bool bRestrictByClass = !V_strcmp( pEntClassName, "info_player_teamspawn" );

	CBaseEntity *pFirstSpot = pSpot;
	do 
	{
		if ( pSpot )
		{
			// Check to see if this is a valid team spawn (player is on this team, etc.).
			if ( TFGameRules()->IsSpawnPointValid( pSpot, this, bIgnorePlayers ) )
			{
				// Check for a bad spawn entity.
				if ( pSpot->GetAbsOrigin() == Vector( 0, 0, 0 ) )
				{
					goto next_spawn_point;
				}
				// SpawnFlags were only recently added to the .fgd (Feb 2016), which means older maps won't have any flags at all (they default to on).
				// So this means we only look for restrictions when we find flags, which a map compiled after this change would/should have.
				else if ( bRestrictByClass && pSpot->GetSpawnFlags() )
				{
					int nClass = GetPlayerClass()->GetClassIndex() - 1;
					if ( !pSpot->HasSpawnFlags( ( 1 << nClass ) ) )
					{
						goto next_spawn_point;
					}
				}

				// Found a valid spawn point.
				return true;
			}
		}

	next_spawn_point:;

		// Let's save off a fallback spot for competitive mode
		if ( bMatchSummary && !pMatchSummaryFallback )
		{
			CTFTeamSpawn *pCTFSpawn = dynamic_cast<CTFTeamSpawn*>( pSpot );
			if ( pCTFSpawn )
			{
				if ( ( pCTFSpawn->GetTeamNumber() == pCTFSpawn->GetTeamNumber() ) && ( pCTFSpawn->GetMatchSummaryType() == PlayerTeamSpawn_MatchSummary_None ) )
				{
					pMatchSummaryFallback = pCTFSpawn;
				}
			}
		}

		// Get the next spawning point to check.
		pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );

		// Exhausted the list
		if ( pSpot == pFirstSpot )
		{
			// Loop through again, ignoring class restrictions (but check against players)
			if ( bRestrictByClass )
			{
				bRestrictByClass = false;
				pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
			}
			// Loop through again, ignoring players and classes
			else if ( !bRestrictByClass && !bIgnorePlayers )
			{
				bIgnorePlayers = true;
				pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
			}
		}
	} 
	// Continue until a valid spawn point is found or we hit the start.
	while ( pSpot != pFirstSpot );

	// Return a fallback spot for competitive mode
	if ( bMatchSummary && pMatchSummaryFallback )
	{
		pSpot = pMatchSummaryFallback;
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: We're being asked to use a spawn with a specific name
//-----------------------------------------------------------------------------
bool CTFPlayer::SelectSpawnSpotByName( const char *pEntName, CBaseEntity* &pSpot )
{
	if ( pEntName && pEntName[0] )
	{
		pSpot = gEntList.FindEntityByName( pSpot, pEntName );

		while ( pSpot )
		{
			if ( TFGameRules()->IsSpawnPointValid( pSpot, this, true, PlayerTeamSpawnMode_Triggered ) )
				return true;

			pSpot = gEntList.FindEntityByName( pSpot, pEntName );
		}
	}
	
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
{
	MDLCACHE_CRITICAL_SECTION();

	m_PlayerAnimState->DoAnimationEvent( event, nData );
	TE_PlayerAnimEvent( this, event, nData );	// Send to any clients who can see this guy.
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::HandleAnimEvent( animevent_t *pEvent )
{
	if ( pEvent->event == AE_TAUNT_ENABLE_MOVE )
	{
		m_bAllowMoveDuringTaunt = true;
	}
	else if ( pEvent->event == AE_TAUNT_DISABLE_MOVE )
	{
		m_bAllowMoveDuringTaunt = false;
	}
	else if ( pEvent->event == AE_WPN_HIDE )
	{
		// does nothing for now.
	}
	else
		BaseClass::HandleAnimEvent( pEvent );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PhysObjectSleep()
{
	IPhysicsObject *pObj = VPhysicsGetObject();
	if ( pObj )
		pObj->Sleep();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PhysObjectWake()
{
	IPhysicsObject *pObj = VPhysicsGetObject();
	if ( pObj )
		pObj->Wake();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFPlayer::GetAutoTeam( int nPreferedTeam /*= TF_TEAM_AUTOASSIGN*/ )
{
	int iTeam = TEAM_SPECTATOR;

	CTFTeam *pBlue = TFTeamMgr()->GetTeam( TF_TEAM_BLUE );
	CTFTeam *pRed  = TFTeamMgr()->GetTeam( TF_TEAM_RED );

	if ( pBlue && pRed )
	{
		if ( TFGameRules() )
		{
			if ( TFGameRules()->IsInHighlanderMode() )
			{
				if ( ( pBlue->GetNumPlayers() >= TF_LAST_NORMAL_CLASS - 1 ) &&
					 ( pRed->GetNumPlayers() >= TF_LAST_NORMAL_CLASS - 1 ) )
				{
					// teams are full....join team Spectator for now
					return TEAM_SPECTATOR;
				}
			}

			bool bReturnDefenders = false;

#ifdef TF_RAID_MODE
			if ( TFGameRules()->IsBossBattleMode() )
			{
				bReturnDefenders = true;
			}
#endif // TF_RAID_MODE

			if ( TFGameRules()->IsMannVsMachineMode() )
			{
				bReturnDefenders = true;
			}

			if ( bReturnDefenders )
			{
				// If joining a MVM game that's in-progress, give us the max per-player collected value
				if ( TFGameRules()->IsMannVsMachineMode() && g_pPopulationManager )
				{
					int nRoundCurrency = MannVsMachineStats_GetAcquiredCredits();
					nRoundCurrency += g_pPopulationManager->GetStartingCurrency();

					// Check to see if this player has an upgrade history and apply it to them
					// deduct any cash that has already been spent
					int spentCurrency = g_pPopulationManager->GetPlayerCurrencySpent( this );

					if ( m_nCurrency < nRoundCurrency )
					{
						SetCurrency( nRoundCurrency - spentCurrency );
					}

					if ( g_pPopulationManager )
					{
						// See if the team's earned any respec credits
						if ( TFGameRules()->IsMannVsMachineRespecEnabled() && !g_pPopulationManager->GetNumRespecsAvailableForPlayer( this ) )
						{
							uint16 nRespecs = g_pPopulationManager->GetNumRespecsEarned();
							if ( nRespecs )
							{
								g_pPopulationManager->SetNumRespecsForPlayer( this, nRespecs );
							}
						}

						// Set buyback credits - if they aren't reconnecting
						if ( !g_pPopulationManager->IsPlayerBeingTrackedForBuybacks( this ) )
						{
							g_pPopulationManager->SetBuybackCreditsForPlayer( this, tf_mvm_buybacks_per_wave.GetInt() );
						}
					}
				}

				return TFGameRules()->GetTeamAssignmentOverride( this, TF_TEAM_PVE_DEFENDERS );
			}
		}

		CTFBot *pPlayerBot = dynamic_cast<CTFBot*>( this );
		if ( FStrEq( tf_bot_quota_mode.GetString(), "fill" ) && ( tf_bot_quota.GetInt() > 0 ) && !( pPlayerBot && pPlayerBot->HasAttribute( CTFBot::QUOTA_MANANGED ) ) )
		{
			// We're using 'tf_bot_quota_mode fill' to keep the teams even so balance based on the human players on each team
			int nPlayerCountRed = 0;
			int nPlayerCountBlue = 0;

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

				if ( pPlayer == NULL )
					continue;

				if ( FNullEnt( pPlayer->edict() ) )
					continue;

				if ( !pPlayer->IsConnected() )
					continue;

				if ( !pPlayer->IsPlayer() )
					continue;

				CTFBot* pBot = dynamic_cast<CTFBot*>( pPlayer );
				if ( pBot && pBot->HasAttribute( CTFBot::QUOTA_MANANGED ) )
					continue;

				if ( pPlayer->GetTeamNumber() == TF_TEAM_RED )
				{
					nPlayerCountRed++;
				}
				else if( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
				{
					nPlayerCountBlue++;
				}
			}

			if ( nPlayerCountRed < nPlayerCountBlue )
			{
				iTeam = TF_TEAM_RED;
			}
			else if ( nPlayerCountBlue < nPlayerCountRed )
			{
				iTeam = TF_TEAM_BLUE;
			}
			else if ( TFGameRules()->GetGameType() == TF_GAMETYPE_ESCORT || pRed->GetRole() == TEAM_ROLE_DEFENDERS )
			{
				// AutoTeam should give new players to the attackers on A/D maps if the teams are even
				iTeam = TF_TEAM_BLUE;
			}
			else
			{
				// teams have an even number of human players, pick a random team
				iTeam = RandomInt( 0, 1 ) ? TF_TEAM_RED : TF_TEAM_BLUE;
			}

			bool bKick = false;
			// Now we have a team we want to join to balance the human players, can we join it?
			if ( iTeam == TF_TEAM_RED )
			{
				if ( pBlue->GetNumPlayers() < pRed->GetNumPlayers() )
				{
					bKick = true;
				}
			}
			else
			{
				if ( pRed->GetNumPlayers() < pBlue->GetNumPlayers() )
				{
					bKick = true;
				}
			}

			if ( !bKick || TheTFBots().RemoveBotFromTeamAndKick( iTeam ) )
			{
				return iTeam;
			}

			// If kick needed but failed, fall through to default logic
		}

		if ( pBlue->GetNumPlayers() < pRed->GetNumPlayers() )
		{
			iTeam = TF_TEAM_BLUE;
		}
		else if ( pRed->GetNumPlayers() < pBlue->GetNumPlayers() )
		{
			iTeam = TF_TEAM_RED;
		}
		else if ( TFGameRules()->GetGameType() == TF_GAMETYPE_ESCORT || pRed->GetRole() == TEAM_ROLE_DEFENDERS )
		{
			// AutoTeam should give new players to the attackers on A/D maps if the teams are even
			iTeam = TF_TEAM_BLUE;
		}
		else
		{
			if ( nPreferedTeam == TF_TEAM_AUTOASSIGN )
			{
				iTeam = RandomInt( 0, 1 ) ? TF_TEAM_RED : TF_TEAM_BLUE;
			}
			else
			{
				Assert( nPreferedTeam >= FIRST_GAME_TEAM );
				iTeam = nPreferedTeam;
			}
		}
	}

	return iTeam;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::ShouldForceAutoTeam( void )
{
	if ( mp_forceautoteam.GetBool() )
		return true;

	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
		return true;

	if ( TFGameRules() && TFGameRules()->IsCompetitiveMode() )
		return true;

	bool bForce = false;

	// On official servers, and in normal game modes, see if we should re-assign returning players
	if ( TFGameRules() && TFGameRules()->IsDefaultGameMode() )
	{
		int nTimeSinceLast = TFGameRules()->PlayerHistory_GetTimeSinceLastSeen( this );
		bForce = ( tf_mm_trusted.GetBool() && nTimeSinceLast > 0 && nTimeSinceLast < 60 );
	}

	return bForce;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::HandleCommand_JoinTeam( const char *pTeamName )
{
	if ( TFGameRules()->State_Get() == GR_STATE_GAME_OVER )
		return;

	if ( GetTeamNumber() == TF_TEAM_RED || GetTeamNumber() == TF_TEAM_BLUE )
	{
		const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
		if ( pMatchDesc && !pMatchDesc->m_params.m_bAllowTeamChange )
		{
			ClientPrint( this, HUD_PRINTCENTER, "#TF_Ladder_NoTeamChange" );
			return;
		}
#ifdef STAGING_ONLY
		else if ( TFGameRules()->ArePlayersInHell() )
#else
		else if ( TFGameRules()->ArePlayersInHell() || TFGameRules()->IsPowerupMode() )
#endif // STAGING_ONLY
		{
			ClientPrint( this, HUD_PRINTCENTER, "#TF_CantChangeTeamNow" );
			return;
		}
	}

	bool bAutoTeamed = false;
	bool bArenaSpectator = false;

	int iTeam = TF_TEAM_RED;

	if ( stricmp( pTeamName, "auto" ) == 0 )
	{	
		iTeam = GetAutoTeam();
		bAutoTeamed = true;
	}
	else if ( stricmp( pTeamName, "spectate" ) == 0 )
	{
		iTeam = TEAM_SPECTATOR;
	}
	else if ( stricmp( pTeamName, "spectatearena" ) == 0 )
	{
		iTeam = TEAM_SPECTATOR;

		if ( mp_allowspectators.GetBool() == true )
		{
			bArenaSpectator = true;
		}
	}
	else
	{
		for ( int i = 0; i < TF_TEAM_COUNT; ++i )
		{
			COMPILE_TIME_ASSERT( TF_TEAM_COUNT == ARRAYSIZE( g_aTeamNames ) );
			if ( stricmp( pTeamName, g_aTeamNames[i] ) == 0 )
			{
				iTeam = i;
				break;
			}
		}
	}

	// now check if we're limited in our team selection (unless we want to be on the spectator team)
	if ( !IsBot() && iTeam != TEAM_SPECTATOR )
	{		
		int iHumanTeam = TFGameRules()->GetAssignedHumanTeam();
		if ( iHumanTeam != TEAM_ANY )
		{
			iTeam = iHumanTeam;
			bAutoTeamed = true;
		}
	}
	
	// invalid team selection
	if ( iTeam < TEAM_SPECTATOR )
	{
		return;
	}

	if ( IsCoaching() && ( iTeam != TEAM_SPECTATOR ) )
		return;

#ifdef TF_RAID_MODE
	if ( TFGameRules()->IsRaidMode() )
	{
		if ( !IsBot() && iTeam != TEAM_SPECTATOR )
		{
			// human raiders can only be on the blue team
			CTeam *raidingTeam = GetGlobalTeam( TF_TEAM_BLUE );
			int humanCount = 0;
			for( int i=0; i<raidingTeam->GetNumPlayers(); ++i )
			{
				if ( raidingTeam->GetPlayer(i)->IsBot() )
					continue;

				++humanCount;
			}

			if ( humanCount < tf_raid_team_size.GetInt() )
			{
				iTeam = TF_TEAM_BLUE;
			}
			else
			{
				// no room
				iTeam = TEAM_SPECTATOR;
			}
		}
	}

	if ( TFGameRules()->IsBossBattleMode() )
	{
		if ( !IsBot() && iTeam != TEAM_SPECTATOR )
		{
			// players can only be on the blue team
			if ( GetGlobalTeam( TF_TEAM_BLUE )->GetNumPlayers() < tf_boss_battle_team_size.GetInt() )
			{
				iTeam = TF_TEAM_BLUE;
			}
			else
			{
				// no room
				iTeam = TEAM_SPECTATOR;
			}
		}

		DuelMiniGame_NotifyPlayerChangedTeam( this, iTeam, true );
		ChangeTeam( iTeam, true );

		return;
	}
#endif // TF_RAID_MODE	

	// Some game modes will overrule our player-based logic
	iTeam = TFGameRules()->GetTeamAssignmentOverride( this, iTeam );

	if ( iTeam == TEAM_SPECTATOR || ( TFGameRules()->IsInArenaMode() && tf_arena_use_queue.GetBool() && GetTeamNumber() <= LAST_SHARED_TEAM ) )
	{
		// Prevent this is the cvar is set
		if ( ( mp_allowspectators.GetBool() == false ) && !IsHLTV() && !IsReplay() && TFGameRules()->IsInArenaMode() == false )
		{
			ClientPrint( this, HUD_PRINTCENTER, "#Cannot_Be_Spectator" );
			return;
		}

		// Deny spectator access if it would unbalance the teams
		if ( ( mp_spectators_restricted.GetBool() || tf_mm_trusted.GetBool() ) && TFGameRules() && !TFGameRules()->IsMannVsMachineMode() )
		{
			if ( GetTeamNumber() == TF_TEAM_RED || GetTeamNumber() == TF_TEAM_BLUE )
			{
				CTeam *pRedTeam = GetGlobalTeam( TF_TEAM_RED );
				CTeam *pBlueTeam = GetGlobalTeam( TF_TEAM_BLUE );
				if ( pRedTeam && pBlueTeam )
				{
					int nRedCount = pRedTeam->GetNumPlayers();
					int nBlueCount = pBlueTeam->GetNumPlayers();
					int nGap = GetTeamNumber() == TF_TEAM_RED ? ( nBlueCount - nRedCount ) : ( nRedCount - nBlueCount );
					if ( nGap >= mp_teams_unbalance_limit.GetInt() )
					{
						ClientPrint( this, HUD_PRINTCENTER, "#Cannot_Be_Spectator_Unbalance" );
						return;
					}
				}
			}
		}

		if ( GetTeamNumber() != TEAM_UNASSIGNED && !IsDead() )
		{
			CommitSuicide( false, true );
		}

		m_bArenaSpectator = bArenaSpectator;
		DuelMiniGame_NotifyPlayerChangedTeam( this, TEAM_SPECTATOR, true );
		ChangeTeam( TEAM_SPECTATOR );

		if ( m_bArenaSpectator == true )
		{
			SetDesiredPlayerClassIndex( TF_CLASS_UNDEFINED );
			TFGameRules()->Arena_ClientDisconnect( GetPlayerName() );
			TFGameRules()->RemovePlayerFromQueue( this );
		}

		// do we have fadetoblack on? (need to fade their screen back in)
		if ( mp_fadetoblack.GetBool() )
		{
			color32_s clr = { 0,0,0,255 };
			UTIL_ScreenFade( this, clr, 0, 0, FFADE_IN | FFADE_PURGE );
		}

		if ( TFGameRules()->IsInArenaMode() == true && m_bArenaSpectator == false )
		{
			ShowViewPortPanel( PANEL_CLASS_BLUE );
		}
	}
	else
	{
		if ( iTeam == GetTeamNumber() )
		{
			return;	// we wouldn't change the team
		}

		if ( TFGameRules() && TFGameRules()->IsInHighlanderMode() )
		{
			CTFTeam *pTeam = TFTeamMgr()->GetTeam( iTeam );
			if ( pTeam )
			{
				if ( pTeam->GetNumPlayers() >= TF_LAST_NORMAL_CLASS - 1 )
				{
					// if this join would put too many players on the team in Highlander mode, refuse
					// come up with a better way to tell the player they tried to join a full team!
					ShowViewPortPanel( PANEL_TEAM );
					return;
				}
			}
		}

		// if this join would unbalance the teams, refuse
		// come up with a better way to tell the player they tried to join a full team!
		if ( TFGameRules()->WouldChangeUnbalanceTeams( iTeam, GetTeamNumber() ) )
		{
			ShowViewPortPanel( PANEL_TEAM );
			return;
		}

		DuelMiniGame_NotifyPlayerChangedTeam( this, iTeam, true );
		bool bSilent = TFGameRules() && TFGameRules()->IsPVEModeActive() && IsBot();

#ifndef _DEBUG
		TFGameRules()->SetPlayerReadyState( entindex(), false );
		TFGameRules()->SetTeamReadyState( false, GetTeamNumber() );
#endif // _DEBUG

		ChangeTeam( iTeam, bAutoTeamed, bSilent );

		if ( tf_arena_force_class.GetBool() == false )
		{
			ShowViewPortPanel( ( iTeam == TF_TEAM_RED ) ? PANEL_CLASS_RED : PANEL_CLASS_BLUE );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Join a team without using the game menus
//-----------------------------------------------------------------------------
void CTFPlayer::HandleCommand_JoinTeam_NoMenus( const char *pTeamName )
{
	Assert( IsX360() );

	Msg( "Client command HandleCommand_JoinTeam_NoMenus: %s\n", pTeamName );

	// Only expected to be used on the 360 when players leave the lobby to start a new game
	if ( !IsInCommentaryMode() )
	{
		Assert( GetTeamNumber() == TEAM_UNASSIGNED );
		Assert( IsX360() );
	}

	int iTeam = TEAM_SPECTATOR;
	if ( Q_stricmp( pTeamName, "spectate" ) )
	{
		for ( int i = 0; i < TF_TEAM_COUNT; ++i )
		{
			COMPILE_TIME_ASSERT( TF_TEAM_COUNT == ARRAYSIZE( g_aTeamNames ) );
			if ( stricmp( pTeamName, g_aTeamNames[i] ) == 0 )
			{
				iTeam = i;
				break;
			}
		}
	}

	ForceChangeTeam( iTeam );
}

//-----------------------------------------------------------------------------
// Purpose: Player has been forcefully changed to another team
//-----------------------------------------------------------------------------
void CTFPlayer::ForceChangeTeam( int iTeamNum, bool bFullTeamSwitch )
{
	int iNewTeam = iTeamNum;

	if ( iNewTeam == TF_TEAM_AUTOASSIGN )
	{
		iNewTeam = GetAutoTeam();
	}

	if ( !GetGlobalTeam( iNewTeam ) )
	{
		Warning( "CTFPlayer::ForceChangeTeam( %d ) - invalid team index.\n", iNewTeam );
		return;
	}

	// Some game modes will overrule our player-based logic
	iNewTeam = TFGameRules()->GetTeamAssignmentOverride( this, iNewTeam );

	int iOldTeam = GetTeamNumber();

	// if this is our current team, just abort
	if ( iNewTeam == iOldTeam )
		return;

	// can't change teams if in a duel
	if ( DuelMiniGame_IsInDuel( this ) )
	{
		if ( !m_bIsCoaching )
			return;

		DuelMiniGame_NotifyPlayerChangedTeam( this, iTeamNum, true );
	}

	// can't change teams if coaching
	if ( m_bIsCoaching && m_hStudent != NULL && iTeamNum != TEAM_SPECTATOR )
		return;

	RemoveAllOwnedEntitiesFromWorld( true );
	
	m_iPreviousteam = iOldTeam;
	
	BaseClass::ChangeTeam( iNewTeam, false, true );

	if ( !bFullTeamSwitch )
	{
		RemoveNemesisRelationships();

		if ( TFGameRules() && TFGameRules()->IsInHighlanderMode() )
		{
			if ( IsAlive() )
			{
				CommitSuicide( false, true );
			}

			ResetPlayerClass();
		}
	}
	
	if ( iNewTeam == TEAM_UNASSIGNED )
	{
		StateTransition( TF_STATE_OBSERVER );
	}
	else if ( iNewTeam == TEAM_SPECTATOR )
	{
		StateTransition( TF_STATE_OBSERVER );

		RemoveAllWeapons();
		DestroyViewModels();

		if ( TFGameRules()->IsInArenaMode() == true && tf_arena_use_queue.GetBool() == true )
		{
			TFGameRules()->AddPlayerToQueueHead( this );
		}
	}

	DropFlag();

	// Don't modify living players in any way
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::HandleFadeToBlack( void )
{
	if ( mp_fadetoblack.GetBool() )
	{
		SetObserverMode( OBS_MODE_CHASE );

		color32_s clr = { 0,0,0,255 };
		UTIL_ScreenFade( this, clr, 0.75, 0, FFADE_OUT | FFADE_STAYOUT );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ChangeTeam( int iTeamNum, bool bAutoTeam, bool bSilent, bool bAutoBalance /*= false*/ )
{
	if ( !GetGlobalTeam( iTeamNum ) )
	{
		Warning( "CTFPlayer::ChangeTeam( %d ) - invalid team index.\n", iTeamNum );
		return;
	}

	// game rules don't allow to change team
	if ( TFGameRules() && !TFGameRules()->CanChangeTeam( GetTeamNumber() ) )
	{
		return;
	}

	// Not allowed to change teams when a ghost
	if ( m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
	{
		return;
	}

	// Not allowed to change teams in bumper kart
	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
	{
		return;
	}

	// can only be on TEAM_SPECTATOR when coaching
	if ( IsCoaching() && ( iTeamNum >= FIRST_GAME_TEAM ) )
	{
		return;
	}

	// Some game modes will overrule our player-based logic
	iTeamNum = TFGameRules()->GetTeamAssignmentOverride( this, iTeamNum, bAutoBalance );

	int iOldTeam = GetTeamNumber();

	// if this is our current team, just abort
	if ( iTeamNum == iOldTeam )
		return;

	RemoveAllOwnedEntitiesFromWorld( true );

	bool bNoTeam = GetTeamNumber() == TEAM_UNASSIGNED;

	m_iPreviousteam = iOldTeam;

	CTF_GameStats.Event_TeamChange( this, iOldTeam, iTeamNum );

	m_iTeamChanges++;

	// If joining the underdog team, make next spawn instant (autobalance, paladins)
	if ( TFGameRules() && TFGameRules()->IsDefaultGameMode() && GetTeamNumber() >= FIRST_GAME_TEAM )
	{
		int nStackedTeam, nWeakTeam;
		if ( TFGameRules()->AreTeamsUnbalanced( nStackedTeam, nWeakTeam ) )
		{
			if ( iTeamNum == nWeakTeam )
			{
				AllowInstantSpawn();
			}
		}
	}

	BaseClass::ChangeTeam( iTeamNum, bAutoTeam, bSilent, bAutoBalance );

	if ( TFGameRules() && TFGameRules()->IsInHighlanderMode() )
	{
		if ( IsAlive() )
		{
			CommitSuicide( false, true );
		}

		ResetPlayerClass();
	}

	RemoveNemesisRelationships();

	if ( iTeamNum == TEAM_UNASSIGNED )
	{
		StateTransition( TF_STATE_OBSERVER );
	}
	else if ( iTeamNum == TEAM_SPECTATOR )
	{
		StateTransition( TF_STATE_OBSERVER );

		RemoveAllWeapons();
		DestroyViewModels();

		if ( TFGameRules()->IsInArenaMode() == true && bNoTeam == false && tf_arena_use_queue.GetBool() == true )
		{
			TFGameRules()->AddPlayerToQueue( this );
		}
	}
	else // active player
	{
		bool bKill = true;

#ifdef STAGING_ONLY
		bKill = ( m_Shared.InCond( TF_COND_REPROGRAMMED ) ) ?  false : true;
#endif // STAGING_ONLY

		if ( bKill && !IsDead() && (iOldTeam == TF_TEAM_RED || iOldTeam == TF_TEAM_BLUE) )
		{
			// Kill player if switching teams while alive
			CommitSuicide( false, true );
		}
		else if ( IsDead() && iOldTeam < FIRST_GAME_TEAM )
		{
			HandleFadeToBlack();
		}

		// let any spies disguising as me know that I've changed teams
		for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
		{
			CTFPlayer *pTemp = ToTFPlayer( UTIL_PlayerByIndex( i ) );
			if ( pTemp && pTemp != this )
			{
				if ( ( pTemp->m_Shared.GetDisguiseTarget() == this ) || // they were disguising as me and I've changed teams
 					 ( !pTemp->m_Shared.GetDisguiseTarget() && pTemp->m_Shared.GetDisguiseTeam() == iTeamNum ) ) // they don't have a disguise and I'm joining the team they're disguising as
				{
					// choose someone else...
					pTemp->m_Shared.FindDisguiseTarget();
				}
			}
		}
	}
	
	m_Shared.RemoveAllCond();
	DuelMiniGame_NotifyPlayerChangedTeam( this, iTeamNum, false );

#ifdef STAGING_ONLY
	if ( TFGameRules() && TFGameRules()->GameModeUsesExperience() )
	{
		RefundExperiencePoints();
	}
#endif // STAGING_ONLY
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ResetPlayerClass( void )
{
	if ( GetPlayerClass() )
	{
		GetPlayerClass()->Reset();
	}

	SetDesiredPlayerClassIndex( TF_CLASS_UNDEFINED );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::HandleCommand_JoinClass( const char *pClassName, bool bAllowSpawn /* = true */ )
{
	VPROF_BUDGET( "CTFPlayer::HandleCommand_JoinClass", VPROF_BUDGETGROUP_PLAYER );
	if ( TFGameRules()->State_Get() == GR_STATE_GAME_OVER )
	{
		return;
	}

// 	if ( TFGameRules()->ArePlayersInHell() && ( m_Shared.m_iDesiredPlayerClass > TF_CLASS_UNDEFINED ) )
// 	{
// 		ClientPrint( this, HUD_PRINTCENTER, "#TF_CantChangeClassNow" );
// 		return;
// 	}

	if ( TFGameRules()->IsCompetitiveMode() )
	{
		if ( !tf_tournament_classchange_allowed.GetBool() && 
			 TFGameRules()->State_Get() == GR_STATE_RND_RUNNING )
		{
			ClientPrint( this, HUD_PRINTCENTER, "#TF_Ladder_NoClassChangeRound" );
			return;
		}

		if ( !tf_tournament_classchange_ready_allowed.GetBool() && 
			 TFGameRules()->State_Get() == GR_STATE_BETWEEN_RNDS && 
			 TFGameRules()->IsPlayerReady( entindex() ) )
		{
			ClientPrint( this, HUD_PRINTCENTER, "#TF_Ladder_NoClassChangeReady" );
			return;
		}
	}

	if ( IsCoaching() )
		return;

	// can only join a class after you join a valid team
	if ( GetTeamNumber() <= LAST_SHARED_TEAM && TFGameRules()->IsInArenaMode() == false )
		return;

	// In case we don't get the class menu message before the spawn timer
	// comes up, fake that we've closed the menu.
	SetClassMenuOpen( false );

	if ( TFGameRules()->InStalemate() && TFGameRules()->IsInArenaMode() == false )
	{
		if ( IsAlive() && !TFGameRules()->CanChangeClassInStalemate() )
		{
			char szTime[6];
			Q_snprintf( szTime, sizeof( szTime ), "%d", tf_stalematechangeclasstime.GetInt() );
	
			ClientPrint( this, HUD_PRINTTALK, "#game_stalemate_cant_change_class", szTime );
			return;
		}
	}

	if ( TFGameRules()->IsInArenaMode() == true && IsAlive() == true )
	{
		if ( GetTeamNumber() > LAST_SHARED_TEAM && TFGameRules()->InStalemate() == true ) 
		{
			ClientPrint( this, HUD_PRINTTALK, "#TF_Arena_NoClassChange" );
			return;
		}
	}

#ifdef TF_RAID_MODE
	if ( TFGameRules()->IsRaidMode() && GetTeamNumber() == TF_TEAM_BLUE && !tf_raid_allow_class_change.GetBool() )
	{
		CTFNavArea *area = (CTFNavArea *)GetLastKnownArea();

		if ( area && !area->HasAttributeTF( TF_NAV_SPAWN_ROOM_BLUE ) )
		{
			ClientPrint( this, HUD_PRINTTALK, "No class changes after leaving the safe room" );
			return;
		}
	}
#endif // TF_RAID_MODE

	if ( TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_DEFENDERS )
	{
		if ( m_nCanPurchaseUpgradesCount > 0 )
		{
			ClientPrint( this, HUD_PRINTCENTER, "#TF_MVM_NoClassUpgradeUI" );
			return;
		}

		if ( IsReadyToPlay() && !TFGameRules()->InSetup() && g_pPopulationManager && !g_pPopulationManager->IsInEndlessWaves() )
		{
			ClientPrint( this, HUD_PRINTTALK, "#TF_MVM_NoClassChangeAfterSetup" );
			return;
		}
	}

	int iClass = TF_CLASS_UNDEFINED;
	bool bShouldNotRespawn = false;

	if ( !bAllowSpawn || ( ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN ) && ( TFGameRules()->GetWinningTeam() != GetTeamNumber() ) ) )
	{
		m_bAllowInstantSpawn = false;
		bShouldNotRespawn = true;
	}

	if ( stricmp( pClassName, "random" ) != 0 && stricmp( pClassName, "auto" ) != 0 )
	{
		int i = 0;

		for ( i = TF_CLASS_SCOUT ; i < TF_CLASS_COUNT_ALL ; i++ )
		{
			if ( stricmp( pClassName, GetPlayerClassData( i )->m_szClassName ) == 0 )
			{
				iClass = i;
				break;
			}
		}
		 
		bool bCivilianOkay = false;

		if ( !bCivilianOkay && ( i >= TF_LAST_NORMAL_CLASS ) )
		{
			Warning( "HandleCommand_JoinClass( %s ) - invalid class name.\n", pClassName );
			return;
		}

		// Check class limits
		if ( !TFGameRules()->CanPlayerChooseClass(this, iClass) )
		{
			ShowViewPortPanel( ( GetTeamNumber() == TF_TEAM_RED ) ? PANEL_CLASS_RED : PANEL_CLASS_BLUE );
			return;
		}
	}
	else
	{
		int iTries = 20;
		// The player has selected Random class...so let's pick one for them.
		do{
			// Don't let them be the same class twice in a row
			iClass = random->RandomInt( TF_FIRST_NORMAL_CLASS, TF_LAST_NORMAL_CLASS - 1 ); // -1 to remove the civilian from the randomness
			iTries--;
		} while( iClass == GetPlayerClass()->GetClassIndex() || (iTries > 0 && !TFGameRules()->CanPlayerChooseClass(this,iClass)) );

		if ( iTries <= 0 )
		{
			// We failed to find a random class. Bring up the class menu again.
			ShowViewPortPanel( ( GetTeamNumber() == TF_TEAM_RED ) ? PANEL_CLASS_RED : PANEL_CLASS_BLUE );
			return;
		}
	}

	if ( TFGameRules() && TFGameRules()->State_Get() == GR_STATE_RND_RUNNING )
	{
		// Bit field of classes played during the game
		CSteamID steamID;
		GetSteamID( &steamID );

		CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
		if ( pMatch )
		{
			CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( steamID );
			if ( pMatchPlayer )
			{
				pMatchPlayer->UpdateClassesPlayed( GetPlayerClass()->GetClassIndex() );
			}
		}
	}

#if defined( _DEBUG ) || defined( STAGING_ONLY )
	if ( mp_developer.GetBool() && !IsBot() )
	{
		Vector vPos = GetAbsOrigin();
		QAngle qAngle = GetAbsAngles();
		SetDesiredPlayerClassIndex( iClass );
		ForceRespawn();
		Teleport( &vPos, &qAngle, &vec3_origin );
		return;
	}
#endif // _DEBUG || STAGING_ONLY

	// joining the same class?
	if ( iClass != TF_CLASS_RANDOM && iClass == GetDesiredPlayerClassIndex() )
	{
		// If we're dead, and we have instant spawn, respawn us immediately. Catches the case
		// were a player misses respawn wave because they're at the class menu, and then changes
		// their mind and reselects their current class.
		if ( m_bAllowInstantSpawn && !IsAlive() )
		{
			ForceRespawn();
		}
		return;
	}

	if ( TFGameRules()->IsInArenaMode() && tf_arena_use_queue.GetBool() == true && GetTeamNumber() <= LAST_SHARED_TEAM )
	{
		TFGameRules()->AddPlayerToQueue( this );
	}

	// @note Tom Bui: we need to restrict the UI somehow
	// if there's a class restriction on duels...
	int iDuelClass = DuelMiniGame_GetRequiredPlayerClass( this );
	if ( iDuelClass >= TF_FIRST_NORMAL_CLASS && iDuelClass < TF_LAST_NORMAL_CLASS )
	{
		iClass = iDuelClass;
	}

	SetDesiredPlayerClassIndex( iClass );
	IGameEvent * event = gameeventmanager->CreateEvent( "player_changeclass" );
	if ( event )
	{
		event->SetInt( "userid", GetUserID() );
		event->SetInt( "class", iClass );

		gameeventmanager->FireEvent( event );
	}

	// are they TF_CLASS_RANDOM and trying to select the class they're currently playing as (so they can stay this class)?
	if ( iClass == GetPlayerClass()->GetClassIndex() )
	{
		// If we're dead, and we have instant spawn, respawn us immediately. Catches the case
		// were a player misses respawn wave because they're at the class menu, and then changes
		// their mind and reselects their current class.
		if ( m_bAllowInstantSpawn && !IsAlive() )
		{
			ForceRespawn();
		}
		return;
	}

	// We can respawn instantly if:
	//	- We're dead, and we're past the required post-death time
	//	- We're inside a respawn room
	//	- We're in the stalemate grace period
	bool bInRespawnRoom = PointInRespawnRoom( this, WorldSpaceCenter() );
	if ( bInRespawnRoom && !IsAlive() )
	{
		// If we're not spectating ourselves, ignore respawn rooms. Otherwise we'll get instant spawns
		// by spectating someone inside a respawn room.
		bInRespawnRoom = (GetObserverTarget() == this);
	}
	bool bDeadInstantSpawn = !IsAlive();
	if ( bDeadInstantSpawn && m_flDeathTime )
	{
		// In death mode, don't allow class changes to force respawns ahead of respawn waves
		float flWaveTime = TFGameRules()->GetNextRespawnWave( GetTeamNumber(), this );
		bDeadInstantSpawn = (gpGlobals->curtime > flWaveTime);
	}
	bool bInStalemateClassChangeTime = false;
	if ( TFGameRules()->InStalemate() && TFGameRules()->IsInWaitingForPlayers() == false )
	{
		// Stalemate overrides respawn rules. Only allow spawning if we're in the class change time.
		bInStalemateClassChangeTime = TFGameRules()->CanChangeClassInStalemate();
		bDeadInstantSpawn = false;
		bInRespawnRoom = false;
	}

	if ( TFGameRules()->IsInArenaMode() == true )
	{
		if ( TFGameRules()->IsInWaitingForPlayers() == false )
		{
			bDeadInstantSpawn = false;

			if ( TFGameRules()->InStalemate() == false && TFGameRules()->State_Get() != GR_STATE_TEAM_WIN  )
			{
				bInRespawnRoom = true;
				bShouldNotRespawn = false;
			}
			else
			{
				bShouldNotRespawn = true;
				
				 if ( tf_arena_use_queue.GetBool() == false )
					return;
			}
		}
		else if ( tf_arena_use_queue.GetBool() == false )
		{
			return;
		}
	}

	if ( TFGameRules()->IsMannVsMachineMode() && TFGameRules()->State_Get() == GR_STATE_BETWEEN_RNDS )
		m_bAllowInstantSpawn = true;

	if ( bShouldNotRespawn == false && ( m_bAllowInstantSpawn || bDeadInstantSpawn || bInRespawnRoom || bInStalemateClassChangeTime ) )
	{
		ForceRespawn();

#ifdef STAGING_ONLY
		if ( TFGameRules() && TFGameRules()->GameModeUsesExperience() )
		{
			RefundExperiencePoints();
		}
#endif // STAGING_ONLY

		return;
	}

	if( iClass == TF_CLASS_RANDOM )
	{
		if( IsAlive() )
		{
			ClientPrint(this, HUD_PRINTTALK, "#game_respawn_asrandom" );
		}
		else
		{
			ClientPrint(this, HUD_PRINTTALK, "#game_spawn_asrandom" );
		}
	}
	else
	{
		if( IsAlive() )
		{
			ClientPrint(this, HUD_PRINTTALK, "#game_respawn_as", GetPlayerClassData( iClass )->m_szLocalizableName );
		}
		else
		{
			ClientPrint(this, HUD_PRINTTALK, "#game_spawn_as", GetPlayerClassData( iClass )->m_szLocalizableName );
		}
	}

	if ( IsAlive() && ( GetHudClassAutoKill() == true ) && bShouldNotRespawn == false )
	{
		CommitSuicide( false, true );
	}

#ifdef STAGING_ONLY
	if ( TFGameRules() && TFGameRules()->GameModeUsesExperience() )
	{
		SetExperiencePoints( 0 );
		SetCurrency( 0 );
		SetExperienceLevel( 1 );
	}
#endif // STAGING_ONLY
}

//-----------------------------------------------------------------------------
// Purpose: The GC has told us this player wants to respawn now that their loadout has changed.
//-----------------------------------------------------------------------------
void CTFPlayer::CheckInstantLoadoutRespawn( void )
{
	// Must be alive
	if ( !IsAlive() )
		return;

	// In a respawn room
	if ( !PointInRespawnRoom( this, WorldSpaceCenter() ) )
		return;
	
	// Not in stalemate (beyond the change class period)
	if ( TFGameRules()->InStalemate() && !TFGameRules()->CanChangeClassInStalemate() )
		return;

	// Not in Arena mode
	if ( TFGameRules()->IsInArenaMode() == true )
		return;

	// Not if we're on the losing team
	if ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN && TFGameRules()->GetWinningTeam() != GetTeamNumber() ) 
		return;

	// Not if our current class's loadout hasn't changed
	int iClass = GetPlayerClass() ? GetPlayerClass()->GetClassIndex() : TF_CLASS_UNDEFINED;
	if ( iClass >= TF_FIRST_NORMAL_CLASS && iClass < TF_LAST_NORMAL_CLASS )
	{
		if ( m_Inventory.ClassLoadoutHasChanged( iClass ) )
		{
			if ( m_Shared.InCond( TF_COND_AIMING ) )
			{
				// If we are in condition TF_COND_AIMING it will be removed during the ForceRespawn() so we need to reset the weapon
				// (which is normally skipped while regenerating)...this only affects the Minigun and the Sniper Rifle.
				CTFWeaponBase *pWeapon = GetActiveTFWeapon();
				if ( pWeapon )
				{
					if ( IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) || WeaponID_IsSniperRifle( pWeapon->GetWeaponID() ) )
					{
						pWeapon->WeaponReset();
					}
				}
			}

			if ( IsPlayerClass( TF_CLASS_MEDIC ) )
			{
				CWeaponMedigun *pMedigun = dynamic_cast< CWeaponMedigun* >( GetActiveTFWeapon() );
				if ( pMedigun )
				{
					pMedigun->Lower();
				}
			}

			// We want to use ForceRespawn() here so the player is physically moved back
			// into the spawn room and not just regenerated instantly in the doorway
			ForceRegenerateAndRespawn();
		}
	}
}

class CGC_RespawnPostLoadoutChange : public GCSDK::CGCClientJob
{
public:
	CGC_RespawnPostLoadoutChange( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		GCSDK::CGCMsg<MsgGCRespawnPostLoadoutChange_t> msg( pNetPacket );
		CSteamID steamID = msg.Body().m_ulInitiatorSteamID;

		// Find the player with this steamID
		CSteamID tmpID;
		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
		{
			CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
			if ( !pPlayer )
				continue;
			if ( !pPlayer->GetSteamID( &tmpID ) )
				continue;

			if ( tmpID == steamID )
			{
				pPlayer->CheckInstantLoadoutRespawn();
				break;
			}
		}

		return true;
	}
};
GC_REG_JOB( GCSDK::CGCClient, CGC_RespawnPostLoadoutChange, "CGC_RespawnPostLoadoutChange", k_EMsgGCRespawnPostLoadoutChange, GCSDK::k_EServerTypeGCClient );

#if defined (_DEBUG)
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static void DebugEconItemView( const char *pszDescStr, CEconItemView *pEconItemView )
{
	if ( !pEconItemView )
		return;

	const GameItemDefinition_t *pItemDef = pEconItemView->GetItemDefinition();
	Assert( pItemDef );

	Warning("%s: \"%s\"\n", pszDescStr, pItemDef->GetDefinitionName() );
}
#endif

bool CTFPlayer::ClientCommand( const CCommand &args )
{
	const char *pcmd = args[0];
	
	m_flLastAction = gpGlobals->curtime;

	if ( FStrEq( pcmd, "addcond" ) )
	{
		if ( sv_cheats->GetBool() && args.ArgC() >= 2 )
		{
			ETFCond eCond = (ETFCond)clamp( atoi( args[1] ), 0, TF_COND_LAST-1 );

			CTFPlayer *pTargetPlayer = this;
			if ( args.ArgC() >= 4 )
			{
				// Find the matching netname
				for ( int i = 1; i <= gpGlobals->maxClients; i++ )
				{
					CBasePlayer *pPlayer = ToBasePlayer( UTIL_PlayerByIndex(i) );
					if ( pPlayer )
					{
						if ( Q_strstr( pPlayer->GetPlayerName(), args[3] ) )
						{
							pTargetPlayer = ToTFPlayer(pPlayer);
							break;
						}
					}
				}
			}

			if ( args.ArgC() >= 3 )
			{
				float flDuration = atof( args[2] );
				pTargetPlayer->m_Shared.AddCond( eCond, flDuration );
			}
			else
			{
				pTargetPlayer->m_Shared.AddCond( eCond );
			}
		}
		return true;
	}
	else if ( FStrEq( pcmd, "removecond" ) )
	{
		if ( sv_cheats->GetBool() && args.ArgC() >= 2 )
		{
			CTFPlayer *pTargetPlayer = this;
			if ( args.ArgC() >= 3 )
			{
				// Find the matching netname
				for ( int i = 1; i <= gpGlobals->maxClients; i++ )
				{
					CBasePlayer *pPlayer = ToBasePlayer( UTIL_PlayerByIndex(i) );
					if ( pPlayer )
					{
						if ( Q_strstr( pPlayer->GetPlayerName(), args[2] ) )
						{
							pTargetPlayer = ToTFPlayer(pPlayer);
							break;
						}
					}
				}
			}

			ETFCond eCond = (ETFCond)clamp( atoi( args[1] ), 0, TF_COND_LAST-1 );
			pTargetPlayer->m_Shared.RemoveCond( eCond );
		}
		return true;
	}
#ifdef _DEBUG
	else if ( FStrEq( pcmd, "burn" ) ) 
	{
		m_Shared.Burn( this, GetActiveTFWeapon() );
		return true;
	}
	else if ( FStrEq( pcmd, "bleed" ) )
	{
		m_Shared.MakeBleed( this, GetActiveTFWeapon(), 10.0f );
		return true;
	}
	else if ( FStrEq( pcmd, "dump_damagers" ) )
	{
		m_AchievementData.DumpDamagers();
		return true;
	}
	else if ( FStrEq( pcmd, "stun" ) )
	{
		if ( args.ArgC() >= 4 )
		{
			m_Shared.StunPlayer( atof(args[1]), atof(args[2]), atof(args[3]) );
		}
		return true;
	}
// 	else if ( FStrEq( pcmd, "decoy" ) )
// 	{
// 		CBotNPCDecoy *decoy = (CBotNPCDecoy *)CreateEntityByName( "bot_npc_decoy" );
// 		if ( decoy )
// 		{
// 			decoy->SetOwnerEntity( this );
// 			DispatchSpawn( decoy );
// 		}
// 		return true;
// 	}
	else if ( FStrEq( pcmd, "tada" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			Taunt( TAUNT_SHOW_ITEM );
		}
		return true;
	}
//	else if ( FStrEq( pcmd, "player_disguise" ) )
//	{
//		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByName( args[1] ) );
//		pPlayer->m_Shared.Disguise( Q_atoi( args[2] ), Q_atoi( args[3] ) );
//		return true;
//	}
	else
#endif

	if ( FStrEq( pcmd, "jointeam" ) )
	{
		// don't let them spam the server with changes
		if ( GetNextChangeTeamTime() > gpGlobals->curtime )
			return true;

		SetNextChangeTeamTime( gpGlobals->curtime + 2.0f );  // limit to one change every 2 secs

		if ( args.ArgC() >= 2 )
		{
			HandleCommand_JoinTeam( args[1] );
		}
		return true;
	}
	else if ( FStrEq( pcmd, "jointeam_nomenus" ) )
	{
		if ( IsX360() )
		{
			if ( args.ArgC() >= 2 )
			{
				HandleCommand_JoinTeam_NoMenus( args[1] );
			}
			return true;
		}
		return false;
	}
	else if ( FStrEq( pcmd, "closedwelcomemenu" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			if ( GetTeamNumber() == TEAM_UNASSIGNED )
			{
				if ( ShouldForceAutoTeam() )
				{
					ChangeTeam( GetAutoTeam(), true, false );
					ShowViewPortPanel( ( GetTeamNumber() == TF_TEAM_BLUE ) ? PANEL_CLASS_BLUE : PANEL_CLASS_RED );
				}
				else
				{
					ShowViewPortPanel( PANEL_TEAM, true );
				}
			}
			else if ( IsPlayerClass( TF_CLASS_UNDEFINED ) )
			{
				if ( tf_arena_force_class.GetBool() == false )
				{
					switch( GetTeamNumber() )
					{
					case TF_TEAM_RED:
						ShowViewPortPanel( PANEL_CLASS_RED, true );
						break;

					case TF_TEAM_BLUE:
						ShowViewPortPanel( PANEL_CLASS_BLUE, true );
						break;

					default:
						break;
					}
				}
			}
		}
		return true;
	}
	else if ( FStrEq( pcmd, "joinclass" ) ) 
	{
		// don't let them spam the server with changes
		if ( GetNextChangeClassTime() > gpGlobals->curtime )
			return true;

		SetNextChangeClassTime( gpGlobals->curtime + 0.5 );  // limit to one change every 0.5 secs

		if ( tf_arena_force_class.GetBool() == false )
		{
			if ( args.ArgC() >= 2 )
			{
				HandleCommand_JoinClass( args[1] );
			}
		}
		return true;
	}
	else if ( FStrEq( pcmd, "resetclass" ) )
	{
		if ( TFGameRules() && TFGameRules()->IsInHighlanderMode() && ( GetTeamNumber() > LAST_SHARED_TEAM ) )
		{
			if ( IsAlive() )
			{
				CommitSuicide( false, true );
			}

			ResetPlayerClass();
			ShowViewPortPanel( ( GetTeamNumber() == TF_TEAM_RED ) ? PANEL_CLASS_RED : PANEL_CLASS_BLUE );
		}

		return true;
	}
	else if ( FStrEq( pcmd, "mp_playgesture" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			if ( args.ArgC() == 1 )
			{
				Warning( "mp_playgesture: Gesture activity or sequence must be specified!\n" );
				return true;
			}

			if ( sv_cheats->GetBool() )
			{
				if ( !PlayGesture( args[1] ) )
				{
					Warning( "mp_playgesture: unknown sequence or activity name \"%s\"\n", args[1] );
					return true;
				}
			}
		}
		return true;
	}
	else if ( FStrEq( pcmd, "mp_playanimation" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			if ( args.ArgC() == 1 )
			{
				Warning( "mp_playanimation: Activity or sequence must be specified!\n" );
				return true;
			}

			if ( sv_cheats->GetBool() )
			{
				if ( !PlaySpecificSequence( args[1] ) )
				{
					Warning( "mp_playanimation: Unknown sequence or activity name \"%s\"\n", args[1] );
					return true;
				}
			}
		}
		return true;
	}
	else if ( FStrEq( pcmd, "menuopen" ) )
	{
		SetClassMenuOpen( true );
		return true;
	}
	else if ( FStrEq( pcmd, "menuclosed" ) )
	{
		SetClassMenuOpen( false );
		return true;
	}
	else if ( FStrEq( pcmd, "pda_click" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			// player clicked on the PDA, play attack animation
			CTFWeaponBase *pWpn = GetActiveTFWeapon();
			CTFWeaponPDA *pPDA = dynamic_cast<CTFWeaponPDA *>( pWpn );

			if ( pPDA && !m_Shared.InCond( TF_COND_DISGUISED ) )
			{
				DoAnimationEvent( PLAYERANIMEVENT_ATTACK_PRIMARY );
			}
		}
		return true;
	}
	else if ( FStrEq( pcmd, "weapon_taunt" ) || FStrEq( pcmd, "taunt" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			int iTauntSlot = args.ArgC() == 2 ? atoi( args[1] ) : 0;
			HandleTauntCommand( iTauntSlot );
		}
		return true;
	}
	else if ( FStrEq( pcmd, "stop_taunt" ) )
	{
		if( m_Shared.GetTauntIndex() == TAUNT_LONG && !m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
		{
			EndLongTaunt();
		}

		return true;
	}
	else if ( FStrEq( pcmd, "-taunt" ) )
	{
		// DO NOTHING
		// We changed taunt key to be press to toggle instead of press and hold to do long taunt
		return true;
	}
	else if ( FStrEq( pcmd, "td_buyback" ) )
	{
		if ( TFGameRules() && TFGameRules()->IsPVEModeActive() && IsObserver() && ( GetTeamNumber() > TEAM_SPECTATOR ) )
		{
			// Make sure we're not still in freezecam
			int iObsMode = GetObserverMode();
			if ( iObsMode == OBS_MODE_FREEZECAM || iObsMode == OBS_MODE_DEATHCAM )
				return true;

			float flWaveTime = TFGameRules()->GetNextRespawnWave( GetTeamNumber(), this );

			bool bSuccess = false;
			int iRespawnWait = (flWaveTime - gpGlobals->curtime);
			int iCost = iRespawnWait * MVM_BUYBACK_COST_PER_SEC;

			// New system (finite buybacks per-wave, not currency-based)
			if ( tf_mvm_buybacks_method.GetBool() )
			{
				if ( g_pPopulationManager->GetNumBuybackCreditsForPlayer( this ) )
				{
					bSuccess = true;
					iCost = 1;
					g_pPopulationManager->RemoveBuybackCreditFromPlayer( this );
				}
			}
			// Old system (currency-based)
			else
			{
				if ( GetCurrency() >= iCost )
				{
					bSuccess = true;
					RemoveCurrency( iCost );
					MannVsMachineStats_PlayerEvent_BoughtInstantRespawn( this, iCost );
				}
			}

			if ( bSuccess )
			{
				ForceRespawn();
				IGameEvent *event = gameeventmanager->CreateEvent( "player_buyback" );
				if ( event )
				{
					event->SetInt( "player", entindex() );
					event->SetInt( "cost", iCost );
					gameeventmanager->FireEvent( event );
				}
			}
			else
			{
				CSingleUserRecipientFilter filter( this );
				EmitSound_t params;
				params.m_pSoundName = "Player.DenyWeaponSelection";
				EmitSound( filter, entindex(), params );
			}
		}
		return true;
	}
	else if ( FStrEq( pcmd, "build" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			if ( TFGameRules()->InStalemate() && mp_stalemate_meleeonly.GetBool() )
				return true;

			// can't issue a build command while carrying an object
			if ( m_Shared.IsCarryingObject() )
				return true;

			if ( IsTaunting() )
				return true;

			int iBuilding = 0;
			int iMode = 0;
			bool bArgsChecked = false;

			// Fixup old binds.
			if ( args.ArgC() == 2 )
			{
				iBuilding = atoi( args[ 1 ] );
				if ( iBuilding == 3 ) // Teleport exit is now a mode.
				{
					iBuilding = 1;
					iMode = 1;
				}
				bArgsChecked = true;
			}
			else if ( args.ArgC() == 3 )
			{
				iBuilding = atoi( args[ 1 ] );
				iMode = atoi( args[ 2 ] );
				bArgsChecked = true;
			}

			if ( bArgsChecked )
			{
				StartBuildingObjectOfType( iBuilding, iMode );
			}
			else
			{
				Warning( "Usage: build <building> <mode>\n" );
			}
		}
		return true;
	}
	else if ( FStrEq( pcmd, "destroy" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			if ( IsPlayerClass( TF_CLASS_ENGINEER ) ) // Spies can't destroy buildings (sappers)
			{
				int iBuilding = 0;
				int iMode = 0;
				bool bArgsChecked = false;

				// Fixup old binds.
				if ( args.ArgC() == 2 )
				{
					iBuilding = atoi( args[ 1 ] );
					if ( iBuilding == 3 ) // Teleport exit is now a mode.
					{
						iBuilding = 1;
						iMode = 1;
					}
					bArgsChecked = true;
				}
				else if ( args.ArgC() == 3 )
				{
					iBuilding = atoi( args[ 1 ] );
					iMode = atoi( args[ 2 ] );
					bArgsChecked = true;
				}

				if ( bArgsChecked )
				{
					DetonateObjectOfType( iBuilding, iMode );
				}
				else
				{
					Warning( "Usage: destroy <building> <mode>\n" );
				}
			}
		}
		return true;
	}
	else if ( FStrEq( pcmd, "eureka_teleport" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			CTFWeaponBase* pWeapon = GetActiveTFWeapon();
			if ( !pWeapon )
				return true;

			if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
				return true;

			int iAltFireTeleportToSpawn = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iAltFireTeleportToSpawn, alt_fire_teleport_to_spawn );

			if ( IsPlayerClass( TF_CLASS_ENGINEER ) && iAltFireTeleportToSpawn )
			{
				if ( args.ArgC() == 2 )
				{
					m_eEurekaTeleportTarget = (eEurekaTeleportTargets)atoi( args[1] );
				}
				else
				{
					m_eEurekaTeleportTarget = EUREKA_TELEPORT_HOME;
				}

				// Do the Eureka Effect teleport taunt
				Taunt( TAUNT_SPECIAL, MP_CONCEPT_TAUNT_EUREKA_EFFECT_TELEPORT );
			}
		}
	}
	else if ( FStrEq( pcmd, "arena_changeclass" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			if ( TFGameRules() && TFGameRules()->IsInArenaMode() && ( tf_arena_force_class.GetBool() == true ) )
			{
				if ( TFGameRules()->State_Get() == GR_STATE_PREROUND )
				{
					if ( m_Shared.GetArenaNumChanges() < tf_arena_change_limit.GetInt() )
					{
						CommitSuicide( true, false );
						m_Shared.IncrementArenaNumChanges();
					}
				}
			}
		}
		return true;
	}
	else if ( FStrEq( pcmd, "extendfreeze" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			m_flDeathTime += 2.0f;
		}
		return true;
	}
	else if ( FStrEq( pcmd, "show_motd" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			if ( ShouldForceAutoTeam() )
			{
				int nPreferedTeam = TF_TEAM_AUTOASSIGN;
				PlayerHistoryInfo_t *pPlayerInfo = ( TFGameRules() ) ? TFGameRules()->PlayerHistory_GetPlayerInfo( this ) : NULL;
				if ( pPlayerInfo && pPlayerInfo->nTeam >= FIRST_GAME_TEAM )
				{
					nPreferedTeam = pPlayerInfo->nTeam;
				}

				int iTeam = GetAutoTeam( nPreferedTeam );
				ChangeTeam( iTeam, true, false );
				ShowViewPortPanel( ( iTeam == TF_TEAM_RED ) ? PANEL_CLASS_RED : PANEL_CLASS_BLUE );
			}
#ifdef TF_RAID_MODE
			else if ( TFGameRules()->IsBossBattleMode() )
			{
				int iTeam = GetAutoTeam();
				ChangeTeam( iTeam, true );
				ShowViewPortPanel( ( iTeam == TF_TEAM_RED ) ? PANEL_CLASS_RED : PANEL_CLASS_BLUE );
			}
#endif
			else
			{
				ShowViewPortPanel( PANEL_TEAM, false );
			}
			ShowViewPortPanel( PANEL_ARENA_TEAM, false );

			char pszWelcome[128];
			Q_snprintf( pszWelcome, sizeof(pszWelcome), "#TF_Welcome" );
			if ( UTIL_GetActiveHolidayString() )
			{
				Q_snprintf( pszWelcome, sizeof(pszWelcome), "#TF_Welcome_%s", UTIL_GetActiveHolidayString() );
			}

			KeyValues *data = new KeyValues( "data" );
			data->SetString( "title", pszWelcome );		// info panel title
			data->SetString( "type", "1" );				// show userdata from stringtable entry
			data->SetString( "msg",	"motd" );			// use this stringtable entry
			data->SetString( "msg_fallback",	"motd_text" );			// use this stringtable entry if the base is HTML, and client has disabled HTML motds
			data->SetBool( "unload", sv_motd_unload_on_dismissal.GetBool() );

			ShowViewPortPanel( PANEL_INFO, true, data );

			data->deleteThis();
		}
		return true;
	}
	else if ( FStrEq( pcmd, "show_htmlpage" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			if ( args.ArgC() != 2 )
			{
				Warning( "Usage: show_htmlpage <url>\n" );
				return true;
			}

			KeyValues *data = new KeyValues( "data" );
			data->SetString( "title", "#TF_Welcome" );	// info panel title
			data->SetString( "type", "2" );				// show url
			data->SetString( "msg",	args[1] );
			data->SetString( "msg_fallback", "motd_text" );			// use this stringtable entry if the base is HTML, and client has disabled HTML motds
			data->SetInt( "cmd", TEXTWINDOW_CMD_CLOSED_HTMLPAGE );		// exec this command if panel closed
			data->SetString( "customsvr", "1" );
			data->SetBool( "unload", false );

			ShowViewPortPanel( PANEL_INFO, true, data );

			data->deleteThis();
		}
		return true;
	}
	else if ( FStrEq( pcmd, "closed_htmlpage" ) )
	{
		// Does nothing, it's for server plugins to hook.
		return true;
	}
	else if ( FStrEq( pcmd, "condump_on" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			if ( !PlayerHasPowerplay() )
			{
				Msg("Console dumping on.\n");
				return true;
			}
			else 
			{
				if ( args.ArgC() == 2 && GetTeam() )
				{
					for ( int i = 0; i < GetTeam()->GetNumPlayers(); i++ )
					{
						CTFPlayer *pTeamPlayer = ToTFPlayer( GetTeam()->GetPlayer(i) );
						if ( pTeamPlayer )
						{
							pTeamPlayer->SetPowerplayEnabled( true );
						}
					}
					return true;
				}
				else
				{
					if ( SetPowerplayEnabled( true ) )
						return true;
				}
			}
		}
	}
	else if ( FStrEq( pcmd, "condump_off" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			if ( !PlayerHasPowerplay() )
			{
				Msg("Console dumping off.\n");
				return true;
			}
			else
			{
				if ( args.ArgC() == 2 && GetTeam() )
				{
					for ( int i = 0; i < GetTeam()->GetNumPlayers(); i++ )
					{
						CTFPlayer *pTeamPlayer = ToTFPlayer( GetTeam()->GetPlayer(i) );
						if ( pTeamPlayer )
						{
							pTeamPlayer->SetPowerplayEnabled( false );
						}
					}
					return true;
				}
				else
				{
					if ( SetPowerplayEnabled( false ) )
						return true;
				}
			}
		}
	}
	else if ( FStrEq( pcmd, "spec_next" ) ) // chase next player
	{
		if ( m_bIsCoaching )
		{
			return true;
		}
// 		if ( !ShouldRunRateLimitedCommand( args ) )
// 			return true;

		// intentionally falling through to the bottom so the baseclass version is called
		m_bArenaIsAFK = false;
	}
	else if ( FStrEq( pcmd, "spec_prev" ) ) // chase prev player
	{
		if ( m_bIsCoaching )
		{
			return true;
		}
// 		if ( !ShouldRunRateLimitedCommand( args ) )
// 			return true;

		// intentionally falling through to the bottom so the baseclass version is called
		m_bArenaIsAFK = false;
	}
	else if ( FStrEq( pcmd, "spec_mode" ) ) // set obs mode
	{
// 		if ( !ShouldRunRateLimitedCommand( args ) )
// 			return true;

		// intentionally falling through to the bottom so the baseclass version is called
		m_bArenaIsAFK = false;
	}
	else if ( FStrEq( pcmd, "showroundinfo" ) )
	{
		if ( ShouldRunRateLimitedCommand( args ) )
		{
			// don't let the player open the round info menu until they're a spectator or they're on a regular team and have picked a class
			if ( ( GetTeamNumber() == TEAM_SPECTATOR ) || ( ( GetTeamNumber() != TEAM_UNASSIGNED ) && ( GetPlayerClass()->GetClassIndex() != TF_CLASS_UNDEFINED ) ) )
			{
				if ( TFGameRules() )
				{
					TFGameRules()->ShowRoundInfoPanel( this );
				}
			}
		}

		return true;
	}
#ifdef STAGING_ONLY
	else if ( FStrEq( pcmd, "feigndeath") )
	{
		m_Shared.SetFeignDeathReady( true );
	}
#endif // STAGING_ONLY
	else if ( FStrEq( pcmd, "autoteam" ) )
	{
		if ( !IsCoaching() )
		{
			int iTeam = GetAutoTeam();
			ChangeTeam( iTeam, true, false );

			if ( iTeam > LAST_SHARED_TEAM )
			{
				ShowViewPortPanel( ( iTeam == TF_TEAM_RED ) ? PANEL_CLASS_RED : PANEL_CLASS_BLUE );
			}
		}

		return true;
	}
	else if ( FStrEq( pcmd, "coach_command" ) )
	{
		if ( m_bIsCoaching && m_hStudent && args.ArgC() > 1 )
		{
			eCoachCommand command = (eCoachCommand)atoi( args[1] );
			HandleCoachCommand( this, command );
			return true;
		}
	}
	else if ( FStrEq( pcmd, "boo" ) && m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
	{
		if ( m_booTimer.IsElapsed() )
		{
			m_booTimer.Start( 1.f );
			EmitSound( "Halloween.GhostBoo" );
		}

		return true;
	}
	else if ( FStrEq( pcmd, "loot_response" ) )
	{
		// Only allowed to speak these during post-game MvM
		if (   !TFGameRules() 
			|| !TFGameRules()->IsMannVsMachineMode()
			|| !( TFGameRules()->State_Get() == GR_STATE_GAME_OVER ) )
		{
			return true;
		}

		if ( FStrEq( args[1], "common" ) )
		{
			SpeakConceptIfAllowed( MP_CONCEPT_MVM_LOOT_COMMON );
			return true;
		}
		else if ( FStrEq( args[1], "rare" ) )
		{
			SpeakConceptIfAllowed( MP_CONCEPT_MVM_LOOT_RARE );
			return true;
		}
		else if ( FStrEq( args[1], "ultra_rare" ) )
		{
			SpeakConceptIfAllowed( MP_CONCEPT_MVM_LOOT_ULTRARARE );
			return true;
		}
	}
	else if ( FStrEq( pcmd, "done_viewing_loot" ) )
	{
		if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && g_pPopulationManager )
		{
			g_pPopulationManager->PlayerDoneViewingLoot( this );
		}
		return true;
	}
	else if ( FStrEq( pcmd, "spectate" ) )
	{
		HandleCommand_JoinTeam( "spectate" );
		return true;
	}
	else if ( FStrEq( pcmd, "team_ui_setup" ) )
	{
		bool bAutoTeam = ShouldForceAutoTeam();
#ifdef TF_RAID_MODE
		bAutoTeam |= TFGameRules()->IsBossBattleMode();
#endif
		
		// For autoteam, display the appropriate team's CLASS selection ui
		if ( bAutoTeam )
		{
			ChangeTeam( GetAutoTeam(), true, false );
			ShowViewPortPanel( ( GetTeamNumber() == TF_TEAM_BLUE ) ? PANEL_CLASS_BLUE : PANEL_CLASS_RED );
		}
		// Otherwise, show TEAM selection ui
		else
		{
			ShowViewPortPanel( PANEL_TEAM );
		}

		return true;
	}
	else if ( FStrEq( "next_map_vote", pcmd ) )
	{
		CTFGameRules::EUserNextMapVote eVoteState = (CTFGameRules::EUserNextMapVote)atoi( args[1] );
		switch( eVoteState )
		{
		case CTFGameRules::USER_NEXT_MAP_VOTE_MAP_0:
		case CTFGameRules::USER_NEXT_MAP_VOTE_MAP_1:
		case CTFGameRules::USER_NEXT_MAP_VOTE_MAP_2:
			// Valid
			break;
		default:
			// Invalid
			Assert( false );
			return true;
		}

		// No flip flop!
		if ( TFGameRules()->PlayerNextMapVoteState( entindex() ) != CTFGameRules::USER_NEXT_MAP_VOTE_UNDECIDED )
			return true;

		// Needs to do next-map voting
		const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
		if ( !pMatchDesc || !pMatchDesc->BUsesMapVoteAfterMatchEnds() )
			return true;

		if ( TFGameRules()->State_Get() != GR_STATE_GAME_OVER )
			return true;

		CMatchInfo* pMatch = GTFGCClientSystem()->GetMatch();
		if ( !pMatch )
			return true;

		TFGameRules()->SetPlayerNextMapVote( entindex(), eVoteState );
		DevMsg( "Settings player %d to rematch vote state %d.\n", entindex(), eVoteState );
		
		return true;
	}
#ifdef STAGING_ONLY
	else if ( FStrEq( pcmd, "reload_extra_models" ) )
	{
		for ( int i = 0; i < CExtraMapEntity::AutoList().Count(); i++ )
		{
			CExtraMapEntity *pEntity = static_cast<CExtraMapEntity*>( CExtraMapEntity::AutoList()[i] );
			UTIL_Remove( pEntity );
		}

		CExtraMapEntity::SpawnExtraModel();
		return true;
	}
#endif // STAGING_ONLY

	return BaseClass::ClientCommand( args );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::SetClassMenuOpen( bool bOpen )
{
	m_bIsClassMenuOpen = bOpen;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsClassMenuOpen( void )
{
	return m_bIsClassMenuOpen;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::MerasmusPlayerBombExplode( bool bExcludeMe /*= true */ )
{
	float flDamage = 40.0f;
	// bomb head damage is 100 only for fighting Merasmus, lower for all other scenarios
	if ( TFGameRules() && TFGameRules()->GetActiveBoss() && ( TFGameRules()->GetActiveBoss()->GetBossType() == HALLOWEEN_BOSS_MERASMUS ) )
	{
		flDamage = 100.0f;
	}

	// explode!
	Vector vecExplosion = EyePosition();

	CPVSFilter filter( vecExplosion );
	TE_TFExplosion( filter, 0.0f, vecExplosion, Vector(0,0,1), NULL, entindex() );
	int iDmgType = DMG_BLAST | DMG_USEDISTANCEMOD;
	CTakeDamageInfo info( this, this, NULL, vecExplosion, vecExplosion, flDamage, iDmgType, TF_DMG_CUSTOM_MERASMUS_PLAYER_BOMB, &vecExplosion );

	CBaseEntity *pIgnoreEnt = NULL;
	if ( bExcludeMe )
	{
		pIgnoreEnt = this;
	}

	CTFRadiusDamageInfo radiusinfo( &info, vecExplosion, 100.f, pIgnoreEnt );
	TFGameRules()->RadiusDamage( radiusinfo );

	UTIL_ScreenShake( vecExplosion, 15.0f, 5.0f, 2.f, 750.f, SHAKE_START, true );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::DropDeathCallingCard( CTFPlayer* pTFAttacker, CTFPlayer* pTFVictim )
{
	int iCallingCard = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iCallingCard, calling_card_on_kill );
	if ( iCallingCard )
	{
		CEffectData	data;

		data.m_vOrigin = pTFVictim->GetAbsOrigin();
		data.m_vAngles = pTFVictim->GetAbsAngles();
		data.m_nAttachmentIndex = pTFVictim->entindex();	// Victim
		data.m_nHitBox = entindex();						// iShooter
		data.m_fFlags = iCallingCard;						// Index to the Calling card

		DispatchEffect( "TFDeathCallingCard", data );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::PlayGesture( const char *pGestureName )
{
	Activity nActivity = (Activity)LookupActivity( pGestureName );
	if ( nActivity != ACT_INVALID )
	{
		DoAnimationEvent( PLAYERANIMEVENT_CUSTOM_GESTURE, nActivity );
		return true;
	}

	int nSequence = LookupSequence( pGestureName );
	if ( nSequence != -1 )
	{
		DoAnimationEvent( PLAYERANIMEVENT_CUSTOM_GESTURE_SEQUENCE, nSequence );
		return true;
	} 

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::PlaySpecificSequence( const char *pAnimationName )
{
	Activity nActivity = (Activity)LookupActivity( pAnimationName );
	if ( nActivity != ACT_INVALID )
	{
		DoAnimationEvent( PLAYERANIMEVENT_CUSTOM, nActivity );
		return true;
	}

	int nSequence = LookupSequence( pAnimationName );
	if ( nSequence != -1 )
	{
		DoAnimationEvent( PLAYERANIMEVENT_CUSTOM_SEQUENCE, nSequence );
		return true;
	} 

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::DetonateObjectOfType( int iType, int iMode, bool bIgnoreSapperState )
{
	CBaseObject *pObj = GetObjectOfType( iType, iMode );
	if( !pObj )
		return;

	if( !bIgnoreSapperState && ( pObj->HasSapper() || pObj->IsPlasmaDisabled() ) )
		return;

	IGameEvent *event = gameeventmanager->CreateEvent( "object_removed" );	
	if ( event )
	{
		event->SetInt( "userid", GetUserID() ); // user ID of the object owner
		event->SetInt( "objecttype", iType ); // type of object removed
		event->SetInt( "index", pObj->entindex() ); // index of the object removed
		gameeventmanager->FireEvent( event );
	}

	if ( TFGameRules() && TFGameRules()->GetTrainingModeLogic() && IsFakeClient() == false )
	{
		TFGameRules()->GetTrainingModeLogic()->OnPlayerDetonateBuilding( this, pObj );
	}

	SpeakConceptIfAllowed( MP_CONCEPT_DETONATED_OBJECT, pObj->GetResponseRulesModifier() );
	pObj->DetonateObject();

	const CObjectInfo *pInfo = GetObjectInfo( iType );

	if ( pInfo )
	{
		UTIL_LogPrintf( "\"%s<%i><%s><%s>\" triggered \"killedobject\" (object \"%s\") (weapon \"%s\") (objectowner \"%s<%i><%s><%s>\") (attacker_position \"%d %d %d\")\n",   
			GetPlayerName(),
			GetUserID(),
			GetNetworkIDString(),
			GetTeam()->GetName(),
			pInfo->m_pObjectName,
			"pda_engineer",
			GetPlayerName(),
			GetUserID(),
			GetNetworkIDString(),
			GetTeam()->GetName(),
			(int)GetAbsOrigin().x, 
			(int)GetAbsOrigin().y,
			(int)GetAbsOrigin().z );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::GetObjectBuildSpeedMultiplier( int iObjectType, bool bIsRedeploy ) const
{
	float flBuildRate = 1.f; // need a base value for mult

	switch( iObjectType )
	{
	case OBJ_SENTRYGUN:
		CALL_ATTRIB_HOOK_FLOAT( flBuildRate, sentry_build_rate_multiplier );
		flBuildRate += bIsRedeploy ? 2.0 : 0.0f;
		break;

	case OBJ_TELEPORTER:
		CALL_ATTRIB_HOOK_FLOAT( flBuildRate, teleporter_build_rate_multiplier );
		flBuildRate += bIsRedeploy ? 3.0 : 0.0f;
		break;

	case OBJ_DISPENSER:
		CALL_ATTRIB_HOOK_FLOAT( flBuildRate, teleporter_build_rate_multiplier );
		flBuildRate += bIsRedeploy ? 3.0 : 0.0f;
		break;
#ifdef STAGING_ONLY
		// STAGING_ENGY
	case OBJ_CATAPULT:
		flBuildRate += 5.0f;
		flBuildRate += bIsRedeploy ? 3.0 : 0.0f;
		break;
#endif
	}

	return flBuildRate - 1.0f; // sub out the initial 1 so the final result is added
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
{
	if ( m_takedamage != DAMAGE_YES )
		return;

	CTFPlayer *pAttacker = ToTFPlayer( info.GetAttacker() );
	if ( pAttacker )
	{
		// Weapons that use uber ammo can transfer that uber into other medics
		if ( pAttacker->IsPlayerClass( TF_CLASS_MEDIC ) && IsPlayerClass( TF_CLASS_MEDIC ) )
		{
			CTFWeaponBase *pWep = pAttacker->GetActiveTFWeapon();
			if ( pWep )
			{
				float flUberTransfer = pWep->UberChargeAmmoPerShot();
				if ( flUberTransfer > 0.0f )
				{
					float flTransferPercent = 0.0f;
					CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWep, flTransferPercent, ubercharge_transfer );

					if ( flTransferPercent )
					{
						flUberTransfer *= ( flTransferPercent * 0.01f );

						CWeaponMedigun *pMedigun = static_cast< CWeaponMedigun * >( Weapon_OwnsThisID( TF_WEAPON_MEDIGUN ) );
						if ( pMedigun )
						{
							pMedigun->AddCharge( flUberTransfer );
						}
					}
				}
			}
		}

		// Prevent team damage here so blood doesn't appear
		if ( !g_pGameRules->FPlayerCanTakeDamage( this, pAttacker, info ) )
		{
			return;
		}
	}

	// Save this bone for the ragdoll.
	m_nForceBone = ptr->physicsbone;

	SetLastHitGroup( ptr->hitgroup );

	// Ignore hitboxes for all weapons except the sniper rifle
	CTakeDamageInfo info_modified = info;
	bool bIsHeadshot = false;

	if ( info_modified.GetDamageType() & DMG_USE_HITLOCATIONS )
	{
		if ( !m_Shared.InCond( TF_COND_INVULNERABLE ) && ptr->hitgroup == HITGROUP_HEAD )
		{
			CTFWeaponBase *pWpn = pAttacker->GetActiveTFWeapon();
			bool bCritical = true;
			bIsHeadshot = true;

			if ( pWpn && !pWpn->CanFireCriticalShot( true ) )
			{
				bCritical = false;
			}

			int iBackheadshot = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetInflictor(), iBackheadshot, back_headshot );
			if ( iBackheadshot )
			{
				// only allow if hit in the back of the head
				Vector entForward;
				AngleVectors( EyeAngles(), &entForward );

				Vector toEnt = GetAbsOrigin() - pAttacker->GetAbsOrigin();
				toEnt.NormalizeInPlace();

				// did not backshot
				//if ( DotProduct( toEnt, entForward ) <= 0.7071f ) // 0.7 os 45 degress from center
				if ( DotProduct( toEnt, entForward ) < 0.5f )	// 60 degrees from center (total of 120)
				{
					bCritical = false;
					bIsHeadshot = false;
				}
			}

			// Check for headshot damage modifiers
			float flHeadshotModifier = 1.0f;
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER ( pAttacker, flHeadshotModifier, headshot_damage_modify);
			info_modified.ScaleDamage(flHeadshotModifier);

			if ( bCritical )
			{
				info_modified.AddDamageType( DMG_CRITICAL );

				int iDecapType = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER ( pAttacker, iDecapType, decapitate_type);
				if ( iDecapType > 0 ) 
				{
					info_modified.SetDamageCustom( TF_DMG_CUSTOM_HEADSHOT_DECAPITATION );
				}
				else 
				{
					info_modified.SetDamageCustom( TF_DMG_CUSTOM_HEADSHOT );
				}

				// play the critical shot sound to the shooter	
				if ( pWpn )
				{
					pWpn->WeaponSound( BURST );
				}
			}
		}
	}

	if ( !bIsHeadshot && pAttacker )
	{	
		// Check for bodyshot damage modifiers
		CTFWeaponBase *pWpn = pAttacker->GetActiveTFWeapon();
		float flBodyshotModifier = 1.0f;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER ( pWpn, flBodyshotModifier, bodyshot_damage_modify);
		info_modified.ScaleDamage( flBodyshotModifier );
	}

	if ( GetTeamNumber() == TF_TEAM_BLUE )
	{
		info_modified.SetDamage( info_modified.GetDamage() * tf_damage_multiplier_blue.GetFloat() );
	}
	else if ( GetTeamNumber() == TF_TEAM_RED )
	{
		info_modified.SetDamage( info_modified.GetDamage() * tf_damage_multiplier_red.GetFloat() );
	}

	if ( m_Shared.InCond( TF_COND_DISGUISED ) )
	{
		// no impact effects
	}
	else if ( m_Shared.IsInvulnerable() )
	{ 
		// Make bullet impacts
		g_pEffects->Ricochet( ptr->endpos - (vecDir * 8), -vecDir );
	}
	else
	{	
		// Since this code only runs on the server, make sure it shows the tempents it creates.
		CDisablePredictionFiltering disabler;

		// This does smaller splotches on the guy and splats blood on the world.
		TraceBleed( info_modified.GetDamage(), vecDir, ptr, info_modified.GetDamageType() );
	}

	AddMultiDamage( info_modified, this );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFPlayer::TakeHealth( float flHealth, int bitsDamageType )
{
	if ( m_Shared.InCond( TF_COND_NOHEALINGDAMAGEBUFF ) )
	{
		return 0; // No healing while in this state!
	}

	int nResult = 0;

	CTFWeaponBase *pWeapon = GetActiveTFWeapon();
	if ( pWeapon )
	{
		float flHealingBonus = 1.f;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flHealingBonus, mult_healing_received );
		flHealth *= flHealingBonus;
	}

	// Medigun healing and player/class regen use an accumulator, so they've already factored in debuffs.
// 	if ( m_Shared.InCond( TF_COND_HEALING_DEBUFF ) && !( bitsDamageType & DMG_IGNORE_DEBUFFS ) )
// 	{
// 		flHealth *= 0.75f;
// 	}

	// If the bit's set, add over the max health
	if ( bitsDamageType & DMG_IGNORE_MAXHEALTH )
	{
		int iTimeBasedDamage = g_pGameRules->Damage_GetTimeBased();
		m_bitsDamageType &= ~(bitsDamageType & ~iTimeBasedDamage);
		m_iHealth += flHealth;
		nResult = flHealth;
	}
	else
	{
		float flHealthToAdd = flHealth;
		float flMaxHealth = GetMaxHealth();
		
		// don't want to add more than we're allowed to have
		if ( flHealthToAdd > flMaxHealth - m_iHealth )
		{
			flHealthToAdd = flMaxHealth - m_iHealth;
		}

		if ( flHealthToAdd <= 0 )
		{
			nResult = 0;
		}
		else
		{
			nResult = BaseClass::TakeHealth( flHealthToAdd, bitsDamageType );
		}
	}

	return nResult;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::TFWeaponRemove( int iWeaponID )
{
	// find the weapon that matches the id and remove it
	int i;
	for (i = 0; i < WeaponCount(); i++) 
	{
		CTFWeaponBase *pWeapon = ( CTFWeaponBase *)GetWeapon( i );
		if ( !pWeapon )
			continue;

		if ( pWeapon->GetWeaponID() != iWeaponID )
			continue;

		RemovePlayerItem( pWeapon );
		UTIL_Remove( pWeapon );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::BumpWeapon( CBaseCombatWeapon *pWeapon )
{
	CBaseCombatCharacter *pOwner = pWeapon->GetOwner();

	// Can I have this weapon type?
	if ( !IsAllowedToPickupWeapons() )
		return false;

	if ( pOwner || !Weapon_CanUse( pWeapon ) || !g_pGameRules->CanHavePlayerItem( this, pWeapon ) )
	{
		UTIL_Remove( pWeapon );
		return false;
	}

	// Don't let the player fetch weapons through walls (use MASK_SOLID so that you can't pickup through windows)
	if ( !pWeapon->FVisible( this, MASK_SOLID ) )
		return false;

	// ----------------------------------------
	// If I already have it just take the ammo
	// ----------------------------------------
	if (Weapon_OwnsThisType( pWeapon->GetClassname(), pWeapon->GetSubType())) 
	{
		UTIL_Remove( pWeapon );
		return true;
	}
	else 
	{
		// -------------------------
		// Otherwise take the weapon
		// -------------------------
		pWeapon->CheckRespawn();

		pWeapon->AddSolidFlags( FSOLID_NOT_SOLID );
		pWeapon->AddEffects( EF_NODRAW );

		Weapon_Equip( pWeapon );
		return true;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::DropCurrentWeapon( void )
{
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::DropFlag( bool bSilent /* = false */ )
{
	if ( HasItem() )
	{
		CCaptureFlag *pFlag = dynamic_cast<CCaptureFlag*>( GetItem() );
		if ( pFlag )
		{
			int nFlagTeamNumber = pFlag->GetTeamNumber();
			pFlag->Drop( this, true, true, !bSilent );
			IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_flag_event" );
			if ( event )
			{
				event->SetInt( "player", entindex() );
				event->SetInt( "eventtype", TF_FLAGEVENT_DROPPED );
				event->SetInt( "priority", 8 );
				event->SetInt( "team", nFlagTeamNumber );

				gameeventmanager->FireEvent( event );
			}
		}
	}
}
//-----------------------------------------------------------------------------
// Purpose: Players can drop Powerup Runes
//-----------------------------------------------------------------------------
void CTFPlayer::DropRune( bool bApplyForce /* = true */, int nTeam /* = TEAM_ANY */ )
{
	if ( m_Shared.IsCarryingRune() )
	{
		Vector forward;
		EyeVectors( &forward );

		RuneTypes_t nRuneType = m_Shared.GetCarryingRuneType();
		// We expect that we are actually are carrying here, so assert that we are.
		Assert( nRuneType >= 0 && nRuneType < RUNE_TYPES_MAX );

		m_Shared.SetCarryingRuneType( RUNE_NONE );

		bool bShouldRemoveMeleeOnly = !( IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && m_Shared.InCond( TF_COND_ENERGY_BUFF ) );
		if ( bShouldRemoveMeleeOnly )
		{
			m_Shared.RemoveCond( TF_COND_CANNOT_SWITCH_FROM_MELEE );	// Knockout powerup sets this to on
		}
		TeamFortress_SetSpeed();									// Need to call this or speed bonus isn't removed immediately
		CTFRune::CreateRune( GetAbsOrigin(), nRuneType, nTeam, true, bApplyForce, forward ); // Manually dropped powerups are always neutral
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
EHANDLE CTFPlayer::TeamFortress_GetDisguiseTarget( int nTeam, int nClass )
{
	if ( /*nTeam == GetTeamNumber() ||*/ nTeam == TF_SPY_UNDEFINED )
	{
		// we're not disguised as the enemy team
		return NULL;
	}

	CUtlVector<int> potentialTargets;

	CBaseEntity *pLastTarget = m_Shared.GetDisguiseTarget(); // don't redisguise self as this person
	
	// Find a player on the team the spy is disguised as to pretend to be
	CTFPlayer *pPlayer = NULL;

	// Loop through players and attempt to find a player as the team/class we're disguising as
	int i;
	for ( i = 1; i <= gpGlobals->maxClients; i++ )
	{
		pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pPlayer && ( pPlayer != pLastTarget ) )
		{
			// First, try to find a player with the same color AND skin
			if ( ( pPlayer->GetTeamNumber() == nTeam ) && ( pPlayer->GetPlayerClass()->GetClassIndex() == nClass ) )
			{
				potentialTargets.AddToHead( i );
			}
		}
	}

	// do we have any potential targets in the list?
	if ( potentialTargets.Count() > 0 )
	{
		int iIndex = random->RandomInt( 0, potentialTargets.Count() - 1 );
		return UTIL_PlayerByIndex( potentialTargets[iIndex] );
	}

	// we didn't find someone with the class, so just find someone with the same team color
	for ( i = 1; i <= gpGlobals->maxClients; i++ )
	{
		pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pPlayer && ( pPlayer->GetTeamNumber() == nTeam ) )
		{
			potentialTargets.AddToHead( i );
		}
	}

	if ( potentialTargets.Count() > 0 )
	{
		int iIndex = random->RandomInt( 0, potentialTargets.Count() - 1 );
		return UTIL_PlayerByIndex( potentialTargets[iIndex] );
	}

	// we didn't find anyone
	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float DamageForce( const Vector &size, float damage, float scale )
{ 
	float force = damage * ((48 * 48 * 82.0) / (size.x * size.y * size.z)) * scale;
	
	if ( force > 1000.0 )
	{
		force = 1000.0;
	}

	return force;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::SetBlastJumpState( int iState, bool bPlaySound /*= false*/ )
{
	m_iBlastJumpState |= iState;

	const char *pszEvent = NULL;
	if ( iState == TF_PLAYER_STICKY_JUMPED )
	{
		pszEvent = "sticky_jump";
	}
	else if ( iState == TF_PLAYER_ROCKET_JUMPED )
	{
		pszEvent = "rocket_jump";
	}

	if ( pszEvent )
	{
		IGameEvent * event = gameeventmanager->CreateEvent( pszEvent );
		if ( event )
		{
			event->SetInt( "userid", GetUserID() );
			event->SetBool( "playsound", bPlaySound );
			gameeventmanager->FireEvent( event );
		}
	}

	m_Shared.AddCond( TF_COND_BLASTJUMPING );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ClearBlastJumpState( void )
{
	m_bCreatedRocketJumpParticles = false;
	m_iBlastJumpState = 0;
	m_flBlastJumpLandTime = gpGlobals->curtime;
	m_Shared.RemoveCond( TF_COND_BLASTJUMPING );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void HandleRageGain( CTFPlayer *pPlayer, unsigned int iRequiredBuffFlags, float flDamage, float fInverseRageGainScale )
{
	if ( !pPlayer )
		return;

	if ( pPlayer->IsPlayerClass( TF_CLASS_SOLDIER ) )
	{
		CTFBuffItem *pBuffItem = dynamic_cast<CTFBuffItem*>( pPlayer->Weapon_OwnsThisID( TF_WEAPON_BUFF_ITEM ) );
		unsigned int iBuffId = pBuffItem ? pBuffItem->GetBuffType() : 0;
		if ( iBuffId < ARRAYSIZE( g_RageBuffTypes ) )
		{
			if ( g_RageBuffTypes[iBuffId].m_iBuffFlags & iRequiredBuffFlags )
			{
				pPlayer->m_Shared.ModifyRage( g_RageBuffTypes[iBuffId].m_fRageScale * ( flDamage / fInverseRageGainScale ) );
			}
		}
	}
	else if ( pPlayer->IsPlayerClass( TF_CLASS_PYRO ) )
	{
		CTFFlameThrower *pFlameThrower = dynamic_cast<CTFFlameThrower*>( pPlayer->Weapon_OwnsThisID( TF_WEAPON_FLAMETHROWER ) );
		unsigned int iBuffId = pFlameThrower ? pFlameThrower->GetBuffType() : 0;
		if ( iBuffId < ARRAYSIZE( g_RageBuffTypes ) )
		{
			if ( g_RageBuffTypes[iBuffId].m_iBuffFlags & iRequiredBuffFlags )
			{
				if ( TFGameRules() && TFGameRules()->IsPowerupMode() && pPlayer->m_Shared.GetCarryingRuneType() != RUNE_NONE )
				{
					pPlayer->m_Shared.ModifyRage(g_RageBuffTypes[iBuffId].m_fRageScale * ( ( flDamage / 10 ) / fInverseRageGainScale) );
				}
				else
				{
					pPlayer->m_Shared.ModifyRage( g_RageBuffTypes[iBuffId].m_fRageScale * ( flDamage / fInverseRageGainScale ) );
				}
			}
		}
	}

	// General
	int iRage = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iRage, generate_rage_on_dmg );
	if ( iRage )
	{
		if ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) && ( kRageBuffFlag_OnDamageDealt & iRequiredBuffFlags ) )
		{
			pPlayer->m_Shared.ModifyRage( flDamage );
		}
		else if ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && ( kRageBuffFlag_OnDamageDealt & iRequiredBuffFlags ) )
		{
			pPlayer->m_Shared.ModifyRage( 0.22f * ( flDamage / fInverseRageGainScale ) );	
		}
	}

	int iHealRage = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iHealRage, generate_rage_on_heal );		// ...lol
	if ( iHealRage )
	{
		if ( pPlayer->IsPlayerClass( TF_CLASS_MEDIC ) && ( kRageBuffFlag_OnHeal & iRequiredBuffFlags ) )
		{
			pPlayer->m_Shared.ModifyRage( 0.25f * flDamage );	
		}
	}

#ifdef STAGING_ONLY
	if ( TFGameRules()->GameModeUsesUpgrades() && pPlayer->IsPlayerClass( TF_CLASS_SPY ) && ( kRageBuffFlag_OnDamageDealt & iRequiredBuffFlags ) )
	{
		// Don't allow when radius cloak is in effect
		if ( !pPlayer->m_Shared.InCond( TF_COND_STEALTHED_USER_BUFF ) )
		{
			pPlayer->m_Shared.ModifyRage( 0.025f * flDamage );
		}
	}
#endif // STAGING_ONLY
}

// we want to ship this...do not remove
ConVar tf_debug_damage( "tf_debug_damage", "0", FCVAR_CHEAT );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFPlayer::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
	CTakeDamageInfo info = inputInfo;

	bool bIsObject = info.GetInflictor() && info.GetInflictor()->IsBaseObject(); 

// need to check this now, before dying
	bool bHadBallBeforeDamage = false;
	if ( TFGameRules() && TFGameRules()->IsPasstimeMode() )
	{
		bHadBallBeforeDamage = m_Shared.HasPasstimeBall();
	}

	// damage may not come from a weapon (ie: Bosses, etc)
	// The existing code below already checked for NULL pWeapon, anyways
	CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( inputInfo.GetWeapon() );

	if ( GetFlags() & FL_GODMODE )
		return 0;

	if ( IsInCommentaryMode() )
		return 0;

	bool bBuddha = ( m_debugOverlays & OVERLAY_BUDDHA_MODE ) ? true : false;

#if defined( _DEBUG ) || defined( STAGING_ONLY )
	if ( mp_developer.GetInt() > 1 && !IsBot() )
		bBuddha = true;
#endif // _DEBUG || STAGING_ONLY

	if ( bBuddha )
	{
		if ( ( m_iHealth - info.GetDamage() ) <= 0 )
		{
			m_iHealth = 1;
			return 0;
		}
	}

	if ( !IsAlive() )
		return 0;

	// Early out if there's no damage
	if ( !info.GetDamage() )
		return 0;

	// Ghosts dont take damage
	if ( m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
	{
		return 0;
	}

	CBaseEntity *pAttacker = info.GetAttacker();
	CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );

	bool bDebug = tf_debug_damage.GetBool();

	// If attacker has Strength Powerup Rune, apply damage multiplier, but not if you're a building
	if ( !bIsObject && pTFAttacker && pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_STRENGTH )
	{
		info.ScaleDamage( 2.f );
	}

	// Make sure the player can take damage from the attacking entity
	if ( !g_pGameRules->FPlayerCanTakeDamage( this, pAttacker, info ) )
	{
		if ( bDebug )
		{
			Warning( "    ABORTED: Player can't take damage from that attacker.\n" );
		}

		return 0;
	}

	if ( IsBot() )
	{
		// Don't let Sentry Busters die until they've done their spin-up
		if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
		{
			CTFBot *bot = ToTFBot( this );
			if ( bot )
			{
				if ( bot->HasMission( CTFBot::MISSION_DESTROY_SENTRIES ) )
				{
					if ( ( m_iHealth - info.GetDamage() ) <= 0 )
					{
						m_iHealth = 1;
						return 0;
					}
				}

				// Sentry Busters hurt teammates when they explode.
				// Force damage value when the victim is a giant.
				if ( pTFAttacker && pTFAttacker->IsBot() )
				{
					CTFBot *pTFAttackerBot = ToTFBot( pTFAttacker );
					if ( pTFAttackerBot && 
						 ( pTFAttackerBot != this ) && 
						 pTFAttackerBot->GetPrevMission() == CTFBot::MISSION_DESTROY_SENTRIES &&
						 info.IsForceFriendlyFire() && 
						 InSameTeam( pTFAttackerBot ) &&
						 IsMiniBoss() )
					{
						info.SetDamage( 600.f );
					}
				}
			}
		}
	}

	// Halloween 2011
	if ( IsInPurgatory() )
	{
		info.SetDamage( m_purgatoryPainMultiplier * info.GetDamage() );
	}

	m_iHealthBefore = GetHealth();

	bool bIsSoldierRocketJumping = ( IsPlayerClass( TF_CLASS_SOLDIER ) && (pAttacker == this) && !(GetFlags() & FL_ONGROUND) && !(GetFlags() & FL_INWATER)) && (inputInfo.GetDamageType() & DMG_BLAST);
	bool bIsDemomanPipeJumping = ( IsPlayerClass( TF_CLASS_DEMOMAN) && (pAttacker == this) && !(GetFlags() & FL_ONGROUND) && !(GetFlags() & FL_INWATER)) && (inputInfo.GetDamageType() & DMG_BLAST);
	
	if ( bDebug )
	{
		Warning( "%s taking damage from %s, via %s. Damage: %.2f\n", GetDebugName(), info.GetInflictor() ? info.GetInflictor()->GetDebugName() : "Unknown Inflictor", pAttacker ? pAttacker->GetDebugName() : "Unknown Attacker", info.GetDamage() );
	}

	if ( pTFAttacker )
	{
		pTFAttacker->SetLastEntityDamagedTime( gpGlobals->curtime );
		pTFAttacker->SetLastEntityDamaged( this );

		CTFWeaponBase *myWeapon = GetActiveTFWeapon();
		CTFWeaponBase *attackerWeapon = pTFAttacker->GetActiveTFWeapon();
		
		if ( myWeapon && attackerWeapon )
		{
			int iStunEnemyWithSameWeapon = 0;
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( attackerWeapon, iStunEnemyWithSameWeapon, stun_enemies_wielding_same_weapon );
			if ( iStunEnemyWithSameWeapon )
			{
				CEconItemView *myItem = myWeapon->GetAttributeContainer()->GetItem();
				CEconItemView *attackerItem = attackerWeapon->GetAttributeContainer()->GetItem();

				if ( myItem && attackerItem && myItem->GetItemDefIndex() == attackerItem->GetItemDefIndex() )
				{
					// we're both wielding the same weapon - stun!
					m_Shared.StunPlayer( 1.0f, 1.0, TF_STUN_BOTH | TF_STUN_NO_EFFECTS );
				}
			}
		}
	}

	if ( ( info.GetDamageType() & DMG_FALL ) )
	{
		bool bHitEnemy = false;

		// Are we transferring falling damage to someone else?
		// Space Gravity gives everyone manntreads effect.  Mantreads just makes it higher
		int iHeadStomp = 0;
		CALL_ATTRIB_HOOK_INT( iHeadStomp, boots_falling_stomp );

//#ifdef STAGING_ONLY
//		if ( ( iHeadStomp || m_Shared.InCond( TF_COND_SPACE_GRAVITY ) ) &&
//#else
		if ( iHeadStomp &&
//#endif // STAGING_ONLY
			 GetGroundEntity() &&
			 GetGroundEntity()->IsPlayer() )
		{
			// Did we land on a guy from the enemy team?
			CTFPlayer *pOther = ToTFPlayer( GetGroundEntity() );
			if ( pOther && pOther->GetTeamNumber() != GetTeamNumber() )
			{
				float flStompDamage = info.GetDamage();
				if ( iHeadStomp )
				{
					flStompDamage = 10.0f + flStompDamage * 3.0f;
				}

				CTakeDamageInfo infoInner( this, this, GetEquippedWearableForLoadoutSlot( LOADOUT_POSITION_SECONDARY ), flStompDamage, DMG_FALL, TF_DMG_CUSTOM_BOOTS_STOMP );
				pOther->TakeDamage( infoInner );
				m_Local.m_flFallVelocity = 0;
				info.SetDamage( 0.0f );
				EmitSound( "Weapon_Mantreads.Impact" );
				UTIL_ScreenShake( pOther->WorldSpaceCenter(), 15.0, 150.0, 1.0, 500, SHAKE_START );

				bHitEnemy = true;
			}
		}

#ifdef STAGING_ONLY
/*
		// no fall damage in space
		if (  m_Shared.InCond( TF_COND_SPACE_GRAVITY ) )
		{
			info.SetDamage( 0.0f );
		}
*/

		// Apply an impact stun (intensity determined by fall damage for now)
		if ( TFGameRules()->GameModeUsesUpgrades() && m_Shared.InCond( TF_COND_ROCKETPACK ) )
		{
			float flStunTime = RemapValClamped( info.GetDamage(), 0.1f, 50.f, 1.f, 3.f );
			m_Shared.ApplyRocketPackStun( bHitEnemy ? 5.f : flStunTime );

			info.SetDamage( 0.f );
			m_Local.m_flFallVelocity = 0.f;
		}
#endif // STAGING_ONLY
	}

	// Ignore damagers on our team, to prevent capturing rocket jumping, etc.
	if ( pAttacker && pAttacker->GetTeam() != GetTeam() )
	{
		m_AchievementData.AddDamagerToHistory( pAttacker );
		if ( pAttacker->IsPlayer() )
		{
			ToTFPlayer( pAttacker )->m_AchievementData.AddTargetToHistory( this );

			// add to list of damagers via sentry so that later we can check for achievement: ACHIEVEMENT_TF_ENGINEER_SHOTGUN_KILL_PREV_SENTRY_TARGET
			CBaseEntity *pInflictor = info.GetInflictor();
			CObjectSentrygun *pSentry = dynamic_cast< CObjectSentrygun * >( pInflictor );
			if ( pSentry )
			{
				m_AchievementData.AddSentryDamager( pAttacker, pInflictor );
			}
		}
	}

	// keep track of amount of damage last sustained
	m_lastDamageAmount = info.GetDamage();
	m_LastDamageType = info.GetDamageType();

	if ( m_LastDamageType & DMG_FALL )
	{
		if ( ( m_lastDamageAmount > m_iLeftGroundHealth ) && ( m_lastDamageAmount < GetHealth() ) )
		{
			// we gained health in the air, and it saved us from death.
			// if any medics are healing us, they get an achievement
			int iNumHealers = m_Shared.GetNumHealers();
			for ( int i=0;i<iNumHealers;i++ )
			{
				CTFPlayer *pMedic = ToTFPlayer( m_Shared.GetHealerByIndex(i) );

				// if its a medic healing us
				if ( pMedic && pMedic->IsPlayerClass( TF_CLASS_MEDIC ) )
				{
					pMedic->AwardAchievement( ACHIEVEMENT_TF_MEDIC_SAVE_FALLING_TEAMMATE );
				}
			}
		}
	}

	// Check for Demo Achievement:
	// Kill a Heavy from full health with one detonation
	if ( IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
	{
		if ( pTFAttacker && pTFAttacker->IsPlayerClass( TF_CLASS_DEMOMAN ) )
		{
			if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_PIPEBOMBLAUNCHER )
			{
				// We're at full health
				if ( m_iHealthBefore >= GetMaxHealth() )
				{
					// Record the time
					m_fMaxHealthTime = gpGlobals->curtime;
				}

				// If we're still being hit in the same time window
				if ( m_fMaxHealthTime == gpGlobals->curtime )
				{
					// Check if the damage is fatal
					int iDamage = info.GetDamage();
					if ( m_iHealth - iDamage <= 0 )
					{
						pTFAttacker->AwardAchievement( ACHIEVEMENT_TF_DEMOMAN_KILL_X_HEAVIES_FULLHP_ONEDET );
					}
				}
			}
		}
	}

	if ( bIsSoldierRocketJumping || bIsDemomanPipeJumping )
	{
		int nJumpType = 0;

		// If this is our own rocket, scale down the damage if we're rocket jumping
		if ( bIsSoldierRocketJumping ) 
		{
			float flDamage = info.GetDamage() * tf_damagescale_self_soldier.GetFloat();
			info.SetDamage( flDamage );

			if ( m_iHealthBefore - flDamage > 0 )
			{
				nJumpType = TF_PLAYER_ROCKET_JUMPED;
			}
		}
		else if ( bIsDemomanPipeJumping )
		{
			nJumpType = TF_PLAYER_STICKY_JUMPED;
		}

		if ( nJumpType )
		{
			bool bPlaySound = false;
			if ( pWeapon )
			{
				int iNoBlastDamage = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iNoBlastDamage, no_self_blast_dmg )
					bPlaySound = iNoBlastDamage ? true : false;
			}

			SetBlastJumpState( nJumpType, bPlaySound );
		}
	}

	if ( TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
	{
		// can only bounce invaders when they are on the ground
		if ( GetGroundEntity() == NULL )
		{
			info.SetDamageForce( vec3_origin );
		}
	}

	// Save damage force for ragdolls.
	m_vecTotalBulletForce = info.GetDamageForce();
	m_vecTotalBulletForce.x = clamp( m_vecTotalBulletForce.x, -15000.0f, 15000.0f );
	m_vecTotalBulletForce.y = clamp( m_vecTotalBulletForce.y, -15000.0f, 15000.0f );
	m_vecTotalBulletForce.z = clamp( m_vecTotalBulletForce.z, -15000.0f, 15000.0f );

	int bTookDamage = 0;
 	int bitsDamage = inputInfo.GetDamageType();

	bool bAllowDamage = false;

	// check to see if our attacker is a trigger_hurt entity (and allow it to kill us even if we're invuln)
	if ( pAttacker && pAttacker->IsSolidFlagSet( FSOLID_TRIGGER ) )
	{
		CTriggerHurt *pTrigger = dynamic_cast<CTriggerHurt *>( pAttacker );
		if ( pTrigger )
		{
			bAllowDamage = true;
			info.SetDamageCustom( TF_DMG_CUSTOM_TRIGGER_HURT );
		}
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TELEFRAG )
	{
		bAllowDamage = true;
	}

	if ( !TFGameRules()->ApplyOnDamageModifyRules( info, this, bAllowDamage ) )
	{
		return 0;
	}

	// If player has Reflect Powerup, reflect damage to attacker. 
	// We do this here, after damage modify rules to ensure distance falloff calculations have already been made before we pass that damage back to the attacker
	if ( pTFAttacker && m_Shared.GetCarryingRuneType() == RUNE_REFLECT && pTFAttacker != this && !pTFAttacker->m_Shared.IsInvulnerable() && pTFAttacker->IsAlive() )
	{
		CTakeDamageInfo dmg = info;
		CTFProjectile_SentryRocket *sentryRocket = dynamic_cast<CTFProjectile_SentryRocket *>( info.GetInflictor() );

		if ( gpGlobals->curtime > m_flNextReflectZap ) // don't spam the effect for fast weapons like flamethrower and minigun
		{
			m_flNextReflectZap = gpGlobals->curtime + 0.5f;

			CPVSFilter filter( WorldSpaceCenter() );
			Vector vEnd = pTFAttacker->WorldSpaceCenter();
			Vector vStart = WorldSpaceCenter();

			if ( bIsObject || sentryRocket )
			{
				CBaseEntity *pInflictor = info.GetInflictor();
				vEnd = pInflictor->WorldSpaceCenter();
			}
			else
			{
				// Push the attacker away from the Reflect powerup holder
				Vector toPlayer = vEnd - vStart;
				toPlayer.z = 0.0f;
				toPlayer.NormalizeInPlace();
				toPlayer.z = 1.0f;
				float flDamage = dmg.GetDamage();
				if ( dmg.GetDamageCustom() != TF_DMG_CUSTOM_BURNING )
				{
					float flPushForce = RemapValClamped( flDamage, 0.1f, 150.f, 300.f, 500.f );		// Scale the push force according to damage
					Vector vPush = flPushForce * toPlayer;
					pTFAttacker->ApplyAbsVelocityImpulse( vPush );
				}

				// Play a sound and reduce the volume if damage is low
				CSoundParameters params;
				if ( CBaseEntity::GetParametersForSound( "Powerup.Reflect.Reflect", params, NULL ) )
				{
					CPASAttenuationFilter soundFilter( pTFAttacker->GetAbsOrigin(), params.soundlevel );
					EmitSound_t ep( params );

					if ( flDamage < 10.f )
					{
						ep.m_flVolume *= 0.75f;
					}

					pTFAttacker->EmitSound( soundFilter, entindex(), ep );
					pTFAttacker->PainSound( dmg );
				}
			}

			te_tf_particle_effects_control_point_t controlPoint = { PATTACH_ABSORIGIN, vEnd };
			TE_TFParticleEffectComplex( filter, 0.f, "dxhr_arm_muzzleflash", vStart, QAngle( 0.f, 0.f, 0.f ), NULL, &controlPoint, pTFAttacker, PATTACH_CUSTOMORIGIN );
		}

		dmg.SetDamageCustom( TF_DMG_CUSTOM_RUNE_REFLECT );
		dmg.SetDamageType( DMG_SHOCK );
		dmg.SetAttacker( this );

		if ( bIsObject )
		{
			CBaseEntity *pInflictor = info.GetInflictor();
			dmg.SetDamage( info.GetDamage() );
			pInflictor->TakeDamage( dmg );
		}
		// Sentry rockets are not included in bIsobject so we deal with them separately
		else
		{
			if ( sentryRocket )
			{
				dmg.SetDamage( info.GetDamage() );
				info.GetInflictor()->GetOwnerEntity()->TakeDamage( dmg );
			}
			else
			{
				// Take damage unless you have Resist or Vampire (they are immune to reflect damage)
				if ( pTFAttacker->m_Shared.GetCarryingRuneType() != RUNE_RESIST && pTFAttacker->m_Shared.GetCarryingRuneType() != RUNE_VAMPIRE )
				{
					dmg.SetDamage(info.GetDamage() * 0.8f);
					pTFAttacker->TakeDamage( dmg );
				}
			}
		}
	}

	//Don't take damage while I'm phasing.
	if ( ( m_Shared.InCond( TF_COND_PHASE ) || m_Shared.InCond( TF_COND_PASSTIME_INTERCEPTION ) ) && bAllowDamage == false )
	{
		SpeakConceptIfAllowed( MP_CONCEPT_DODGE_SHOT );

		if ( pAttacker && pAttacker->IsPlayer() )
		{
			CEffectData	data;
			data.m_nHitBox = GetParticleSystemIndex( "miss_text" );
			data.m_vOrigin = WorldSpaceCenter() + Vector(0,0,32);
			data.m_vAngles = vec3_angle;
			data.m_nEntIndex = 0;

			CSingleUserRecipientFilter filter( (CBasePlayer*)pAttacker );
			te->DispatchEffect( filter, 0.0, data.m_vOrigin, "ParticleEffect", data );
		}

		Vector vecDir = vec3_origin;
		if ( info.GetInflictor() )
		{
			vecDir = info.GetInflictor()->WorldSpaceCenter() - Vector ( 0.0f, 0.0f, 10.0f ) - WorldSpaceCenter();
			VectorNormalize( vecDir );
		}

		ApplyPushFromDamage( info, vecDir );

		if ( m_Shared.InCond( TF_COND_PHASE ) )
		{
			m_Shared.m_ConditionData[ TF_COND_PHASE ].m_nPreventedDamageFromCondition += info.GetDamage();
			m_Shared.m_iPhaseDamage += info.GetDamage();
		}

		bTookDamage = false;
	}
	else
	{
		bool bFatal = ( m_iHealth - info.GetDamage() ) <= 0;

		bool bTrackEvent = pTFAttacker && pTFAttacker != this && !pTFAttacker->IsBot() && !IsBot();
		if ( bTrackEvent )
		{
			float flHealthRemoved = bFatal ? m_iHealth : info.GetDamage();
			if ( info.GetDamageBonus() && info.GetDamageBonusProvider() )
			{
				// Don't deal with raw damage numbers, only health removed.
				// Example based on a crit rocket to a player with 120 hp:
				// Actual damage is 120, but potential damage is 300, where
				// 100 is the base, and 200 is the bonus.  Apply this ratio
				// to actual (so, attacker did 40, and provider added 80).
				float flBonusMult = info.GetDamage() / abs( info.GetDamageBonus() - info.GetDamage() );
				float flBonus = flHealthRemoved - ( flHealthRemoved / flBonusMult );
				m_AchievementData.AddDamageEventToHistory( info.GetDamageBonusProvider(), flBonus );
				flHealthRemoved -= flBonus;
			}
			m_AchievementData.AddDamageEventToHistory( pAttacker, flHealthRemoved );
		}

		// This should kill us
		if ( bFatal )
		{
			// Damage could have been modified since we started
			// Try to prevent death with buddha one more time
			if ( bBuddha )
			{
				m_iHealth = 1;
				return 0;
			}

			// Check to see if we have the cheat death attribute that makes
			// us teleport to base rather than die
			float flCheatDeathChance = 0.f;
			CALL_ATTRIB_HOOK_FLOAT( flCheatDeathChance, teleport_instead_of_die );
			if( RandomFloat() < flCheatDeathChance )
			{
				// Send back to base
				ForceRespawn();

				m_iHealth = 1;
				return 0;
			}

			// Avoid one death
			if ( m_Shared.InCond( TF_COND_PREVENT_DEATH ) )
			{
				m_Shared.RemoveCond( TF_COND_PREVENT_DEATH );
				m_iHealth = 1;
				return 0;
			}

			// Powerup-sourced reflected damage should not kill player
			if ( info.GetDamageCustom() == TF_DMG_CUSTOM_RUNE_REFLECT )
			{
				m_iHealth = 1;
				return 0;
			}
		}

		// NOTE: Deliberately skip base player OnTakeDamage, because we don't want all the stuff it does re: suit voice
		bTookDamage = CBaseCombatCharacter::OnTakeDamage( info );

		// Early out if the base class took no damage
		if ( !bTookDamage )
		{
			if ( bDebug )
			{
				Warning( "    ABORTED: Player failed to take the damage.\n" );
			}
			return 0;
		}

		// Check to see if we need to pass along the damage to other players
		if ( pWeapon && ( gs_pRecursivePlayerCheck == NULL ) )
		{
			int iDamageAllConnected = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iDamageAllConnected, damage_all_connected );

			if ( iDamageAllConnected > 0 )
			{
				// Am I healing someone or being healed?
				CUtlVector<CTFPlayer*> pTempPlayerQueue;
				AddConnectedPlayers( pTempPlayerQueue, this );

				gs_pRecursivePlayerCheck = this;
				for ( int iCount = 0 ; iCount < pTempPlayerQueue.Count() ; iCount++ )
				{
					CTFPlayer *pTFPlayer = pTempPlayerQueue[iCount];
					if ( pTFPlayer && ( pTFPlayer != this ) )
					{
						pTFPlayer->TakeDamage( inputInfo );
					}
				}
				gs_pRecursivePlayerCheck = NULL;
			}
		}
	}

	if ( bTookDamage == false )
		return 0;

	if ( bDebug )
	{
		Warning( "    DEALT: Player took %.2f damage.\n", info.GetDamage() );
		Warning( "    HEALTH LEFT: %d\n", GetHealth() );
	}

	// Some weapons have the ability to impart extra moment just because they feel like it. Let their attributes
	// do so if they're in the mood.
	if ( pWeapon != NULL )
	{
		float flZScale = 0.0f;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flZScale, apply_z_velocity_on_damage );
		if ( flZScale != 0.0f )
		{
			ApplyAbsVelocityImpulse( Vector( 0.0f, 0.0f, flZScale ) );
		}

		float flDirScale = 0.0f;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flDirScale, apply_look_velocity_on_damage );
		if ( flDirScale != 0.0f && pAttacker != NULL )
		{
			Vector vecForward;
			AngleVectors( pAttacker->EyeAngles(), &vecForward );

			Vector vecForwardNoDownward = Vector( vecForward.x, vecForward.y, MIN( 0.0f, vecForward.z ) ).Normalized();
			ApplyAbsVelocityImpulse( vecForwardNoDownward * flDirScale );
		}
	}

	// let weapons react to their owner being injured
	CTFWeaponBase *pMyWeapon = GetActiveTFWeapon();
	if ( pMyWeapon )
	{
		pMyWeapon->ApplyOnInjuredAttributes( this, pTFAttacker, info );
	}

	// Send the damage message to the client for the hud damage indicator
	// Try and figure out where the damage is coming from
	Vector vecDamageOrigin = info.GetReportedPosition();

	// If we didn't get an origin to use, try using the attacker's origin
	if ( vecDamageOrigin == vec3_origin && info.GetInflictor() )
	{
		vecDamageOrigin = info.GetInflictor()->GetAbsOrigin();
	}

	// Tell the player's client that he's been hurt.
	if ( m_iHealthBefore != GetHealth() )
	{
 		CSingleUserRecipientFilter user( this );
		UserMessageBegin( user, "Damage" );
			WRITE_SHORT( clamp( (int)info.GetDamage(), 0, 32000 ) );
			WRITE_LONG( info.GetDamageType() );
			// Tell the client whether they should show it in the indicator
			if ( bitsDamage != DMG_GENERIC && !(bitsDamage & (DMG_DROWN | DMG_FALL | DMG_BURN) ) )
			{
				WRITE_BOOL( true );
				WRITE_VEC3COORD( vecDamageOrigin );
			}
			else
			{
				WRITE_BOOL( false );
			}
		MessageEnd();
	}

	// add to the damage total for clients, which will be sent as a single
	// message at the end of the frame
	// todo: remove after combining shotgun blasts?
	if ( info.GetInflictor() && info.GetInflictor()->edict() )
	{
		m_DmgOrigin = info.GetInflictor()->GetAbsOrigin();
	}

	m_DmgTake += (int)info.GetDamage();

	// Reset damage time countdown for each type of time based damage player just sustained
	for (int i = 0; i < CDMG_TIMEBASED; i++)
	{
		// Make sure the damage type is really time-based.
		// This is kind of hacky but necessary until we setup DamageType as an enum.
		int iDamage = ( DMG_PARALYZE << i );
		if ( ( info.GetDamageType() & iDamage ) && g_pGameRules->Damage_IsTimeBased( iDamage ) )
		{
			m_rgbTimeBasedDamage[i] = 0;
		}
	}

	const char* pzsMedigunResistEffect = NULL;
	const char* pzsTeam = GetTeamNumber() == TF_TEAM_RED ? "red" : "blue";

	// If we have one of the medigun resist buffs and get hit with the matching damage type then
	// spawn a particle above our head to let enemies know their damage is being resisted, and tell
	// the medic he's doing the right thing.

	bool bMedicBulletResist		= m_Shared.InCond( TF_COND_MEDIGUN_UBER_BULLET_RESIST ) || m_Shared.InCond( TF_COND_MEDIGUN_SMALL_BULLET_RESIST );
	bool bMedicExplosiveResist	= m_Shared.InCond( TF_COND_MEDIGUN_UBER_BLAST_RESIST )	|| m_Shared.InCond( TF_COND_MEDIGUN_SMALL_BLAST_RESIST );
	bool bMedicFireResist		= m_Shared.InCond( TF_COND_MEDIGUN_UBER_FIRE_RESIST )	|| m_Shared.InCond( TF_COND_MEDIGUN_SMALL_FIRE_RESIST );

	if( ( bMedicBulletResist && ( bitsDamage & DMG_BULLET	) ) )
	{
		pzsMedigunResistEffect = CFmtStr( "vaccinator_%s_buff1_burst", pzsTeam );
	}
	else if( bMedicExplosiveResist	&& ( bitsDamage & DMG_BLAST	) )
	{
		pzsMedigunResistEffect = CFmtStr( "vaccinator_%s_buff2_burst", pzsTeam );
	}
	else if( bMedicFireResist && ( bitsDamage & DMG_BURN ) )
	{
		pzsMedigunResistEffect = CFmtStr( "vaccinator_%s_buff3_burst", pzsTeam );
	}

	if( pzsMedigunResistEffect != NULL )
	{
		const Vector& vecOrigin = GetAbsOrigin();
		CPVSFilter filter( vecOrigin );
		TE_TFParticleEffect( filter, 0, pzsMedigunResistEffect, vecOrigin, vec3_angle );
	}

	// Display any effect associate with this damage type
	DamageEffect( info.GetDamage(),bitsDamage );

	m_bitsDamageType |= bitsDamage; // Save this so we can report it to the client
	m_bitsHUDDamage = -1;  // make sure the damage bits get reset

	// Flinch
	bool bFlinch = true;
	if ( bitsDamage != DMG_GENERIC )
	{
		if ( IsPlayerClass( TF_CLASS_SNIPER ) && m_Shared.InCond( TF_COND_AIMING ) )
		{
			if ( pTFAttacker && pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_MINIGUN )
			{
				float flDistSqr = ( pTFAttacker->GetAbsOrigin() - GetAbsOrigin() ).LengthSqr();
				if ( flDistSqr > 750 * 750 )
				{
					bFlinch = false;
				}
			}
		}

		if ( bFlinch )
		{
			if ( ApplyPunchImpulseX( -2 ) ) 
			{
				PlayFlinch( info );
			}
		}

		// PASSTIME intense flinch to make it hard to throw straight while taking damage
		extern ConVar tf_passtime_flinch_boost;
		if( TFGameRules() && TFGameRules()->IsPasstimeMode() && (tf_passtime_flinch_boost.GetInt() > 0) )
		{
			int iFlinch = tf_passtime_flinch_boost.GetInt();
			CTFWeaponBase *pMyWeapon = GetActiveTFWeapon();
			if( pMyWeapon && pMyWeapon->GetWeaponID() == TF_WEAPON_PASSTIME_GUN )
			{
				QAngle punch;
				punch.Random( -iFlinch, iFlinch );
				SetPunchAngle( punch );
			}
		}
	}

	// Do special explosion damage effect
	if ( bitsDamage & DMG_BLAST )
	{
		OnDamagedByExplosion( info );
	}

	if ( m_iHealthBefore != GetHealth() )
	{
		PainSound( info );
	}

	// Detect drops below 25% health and restart expression, so that characters look worried.
	int iHealthBoundary = (GetMaxHealth() * 0.25);
	if ( GetHealth() <= iHealthBoundary && m_iHealthBefore > iHealthBoundary )
	{
		ClearExpression();
	}

#ifdef _DEBUG
	// Report damage from the info in debug so damage against targetdummies goes
	// through the system, as m_iHealthBefore - GetHealth() will always be 0.
	CTF_GameStats.Event_PlayerDamage( this, info, info.GetDamage() );
#else
	CTF_GameStats.Event_PlayerDamage( this, info, m_iHealthBefore - GetHealth() );
#endif // _DEBUG

	// if we take damage after we leave the ground, update the health if its less
	if ( bTookDamage && m_iLeftGroundHealth > 0 )
	{
		if ( GetHealth() < m_iLeftGroundHealth )
		{
			m_iLeftGroundHealth = GetHealth();
		}
	}
	
	if ( IsPlayerClass( TF_CLASS_SPY ) && ( inputInfo.GetDamageCustom() != TF_DMG_CUSTOM_TELEFRAG ) )
	{
		// Trigger feign death if the player has it prepped...
		if ( m_Shared.IsFeignDeathReady() )
		{
			m_Shared.SetFeignDeathReady( false );
			if ( !m_Shared.InCond( TF_COND_TAUNTING ) )
			{
				SpyDeadRingerDeath( info );
				pTFAttacker->IncrementKillCountSinceLastDeploy( info );
			}
		}
		else if ( !( info.GetDamageType() & DMG_FALL ) )
		{
			m_Shared.NoteLastDamageTime( m_lastDamageAmount );
		}
	}

	if ( pWeapon ) 
	{
		pWeapon->ApplyPostHitEffects( inputInfo, this );
	}

	if ( IsPlayerClass( TF_CLASS_DEMOMAN ) )
	{
		// Reduce charge if damage is taken
		int iDemoChargeDamagePenalty = 0;
		CALL_ATTRIB_HOOK_INT( iDemoChargeDamagePenalty, lose_demo_charge_on_damage_when_charging );
		// Does not apply to self or fall damage
		if ( iDemoChargeDamagePenalty && m_Shared.InCond( TF_COND_SHIELD_CHARGE ) && !( info.GetDamageType() & DMG_FALL ) && (pAttacker != this) )
		{
			iDemoChargeDamagePenalty *= info.GetDamage();
			m_Shared.SetDemomanChargeMeter( Max( m_Shared.GetDemomanChargeMeter() - (float)iDemoChargeDamagePenalty, 0.0f ) );
		}
	}

#ifdef STAGING_ONLY
	// Remove Cond if hit
	if ( m_Shared.InCond( TF_COND_NO_COMBAT_SPEED_BOOST ) )
	{
		m_Shared.RemoveCond( TF_COND_NO_COMBAT_SPEED_BOOST );
	}
#endif

	float flRageScale = 1.0f;
	CALL_ATTRIB_HOOK_FLOAT( flRageScale, rage_giving_scale );

	// Give the soldier/pyro some rage points for dealing/taking damage.
	if ( bTookDamage && pTFAttacker != this )
	{
		// Buff flag 1: we get rage when we deal damage. Here, that means the soldier that attacked
		// gets rage when we take damage.
		HandleRageGain( pTFAttacker, kRageBuffFlag_OnDamageDealt, info.GetDamage() * flRageScale, 6.0f );

		// Buff flag 2: we get rage when we take damage.
		if (  !( info.GetDamageType() & DMG_FALL ) )
		{
			HandleRageGain( this, kRageBuffFlag_OnDamageReceived, info.GetDamage() * flRageScale, 3.5f );
		}

		// Buff 5: our pyro attacker get rage when we're damaged by fire
		if ( ( info.GetDamageType() & DMG_BURN ) != 0 || ( info.GetDamageType() & DMG_PLASMA ) != 0 )
		{
			float flInverseRageGainScale = TFGameRules()->IsMannVsMachineMode() ? 12.f : 3.f;
			HandleRageGain( pTFAttacker, kRageBuffFlag_OnBurnDamageDealt, info.GetDamage() * flRageScale, flInverseRageGainScale );
		}
	}

	if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_BAT_FISH )
	{
		bool bDisguised = m_Shared.InCond( TF_COND_DISGUISED ) && (m_Shared.GetDisguiseTeam() == pTFAttacker->GetTeamNumber());

		if ( m_iHealth <= 0 )
		{
			info.SetDamageCustom( TF_DMG_CUSTOM_FISH_KILL );
		}

		if ( m_iHealth <= 0 || !bDisguised )
		{
			// Do you ever find yourself typing "fish damage override" into a million-lines-of-code project and
			// wondering about the world? Because I do.
			int iFishDamageOverride = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iFishDamageOverride, fish_damage_override );

			TFGameRules()->DeathNotice( this, info, iFishDamageOverride ? "fish_notice__arm" : "fish_notice" );
		}
	}

	if ( IsPlayerClass( TF_CLASS_SCOUT) )
	{
		// Lose hype on take damage
		int iHypeResetsOnTakeDamage = 0;
		CALL_ATTRIB_HOOK_INT( iHypeResetsOnTakeDamage, lose_hype_on_take_damage );
		if ( iHypeResetsOnTakeDamage != 0 )
		{
			// Loose x hype on jump
			float flHype = m_Shared.GetScoutHypeMeter();
			m_Shared.SetScoutHypeMeter( flHype - iHypeResetsOnTakeDamage * info.GetDamage() );
			TeamFortress_SetSpeed();
		}
	}

	// Add humilation Obituary here for throwable hits
	//if ( info.GetDamageCustom() == TF_DMG_CUSTOM_THROWABLE )
	//{
	//	bool bDisguised = m_Shared.InCond( TF_COND_DISGUISED ) && (m_Shared.GetDisguiseTeam() == pTFAttacker->GetTeamNumber());

	//	if( m_iHealth <= 0 )
	//	{
	//		info.SetDamageCustom( TF_DMG_CUSTOM_THROWABLE_KILL );
	//	}

	//	if ( m_iHealth <= 0 || !bDisguised )
	//	{
	//		TFGameRules()->DeathNotice( this, info, "throwable_hit" );
	//	}
	//}

	// Let attacker react to the damage they dealt
	if ( pTFAttacker )
	{
		pTFAttacker->OnDealtDamage( this, info );
	}

	bool bIsPyroDetonateJumping = ( IsPlayerClass( TF_CLASS_PYRO ) && pAttacker == this && !(GetFlags() & FL_ONGROUND) && !(GetFlags() & FL_INWATER));
	if ( bIsDemomanPipeJumping || bIsSoldierRocketJumping || bIsPyroDetonateJumping )
	{
		// Are we being healed by any QuickFix medics?
		for ( int i = 0; i < m_Shared.m_nNumHealers; i++ )
		{
			CTFPlayer *pMedic = ToTFPlayer( m_Shared.m_aHealers[i].pHealer );
			if ( !pMedic )
				continue;

			// Share blast jump with them
			CWeaponMedigun *pMedigun = dynamic_cast< CWeaponMedigun* >( pMedic->GetActiveTFWeapon() );
			if ( pMedigun && pMedigun->GetMedigunType() == MEDIGUN_QUICKFIX )
			{
// 				Vector vecDir = vec3_origin;
// 				if ( info.GetInflictor() )
// 				{
// 					vecDir = info.GetInflictor()->WorldSpaceCenter() - Vector ( 0.0f, 0.0f, 10.0f ) - WorldSpaceCenter();
// 					info.GetInflictor()->AdjustDamageDirection( info, vecDir, this );
// 					VectorNormalize( vecDir );
// 				}
// 				pMedic->RemoveFlag( FL_ONGROUND );
// 				pMedic->ApplyPushFromDamage( info, vecDir );

				float flForce = GetAbsVelocity().Length();
				flForce = MIN( flForce, 900.f );
				Vector vecNewVelocity = GetAbsVelocity();
				VectorNormalize( vecNewVelocity );
				pMedic->RemoveFlag( FL_ONGROUND );
				pMedic->ApplyAbsVelocityImpulse( vecNewVelocity * flForce );
			}
		}
	}

	if ( pTFAttacker && pTFAttacker->IsPlayerClass( TF_CLASS_SOLDIER ) )
	{
		if ( info.GetDamageType() & DMG_BLAST )
		{
			// Send an event whenever a soldier hits another player directly with a stun rocket
			CTFBaseRocket *pRocket = dynamic_cast< CTFBaseRocket* >( info.GetInflictor() );
			if ( pRocket && pRocket->GetStunLevel() && pRocket->GetEnemy() && pRocket->GetEnemy() == this )
			{
				IGameEvent *event = gameeventmanager->CreateEvent( "player_directhit_stun" );
				if ( event )
				{
					event->SetInt( "attacker", pTFAttacker->entindex() );
					event->SetInt( "victim", entindex() );
					gameeventmanager->FireEvent( event );
				}
			}
		}
	}


	CTFWeaponBase *pTFWeapon = GetKilleaterWeaponFromDamageInfo( &info );
	if ( !pTFWeapon )
	{
		// Check Wearable instead like demoshields or manntreads
		CTFWearable *pWearable = dynamic_cast< CTFWearable* >( info.GetWeapon() );
		if ( pWearable )
		{
			EconEntity_OnOwnerKillEaterEvent_Batched( pWearable, pTFAttacker, this, kKillEaterEvent_DamageDealt, info.GetDamage() );
			EconEntity_OnOwnerKillEaterEvent_Batched( pWearable, pTFAttacker, this, kKillEaterEvent_PlayersHit, 1 );
		}
	}
	else
	{
		EconEntity_OnOwnerKillEaterEvent_Batched( pTFWeapon, pTFAttacker, this, kKillEaterEvent_DamageDealt, info.GetDamage() );
		EconEntity_OnOwnerKillEaterEvent_Batched( pTFWeapon, pTFAttacker, this, kKillEaterEvent_PlayersHit, 1 );
	}

	// bHadBallBeforeDamage will always be false in non-passtime modes
	if ( bTookDamage && bHadBallBeforeDamage )
	{
		g_pPasstimeLogic->OnBallCarrierDamaged( this, pTFAttacker, info );
	}

	return info.GetDamage();
}

//-----------------------------------------------------------------------------
// Purpose: Invoked when we deal damage to another victim
//-----------------------------------------------------------------------------
void CTFPlayer::OnDealtDamage( CBaseCombatCharacter *pVictim, const CTakeDamageInfo &info )
{
	if ( pVictim )
	{
		// which second of the window are we in
		int i = (int)gpGlobals->curtime;
		i %= DPS_Period;

		if ( i != m_lastDamageRateIndex )
		{
			// a second has ticked over, start a new accumulation
			m_damageRateArray[ i ] = info.GetDamage();
			m_lastDamageRateIndex = i;

			// track peak DPS for this player
			m_peakDamagePerSecond = 0;
			for( i=0; i<DPS_Period; ++i )
			{
				if ( m_damageRateArray[i] > m_peakDamagePerSecond )
				{
					m_peakDamagePerSecond = m_damageRateArray[i];
				}
			}
		}
		else
		{
			m_damageRateArray[ i ] += info.GetDamage();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::AddConnectedPlayers( CUtlVector<CTFPlayer*> &vecPlayers, CTFPlayer *pPlayerToConsider )
{
	if ( !pPlayerToConsider )
		return;

	if ( vecPlayers.Find( pPlayerToConsider ) != vecPlayers.InvalidIndex() )
		return; // already in the list

	vecPlayers.AddToTail( pPlayerToConsider );
  
	if ( pPlayerToConsider->MedicGetHealTarget() )
	{
		AddConnectedPlayers( vecPlayers, ToTFPlayer( pPlayerToConsider->MedicGetHealTarget() ) );
	}

	for ( int i = 0 ; i < pPlayerToConsider->m_Shared.GetNumHealers() ; i++ )
	{
		CTFPlayer *pMedic = ToTFPlayer( pPlayerToConsider->m_Shared.GetHealerByIndex( i ) );
		if ( pMedic )
		{
			AddConnectedPlayers( vecPlayers, pMedic );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Reduces backstab damage if we have a back shield.
//-----------------------------------------------------------------------------
bool CTFPlayer::CheckBlockBackstab( CTFPlayer *pTFAttacker )
{
	// Check all items for the attribute that blocks a backstab.
	// Destroy the first item that intercepts the backstab.
	CUtlVector<CBaseEntity*> itemList;
	int iBackStabShield = 0;
	CALL_ATTRIB_HOOK( int, iBackStabShield, set_blockbackstab_once, this, &itemList );
	if ( iBackStabShield )
	{
		Assert( itemList.Count() != 0 );
		CBaseEntity *pEntity = itemList.Element( 0 );
		if ( pEntity )
		{
			if ( pEntity->IsBaseCombatWeapon() )
			{
				// Remove.
			}

			if ( pEntity->IsWearable() )
			{
				// Yay stats.
				EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pEntity ), this, pTFAttacker, kKillEaterEvent_BackstabAbsorbed );

				// Unequip.
				CTFWearable *pItem = dynamic_cast<CTFWearable *>( pEntity );
				pItem->Break();
				pItem->RemoveFrom( this );
			}

			UTIL_Remove( pEntity );

			// tell the bot his Razorback just got broken
			CTFBot *me = ToTFBot( this );
			if ( me )
			{
				me->DelayedThreatNotice( pTFAttacker, 0.5f );
			}
		}
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::DamageEffect(float flDamage, int fDamageType)
{
	bool bDisguised = m_Shared.InCond( TF_COND_DISGUISED );

	if (fDamageType & DMG_CRUSH)
	{
		//Red damage indicator
		color32 red = {128,0,0,128};
		UTIL_ScreenFade( this, red, 1.0f, 0.1f, FFADE_IN );
	}
	else if (fDamageType & DMG_DROWN)
	{
		//Red damage indicator
		color32 blue = {0,0,128,128};
		UTIL_ScreenFade( this, blue, 1.0f, 0.1f, FFADE_IN );
	}
	else if (fDamageType & DMG_SLASH)
	{
		if ( !bDisguised )
		{
			// If slash damage shoot some blood
			SpawnBlood(EyePosition(), g_vecAttackDir, BloodColor(), flDamage);
		}
	}
	else if ( fDamageType & DMG_BULLET )
	{
		if ( !bDisguised )
		{
			EmitSound( "Flesh.BulletImpact" );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : collisionGroup - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFPlayer::ShouldCollide( int collisionGroup, int contentsMask ) const
{
	if ( ( ( collisionGroup == COLLISION_GROUP_PLAYER_MOVEMENT ) && tf_avoidteammates.GetBool() ) ||
		collisionGroup == TFCOLLISION_GROUP_ROCKETS || collisionGroup == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS )
	{
		switch( GetTeamNumber() )
		{
		case TF_TEAM_RED:
			if ( !( contentsMask & CONTENTS_REDTEAM ) )
				return false;
			break;

		case TF_TEAM_BLUE:
			if ( !( contentsMask & CONTENTS_BLUETEAM ) )
				return false;
			break;
		}
	}
	return BaseClass::ShouldCollide( collisionGroup, contentsMask );
}

//---------------------------------------
// Is the player the passed player class?
//---------------------------------------
bool CTFPlayer::IsPlayerClass( int iClass ) const
{
	const CTFPlayerClass *pClass = &m_PlayerClass;

	if ( !pClass )
		return false;

	return ( pClass->IsClass( iClass ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::CommitSuicide( bool bExplode /* = false */, bool bForce /*= false*/ )
{
	// Don't suicide if we haven't picked a class for the first time, or we're not in active state
	if ( IsPlayerClass( TF_CLASS_UNDEFINED ) || !m_Shared.InState( TF_STATE_ACTIVE ) )
		return;

	// Don't suicide during the "bonus time" if we're not on the winning team
	if ( !bForce && TFGameRules()->State_Get() == GR_STATE_TEAM_WIN && 
		 GetTeamNumber() != TFGameRules()->GetWinningTeam() )
	{
		return;
	}

	if ( TFGameRules()->ShowMatchSummary() )
		return;

	// No suicide while a ghost!
	if ( m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
		return;
	
	// No suicide while a kart
	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
		return;

	m_bSuicideExplode = bExplode;
	m_iSuicideCustomKillFlags = TF_DMG_CUSTOM_SUICIDE;

	BaseClass::CommitSuicide( bExplode, bForce );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &info - 
// Output : int
//-----------------------------------------------------------------------------
ConVar tf_preround_push_from_damage_enable( "tf_preround_push_from_damage_enable", "0", FCVAR_NONE, "If enabled, this will allow players using certain type of damage to move during pre-round freeze time." );
void CTFPlayer::ApplyPushFromDamage( const CTakeDamageInfo &info, Vector vecDir )
{
	// check if player can be moved
	if ( !tf_preround_push_from_damage_enable.GetBool() && !CanPlayerMove() )
		return;

	if ( m_bIsTargetDummy )
		return;

	Vector vecForce;
	vecForce.Init();
	if ( info.GetAttacker() == this )
	{
		Vector vecSize = WorldAlignSize();
		Vector hullSizeCrouch = VEC_DUCK_HULL_MAX - VEC_DUCK_HULL_MIN;

		if ( vecSize == hullSizeCrouch )
		{
			// Use the original hull for damage force calculation to ensure our RJ height doesn't change due to crouch hull increase
			// ^^ Comment above is an ancient lie, Ducking actually increases blast force, this value increases it even more 82 standing, 62 ducking, 55 modified
			vecSize.z = 55;
		}

		float flDamageForForce = info.GetDamageForForceCalc() ? info.GetDamageForForceCalc() : info.GetDamage();

		float flSelfPushMult = 1.0;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( info.GetWeapon(), flSelfPushMult, mult_dmgself_push_force );

		
		if ( IsPlayerClass( TF_CLASS_SOLDIER ) )
		{
			// Rocket Jump
			if ( (info.GetDamageType() & DMG_BLAST) )
			{
				if ( GetFlags() & FL_ONGROUND )
				{
					vecForce = vecDir * -DamageForce( vecSize, flDamageForForce, tf_damageforcescale_self_soldier_badrj.GetFloat() ) * flSelfPushMult;
				}
				else
				{
					vecForce = vecDir * -DamageForce( vecSize, flDamageForForce, tf_damageforcescale_self_soldier_rj.GetFloat() ) * flSelfPushMult;
				}

				SetBlastJumpState( TF_PLAYER_ROCKET_JUMPED );

				// Reset duck in air on self rocket impulse.
				m_Shared.SetAirDucked( 0 );
			}
			else
			{
				// Self Damage no force
				vecForce.Zero();
			}
			
		}
		else
		{
			// Detonator blast jump modifier
			if ( IsPlayerClass( TF_CLASS_PYRO ) && info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_EXPLOSION )
			{
				vecForce = vecDir * -DamageForce( vecSize, flDamageForForce, tf_damageforcescale_pyro_jump.GetFloat() ) * flSelfPushMult;
			}
			else
			{
				// Other Jumps (Stickies)
				vecForce = vecDir * -DamageForce( vecSize, flDamageForForce, DAMAGE_FORCE_SCALE_SELF ) * flSelfPushMult;
			}

			// Reset duck in air on self grenade impulse.
			m_Shared.SetAirDucked( 0 );
		}
		// Precision removes self damage so we don't want push force from damage
		if ( m_Shared.GetCarryingRuneType() == RUNE_PRECISION )
		{
			vecForce.Zero();
		}
	}
	else
	{
		// Don't let bot get pushed while they're in spawn area
		if ( m_Shared.InCond( TF_COND_INVULNERABLE_HIDE_UNLESS_DAMAGED ) || m_Shared.GetCarryingRuneType() == RUNE_KNOCKOUT )
		{
			return;
		}

		// Sentryguns push a lot harder
		if ( (info.GetDamageType() & DMG_BULLET) && info.GetInflictor() && info.GetInflictor()->IsBaseObject() )
		{
			float flSentryPushMultiplier = 16.f;
			CObjectSentrygun* pSentry = dynamic_cast<CObjectSentrygun*>( info.GetInflictor() );
			if ( pSentry )
			{
				flSentryPushMultiplier = pSentry->GetPushMultiplier();

				// Scale the force based on Distance, Wrangled Sentries should not push so hard at distance
				// get the distance between sentry and victim and lower push force if outside of attack range (wrangled)
				float flDistSqr = (pSentry->GetAbsOrigin() - GetAbsOrigin()).LengthSqr();
				if ( flDistSqr > SENTRY_MAX_RANGE_SQRD )
				{
					flSentryPushMultiplier *= 0.5f;
				}
			}
			vecForce = vecDir * -DamageForce( WorldAlignSize(), info.GetDamage(), flSentryPushMultiplier );
		}
		else
		{
			CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase*>(info.GetWeapon());
			if ( pWeapon && (pWeapon->GetWeaponID() == TF_WEAPON_COMPOUND_BOW) )
			{
				vecForce = vecDir * -DamageForce( WorldAlignSize(), info.GetDamage(), tf_damageforcescale_other.GetFloat() );
				vecForce.z = 0;
			}
			else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_PLASMA_CHARGED )
			{
				vecForce = vecDir * -DamageForce( WorldAlignSize(), info.GetDamage(), tf_damageforcescale_other.GetFloat() ) * 1.25f;
			}
			else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_PELLET)
			{
				float flTimeAlive = 0.0f;
				CTFProjectile_Flare *pFlare = dynamic_cast< CTFProjectile_Flare* >( info.GetInflictor() );
				if ( pFlare )
				{
					flTimeAlive = pFlare->GetTimeAlive();
				}
				vecForce = vecDir * -DamageForce( WorldAlignSize(), info.GetDamage(), TF_FLARE_PELLET_FORCE * RemapValClamped( flTimeAlive, 0.1f, 1.0f, 1.0f, TF_FLARE_PELLET_FORCE_DISTANCE_SCALE ) );
				vecForce.z = ( ( GetPlayerClass()->GetClassIndex() == TF_CLASS_HEAVYWEAPONS ) ? ( TF_FLARE_PELLET_FORCE_UPWARD_HEAVY ) : ( TF_FLARE_PELLET_FORCE_UPWARD ) );
			}
			else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_KART )
			{
				vecForce = info.GetDamageForce();
			}
			else
			{
				vecForce = vecDir * -DamageForce( WorldAlignSize(), info.GetDamage(), tf_damageforcescale_other.GetFloat() );
			}

			if ( IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
			{
				// Heavies take less push from non sentryguns
				vecForce *= 0.5;
			}

			CBaseEntity* pInflictor = info.GetInflictor();
			if ( pInflictor && CanScatterGunKnockBack(pWeapon, info.GetDamage(), (WorldSpaceCenter() - pInflictor->WorldSpaceCenter()).LengthSqr() ) )
			{
				// Remove all Z force from these shots if they are close enough and doing enough damage
				if ( vecForce.z < 0 )
				{
					vecForce.z = 0;
				}
			}

			int iAirBlast = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iAirBlast, damage_causes_airblast );
			if ( iAirBlast )
			{
				float force = -DamageForce( WorldAlignSize(), 100, 6 );
				ApplyAirBlastImpulse( force * vecDir );
				vecForce.Zero();
			}
		}

		bool bBigKnockback = false;

		CTFPlayer *pAttacker = ToTFPlayer( info.GetAttacker() );
		if ( pAttacker && pAttacker->IsPlayerClass( TF_CLASS_HEAVYWEAPONS )  && pAttacker->m_Shared.IsRageDraining() )
		{
			// Generic Rage attribute
			int iRage = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pAttacker, iRage, generate_rage_on_dmg );
			if ( iRage )
			{
				// In MvM, Heavies can purchase a knockback+stun effect
				float flPushMultiplier = ( iRage + 1 ) * 24.f;
				vecForce = vecDir * -DamageForce( WorldAlignSize(), info.GetDamage(), flPushMultiplier );
				bBigKnockback = true;

				// Track for achievements
				m_AchievementData.AddPusherToHistory( pAttacker );
			}
		}

		// Airblast effect for general attacks.  Scaled by range.
		float flImpactBlastForce = 1.f;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), flImpactBlastForce, damage_blast_push );
		if ( flImpactBlastForce != 1.f )
		{
			CBaseEntity *pInflictor = info.GetInflictor();
			if ( pInflictor )
			{
				const float flMaxPushBackDistSqr = 700.f * 700.f;
				float flDistSqr = ( WorldSpaceCenter() - pInflictor->WorldSpaceCenter() ).LengthSqr();
				if ( flDistSqr <= flMaxPushBackDistSqr )
				{
					if ( vecForce.z < 0 )
					{
						vecForce.z = 0;
					}

					m_Shared.StunPlayer( 0.3f, 1.f, TF_STUN_MOVEMENT | TF_STUN_MOVEMENT_FORWARD_ONLY, pAttacker );
					flImpactBlastForce = RemapValClamped( flDistSqr, 1000.f, flMaxPushBackDistSqr, flImpactBlastForce, ( flImpactBlastForce * 0.5f ) );
					float flForce = -DamageForce( WorldAlignSize(), info.GetDamage() * 2, flImpactBlastForce );
					ApplyAirBlastImpulse( flForce * vecDir );
				}
			}
		}

		if ( TFGameRules()->GameModeUsesUpgrades() )
		{
			if ( GetTeamNumber() == TF_TEAM_PVE_INVADERS )
			{
				// invading bots can't be pushed by sentry guns
				if ( info.GetInflictor() && info.GetInflictor()->IsBaseObject() )
				{
					return;
				}
			}

			if ( GetTeamNumber() == TF_TEAM_PVE_INVADERS && !bBigKnockback )
			{
				if ( IsMiniBoss() )
				{
					// Minibosses can't be pushed by anything except heavy rage and airblast (airblast is suppressed when deploying in deploy ai code)
					return;
				}
				else if ( m_nDeployingBombState != TF_BOMB_DEPLOYING_NONE && ( info.GetDamageType() & DMG_BLAST ) == 0 )
				{
					// Regular robots only get pushed by blast damage when deploying the bomb
					return;
				}
			}
		}

		float flDamageForceReduction = 1.f;
		CALL_ATTRIB_HOOK_FLOAT( flDamageForceReduction, damage_force_reduction );
		vecForce *= flDamageForceReduction;
	}

	ApplyAbsVelocityImpulse( vecForce );

	// If we were pushed by an enemy explosion, we're now marked as being blasted by an enemy.
	// If we stay on the ground, next frame our player think will remove this flag.
	if ( info.GetAttacker() != this && info.GetDamageType() & DMG_BLAST )
	{
		m_bTakenBlastDamageSinceLastMovement = true;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PlayDamageResistSound( float flStartDamage, float flModifiedDamage )
{
	if ( flStartDamage <= 0.f )
		return;

	// Spam control
	if ( gpGlobals->curtime - m_flLastDamageResistSoundTime <= 0.1f )
		return;

	// Play an absorb sound based on the percentage the damage has been reduced to
	float flDamagePercent = flModifiedDamage / flStartDamage;
	if ( flDamagePercent > 0.f && flDamagePercent < 1.f )
	{
		const char *pszSoundName = ( flDamagePercent >= 0.75f ) ? "Player.ResistanceLight" :
								   ( flDamagePercent <= 0.25f ) ? "Player.ResistanceHeavy" : "Player.ResistanceMedium";

		CSoundParameters params;
		if ( CBaseEntity::GetParametersForSound( pszSoundName, params, NULL ) )
		{
			CPASAttenuationFilter filter( GetAbsOrigin(), params.soundlevel );
			EmitSound_t ep( params );
			ep.m_flVolume *= RemapValClamped( flStartDamage, 1.f, 70.f, 0.7f, 1.f );
			EmitSound( filter, entindex(), ep );
			m_flLastDamageResistSoundTime = gpGlobals->curtime;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &info - 
// Output : int
//-----------------------------------------------------------------------------
int CTFPlayer::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
	if ( TFGameRules()->IsInItemTestingMode() && !IsFakeClient() )
		return 0;

	bool bUsingUpgrades = TFGameRules()->GameModeUsesUpgrades();

	// Always NULL check this below
	CTFPlayer *pTFAttacker = ToTFPlayer( info.GetAttacker() );

	CTFGameRules::DamageModifyExtras_t outParams;
	outParams.bIgniting = false;
	outParams.bSelfBlastDmg = false;
	outParams.bSendPreFeignDamage = false;
	outParams.bPlayDamageReductionSound = false;
	float realDamage = info.GetDamage();
	int iPreFeignDamage = realDamage;
	if ( TFGameRules() )
	{
		realDamage = TFGameRules()->ApplyOnDamageAliveModifyRules( info, this, outParams );

		if ( realDamage == -1 )
		{
			// Hard out requested from ApplyOnDamageModifyRules 
			return 0;
		}
	}

	if ( outParams.bPlayDamageReductionSound )
	{
		PlayDamageResistSound( info.GetDamage(), realDamage );
	}

	// Grab the vector of the incoming attack. 
	// (Pretend that the inflictor is a little lower than it really is, so the body will tend to fly upward a bit).
	Vector vecDir = vec3_origin;
	if ( info.GetInflictor() )
	{
		vecDir = info.GetInflictor()->WorldSpaceCenter() - Vector ( 0.0f, 0.0f, 10.0f ) - WorldSpaceCenter();
		info.GetInflictor()->AdjustDamageDirection( info, vecDir, this );
		VectorNormalize( vecDir );
	}
	g_vecAttackDir = vecDir;

	// Do the damage.
	m_bitsDamageType |= info.GetDamageType();

	// Check to see if the Wheatley sapper item is equipped and should react
	if ( m_bitsDamageType & DMG_BULLET &&  IsPlayerClass( TF_CLASS_SPY ) )
	{
		CBaseCombatWeapon *pRet = GetActiveWeapon();
		CTFWeaponSapper *pSap = dynamic_cast< CTFWeaponSapper* >( pRet );
		if ( pSap != NULL )
		{
			if (pSap->IsWheatleySapper())
			{
				pSap->WheatleyDamage();
			}
		}
	}

	float flBleedingTime = 0.0f;
	int iPrevHealth = m_iHealth;

	if ( m_takedamage != DAMAGE_EVENTS_ONLY )
	{
		if ( info.GetDamageCustom() != TF_DMG_CUSTOM_BLEEDING && !outParams.bSelfBlastDmg )
		{
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( info.GetWeapon(), flBleedingTime, bleeding_duration );
		}

		// Take damage - round to the nearest integer.
		int iOldHealth = m_iHealth;
		m_iHealth -= ( realDamage + 0.5f );

		if ( IsHeadshot( info.GetDamageCustom() ) && (m_iHealth <= 0) && (iOldHealth != 1) )
		{
			int iNoDeathFromHeadshots = 0;
			CALL_ATTRIB_HOOK_INT( iNoDeathFromHeadshots, no_death_from_headshots );
			if ( iNoDeathFromHeadshots == 1 )
			{
				m_iHealth = 1;
			}
		}

		// For lifeleech, calculate how much damage we actually inflicted.
		CTFPlayer *pAttackingPlayer = dynamic_cast<CTFPlayer *>( info.GetAttacker() );
		if ( pAttackingPlayer && pAttackingPlayer->GetActiveWeapon() )
		{
			float fLifeleechOnDamage = 0.0f;
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pAttackingPlayer->GetActiveWeapon(), fLifeleechOnDamage, lifeleech_on_damage );
			if ( fLifeleechOnDamage > 0.0f )
			{
				const float fActualDamageDealt = iOldHealth - m_iHealth;
				const float fHealAmount = fActualDamageDealt * fLifeleechOnDamage;

				if ( fHealAmount >= 0.5f )
				{
					const int iHealthToAdd = MIN( (int)(fHealAmount + 0.5f), pAttackingPlayer->m_Shared.GetMaxBuffedHealth() - pAttackingPlayer->GetHealth() );
					pAttackingPlayer->TakeHealth( iHealthToAdd, DMG_GENERIC );
				}
			}
		}

		// track accumulated sentry gun damage dealt by players
		if ( pTFAttacker )
		{
			// track amount of damage dealt by defender's sentry guns
			CObjectSentrygun *sentry = dynamic_cast< CObjectSentrygun * >( info.GetInflictor() );
			CTFProjectile_SentryRocket *sentryRocket = dynamic_cast< CTFProjectile_SentryRocket * >( info.GetInflictor() );

			if ( ( sentry && !sentry->IsDisposableBuilding() ) || sentryRocket )
			{
				int flooredHealth = clamp( m_iHealth, 0, m_iHealth );

				pTFAttacker->AccumulateSentryGunDamageDealt( iOldHealth - flooredHealth );
			}
		}
	}

	m_flLastDamageTime = gpGlobals->curtime;

	// Apply a damage force.
	CBaseEntity *pAttacker = info.GetAttacker();
	if ( !pAttacker )
		return 0;

	if ( ( info.GetDamageType() & DMG_PREVENT_PHYSICS_FORCE ) == 0 )
	{
		if ( info.GetInflictor() && ( GetMoveType() == MOVETYPE_WALK ) && 
		   ( !pAttacker->IsSolidFlagSet( FSOLID_TRIGGER ) ) && 
		   ( !m_Shared.InCond( TF_COND_DISGUISED ) ) )	
		{
			if ( !m_Shared.InCond( TF_COND_MEGAHEAL ) || outParams.bSelfBlastDmg )
			{
				ApplyPushFromDamage( info, vecDir );
			}
		}
	}

	if ( outParams.bIgniting && pTFAttacker )
	{
		m_Shared.Burn( pTFAttacker, dynamic_cast< CTFWeaponBase * >( info.GetWeapon() ) );
	}

	if ( flBleedingTime > 0 && pTFAttacker )
	{
		m_Shared.MakeBleed( pTFAttacker, dynamic_cast< CTFWeaponBase * >( info.GetWeapon() ), flBleedingTime );
	}

	// Don't recieve reflected damage if you are carrying Reflect (prevents a loop in a game with two Reflect players)
	if ( ( info.GetDamageType() & TF_DMG_CUSTOM_RUNE_REFLECT ) && m_Shared.GetCarryingRuneType() == RUNE_REFLECT )
	{
		return 0;
	}

	CTFWeaponBase *pTFWeapon = dynamic_cast< CTFWeaponBase * >( info.GetWeapon() );
	if ( pTFWeapon && WeaponID_IsSniperRifle( pTFWeapon->GetWeaponID() ) )
	{
		CTFSniperRifle *pSniper = dynamic_cast<CTFSniperRifle*>( pTFWeapon );
		if ( pSniper && ( pSniper->IsZoomed() || ( pSniper->GetWeaponID() == TF_WEAPON_SNIPERRIFLE_CLASSIC ) ) )
		{
			float flJarateTime = pSniper->GetJarateTime();
			if ( flJarateTime && !m_Shared.IsInvulnerable() && !m_Shared.InCond( TF_COND_PHASE ) && !m_Shared.InCond( TF_COND_PASSTIME_INTERCEPTION ) )
			{
				Vector vecOrigin = info.GetDamagePosition();
				CPVSFilter filter( vecOrigin );
				TE_TFParticleEffect( filter, 0.0, "peejar_impact_small", vecOrigin, vec3_angle );
				m_Shared.AddCond( TF_COND_URINE, flJarateTime );

				if ( pTFAttacker )
				{
					UTIL_LogPrintf( "\"%s<%i><%s><%s>\" triggered \"%s\" against \"%s<%i><%s><%s>\" with \"%s\" (attacker_position \"%d %d %d\") (victim_position \"%d %d %d\")\n",    
						pTFAttacker->GetPlayerName(),
						pTFAttacker->GetUserID(),
						pTFAttacker->GetNetworkIDString(),
						pTFAttacker->GetTeam()->GetName(),
						"jarate_attack",
						GetPlayerName(),
						GetUserID(),
						GetNetworkIDString(),
						GetTeam()->GetName(),
						"sniperrifle",
						(int)pTFAttacker->GetAbsOrigin().x, 
						(int)pTFAttacker->GetAbsOrigin().y,
						(int)pTFAttacker->GetAbsOrigin().z,
						(int)GetAbsOrigin().x, 
						(int)GetAbsOrigin().y,
						(int)GetAbsOrigin().z );

					// explosive jarate shot for a fully charged shot or headshot
					if ( pSniper->IsFullyCharged() || IsHeadshot( info.GetDamageCustom() ) || LastHitGroup() == HITGROUP_HEAD )
					{
						JarExplode( entindex(), pTFAttacker, pTFWeapon, pTFWeapon, info.GetDamagePosition(), pTFAttacker->GetTeamNumber(), 100.f, TF_COND_URINE, flJarateTime, "peejar_impact" );
					}
				}
			}

			if ( bUsingUpgrades && pTFAttacker )
			{
				int iExplosiveShot = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER ( pTFAttacker, iExplosiveShot, explosive_sniper_shot );
				if ( iExplosiveShot )
				{
					if ( IsHeadshot( info.GetDamageCustom() ) || ( flJarateTime && LastHitGroup() == HITGROUP_HEAD ) )
					{
						pSniper->ExplosiveHeadShot( pTFAttacker, this );
					}
				}
			}
		}
	}

	// Prevents a sandwich ignore-ammo-while-taking-damage-and-eating alias exploit
	if ( m_Shared.InCond( TF_COND_TAUNTING ) && m_Shared.GetTauntIndex() == TAUNT_BASE_WEAPON )
	{
		if ( IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
		{
			CTFLunchBox *pLunchBox = dynamic_cast <CTFLunchBox *> ( m_Shared.GetActiveTFWeapon() );
			if ( pLunchBox )
			{
				if ( pLunchBox->GetLunchboxType() != LUNCHBOX_ADDS_MAXHEALTH )
				{
					pLunchBox->DrainAmmo( true );
				}
			}
		}
	}

	// Fire a global game event - "player_hurt"
	IGameEvent * event = gameeventmanager->CreateEvent( "player_hurt" );
	if ( event )
	{
		event->SetInt( "userid", GetUserID() );
		event->SetInt( "health", MAX( 0, m_iHealth ) );

		// HLTV event priority, not transmitted
		event->SetInt( "priority", 5 );	

		int iDamageAmount = ( iPrevHealth - m_iHealth );
		event->SetInt( "damageamount", outParams.bSendPreFeignDamage ? iPreFeignDamage : iDamageAmount );

		// Hurt by another player.
		if ( pAttacker->IsPlayer() )
		{
			CBasePlayer *pPlayer = ToBasePlayer( pAttacker );
			event->SetInt( "attacker", pPlayer->GetUserID() );
			
			event->SetInt( "custom", info.GetDamageCustom() );
			event->SetBool( "showdisguisedcrit", m_bShowDisguisedCrit );
			event->SetBool( "crit", (info.GetDamageType() & DMG_CRITICAL) != 0 );
			event->SetBool( "minicrit", m_bMiniCrit );
			event->SetBool( "allseecrit", m_bAllSeeCrit );
			Assert( (int)m_eBonusAttackEffect < 256 );
			event->SetInt( "bonuseffect", (int)m_eBonusAttackEffect );

			if ( pTFAttacker && pTFAttacker->GetActiveTFWeapon() )
			{
				event->SetInt( "weaponid", pTFAttacker->GetActiveTFWeapon()->GetWeaponID() );
			}
		}
		// Hurt by world.
		else
		{
			event->SetInt( "attacker", 0 );
		}

        gameeventmanager->FireEvent( event );
	}
	
	if ( pTFAttacker && pTFAttacker != this )
	{
		pTFAttacker->RecordDamageEvent( info, (m_iHealth <= 0), iPrevHealth );
	}

	//No bleeding while invul or disguised.
	bool bBleed = ( ( m_Shared.InCond( TF_COND_DISGUISED ) == false || m_Shared.GetDisguiseTeam() != pAttacker->GetTeamNumber() )
					&& !m_Shared.IsInvulnerable() );

	// No bleed effects for DMG_GENERIC
	if ( info.GetDamageType() == 0 )
	{
		bBleed = false;
	}
										   
	// Except if we are really bleeding!
	bBleed |= m_Shared.InCond( TF_COND_BLEEDING );
	
	if ( bBleed && pTFAttacker )
	{
		CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
		if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_FLAMETHROWER )
		{
			bBleed = false;
		}
	}

	if ( bBleed && ( realDamage > 0.f ) )
	{
		Vector vDamagePos = info.GetDamagePosition();

		if ( vDamagePos == vec3_origin )
		{
			vDamagePos = WorldSpaceCenter();
		}

		if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
		{
			if ( ( IsMiniBoss() && static_cast< float >( GetHealth() ) / GetMaxHealth() > 0.3f ) || realDamage < 50 )
			{
				DispatchParticleEffect( "bot_impact_light", GetAbsOrigin(), vec3_angle );
			}
			else
			{
				DispatchParticleEffect( "bot_impact_heavy", GetAbsOrigin(), vec3_angle );
			}
		}
		else
		{
			CPVSFilter filter( vDamagePos );
			TE_TFBlood( filter, 0.0, vDamagePos, -vecDir, entindex() );
		}
	}

	if ( m_bIsTargetDummy )
	{
		// In the case of a targetdummy bot, restore any damage so it can never die
		TakeHealth( ( iPrevHealth - m_iHealth ), DMG_GENERIC );
	}

	m_vecFeignDeathVelocity = GetAbsVelocity();

	if ( pTFAttacker )
	{
		// If we're invuln, give whomever provided it rewards/credit
		if ( m_Shared.IsInvulnerable() && realDamage > 0.f )
		{
			// Medigun?
			CBaseEntity *pProvider = m_Shared.GetConditionProvider( TF_COND_INVULNERABLE );
			if ( !pProvider && bUsingUpgrades )
			{
				// Bottle?
				pProvider = m_Shared.GetConditionProvider( TF_COND_INVULNERABLE_USER_BUFF );
			}

			if ( pProvider )
			{
				CTFPlayer *pTFProvider = ToTFPlayer( pProvider );
				if ( pTFProvider )
				{
					if ( pTFProvider != pTFAttacker && bUsingUpgrades )
					{
						HandleRageGain( pTFProvider, kRageBuffFlag_OnHeal, ( realDamage / 2.f ), 1.f );
					}

					CTF_GameStats.Event_PlayerBlockedDamage( pTFProvider, realDamage );
				}
			}
		}

		// Give the attacker's medic Energy based on damage done
		CBaseEntity *pProvider = pTFAttacker->m_Shared.GetConditionProvider( TF_COND_HEALTH_BUFF );
		if ( pProvider )
		{
			CTFPlayer *pTFProvider = ToTFPlayer( pProvider );
			if ( pTFProvider && pTFProvider->IsPlayerClass( TF_CLASS_MEDIC ) )
			{
				// Cap to prevent insane values coming from headshots and backstabs
				float flAmount = Min( realDamage, 250.f ) / 10.f;
				HandleRageGain( ToTFPlayer( pProvider ), kRageBuffFlag_OnHeal, flAmount, 1.f );
			}
		}
	}

	// Done.
	return 1;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &info - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFPlayer::ShouldGib( const CTakeDamageInfo &info )
{
	// Check to see if we should allow players to gib.
	if ( tf_playergib.GetInt() != 1 )
	{
		if ( tf_playergib.GetInt() < 1 )
			return false;
		else
			return true;
	}

	// normal players/bots don't gib in MvM
	if ( TFGameRules()->IsMannVsMachineMode() )
		return false;

	// Suicide explode always gibs.
	if ( m_bSuicideExplode )
	{
		m_bSuicideExplode = false;
		return true;
	}

	// Are we set up to gib always on critical hits?
	if ( info.GetDamageType() & DMG_CRITICAL )
	{
		int iAlwaysGibOnCrit = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iAlwaysGibOnCrit, crit_kill_will_gib );
		if ( iAlwaysGibOnCrit )
			return true;
	}

	int iCritOnHardHit = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iCritOnHardHit, crit_on_hard_hit );
	if ( iCritOnHardHit == 0 )
	{
		// Only blast & half falloff damage can gib.
		if ( ( (info.GetDamageType() & DMG_BLAST) == 0 ) &&
			( (info.GetDamageType() & DMG_HALF_FALLOFF) == 0 ) )
			return false;
	}

	// Explosive crits always gib.
	if ( info.GetDamageType() & DMG_CRITICAL )
		return true;

	// Hard hits also gib.
	if ( GetHealth() <= -10 )
		return true;
	
	if ( m_bGoingFeignDeath )
	{
		// The player won't actually have negative health,
		// but spies often gib from explosive damage so we should make that likely here.
		float frand = (float) rand() / VALVE_RAND_MAX;
		return (frand>0.15f) ? true : false;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::HasBombinomiconEffectOnDeath( void )
{
	int iBombinomicomEffectOnDeath = 0;
	CALL_ATTRIB_HOOK_INT( iBombinomicomEffectOnDeath, bombinomicon_effect_on_death );

	return ( iBombinomicomEffectOnDeath != 0 );
}

//-----------------------------------------------------------------------------
// Purpose: Figures out if there is a special assist responsible for our death.
// Must be called before conditions are cleared druing death.
//-----------------------------------------------------------------------------
void CTFPlayer::DetermineAssistForKill( const CTakeDamageInfo &info )
{
	CTFPlayer *pPlayerAttacker = ToTFPlayer( info.GetAttacker() );
	if ( !pPlayerAttacker )
		return;

	CTFPlayer *pPlayerAssist = NULL;

	if ( m_Shared.GetConditionAssistFromVictim() )
	{
		// If we are covered in urine, mad milk, etc, then give the provider an assist.
		pPlayerAssist = ToTFPlayer( m_Shared.GetConditionAssistFromVictim() );
	}

	if ( m_Shared.IsControlStunned() )
	{
		// If we've been stunned, the stunner gets credit for the assist.
		pPlayerAssist = m_Shared.GetStunner();
	}

	// Can't assist ourself.
	if ( pPlayerAttacker && (pPlayerAttacker != pPlayerAssist) )
	{
		m_Shared.SetAssist( pPlayerAssist );
	}
	else
	{
		m_Shared.SetAssist( NULL );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::Event_KilledOther( CBaseEntity *pVictim, const CTakeDamageInfo &info )
{
	BaseClass::Event_KilledOther( pVictim, info );

	if ( pVictim->IsPlayer() )
	{
		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );

		if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
		{
			if ( pTFVictim && pTFVictim->IsBot() && ( pTFVictim->GetTeamNumber() == TF_TEAM_PVE_INVADERS ) )
			{
				if ( pTFVictim->GetDeployingBombState() > TF_BOMB_DEPLOYING_NONE )
				{
					IGameEvent *event = gameeventmanager->CreateEvent( "mvm_kill_robot_delivering_bomb" );
					if ( event )
					{
						event->SetInt( "player", entindex() );
						gameeventmanager->FireEvent( event );
					}
				}
			}
		}

		// Custom death handlers
		// TODO: Need a system here!  This conditional is getting pretty big.
		const char *pszCustomDeath = "customdeath:none";
		if ( info.GetAttacker() && info.GetAttacker()->IsBaseObject() )
		{
			pszCustomDeath = "customdeath:sentrygun";
		}
		else if ( info.GetInflictor() && info.GetInflictor()->IsBaseObject() )
		{
			CBaseObject* pObj = dynamic_cast<CBaseObject*>( info.GetInflictor() );
			if ( pObj->IsMiniBuilding() )
			{
				pszCustomDeath = "customdeath:minisentrygun";
			}
			else
			{
				pszCustomDeath = "customdeath:sentrygun";
			}
		}
		else if ( IsHeadshot( info.GetDamageCustom() ) )
		{				
			pszCustomDeath = "customdeath:headshot";
		}
		else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB )
		{
			pszCustomDeath = "customdeath:backstab";
		}
		else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING )
		{
			pszCustomDeath = "customdeath:burning";
		}
		else if ( IsTauntDmg( info.GetDamageCustom() ) )
		{
			pszCustomDeath = "customdeath:taunt";
		}
		else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING_FLARE )
		{
			pszCustomDeath = "customdeath:flareburn";
		}

		// Revenge handler
		const char *pszDomination = "domination:none";
		if ( pTFVictim->GetDeathFlags() & (TF_DEATH_REVENGE|TF_DEATH_ASSISTER_REVENGE) )
		{
			pszDomination = "domination:revenge";
		}
		else if ( pTFVictim->GetDeathFlags() & TF_DEATH_DOMINATION )
		{
			pszDomination = "domination:dominated";
		}

		const char *pszVictimStunned = "victimstunned:0";
		if ( pTFVictim->m_Shared.InCond( TF_COND_STUNNED ) )
		{
			pszVictimStunned = "victimstunned:1";
		}

		const char *pszVictimDoubleJumping = "victimdoublejumping:0";
		if ( pTFVictim->m_Shared.GetAirDash() > 0 )
		{
			pszVictimDoubleJumping = "victimdoublejumping:1";
		}

		CFmtStrN<128> modifiers( "%s,%s,%s,%s,victimclass:%s", pszCustomDeath, pszDomination, pszVictimStunned, pszVictimDoubleJumping, g_aPlayerClassNames_NonLocalized[ pTFVictim->GetPlayerClass()->GetClassIndex() ] );

		bool bPlayspeech = true;

		// Don't play speech if this kill disguises the spy
		if ( IsPlayerClass( TF_CLASS_SPY ) )
		{
			if ( !Q_stricmp( "customdeath:backstab", pszCustomDeath ) )
			{
				CTFKnife *pKnife = dynamic_cast<CTFKnife *>( GetActiveTFWeapon() );
				if ( pKnife && pKnife->GetKnifeType() == KNIFE_DISGUISE_ONKILL )
				{
					bPlayspeech = false;
				}
			}
		}

		if ( bPlayspeech )
		{
			SpeakConceptIfAllowed( MP_CONCEPT_KILLED_PLAYER, modifiers );
		}

		CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(info.GetWeapon());
		if ( pWeapon )
		{
			pWeapon->OnPlayerKill( pTFVictim, info );

			int iCritBoost = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritBoost, add_onkill_critboost_time );
			if ( iCritBoost )
			{
				// Perceptually, people seem to think the effect is shorter than the stated time, so we cheat by adding a tad more for that
				m_Shared.AddCond( TF_COND_CRITBOOSTED_ON_KILL, iCritBoost+1 );
			}

			int iMiniCritBoost = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBoost, add_onkill_minicritboost_time );
			if ( iMiniCritBoost )
			{
				// Perceptually, people seem to think the effect is shorter than the stated time, so we cheat by adding a tad more for that
				m_Shared.AddCond( TF_COND_ENERGY_BUFF, iMiniCritBoost + 1 );
			}
		}

		// Check for CP_Foundry achievements
		if ( FStrEq( "cp_foundry", STRING( gpGlobals->mapname ) ) )
		{
			if ( pTFVictim && ( pTFVictim->GetTeamNumber() != GetTeamNumber() ) )
			{
				if ( pTFVictim->IsCapturingPoint() )
				{
					if ( info.GetDamageType() & DMG_CRITICAL )
					{
						AwardAchievement( ACHIEVEMENT_TF_MAPS_FOUNDRY_KILL_CAPPING_ENEMY );
					}
				}

				if ( InAchievementZone( pTFVictim ) )
				{
					IGameEvent *event = gameeventmanager->CreateEvent( "player_killed_achievement_zone" );
					if ( event )
					{
						event->SetInt( "attacker", entindex() );
						event->SetInt( "victim", pTFVictim->entindex() );
						gameeventmanager->FireEvent( event );
					}
				}
			}
		}
		
		// Check for SD_Doomsday achievements		
		if ( FStrEq( "sd_doomsday", STRING( gpGlobals->mapname ) ) )
		{
			if ( pTFVictim && ( pTFVictim->GetTeamNumber() != GetTeamNumber() ) )
			{
				// find the flag in the map
				CCaptureFlag *pFlag = NULL;
				for ( int i=0; i<ICaptureFlagAutoList::AutoList().Count(); ++i )
				{
					pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[i] );
					if ( !pFlag->IsDisabled() )
					{
						break;
					}
				}

				// was the victim in an achievement zone?
				CAchievementZone *pZone = InAchievementZone( pTFVictim );
				if ( pZone )
				{
					int iZoneID = pZone->GetZoneID();
					if ( iZoneID == 0 )
					{
						if ( pFlag && pFlag->IsHome() )
						{
							AwardAchievement( ACHIEVEMENT_TF_MAPS_DOOMSDAY_DENY_NEUTRAL_PICKUP );
						}
					}
					else
					{
						IGameEvent *event = gameeventmanager->CreateEvent( "player_killed_achievement_zone" );
						if ( event )
						{
							event->SetInt( "attacker", entindex() );
							event->SetInt( "victim", pTFVictim->entindex() );
							event->SetInt( "zone_id", iZoneID );
							gameeventmanager->FireEvent( event );
						}
					}
				}

				// check the flag carrier to see if the victim has recently damaged them
				if ( pFlag && pFlag->IsStolen() )
				{
					CTFPlayer *pFlagCarrier = ToTFPlayer( pFlag->GetOwnerEntity() );
					if ( pFlagCarrier && ( pFlagCarrier->GetTeamNumber() == GetTeamNumber() ) )
					{
						// has the victim damaged the flag carrier in the last 3 seconds?
						if ( pFlagCarrier->m_AchievementData.IsDamagerInHistory( pTFVictim, 3.0 ) )
						{
							AwardAchievement( ACHIEVEMENT_TF_MAPS_DOOMSDAY_DEFEND_CARRIER );
						}
					}
				}
			}
		}

		// Check for CP_Snakewater achievement
		if ( FStrEq( "cp_snakewater_final1", STRING( gpGlobals->mapname ) ) )
		{
			if ( pTFVictim && ( pTFVictim->GetTeamNumber() != GetTeamNumber() ) )
			{
				if ( InAchievementZone( pTFVictim ) )
				{
					IGameEvent *event = gameeventmanager->CreateEvent( "player_killed_achievement_zone" );
					if ( event )
					{
						event->SetInt( "attacker", entindex() );
						event->SetInt( "victim", pTFVictim->entindex() );
						gameeventmanager->FireEvent( event );
					}
				}
			}
		}

		if ( IsPlayerClass( TF_CLASS_DEMOMAN ) )
		{
			if ( pVictim->GetTeamNumber() != GetTeamNumber() )
			{
				// Check if this kill should refill the charge meter
				CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(info.GetWeapon());

				float flRefill = 0.0f;
				CALL_ATTRIB_HOOK_FLOAT( flRefill, kill_refills_meter );
				if ( m_Shared.GetCarryingRuneType() == RUNE_KNOCKOUT ) // Knockout powerup restricts charge 
				{
					flRefill *= 0.2;
				}

				if ( flRefill > 0 && ((info.GetDamageType() & DMG_MELEE) || ( info.GetDamageCustom() == TF_DMG_CUSTOM_CHARGE_IMPACT ) ) )
				{
					m_Shared.SetDemomanChargeMeter( m_Shared.GetDemomanChargeMeter() + flRefill * 100.0f );
				}

				if ( ( pWeapon && pWeapon->IsCurrentAttackDuringDemoCharge() ) || ( info.GetDamageCustom() == TF_DMG_CUSTOM_CHARGE_IMPACT ) )
				{	
					if ( flRefill > 0 )
					{
						IGameEvent *event = gameeventmanager->CreateEvent( "kill_refills_meter" );
						if ( event )
						{
							event->SetInt( "index", entindex() );
							gameeventmanager->FireEvent( event );
						}
					}

					if ( pTFVictim )
					{
						// could the attacker see this player when the charge started?
						if ( m_Shared.m_hPlayersVisibleAtChargeStart.Find( pTFVictim ) == m_Shared.m_hPlayersVisibleAtChargeStart.InvalidIndex() )
						{
							AwardAchievement( ACHIEVEMENT_TF_DEMOMAN_KILL_PLAYER_YOU_DIDNT_SEE );
						}
					}
				}

				// Demoman achievement:  Kill at least 3 players capping or pushing the cart with the same detonation
				CTriggerAreaCapture *pAreaTrigger = pTFVictim->GetControlPointStandingOn();
				if ( pAreaTrigger )
				{
					CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint();
					if ( pCP )
					{
						if ( pCP->GetOwner() == GetTeamNumber() )
						{
							if ( GetActiveTFWeapon() && ( GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_PIPEBOMBLAUNCHER ) )
							{
								// Add victim to our list
								int iIndex = m_Cappers.Find( pTFVictim->GetUserID() );
								if ( iIndex != m_Cappers.InvalidIndex() )
								{
									// they're already in our list
									m_Cappers[iIndex] = gpGlobals->curtime;
								}
								else
								{
									// we need to add them
									m_Cappers.Insert( pTFVictim->GetUserID(), gpGlobals->curtime );
								}
								// Did we get three?
								if ( m_Cappers.Count() >= 3 )
								{
									// Traverse the list, comparing the recorded time to curtime
									int iHitCount = 0;
									FOR_EACH_MAP_FAST ( m_Cappers, cIndex )
									{
										// For each match, increment counter
										if ( gpGlobals->curtime <= m_Cappers[cIndex] + 0.1f )
										{
											iHitCount++;
										}
										else
										{
											m_Cappers.Remove( cIndex );
										}
										
										// If we hit 3, award and purge the group
										if ( iHitCount >= 3 )
										{
											AwardAchievement( ACHIEVEMENT_TF_DEMOMAN_KILL_X_CAPPING_ONEDET );
											m_Cappers.RemoveAll();
										}					
									}
								}
							}
						}
						// Kill players defending "x" times
						else
						{
							// If we're able to cap the point...
							if ( TeamplayGameRules()->TeamMayCapturePoint( GetTeamNumber(), pCP->GetPointIndex() ) && 
								TeamplayGameRules()->PlayerMayCapturePoint( this, pCP->GetPointIndex() ) )
							{
								AwardAchievement( ACHIEVEMENT_TF_DEMOMAN_KILL_X_DEFENDING );
							}
						}
					}
				}
			}
		}

		// Sniper Kill Rage
		if ( IsPlayerClass( TF_CLASS_SNIPER ) )
		{
			// Item attribute
			// Add Sniper Rage On Kills
			float flRageGain = 0;
			CALL_ATTRIB_HOOK_FLOAT( flRageGain, rage_on_kill );
			if (flRageGain != 0)
			{
				m_Shared.ModifyRage(flRageGain);
			}
			
		}

		for ( int i=0; i<m_Shared.m_nNumHealers; i++ )
		{
			m_Shared.m_aHealers[i].iKillsWhileBeingHealed++;
			if ( IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
			{
				if ( m_Shared.m_aHealers[i].iKillsWhileBeingHealed >= 5 && m_Shared.m_aHealers[i].bDispenserHeal )
				{
					// We got five kills while being healed by this dispenser. Reward the engineer with an achievement!
					CTFPlayer *pHealScorer = ToTFPlayer( m_Shared.m_aHealers[i].pHealScorer );
					if ( pHealScorer && pHealScorer->IsPlayerClass( TF_CLASS_ENGINEER ) )
					{
						pHealScorer->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_HEAVY_ASSIST );
					}
				}
			}
		}

		OnKilledOther_Effects( pVictim, info );

		// track accumulated sentry gun kills on owning player for Sentry Busters in MvM (so they can't clear this by rebuilding their sentry)
		CObjectSentrygun *sentry = dynamic_cast< CObjectSentrygun * >( info.GetInflictor() );
		CTFProjectile_SentryRocket *sentryRocket = dynamic_cast< CTFProjectile_SentryRocket * >( info.GetInflictor() );

		if ( ( sentry && !sentry->IsDisposableBuilding() ) || sentryRocket )
		{
			IncrementSentryGunKillCount();
		}

		// Halloween Death Ghosts
		// Check the weapon I used to kill with this player and if it has my desired attribute
		if ( TF_IsHolidayActive( kHoliday_HalloweenOrFullMoon ) )
		{
			int iHalloweenDeathGhosts = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iHalloweenDeathGhosts, halloween_death_ghosts );
			if ( iHalloweenDeathGhosts > 0 )
			{
				if ( pTFVictim->GetTeam()->GetTeamNumber() == TF_TEAM_BLUE )
				{
					DispatchParticleEffect( "halloween_player_death_blue", pTFVictim->GetAbsOrigin() + Vector( 0, 0, 32 ), vec3_angle );
				}
				else if ( pTFVictim->GetTeam()->GetTeamNumber() == TF_TEAM_RED )
				{
					DispatchParticleEffect( "halloween_player_death", pTFVictim->GetAbsOrigin() + Vector( 0, 0, 32 ), vec3_angle );
				}
			}
		}

		DropDeathCallingCard( this, pTFVictim );

		if ( pTFVictim != this )
		{
			for ( int i=0; i<GetNumWearables(); ++i )
			{
				CTFWearableLevelableItem *pItem = dynamic_cast< CTFWearableLevelableItem* >( GetWearable(i) );
				if ( pItem )
				{
					pItem->IncrementLevel();
				}
			}
		}

		if ( pTFVictim )
		{
			// was the victim on a control point (includes payload carts)
			CTriggerAreaCapture *pAreaTrigger = pTFVictim->GetControlPointStandingOn();
			if ( pAreaTrigger )
			{
				CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint();
				if ( pCP && ( pCP->GetOwner() != pTFVictim->GetTeamNumber() ) )
				{
					if ( TeamplayGameRules()->TeamMayCapturePoint( pTFVictim->GetTeamNumber(), pCP->GetPointIndex() ) &&
						TeamplayGameRules()->PlayerMayCapturePoint( pTFVictim, pCP->GetPointIndex() ) )
					{
						CTFPlayer *pTFAssister = NULL;
						if ( TFGameRules() ) 
						{
							pTFAssister = ToTFPlayer( TFGameRules()->GetAssister( pTFVictim, this, info.GetInflictor() ) );
						}

						IGameEvent *event = gameeventmanager->CreateEvent( "killed_capping_player" );
						if ( event )
						{
							event->SetInt( "cp", pCP->GetPointIndex() );
							event->SetInt( "killer", entindex() );
							event->SetInt( "victim", pTFVictim->entindex() );
							event->SetInt( "assister", pTFAssister ? pTFAssister->entindex() : -1 );
							event->SetInt( "priority", 9 );

							gameeventmanager->FireEvent( event );
						}
					}
				}
			}
		}
	}
	else
	{
		if ( pVictim->IsBaseObject() )
		{
			CBaseObject *pObject = dynamic_cast<CBaseObject *>( pVictim );
			SpeakConceptIfAllowed( MP_CONCEPT_KILLED_OBJECT, pObject->GetResponseRulesModifier() );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called on kill for primary and second-highest damage dealer
//-----------------------------------------------------------------------------
void CTFPlayer::OnKilledOther_Effects( CBaseEntity *pVictim, const CTakeDamageInfo &info )
{
	int iHealOnKill = 0;

	if ( IsPlayerClass( TF_CLASS_SPY ) )
	{
		int iCloakOnKill = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( GetActiveWeapon(), iCloakOnKill, add_cloak_on_kill );
		if ( iCloakOnKill > 0 )
		{
			m_Shared.AddToSpyCloakMeter( iCloakOnKill, true );
		}
	}

	CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>( info.GetWeapon() );
	if ( !pWeapon )
		return;

	int iRestoreHealthToPercentageOnKill = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iRestoreHealthToPercentageOnKill, restore_health_on_kill );

	if ( iRestoreHealthToPercentageOnKill > 0 )
	{
		// This attribute should ignore runes
		int iRestoreMax = GetMaxHealth() - GetRuneHealthBonus();
		// We add one here to deal with a bizarre problem that comes up leaving you one health short sometimes
		// due to bizarre floating point rounding or something equally silly.
		int iTargetHealth = ( int )( ( ( float )iRestoreHealthToPercentageOnKill / 100.0f ) * ( float )iRestoreMax ) + 1;

		int iBaseMaxHealth = GetMaxHealth() * 1.5,
			iNewHealth = Min( GetHealth() + iTargetHealth, iBaseMaxHealth ),
			iDeltaHealth = Max(iNewHealth - GetHealth(), 0);

		TakeHealth( iDeltaHealth, DMG_IGNORE_MAXHEALTH );
	}

	CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iHealOnKill, heal_on_kill );
	if ( iHealOnKill != 0 )
	{
		int iHealthToAdd = MIN( iHealOnKill, m_Shared.GetMaxBuffedHealth() - m_iHealth );
		TakeHealth( iHealthToAdd, DMG_GENERIC );
		//m_iHealth += iHealthToAdd;

		IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
		if ( event )
		{
			event->SetInt( "amount", iHealthToAdd );
			event->SetInt( "entindex", entindex() );
			item_definition_index_t healingItemDef = INVALID_ITEM_DEF_INDEX;
			if ( pWeapon->GetAttributeContainer() && pWeapon->GetAttributeContainer()->GetItem() )
			{
				healingItemDef = pWeapon->GetAttributeContainer()->GetItem()->GetItemDefIndex();
			}
			event->SetInt( "weapon_def_index", healingItemDef );
			gameeventmanager->FireEvent( event ); 
		}
	}

	int iSpeedBoostOnKill = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iSpeedBoostOnKill, speed_boost_on_kill );
	if ( iSpeedBoostOnKill )
	{
		m_Shared.AddCond( TF_COND_SPEED_BOOST, iSpeedBoostOnKill );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::Event_Killed( const CTakeDamageInfo &info )
{
	CTFPlayer *pPlayerAttacker = NULL;
	if ( info.GetAttacker() && info.GetAttacker()->IsPlayer() )
	{
		pPlayerAttacker = ToTFPlayer( info.GetAttacker() );
	}

	CTFWeaponBase *pKillerWeapon = NULL;
	if ( pPlayerAttacker )
	{
		pKillerWeapon = dynamic_cast < CTFWeaponBase * > ( info.GetWeapon() );
	}

	if ( m_Shared.InCond( TF_COND_TAUNTING ) )
	{
		static CSchemaItemDefHandle dosidoTaunt( "Square Dance Taunt" );
		static CSchemaItemDefHandle congaTaunt( "Conga Taunt" );
		if ( GetTauntEconItemView() )
		{
			if ( GetTauntEconItemView()->GetItemDefinition() == dosidoTaunt )
			{
				if ( pKillerWeapon && ( pKillerWeapon->GetTFWpnData().m_iWeaponType == TF_WPN_TYPE_MELEE ) )
				{
					if ( pPlayerAttacker )
					{
						pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_TAUNT_DOSIDO_MELLE_KILL );
					}
				}
			}
			else if ( GetTauntEconItemView()->GetItemDefinition() == congaTaunt )
			{
				if ( pPlayerAttacker )
				{
					IGameEvent *event = gameeventmanager->CreateEvent( "conga_kill" );
					if ( event )
					{
						event->SetInt( "index", pPlayerAttacker->entindex() );
						gameeventmanager->FireEvent( event );
					}
				}
			}
		}

		StopTaunt();
	}

	// Cheat this death!
	if ( m_Shared.InCond( TF_COND_HALLOWEEN_IN_HELL ) )
	{
		// Turn into a ghost
		m_Shared.RemoveAllCond();
		m_Shared.AddCond( TF_COND_HALLOWEEN_GHOST_MODE );

		// Create a puff right where we died to mask the ghost spawning in
		DispatchParticleEffect( "ghost_appearation", PATTACH_ABSORIGIN, this );

		// Check for achievement
		if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TRIGGER_HURT )
		{
			if ( TFGameRules() && TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
			{
				CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 1, 5.0 );
				if ( pRecentDamager )
				{
					pRecentDamager->AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_HELLTOWER_ENVIRONMENTAL_KILLS );
				}
			}
		}

		CTakeDamageInfo ghostinfo = info;

		// If we were killed by "the world", then give credit to the next damager in the list
		CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 1, 10.0 );

		// If killed by trigger hurt, get last attacker
		if ( info.GetAttacker() == info.GetInflictor() && info.GetAttacker() && info.GetAttacker()->IsBSPModel() )
		{
			if ( pRecentDamager )
			{
				ghostinfo.SetAttacker( pRecentDamager );
				
				if ( TFGameRules() && TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
				{
					ghostinfo.SetDamageCustom( TF_DMG_CUSTOM_KART );
					pRecentDamager->AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_DOOMSDAY_KILL_KARTS );
					HatAndMiscEconEntities_OnOwnerKillEaterEvent( pRecentDamager, this, kKillEaterEvent_Halloween_UnderworldKills );
				}
			}
			// if no recent damager, check for HHH
			else if ( m_flHHHKartAttackTime > gpGlobals->curtime - 15.0f )
			{
				ghostinfo.SetDamageCustom( TF_DMG_CUSTOM_DECAPITATION_BOSS );	
			}
		}

		if ( pRecentDamager )
		{
			// Score the "kill". We don't want any of the other logic, so short circuit here.
			pRecentDamager->Event_KilledOther( this, ghostinfo );

			IGameEvent *pEvent = gameeventmanager->CreateEvent( "kill_in_hell" );
			if ( pEvent )
			{
				pEvent->SetInt( "killer", pRecentDamager->GetUserID() );
				pEvent->SetInt( "victim", GetUserID() );
				gameeventmanager->FireEvent( pEvent, true );
			}
		}

		FeignDeath( ghostinfo );

		// Have 1 HP
		m_iHealth = 1;
		return;
	}

	SpeakConceptIfAllowed( MP_CONCEPT_DIED );

	StateTransition( TF_STATE_DYING );	// Transition into the dying state.

	if ( pPlayerAttacker )
	{
		if ( TFGameRules()->IsIT( this ) )
		{
			// I was IT - transfer to my killer
			TFGameRules()->SetIT( pPlayerAttacker );
		}

		if ( pPlayerAttacker != this )
		{
			if ( CTFPlayerDestructionLogic::GetRobotDestructionLogic() && ( CTFPlayerDestructionLogic::GetRobotDestructionLogic()->GetType() == CTFPlayerDestructionLogic::TYPE_PLAYER_DESTRUCTION ) )
			{
				// was this the team leader?
				if ( CTFPlayerDestructionLogic::GetRobotDestructionLogic()->GetTeamLeader( GetTeamNumber() ) == this )
				{
					IGameEvent * event = gameeventmanager->CreateEvent( "team_leader_killed" );
					if ( event )
					{
						event->SetInt( "killer", pPlayerAttacker->entindex() );
						event->SetInt( "victim", entindex() );
						gameeventmanager->FireEvent( event );
					}
				}
			}
		}
	}

	m_bIsTeleportingUsingEurekaEffect = false;

	for ( int i=0; i<GetNumWearables(); ++i )
	{
		CTFWearableLevelableItem *pItem = dynamic_cast< CTFWearableLevelableItem* >( GetWearable(i) );
		if ( pItem )
		{
			pItem->ResetLevel();
		}
	}

/*
	// We're going to save this for a future date
	if ( pPlayerAttacker )
	{
		if ( pPlayerAttacker != this )
		{
			// Killed by another player
			if ( ( TFGameRules()->GetBirthdayPlayer() == this ) || ( TFGameRules()->GetBirthdayPlayer() == NULL ) )
			{
				// I was the birthday player (or we don't have one) - transfer to my killer
				TFGameRules()->SetBirthdayPlayer( pPlayerAttacker );
			}
		}
		else
		{
			// Suicide
			if ( TFGameRules()->GetBirthdayPlayer() == this )
			{
				// I was the birthday player - reset for suicide
				TFGameRules()->SetBirthdayPlayer( NULL );
			}
		}
	}
*/
	bool bOnGround = GetFlags() & FL_ONGROUND;
	bool bElectrocuted = false;
	bool bDisguised = m_Shared.InCond( TF_COND_DISGUISED );
	// we want the rag doll to burn if the player was burning and was not a pyro (who only burns momentarily)
	bool bBurning = m_Shared.InCond( TF_COND_BURNING ) && ( TF_CLASS_PYRO != GetPlayerClass()->GetClassIndex() );
	CTFPlayer *pOriginalBurner = m_Shared.GetOriginalBurnAttacker();
	CTFPlayer *pLastBurner = m_Shared.GetBurnAttacker();

	if ( m_aBurnFromBackAttackers.Count() > 0 )
	{
		CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(info.GetWeapon());
		if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_FLAMETHROWER )
		{
			for ( int i = 0; i < m_aBurnFromBackAttackers.Count(); i++ )
			{
				CTFPlayer *pBurner = ToTFPlayer( m_aBurnFromBackAttackers[i].Get() );

				if ( pBurner )
				{
					pBurner->AwardAchievement( ACHIEVEMENT_TF_PYRO_KILL_FROM_BEHIND );
				}
			}
		}

		ClearBurnFromBehindAttackers();
	}

	if ( IsPlayerClass( TF_CLASS_MEDIC ) )
	{
		CWeaponMedigun* pMedigun = assert_cast<CWeaponMedigun*>( Weapon_OwnsThisID( TF_WEAPON_MEDIGUN ) );
		float flChargeLevel = pMedigun ? pMedigun->GetChargeLevel() : 0.f;
		float flMinChargeLevel = pMedigun ? pMedigun->GetMinChargeAmount() : 1.f;

		bool bCharged = flChargeLevel >= flMinChargeLevel;

		if ( bCharged )
		{
			// Had an ubercharge ready at death?
			CEconEntity *pVictimEconWeapon = dynamic_cast<CEconEntity *>( GetActiveTFWeapon() );
			EconEntity_OnOwnerKillEaterEventNoPartner( pVictimEconWeapon, this, kKillEaterEvent_NEGATIVE_UbersDropped );

			bElectrocuted = true;
			if ( pPlayerAttacker )
			{
				if ( pPlayerAttacker->IsPlayerClass( TF_CLASS_SCOUT ) )
				{
					pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SCOUT_KILL_CHARGED_MEDICS );
				}
				else if ( pPlayerAttacker->IsPlayerClass( TF_CLASS_SNIPER ) )
				{
					pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SNIPER_KILL_CHARGED_MEDIC );
				}
				else if ( pPlayerAttacker->IsPlayerClass( TF_CLASS_SPY ) )
				{
					if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB )
					{
						pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SPY_BACKSTAB_MEDIC_CHARGED );
					}
				}

				CTF_GameStats.Event_PlayerAwardBonusPoints( pPlayerAttacker, this, 20 );
			}
		}

		// Disable radius healing
		m_Shared.Heal_Radius( false );

		IGameEvent * event = gameeventmanager->CreateEvent( "medic_death" );
		if ( event )
		{
			int iHealing = 0;

			PlayerStats_t *pPlayerStats = CTF_GameStats.FindPlayerStats( this );
			if ( pPlayerStats )
			{
				iHealing = pPlayerStats->statsCurrentLife.m_iStat[TFSTAT_HEALING];

				// defensive fix for the moment for bug where healing value becomes bogus sometimes: if bogus, slam it to 0
				// ...copied from CTFGameRules::CalcPlayerScore()
				if ( iHealing < 0 || iHealing > 10000000 )
				{
					iHealing = 0;
				}
			}

			event->SetInt( "userid", GetUserID() );
			event->SetInt( "attacker", pPlayerAttacker ? pPlayerAttacker->GetUserID() : 0 );
			event->SetInt( "healing", iHealing );
			event->SetBool( "charged", bCharged );

			gameeventmanager->FireEvent( event );
		}
	}
	else if ( IsPlayerClass( TF_CLASS_SOLDIER ) || IsPlayerClass( TF_CLASS_DEMOMAN ) )
	{
		if ( pPlayerAttacker && pPlayerAttacker->IsPlayerClass( TF_CLASS_SNIPER ) && RocketJumped() && !GetGroundEntity() ) 
		{
			if ( pKillerWeapon )
			{
				if ( WeaponID_IsSniperRifleOrBow( pKillerWeapon->GetWeaponID() ) )
				{
					pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SNIPER_KILL_RJER );
				}

				if ( pKillerWeapon->GetWeaponID() == TF_WEAPON_SNIPERRIFLE_CLASSIC )
				{
					if ( ( info.GetDamageCustom() == TF_DMG_CUSTOM_HEADSHOT ) && ( info.GetDamageType() & DMG_CRITICAL ) )
					{
						if ( pPlayerAttacker->m_Shared.IsAiming() == false )
						{
							pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SNIPER_CLASSIC_RIFLE_HEADSHOT_JUMPER );
						}
					}
				}
			}
		}
	}
	else if ( IsPlayerClass( TF_CLASS_ENGINEER ) )
	{
		if ( pPlayerAttacker && pPlayerAttacker->IsPlayerClass( TF_CLASS_SOLDIER ) )
		{
			// Has Engineer worked on his sentrygun recently?
			CBaseObject	*pSentry = GetObjectOfType( OBJ_SENTRYGUN );
			if ( pSentry && m_AchievementData.IsTargetInHistory( pSentry, 4.0 ) )
			{
				if ( pSentry->m_AchievementData.CountDamagersWithinTime( 3.0 ) > 0 )
				{
					pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SOLDIER_KILL_ENGY );
				}
			}
		}

		if ( m_Shared.IsCarryingObject() )
		{
			CTakeDamageInfo info( pPlayerAttacker, pPlayerAttacker, NULL, vec3_origin, GetAbsOrigin(), 0, DMG_GENERIC );
			info.SetDamageCustom( TF_DMG_CUSTOM_CARRIED_BUILDING );
			if ( m_Shared.GetCarriedObject() != NULL )
			{
				m_Shared.GetCarriedObject()->Killed( info );

				// Killeater event for being killed while carrying a building
				CEconEntity *pVictimEconWeapon = dynamic_cast<CEconEntity *>( Weapon_OwnsThisID( TF_WEAPON_WRENCH ) );
				EconEntity_OnOwnerKillEaterEventNoPartner( pVictimEconWeapon, this, kKillEaterEvent_NEGATIVE_DeathsWhileCarryingBuilding );
			}
		}
	}
	else if ( IsPlayerClass( TF_CLASS_SNIPER ) )
	{
		if ( pPlayerAttacker )
		{
			if ( GetActiveTFWeapon() && ( GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_SNIPERRIFLE_CLASSIC ) )
			{
				if ( pKillerWeapon && ( pKillerWeapon->GetTFWpnData().m_iWeaponType == TF_WPN_TYPE_MELEE ) )
				{
					pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_MELEE_KILL_CLASSIC_RIFLE_SNIPER );
				}
			}
		}
	}

	if ( pPlayerAttacker )
	{
		if ( pPlayerAttacker->IsPlayerClass( TF_CLASS_SOLDIER ) )
		{
			if ( pPlayerAttacker->RocketJumped() || (gpGlobals->curtime - pPlayerAttacker->m_flBlastJumpLandTime) < 1 )
			{
				if ( pKillerWeapon && pKillerWeapon->GetWeaponID() == TF_WEAPON_SHOVEL )
				{
					CTFShovel *pShovel = static_cast< CTFShovel* >( pKillerWeapon );
					if ( pShovel && pShovel->GetShovelType() == SHOVEL_DAMAGE_BOOST )
					{
						pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SOLDIER_RJ_EQUALIZER_KILL );
					}
				}
			}
		}
		else if ( pPlayerAttacker->IsPlayerClass( TF_CLASS_SNIPER ) )
		{
			if ( pKillerWeapon && WeaponID_IsSniperRifle( pKillerWeapon->GetWeaponID() ) && pPlayerAttacker->m_Shared.IsAiming() == false )
			{
				pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SNIPER_KILL_UNSCOPED );
			}

			if ( pKillerWeapon && ( pKillerWeapon->GetWeaponID() == TF_WEAPON_SNIPERRIFLE_CLASSIC ) )
			{
				if ( ( info.GetDamageCustom() == TF_DMG_CUSTOM_HEADSHOT ) && ( info.GetDamageType() & DMG_CRITICAL ) )
				{
					if ( pPlayerAttacker->m_Shared.IsAiming() == false )
					{
						pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SNIPER_CLASSIC_RIFLE_NOSCOPE_HEADSHOT );
					}
				}
			}
		}
		else if ( pPlayerAttacker->IsPlayerClass( TF_CLASS_SPY ) )
		{
#ifdef STAGING_ONLY
			// Move to Killed Other
			// Spy Tranq Buff
			if ( m_Shared.InCond( TF_COND_TRANQ_MARKED ) && info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB )
			{
				int iTranq = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayerAttacker, iTranq, override_projectile_type );
				if ( iTranq == TF_PROJECTILE_TRANQ )
				{
					// BIGGEST HACK EVER
					int iDesiredClass = GetPlayerClass()->GetClassIndex();

					if ( iDesiredClass != TF_CLASS_SPY )
					{
						pPlayerAttacker->GetPlayerClass()->Init( iDesiredClass );

						for ( int i = 0; i < MAX_WEAPONS; i++ )
						{
							CTFWeaponBase *pWeapon = (CTFWeaponBase *)pPlayerAttacker->GetWeapon( i );
							if ( pWeapon )
							{
								pWeapon->OnOwnerClassChange();
							}
						}

						pPlayerAttacker->RemoveAllItems( true );

						// TODO: move this into conditions
						pPlayerAttacker->RemoveTeleportEffect();

						// remove invisibility very quickly	
						pPlayerAttacker->m_Shared.FadeInvis( 0.1f );

						// Stop any firing that was taking place before respawn.
						pPlayerAttacker->m_nButtons = 0;

						// Possibly Save and set their health percentage here
						Vector vAttackerPos = pPlayerAttacker->GetAbsOrigin();
						QAngle qAttackerAngle = pPlayerAttacker->GetAbsAngles();

						pPlayerAttacker->StateTransition( TF_STATE_ACTIVE );
						pPlayerAttacker->Spawn();

						pPlayerAttacker->Teleport( &vAttackerPos, &qAttackerAngle, &vec3_origin );

						pPlayerAttacker->m_Shared.AddCond( TF_COND_SPY_CLASS_STEAL );

						// Overheal
						pPlayerAttacker->SetHealth( pPlayerAttacker->GetMaxHealth() * 1.5f );

						// Steal their uber
						if ( IsPlayerClass( TF_CLASS_MEDIC ) )
						{
							// Steal Enemy Uber
							CWeaponMedigun *pMedigun = (CWeaponMedigun *)Weapon_OwnsThisID( TF_WEAPON_MEDIGUN );
							if ( pMedigun )
							{
								float flCharge = pMedigun->GetChargeLevel();
								CWeaponMedigun *pAttackerMedigun = (CWeaponMedigun *)pPlayerAttacker->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN );
								if ( pAttackerMedigun )
								{
									pAttackerMedigun->AddCharge( flCharge );
								}
							}
						}

						// Steal Rage
						pPlayerAttacker->m_Shared.SetRageMeter( m_Shared.GetRageMeter() );
						
						// Steal heads
						pPlayerAttacker->m_Shared.SetDecapitations( m_Shared.GetDecapitations() );

						// Effects
						//pPlayerAttacker->EmitSound( "Player.Spy_Disguise" );
						pPlayerAttacker->EmitSound( "WeaponDNAGun.Transform" );
						Vector vOrigin = pPlayerAttacker->GetAbsOrigin();
						CPVSFilter filter( vOrigin );

						switch ( pPlayerAttacker->GetTeamNumber() )
						{
						case TF_TEAM_RED:
							TE_TFParticleEffect( filter, 0.0, "teleported_red", vOrigin, vec3_angle );
							TE_TFParticleEffect( filter, 0.0, "player_sparkles_red", vOrigin, vec3_angle, pPlayerAttacker, PATTACH_POINT );
							break;
						case TF_TEAM_BLUE:
							TE_TFParticleEffect( filter, 0.0, "teleported_blue", vOrigin, vec3_angle );
							TE_TFParticleEffect( filter, 0.0, "player_sparkles_blue", vOrigin, vec3_angle, pPlayerAttacker, PATTACH_POINT );
							break;
						default:
							break;
						}
					}
				}
			}
#endif // STAGING_ONLY
			CTriggerAreaCapture *pAreaTrigger = GetControlPointStandingOn();
			if ( pAreaTrigger )
			{
				CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint();
				if ( pCP )
				{
					if ( pCP->GetOwner() == GetTeamNumber() )
					{
						// killed on a control point owned by my team
						pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SPY_KILL_CP_DEFENDERS );
					}
					else
					{
						// killed on a control point NOT owned by my team, was it a backstab?
						if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB )
						{
							// was i able to capture the control point?
							if ( TeamplayGameRules()->TeamMayCapturePoint( GetTeamNumber(), pCP->GetPointIndex() ) && 
								 TeamplayGameRules()->PlayerMayCapturePoint( this, pCP->GetPointIndex() ) )
							{
								pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SPY_BACKSTAB_CAPPING_ENEMIES );
							}
						}
					}
				}
			}

			if ( IsPlayerClass( TF_CLASS_ENGINEER ) )
			{
				//m_AchievementData.CountTargetsWithinTime
				int iHistory = 0;
				EntityHistory_t *pHistory = m_AchievementData.GetTargetHistory( iHistory );

				while ( pHistory )
				{
					if ( pHistory->hEntity && pHistory->hEntity->IsBaseObject() && m_AchievementData.IsTargetInHistory( pHistory->hEntity, 1.0f ) )
					{
						CBaseObject *pObject = dynamic_cast<CBaseObject *>( pHistory->hEntity.Get() );
					
						if ( pObject->ObjectType() == OBJ_SENTRYGUN )
						{
							pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SPY_KILL_WORKING_ENGY );
							break;
						}
					}

					iHistory++;
					pHistory = m_AchievementData.GetTargetHistory( iHistory );
				}
			}
		}
		else if ( pPlayerAttacker->IsPlayerClass( TF_CLASS_DEMOMAN ) )
		{
			// Kill "x" players with a direct pipebomb hit
			if ( pPlayerAttacker->GetActiveTFWeapon() && ( pPlayerAttacker->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_GRENADELAUNCHER ) )
			{
				CBaseEntity *pInflictor = info.GetInflictor();
		
				if ( pInflictor && pInflictor->IsPlayer() == false )
				{
					CTFGrenadePipebombProjectile *pBaseGrenade = dynamic_cast< CTFGrenadePipebombProjectile* >( pInflictor );

					if ( pBaseGrenade && pBaseGrenade->m_bTouched != true )
					{
						pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_DEMOMAN_KILL_X_WITH_DIRECTPIPE );
					}
				}
			}
		}
		else if ( pPlayerAttacker->IsPlayerClass( TF_CLASS_ENGINEER ) )
		{
			// give achievement for killing someone who was recently damaged by our sentry
			// note that we don't check to see if the sentry is still alive
			if ( pKillerWeapon &&
				( pKillerWeapon->GetWeaponID() == TF_WEAPON_SENTRY_REVENGE ||
				pKillerWeapon->GetWeaponID() == TF_WEAPON_SHOTGUN_PRIMARY ) )
			{
				if ( m_AchievementData.IsSentryDamagerInHistory( pPlayerAttacker, 5.0 ) )
				{
					pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_SHOTGUN_KILL_PREV_SENTRY_TARGET );
				}
			}
		}

		// Revenge Crits for Diamondback
		if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB )
		{
			pPlayerAttacker->m_Shared.IncrementRevengeCrits();
		}
	}

	// Check for CP_Foundry achievement
	if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TRIGGER_HURT )
	{
		if ( FStrEq( "cp_foundry", STRING( gpGlobals->mapname ) ) )
		{
			CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 1, 5.0 );
			if ( pRecentDamager )
			{
				pRecentDamager->AwardAchievement( ACHIEVEMENT_TF_MAPS_FOUNDRY_PUSH_INTO_CAULDRON );
			}
		}
	}

	// Record if we were stunned for achievement tracking.
	m_iOldStunFlags = m_Shared.GetStunFlags();

	// Determine the optional assist for the kill.
	DetermineAssistForKill( info );

	// put here to stop looping kritz sound from playing til respawn.
	if ( m_Shared.InCond( TF_COND_CRITBOOSTED ) )
	{
		StopSound( "TFPlayer.CritBoostOn" );
	}

	if ( m_Shared.InCond( TF_COND_HALLOWEEN_BOMB_HEAD ) )
	{
		SetPendingMerasmusPlayerBombExplode();
	}

	// check for MvM achievements
	if ( TFGameRules()->IsMannVsMachineMode() && IsBot() )
	{
		if ( pPlayerAttacker && ( pPlayerAttacker->GetTeamNumber() == TF_TEAM_PVE_DEFENDERS ) )
		{
			if ( FStrEq( "mvm_mannhattan", STRING( gpGlobals->mapname ) ) )
			{
				CTFBot *pBot = dynamic_cast< CTFBot* >( this );
				if ( pBot )
				{
					// kill gate bots
					if ( pBot->HasTag( "bot_gatebot" ) )
					{
						pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_MVM_MAPS_MANNHATTAN_BOMB_BOT_GRIND );
					}
				}

				// kill stunned bots
				if ( m_Shared.InCond( TF_COND_MVM_BOT_STUN_RADIOWAVE ) )
				{
					if ( g_pPopulationManager->IsAdvancedPopFile() )
					{
						IGameEvent *event = gameeventmanager->CreateEvent( "mvm_adv_wave_killed_stun_radio" );
						if ( event )
						{
							gameeventmanager->FireEvent( event );
						}
					}
				}
			}
		}
	}

	// Reset our model if we were disguised
	if ( bDisguised )
	{
		UpdateModel();
	}

	RemoveTeleportEffect();

	// Drop a pack with their leftover ammo
	// Arena: Only do this if the match hasn't started yet.
	if ( ShouldDropAmmoPack() )
	{
		DropAmmoPack( info, false, false );
	}

	if ( TFGameRules()->IsInMedievalMode() )
	{
		DropHealthPack( info, true );
	}

#ifdef TF_RAID_MODE
	// Bots sometimes drop health kits in Raid Mode
	if ( TFGameRules()->IsRaidMode() && GetTeamNumber() == TF_TEAM_RED )
	{
		if ( RandomInt( 1, 100 ) <= tf_raid_drop_healthkit_chance.GetInt() )
		{
			DropHealthPack( info, true );
		}
	}
#endif // TF_RAID_MODE

	// PvE mode credits/currency
	if ( TFGameRules()->IsMannVsMachineMode() )
	{
		MannVsMachineStats_PlayerEvent_Died( this );

		if ( IsBot() )
		{
			m_nCurrency = 0;
			if ( !IsMissionEnemy() && m_pWaveSpawnPopulator )
			{
				m_nCurrency = m_pWaveSpawnPopulator->GetCurrencyAmountPerDeath();
			}

			// only drop currency if the map designer has specified it
			if ( m_nCurrency > 0 )
			{
				// We only drop a pack when the game's accumulated enough to make it worth it
				int nDropAmount = TFGameRules()->CalculateCurrencyAmount_CustomPack( m_nCurrency );
				if ( nDropAmount )
				{
					bool bDropPack = true;

					// Give money directly to the team if a trigger killed us
					if ( info.GetDamageType() )
					{
						CBaseTrigger *pTrigger = dynamic_cast< CBaseTrigger *>( info.GetInflictor() );
						if ( pTrigger )
						{
							bDropPack = false;	
							TFGameRules()->DistributeCurrencyAmount( nDropAmount, NULL, true, true );
						}
					}

					if ( bDropPack )
					{
						CTFPlayer* pMoneyMaker = NULL;
						if ( pPlayerAttacker && pPlayerAttacker->IsPlayerClass( TF_CLASS_SNIPER ) )
						{
							if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BLEEDING || ( pKillerWeapon && WeaponID_IsSniperRifleOrBow( pKillerWeapon->GetWeaponID() ) ) )
							{
								pMoneyMaker = pPlayerAttacker;

								if ( IsHeadshot( info.GetDamageCustom() ) || ( LastHitGroup() == HITGROUP_HEAD && pKillerWeapon && pKillerWeapon->GetJarateTime() ) )
								{
									IGameEvent *event = gameeventmanager->CreateEvent( "mvm_sniper_headshot_currency" );
									if ( event )
									{
										event->SetInt( "userid", pPlayerAttacker->GetUserID() );
										event->SetInt( "currency", nDropAmount );
										gameeventmanager->FireEvent( event );
									}
								}
							}
						}

						int iForceDistributeCurrency = 0;
						CALL_ATTRIB_HOOK_INT( iForceDistributeCurrency, force_distribute_currency_on_death );
						bool bForceDistribute = iForceDistributeCurrency != 0;

						// if I'm force to distribute currency, just give the credit to the attacker
						if ( !pMoneyMaker && bForceDistribute )
						{
							pMoneyMaker = pPlayerAttacker;
						}

						DropCurrencyPack( TF_CURRENCY_PACK_CUSTOM, nDropAmount, bForceDistribute, pMoneyMaker );
					}
				}
			}

			if ( !m_bIsSupportEnemy )
			{
				unsigned int iFlags = m_bIsMissionEnemy ? MVM_CLASS_FLAG_MISSION : MVM_CLASS_FLAG_NORMAL;
				if ( IsMiniBoss() )
				{
					iFlags |= MVM_CLASS_FLAG_MINIBOSS;
				}

				TFObjectiveResource()->DecrementMannVsMachineWaveClassCount( GetPlayerClass()->GetClassIconName(), iFlags );
			}

			if ( m_bIsLimitedSupportEnemy )
			{
				TFObjectiveResource()->DecrementMannVsMachineWaveClassCount( GetPlayerClass()->GetClassIconName(), MVM_CLASS_FLAG_SUPPORT_LIMITED );
			}

			// Electrical effect whenever a bot dies
			CPVSFilter filter( WorldSpaceCenter() );
			TE_TFParticleEffect( filter, 0.f, "bot_death", GetAbsOrigin(), vec3_angle );
		}
		else
		{
			// Players lose money for dying
			RemoveCurrency( tf_mvm_death_penalty.GetInt() );
		}

		// tell the population manager a player died
		// THIS MUST HAPPEN AFTER THE CURRENCY CALCULATION (ABOVE)
		// NOW THAT WE'RE CALCULATING CURRENCY ON-DEATH INSTEAD OF ON-SPAWN
		if ( g_pPopulationManager )
		{
			g_pPopulationManager->OnPlayerKilled( this );
		}

		if ( IsBot() && HasTheFlag() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
		{
			int nLevel = TFObjectiveResource()->GetFlagCarrierUpgradeLevel();
			IGameEvent *event = gameeventmanager->CreateEvent( "mvm_bomb_carrier_killed" );
			if ( event )
			{
				event->SetInt( "level", nLevel );
				gameeventmanager->FireEvent( event );
			}
		}

		if ( !IsBot() && !m_hReviveMarker )
		{
			m_hReviveMarker = CTFReviveMarker::Create( this );
		}
	}

	// This system is designed to coarsely measure a player's skill in public pvp games.
//	UpdateSkillRatingData();

#ifdef STAGING_ONLY
	if ( TFGameRules()->IsBountyMode() )
	{
		// Lose unspent currency on death?
		float flPenalty = tf_bountymode_currency_penalty_ondeath.GetFloat();
		if ( flPenalty )
		{
			int nAmount = GetCurrency();
			if ( nAmount )
			{
				nAmount *= ( 1.f - flPenalty );
				SetCurrency( Max( nAmount, 0 ) );
			}
		}

		if ( tf_bountymode_upgrades_wipeondeath.GetInt() )
		{
			// Remove upgrade attributes from the player and their items
			if ( g_hUpgradeEntity )
			{
				g_hUpgradeEntity->GrantOrRemoveAllUpgrades( this, true, false );
			}

			// Remove the appropriate upgrade info from upgrade histories
			if ( g_pPopulationManager )
			{
				g_pPopulationManager->RemovePlayerAndItemUpgradesFromHistory( this );
			}
		}
	}
#endif // STAGING_ONLY

	if ( pPlayerAttacker )
	{
		int iDropHealthOnKill = 0;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pPlayerAttacker, iDropHealthOnKill, drop_health_pack_on_kill );
		if ( iDropHealthOnKill == 1 )
		{
			DropHealthPack( info, true );
		}

		int iKillForcesAttackerToLaugh = 0;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pPlayerAttacker, iKillForcesAttackerToLaugh, kill_forces_attacker_to_laugh );
		if ( iKillForcesAttackerToLaugh == 1 )
		{
			// force yourself to laugh!
			pPlayerAttacker->Taunt( TAUNT_MISC_ITEM, MP_CONCEPT_TAUNT_LAUGH );
		}
	}

	// If the player has a capture flag and was killed by another player, award that player a defense
	if ( HasItem() && pPlayerAttacker && ( pPlayerAttacker != this ) )
	{
		CCaptureFlag *pCaptureFlag = dynamic_cast<CCaptureFlag *>( GetItem() );
		if ( pCaptureFlag )
		{
			IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_flag_event" );
			if ( event )
			{
				event->SetInt( "player", pPlayerAttacker->entindex() );
				event->SetInt( "eventtype", TF_FLAGEVENT_DEFEND );
				event->SetInt( "carrier", entindex() );
				event->SetInt( "priority", 8 );
				event->SetInt( "team", pCaptureFlag->GetTeamNumber() );
				gameeventmanager->FireEvent( event );
			}
			CTF_GameStats.Event_PlayerDefendedPoint( pPlayerAttacker );

			if ( !CTFPlayerDestructionLogic::GetRobotDestructionLogic() || ( CTFPlayerDestructionLogic::GetRobotDestructionLogic()->GetType() != CTFPlayerDestructionLogic::TYPE_PLAYER_DESTRUCTION ) )
			{
				if ( pPlayerAttacker && pPlayerAttacker->IsPlayerClass( TF_CLASS_SNIPER ) )
				{
					CTFWeaponBase *pKillerWeapon = dynamic_cast < CTFWeaponBase * > ( info.GetWeapon() );

					if ( pKillerWeapon && pKillerWeapon->GetWeaponID() == TF_WEAPON_COMPOUND_BOW )
					{
						pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_SNIPER_BOW_KILL_FLAGCARRIER );
					}
				}

				// Handle the "you killed someone with the flag" event. We can't handle this with the usual block
				// in PlayerKilled() because by that point we've forgotten that we had the flag.
				EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pKillerWeapon ), pPlayerAttacker, this, kKillEaterEvent_DefenderKill );
			}
		}
	}

	CTFWeaponBase* pActiveWeapon = GetActiveTFWeapon();
	if( pActiveWeapon  )
	{
		CEconEntity *pVictimEconWeapon = dynamic_cast<CEconEntity *>( pActiveWeapon );

		EconEntity_OnOwnerKillEaterEventNoPartner( pVictimEconWeapon, this, kKillEaterEvent_NEGATIVE_Deaths );

		// Check if we died from environmental damage
		CBaseTrigger *pTrigger = dynamic_cast< CBaseTrigger *>( info.GetInflictor() );
		if ( pTrigger )
		{
			EconEntity_OnOwnerKillEaterEventNoPartner( pVictimEconWeapon, this, kKillEaterEvent_NEGATIVE_DeathsFromEnvironment );
		}
		
		// Check if we died from fall damage
		if( info.GetDamageType() == DMG_FALL )
		{
			EconEntity_OnOwnerKillEaterEventNoPartner( pVictimEconWeapon, this, kKillEaterEvent_NEGATIVE_DeathsFromCratering );
		}
	}
	
	ClearZoomOwner();

	m_vecLastDeathPosition = GetAbsOrigin();

	CTakeDamageInfo info_modified = info;

	// Ragdoll, gib, or death animation.
	bool bRagdoll = true;
	bool bGib = false;

	// See if we should gib.
	if ( ShouldGib( info ) )
	{
		bGib = true;
		bRagdoll = false;
	}
	else
	// See if we should play a custom death animation.
	{
		// If this was a rocket/grenade kill that didn't gib, exaggerated the blast force
		if ( ( info.GetDamageType() & DMG_BLAST ) != 0 )
		{
			Vector vForceModifier = info.GetDamageForce();
			vForceModifier.x *= 2.5;
			vForceModifier.y *= 2.5;
			vForceModifier.z *= 2;
			info_modified.SetDamageForce( vForceModifier );
		}
	}

	if ( bElectrocuted && bGib )
	{
		const char *pEffectName = ( GetTeamNumber() == TF_TEAM_RED ) ? "electrocuted_gibbed_red" : "electrocuted_gibbed_blue";
		DispatchParticleEffect( pEffectName, GetAbsOrigin(), vec3_angle );
		EmitSound( "TFPlayer.MedicChargedDeath" );
	}
	
	SetGibbedOnLastDeath( bGib );

	bool bIsMvMRobot = TFGameRules()->IsMannVsMachineMode() && IsBot();
	if ( bGib && !bIsMvMRobot && IsPlayerClass( TF_CLASS_SCOUT ) && RandomInt( 1, 100 ) <= SCOUT_ADD_BIRD_ON_GIB_CHANCE )
	{
		Vector vecPos = WorldSpaceCenter();
		SpawnClientsideFlyingBird( vecPos );
	}

	// show killer in death cam mode
	// chopped down version of SetObserverTarget without the team check
	if( pPlayerAttacker )
	{
		// See if we were killed by a sentrygun. If so, look at that instead of the player
		if ( info.GetInflictor() && info.GetInflictor()->IsBaseObject() )
		{
			// Catches the case where we're killed directly by the sentrygun (i.e. bullets)
			// Look at the sentrygun
			m_hObserverTarget.Set( info.GetInflictor() ); 
		}
		// See if we were killed by a projectile emitted from a base object. The attacker
		// will still be the owner of that object, but we want the deathcam to point to the 
		// object itself.
		else if ( info.GetInflictor() && info.GetInflictor()->GetOwnerEntity() && 
					info.GetInflictor()->GetOwnerEntity()->IsBaseObject() )
		{
			m_hObserverTarget.Set( info.GetInflictor()->GetOwnerEntity() );
		}
		else
		{
			// Look at the player
			if ( m_Shared.InCond( TF_COND_HALLOWEEN_IN_HELL ) )
			{
				m_hObserverTarget.Set( pPlayerAttacker ); 
			}
			else
			{
				m_hObserverTarget.Set( info.GetAttacker() ); 
			}
		}

		// reset fov to default
		SetFOV( this, 0 );
	}
	else if ( info.GetAttacker() && info.GetAttacker()->IsBaseObject() )
	{
		// Catches the case where we're killed by entities spawned by the sentrygun (i.e. rockets)
		// Look at the sentrygun. 
		m_hObserverTarget.Set( info.GetAttacker() ); 
	}
	else if ( info.GetAttacker() && TFGameRules()->GetActiveBoss() && info.GetAttacker()->entindex() == TFGameRules()->GetActiveBoss()->entindex() )
	{
		// killed by the boss - look at him
		m_hObserverTarget.Set( info.GetAttacker() ); 
	}
	else
	{
		m_hObserverTarget.Set( NULL );
	}

	bool bSuicide = false;
	if ( info_modified.GetDamageCustom() == TF_DMG_CUSTOM_SUICIDE )
	{
		bSuicide = true;
		// if this was suicide, recalculate attacker to see if we want to award the kill to a recent damager
		info_modified.SetAttacker( TFGameRules()->GetDeathScorer( info.GetAttacker(), info.GetInflictor(), this ) );
	}
	else if ( info.GetAttacker() == this )
	{
		bSuicide = true;
		// If we killed ourselves in non-suicide fashion, and we've been hurt lately, give that guy the kill.
		CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 0, 5.0 );
		if ( pRecentDamager )
		{
			info_modified.SetDamageCustom( TF_DMG_CUSTOM_SUICIDE );
			info_modified.SetDamageType( DMG_GENERIC );
			info_modified.SetAttacker( pRecentDamager );
			info_modified.SetWeapon( NULL );
			info_modified.SetInflictor( NULL );
		}
	}
	else if	( info.GetAttacker() == info.GetInflictor() && info.GetAttacker() && info.GetAttacker()->IsBSPModel() )
	{
		bSuicide = true;
		if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
		{
			// If we were killed by "the world", then give credit to the next damager in the list
			CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 1, 10.0 );
			if ( pRecentDamager )
			{
				//info_modified.SetDamageCustom( TF_DMG_CUSTOM_SUICIDE );
				info_modified.SetDamageType( DMG_GENERIC );
				info_modified.SetAttacker( pRecentDamager );
				info_modified.SetWeapon( NULL );
				info_modified.SetInflictor( NULL );
			}
		}
		else
		{
			// If we were killed by "the world", then give credit to the next damager in the list
			CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 1, 5.0 );
			if ( pRecentDamager )
			{
				info_modified.SetDamageCustom( TF_DMG_CUSTOM_SUICIDE );
				info_modified.SetDamageType( DMG_GENERIC );
				info_modified.SetAttacker( pRecentDamager );
				info_modified.SetWeapon( NULL );
				info_modified.SetInflictor( NULL );
			}
			else if ( TFGameRules() && TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) && ( info_modified.GetDamageType() & DMG_CLUB ) )
			{
				info_modified.SetDamageCustom( TF_DMG_CUSTOM_GIANT_HAMMER );
				info_modified.SetDamageType( info_modified.GetDamageType() | DMG_CRITICAL );
			}
		}
	}

	if ( pPlayerAttacker && pPlayerAttacker->m_Shared.InCond( TF_COND_HALLOWEEN_TINY ) && !pPlayerAttacker->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
	{
		info_modified.SetDamageCustom( TF_DMG_CUSTOM_SPELL_TINY );
		if ( TFGameRules() && TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
		{
			pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_DOOMSDAY_TINY_SMASHER );
		}
	}

	if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
	{
		// Report Kill
		CTF_GameStats.Event_PowerUpModeDeath( pPlayerAttacker, this );
	}

	// Drop your powerup rune when you die 
	if ( m_Shared.IsCarryingRune() )
	{
		int iTeam = GetEnemyTeam( GetTeamNumber() ); // Dead players drop opposing team colored powerups
		CTFRune::CreateRune( GetAbsOrigin(), m_Shared.GetCarryingRuneType(), iTeam, true, false );
	}

	// in PD, player death adds points to the flag drop
	if ( CTFPlayerDestructionLogic::GetRobotDestructionLogic()
		&& CTFPlayerDestructionLogic::GetRobotDestructionLogic()->GetType() == CTFPlayerDestructionLogic::TYPE_PLAYER_DESTRUCTION )
	{
		CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 0, 5.0 );
		int pointsOnDeath = ( !bSuicide || pRecentDamager ) ? CTFPlayerDestructionLogic::GetPlayerDestructionLogic()->GetPointsOnPlayerDeath() : 0;

		CCaptureFlag *pFlag = NULL;
		if ( HasItem() )
		{
			pFlag = dynamic_cast<CCaptureFlag*>( GetItem() );
		}
		else
		{
			if ( pointsOnDeath && !PointInRespawnRoom( this, WorldSpaceCenter() ) )
			{
				pFlag = CCaptureFlag::Create( GetAbsOrigin(), CTFPlayerDestructionLogic::GetPlayerDestructionLogic()->GetPropModelName(), TF_FLAGTYPE_PLAYER_DESTRUCTION );
			}
		}

		if ( pFlag )
		{
			// don't add more point to the dropping flag if the player suicided
			if ( pointsOnDeath )
			{
				pFlag->AddPointValue( pointsOnDeath );
			}
			pFlag->Drop( this, true, true, true );
		}
	}

	CTFPlayerResource *pResource = dynamic_cast<CTFPlayerResource *>( g_pPlayerResource );
	if ( pResource )
	{
		pResource->SetPlayerClassWhenKilled( entindex(), GetPlayerClass()->GetClassIndex() );
	}

	BaseClass::Event_Killed( info_modified );

	if ( !m_bSwitchedClass )
	{
		SaveLastWeaponSlot();
	}
	// Remove all items...
	RemoveAllItems( true );

	for ( int iWeapon = 0; iWeapon < TF_PLAYER_WEAPON_COUNT; ++iWeapon )
	{
		CTFWeaponBase *pWeapon = (CTFWeaponBase *)GetWeapon( iWeapon );

		if ( pWeapon )
		{
			pWeapon->WeaponReset();
		}
	}

	if ( GetActiveWeapon() )
	{
		m_iActiveWeaponTypePriorToDeath = GetActiveTFWeapon()->GetWeaponID();
		if ( m_iActiveWeaponTypePriorToDeath == TF_WEAPON_BUILDER )
			m_iActiveWeaponTypePriorToDeath = 0;
		GetActiveWeapon()->SendViewModelAnim( ACT_IDLE );
		GetActiveWeapon()->Holster();
		SetActiveWeapon( NULL );
	}
	else
	{
		m_iActiveWeaponTypePriorToDeath = 0;
	}

	int iIceRagdoll = 0;

	CTFPlayer *pInflictor = ToTFPlayer( info.GetInflictor() );
	if ( ( IsHeadshot( info.GetDamageCustom() ) ) && pPlayerAttacker )
	{
		CTFWeaponBase *pWpn = ( CTFWeaponBase *) info.GetWeapon();
		bool bBowShot = false;
		if ( pWpn && pWpn->GetWeaponID() == TF_WEAPON_COMPOUND_BOW )
		{
			bBowShot = true;
		}
		CTF_GameStats.Event_Headshot( pPlayerAttacker, bBowShot );
	}
	else if ( ( TF_DMG_CUSTOM_BACKSTAB == info.GetDamageCustom() ) && pInflictor )
	{
		CTF_GameStats.Event_Backstab( pInflictor );

		if ( pKillerWeapon )
		{
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pKillerWeapon, iIceRagdoll, freeze_backstab_victim );
		}
	}

	bool bCloakedCorpse = false;
	if ( pKillerWeapon && pKillerWeapon->GetWeaponID() == TF_WEAPON_KNIFE )
	{
		CTFKnife *pKnife = dynamic_cast<CTFKnife*>( pKillerWeapon );
		if ( pKnife && pKnife->ShouldDisguiseOnBackstab() )
		{
			bCloakedCorpse = true;
		}
	}

	int iGoldRagdoll = 0;
	if ( pKillerWeapon )
	{
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pKillerWeapon, iGoldRagdoll, set_turn_to_gold );
	}

	int iRagdollsBecomeAsh = 0;
	if ( info.GetWeapon() )
	{
		CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iRagdollsBecomeAsh, ragdolls_become_ash );
	}

	int iRagdollsPlasmaEffect = 0;
	if ( info.GetWeapon() )
	{
		CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iRagdollsPlasmaEffect, ragdolls_plasma_effect );
	}

	int iCustomDamage = info.GetDamageCustom();
	if ( iRagdollsPlasmaEffect )
	{
		iCustomDamage = TF_DMG_CUSTOM_PLASMA;
	}

	int iCritOnHardHit = 0;
	if ( info.GetWeapon() )
	{
		CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iCritOnHardHit, crit_on_hard_hit );
	}

	// Create the ragdoll entity.
	if ( bGib || bRagdoll )
	{
		CreateRagdollEntity( bGib, bBurning, bElectrocuted, bOnGround, bCloakedCorpse, iGoldRagdoll != 0, iIceRagdoll != 0, iRagdollsBecomeAsh != 0, iCustomDamage, ( iCritOnHardHit != 0 ) );
	}

#ifdef STAGING_ONLY
	// Spy Mark removal on others when killed
	// Only check if I have the spy marking gun
	// STAGING_SPY
	int iTranq = 0;
	CALL_ATTRIB_HOOK_INT( iTranq, override_projectile_type );
	if ( iTranq == TF_PROJECTILE_TRANQ )
	{
		CUtlVector< CTFPlayer * > playerVector;
		CollectPlayers( &playerVector, GetTeamNumber() == TF_TEAM_BLUE ? TF_TEAM_RED : TF_TEAM_BLUE, true );
		FOR_EACH_VEC ( playerVector, i )
		{
			if ( playerVector[i]->m_Shared.GetConditionProvider( TF_COND_TRANQ_MARKED ) == this )
			{
				playerVector[i]->m_Shared.RemoveCond( TF_COND_TRANQ_MARKED );
			}
		}
	}

	// If I was a spy cloned, give me instant respawn
	if ( m_Shared.InCond( TF_COND_SPY_CLASS_STEAL ) )
	{
		m_flRespawnTimeOverride = 2.0f;
	}

#endif

	// Remove all conditions...
	m_Shared.RemoveAllCond();

	// Don't overflow the value for this.
	m_iHealth = 0;

	// If we died in sudden death and we're an engineer, explode our buildings
	if ( IsPlayerClass( TF_CLASS_ENGINEER ) && TFGameRules()->InStalemate() && TFGameRules()->IsInArenaMode() == false )
	{
		for (int i = GetObjectCount()-1; i >= 0; i--)
		{
			CBaseObject *obj = GetObject(i);
			Assert( obj );

			if ( obj )
			{
				obj->DetonateObject();
			}		
		}
	}

	// Achievement checks
	if ( pPlayerAttacker )
	{
		// ACHIEVEMENT_TF_MEDIC_KILL_HEALED_SPY - medic kills a spy he has been healing
		if ( IsPlayerClass( TF_CLASS_SPY ) && pPlayerAttacker->IsPlayerClass( TF_CLASS_MEDIC ) )
		{
			// if we were killed by a medic, see if he healed us most recently

			for ( int i=0;i<pPlayerAttacker->WeaponCount();i++ )
			{
				CTFWeaponBase *pWpn = ( CTFWeaponBase *)pPlayerAttacker->GetWeapon( i );

				if ( pWpn == NULL )
					continue;

				if ( pWpn->GetWeaponID() == TF_WEAPON_MEDIGUN )
				{
					CWeaponMedigun *pMedigun = dynamic_cast< CWeaponMedigun * >( pWpn );
					if ( pMedigun )
					{
						if ( pMedigun->GetMostRecentHealTarget() == this )
						{
							pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_MEDIC_KILL_HEALED_SPY );
						}
					}
				}
			}
		}

		if ( bBurning && pPlayerAttacker->IsPlayerClass( TF_CLASS_PYRO ) )
		{
			// ACHIEVEMENT_TF_PYRO_KILL_MULTIWEAPONS - Pyro kills previously ignited target with other weapon
			CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(info.GetWeapon());

			if ( ( pOriginalBurner == pPlayerAttacker || pLastBurner == pPlayerAttacker ) && pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_SHOTGUN_PYRO )
			{
				pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_PYRO_KILL_MULTIWEAPONS );
			}

			// ACHIEVEMENT_TF_PYRO_KILL_TEAMWORK - Pyro kills an enemy previously ignited by another Pyro
			if ( pOriginalBurner != pPlayerAttacker )
			{
				pPlayerAttacker->AwardAchievement( ACHIEVEMENT_TF_PYRO_KILL_TEAMWORK );
			}
		}
	}

	if ( TFGameRules()->IsMannVsMachineMode() )
	{
		// Have teammates announce my death
		if ( GetTeamNumber() == TF_TEAM_PVE_DEFENDERS )
		{
			// have the last player on the defenders speak the last_man_standing line
			CUtlVector< CTFPlayer * > playerVector;
			CollectPlayers( &playerVector, TF_TEAM_PVE_DEFENDERS, true );
			if ( playerVector.Count() == 1 )
			{
				CTFPlayer *pAlivePlayer = playerVector[0];
				if ( pAlivePlayer )
				{
					pAlivePlayer->SpeakConceptIfAllowed( MP_CONCEPT_MVM_LAST_MAN_STANDING );
				}
			}
			else
			{
				if ( pPlayerAttacker && pPlayerAttacker->IsMiniBoss() )
				{
					TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_MVM_GIANT_KILLED_TEAMMATE, TF_TEAM_PVE_DEFENDERS );
				}

				TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_MVM_DEFENDER_DIED, TF_TEAM_PVE_DEFENDERS, CFmtStr( "victimclass:%s", g_aPlayerClassNames_NonLocalized[ GetPlayerClass()->GetClassIndex() ] ).Access() );
			}
		}
		else
		{
			if ( IsMiniBoss() )
			{
				TFGameRules()->HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_MVM_GIANT_KILLED, TF_TEAM_PVE_DEFENDERS );
			}
		}
	}

	// Reset Streaks to zero
	m_Shared.ResetStreaks();
	for ( int i = 0; i < WeaponCount(); i++) 
	{
		CTFWeaponBase *pWpn = ( CTFWeaponBase *)GetWeapon(i);
		if ( !pWpn )
			continue;
		pWpn->SetKillStreak( 0 );
	}

	for ( int i = 0; i < GetNumWearables(); ++i )
	{
		CTFWearable* pWearable = dynamic_cast<CTFWearable*>( GetWearable(i) );
		if ( !pWearable )
			continue;
		pWearable->SetKillStreak( 0 );
	}

	// Is the player inside a respawn time override volume?
	// don't do this for MvM bots
	if ( !TFGameRules()->IsMannVsMachineMode() || !IsBot() )
	{
		FOR_EACH_VEC( ITriggerPlayerRespawnOverride::AutoList(), i )
		{
			CTriggerPlayerRespawnOverride *pTriggerRespawn = static_cast< CTriggerPlayerRespawnOverride* >( ITriggerPlayerRespawnOverride::AutoList()[i] );
			if ( !pTriggerRespawn->m_bDisabled && pTriggerRespawn->IsTouching( this ) )
			{
				SetRespawnOverride( pTriggerRespawn->GetRespawnTime(), pTriggerRespawn->GetRespawnName() );
				break;
			}
			else
			{
				SetRespawnOverride( -1.f, NULL_STRING );
			}
		}
	}

	// Is this an environmental death?
	if ( ( info.GetAttacker() == info.GetInflictor() && info.GetAttacker() && info.GetAttacker()->IsBSPModel() ) ||
		 ( info.GetDamageCustom() == TF_DMG_CUSTOM_TRIGGER_HURT ) ||
		 ( info.GetDamageType() & DMG_VEHICLE ) )
	{
		CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 1, 5.0 );
		if ( pRecentDamager )
		{
			IGameEvent *event = gameeventmanager->CreateEvent( "environmental_death" );
			if ( event )
			{
				event->SetInt( "killer", pRecentDamager->entindex() );
				event->SetInt( "victim", entindex() );
				event->SetInt( "priority", 9 );

				gameeventmanager->FireEvent( event );
			}
		}
	}

	// make sure to remove custom attributes
	RemoveAllCustomAttributes();
}

struct SkillRatingAttackRecord_t
{
	CHandle< CTFPlayer > hAttacker;
	float flDamagePercent;
};
	
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pWeapon - 
//			&vecOrigin - 
//			&vecAngles - 
//-----------------------------------------------------------------------------
bool CTFPlayer::CalculateAmmoPackPositionAndAngles( CTFWeaponBase *pWeapon, Vector &vecOrigin, QAngle &vecAngles )
{
	// Look up the hand and weapon bones.
	int iHandBone = LookupBone( "weapon_bone" );
	if ( iHandBone == -1 )
		return false;

	GetBonePosition( iHandBone, vecOrigin, vecAngles );

	// need to fix up the z because the weapon bone position can be under the player
	if ( IsTaunting() )
	{
		// put the pack at the middle of the dying player
		vecOrigin = WorldSpaceCenter();
	}

	// Draw the position and angles.
	Vector vecDebugForward2, vecDebugRight2, vecDebugUp2;
	AngleVectors( vecAngles, &vecDebugForward2, &vecDebugRight2, &vecDebugUp2 );

	/*
	NDebugOverlay::Line( vecOrigin, ( vecOrigin + vecDebugForward2 * 25.0f ), 255, 0, 0, false, 30.0f );
	NDebugOverlay::Line( vecOrigin, ( vecOrigin + vecDebugRight2 * 25.0f ), 0, 255, 0, false, 30.0f );
	NDebugOverlay::Line( vecOrigin, ( vecOrigin + vecDebugUp2 * 25.0f ), 0, 0, 255, false, 30.0f ); 
	*/

	VectorAngles( vecDebugUp2, vecAngles );

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
// NOTE: If we don't let players drop ammo boxes, we don't need this code..
//-----------------------------------------------------------------------------
void CTFPlayer::AmmoPackCleanUp( void )
{
	// If we have more than 3 ammo packs out now, destroy the oldest one.
	int iNumPacks = 0;
	CTFAmmoPack *pOldestBox = NULL;

	// Cycle through all ammobox in the world and remove them
	CBaseEntity *pEnt = gEntList.FindEntityByClassname( NULL, "tf_ammo_pack" );
	while ( pEnt )
	{
		CBaseEntity *pOwner = pEnt->GetOwnerEntity();
		if (pOwner == this)
		{
			CTFAmmoPack *pThisBox = dynamic_cast<CTFAmmoPack *>( pEnt );
			Assert( pThisBox );
			if ( pThisBox )
			{
				iNumPacks++;

				// Find the oldest one
				if ( pOldestBox == NULL || pOldestBox->GetCreationTime() > pThisBox->GetCreationTime() )
				{
					pOldestBox = pThisBox;
				}
			}
		}

		pEnt = gEntList.FindEntityByClassname( pEnt, "tf_ammo_pack" );
	}

	// If they have more than 3 packs active, remove the oldest one
	if ( iNumPacks > 3 && pOldestBox )
	{
		UTIL_Remove( pOldestBox );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::ShouldDropAmmoPack()
{
	if ( TFGameRules()->IsMannVsMachineMode() && IsBot() )
		return false;

	if ( TFGameRules()->IsInArenaMode() && TFGameRules()->InStalemate() == false )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::DropAmmoPack( const CTakeDamageInfo &info, bool bEmpty, bool bDisguisedWeapon )
{
	// We want the ammo packs to look like the player's weapon model they were carrying.
	// except if they are melee or building weapons
	CTFWeaponBase *pWeapon = NULL;
	CTFWeaponBase *pActiveWeapon = m_Shared.GetActiveTFWeapon();

	if ( !pActiveWeapon || pActiveWeapon->GetTFWpnData().m_bDontDrop )
	{
		// Don't drop this one, find another one to drop

		int iWeight = -1;

		// find the highest weighted weapon
		for (int i = 0;i < WeaponCount(); i++) 
		{
			CTFWeaponBase *pWpn = ( CTFWeaponBase *)GetWeapon(i);
			if ( !pWpn )
				continue;

			if ( pWpn->GetTFWpnData().m_bDontDrop )
				continue;

			int iThisWeight = pWpn->GetTFWpnData().iWeight;

			if ( iThisWeight > iWeight )
			{
				iWeight = iThisWeight;
				pWeapon = pWpn;
			}
		}
	}
	else
	{
		pWeapon = pActiveWeapon;
	}

	// If we didn't find one, bail
	if ( !pWeapon )
		return;

	// Figure out which model/skin to use for the drop. We may pull from our real weapon or
	// from the weapon we're disguised as.
	CTFWeaponBase *pDropWeaponProps = (bDisguisedWeapon && m_Shared.InCond( TF_COND_DISGUISED ) && m_Shared.GetDisguiseWeapon())
									? m_Shared.GetDisguiseWeapon()
									: pWeapon;

	const char *pszWorldModel = pDropWeaponProps->GetWorldModel();
	int nSkin = pDropWeaponProps->GetDropSkinOverride();

	if ( nSkin < 0 )
	{
		nSkin = pDropWeaponProps->GetSkin();
	}

	if ( pszWorldModel == NULL )
		return;

	// Find the position and angle of the weapons so the "ammo box" matches.
	Vector vecPackOrigin;
	QAngle vecPackAngles;
	if( !CalculateAmmoPackPositionAndAngles( pWeapon, vecPackOrigin, vecPackAngles ) )
		return;

	CEconItemView *pItem = pDropWeaponProps->GetAttributeContainer()->GetItem();
	bool bIsSuicide = info.GetAttacker() ? info.GetAttacker()->GetTeamNumber() == GetTeamNumber() : false;

	CTFDroppedWeapon *pDroppedWeapon = CTFDroppedWeapon::Create( this, vecPackOrigin, vecPackAngles, pszWorldModel, pItem );
	if ( pDroppedWeapon )
	{
		pDroppedWeapon->InitDroppedWeapon( this, pDropWeaponProps, false, bIsSuicide );
	}

	// Create the ammo pack.
	CTFAmmoPack *pAmmoPack = CTFAmmoPack::Create( vecPackOrigin, vecPackAngles, this, "models/items/ammopack_medium.mdl" );
	Assert( pAmmoPack );
	if ( pAmmoPack )
	{
		pAmmoPack->InitWeaponDrop( this, pWeapon, nSkin, bEmpty, bIsSuicide );
	
		// Clean up old ammo packs if they exist in the world
		AmmoPackCleanUp();	
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::DropHealthPack( const CTakeDamageInfo &info, bool bEmpty )
{
	Vector vecSrc = this->WorldSpaceCenter();
	CHealthKitSmall *pMedKit = assert_cast<CHealthKitSmall*>( CBaseEntity::Create( "item_healthkit_small", vecSrc, vec3_angle, this ) );
	if ( pMedKit )
	{
		Vector vecImpulse = RandomVector( -1,1 );
		vecImpulse.z = 1;
		VectorNormalize( vecImpulse );

		Vector vecVelocity = vecImpulse * 250.0;
		pMedKit->DropSingleInstance( vecVelocity, this, 0 );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::DropCurrencyPack( CurrencyRewards_t nSize /* = TF_CURRENCY_PACK_SMALL */, int nAmount /*= 0*/, bool bForceDistribute /*= false*/, CBasePlayer* pMoneyMaker /*= NULL*/ )
{
	// SMALL, MEDIUM, LARGE packs generate a default value on spawn
	// Only pass in an amount when dropping TF_CURRENCY_PACK_CUSTOM

	Vector vecSrc = this->WorldSpaceCenter();
	CCurrencyPack *pCurrencyPack = NULL;

	switch ( nSize )
	{
	case TF_CURRENCY_PACK_SMALL:
		pCurrencyPack = assert_cast<CCurrencyPackSmall*>( CBaseEntity::Create( "item_currencypack_small", vecSrc, vec3_angle, this ) );
		break;

	case TF_CURRENCY_PACK_MEDIUM:
		pCurrencyPack = assert_cast<CCurrencyPackMedium*>( CBaseEntity::Create( "item_currencypack_medium", vecSrc, vec3_angle, this ) );
		break;

	case TF_CURRENCY_PACK_LARGE:
		pCurrencyPack = assert_cast<CCurrencyPack*>( CBaseEntity::Create( "item_currencypack_large", vecSrc, vec3_angle, this ) );
		break;

	case TF_CURRENCY_PACK_CUSTOM:
		// Pop file may have said to not drop anything
		Assert( nAmount > 0 );
		if ( nAmount == 0 )
			return;

		// Create no spawn first so we can set the multiplier before it spawns & picks it model
		pCurrencyPack = assert_cast<CCurrencyPack*>( CBaseEntity::CreateNoSpawn( "item_currencypack_custom", vecSrc, vec3_angle, this ) );
		pCurrencyPack->SetAmount( nAmount );
		break;
	};

	if ( pCurrencyPack )
	{
		Vector vecImpulse = RandomVector( -1,1 );
		vecImpulse.z = 1;
		VectorNormalize( vecImpulse );
		Vector vecVelocity = vecImpulse * 250.0;

		if ( pMoneyMaker || bForceDistribute )
		{
			pCurrencyPack->DistributedBy( pMoneyMaker );
		}
		
		DispatchSpawn( pCurrencyPack );
		pCurrencyPack->DropSingleInstance( vecVelocity, this, 0, 0 );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PlayerDeathThink( void )
{
	// We're doing this here to avoid getting stuck
	// in a recursive loop if we do it in Event_Killed
	if ( m_bPendingMerasmusPlayerBombExplode )
	{
		m_bPendingMerasmusPlayerBombExplode = false;
		MerasmusPlayerBombExplode();
	}

	// don't need to think again...
}

//-----------------------------------------------------------------------------
// Purpose: Remove the tf items from the player then call into the base class
//          removal of items.
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveAllItems( bool removeSuit )
{
	if ( TFGameRules() && TFGameRules()->IsPasstimeMode() && m_Shared.HasPasstimeBall() )
	{
		g_pPasstimeLogic->EjectBall( this, this );
	}

	// If the player has a capture flag, drop it.
	if ( HasItem() )
	{
		int nFlagTeamNumber = GetItem()->GetTeamNumber();
		GetItem()->Drop( this, true );

		IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_flag_event" );
		if ( event )
		{
			event->SetInt( "player", entindex() );
			event->SetInt( "eventtype", TF_FLAGEVENT_DROPPED );
			event->SetInt( "priority", 8 );
			event->SetInt( "team", nFlagTeamNumber );
			gameeventmanager->FireEvent( event );
		}
	}

	m_Shared.Heal_Radius( false );

	if ( m_hOffHandWeapon.Get() )
	{ 
		HolsterOffHandWeapon();

		// hide the weapon model
		// don't normally have to do this, unless we have a holster animation
		CBaseViewModel *vm = GetViewModel( 1 );
		if ( vm )
		{
			vm->SetWeaponModel( NULL, NULL );
		}

		m_hOffHandWeapon = NULL;
	}

	Weapon_SetLast( NULL );
	UpdateClientData();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ClientHearVox( const char *pSentence )
{
	//TFTODO: implement this.
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::UpdateModel( void )
{
	SetModel( GetPlayerClass()->GetModelName() );

	// Immediately reset our collision bounds - our collision bounds will be set to the model's bounds.
	SetCollisionBounds( GetPlayerMins(), GetPlayerMaxs() );

	m_PlayerAnimState->OnNewModel();
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : iSkin - 
//-----------------------------------------------------------------------------
void CTFPlayer::UpdateSkin( int iTeam )
{
	// The player's skin is team - 2.
	int iSkin = iTeam - 2;

	// Check to see if the skin actually changed.
	if ( iSkin != m_iLastSkin )
	{
		m_nSkin = iSkin;
		m_iLastSkin = iSkin;
	}
}

//=========================================================================
// Displays the state of the items specified by the Goal passed in
void CTFPlayer::DisplayLocalItemStatus( CTFGoal *pGoal )
{
#if 0
	for (int i = 0; i < 4; i++)
	{
		if (pGoal->display_item_status[i] != 0)
		{
			CTFGoalItem *pItem = Finditem(pGoal->display_item_status[i]);
			if (pItem)
				DisplayItemStatus(pGoal, this, pItem);
			else
				ClientPrint( this, HUD_PRINTTALK, "#Item_missing" );
		}
	}
#endif
}

void CTFPlayer::SetIsCoaching( bool bIsCoaching )
{ 
	m_bIsCoaching = bIsCoaching;

	if ( !bIsCoaching )
	{
		// reset our last action time so we don't get kicked for being idle while we were coaching
		m_flLastAction = gpGlobals->curtime;
	}
}

//=========================================================================
// Called when the player disconnects from the server.
void CTFPlayer::TeamFortress_ClientDisconnected( void )
{
	RemoveAllOwnedEntitiesFromWorld( true );
	RemoveNemesisRelationships();

	StopTaunt();

	RemoveAllWeapons();

	RemoveAllItems( true );

	TFGameRules()->RemovePlayerFromQueue( this );
	TFGameRules()->PlayerHistory_AddPlayer( this );

	DuelMiniGame_NotifyPlayerDisconnect( this );

	// cleanup coaching
	if ( GetCoach() )
	{
		GetCoach()->SetIsCoaching( false );
		GetCoach()->SetStudent( NULL );
	}
	else if ( GetStudent() )
	{
		SetIsCoaching( false );
		GetStudent()->SetCoach( NULL );
	}

	// Drop your powerup when you disconnect 
	if ( m_Shared.IsCarryingRune() )
	{
		CTFRune::CreateRune( GetAbsOrigin(), m_Shared.GetCarryingRuneType(), TEAM_ANY, true, false );
	}
}

//=========================================================================
// Removes everything this player has (buildings, grenades, etc.) from the world
void CTFPlayer::RemoveAllOwnedEntitiesFromWorld( bool bExplodeBuildings /* = false */ )
{
	RemoveOwnedProjectiles();

	if ( TFGameRules()->IsMannVsMachineMode() && ( GetTeamNumber() == TF_TEAM_PVE_INVADERS ) )
	{
		// MvM engineer bots leave their sentries behind when they die
		return;
	}


#ifdef TF_RAID_MODE
	if ( TFGameRules()->IsRaidMode() && ( GetTeamNumber() == TF_TEAM_RED ) )
	{
		// for now, leave Engineer's sentrygun alive after he dies
		return;
	}
#endif // TF_RAID_MODE

	if ( IsBotOfType( TF_BOT_TYPE ) && ToTFBot( this )->HasAttribute( CTFBot::RETAIN_BUILDINGS ) )
	{
		// keep this bot's buildings
		return;
	}

	// Destroy any buildables - this should replace TeamFortress_RemoveBuildings
	RemoveAllObjects( bExplodeBuildings );
}

//=========================================================================
// Removes all rockets the player has fired into the world
// (this prevents a team kill cheat where players would fire rockets 
// then change teams to kill their own team)
void CTFPlayer::RemoveOwnedProjectiles( void )
{
	FOR_EACH_VEC( IBaseProjectileAutoList::AutoList(), i )
	{
		CBaseProjectile *pProjectile = static_cast< CBaseProjectile* >( IBaseProjectileAutoList::AutoList()[i] );

		// if the player owns this entity, remove it
		bool bOwner = ( pProjectile->GetOwnerEntity() == this );

		if ( !bOwner )
		{
			if ( pProjectile->GetBaseProjectileType() == TF_BASE_PROJECTILE_GRENADE )
			{

				CTFWeaponBaseGrenadeProj *pGrenade = assert_cast<CTFWeaponBaseGrenadeProj*>( pProjectile );
				if ( pGrenade )
				{
					bOwner = ( pGrenade->GetThrower() == this );
				}
			}
			else if ( pProjectile->GetProjectileType() == TF_PROJECTILE_SENTRY_ROCKET )
			{
				CTFProjectile_SentryRocket *pRocket = assert_cast<CTFProjectile_SentryRocket*>( pProjectile );
				if ( pRocket )
				{
					bOwner = ( pRocket->GetScorer() == this );
				}
			}
		}

		if ( bOwner )
		{
			pProjectile->SetTouch( NULL );
			pProjectile->AddEffects( EF_NODRAW );
			UTIL_Remove( pProjectile );
		}
	}

	FOR_EACH_VEC( ITFFlameEntityAutoList::AutoList(), i )
	{
		CTFFlameEntity *pFlameEnt = static_cast< CTFFlameEntity* >( ITFFlameEntityAutoList::AutoList()[i] );

		if ( pFlameEnt->IsEntityAttacker( this ) )
		{
			pFlameEnt->SetTouch( NULL );
			pFlameEnt->AddEffects( EF_NODRAW );
			UTIL_Remove( pFlameEnt );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::NoteWeaponFired()
{
	Assert( m_pCurrentCommand );
	if ( m_pCurrentCommand )
	{
		m_iLastWeaponFireUsercmd = m_pCurrentCommand->command_number;
	}

	// Remember the tickcount when the weapon was fired and lock viewangles here!
	if ( m_iLockViewanglesTickNumber != gpGlobals->tickcount )
	{
		m_iLockViewanglesTickNumber = gpGlobals->tickcount;
		m_qangLockViewangles = pl.v_angle;
	}
}

//=============================================================================
//
// Player state functions.
//

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CPlayerStateInfo *CTFPlayer::StateLookupInfo( int nState )
{
	// This table MUST match the 
	static CPlayerStateInfo playerStateInfos[] =
	{
		{ TF_STATE_ACTIVE,				"TF_STATE_ACTIVE",				&CTFPlayer::StateEnterACTIVE,				NULL,	NULL },
		{ TF_STATE_WELCOME,				"TF_STATE_WELCOME",				&CTFPlayer::StateEnterWELCOME,				NULL,	&CTFPlayer::StateThinkWELCOME },
		{ TF_STATE_OBSERVER,			"TF_STATE_OBSERVER",			&CTFPlayer::StateEnterOBSERVER,				NULL,	&CTFPlayer::StateThinkOBSERVER },
		{ TF_STATE_DYING,				"TF_STATE_DYING",				&CTFPlayer::StateEnterDYING,				NULL,	&CTFPlayer::StateThinkDYING },
	};

	for ( int iState = 0; iState < ARRAYSIZE( playerStateInfos ); ++iState )
	{
		if ( playerStateInfos[iState].m_nPlayerState == nState )
			return &playerStateInfos[iState];
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::StateEnter( int nState )
{
	m_Shared.m_nPlayerState = nState;
	m_pStateInfo = StateLookupInfo( nState );

	if ( tf_playerstatetransitions.GetInt() == -1 || tf_playerstatetransitions.GetInt() == entindex() )
	{
		if ( m_pStateInfo )
			Msg( "ShowStateTransitions: entering '%s'\n", m_pStateInfo->m_pStateName );
		else
			Msg( "ShowStateTransitions: entering #%d\n", nState );
	}

	// Initialize the new state.
	if ( m_pStateInfo && m_pStateInfo->pfnEnterState )
	{
		(this->*m_pStateInfo->pfnEnterState)();
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::StateLeave( void )
{
	if ( m_pStateInfo && m_pStateInfo->pfnLeaveState )
	{
		(this->*m_pStateInfo->pfnLeaveState)();
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::StateTransition( int nState )
{
	StateLeave();
	StateEnter( nState );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::StateEnterWELCOME( void )
{
	PickWelcomeObserverPoint();  
	
	StartObserverMode( OBS_MODE_FIXED );

	// Important to set MOVETYPE_NONE or our physics object will fall while we're sitting at one of the intro cameras.
	SetMoveType( MOVETYPE_NONE );
	AddSolidFlags( FSOLID_NOT_SOLID );
	AddEffects( EF_NODRAW | EF_NOSHADOW );		

	PhysObjectSleep();

	if ( g_pServerBenchmark->IsLocalBenchmarkPlayer( this ) )
	{
		m_bSeenRoundInfo = true;

		ChangeTeam( TEAM_SPECTATOR );
	}
	else if ( gpGlobals->eLoadType == MapLoad_Background )
	{
		m_bSeenRoundInfo = true;

		ChangeTeam( TEAM_SPECTATOR );
	}
	else if ( (TFGameRules() && TFGameRules()->IsLoadingBugBaitReport()) )
	{
		m_bSeenRoundInfo = true;
		
		ChangeTeam( TF_TEAM_BLUE );
		SetDesiredPlayerClassIndex( TF_CLASS_SCOUT );
		ForceRespawn();
	}
	else if ( IsInCommentaryMode()  )
	{
		m_bSeenRoundInfo = true;
	}
//=============================================================================
// HPE_BEGIN:
// [msmith]	When in training, we want the option to show an intro movie.
//=============================================================================
	else if ( TFGameRules()->IsInTraining() && IsFakeClient() == false )
	{
		ShowViewPortPanel( PANEL_INTRO, true );
		m_bSeenRoundInfo = true;
	}
//=============================================================================
// HPE_END
//=============================================================================
#ifdef STAGING_ONLY
	else if ( tf_skip_intro_and_spectate.GetBool() )
	{
		m_bSeenRoundInfo = true;
		ChangeTeam( TEAM_SPECTATOR );
		SetObserverMode( OBS_MODE_CHASE );
	}
#endif
	else
	{
		if ( !IsX360() )
		{
			char pszWelcome[128];
			Q_snprintf( pszWelcome, sizeof(pszWelcome), "#TF_Welcome" );
			if ( UTIL_GetActiveHolidayString() )
			{
				Q_snprintf( pszWelcome, sizeof(pszWelcome), "#TF_Welcome_%s", UTIL_GetActiveHolidayString() );
			}

			KeyValues *data = new KeyValues( "data" );
			data->SetString( "title", pszWelcome );		// info panel title
			data->SetString( "type", "1" );				// show userdata from stringtable entry
			data->SetString( "msg",	"motd" );			// use this stringtable entry
			data->SetString( "msg_fallback",	"motd_text" );			// use this stringtable entry if the base is HTML, and client has disabled HTML motds
			data->SetBool( "unload", sv_motd_unload_on_dismissal.GetBool() );

			ShowViewPortPanel( PANEL_INFO, true, data );

			data->deleteThis();
		}
		else
		{
			ShowViewPortPanel( PANEL_MAPINFO, true );
		}

		m_bSeenRoundInfo = false;
	}

#ifdef STAGING_ONLY
	if ( TFGameRules() && TFGameRules()->IsBountyMode() )
	{
		// See if we should give starting money
		int nCurrency = tf_bountymode_currency_starting.GetInt();
		if ( nCurrency > 0 )
		{
			SetCurrency( nCurrency );
		}
	}
#endif // STAGING_ONLY
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::StateThinkWELCOME( void )
{
	if ( !IsFakeClient() )
	{
		if ( IsInCommentaryMode() )
		{
			ChangeTeam( TF_TEAM_BLUE );
			SetDesiredPlayerClassIndex( TF_CLASS_SCOUT );
			ForceRespawn();
		}
		else if ( TFGameRules()->IsInTraining() )
		{
			int iTeam = TFGameRules()->GetAssignedHumanTeam();
			int iClass = TFGameRules()->GetTrainingModeLogic() ? TFGameRules()->GetTrainingModeLogic()->GetDesiredClass() : TF_CLASS_SOLDIER;
			ChangeTeam( iTeam != TEAM_ANY ? iTeam : TF_TEAM_BLUE );
			SetDesiredPlayerClassIndex( iClass );
			ForceRespawn();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::StateEnterACTIVE()
{
	SetMoveType( MOVETYPE_WALK );
	RemoveEffects( EF_NODRAW | EF_NOSHADOW );
	RemoveSolidFlags( FSOLID_NOT_SOLID );
	m_Local.m_iHideHUD = 0;
	PhysObjectWake();

	m_flLastAction = gpGlobals->curtime;
	m_flLastHealthRegenAt = gpGlobals->curtime;
	SetContextThink( &CTFPlayer::RegenThink, gpGlobals->curtime + TF_REGEN_TIME, "RegenThink" );
	if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
	{
		SetContextThink( &CTFPlayer::RuneRegenThink, gpGlobals->curtime + TF_REGEN_TIME_RUNE, "RuneRegenThink" );
	}

}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::SetObserverMode(int mode)
{
	if ( !TFGameRules() )
		return false;

	if ( mode < OBS_MODE_NONE || mode >= NUM_OBSERVER_MODES )
		return false;

	if ( TFGameRules()->ShowMatchSummary() )
		return false;

	// Skip over OBS_MODE_POI if we're not in Passtime mode
	if ( mode == OBS_MODE_POI )
	{
		if ( !TFGameRules()->IsPasstimeMode() )
		{
			mode = OBS_MODE_ROAMING;
		}
	}

	// Skip over OBS_MODE_ROAMING for dead players
	if( GetTeamNumber() > TEAM_SPECTATOR )
	{
		if ( IsDead() && ( mode > OBS_MODE_FIXED ) && mp_fadetoblack.GetBool() )
		{
			mode = OBS_MODE_CHASE;
		}
		else if ( mode == OBS_MODE_ROAMING )
		{
			mode = OBS_MODE_IN_EYE;
		}
	}

	if ( m_iObserverMode > OBS_MODE_DEATHCAM )
	{
		// remember mode if we were really spectating before
		m_iObserverLastMode = m_iObserverMode;
	}

	m_iObserverMode = mode;

	if ( !m_bArenaIsAFK )
	{
		m_flLastAction = gpGlobals->curtime;
	}

	// this is the old behavior, still supported for community servers
	bool bAllowSpecModeChange = TFGameRules()->IsInTournamentMode() ? TFGameRules()->IsMannVsMachineMode() : true;

	// new behavior for Valve casual, competitive, and mvm matches
	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( TFGameRules()->GetCurrentMatchGroup() );
	if ( pMatchDesc )
	{
		bAllowSpecModeChange = pMatchDesc->m_params.m_bAllowSpecModeChange;
	}

	if ( !bAllowSpecModeChange )
	{
		if ( ( mode != OBS_MODE_DEATHCAM ) && ( mode != OBS_MODE_FREEZECAM ) && ( GetTeamNumber() > TEAM_SPECTATOR ) )
		{
			if ( IsValidObserverTarget( GetObserverTarget() ) )
			{
				m_iObserverMode.Set( OBS_MODE_IN_EYE );
			}
			else
			{
				m_iObserverMode.Set( OBS_MODE_DEATHCAM );
			}
		}
	}

	switch ( m_iObserverMode )
	{
	case OBS_MODE_NONE:
	case OBS_MODE_FIXED :
	case OBS_MODE_DEATHCAM :
		SetFOV( this, 0 );	// Reset FOV
		SetViewOffset( vec3_origin );
		SetMoveType( MOVETYPE_NONE );
		break;

	case OBS_MODE_CHASE :
	case OBS_MODE_IN_EYE :	
		// udpate FOV and viewmodels
		SetObserverTarget( m_hObserverTarget );	
		SetMoveType( MOVETYPE_OBSERVER );
		break;

	case OBS_MODE_POI : // PASSTIME
		SetObserverTarget( TFGameRules()->GetObjectiveObserverTarget() );	
		SetMoveType( MOVETYPE_OBSERVER );
		break;

	case OBS_MODE_ROAMING :
		SetFOV( this, 0 );	// Reset FOV
		SetObserverTarget( m_hObserverTarget );
		SetViewOffset( vec3_origin );
		SetMoveType( MOVETYPE_OBSERVER );
		break;
		
	case OBS_MODE_FREEZECAM:
		SetFOV( this, 0 );	// Reset FOV
		SetObserverTarget( m_hObserverTarget );
		SetViewOffset( vec3_origin );
		SetMoveType( MOVETYPE_OBSERVER );
		break;
	}

	CheckObserverSettings();

	return true;	
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::StateEnterOBSERVER( void )
{
	// Always start a spectator session in chase mode
	m_iObserverLastMode = OBS_MODE_CHASE;

	if( m_hObserverTarget == NULL )
	{
		// find a new observer target
		CheckObserverSettings();
	}

	if ( !m_bAbortFreezeCam )
	{
		FindInitialObserverTarget();
	}

	// If we haven't yet set a valid observer mode, such as when
	// the player aborts the freezecam and sets a mode "by hand"
	// force the initial mode to last mode
	if ( m_iObserverMode <= OBS_MODE_FREEZECAM )
	{
		if ( TFGameRules() && TFGameRules()->IsPasstimeMode() )
		{
			m_iObserverMode = OBS_MODE_POI;
		}
		else
		{
			m_iObserverMode = m_iObserverLastMode;
		}
	}

	// If we're in fixed mode, but we found an observer target, move to non fixed.
	if ( m_hObserverTarget.Get() != NULL && m_iObserverMode == OBS_MODE_FIXED )
	{
		m_iObserverMode.Set( OBS_MODE_IN_EYE );
	}

	StartObserverMode( m_iObserverMode );

	PhysObjectSleep();

	if ( GetTeamNumber() != TEAM_SPECTATOR )
	{
		HandleFadeToBlack();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::StateThinkOBSERVER()
{
	// Make sure nobody has changed any of our state.
	Assert( m_takedamage == DAMAGE_NO );
	Assert( IsSolidFlagSet( FSOLID_NOT_SOLID ) );

	// Must be dead.
	Assert( m_lifeState == LIFE_DEAD );
	Assert( pl.deadflag );

#ifdef STAGING_ONLY
	if ( tf_skip_intro_and_spectate.GetInt() > 5 )
	{
		static float s_flLastTime = gpGlobals->curtime;
		float curtime = gpGlobals->curtime;

		if ( ( curtime - s_flLastTime ) > tf_skip_intro_and_spectate.GetInt() )
		{
			s_flLastTime = curtime;

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

				if ( pl && ( pl->GetTeamNumber() == TEAM_SPECTATOR ) )
				{
					CBaseEntity * target = pl->FindNextObserverTarget( false );
					if ( target )
					{
						// Could also switch spec_mode: GetObserverMode().
						pl->SetObserverTarget( target );
					}
				}
			}
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::StateEnterDYING( void )
{
	SetMoveType( MOVETYPE_NONE );
	AddSolidFlags( FSOLID_NOT_SOLID );

	m_bPlayedFreezeCamSound = false;
	m_bAbortFreezeCam = false;

	if ( TFGameRules() && TFGameRules()->IsInArenaMode() )
	{
		float flLastActionTime =  gpGlobals->curtime - m_flLastAction;
		float flAliveThisRoundTime = gpGlobals->curtime - TFGameRules()->GetRoundStart();

		if ( flAliveThisRoundTime - flLastActionTime < 0 )
		{
			m_bArenaIsAFK = true;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Move the player to observer mode once the dying process is over
//-----------------------------------------------------------------------------
void CTFPlayer::StateThinkDYING( void )
{
	// If we have a ragdoll, it's time to go to deathcam
	if ( !m_bAbortFreezeCam && m_hRagdoll && 
		(m_lifeState == LIFE_DYING || m_lifeState == LIFE_DEAD) && 
		GetObserverMode() != OBS_MODE_FREEZECAM )
	{
		if ( GetObserverMode() != OBS_MODE_DEATHCAM )
		{
			StartObserverMode( OBS_MODE_DEATHCAM );	// go to observer mode
		}
		RemoveEffects( EF_NODRAW | EF_NOSHADOW );	// still draw player body
	}

	float flTimeInFreeze = spec_freeze_traveltime.GetFloat() + spec_freeze_time.GetFloat();
	float flFreezeEnd = (m_flDeathTime + TF_DEATH_ANIMATION_TIME + flTimeInFreeze );
	if ( !m_bPlayedFreezeCamSound  && GetObserverTarget() && GetObserverTarget() != this )
	{
		// Start the sound so that it ends at the freezecam lock on time
		float flFreezeSoundLength = 0.3;
		float flFreezeSoundTime = (m_flDeathTime + TF_DEATH_ANIMATION_TIME ) + spec_freeze_traveltime.GetFloat() - flFreezeSoundLength;
		if ( gpGlobals->curtime >= flFreezeSoundTime )
		{
			CSingleUserRecipientFilter filter( this );
			EmitSound_t params;
			params.m_flSoundTime = 0;
			params.m_pSoundName = "TFPlayer.FreezeCam";
			EmitSound( filter, entindex(), params );

			m_bPlayedFreezeCamSound = true;
		}
	}

	if ( gpGlobals->curtime >= (m_flDeathTime + TF_DEATH_ANIMATION_TIME ) )	// allow x seconds death animation / death cam
	{
		if ( GetObserverTarget() && GetObserverTarget() != this )
		{
			if ( !m_bAbortFreezeCam && gpGlobals->curtime < flFreezeEnd )
			{
				if ( GetObserverMode() != OBS_MODE_FREEZECAM )
				{
					StartObserverMode( OBS_MODE_FREEZECAM );
					PhysObjectSleep();
				}
				return;
			}
		}

		if ( GetObserverMode() == OBS_MODE_FREEZECAM )
		{
			// If we're in freezecam, and we want out, abort.  (only if server is not using mp_fadetoblack)
			if ( m_bAbortFreezeCam && !mp_fadetoblack.GetBool() )
			{
				if ( m_hObserverTarget == NULL )
				{
					// find a new observer target
					CheckObserverSettings();
				}

				FindInitialObserverTarget();

				if ( TFGameRules() && TFGameRules()->IsPasstimeMode() )
				{
					SetObserverMode( OBS_MODE_POI );
				}
				else
				{
					SetObserverMode( OBS_MODE_CHASE );
				}
				ShowViewPortPanel( "specgui" , ModeWantsSpectatorGUI(OBS_MODE_CHASE) );
			}
		}

		// Don't allow anyone to respawn until freeze time is over, even if they're not
		// in freezecam. This prevents players skipping freezecam to spawn faster.
		if ( gpGlobals->curtime < flFreezeEnd )
			return;

		m_lifeState = LIFE_RESPAWNABLE;

		StopAnimation();

		IncrementInterpolationFrame();

		if ( GetMoveType() != MOVETYPE_NONE && (GetFlags() & FL_ONGROUND) )
			SetMoveType( MOVETYPE_NONE );

		StateTransition( TF_STATE_OBSERVER );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::AttemptToExitFreezeCam( void )
{
	float flFreezeTravelTime = (m_flDeathTime + TF_DEATH_ANIMATION_TIME ) + spec_freeze_traveltime.GetFloat() + 0.5;
	if ( gpGlobals->curtime < flFreezeTravelTime )
		return;

	m_bAbortFreezeCam = true;
}

class CIntroViewpoint : public CPointEntity
{
	DECLARE_CLASS( CIntroViewpoint, CPointEntity );
public:
	DECLARE_DATADESC();

	virtual int UpdateTransmitState()
	{
		return SetTransmitState( FL_EDICT_ALWAYS );
	}

	int			m_iIntroStep;
	float		m_flStepDelay;
	string_t	m_iszMessage;
	string_t	m_iszGameEvent;
	float		m_flEventDelay;
	int			m_iGameEventData;
	float		m_flFOV;
};

BEGIN_DATADESC( CIntroViewpoint )
	DEFINE_KEYFIELD( m_iIntroStep,	FIELD_INTEGER,	"step_number" ),
	DEFINE_KEYFIELD( m_flStepDelay,	FIELD_FLOAT,	"time_delay" ),
	DEFINE_KEYFIELD( m_iszMessage,	FIELD_STRING,	"hint_message" ),
	DEFINE_KEYFIELD( m_iszGameEvent,	FIELD_STRING,	"event_to_fire" ),
	DEFINE_KEYFIELD( m_flEventDelay,	FIELD_FLOAT,	"event_delay" ),
	DEFINE_KEYFIELD( m_iGameEventData,	FIELD_INTEGER,	"event_data_int" ),
	DEFINE_KEYFIELD( m_flFOV,	FIELD_FLOAT,	"fov" ),
END_DATADESC()

LINK_ENTITY_TO_CLASS( game_intro_viewpoint, CIntroViewpoint );

//-----------------------------------------------------------------------------
// Purpose: Give the player some ammo.
// Input  : iCount - Amount of ammo to give.
//			iAmmoIndex - Index of the ammo into the AmmoInfoArray
//			iMax - Max carrying capability of the player
// Output : Amount of ammo actually given
//-----------------------------------------------------------------------------
int CTFPlayer::GiveAmmo( int iCount, int iAmmoIndex, bool bSuppressSound )
{
 	return GiveAmmo( iCount, iAmmoIndex, bSuppressSound, kAmmoSource_Pickup );
}

//-----------------------------------------------------------------------------
// Purpose: Give the player some ammo.
// Input  : iCount - Amount of ammo to give.
//			iAmmoIndex - Index of the ammo into the AmmoInfoArray
//			iMax - Max carrying capability of the player
// Output : Amount of ammo actually given
//-----------------------------------------------------------------------------
int CTFPlayer::GiveAmmo( int iCount, int iAmmoIndex, bool bSuppressSound, EAmmoSource eAmmoSource )
{
	if ( iCount <= 0 )
	{
		return 0;
	}

	// Metal always ignores the eAmmoSource settings, which are really used only for determining
	// whether ammo should be converted into health or ignored or, in rare cases, treated as actual
	// ammo.
	if ( iAmmoIndex != TF_AMMO_METAL )
	{
		//int iAmmoBecomesHealth = 0;
		//CALL_ATTRIB_HOOK_INT( iAmmoBecomesHealth, ammo_becomes_health );
		//if ( iAmmoBecomesHealth == 1 )
		//{
		//	// Ammo from ground pickups is converted to health.
		//	if ( eAmmoSource == kAmmoSource_Pickup )
		//	{
		//		int iTakenHealth = TakeHealth( iCount, DMG_GENERIC );
		//		if ( iTakenHealth > 0 )
		//		{
		//			if ( !bSuppressSound )
		//			{
		//				EmitSound( "BaseCombatCharacter.AmmoPickup" );
		//			}
		//			m_Shared.HealthKitPickupEffects( iCount );
		//		}
		//		return iTakenHealth;
		//	}

		//	// Ammo from the cart or engineer dispensers is flatly ignored.
		//	if ( eAmmoSource == kAmmoSource_DispenserOrCart )
		//		return 0;

		//	Assert( eAmmoSource == kAmmoSource_Resupply );
		//}
	}
	else if ( iAmmoIndex == TF_AMMO_METAL )
	{
		if ( eAmmoSource != kAmmoSource_Resupply )
		{
			float flMultMetal = 1.0f;
			CALL_ATTRIB_HOOK_FLOAT( flMultMetal, mult_metal_pickup );
			iCount = (int)(flMultMetal * iCount );
		}
	}


	if ( !g_pGameRules->CanHaveAmmo( this, iAmmoIndex ) )
	{
		// game rules say I can't have any more of this ammo type.
		return 0;
	}

	if ( iAmmoIndex < 0 || iAmmoIndex >= MAX_AMMO_SLOTS )
	{
		return 0;
	}

	int iAdd = MIN( iCount, GetMaxAmmo(iAmmoIndex) - GetAmmoCount(iAmmoIndex) );
	if ( iAdd < 1 )
	{
		return 0;
	}

	// Ammo pickup sound
	if ( !bSuppressSound )
	{
		EmitSound( "BaseCombatCharacter.AmmoPickup" );
	}

	CBaseCombatCharacter::GiveAmmo( iAdd, iAmmoIndex, bSuppressSound );
	return iAdd;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveAmmo( int iCount, int iAmmoIndex )
{
#ifdef STAGING_ONLY
	if ( tf_infinite_ammo.GetBool() )
	{
		return;
	}
#endif // STAGING_ONLY

#if defined( _DEBUG ) || defined( STAGING_ONLY )
	if ( mp_developer.GetInt() > 1 && !IsBot() )
		return;
#endif // _DEBUG || STAGING_ONLY

	if ( m_Shared.InCond( TF_COND_HALLOWEEN_GIANT ) )
	{
		return;
	}

	// Infinite primary, secondary and metal in these game modes
	if ( TFGameRules() && iAmmoIndex < TF_AMMO_GRENADES1 )
	{
		if ( TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
			return;

#ifdef STAGING_ONLY
		if ( TFGameRules()->IsBountyMode() && IsMiniBoss() )
			return;
#endif // STAGING_ONLY
	}

	CBaseCombatCharacter::RemoveAmmo( iCount, iAmmoIndex );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveAmmo( int iCount, const char *szName )
{
	if ( TFGameRules() )
	{
		if ( TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
			return;

		if ( TFGameRules()->GameModeUsesMiniBosses() && IsMiniBoss() )
			return;
	}

	CBaseCombatCharacter::RemoveAmmo( iCount, szName );
}

//-----------------------------------------------------------------------------
// Purpose: Returns the amount of ammunition of a particular type owned
//			owned by the character
// Input  :	Ammo Index
// Output :	The amount of ammo
//-----------------------------------------------------------------------------
int CTFPlayer::GetAmmoCount( int iAmmoIndex ) const
{
	if ( iAmmoIndex == -1 )
		return 0;

	if ( IsFakeClient() && TFGameRules()->IsInItemTestingMode() )
		return 999;

	return BaseClass::GetAmmoCount( iAmmoIndex );
}

//-----------------------------------------------------------------------------
// Purpose: Has to be const for override, but needs to access non-const member methods.
//-----------------------------------------------------------------------------
int	CTFPlayer::GetMaxHealth() const
{
	int iMax = GetMaxHealthForBuffing();

	// Also add the nonbuffed health bonuses
	CALL_ATTRIB_HOOK_INT( iMax, add_maxhealth_nonbuffed );

	return MAX( iMax, 1 );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFPlayer::GetMaxHealthForBuffing() const
{
	int iMax = m_PlayerClass.GetMaxHealth();
	CALL_ATTRIB_HOOK_INT( iMax, add_maxhealth );

	CTFWeaponBase *pWeapon = GetActiveTFWeapon();
	if ( pWeapon )
	{
		iMax += pWeapon->GetMaxHealthMod();
	}
	if ( const_cast<CTFPlayer*>(this)->GetPlayerClass()->GetClassIndex() == TF_CLASS_DEMOMAN )
	{
		CTFSword *pSword = dynamic_cast<CTFSword*>(const_cast<CTFPlayer*>(this)->Weapon_OwnsThisID( TF_WEAPON_SWORD ));
		if ( pSword )
		{
			iMax += pSword->GetSwordHealthMod();
		}
	}

	// Some Powerup Runes increase your Max Health
	iMax += GetRuneHealthBonus();

	if ( m_Shared.InCond( TF_COND_HALLOWEEN_GIANT ) )
	{
		return iMax * tf_halloween_giant_health_scale.GetFloat();
	}

	return iMax;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFPlayer::GetRuneHealthBonus() const
{
	int nRuneType = m_Shared.GetCarryingRuneType();

	if ( nRuneType == RUNE_NONE )
	{
		return 0;
	}
	
	if ( nRuneType == RUNE_KNOCKOUT )
	{
		if ( IsPlayerClass( TF_CLASS_DEMOMAN ) )
		{
			// Swords have various extra melee benefits, so we reduce Max Health bonus
			if ( Weapon_GetSlot( TF_WPN_TYPE_MELEE ) )
			{
				int iDecapitateType = 0;
				CALL_ATTRIB_HOOK_INT( iDecapitateType, decapitate_type );

				if ( iDecapitateType )
				{
					return 20;
				}
			}
			// Shields have passive resistance so we reduce Max Health bonus
			if ( m_Shared.IsShieldEquipped() )
			{
				return 30;
			}
			return 150;
		}
		else if ( IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) || IsPlayerClass( TF_CLASS_PYRO ) )
		{
			return 125;
		}
		else if ( IsPlayerClass( TF_CLASS_SOLDIER ) || IsPlayerClass( TF_CLASS_MEDIC ) )
		{
			return 150;
		}
		else
		{
			return 175;
		}
	}
	else if ( nRuneType == RUNE_REFLECT )
	{
		return ( 400 - m_PlayerClass.GetMaxHealth() );
	}
	else if ( nRuneType == RUNE_KING )
	{
		return 100;
	}
	else if ( nRuneType == RUNE_VAMPIRE )
	{
		return 80;
	}

	return 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ForceRegenerateAndRespawn( void )
{
	m_bRegenerating = true;
	ForceRespawn();
	m_bRegenerating = false;
}

//-----------------------------------------------------------------------------
// Purpose: Reset player's information and force him to spawn
//-----------------------------------------------------------------------------
void CTFPlayer::ForceRespawn( void )
{
	VPROF_BUDGET( "CTFPlayer::ForceRespawn", VPROF_BUDGETGROUP_PLAYER );

	CTF_GameStats.Event_PlayerForceRespawn( this );

	m_flSpawnTime = gpGlobals->curtime;

	bool bRandom = false;

	// force a random class if the server requires it
	if ( TFGameRules() && TFGameRules()->IsInArenaMode() )
	{
		if ( tf_arena_force_class.GetBool() == true )
		{
			bRandom = true;
			if ( GetTeamNumber() > LAST_SHARED_TEAM )
			{
				if ( !IsAlive() || ( TFGameRules() && TFGameRules()->State_Get() != GR_STATE_STALEMATE ) )
				{
					HandleCommand_JoinClass( "random", false );
				}
			}
		}

		if ( ( tf_arena_use_queue.GetBool() == false && TFGameRules()->IsInWaitingForPlayers() ) || TFGameRules()->State_Get() == GR_STATE_PREGAME  )
		{
			return;
		}
	}

	int iDesiredClass = GetDesiredPlayerClassIndex();

	if ( iDesiredClass == TF_CLASS_UNDEFINED )
	{
		return;
	}

	if ( iDesiredClass == TF_CLASS_RANDOM )
	{
		bRandom = true;

		// Don't let them be the same class twice in a row
		do{
			iDesiredClass = random->RandomInt( TF_FIRST_NORMAL_CLASS, TF_LAST_NORMAL_CLASS );
		} while( iDesiredClass == GetPlayerClass()->GetClassIndex() );
	}

	if ( HasTheFlag() )
	{
		DropFlag();
	}

	if ( GetPlayerClass()->GetClassIndex() != iDesiredClass )
	{
		// clean up any pipebombs/buildings in the world (no explosions)
		m_bSwitchedClass = true;

		RemoveAllOwnedEntitiesFromWorld();

		int iOldClass = GetPlayerClass()->GetClassIndex();

		GetPlayerClass()->Init( iDesiredClass );

		// Don't report class changes if we're random, because it's not a player choice
		if ( !bRandom )
		{
			m_iClassChanges++;
			CTF_GameStats.Event_PlayerChangedClass( this, iOldClass, iDesiredClass );
		}
	}
	else
	{
		m_bSwitchedClass = false;
	}

	m_Shared.RemoveAllCond();
	m_Shared.ResetRageMeter();

	if ( m_bSwitchedClass )
	{
		m_iLastWeaponSlot = 1;
		// Tell all the items we have that we've changed class. Some items need to change model.
		// Also reset KillStreaks
		for ( int i = 0; i < MAX_WEAPONS; i++ )
		{
			CTFWeaponBase *pWeapon = (CTFWeaponBase *)GetWeapon(i);
			if ( pWeapon )
			{
				pWeapon->OnOwnerClassChange();
			}
		}
	}
	else
	{
		if ( IsAlive() )
		{
			if ( GetActiveTFWeapon() )
			{
				m_iActiveWeaponTypePriorToDeath = GetActiveTFWeapon()->GetWeaponID();
			}
			SaveLastWeaponSlot();
		}
	}

	// Any Respawns will reset killstreaks
	m_Shared.ResetStreaks();
	for ( int i = 0; i < WeaponCount(); i++ )
	{
		CTFWeaponBase *pWpn = (CTFWeaponBase *)GetWeapon( i );
		if ( !pWpn )
			continue;
		pWpn->SetKillStreak( 0 );
	}

	for ( int i = 0; i < GetNumWearables(); ++i )
	{
		CTFWearable* pWearable = dynamic_cast<CTFWearable*>( GetWearable( i ) );
		if ( !pWearable )
			continue;
		pWearable->SetKillStreak( 0 );
	}

	RemoveAllItems( true );

	// Reset ground state for airwalk animations
	SetGroundEntity( NULL );

	// TODO: move this into conditions
	RemoveTeleportEffect();

	// remove invisibility very quickly	
	m_Shared.FadeInvis( 0.1f );

	// Stop any firing that was taking place before respawn.
	m_nButtons = 0;

	StateTransition( TF_STATE_ACTIVE );
	Spawn();
	m_bSwitchedClass = false;
}

//-----------------------------------------------------------------------------
// Purpose: Do nothing multiplayer_animstate takes care of animation.
// Input  : playerAnim - 
//-----------------------------------------------------------------------------
void CTFPlayer::SetAnimation( PLAYER_ANIM playerAnim )
{
	return;
}

//-----------------------------------------------------------------------------
// Purpose: Handle cheat commands
// Input  : iImpulse - 
//-----------------------------------------------------------------------------
void CTFPlayer::CheatImpulseCommands( int iImpulse )
{
	switch( iImpulse )
	{
	case 101:
		{
			if( sv_cheats->GetBool() )
			{
				extern int gEvilImpulse101;
				gEvilImpulse101 = true;

				GiveAmmo( 1000, TF_AMMO_PRIMARY );
				GiveAmmo( 1000, TF_AMMO_SECONDARY );
				GiveAmmo( 1000, TF_AMMO_METAL );
				GiveAmmo( 1000, TF_AMMO_GRENADES1 );
				GiveAmmo( 1000, TF_AMMO_GRENADES2 );
				GiveAmmo( 1000, TF_AMMO_GRENADES3 );
				TakeHealth( 999, DMG_GENERIC );

				// Refills weapon clips, too
				for ( int i = 0; i < MAX_WEAPONS; i++ )
				{
					CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase* >( GetWeapon( i ) );
					if ( !pWeapon )
						continue;

					pWeapon->GiveDefaultAmmo();

					if ( pWeapon->IsEnergyWeapon() )
					{
						pWeapon->WeaponRegenerate();
					}
				}

				m_Shared.m_flRageMeter = 100.f;
				m_Shared.SetDemomanChargeMeter( 100.f );

				gEvilImpulse101 = false;
			}
		}
		break;

	default:
		{
			BaseClass::CheatImpulseCommands( iImpulse );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::SetWeaponBuilder( CTFWeaponBuilder *pBuilder )
{
	m_hWeaponBuilder = pBuilder;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFWeaponBuilder *CTFPlayer::GetWeaponBuilder( void )
{
	Assert( 0 );
	return m_hWeaponBuilder;
}

//-----------------------------------------------------------------------------
// Purpose: Returns true if this player is building something
//-----------------------------------------------------------------------------
bool CTFPlayer::IsBuilding( void )
{
	/*
	CTFWeaponBuilder *pBuilder = GetWeaponBuilder();
	if ( pBuilder )
		return pBuilder->IsBuilding();
		*/

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveBuildResources( int iAmount )
{
	RemoveAmmo( iAmount, TF_AMMO_METAL );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::AddBuildResources( int iAmount )
{
	GiveAmmo( iAmount, TF_AMMO_METAL, false, kAmmoSource_Pickup );	
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBaseObject	*CTFPlayer::GetObject( int index ) const
{
	return (CBaseObject *)( m_aObjects[index].Get() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBaseObject	*CTFPlayer::GetObjectOfType( int iObjectType, int iObjectMode ) const
{
	int iNumObjects = GetObjectCount();
	for ( int i=0; i<iNumObjects; i++ )
	{
		CBaseObject *pObj = GetObject(i);

		if ( !pObj )
			continue;

		if ( pObj->GetType() != iObjectType )
			continue;

		if ( pObj->GetObjectMode() != iObjectMode )
			continue;

		if ( pObj->IsDisposableBuilding() )
			continue;

		return pObj;
	}
	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int	CTFPlayer::GetObjectCount( void ) const
{
	return m_aObjects.Count();
}

//-----------------------------------------------------------------------------
// Purpose: Remove all the player's objects
//			If bExplodeBuildings is not set, remove all of them immediately.
//			Otherwise, make them all explode.
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveAllObjects( bool bExplodeBuildings /* = false */ )
{
	// Remove all the player's objects
	for (int i = GetObjectCount()-1; i >= 0; i--)
	{
		CBaseObject *obj = GetObject(i);
		Assert( obj );

		if ( obj )
		{
			// this is separate from the object_destroyed event, which does
			// not get sent when we remove the objects from the world
			IGameEvent *event = gameeventmanager->CreateEvent( "object_removed" );	
			if ( event )
			{
				event->SetInt( "userid", GetUserID() ); // user ID of the object owner
				event->SetInt( "objecttype", obj->GetType() ); // type of object removed
				event->SetInt( "index", obj->entindex() ); // index of the object removed
				gameeventmanager->FireEvent( event );
			}

			if ( bExplodeBuildings )
			{
				obj->DetonateObject();
			}
			else
			{
				// This fixes a bug in Raid mode where we could spawn where our sentry was but 
				// we didn't get the weapons because they couldn't trace to us in FVisible
				obj->SetSolid( SOLID_NONE );
				UTIL_Remove( obj );
			}
		}		
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::StopPlacement( void )
{
	/*
	// Tell our builder weapon
	CTFWeaponBuilder *pBuilder = GetWeaponBuilder();
	if ( pBuilder )
	{
		pBuilder->StopPlacement();
	}
	*/
}

//-----------------------------------------------------------------------------
// Purpose: Player has started building an object
//-----------------------------------------------------------------------------
int	CTFPlayer::StartedBuildingObject( int iObjectType )
{
	// Deduct the cost of the object
	int iCost = m_Shared.CalculateObjectCost( this, iObjectType );
	if ( iCost > GetBuildResources() )
	{
		// Player must have lost resources since he started placing
		return 0;
	}

	RemoveBuildResources( iCost );

	// If the object costs 0, we need to return non-0 to mean success
	if ( !iCost )
		return 1;

	return iCost;
}

//-----------------------------------------------------------------------------
// Purpose: Player has aborted building something
//-----------------------------------------------------------------------------
void CTFPlayer::StoppedBuilding( int iObjectType )
{
	/*
	int iCost = CalculateObjectCost( iObjectType );

	AddBuildResources( iCost );

	// Tell our builder weapon
	CTFWeaponBuilder *pBuilder = GetWeaponBuilder();
	if ( pBuilder )
	{
		pBuilder->StoppedBuilding( iObjectType );
	}
	*/
}

//-----------------------------------------------------------------------------
// Purpose: Object has been built by this player
//-----------------------------------------------------------------------------
void CTFPlayer::FinishedObject( CBaseObject *pObject )
{
	AddObject( pObject );

	CTF_GameStats.Event_PlayerCreatedBuilding( this, pObject );

	if ( TFGameRules() && TFGameRules()->IsInTraining() && TFGameRules()->GetTrainingModeLogic() && IsFakeClient() == false )
	{
		TFGameRules()->GetTrainingModeLogic()->OnPlayerBuiltBuilding( this, pObject );
	}

	/*
	// Tell our builder weapon
	CTFWeaponBuilder *pBuilder = GetWeaponBuilder();
	if ( pBuilder )
	{
		pBuilder->FinishedObject();
	}
	*/
}

//-----------------------------------------------------------------------------
// Purpose: Add the specified object to this player's object list.
//-----------------------------------------------------------------------------
void CTFPlayer::AddObject( CBaseObject *pObject )
{
	TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseTFPlayer::AddObject adding object %p:%s to player %s\n", gpGlobals->curtime, pObject, pObject->GetClassname(), GetPlayerName() ) );

	// Make a handle out of it
	CHandle<CBaseObject> hObject;
	hObject = pObject;

	bool alreadyInList = PlayerOwnsObject( pObject );
	// Assert( !alreadyInList );
	if ( !alreadyInList )
	{
		m_aObjects.AddToTail( hObject );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Object built by this player has been destroyed
//-----------------------------------------------------------------------------
void CTFPlayer::OwnedObjectDestroyed( CBaseObject *pObject )
{
	TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseTFPlayer::OwnedObjectDestroyed player %s object %p:%s\n", gpGlobals->curtime, 
		GetPlayerName(),
		pObject,
		pObject->GetClassname() ) );

	RemoveObject( pObject );

	// Tell our builder weapon so it recalculates the state of the build icons
	/*
	CTFWeaponBuilder *pBuilder = GetWeaponBuilder();
	if ( pBuilder )
	{
		pBuilder->RecalcState();
	}
	*/
}

//-----------------------------------------------------------------------------
// Removes an object from the player
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveObject( CBaseObject *pObject )
{
	TRACE_OBJECT( UTIL_VarArgs( "%0.2f CBaseTFPlayer::RemoveObject %p:%s from player %s\n", gpGlobals->curtime, 
		pObject,
		pObject->GetClassname(),
		GetPlayerName() ) );

	Assert( pObject );

	int i;
	for ( i = m_aObjects.Count(); --i >= 0; )
	{
		// Also, while we're at it, remove all other bogus ones too...
		if ( (!m_aObjects[i].Get()) || (m_aObjects[i] == pObject))
		{
			m_aObjects.FastRemove(i);
		}
	}
}

//-----------------------------------------------------------------------------
// See if the player owns this object
//-----------------------------------------------------------------------------
bool CTFPlayer::PlayerOwnsObject( CBaseObject *pObject )
{
	return ( m_aObjects.Find( pObject ) != -1 );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PlayFlinch( const CTakeDamageInfo &info )
{
	// Don't play flinches if we just died. 
	if ( !IsAlive() )
		return;

	// No pain flinches while disguised, our man has supreme discipline
	if ( m_Shared.InCond( TF_COND_DISGUISED ) )
		return;

	PlayerAnimEvent_t flinchEvent;

	switch ( LastHitGroup() )
	{
		// pick a region-specific flinch
	case HITGROUP_HEAD:
		flinchEvent = PLAYERANIMEVENT_FLINCH_HEAD;
		break;
	case HITGROUP_LEFTARM:
		flinchEvent = PLAYERANIMEVENT_FLINCH_LEFTARM;
		break;
	case HITGROUP_RIGHTARM:
		flinchEvent = PLAYERANIMEVENT_FLINCH_RIGHTARM;
		break;
	case HITGROUP_LEFTLEG:
		flinchEvent = PLAYERANIMEVENT_FLINCH_LEFTLEG;
		break;
	case HITGROUP_RIGHTLEG:
		flinchEvent = PLAYERANIMEVENT_FLINCH_RIGHTLEG;
		break;
	case HITGROUP_STOMACH:
	case HITGROUP_CHEST:
	case HITGROUP_GEAR:
	case HITGROUP_GENERIC:
	default:
		// just get a generic flinch.
		flinchEvent = PLAYERANIMEVENT_FLINCH_CHEST;
		break;
	}

	DoAnimationEvent( flinchEvent );
}

//-----------------------------------------------------------------------------
// Purpose: Plays the crit sound that players that get crit hear
//-----------------------------------------------------------------------------
float CTFPlayer::PlayCritReceivedSound( void )
{
	float flCritPainLength = 0;
	// Play a custom pain sound to the guy taking the damage
	CSingleUserRecipientFilter receiverfilter( this );
	EmitSound_t params;
	params.m_flSoundTime = 0;
	params.m_pSoundName = "TFPlayer.CritPain";
	params.m_pflSoundDuration = &flCritPainLength;
	EmitSound( receiverfilter, entindex(), params );

	return flCritPainLength;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PainSound( const CTakeDamageInfo &info )
{
	// Don't make sounds if we just died. DeathSound will handle that.
	if ( !IsAlive() )
		return;

	// no pain sounds while disguised, our man has supreme discipline
	if ( m_Shared.InCond( TF_COND_DISGUISED ) )
		return;

	if ( m_flNextPainSoundTime > gpGlobals->curtime )
		return;

	// Don't play falling pain sounds, they have their own system
	if ( info.GetDamageType() & DMG_FALL )
		return;

	// No sound for DMG_GENERIC
	if ( info.GetDamageType() == 0 || info.GetDamageType() == DMG_PREVENT_PHYSICS_FORCE )
		return;

	if ( info.GetDamageType() & DMG_DROWN )
	{
		EmitSound( "TFPlayer.Drown" );
		return;
	}

	if ( info.GetDamageType() & DMG_BURN )
	{
		// Looping fire pain sound is done in CTFPlayerShared::ConditionThink
		return;
	}

	float flPainLength = 0;

	bool bAttackerIsPlayer = ( info.GetAttacker() && info.GetAttacker()->IsPlayer() );

	CMultiplayer_Expresser *pExpresser = GetMultiplayerExpresser();
	Assert( pExpresser );

	pExpresser->AllowMultipleScenes();

	// speak a pain concept here, send to everyone but the attacker
	CPASFilter filter( GetAbsOrigin() );

	if ( bAttackerIsPlayer )
	{
		filter.RemoveRecipient( ToBasePlayer( info.GetAttacker() ) );
	}

	// play a crit sound to the victim ( us )
	if ( info.GetDamageType() & DMG_CRITICAL )
	{
		flPainLength = PlayCritReceivedSound();

		// remove us from hearing our own pain sound if we hear the crit sound
		filter.RemoveRecipient( this );
	}

	char szResponse[AI_Response::MAX_RESPONSE_NAME];

	if ( SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_PAIN, "damagecritical:1", szResponse, AI_Response::MAX_RESPONSE_NAME, &filter ) )
	{
		flPainLength = MAX( GetSceneDuration( szResponse ), flPainLength );
	}

	// speak a louder pain concept to just the attacker
	if ( bAttackerIsPlayer )
	{
		CSingleUserRecipientFilter attackerFilter( ToBasePlayer( info.GetAttacker() ) );
		SpeakConceptIfAllowed( MP_CONCEPT_PLAYER_ATTACKER_PAIN, "damagecritical:1", szResponse, AI_Response::MAX_RESPONSE_NAME, &attackerFilter );
	}

	pExpresser->DisallowMultipleScenes();

	m_flNextPainSoundTime = gpGlobals->curtime + flPainLength;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::DeathSound( const CTakeDamageInfo &info )
{
	// Don't make death sounds when choosing a class
	if ( IsPlayerClass( TF_CLASS_UNDEFINED ) )
		return;

	TFPlayerClassData_t *pData = GetPlayerClass()->GetData();
	if ( !pData )
		return;

	if ( m_bGoingFeignDeath  )
	{
		bool bDisguised = m_Shared.InCond( TF_COND_DISGUISED ) && (m_Shared.GetDisguiseTeam() == GetTeamNumber());
		if ( bDisguised )
		{
			// Use our disguise class, if we have one and will drop a disguise class corpse.
			pData = g_pTFPlayerClassDataMgr->Get( m_Shared.GetDisguiseClass() );
			if ( !pData )
				return;
		}
	}

	CTFPlayer *pAttacker = (CTFPlayer*)ToTFPlayer( info.GetAttacker() );
	if ( pAttacker )
	{
		CTFWeaponBase *pWpn = pAttacker->GetActiveTFWeapon();
		if ( pWpn && pWpn->IsSilentKiller() )
			return;
	}

	int nDeathSoundOffset = DEATH_SOUND_FIRST;

	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
	{
		nDeathSoundOffset = IsMiniBoss() ? DEATH_SOUND_GIANT_MVM_FIRST : DEATH_SOUND_MVM_FIRST;
	}
	
	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && 
		 GetTeamNumber() != TF_TEAM_PVE_INVADERS && !m_bGoingFeignDeath )
	{
		EmitSound( "MVM.PlayerDied" );
		return;
	}

	if ( m_LastDamageType & DMG_FALL ) // Did we die from falling?
	{
		// They died in the fall. Play a splat sound.
		EmitSound( "Player.FallGib" );
	}
	else if ( m_LastDamageType & DMG_BLAST )
	{
		EmitSound( pData->GetDeathSound( DEATH_SOUND_EXPLOSION + nDeathSoundOffset ) );
	}
	else if ( m_LastDamageType & DMG_CRITICAL )
	{
		EmitSound( pData->GetDeathSound( DEATH_SOUND_CRIT + nDeathSoundOffset ) );

		PlayCritReceivedSound();
	}
	else if ( m_LastDamageType & DMG_CLUB )
	{
		EmitSound( pData->GetDeathSound( DEATH_SOUND_MELEE + nDeathSoundOffset ) );
	}
	else
	{
		EmitSound( pData->GetDeathSound( DEATH_SOUND_GENERIC + nDeathSoundOffset ) );
	}

	// Play an additional sound when we're in MvM and have a boss death
	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && IsMiniBoss() )
	{
		switch ( GetPlayerClass()->GetClassIndex() )
		{
			case TF_CLASS_HEAVYWEAPONS:
			{
				EmitSound( "MVM.GiantHeavyExplodes" );
				break;
			}
			default:
			{
				EmitSound( "MVM.GiantCommonExplodes" );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char* CTFPlayer::GetSceneSoundToken( void )
{
	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
	{
		if ( IsMiniBoss() )
		{
			return "M_MVM_";
		}
		else
		{
			return "MVM_";
		}
	}
	else
	{
		return "";
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::StunSound( CTFPlayer* pAttacker, int iStunFlags, int iOldStunFlags )
{
	if ( !IsAlive() )
		return;

	if ( !(iStunFlags & TF_STUN_CONTROLS) && !(iStunFlags & TF_STUN_LOSER_STATE) )
		return;

	if ( (iStunFlags & TF_STUN_BY_TRIGGER) && (iOldStunFlags != 0) )
		return; // Only play stun triggered sounds when not already stunned.

	// Play the stun sound for everyone but the attacker.
	CMultiplayer_Expresser *pExpresser = GetMultiplayerExpresser();
	Assert( pExpresser );

	pExpresser->AllowMultipleScenes();

	float flStunSoundLength = 0;
	EmitSound_t params;
	params.m_flSoundTime = 0;
	if ( iStunFlags & TF_STUN_SPECIAL_SOUND )
	{
		params.m_pSoundName = "TFPlayer.StunImpactRange";
	}
	else if ( (iStunFlags & TF_STUN_LOSER_STATE) && !pAttacker )
	{
		params.m_pSoundName = "Halloween.PlayerScream";
	}
	else
	{
		params.m_pSoundName = "TFPlayer.StunImpact";
	}
	params.m_pflSoundDuration = &flStunSoundLength;

	if ( pAttacker )
	{
		CPASFilter filter( GetAbsOrigin() );
		filter.RemoveRecipient( pAttacker );
		EmitSound( filter, entindex(), params );

		// Play a louder pain sound for the person who got the stun.
		CSingleUserRecipientFilter attackerFilter( pAttacker );
		EmitSound( attackerFilter, pAttacker->entindex(), params );
	}
	else
	{
		EmitSound( params.m_pSoundName );
	}

	pExpresser->DisallowMultipleScenes();

	// Suppress any pain sound that might come right after this stun sound.
	m_flNextPainSoundTime = gpGlobals->curtime + 2.0f;
}

//-----------------------------------------------------------------------------
// Purpose: called when this player burns another player
//-----------------------------------------------------------------------------
void CTFPlayer::OnBurnOther( CTFPlayer *pTFPlayerVictim, CTFWeaponBase *pWeapon )
{
#define ACHIEVEMENT_BURN_TIME_WINDOW	30.0f
#define ACHIEVEMENT_BURN_VICTIMS	5
	// add current time we burned another player to head of vector
	m_aBurnOtherTimes.AddToHead( gpGlobals->curtime );

	// remove any burn times that are older than the burn window from the list
	float flTimeDiscard = gpGlobals->curtime - ACHIEVEMENT_BURN_TIME_WINDOW;
	for ( int i = 1; i < m_aBurnOtherTimes.Count(); i++ )
	{
		if ( m_aBurnOtherTimes[i] < flTimeDiscard )
		{
			m_aBurnOtherTimes.RemoveMultiple( i, m_aBurnOtherTimes.Count() - i );
			break;
		}
	}

	// see if we've burned enough players in time window to satisfy achievement
	if ( m_aBurnOtherTimes.Count() >= ACHIEVEMENT_BURN_VICTIMS )
	{
		AwardAchievement( ACHIEVEMENT_TF_BURN_PLAYERSINMINIMIMTIME );
	}

	// ACHIEVEMENT_TF_PYRO_KILL_SPIES - Awarded for igniting enemy spies who have active sappers on friendly building
	if ( pTFPlayerVictim->IsPlayerClass(TF_CLASS_SPY))
	{
		CBaseObject	*pSapper = pTFPlayerVictim->GetObjectOfType( OBJ_ATTACHMENT_SAPPER, 0 );
		if ( pSapper )
		{
			AwardAchievement( ACHIEVEMENT_TF_PYRO_KILL_SPIES );
		}
	}

	// ACHIEVEMENT_TF_PYRO_BURN_RJ_SOLDIER - Pyro ignited a rocket jumping soldier in mid-air
	if ( pTFPlayerVictim->IsPlayerClass(TF_CLASS_SOLDIER) )
	{
		if ( pTFPlayerVictim->RocketJumped() && !pTFPlayerVictim->GetGroundEntity() )
		{
			AwardAchievement( ACHIEVEMENT_TF_PYRO_BURN_RJ_SOLDIER );
		}
	}

	// ACHIEVEMENT_TF_PYRO_DEFEND_POINTS - Pyro kills targets capping control points
	CTriggerAreaCapture *pAreaTrigger = pTFPlayerVictim->GetControlPointStandingOn();
	if ( pAreaTrigger )
	{
		CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint();
		if ( pCP && pCP->GetOwner() == GetTeamNumber() )
		{
			if ( TeamplayGameRules()->TeamMayCapturePoint( pTFPlayerVictim->GetTeamNumber(), pCP->GetPointIndex() ) && 
				TeamplayGameRules()->PlayerMayCapturePoint( pTFPlayerVictim, pCP->GetPointIndex() ) )
			{
				AwardAchievement( ACHIEVEMENT_TF_PYRO_DEFEND_POINTS );
			}
		}
	}

	// ACHIEVEMENT_TF_MEDIC_ASSIST_PYRO
	// if we're invuln, let the medic know that we burned someone
	if ( m_Shared.InCond( TF_COND_INVULNERABLE ) || m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
	{
		int i;
		int iNumHealers = m_Shared.GetNumHealers();

		for ( i=0;i<iNumHealers;i++ )
		{
			// Send a message to all medics invulning the Pyro at this time
			CTFPlayer *pMedic = ToTFPlayer( m_Shared.GetHealerByIndex( i ) );
			if ( pMedic && pMedic->GetChargeEffectBeingProvided() == MEDIGUN_CHARGE_INVULN )
			{
				// Tell the clients involved in the ignition
				CSingleUserRecipientFilter medic_filter( pMedic );
				UserMessageBegin( medic_filter, "PlayerIgnitedInv" );
					WRITE_BYTE( entindex() );
					WRITE_BYTE( pTFPlayerVictim->entindex() );
					WRITE_BYTE( pMedic->entindex() );
				MessageEnd();
			}
		}
	}

	// Tell the clients involved in the ignition
	CRecipientFilter involved_filter;
	involved_filter.AddRecipient( this );
	involved_filter.AddRecipient( pTFPlayerVictim );
	UserMessageBegin( involved_filter, "PlayerIgnited" );
		WRITE_BYTE( entindex() );
		WRITE_BYTE( pTFPlayerVictim->entindex() );
		WRITE_BYTE( pWeapon ? pWeapon->GetWeaponID() : 0 );
	MessageEnd();

	IGameEvent *event = gameeventmanager->CreateEvent( "player_ignited" );
	if ( event )
	{
		event->SetInt( "pyro_entindex", entindex() );
		event->SetInt( "victim_entindex", pTFPlayerVictim->entindex() );
		event->SetInt( "weaponid", pWeapon ? pWeapon->GetWeaponID() : 0 );
		gameeventmanager->FireEvent( event, true );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Returns true if the player is capturing a point.
//-----------------------------------------------------------------------------
bool CTFPlayer::IsCapturingPoint()
{
	CTriggerAreaCapture *pAreaTrigger = GetControlPointStandingOn();
	if ( pAreaTrigger )
	{
		CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint();
		if ( pCP )
		{
			if ( TeamplayGameRules()->TeamMayCapturePoint( GetTeamNumber(), pCP->GetPointIndex() ) && 
				TeamplayGameRules()->PlayerMayCapturePoint( this, pCP->GetPointIndex() ) )
			{
				// if we own this point, we're no longer "capturing" it
				return pCP->GetOwner() != GetTeamNumber();
			}
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFTeam *CTFPlayer::GetTFTeam( void )
{
	CTFTeam *pTeam = dynamic_cast<CTFTeam *>( GetTeam() );
	Assert( pTeam );
	return pTeam;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFTeam *CTFPlayer::GetOpposingTFTeam( void )
{
	if ( TFTeamMgr() )
	{
		int iTeam = GetTeamNumber();
		if ( iTeam == TF_TEAM_RED )
		{
			return TFTeamMgr()->GetTeam( TF_TEAM_BLUE );
		}
		else if ( iTeam == TF_TEAM_BLUE )
		{
			return TFTeamMgr()->GetTeam( TF_TEAM_RED );
		}
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Give this player the "i just teleported" effect for 12 seconds
//-----------------------------------------------------------------------------
void CTFPlayer::TeleportEffect( void )
{
	m_Shared.AddCond( TF_COND_TELEPORTED );

	float flDuration = 12.f;
	if ( TFGameRules()->IsMannVsMachineMode() && m_bIsABot && IsBotOfType( TF_BOT_TYPE ) )
	{
		flDuration = 30.f;
	}

	// Also removed on death
	SetContextThink( &CTFPlayer::RemoveTeleportEffect, gpGlobals->curtime + flDuration, "TFPlayer_TeleportEffect" );
}

//-----------------------------------------------------------------------------
// Purpose: Remove the teleporter effect
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveTeleportEffect( void )
{
	m_Shared.RemoveCond( TF_COND_TELEPORTED );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::StopRagdollDeathAnim( void )
{
	CTFRagdoll *pRagdoll = dynamic_cast<CTFRagdoll*>( m_hRagdoll.Get() );
	if ( pRagdoll )
	{
		pRagdoll->m_iDamageCustom = 0;
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayer::CreateRagdollEntity( void )
{
	CreateRagdollEntity( false, false, false, false, false, false, false, false );
}

//-----------------------------------------------------------------------------
// Purpose: Create a ragdoll entity to pass to the client.
//-----------------------------------------------------------------------------
void CTFPlayer::CreateRagdollEntity( bool bGib, bool bBurning, bool bElectrocuted, bool bOnGround, bool bCloakedCorpse, bool bGoldRagdoll, bool bIceRagdoll, bool bBecomeAsh, int iDamageCustom, bool bCritOnHardHit )
{
	// If we already have a ragdoll destroy it.
	CTFRagdoll *pRagdoll = dynamic_cast<CTFRagdoll*>( m_hRagdoll.Get() );
	if( pRagdoll )
	{
		UTIL_Remove( pRagdoll );
		pRagdoll = NULL;
	}
	Assert( pRagdoll == NULL );

	// Create a ragdoll.
	pRagdoll = dynamic_cast<CTFRagdoll*>( CreateEntityByName( "tf_ragdoll" ) );
	if ( pRagdoll )
	{
		pRagdoll->m_vecRagdollOrigin = GetAbsOrigin();
		pRagdoll->m_vecRagdollVelocity = GetAbsVelocity();
		pRagdoll->m_vecForce = m_vecForce;
		pRagdoll->m_nForceBone = m_nForceBone;
		Assert( entindex() >= 1 && entindex() <= MAX_PLAYERS );
		pRagdoll->m_iPlayerIndex.Set( entindex() );
		pRagdoll->m_bGib = bGib;
		pRagdoll->m_bBurning = bBurning;
		pRagdoll->m_bElectrocuted = bElectrocuted;
		pRagdoll->m_bOnGround = bOnGround;
		pRagdoll->m_bCloaked = bCloakedCorpse;
		pRagdoll->m_iDamageCustom = iDamageCustom;
		pRagdoll->m_iTeam = GetTeamNumber();
		pRagdoll->m_iClass = GetPlayerClass()->GetClassIndex();
		pRagdoll->m_bGoldRagdoll = bGoldRagdoll;
		pRagdoll->m_bIceRagdoll = bIceRagdoll;
		pRagdoll->m_bBecomeAsh = bBecomeAsh;
		pRagdoll->m_bCritOnHardHit = bCritOnHardHit;
		pRagdoll->m_flHeadScale = m_flHeadScale;
		pRagdoll->m_flTorsoScale = m_flTorsoScale;
		pRagdoll->m_flHandScale = m_flHandScale;
	}

	// Turn off the player.
	AddSolidFlags( FSOLID_NOT_SOLID );
	AddEffects( EF_NODRAW | EF_NOSHADOW );
	SetMoveType( MOVETYPE_NONE );

	// Add additional gib setup.
	if ( bGib )
	{
		m_nRenderFX = kRenderFxRagdoll;
	}

	// Save ragdoll handle.
	m_hRagdoll = pRagdoll;
}

//-----------------------------------------------------------------------------
// Purpose: Destroy's a ragdoll, called with a player is disconnecting.
//-----------------------------------------------------------------------------
void CTFPlayer::DestroyRagdoll( void )
{
	CTFRagdoll *pRagdoll = dynamic_cast<CTFRagdoll*>( m_hRagdoll.Get() );	
	if( pRagdoll )
	{
		UTIL_Remove( pRagdoll );
	}

	// Remove the feign death ragdoll at the same time.
	pRagdoll = dynamic_cast<CTFRagdoll*>( m_hFeignRagdoll.Get() );	
	if( pRagdoll )
	{
		UTIL_Remove( pRagdoll );
	}
}

//-----------------------------------------------------------------------------
// Purpose: The player appears to die, creating a corpse and silently stealthing.
//			Occurs when a player takes damage with the dead ringer active
//-----------------------------------------------------------------------------
void CTFPlayer::SpyDeadRingerDeath( const CTakeDamageInfo& info )
{
	// Can't feign death if we're actually dead or if we're not a spy.
	if ( !IsAlive() || !IsPlayerClass( TF_CLASS_SPY ) )
		return;

	// Can't feign death if we're already stealthed.
	if ( m_Shared.InCond( TF_COND_STEALTHED ) )
		return;

	// Can't feign death if we aren't at full cloak energy.
	if ( !CanGoInvisible( true ) || ( m_Shared.GetSpyCloakMeter() < 100.0f ) )
		return;

	m_Shared.SetSpyCloakMeter( 50.0f );

	m_bGoingFeignDeath = true; 

	FeignDeath( info );

	// Go feign death.
	m_Shared.AddCond( TF_COND_FEIGN_DEATH, tf_feign_death_duration.GetFloat() );
	m_bGoingFeignDeath = false;
}

//-----------------------------------------------------------------------------
// Purpose: The player appears to die, creating a corpse
//-----------------------------------------------------------------------------
void CTFPlayer::FeignDeath( const CTakeDamageInfo& info )
{
	if ( HasTheFlag() )
	{
		DropFlag();
	}

	// Dead Ringer death removes Powerup Rune for authenticity
	DropRune();

	// Only drop disguised ragdoll & weapon if we're disguised as a teammate.
	bool bDisguised = m_Shared.InCond( TF_COND_DISGUISED ) && (m_Shared.GetDisguiseTeam() == GetTeamNumber());

	// We want the ragdoll to burn if the player was burning and was not disguised as a pyro.
	bool bBurning = m_Shared.InCond( TF_COND_BURNING ) && (!bDisguised || (TF_CLASS_PYRO != m_Shared.GetDisguiseClass()));

	// Stop us from burning and other effects that would give the game away.
	m_Shared.RemoveCond( TF_COND_BURNING );
	m_Shared.RemoveCond( TF_COND_BLEEDING );
	RemoveTeleportEffect();

	// Fake death audio.
	EmitSound( "BaseCombatCharacter.StopWeaponSounds" );
	SpeakConceptIfAllowed( MP_CONCEPT_DIED );
	DeathSound( info );

	// Check if we should create gibs.
	bool bGib = ShouldGib( info );

	SetGibbedOnLastDeath( bGib );

	// Fake death notice.
	TFGameRules()->DeathNotice( this, info );

	// Drop an empty ammo pack!
	if ( ShouldDropAmmoPack() )
	{
		DropAmmoPack( info, true /*Empty*/, bDisguised );
	}

	if ( TFGameRules()->IsInMedievalMode() )
	{
		DropHealthPack( info, true );
	}

	if ( GetActiveTFWeapon() )
	{
		int iDropHealthOnKill = 0;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( GetActiveTFWeapon(), iDropHealthOnKill, drop_health_pack_on_kill );
		if ( iDropHealthOnKill == 1 )
		{
			DropHealthPack( info, true );
		}
	}

	CTFPlayer *pTFPlayer = ToTFPlayer( info.GetAttacker() );
	if ( pTFPlayer )
	{
		int iKillForcesAttackerToLaugh = 0;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFPlayer, iKillForcesAttackerToLaugh, kill_forces_attacker_to_laugh );
		if ( iKillForcesAttackerToLaugh == 1 )
		{
			// force the attacker to laugh!
			pTFPlayer->Taunt( TAUNT_MISC_ITEM, MP_CONCEPT_TAUNT_LAUGH );
		}

		CTFWeaponInvis *pWpn = (CTFWeaponInvis *)Weapon_OwnsThisID( TF_WEAPON_INVIS );
		if ( pWpn && pWpn->HasFeignDeath() )
		{
			DropDeathCallingCard( pTFPlayer, this );
		}
	}

	// Create a ragdoll.
	CreateFeignDeathRagdoll( info, bGib, bBurning, bDisguised );

	// Note that we succeeded for stats tracking.
	EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( GetEntityForLoadoutSlot( LOADOUT_POSITION_PDA2 ) ),
									  this,
									  pTFPlayer,			// in this case the "victim" is the person doing the damage
									  kKillEaterEvent_DeathsFeigned );
}

//-----------------------------------------------------------------------------
// Purpose: Create a ragdoll entity for feign death. Does not hide the player.
// Creates an entirely seperate ragdoll that isn't used for client death cam or other real death stuff.
//-----------------------------------------------------------------------------
void CTFPlayer::CreateFeignDeathRagdoll( const CTakeDamageInfo& info, bool bGib, bool bBurning, bool bDisguised )
{
	// If we already have a feigning ragdoll destroy it.
	CTFRagdoll *pRagdoll = dynamic_cast<CTFRagdoll*>( m_hFeignRagdoll.Get() );
	if( pRagdoll )
	{
		UTIL_Remove( pRagdoll );
		pRagdoll = NULL;
	}
	Assert( pRagdoll == NULL );

	// Create a ragdoll.
	pRagdoll = dynamic_cast<CTFRagdoll*>( CreateEntityByName( "tf_ragdoll" ) );
	if ( pRagdoll )
	{
		pRagdoll->m_vecRagdollOrigin = GetAbsOrigin();
		pRagdoll->m_vecRagdollVelocity = m_vecFeignDeathVelocity;
		pRagdoll->m_vecForce = CalcDamageForceVector( info );
		pRagdoll->m_nForceBone = m_nForceBone;
		Assert( entindex() >= 1 && entindex() <= MAX_PLAYERS );
		pRagdoll->m_iPlayerIndex.Set( entindex() );
		pRagdoll->m_bGib = bGib;
		pRagdoll->m_bBurning = bBurning;
		pRagdoll->m_bElectrocuted = false;
		pRagdoll->m_bFeignDeath = true;
		pRagdoll->m_bWasDisguised = bDisguised;
		pRagdoll->m_bBecomeAsh = false;
		pRagdoll->m_bOnGround = (bool) (GetFlags() & FL_ONGROUND);
		pRagdoll->m_iDamageCustom = info.GetDamageCustom();
		pRagdoll->m_bCritOnHardHit = false;
		pRagdoll->m_flHeadScale = m_flHeadScale;
		pRagdoll->m_flTorsoScale = m_flTorsoScale;
		pRagdoll->m_flHandScale = m_flHandScale;

		{
			int iGoldRagdoll = 0;
			if ( info.GetWeapon() )
			{
				 CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iGoldRagdoll, set_turn_to_gold );
			}
			pRagdoll->m_bGoldRagdoll = iGoldRagdoll != 0;

			int iIceRagdoll = 0;
			if ( info.GetWeapon() )
			{
				CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iIceRagdoll, set_turn_to_ice );
			}
			pRagdoll->m_bIceRagdoll = iIceRagdoll != 0;

			int iRagdollsBecomeAsh = 0;
			if ( info.GetWeapon() )
			{
				CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iRagdollsBecomeAsh, ragdolls_become_ash );
			}
			pRagdoll->m_bBecomeAsh = iRagdollsBecomeAsh != 0;

			int iRagdollsPlasmaEffect = 0;
			if ( info.GetWeapon() )
			{
				CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iRagdollsPlasmaEffect, ragdolls_plasma_effect );
			}
			if ( iRagdollsPlasmaEffect )
			{
				pRagdoll->m_iDamageCustom = TF_DMG_CUSTOM_PLASMA;
			}

			int iCritOnHardHit = 0;
			if ( info.GetWeapon() )
			{
				CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iCritOnHardHit, crit_on_hard_hit );
			}
			pRagdoll->m_bCritOnHardHit = iCritOnHardHit != 0;
		}

		// If we are disguised, make the ragdoll look like our disguise.
		if ( bDisguised )
		{
			pRagdoll->m_iTeam = m_Shared.GetDisguiseTeam();
			pRagdoll->m_iClass = m_Shared.GetDisguiseClass();
		}
		else
		{
			pRagdoll->m_iTeam = GetTeamNumber();
			pRagdoll->m_iClass = GetPlayerClass()->GetClassIndex();
		}
	}

	// Exaggerate ragdoll velocity if recently hit by blast damage.
	if ( !bGib && ( info.GetDamageType() & DMG_BLAST ) )
	{
		Vector vForceModifier = info.GetDamageForce();
		vForceModifier.x *= 1.5;
		vForceModifier.y *= 1.5;
		vForceModifier.z *= 1;
		pRagdoll->m_vecForce = vForceModifier;
	}

	// Save ragdoll handle.
	m_hFeignRagdoll = pRagdoll;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::Weapon_FrameUpdate( void )
{
	BaseClass::Weapon_FrameUpdate();

	if ( m_hOffHandWeapon.Get() && m_hOffHandWeapon->IsWeaponVisible() )
	{
		m_hOffHandWeapon->Operator_FrameUpdate( this );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
// Input  :
// Output :
//-----------------------------------------------------------------------------
void CTFPlayer::Weapon_HandleAnimEvent( animevent_t *pEvent )
{
	BaseClass::Weapon_HandleAnimEvent( pEvent );

	if ( m_hOffHandWeapon.Get() )
	{
		m_hOffHandWeapon->Operator_HandleAnimEvent( pEvent, this );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
// Input  :
// Output :
//-----------------------------------------------------------------------------
void CTFPlayer::Weapon_Drop( CBaseCombatWeapon *pWeapon, const Vector *pvecTarget , const Vector *pVelocity ) 
{

}

//-----------------------------------------------------------------------------
// Purpose: Call this when this player fires a weapon to allow other systems to react
//-----------------------------------------------------------------------------
void CTFPlayer::OnMyWeaponFired( CBaseCombatWeapon *weapon )
{
	BaseClass::OnMyWeaponFired( weapon );

	// mark region as 'in combat'
	if ( m_inCombatThrottleTimer.IsElapsed() )
	{
		CTFWeaponBase *tfWeapon = static_cast< CTFWeaponBase * >( weapon );

		if ( !tfWeapon )
		{
			return;
		}

		switch ( tfWeapon->GetWeaponID() )
		{
		case TF_WEAPON_MEDIGUN:
		case TF_WEAPON_PDA:
		case TF_WEAPON_PDA_ENGINEER_BUILD:
		case TF_WEAPON_PDA_ENGINEER_DESTROY:
		case TF_WEAPON_PDA_SPY:
		case TF_WEAPON_BUILDER:
		case TF_WEAPON_DISPENSER:
		case TF_WEAPON_INVIS:
		case TF_WEAPON_LUNCHBOX:
		case TF_WEAPON_BUFF_ITEM:
		case TF_WEAPON_PUMPKIN_BOMB:
		case TF_WEAPON_WRENCH:			// skip this so engineer building doesn't mark 'in combat'
		case TF_WEAPON_PDA_SPY_BUILD:
			// not a 'combat' weapon
			return;
		};

		// important to keep this at one second, so rate cvars make sense (units/sec)
		m_inCombatThrottleTimer.Start( 1.0f );

		// only search up/down StepHeight as a cheap substitute for line of sight
		CUtlVector< CNavArea * > nearbyAreaVector;
		CollectSurroundingAreas( &nearbyAreaVector, GetLastKnownArea(), tf_nav_in_combat_range.GetFloat(), StepHeight, StepHeight );

		for( int i=0; i<nearbyAreaVector.Count(); ++i )
		{
			static_cast< CTFNavArea * >( nearbyAreaVector[i] )->OnCombat();
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: Remove invisibility, called when player attacks
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveInvisibility( void )
{
	if ( !m_Shared.IsStealthed() )
		return;

	// remove quickly
	CTFPlayer *pProvider = ToTFPlayer( m_Shared.GetConditionProvider( TF_COND_STEALTHED_USER_BUFF ) );
	bool bAEStealth = ( m_Shared.InCond( TF_COND_STEALTHED_USER_BUFF ) && 
						pProvider && 
						( pProvider->IsPlayerClass( TF_CLASS_SPY ) ? true : false ) &&
						( pProvider != this ) );
	if ( m_Shared.InCond( TF_COND_STEALTHED_USER_BUFF ) )
	{
		m_Shared.AddCond( TF_COND_STEALTHED_USER_BUFF_FADING, ( bAEStealth ) ? 4.f : 0.5f );
	}

	m_Shared.FadeInvis( bAEStealth ? 2.f : 0.5f );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::SayAskForBall() 
{
	if ( !TFGameRules() || !TFGameRules()->IsPasstimeMode() 
		|| ( m_Shared.AskForBallTime() > gpGlobals->curtime ) )
	{
		return false;
	}

	CPasstimeBall *pBall = g_pPasstimeLogic->GetBall();
	if ( !pBall )
	{
		return false;
	}

	CTFPlayer *pBallCarrier = pBall->GetCarrier();
	if ( !pBallCarrier )
	{
		return false;
	}

	HudNotification_t cantCarryReason;
	if ( !CPasstimeGun::BValidPassTarget( pBallCarrier, this, &cantCarryReason ) )
	{
		if ( cantCarryReason ) 
		{
			CSingleUserReliableRecipientFilter filter( this );
			TFGameRules()->SendHudNotification( filter, cantCarryReason );
		}
		return false;
	}

	CRecipientFilter filter;
	filter.AddRecipient( this );
	filter.AddRecipient( pBallCarrier );
	filter.MakeReliable();
	EmitSound( filter, entindex(), "Passtime.AskForBall" );

	++CTF_GameStats.m_passtimeStats.summary.nTotalPassRequests;
	m_Shared.SetAskForBallTime( gpGlobals->curtime + 5.0f );
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::SaveMe( void )
{
	if ( !IsAlive() || IsPlayerClass( TF_CLASS_UNDEFINED ) || GetTeamNumber() < TF_TEAM_RED )
		return;

	m_bSaveMeParity = !m_bSaveMeParity;
}

//-----------------------------------------------------------------------------
// Purpose: drops the flag
//-----------------------------------------------------------------------------
void CC_DropItem( void )
{
	CTFPlayer *pPlayer = ToTFPlayer( UTIL_GetCommandClient() );
	if ( !pPlayer )
		return;

	if ( pPlayer->m_Shared.IsCarryingRune() )
	{
		pPlayer->DropRune();
		return;
	}
	
	if ( pPlayer->HasTheFlag() )
	{
		pPlayer->DropFlag();
	}
}
static ConCommand dropitem( "dropitem", CC_DropItem, "Drop the flag." );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CObserverPoint::CObserverPoint()
{
	m_bMatchSummary = false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObserverPoint::Activate( void )
{
	BaseClass::Activate();

	if ( m_bMatchSummary )
	{
		// sanity check to make sure the competitive match summary target is disabled until we're ready for it
		SetDisabled( true );
	}

	if ( m_iszAssociateTeamEntityName != NULL_STRING )
	{
		m_hAssociatedTeamEntity = gEntList.FindEntityByName( NULL, m_iszAssociateTeamEntityName );
		if ( !m_hAssociatedTeamEntity )
		{
			Warning("info_observer_point (%s) couldn't find associated team entity named '%s'\n", GetDebugName(), STRING(m_iszAssociateTeamEntityName) );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CObserverPoint::CanUseObserverPoint( CTFPlayer *pPlayer )
{
	if ( m_bDisabled )
		return false;

	// Only spectate observer points on control points in the current miniround
	if ( g_pObjectiveResource->PlayingMiniRounds() && m_hAssociatedTeamEntity )
	{
		CTeamControlPoint *pPoint = dynamic_cast<CTeamControlPoint*>(m_hAssociatedTeamEntity.Get());
		if ( pPoint )
		{
			bool bInRound = g_pObjectiveResource->IsInMiniRound( pPoint->GetPointIndex() );
			if ( !bInRound )
				return false;
		}
	}

	if ( m_hAssociatedTeamEntity && mp_forcecamera.GetInt() == OBS_ALLOW_TEAM )
	{
		// don't care about this check during a team win
		if ( TFGameRules() && TFGameRules()->State_Get() != GR_STATE_TEAM_WIN )
		{
			// If we don't own the associated team entity, we can't use this point
			if ( m_hAssociatedTeamEntity->GetTeamNumber() != pPlayer->GetTeamNumber() && pPlayer->GetTeamNumber() >= FIRST_GAME_TEAM )
				return false;
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CObserverPoint::UpdateTransmitState()
{
	return SetTransmitState( FL_EDICT_ALWAYS );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObserverPoint::InputEnable( inputdata_t &inputdata )
{
	m_bDisabled = false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CObserverPoint::InputDisable( inputdata_t &inputdata )
{
	m_bDisabled = true;
}

BEGIN_DATADESC( CObserverPoint )
DEFINE_KEYFIELD( m_bDisabled, FIELD_BOOLEAN, "StartDisabled" ),
DEFINE_KEYFIELD( m_bDefaultWelcome, FIELD_BOOLEAN, "defaultwelcome" ),
DEFINE_KEYFIELD( m_iszAssociateTeamEntityName, FIELD_STRING, "associated_team_entity" ),
DEFINE_KEYFIELD( m_flFOV, FIELD_FLOAT, "fov" ),
DEFINE_KEYFIELD( m_bMatchSummary, FIELD_BOOLEAN, "match_summary" ),

DEFINE_INPUTFUNC( FIELD_VOID, "Enable", InputEnable ),
DEFINE_INPUTFUNC( FIELD_VOID, "Disable", InputDisable ),
END_DATADESC()

LINK_ENTITY_TO_CLASS( info_observer_point, CObserverPoint );

//-----------------------------------------------------------------------------
// Purpose: Builds a list of entities that this player can observe.
//			Returns the index into the list of the player's current observer target.
//-----------------------------------------------------------------------------
int CTFPlayer::BuildObservableEntityList( void )
{
	m_hObservableEntities.Purge();
	int iCurrentIndex = -1;

	// Add all the map-placed observer points
	CBaseEntity *pObserverPoint = gEntList.FindEntityByClassname( NULL, "info_observer_point" );
	while ( pObserverPoint )
	{
		m_hObservableEntities.AddToTail( pObserverPoint );

		if ( m_hObserverTarget.Get() == pObserverPoint )
		{
			iCurrentIndex = (m_hObservableEntities.Count()-1);
		}

		pObserverPoint = gEntList.FindEntityByClassname( pObserverPoint, "info_observer_point" );
	}

	// Add all the players
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CBaseEntity *pPlayer = UTIL_PlayerByIndex( i );
		if ( pPlayer )
		{
			m_hObservableEntities.AddToTail( pPlayer );

			if ( m_hObserverTarget.Get() == pPlayer )
			{
				iCurrentIndex = (m_hObservableEntities.Count()-1);
			}
		}
	}

	// Add all my objects
	int iNumObjects = GetObjectCount();
	for ( int i = 0; i < iNumObjects; i++ )
	{
		CBaseObject *pObj = GetObject( i );
		if ( pObj )
		{
			m_hObservableEntities.AddToTail( pObj );

			if ( m_hObserverTarget.Get() == pObj )
			{
				iCurrentIndex = ( m_hObservableEntities.Count() - 1 );
			}
		}
	}

#ifdef TF_RAID_MODE
	// Add all of the objects for my team if we're in Raid mode
	if ( TFGameRules() && TFGameRules()->IsRaidMode() )
	{
		CTFTeam *pTeam = TFTeamMgr()->GetTeam( TF_TEAM_BLUE );
		if ( pTeam )
		{
			int nTeamObjectCount = pTeam->GetNumObjects();

			for ( int iObject = 0; iObject < nTeamObjectCount; ++iObject )
			{
				CBaseObject *pObj = pTeam->GetObject( iObject );

				if ( !pObj )
					continue;

				// we've already added our own buildings in the previous loop
				if ( pObj->GetOwner() == this )
					continue;

				m_hObservableEntities.AddToTail( pObj );

				if ( m_hObserverTarget.Get() == pObj )
				{
					iCurrentIndex = ( m_hObservableEntities.Count() - 1 );
				}
			}
		}
	}
#endif // TF_RAID_MODE

	// If there are any team_train_watchers, add the train they are linked to
	CTeamTrainWatcher *pWatcher = dynamic_cast<CTeamTrainWatcher*>( gEntList.FindEntityByClassname( NULL, "team_train_watcher" ) );
	while ( pWatcher )
	{
		if ( !pWatcher->IsDisabled() )
		{
			CBaseEntity *pTrain = pWatcher->GetTrainEntity();
			if ( pTrain )
			{
				m_hObservableEntities.AddToTail( pTrain );

				if ( m_hObserverTarget.Get() == pTrain )
				{
					iCurrentIndex = (m_hObservableEntities.Count()-1);
				}
			}
		}		

		pWatcher = dynamic_cast<CTeamTrainWatcher*>( gEntList.FindEntityByClassname( pWatcher, "team_train_watcher" ) );
	}

	// observe active bosses
	if ( TFGameRules()->GetActiveBoss() )
	{
		m_hObservableEntities.AddToTail( TFGameRules()->GetActiveBoss() );

		if ( m_hObserverTarget.Get() == TFGameRules()->GetActiveBoss() )
		{
			iCurrentIndex = ( m_hObservableEntities.Count() - 1 );
		}
	}

	return iCurrentIndex;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFPlayer::GetNextObserverSearchStartPoint( bool bReverse )
{
	int iDir = bReverse ? -1 : 1; 
	int startIndex = BuildObservableEntityList();
	int iMax = m_hObservableEntities.Count()-1;

	startIndex += iDir;
	if (startIndex > iMax)
		startIndex = 0;
	else if (startIndex < 0)
		startIndex = iMax;

	return startIndex;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBaseEntity *CTFPlayer::FindNextObserverTarget(bool bReverse)
{
	int startIndex = GetNextObserverSearchStartPoint( bReverse );

	int	currentIndex = startIndex;
	int iDir = bReverse ? -1 : 1; 

	int iMax = m_hObservableEntities.Count()-1;

	// Make sure the current index is within the max. Can happen if we were previously
	// spectating an object which has been destroyed.
	if ( startIndex > iMax )
	{
		currentIndex = startIndex = 1;
	}

	do
	{
		CBaseEntity *nextTarget = m_hObservableEntities[currentIndex];

		if ( IsValidObserverTarget( nextTarget ) )
			return nextTarget;	
 
		currentIndex += iDir;

		// Loop through the entities
		if (currentIndex > iMax)
		{
			currentIndex = 0;
		}
		else if (currentIndex < 0)
		{
			currentIndex = iMax;
		}
	} while ( currentIndex != startIndex );

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsValidObserverTarget(CBaseEntity * target)
{
	if ( !target || target == this )
		return false;

	// if we are coaching, the target is always valid
	if ( target && m_hStudent == target && target->IsPlayer() )
	{
		return true;
	}

	bool bAllowInTournament = false;

	if ( TFGameRules()->IsMannVsMachineMode() )
	{
		bAllowInTournament = true;
	}

	if ( TFGameRules()->IsPasstimeMode() && (target == TFGameRules()->GetObjectiveObserverTarget()) )
	{
		return true;
	}

	if ( target && !target->IsPlayer() )
	{
		//Can only spectate players in Tournament Mode
		if ( TFGameRules()->IsInTournamentMode() == true && !bAllowInTournament )
			return false;

		CObserverPoint *pObsPoint = dynamic_cast<CObserverPoint *>(target);
		if ( pObsPoint && !pObsPoint->CanUseObserverPoint( this ) )
			return false;

		CFuncTrackTrain *pTrain = dynamic_cast<CFuncTrackTrain *>(target);
		if ( pTrain )
		{
			// can only spec the trains while the round is running
			if ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN )
				return false;
		}

		if ( GetTeamNumber() == TEAM_SPECTATOR )
			return true;
		
		switch ( mp_forcecamera.GetInt() )	
		{
		case OBS_ALLOW_ALL	:	break;
		case OBS_ALLOW_TEAM :	if ( target->GetTeamNumber() != TEAM_UNASSIGNED && GetTeamNumber() != target->GetTeamNumber() )
									return false;
								break;
		case OBS_ALLOW_NONE :	return false;
		}

		return true;
	}

	return BaseClass::IsValidObserverTarget( target );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PickWelcomeObserverPoint( void )
{
	//Don't just spawn at the world origin, find a nice spot to look from while we choose our team and class.
	CObserverPoint *pObserverPoint = (CObserverPoint *)gEntList.FindEntityByClassname( NULL, "info_observer_point" );

	while ( pObserverPoint )
	{
		if ( IsValidObserverTarget( pObserverPoint ) )
		{
			SetObserverTarget( pObserverPoint );
		}

		if ( pObserverPoint->IsDefaultWelcome() )
			break;

		pObserverPoint = (CObserverPoint *)gEntList.FindEntityByClassname( pObserverPoint, "info_observer_point" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::SetObserverTarget(CBaseEntity *target)
{
	ClearZoomOwner();
	SetFOV( this, 0 );
		
	if ( !BaseClass::SetObserverTarget(target) )
		return false;

	CObserverPoint *pObsPoint = dynamic_cast<CObserverPoint *>(target);
	if ( pObsPoint )
	{
		SetViewOffset( vec3_origin );
		JumptoPosition( target->GetAbsOrigin(), target->EyeAngles() );
		SetFOV( pObsPoint, pObsPoint->m_flFOV );
	}

	if ( !m_bArenaIsAFK )
	{
		m_flLastAction = gpGlobals->curtime;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Find the nearest team member within the distance of the origin.
//			Favor players who are the same class.
//-----------------------------------------------------------------------------
CBaseEntity *CTFPlayer::FindNearestObservableTarget( Vector vecOrigin, float flMaxDist )
{
	CTeam *pTeam = GetTeam();
	CBaseEntity *pReturnTarget = NULL;
	bool bFoundClass = false;
	float flCurDistSqr = (flMaxDist * flMaxDist);
	int iNumPlayers = pTeam->GetNumPlayers();

	if ( pTeam->GetTeamNumber() == TEAM_SPECTATOR )
	{
		iNumPlayers = gpGlobals->maxClients;
	}


	for ( int i = 0; i < iNumPlayers; i++ )
	{
		CTFPlayer *pPlayer = NULL;

		if ( pTeam->GetTeamNumber() == TEAM_SPECTATOR )
		{
			pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		}
		else
		{
			pPlayer = ToTFPlayer( pTeam->GetPlayer(i) );
		}

		if ( !pPlayer )
			continue;

		if ( !IsValidObserverTarget(pPlayer) )
			continue;

		float flDistSqr = ( pPlayer->GetAbsOrigin() - vecOrigin ).LengthSqr();

		if ( flDistSqr < flCurDistSqr )
		{
			// If we've found a player matching our class already, this guy needs
			// to be a matching class and closer to boot.
			if ( !bFoundClass || pPlayer->IsPlayerClass( GetPlayerClass()->GetClassIndex() ) )
			{
				pReturnTarget = pPlayer;
				flCurDistSqr = flDistSqr;

				if ( pPlayer->IsPlayerClass( GetPlayerClass()->GetClassIndex() ) )
				{
					bFoundClass = true;
				}
			}
		}
		else if ( !bFoundClass )
		{
			if ( pPlayer->IsPlayerClass( GetPlayerClass()->GetClassIndex() ) )
			{
				pReturnTarget = pPlayer;
				flCurDistSqr = flDistSqr;
				bFoundClass = true;
			}
		}
	}

	if ( !bFoundClass && IsPlayerClass( TF_CLASS_ENGINEER ) )
	{
		// let's spectate our sentry instead, we didn't find any other engineers to spec
		int iNumObjects = GetObjectCount();
		for ( int i=0;i<iNumObjects;i++ )
		{
			CBaseObject *pObj = GetObject(i);

			if ( pObj && pObj->GetType() == OBJ_SENTRYGUN )
			{
				pReturnTarget = pObj;
			}
		}
	}		

	return pReturnTarget;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::FindInitialObserverTarget( void )
{
	// if there is a Boss active, watch him
	if ( TFGameRules()->GetActiveBoss() )
	{
		m_hObserverTarget.Set( TFGameRules()->GetActiveBoss() );
	}

	// If we're on a team (i.e. not a pure observer), try and find
	// a target that'll give the player the most useful information.
	if ( GetTeamNumber() >= FIRST_GAME_TEAM )
	{
		CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
		if ( pMaster )
		{
			// Has our forward cap point been contested recently?
			int iFarthestPoint = TFGameRules()->GetFarthestOwnedControlPoint( GetTeamNumber(), false );
			if ( iFarthestPoint != -1 )
			{
				float flTime = pMaster->PointLastContestedAt( iFarthestPoint );
				if ( flTime != -1 && flTime > (gpGlobals->curtime - 30) )
				{
					// Does it have an associated viewpoint?
					CBaseEntity *pObserverPoint = gEntList.FindEntityByClassname( NULL, "info_observer_point" );
					while ( pObserverPoint )
					{
						CObserverPoint *pObsPoint = assert_cast<CObserverPoint *>(pObserverPoint);
						if ( pObsPoint && pObsPoint->m_hAssociatedTeamEntity == pMaster->GetControlPoint(iFarthestPoint) )
						{
							if ( IsValidObserverTarget( pObsPoint ) )
							{
								m_hObserverTarget.Set( pObsPoint );
								return;
							}
						}

						pObserverPoint = gEntList.FindEntityByClassname( pObserverPoint, "info_observer_point" );
					}
				}
			}

			// Has the point beyond our farthest been contested lately?
			iFarthestPoint += (ObjectiveResource()->GetBaseControlPointForTeam( GetTeamNumber() ) == 0 ? 1 : -1);
			if ( iFarthestPoint >= 0 && iFarthestPoint < MAX_CONTROL_POINTS )
			{
				float flTime = pMaster->PointLastContestedAt( iFarthestPoint );
				if ( flTime != -1 && flTime > (gpGlobals->curtime - 30) )
				{
					// Try and find a player near that cap point
					CBaseEntity *pCapPoint = pMaster->GetControlPoint(iFarthestPoint);
					if ( pCapPoint )
					{
						CBaseEntity *pTarget = FindNearestObservableTarget( pCapPoint->GetAbsOrigin(), 1500 );
						if ( pTarget )
						{
							m_hObserverTarget.Set( pTarget );
							return;
						}
					}
				}
			}
		}
	}

	// Find the nearest guy near myself
	CBaseEntity *pTarget = FindNearestObservableTarget( GetAbsOrigin(), FLT_MAX );
	if ( pTarget )
	{
		m_hObserverTarget.Set( pTarget );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ValidateCurrentObserverTarget( void )
{
	// If our current target is a dead player who's gibbed / died, refind as if 
	// we were finding our initial target, so we end up somewhere useful.
	if ( m_hObserverTarget && m_hObserverTarget->IsPlayer() )
	{
		CBasePlayer *player = ToBasePlayer( m_hObserverTarget );

		if ( player->m_lifeState == LIFE_DEAD || player->m_lifeState == LIFE_DYING )
		{
			// if we are coaching, don't switch
			if ( m_hStudent == m_hObserverTarget )
			{
				return;
			}

			// Once we're past the pause after death, find a new target
			if ( (player->GetDeathTime() + DEATH_ANIMATION_TIME ) < gpGlobals->curtime )
			{
				FindInitialObserverTarget();
			}

			return;
		}
	}

	if ( m_hObserverTarget && !m_hObserverTarget->IsPlayer() )
	{
		// can only spectate players in-eye
		if ( m_iObserverMode == OBS_MODE_IN_EYE )
		{
			ForceObserverMode( OBS_MODE_CHASE );
		}
	}

	BaseClass::ValidateCurrentObserverTarget();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::CheckObserverSettings()
{
	// make sure we are always observing the student
	if ( m_hObserverTarget && m_hStudent && m_hStudent != m_hObserverTarget )
	{
		SetObserverTarget( m_hStudent );
	}
	else if ( TFGameRules() )
	{
		// is there a current entity that is the required spectator target?
		if ( TFGameRules()->GetRequiredObserverTarget() )
		{
			SetObserverTarget( TFGameRules()->GetRequiredObserverTarget() );
			return;
		}

		if ( TFGameRules()->IsPasstimeMode() && g_pPasstimeLogic && (GetObserverMode() == OBS_MODE_POI)  )
		{
			CPasstimeBall *pBall = g_pPasstimeLogic->GetBall();
			if ( !pBall || ((m_hObserverTarget.Get() == pBall) && pBall->BOutOfPlay()) )
			{
				FindInitialObserverTarget();
			}
			else if ( !pBall->BOutOfPlay() && (GetObserverTarget() != TFGameRules()->GetObjectiveObserverTarget()) )
			{
				SetObserverTarget( TFGameRules()->GetObjectiveObserverTarget() );
			}
			return;
		}
		
		// make sure we're not trying to spec the train during a team win
		// if we are, switch to spectating the last control point instead (where the train ended)
		if ( m_hObserverTarget && m_hObserverTarget->IsBaseTrain() && TFGameRules()->State_Get() == GR_STATE_TEAM_WIN )
		{
			// find the nearest spectator point to use instead of the train
			CObserverPoint *pObserverPoint = (CObserverPoint *)gEntList.FindEntityByClassname( NULL, "info_observer_point" );
			CObserverPoint *pClosestPoint = NULL;
			float flMinDistance = -1.0f;
			Vector vecTrainOrigin = m_hObserverTarget->GetAbsOrigin();

			while ( pObserverPoint )
			{
				if ( IsValidObserverTarget( pObserverPoint ) )
				{
					float flDist = pObserverPoint->GetAbsOrigin().DistTo( vecTrainOrigin );
					if ( flMinDistance < 0 || flDist < flMinDistance )
					{
						flMinDistance = flDist;
						pClosestPoint = pObserverPoint;
					}
				}

				pObserverPoint = (CObserverPoint *)gEntList.FindEntityByClassname( pObserverPoint, "info_observer_point" );
			}

			if ( pClosestPoint )
			{
				SetObserverTarget( pClosestPoint );
			}
		}
	}

	BaseClass::CheckObserverSettings();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::Touch( CBaseEntity *pOther )
{
	CTFPlayer *pVictim = ToTFPlayer( pOther );

	if ( pVictim )
	{
		// ACHIEVEMENT_TF_SPY_BUMP_CLOAKED_SPY
		if ( !m_Shared.IsAlly( pVictim ) )
		{
			if ( IsPlayerClass( TF_CLASS_SPY ) && pVictim->IsPlayerClass( TF_CLASS_SPY ) )
			{
				if ( m_Shared.InCond( TF_COND_STEALTHED ) && pVictim->m_Shared.InCond( TF_COND_STEALTHED ) )
				{
					AwardAchievement( ACHIEVEMENT_TF_SPY_BUMP_CLOAKED_SPY );
				}
			}
		}

		CheckUncoveringSpies( pVictim );

		// ACHIEVEMENT_TF_HEAVY_BLOCK_INVULN_HEAVY
		if ( !m_Shared.IsAlly( pVictim ) )
		{
			if ( IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && pVictim->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
			{
				CTFTeam *pTeam = GetGlobalTFTeam( GetTeamNumber() );
				if ( pTeam && pTeam->GetRole() == TEAM_ROLE_DEFENDERS )
				{
					if ( m_Shared.InCond( TF_COND_INVULNERABLE ) || m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
					{
						if ( pVictim->m_Shared.InCond( TF_COND_INVULNERABLE ) || pVictim->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
						{
							float flMaxSpeed = 50.0f * 50.0f;
							if ( ( GetAbsVelocity().LengthSqr() < flMaxSpeed ) && ( pVictim->GetAbsVelocity().LengthSqr() < flMaxSpeed ) )
							{
								AwardAchievement( ACHIEVEMENT_TF_HEAVY_BLOCK_INVULN_HEAVY );
							}
						}
					}
				}
			}

			// ****************************************************************************************************************
			// Halloween Karts
			if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) && m_flHalloweenKartPushEventTime < gpGlobals->curtime )
			{
				// calculate a force and save it off, it is used on a later frame cause it is to late to apply the force here
				float flImpactForce = GetLocalVelocity().Length();
				if ( flImpactForce > 10.0f )
				{
					float flForceMult = 1.0f;

					Vector vAim = GetLocalVelocity();
					vAim.NormalizeInPlace();
					Vector vOrigin = GetAbsOrigin();

					// Force direction is velocity of the player in the case that this is a head on collison.
					// Trace
					trace_t pTrace;
					Ray_t ray;
					CTraceFilterOnlyNPCsAndPlayer pFilter( this, COLLISION_GROUP_NONE );
					//tf_halloween_kart_impact_lookahead
					//tf_halloween_kart_impact_bounds_scale
					ray.Init( vOrigin, Vector( 0, 0, 16 ) + vOrigin + vAim * tf_halloween_kart_impact_lookahead.GetFloat(), GetPlayerMins() * tf_halloween_kart_impact_bounds_scale.GetFloat(), GetPlayerMaxs() * tf_halloween_kart_impact_bounds_scale.GetFloat() );
					enginetrace->TraceRay( ray, MASK_SOLID, &pFilter, &pTrace );

					Vector vecForceDirection;
					vecForceDirection = vAim;
					vecForceDirection.z += 0.60f;
					vecForceDirection.NormalizeInPlace();
					if ( pTrace.m_pEnt == pVictim )
					{
						if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART_DASH ) )
						{
							flForceMult *= tf_halloween_kart_boost_impact_force.GetFloat();
							// Stop moving
							SetAbsVelocity( vec3_origin );
							SetCurrentTauntMoveSpeed( 0 );
							m_Shared.RemoveCond( TF_COND_HALLOWEEN_KART_DASH );
							EmitSound( "BumperCar.BumpHard" );
						}
						else
						{
							SetAbsVelocity( GetAbsVelocity() * tf_halloween_kart_impact_feedback.GetFloat() );
							SetCurrentTauntMoveSpeed( GetCurrentTauntMoveSpeed() * tf_halloween_kart_impact_feedback.GetFloat() );
							EmitSound( "BumperCar.Bump" );
						}

						// Invul Crash
						if ( m_Shared.InCond( TF_COND_INVULNERABLE_USER_BUFF ) )
						{
							flForceMult += 0.5f;
						}

						// Apply some kart damage
						//Speed maxes at 800, normally at 300?  we want about 10 damage a hit? 10-15?
						int iDamage = (int)( ( flImpactForce / 50.0f + RandomInt( 13, 19 ) ) * tf_halloween_kart_impact_damage.GetFloat() );

						// Apply force to enemy
						vecForceDirection *= flImpactForce * flForceMult * tf_halloween_kart_impact_force.GetFloat();
						pVictim->AddHalloweenKartPushEvent( this, NULL, NULL, vecForceDirection, iDamage );
					}
					else
					{
						DevMsg( "Collision with player not in Trace, %f Force \n", flImpactForce );
					}

					// can only give a kart push event every 0.2 seconds
					if ( vecForceDirection.LengthSqr() > 100.0f )
					{
						m_flHalloweenKartPushEventTime = gpGlobals->curtime + tf_halloween_kart_impact_rate.GetFloat();
					}
				}
			}
			if ( ( m_Shared.GetPercentInvisible() < 0.10f ) &&
				m_Shared.GetCarryingRuneType() == RUNE_PLAGUE && 
				!m_Shared.IsAlly( pVictim ) && 
				!pVictim->m_Shared.IsInvulnerable() && 
				!pVictim->m_Shared.InCond( TF_COND_PLAGUE ) && 
				pVictim->m_Shared.GetCarryingRuneType() != RUNE_RESIST )
			{
				pVictim->m_Shared.AddCond( TF_COND_PLAGUE, PERMANENT_CONDITION, this );

				//Plague transmission event infects nearby eligible players on the same team. Only works for powerup carrier to host, not host to host.
				const Vector& vecPos = pVictim->WorldSpaceCenter();
				for ( int i = 0; i < pVictim->GetTeam()->GetNumPlayers(); i++ )
				{
					CTFPlayer *pTeamMate = ToTFPlayer( pVictim->GetTeam()->GetPlayer( i ) );

					if ( pTeamMate && pTeamMate != pVictim && pTeamMate->IsAlive() && !pTeamMate->m_Shared.IsInvulnerable() && !pTeamMate->m_Shared.InCond( TF_COND_PLAGUE ) && pTeamMate->m_Shared.GetCarryingRuneType() != RUNE_RESIST )
					{
						// Only nearby teammates. Check for this before the more expensive visibility trace
						if ( ( vecPos - pTeamMate->WorldSpaceCenter() ).LengthSqr() < ( 350 * 350 ) )
						{
							// Doesn't go through walls
							if ( pVictim->FVisible( pTeamMate, MASK_SOLID ) )
							{
								pTeamMate->m_Shared.AddCond( TF_COND_PLAGUE, PERMANENT_CONDITION, this );
								CPVSFilter filter( WorldSpaceCenter() );
								Vector vStart = pVictim->EyePosition();
								Vector vEnd = pTeamMate->GetAbsOrigin() + Vector( 0, 0, 56 );
								te_tf_particle_effects_control_point_t controlPoint = { PATTACH_ABSORIGIN, vEnd };
								TE_TFParticleEffectComplex( filter, 0.f, "plague_transmission", vStart, QAngle( 0.f, 0.f, 0.f ), NULL, &controlPoint, pTeamMate, PATTACH_CUSTOMORIGIN );
							}
						}
					}
				}
			}
		}
	}

	BaseClass::Touch( pOther );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::RefreshCollisionBounds( void )
{
	BaseClass::RefreshCollisionBounds();

	SetViewOffset( ( IsDucked() ) ? ( VEC_DUCK_VIEW_SCALED( this ) ) : ( GetClassEyeHeight() ) );
}

//-----------------------------------------------------------------------------
/**
 * Invoked (by UpdateLastKnownArea) when we enter a new nav area (or it is reset to NULL)
 */
void CTFPlayer::OnNavAreaChanged( CNavArea *enteredArea, CNavArea *leftArea )
{
	VPROF_BUDGET( "CTFPlayer::OnNavAreaChanged", "NextBot" );

	if ( !IsAlive() || GetTeamNumber() == TEAM_SPECTATOR )
	{
		return;
	}

	if ( leftArea )
	{
		// remove us from old visible set
		NavAreaCollector wasVisible;
		leftArea->ForAllPotentiallyVisibleAreas( wasVisible );

		for( int i=0; i<wasVisible.m_area.Count(); ++i )
		{
			CTFNavArea *area = (CTFNavArea *)wasVisible.m_area[i];
			area->RemovePotentiallyVisibleActor( this );
		}
	}


	if ( enteredArea )
	{
		// add us to new visible set
		// @todo: is it faster to only do this for the areas that changed between sets?
		NavAreaCollector isVisible;
		enteredArea->ForAllPotentiallyVisibleAreas( isVisible );

		for( int i=0; i<isVisible.m_area.Count(); ++i )
		{
			CTFNavArea *area = (CTFNavArea *)isVisible.m_area[i];
			area->AddPotentiallyVisibleActor( this );
		}
	}
}

//-----------------------------------------------------------------------------------------------------
// Return true if the given threat is aiming in our direction
bool CTFPlayer::IsThreatAimingTowardMe( CBaseEntity *threat, float cosTolerance ) const
{
	CTFPlayer *player = ToTFPlayer( threat );
	Vector to = GetAbsOrigin() - threat->GetAbsOrigin();
	float threatRange = to.NormalizeInPlace();
	Vector forward;

	if ( player == NULL )
	{
		CObjectSentrygun *sentry = dynamic_cast< CObjectSentrygun * >( threat );
		if ( sentry )
		{
			// are we in range?
			if ( threatRange < SENTRY_MAX_RANGE )
			{
				// is it pointing at us?
				AngleVectors( sentry->GetTurretAngles(), &forward );

				if ( DotProduct( to, forward ) > cosTolerance )
				{
					return true;
				}
			}
		}

		// not a player, not a sentry, not a threat?
		return false;
	}

	// is the player pointing at me?
	player->EyeVectors( &forward );

	if ( DotProduct( to, forward ) > cosTolerance )
	{
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------------------------------
// Return true if the given threat is aiming in our direction and firing its weapon
bool CTFPlayer::IsThreatFiringAtMe( CBaseEntity *threat ) const
{
	if ( IsThreatAimingTowardMe( threat ) )
	{
		CTFPlayer *player = ToTFPlayer( threat );

		if ( player )
		{
			return player->IsFiringWeapon();
		}

		CObjectSentrygun *sentry = dynamic_cast< CObjectSentrygun * >( threat );
		if ( sentry )
		{
			return sentry->GetTimeSinceLastFired() < 1.0f;
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Check to see if this player has seen through an enemy spy's disguise
//-----------------------------------------------------------------------------
void CTFPlayer::CheckUncoveringSpies( CTFPlayer *pTouchedPlayer )
{
	// Only uncover enemies
	if ( m_Shared.IsAlly( pTouchedPlayer ) )
	{
		return;
	}

	// Only uncover if they're stealthed
	if ( !pTouchedPlayer->m_Shared.InCond( TF_COND_STEALTHED ) )
	{
		return;
	}

	// pulse their invisibility
	pTouchedPlayer->m_Shared.OnSpyTouchedByEnemy();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::DoNoiseMaker( void )
{
	if ( gpGlobals->curtime < m_Shared.GetNextNoiseMakerTime() )
		return;

	CSteamID steamIDForPlayer;
	GetSteamID( &steamIDForPlayer );

	// Check to see that we have a noise maker item equipped. We intentionally
	// want to check this to fix the infinite noise maker bugs.
	CEconItemView *pItem = GetEquippedItemForLoadoutSlot( LOADOUT_POSITION_ACTION );
	if ( !pItem )
		return;

	int iUnlimitedQuantity = 0;
	CALL_ATTRIB_HOOK_INT( iUnlimitedQuantity, unlimited_quantity );

	if ( pItem->GetItemQuantity() <= 0 && !iUnlimitedQuantity )
		return;

	perteamvisuals_t* vis = pItem->GetStaticData()->GetPerTeamVisual( 0 );
	if ( !vis )
		return;

	int iNumSounds = 0;
	for ( int i=0; i<MAX_VISUALS_CUSTOM_SOUNDS; ++i )
	{
		if ( vis->pszCustomSounds[i] )
			iNumSounds++;
	}

	if ( iNumSounds == 0 )
		return;

	int rand = RandomInt( 0, iNumSounds-1 );

	float flSoundLength = 0;
	EmitSound_t params;
	params.m_flSoundTime = 0;
	params.m_pSoundName = vis->pszCustomSounds[rand];
	params.m_pflSoundDuration = &flSoundLength;

	CPASFilter filter( GetAbsOrigin() );
	EmitSound( filter, entindex(), params );

	// Add a particle effect.
	const char *particleEffectName = pItem->GetStaticData()->GetParticleEffect( TEAM_UNASSIGNED );
	if ( particleEffectName )
	{
		TE_TFParticleEffect( filter, 0.0, particleEffectName, PATTACH_POINT_FOLLOW, this, "head" );
	}

	float flDelay = 1.0f;

	// Duck Badge Cooldown is based on badge level.  Noisemaker is more like an easter egg
	CSchemaAttributeDefHandle pAttr_DuckLevelBadge( "duck badge level" );
	uint32 iDuckBadgeLevel = 0;

	if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttr_DuckLevelBadge, &iDuckBadgeLevel ) )
	{
		flDelay = 5.0f;
	}
	
	// Throttle the usage rate to sound duration plus some dead time.
	m_Shared.SetNextNoiseMakerTime( gpGlobals->curtime + flSoundLength + flDelay );
}

//-----------------------------------------------------------------------------
// Purpose: Finds an open space for a high five partner. flTolerance specifies the maximum amount that should be allowed underneath position.
//-----------------------------------------------------------------------------
bool CTFPlayer::FindOpenTauntPartnerPosition( CEconItemView *pEconItemView, Vector &position, float *flTolerance )
{
	if ( !pEconItemView || !pEconItemView->IsValid() )
		return false;

	const GameItemDefinition_t *pItemDef = pEconItemView->GetItemDefinition();
	if ( !pItemDef || !pItemDef->GetTauntData() )
	{
		position = GetAbsOrigin();
		*flTolerance = tf_highfive_height_tolerance.GetFloat();
		return false;
	}

	const float flTauntSeparationForwardDistance = tf_highfive_separation_forward.GetFloat() != 0 ? tf_highfive_separation_forward.GetFloat() : pItemDef->GetTauntData()->GetTauntSeparationForwardDistance();
	const float flTauntSeparationRightDistance = tf_highfive_separation_right.GetFloat() != 0 ? tf_highfive_separation_right.GetFloat() : pItemDef->GetTauntData()->GetTauntSeparationRightDistance();

	bool ret = true;
	Vector forward, right;
	AngleVectors( GetAbsAngles(), &forward, &right, NULL );

	Vector vecStart = GetAbsOrigin();
	Vector vecEnd = vecStart + ( forward * flTauntSeparationForwardDistance ) + ( right * flTauntSeparationRightDistance );
	*flTolerance = tf_highfive_height_tolerance.GetFloat();
	trace_t result;
	CTraceFilterIgnoreTeammates filter( this, COLLISION_GROUP_NONE, GetAllowedTauntPartnerTeam() );
	UTIL_TraceHull( vecStart, vecEnd + ( forward * 2 ), VEC_HULL_MIN, VEC_HULL_MAX, MASK_PLAYERSOLID, &filter, &result );

	if ( result.DidHit() )
	{
		// something's directly in front of us, but let's allow for a little bit of variation since we might be standing on an uneven displacement
		trace_t result2;
		vecStart = GetAbsOrigin() + Vector( 0, 0, *flTolerance );
		vecEnd = vecStart + ( forward * flTauntSeparationForwardDistance ) + ( right * flTauntSeparationRightDistance );
		UTIL_TraceHull( vecStart, vecEnd + ( forward * 2 ), VEC_HULL_MIN, VEC_HULL_MAX, MASK_PLAYERSOLID, &filter, &result2 );

		// Now we can allow for twice the space underneath us.
		*flTolerance *= 2;

		if ( result2.DidHit() )
		{
			// Not enough space in front of us.
			ret = false;
		}
		else
		{
			position = vecEnd;
		}
	}
	else
	{
		position = vecEnd;
	}

	if( ret )
	{
		Vector vecStartCenter = WorldSpaceCenter();
		// Scale up how far we test.  Dont even let them get close.
		Vector vecEndSuperSafe = vecStartCenter + ( forward * flTauntSeparationForwardDistance * 2.f ) + ( right * flTauntSeparationRightDistance );

		// Dont allow crossing through the spawn room visualizers
		ret = !PointsCrossRespawnRoomVisualizer( vecStartCenter, vecEndSuperSafe );
	}


	return ret;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsAllowedToInitiateTauntWithPartner( CEconItemView *pEconItemView, char *pszErrorMessage, int cubErrorMessage )
{
	Vector vecEnd;
	float flTolerance;

	if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
		return true;

	bool ret = FindOpenTauntPartnerPosition( pEconItemView, vecEnd, &flTolerance );

	// Check that there isn't too much space underneath the destination.
	if ( ret )
	{
		trace_t result3;
		CTraceFilterIgnoreTeammates filter( this, COLLISION_GROUP_NONE, GetTeamNumber() );
		UTIL_TraceHull( vecEnd, vecEnd - Vector( 0, 0, flTolerance ), VEC_HULL_MIN, VEC_HULL_MAX, MASK_PLAYERSOLID, &filter, &result3 );
		if ( !result3.DidHit() )
		{
			if ( pszErrorMessage && cubErrorMessage > 0 )
			{
				V_strncpy( pszErrorMessage, "#TF_PartnerTaunt_TooHigh", cubErrorMessage );
			}

			ret = false;
		}
	}
	else if ( pszErrorMessage && cubErrorMessage > 0 )
	{
		V_strncpy( pszErrorMessage, "#TF_PartnerTaunt_Blocked", cubErrorMessage );
	}

	return ret;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsWormsGearEquipped( void ) const
{
	// If we have the Worms Gear equipped, play their custom sound
	static CSchemaItemDefHandle ppItemDefWearables[] = { CSchemaItemDefHandle( "Worms Gear" ) };
	return HasWearablesEquipped( ppItemDefWearables, ARRAYSIZE( ppItemDefWearables ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsRobotCostumeEquipped( void ) const
{
	if ( GetPlayerClass()->GetClassIndex() != TF_CLASS_SOLDIER )
		return false;

	static CSchemaItemDefHandle ppItemDefWearables[] = { CSchemaItemDefHandle( "Idiot Box" ), CSchemaItemDefHandle( "Steel Pipes" ), CSchemaItemDefHandle( "Shoestring Budget" ) };
	return HasWearablesEquipped( ppItemDefWearables, ARRAYSIZE( ppItemDefWearables ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsDemowolf( void ) const
{
	if ( GetPlayerClass()->GetClassIndex() != TF_CLASS_DEMOMAN )
		return false;

	static CSchemaItemDefHandle ppItemDefWearables[] = { CSchemaItemDefHandle( "Hair of the Dog" ), CSchemaItemDefHandle( "Scottish Snarl" ), CSchemaItemDefHandle( "Pickled Paws" ) };
	return HasWearablesEquipped( ppItemDefWearables, ARRAYSIZE( ppItemDefWearables ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsFrankenHeavy( void ) const
{
	if ( GetPlayerClass()->GetClassIndex() != TF_CLASS_HEAVYWEAPONS )
		return false;

	static CSchemaItemDefHandle ppItemDefWearables[] = { CSchemaItemDefHandle( "Can Opener" ), CSchemaItemDefHandle( "Soviet Stitch-Up" ), CSchemaItemDefHandle( "Steel-Toed Stompers" ) };
	return HasWearablesEquipped( ppItemDefWearables, ARRAYSIZE( ppItemDefWearables ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsFairyHeavy( void ) const
{
	if ( GetPlayerClass()->GetClassIndex() != TF_CLASS_HEAVYWEAPONS )
		return false;

	static CSchemaItemDefHandle ppItemDefWearables[] = { CSchemaItemDefHandle( "The Grand Duchess Tutu" ), CSchemaItemDefHandle( "The Grand Duchess Fairy Wings" ), CSchemaItemDefHandle( "The Grand Duchess Tiara" ) };
	return HasWearablesEquipped( ppItemDefWearables, ARRAYSIZE( ppItemDefWearables ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsZombieCostumeEquipped( void ) const
{
	int iZombie = 0;
	CALL_ATTRIB_HOOK_INT( iZombie, zombiezombiezombiezombie );
	return iZombie != 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::HasWearablesEquipped( const CSchemaItemDefHandle *ppItemDefs, int nWearables ) const
{
	for ( int i = 0; i < nWearables; i++ )
	{
		const CEconItemDefinition *pItemDef = ppItemDefs[i];
		
		// Backwards because our wearable items are probably sitting in our cosmetic slots near
		// the end of our list.
		bool bHasWearable = false;

		FOR_EACH_VEC_BACK( m_hMyWearables, wbl )
		{
			CEconWearable *pWearable = m_hMyWearables[wbl];
			if ( pWearable &&
				 pWearable->GetAttributeContainer()->GetItem() &&
				 pWearable->GetAttributeContainer()->GetItem()->GetItemDefinition() == pItemDef )
			{
				bHasWearable = true;
				break;
			}
		}

		if ( !bHasWearable )
		{
			return false;
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Returns the current concept for press-and-hold taunts or MP_CONCEPT_NONE if none is available.
//-----------------------------------------------------------------------------
int CTFPlayer::GetTauntConcept( CEconItemDefinition *pItemDef )
{
	for ( int i=0; i<pItemDef->GetNumAnimations( GetTeamNumber() ); ++i )
	{
		animation_on_wearable_t* pAnim = pItemDef->GetAnimationData( GetTeamNumber(), i );
		if ( pAnim && pAnim->pszActivity &&
			!Q_stricmp( pAnim->pszActivity, "taunt_concept" ) )
		{
			const char* pszConcept = pAnim->pszReplacement;
			if ( !pszConcept )
				return true;

			return GetMPConceptIndexFromString( pszConcept );
		}
	}

	return MP_CONCEPT_NONE;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::PlayTauntSceneFromItem( CEconItemView *pEconItemView )
{
	if ( !pEconItemView )
		return false;

	if ( !IsAllowedToTaunt() )
		return false;

	const GameItemDefinition_t *pItemDef = pEconItemView->GetItemDefinition();
	if ( !pItemDef )
		return false;

	CTFTauntInfo *pTauntData = pItemDef->GetTauntData();
	if ( !pTauntData )
		return false;

	int iClass = GetPlayerClass()->GetClassIndex();
	
	// If we didn't find any custom taunts, then we're done
	if ( pTauntData->GetIntroSceneCount( iClass ) == 0 )
	{
		return false;
	}

	int iScene = RandomInt( 0, pTauntData->GetIntroSceneCount( iClass ) - 1 );
	const char* pszScene = pTauntData->GetIntroScene( iClass, iScene );
	if ( pszScene )
	{
		int iTauntIndex = TAUNT_MISC_ITEM;
		int iTauntConcept = 0;

		// check if this is a long taunt
		static CSchemaAttributeDefHandle pAttrDef_TauntPressAndHold( "taunt is press and hold" );
		attrib_value_t iLongTaunt = 0;
		if ( pEconItemView->FindAttribute( pAttrDef_TauntPressAndHold, &iLongTaunt ) && iLongTaunt != 0 )
		{
			iTauntIndex = TAUNT_LONG;
			iTauntConcept = pTauntData->IsPartnerTaunt() ? MP_CONCEPT_PARTNER_TAUNT_READY : iTauntConcept;
			m_bIsTauntInitiator = true;

			ParseSharedTauntDataFromEconItemView( pEconItemView );

			/*cant we just network over the "taunting item id", since client and server both know all the item defs,
			then they can both look at attributes and we dont need to keep networking more and more stuff?*/
			// check if this taunt can be mimic by other players
			static CSchemaAttributeDefHandle pAttrDef_TauntMimic( "taunt mimic" );
			attrib_value_t iTauntMimic = 0;
			pEconItemView->FindAttribute( pAttrDef_TauntMimic, &iTauntMimic );
			m_bTauntMimic = iTauntMimic != 0;

			// check if we can initiate partner taunt (ignore mimic taunt to allow Conga initiation)
			char szClientError[64];
			if ( !m_bTauntMimic && pTauntData->IsPartnerTaunt() && !IsAllowedToInitiateTauntWithPartner( pEconItemView, szClientError, ARRAYSIZE( szClientError ) ) )
			{
				CSingleUserRecipientFilter filter( this );
				EmitSound_t params;
				params.m_pSoundName = "Player.DenyWeaponSelection";
				EmitSound( filter, entindex(), params );

				TFGameRules()->SendHudNotification( filter, szClientError, "ico_notify_partner_taunt" );

				return false;
			}
		}

		// Store this off so eventually we can let clients know which item ID is doing this taunt.
		m_iTauntItemDefIndex = pEconItemView->GetItemDefIndex();
		m_TauntEconItemView = *pEconItemView;

		// Should we play a sound?
		m_strTauntSoundName = "";
		m_flTauntSoundTime = 0.f;
		static CSchemaAttributeDefHandle pAttrDef_TauntSuccessSound( "taunt success sound" );
		CAttribute_String attrTauntSuccessSound;
		if ( pEconItemView->FindAttribute( pAttrDef_TauntSuccessSound, &attrTauntSuccessSound ) )
		{
			const char* pszTauntSoundName = attrTauntSuccessSound.value().c_str();
			Assert( pszTauntSoundName && *pszTauntSoundName );
			if ( pszTauntSoundName && *pszTauntSoundName )
			{
				m_strTauntSoundName = pszTauntSoundName;

				static CSchemaAttributeDefHandle pAttrDef_TauntSuccessSoundOffset( "taunt success sound offset" );
				attrib_value_t attrTauntSoundOffset = 0;
				pEconItemView->FindAttribute( pAttrDef_TauntSuccessSoundOffset, &attrTauntSoundOffset );
				float flTauntSoundOffset = (float&)attrTauntSoundOffset;
				m_flTauntSoundTime = gpGlobals->curtime + flTauntSoundOffset;
			}
		}

		// Should we play a looping sound?
		m_flTauntSoundLoopTime = 0.f;
		Assert( m_strTauntSoundLoopName.IsEmpty() );
		m_strTauntSoundLoopName = "";
		static CSchemaAttributeDefHandle pAttrDef_TauntSuccessSoundLoop( "taunt success sound loop" );
		CAttribute_String attrTauntSuccessSoundLoop;
		if ( pEconItemView->FindAttribute( pAttrDef_TauntSuccessSoundLoop, &attrTauntSuccessSoundLoop ) )
		{
			const char* pszTauntSoundLoopName = attrTauntSuccessSoundLoop.value().c_str();
			Assert( pszTauntSoundLoopName && *pszTauntSoundLoopName );
			if ( pszTauntSoundLoopName && *pszTauntSoundLoopName )
			{
				// play the looping sounds using the envelope controller
				m_strTauntSoundLoopName = pszTauntSoundLoopName;
			
				static CSchemaAttributeDefHandle pAttrDef_TauntSuccessSoundLoopOffset( "taunt success sound loop offset" );
				attrib_value_t attrTauntSoundLoopOffset = 0;
				pEconItemView->FindAttribute( pAttrDef_TauntSuccessSoundLoopOffset, &attrTauntSoundLoopOffset );
				float flTauntSoundLoopOffset = (float&)attrTauntSoundLoopOffset;
				m_flTauntSoundLoopTime = gpGlobals->curtime + flTauntSoundLoopOffset;
			}
		}

		m_iTauntAttack = TAUNTATK_NONE;
		m_flTauntAttackTime = 0.f;

		static CSchemaAttributeDefHandle pAttrDef_TauntAttackName( "taunt attack name" );
		const char* pszTauntAttackName = NULL;
		if ( FindAttribute_UnsafeBitwiseCast<CAttribute_String>( pItemDef, pAttrDef_TauntAttackName, &pszTauntAttackName ) )
		{
			m_iTauntAttack = GetTauntAttackByName( pszTauntAttackName );
		}

		static CSchemaAttributeDefHandle pAttrDef_TauntAttackTime( "taunt attack time" );
		float flTauntAttackTime = 0.f;
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItemDef, pAttrDef_TauntAttackTime, &flTauntAttackTime ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + flTauntAttackTime;
		}

		m_iPreTauntWeaponSlot = -1;
		if ( GetActiveWeapon() )
		{
			m_iPreTauntWeaponSlot = GetActiveWeapon()->GetSlot();
		}
		static CSchemaAttributeDefHandle pAttrDef_TauntForceWeaponSlot( "taunt force weapon slot" );
		const char* pszTauntForceWeaponSlotName = NULL;
		if ( FindAttribute_UnsafeBitwiseCast<CAttribute_String>( pItemDef, pAttrDef_TauntForceWeaponSlot, &pszTauntForceWeaponSlotName ) )
		{
			int iForceWeaponSlot = StringFieldToInt( pszTauntForceWeaponSlotName, GetItemSchema()->GetWeaponTypeSubstrings() );
			Weapon_Switch( Weapon_GetSlot( iForceWeaponSlot ) );
		}

		m_bInitTaunt = true;

		// Allow voice commands, etc to be interrupted.
		CMultiplayer_Expresser *pExpresser = GetMultiplayerExpresser();
		Assert( pExpresser );
		pExpresser->AllowMultipleScenes();

		float flSceneDuration = PlayScene( pszScene );
		OnTauntSucceeded( pszScene, iTauntIndex, iTauntConcept );

		m_flNextAllowTauntRemapInputTime = iTauntIndex == TAUNT_LONG ? gpGlobals->curtime + flSceneDuration : -1.f;

		pExpresser->DisallowMultipleScenes();

		const char *pszTauntProp = pTauntData->GetProp( iClass );
		if ( pszTauntProp )
		{
			const char *pszTauntPropScene = pTauntData->GetPropIntroScene( iClass );
			if ( pszTauntPropScene )
			{
				CTFTauntProp *pProp = static_cast< CTFTauntProp * >( CreateEntityByName( "tf_taunt_prop" ) );
				if ( pProp )
				{
					pProp->SetModel( pszTauntProp );

					pProp->m_nSkin = GetTeamNumber() == TF_TEAM_RED ? 0 : 1;
					DispatchSpawn( pProp );
					pProp->SetAbsOrigin( GetAbsOrigin() );
					pProp->SetAbsAngles( GetAbsAngles() );
					pProp->SetEFlags( EFL_FORCE_CHECK_TRANSMIT );

					pProp->PlayScene( pszTauntPropScene );
				
					m_hTauntProp = pProp;
				}
			}
			else
			{
				CTFWeaponBase *pWeapon = GetActiveTFWeapon();
				if ( pWeapon && pWeapon->HideAttachmentsAndShowBodygroupsWhenPerformingWeaponIndependentTaunt() )
				{
					// If there's no prop scene, our weapon is being repurposed
					pWeapon->SetIsBeingRepurposedForTaunt( true );
				}
			}
		}

		// check for achievement
		static CSchemaItemDefHandle congaTaunt( "Conga Taunt" );
		if ( pEconItemView->GetItemDefinition() == congaTaunt )
		{
			CUtlVector< CTFPlayer * > vecPlayers;
			CollectPlayers( &vecPlayers, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS );
			CollectPlayers( &vecPlayers, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS );

			CUtlVector< CTFPlayer * > vecCongaLine;

			FOR_EACH_VEC( vecPlayers, i )
			{
				CTFPlayer *pPlayer = vecPlayers[i];
				if ( pPlayer && pPlayer->m_Shared.InCond( TF_COND_TAUNTING ) )
				{
					// is this player doing the Conga?
					if ( pPlayer->GetTauntEconItemView() && ( pPlayer->GetTauntEconItemView()->GetItemDefinition() == congaTaunt ) )
					{
						vecCongaLine.AddToTail( pPlayer );
					}
				}
			}

			if ( vecCongaLine.Count() >= 10 )
			{
				FOR_EACH_VEC( vecCongaLine, i )
				{
					CTFPlayer *pPlayer = vecCongaLine[i];
					if ( pPlayer )
					{
						pPlayer->AwardAchievement( ACHIEVEMENT_TF_TAUNT_CONGA_LINE );
					}
				}
			}
		}

		// override FOV
		m_iPreTauntFOV = GetFOV();
		if ( pTauntData->GetFOV() != 0 )
		{
			SetFOV( this, pTauntData->GetFOV() );
		}

#ifdef STAGING_ONLY
		if ( tf_tauntcam_fov_override.GetInt() != 0 )
		{
			SetFOV( this, tf_tauntcam_fov_override.GetInt() );
		}
#endif // STAGING_ONLY

		m_TauntStage = TAUNT_INTRO;

		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::PlayTauntRemapInputScene()
{
	CTFTauntInfo *pTaunt = m_TauntEconItemView.GetStaticData()->GetTauntData();
	if ( !pTaunt )
	{
		return -1.f;
	}

	if ( m_TauntStage != TAUNT_INTRO )
	{
		return -1.f;
	}

	int iClass = GetPlayerClass()->GetClassIndex();

	const char *pszCurrentSceneFileName = GetSceneFilename( m_hTauntScene );
	
	const char *pszSceneName = NULL;
	for ( int iButtonIndex=0; iButtonIndex<pTaunt->GetTauntInputRemapCount(); ++iButtonIndex )
	{
		const CTFTauntInfo::TauntInputRemap_t& tauntRemap = pTaunt->GetTauntInputRemapScene( iButtonIndex );
		if ( tauntRemap.m_vecButtonPressedScenes[iClass].IsEmpty() )
			continue;

		if ( m_afButtonPressed & tauntRemap.m_iButton )
		{
			int iRandomTaunt = RandomInt( 0, tauntRemap.m_vecButtonPressedScenes[iClass].Count() - 1 );
			pszSceneName = tauntRemap.m_vecButtonPressedScenes[iClass][iRandomTaunt];
			break;
		}

		const char *pszPressedScene = tauntRemap.m_vecButtonPressedScenes[iClass][0];
		if ( m_nButtons & tauntRemap.m_iButton )
		{
			// already in this scene, try again later for next state
			if ( FStrEq( pszCurrentSceneFileName, pszPressedScene ) )
			{
				return 0.f;
			}

			pszSceneName = pszPressedScene;
			break;
		}
		else if ( FStrEq( pszCurrentSceneFileName, pszPressedScene ) && !tauntRemap.m_vecButtonReleasedScenes[iClass].IsEmpty() )
		{
			int iRandomTaunt = RandomInt( 0, tauntRemap.m_vecButtonReleasedScenes[iClass].Count() - 1 );
			pszSceneName = tauntRemap.m_vecButtonReleasedScenes[iClass][iRandomTaunt];
			break;
		}
	}

	if ( pszSceneName )
	{
		StopScriptedScene( this, m_hTauntScene );
		m_hTauntScene = NULL;

		CMultiplayer_Expresser *pInitiatorExpresser = GetMultiplayerExpresser();
		Assert( pInitiatorExpresser );

		pInitiatorExpresser->AllowMultipleScenes();

		// extend initiator's taunt duration to include actual high five
		m_bInitTaunt = true;

		float flSceneDuration = PlayScene( pszSceneName );

		m_bInitTaunt = false;
		pInitiatorExpresser->DisallowMultipleScenes();

		return flSceneDuration;
	}

	return 0.f;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::OnTauntSucceeded( const char* pszSceneName, int iTauntIndex /*= 0*/, int iTauntConcept /*= 0*/ )
{
	float flDuration = GetSceneDuration( pszSceneName ) + 0.2f;

	float flDurationMod = 1;
	CALL_ATTRIB_HOOK_FLOAT( flDurationMod, mult_gesture_time ); // Modify by attributes.
	flDuration /= flDurationMod;

	// Set player state as taunting.
	m_Shared.m_iTauntIndex = iTauntIndex;
	m_Shared.m_iTauntConcept.Set( iTauntConcept );
	m_flTauntStartTime = gpGlobals->curtime;

	const itemid_t unTauntSourceItemID = m_TauntEconItemView.IsValid() ? m_TauntEconItemView.GetItemID() : INVALID_ITEM_ID;
	m_Shared.m_unTauntSourceItemID_Low = unTauntSourceItemID & 0xffffffff;
	m_Shared.m_unTauntSourceItemID_High = (unTauntSourceItemID >> 32) & 0xffffffff;
	m_Shared.AddCond( TF_COND_TAUNTING );

	if ( iTauntIndex == TAUNT_LONG )
	{
		m_flTauntRemoveTime = gpGlobals->curtime;
		m_bAllowedToRemoveTaunt = false;
		if ( iTauntConcept == MP_CONCEPT_PARTNER_TAUNT_READY )
		{
			GetReadyToTauntWithPartner();
		}

		m_flTauntYaw = BodyAngles().y;
	}
	else
	{
		m_flTauntRemoveTime = gpGlobals->curtime + flDuration;
		m_bAllowedToRemoveTaunt = true;
	}

	m_angTauntCamera = EyeAngles();

	// Slam velocity to zero.
	SetAbsVelocity( vec3_origin );

	// play custom set taunt particle if we have a full set equipped
	if ( IsPlayerClass( TF_CLASS_SPY ) )
	{
		// FIX ME:	We should be using string attribute type instead of float when we add code support to it
		// Hand Coded for this effect which may change later
		int iCustomTauntParticle = 0;
		CALL_ATTRIB_HOOK_INT( iCustomTauntParticle, custom_taunt_particle_attr );
		if ( iCustomTauntParticle )
		{
			DispatchParticleEffect( "set_taunt_saharan_spy", PATTACH_ABSORIGIN_FOLLOW, this );
		}
	}

	// set initial taunt yaw to make sure that the client anim not off because of lag
	SetTauntYaw( GetAbsAngles()[YAW] );

	m_vecTauntStartPosition = GetAbsOrigin();

	// Strange Taunts
	EconItemInterface_OnOwnerKillEaterEventNoPartner( &m_TauntEconItemView, this, kKillEaterEvent_TauntsPerformed );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::Taunt( taunts_t iTauntIndex, int iTauntConcept )
{
	if ( !IsAllowedToTaunt() )
		return;

	if ( iTauntIndex == TAUNT_LONG )
	{
		AssertMsg( false, "Long Taunt should be using the new system which reads scene names from item definitions" );
		return;
	}

	// Heavies can purchase a rage-based knockback+stun effect in MvM,
	// so ignore taunt and activate rage if we're at full rage
	if ( IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
	{
		if ( GetActiveTFWeapon() && GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_MINIGUN )
		{
			int iRage = 0;
			CALL_ATTRIB_HOOK_INT( iRage, generate_rage_on_dmg );
			if ( iRage )
			{
				if ( m_Shared.GetRageMeter() >= 100.f )
				{
					m_Shared.m_bRageDraining = true;
					EmitSound( "Heavy.Battlecry03" );
					return;
				}

				if ( m_Shared.IsRageDraining() )
					return;
			}
		}
	}

	// Allow voice commands, etc to be interrupted.
	CMultiplayer_Expresser *pExpresser = GetMultiplayerExpresser();
	Assert( pExpresser );
	pExpresser->AllowMultipleScenes();

	m_hTauntItem = NULL;

	m_bInitTaunt = true;
	char szResponse[AI_Response::MAX_RESPONSE_NAME];
	bool bTauntSucceeded = false;
	switch ( iTauntIndex )
	{
	case TAUNT_SHOW_ITEM:
		iTauntConcept = MP_CONCEPT_PLAYER_SHOW_ITEM_TAUNT;
		break;

	// use the concept specified for these two
	case TAUNT_MISC_ITEM:
	case TAUNT_SPECIAL:
		break;

	default:
	case TAUNT_BASE_WEAPON:
		iTauntConcept = MP_CONCEPT_PLAYER_TAUNT;
		break;
	};

	bTauntSucceeded = SpeakConceptIfAllowed( iTauntConcept, NULL, szResponse, AI_Response::MAX_RESPONSE_NAME );
	if ( bTauntSucceeded )
	{
		OnTauntSucceeded( szResponse, iTauntIndex, iTauntConcept );
	}
	else
	{
		m_bInitTaunt = false;
	}

	pExpresser->DisallowMultipleScenes();

	m_flTauntAttackTime = 0;
	m_iTauntAttack = TAUNTATK_NONE;

	if ( !bTauntSucceeded )
		return;

	// should we play a sound?
	CAttribute_String attrCosmeticTauntSound;
	CALL_ATTRIB_HOOK_STRING( attrCosmeticTauntSound, cosmetic_taunt_sound );
	const char* pszTauntSoundName = attrCosmeticTauntSound.value().c_str();
	if ( pszTauntSoundName && *pszTauntSoundName )
	{
		EmitSound( pszTauntSoundName );
	}

	if ( iTauntIndex == TAUNT_SHOW_ITEM )
	{
		m_flTauntAttackTime = gpGlobals->curtime + 1.5;
		m_iTauntAttack = TAUNTATK_SHOW_ITEM;
		return;
	}
	
	CTFWeaponBase *pActiveWeapon = m_Shared.GetActiveTFWeapon();
	if ( iTauntIndex == TAUNT_BASE_WEAPON )
	{
		// phlogistinator
		if ( IsPlayerClass( TF_CLASS_PYRO ) && m_Shared.GetRageMeter() >= 100.0f && 
			 StringHasPrefix( szResponse, "scenes/player/pyro/low/taunt01" ) )
		{
			// Pyro Rage!
			CBaseCombatWeapon *pWeapon = GetActiveWeapon();
			if ( pWeapon )
			{
				int iBuffType = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iBuffType, set_buff_type );

				if ( iBuffType > 0 )
				{
					// Time for crits!
					m_Shared.ActivateRageBuff( this, iBuffType );

					// Pyro needs high defense while he's taunting
					//m_Shared.AddCond( TF_COND_DEFENSEBUFF_HIGH, 3.0f );
					m_Shared.AddCond( TF_COND_INVULNERABLE_USER_BUFF, 2.60f );
					m_Shared.AddCond( TF_COND_MEGAHEAL, 2.60f );
				}
			}
		}
		else if ( IsPlayerClass( TF_CLASS_SCOUT ) )
		{
			if ( m_Shared.InCond( TF_COND_PHASE ) == false )
			{
				if ( pActiveWeapon && pActiveWeapon->GetWeaponID() == TF_WEAPON_LUNCHBOX )
				{
					m_flTauntAttackTime = gpGlobals->curtime + 0.9;
					m_iTauntAttack = TAUNTATK_SCOUT_DRINK;
				}
			}
		}
		else if ( IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
		{
			if ( pActiveWeapon && pActiveWeapon->GetWeaponID() == TF_WEAPON_LUNCHBOX )
			{
				m_flTauntAttackTime = gpGlobals->curtime + 1.0;
				m_iTauntAttack = TAUNTATK_HEAVY_EAT;

				// Only count sandviches for "eat 100 sandviches" achievement
				CTFLunchBox *pLunchbox = (CTFLunchBox*)pActiveWeapon;
				if ( ( pLunchbox->GetLunchboxType() == LUNCHBOX_STANDARD ) || ( pLunchbox->GetLunchboxType() == LUNCHBOX_STANDARD_ROBO ) )
				{
					AwardAchievement( ACHIEVEMENT_TF_HEAVY_EAT_SANDWICHES );
				}
			}
		}
	}
	else if ( iTauntIndex == TAUNT_SPECIAL )
	{
		if ( IsPlayerClass( TF_CLASS_ENGINEER ) )
		{
			// Wrenchmotron taunt teleport home effect
			if ( !Q_stricmp( szResponse, "scenes/player/engineer/low/taunt_drg_melee.vcd" ) )
			{
				m_bIsTeleportingUsingEurekaEffect = true;

				m_teleportHomeFlashTimer.Start( 1.9f );

				// play teleport sound at location we are leaving
				Vector soundOrigin = WorldSpaceCenter();
				CPASAttenuationFilter filter( soundOrigin );

				EmitSound_t ep;
				ep.m_nChannel = CHAN_STATIC;
				ep.m_pSoundName = "Weapon_DRG_Wrench.Teleport";
				ep.m_flVolume = 1.0f;
				ep.m_SoundLevel = SNDLVL_150dB;
				ep.m_nFlags = 0;
				ep.m_nPitch = PITCH_NORM;
				ep.m_pOrigin = &soundOrigin;

				int worldEntIndex = 0;
				EmitSound( filter, worldEntIndex, ep );
			}
		}
	}

	// Setup taunt attacks. Hacky, but a lot easier to do than getting server side anim events working.
	if ( IsPlayerClass(TF_CLASS_PYRO) )
	{
		if ( !V_stricmp( szResponse, "scenes/player/pyro/low/taunt02.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 2.1f;
			m_iTauntAttack = TAUNTATK_PYRO_HADOUKEN;
		}
		else if ( !V_stricmp( szResponse, "scenes/player/pyro/low/taunt_bubbles.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 3.0f;
			m_iTauntAttack = TAUNTATK_PYRO_ARMAGEDDON;

			// We need to parent this to a target instead of the player because the player changing their camera view can twist the rainbow
			CBaseEntity *pTarget = CreateEntityByName( "info_target" );
			if ( pTarget )
			{
				DispatchSpawn( pTarget );
				pTarget->SetAbsOrigin( GetAbsOrigin() );
				pTarget->SetAbsAngles( GetAbsAngles() );
				pTarget->SetEFlags( EFL_FORCE_CHECK_TRANSMIT );
				pTarget->SetThink( &BaseClass::SUB_Remove );
				pTarget->SetNextThink( gpGlobals->curtime + 8.0f );

				CBaseEntity *pGround = GetGroundEntity();
				if ( pGround && pGround->GetMoveType() == MOVETYPE_PUSH )
				{
					pTarget->SetParent( pGround );
				}
			}

			DispatchParticleEffect( "pyrotaunt_rainbow_norainbow", PATTACH_ABSORIGIN_FOLLOW, pTarget );
		}
		else if ( !V_stricmp( szResponse, "scenes/player/pyro/low/taunt_scorch_shot.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 1.9f;
			m_iTauntAttack = TAUNTATK_PYRO_SCORCHSHOT;
		}
	}
	else if ( IsPlayerClass(TF_CLASS_HEAVYWEAPONS) )
	{
		if ( !V_stricmp( szResponse, "scenes/player/heavy/low/taunt03_v1.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 1.8;
			m_iTauntAttack = TAUNTATK_HEAVY_HIGH_NOON;
		}
		else if ( pActiveWeapon && pActiveWeapon->GetWeaponID() == TF_WEAPON_FISTS )
		{
			CTFFists *pFists = dynamic_cast<CTFFists*>(pActiveWeapon);
			if ( pFists && pFists->GetFistType() == FISTTYPE_RADIAL_BUFF )
			{
				m_flTauntAttackTime = gpGlobals->curtime + 1.0;
				m_iTauntAttack = TAUNTATK_HEAVY_RADIAL_BUFF;
			}
		}
	}
	else if ( IsPlayerClass( TF_CLASS_SCOUT ) )
	{
		if ( !V_stricmp( szResponse, "scenes/player/scout/low/taunt05_v1.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 4.03f;
			m_iTauntAttack = TAUNTATK_SCOUT_GRAND_SLAM;
		}
	}
	else if ( IsPlayerClass( TF_CLASS_MEDIC ) )
	{
		if ( !V_stricmp( szResponse, "scenes/player/medic/low/taunt06.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 0.8f;
			m_flTauntInhaleTime = gpGlobals->curtime + 1.8f;
			
			const char *pszParticleEffect;
			pszParticleEffect = ( GetTeamNumber() == TF_TEAM_RED ? "healhuff_red" : "healhuff_blu" );
			DispatchParticleEffect( pszParticleEffect, PATTACH_POINT_FOLLOW, this, "eyes" );

			m_iTauntAttack = TAUNTATK_MEDIC_INHALE;
		}
		else if ( !V_stricmp( szResponse, "scenes/player/medic/low/taunt08.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 2.2f;
			m_iTauntAttack = TAUNTATK_MEDIC_UBERSLICE_IMPALE;
		}
	}
	else if ( IsPlayerClass( TF_CLASS_SPY ) )
	{
		if ( !V_strnicmp( szResponse, "scenes/player/spy/low/taunt03", 29 ) )		// There's taunt03_v1 & taunt03_v2
		{
			m_flTauntAttackTime = gpGlobals->curtime + 1.8f;
			m_iTauntAttack = TAUNTATK_SPY_FENCING_SLASH_A;
		}
	}
	else if ( IsPlayerClass( TF_CLASS_SNIPER ) )
	{
		if ( !V_stricmp( szResponse, "scenes/player/sniper/low/taunt04.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 0.85f;
			m_iTauntAttack = TAUNTATK_SNIPER_ARROW_STAB_IMPALE;
		}
	}
	else if ( IsPlayerClass( TF_CLASS_SOLDIER ) )
	{
		if ( !V_stricmp( szResponse, "scenes/player/soldier/low/taunt05.vcd" ) )
		{
			if ( IsWormsGearEquipped() )
			{
				m_flTauntAttackTime = gpGlobals->curtime + 1.4f;
				m_iTauntAttack = TAUNTATK_SOLDIER_GRENADE_KILL_WORMSIGN;
				return;
			}

			m_flTauntAttackTime = gpGlobals->curtime + 3.5f;
			m_iTauntAttack = TAUNTATK_SOLDIER_GRENADE_KILL;
		}
	}
	else if ( IsPlayerClass( TF_CLASS_DEMOMAN ) )
	{
		if ( !V_stricmp( szResponse, "scenes/player/demoman/low/taunt09.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 2.55f;
			m_iTauntAttack = TAUNTATK_DEMOMAN_BARBARIAN_SWING;
		}
	}
	else if ( IsPlayerClass( TF_CLASS_ENGINEER ) )
	{
		if ( !V_stricmp( szResponse, "scenes/player/engineer/low/taunt07.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 3.695f;
			m_iTauntAttack = TAUNTATK_ENGINEER_GUITAR_SMASH;
		}
		else if ( !V_stricmp( szResponse, "scenes/player/engineer/low/taunt09.vcd" ) )
		{
			m_flTauntAttackTime = gpGlobals->curtime + 3.2f;
			m_iTauntAttack = TAUNTATK_ENGINEER_ARM_IMPALE;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Aborts a taunt in progress.
//-----------------------------------------------------------------------------
void CTFPlayer::CancelTaunt( void )
{
	m_bIsTeleportingUsingEurekaEffect = false;
	m_teleportHomeFlashTimer.Reset();

	StopTaunt();
}

//-----------------------------------------------------------------------------
// Purpose: Stops taunting
//-----------------------------------------------------------------------------
void CTFPlayer::StopTaunt( void )
{
	if ( m_hTauntScene.Get() )
	{
		StopScriptedScene( this, m_hTauntScene );
		m_flTauntRemoveTime = 0.0f;
		m_bAllowedToRemoveTaunt = true;
		m_hTauntScene = NULL;
	}

	if ( m_hTauntProp.Get() )
	{
		UTIL_Remove( m_hTauntProp );
		m_hTauntProp = NULL;
	}

	if ( IsReadyToTauntWithPartner() )
	{
		CancelTauntWithPartner();
	}

	StopTauntSoundLoop();

	// reset the FOV
	if ( m_TauntEconItemView.IsValid() )
	{
		SetFOV( this, m_iPreTauntFOV );
	}

	m_hHighFivePartner = NULL;
	m_bAllowMoveDuringTaunt = false;
	m_flTauntOutroTime = 0.f;
	m_bTauntForceMoveForward = false;
	m_flTauntForceMoveForwardSpeed = 0.f;
	m_flTauntMoveAccelerationTime = 0.f;
	m_flTauntTurnSpeed = 0.f;
	m_flTauntTurnAccelerationTime = 0.f;
	m_bTauntMimic = false;
	m_bIsTauntInitiator = false;
	m_TauntEconItemView.Invalidate();
	m_flNextAllowTauntRemapInputTime = -1.f;
	m_flCurrentTauntMoveSpeed = 0.f;
	m_nActiveTauntSlot = LOADOUT_POSITION_INVALID;
	m_iTauntItemDefIndex = INVALID_ITEM_DEF_INDEX;
	m_TauntStage = TAUNT_NONE;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::EndLongTaunt()
{
	Assert( m_Shared.GetTauntIndex() == TAUNT_LONG );

	m_bAllowedToRemoveTaunt = true;
	m_flTauntRemoveTime = gpGlobals->curtime;

	int iClass = GetPlayerClass()->GetClassIndex();
	CTFTauntInfo *pTauntData = m_TauntEconItemView.GetStaticData()->GetTauntData();
	if ( pTauntData )
	{
		// Make sure press-and-hold taunts last a minimum amount of time
		float flMinTime = pTauntData->GetMinTauntTime();
		if ( m_flTauntStartTime + flMinTime > gpGlobals->curtime )
		{
			m_flTauntRemoveTime = m_flTauntStartTime + flMinTime;
		}

		// should we play outro?
		if ( pTauntData->GetOutroSceneCount( iClass ) > 0 )
		{
			m_bAllowedToRemoveTaunt = false;
			m_flTauntOutroTime = m_flTauntRemoveTime;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::PlayTauntOutroScene()
{
	m_TauntStage = TAUNT_OUTRO;

	float flDuration = 0.f;
	int iClass = GetPlayerClass()->GetClassIndex();
	CTFTauntInfo *pTauntData = m_TauntEconItemView.GetStaticData()->GetTauntData();
	if ( pTauntData )
	{
		if ( pTauntData->GetOutroSceneCount( iClass ) > 0 )
		{
			// play outro
			const char *pszOutroScene = pTauntData->GetOutroScene( iClass, RandomInt( 0, pTauntData->GetOutroSceneCount( iClass ) - 1 ) );
			if ( m_hTauntScene.Get() )
			{
				StopScriptedScene( this, m_hTauntScene );
				m_hTauntScene = NULL;

				StopTauntSoundLoop();
			}

			// Allow voice commands, etc to be interrupted.
			CMultiplayer_Expresser *pExpresser = GetMultiplayerExpresser();
			Assert( pExpresser );
			pExpresser->AllowMultipleScenes();

			m_bInitTaunt = true;

			flDuration = PlayScene( pszOutroScene );
			OnTauntSucceeded( pszOutroScene, TAUNT_MISC_ITEM, MP_CONCEPT_HIGHFIVE_SUCCESS );

			m_bInitTaunt = false;

			pExpresser->DisallowMultipleScenes();

			if ( m_hTauntProp != NULL )
			{
				const char *pszPropScene = pTauntData->GetPropOutroScene( iClass );
				if ( pszPropScene )
				{
					m_hTauntProp->PlayScene( pszPropScene );
				}
			}
		}
	}

	return flDuration;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::HandleTauntCommand( int iTauntSlot )
{
	if ( !IsAllowedToTaunt() )
		return;

	m_nActiveTauntSlot = LOADOUT_POSITION_INVALID;
	if ( iTauntSlot > 0 && iTauntSlot <= 8 )
	{
		m_nActiveTauntSlot = LOADOUT_POSITION_TAUNT + iTauntSlot - 1;
		CEconItemView* pItem = GetEquippedItemForLoadoutSlot( m_nActiveTauntSlot );
		PlayTauntSceneFromItem( pItem );
		return;
	}
	else
	{
		// Check if I should accept taunt with partner
		CTFPlayer *initiator = FindPartnerTauntInitiator();
		if ( initiator )
		{
			if ( initiator->m_bTauntMimic )
			{
				MimicTauntFromPartner( initiator );
			}
			else
			{
				AcceptTauntWithPartner( initiator );
			}
			return;
		}

		// does this weapon prevent player from doing manual taunt?
		CTFWeaponBase *pActiveWeapon = m_Shared.GetActiveTFWeapon();
		if ( pActiveWeapon && !pActiveWeapon->AllowTaunts() )
			return;

		Taunt( TAUNT_BASE_WEAPON );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ClearTauntAttack()
{
	m_flTauntAttackTime = 0.f;
	m_flTauntInhaleTime = 0.f;
	m_iTauntAttack = TAUNTATK_NONE;
	m_iTauntAttackCount = 0;
	m_iTauntRPSResult = 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::HandleWeaponSlotAfterTaunt()
{
	if ( m_iPreTauntWeaponSlot != -1 )
	{
		// switch back to the active weapon before taunting
		Weapon_Switch( Weapon_GetSlot( m_iPreTauntWeaponSlot ) );
		m_iPreTauntWeaponSlot = -1;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static void DispatchRPSEffect( const CTFPlayer *pPlayer, const char* pszParticleName )
{
	CEffectData	data;
	data.m_nHitBox = GetParticleSystemIndex( pszParticleName );
	data.m_vOrigin = pPlayer->GetAbsOrigin() + Vector( 0, 0, 87.0f );
	data.m_vAngles = vec3_angle;

	CPASFilter intiatorFilter( data.m_vOrigin );
	intiatorFilter.SetIgnorePredictionCull( true );

	te->DispatchEffect( intiatorFilter, 0.0, data.m_vOrigin, "ParticleEffect", data );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::DoTauntAttack( void )
{
	if ( !IsTaunting() || !IsAlive() || m_iTauntAttack == TAUNTATK_NONE )
	{
		return;
	}

	int iTauntAttack = m_iTauntAttack;
	m_iTauntAttack = TAUNTATK_NONE;

	if ( iTauntAttack == TAUNTATK_PYRO_HADOUKEN || iTauntAttack == TAUNTATK_SPY_FENCING_SLASH_A || 
		 iTauntAttack == TAUNTATK_SPY_FENCING_SLASH_B || iTauntAttack == TAUNTATK_SPY_FENCING_STAB )
	{
		// Pyro Hadouken fireball attack
		// Kill all enemies within a small volume in front of the player.
		Vector vecForward;
		AngleVectors( QAngle(0, m_angEyeAngles[YAW], 0), &vecForward );
		Vector vecCenter = WorldSpaceCenter() + vecForward * 64;
		Vector vecSize = Vector(24,24,24);
		CBaseEntity *pList[256];
		int count = UTIL_EntitiesInBox( pList, 256, vecCenter - vecSize, vecCenter + vecSize, FL_CLIENT|FL_OBJECT );
		if ( count )
		{
			// Launch them up a little
			AngleVectors( QAngle(-45, m_angEyeAngles[YAW], 0), &vecForward );

			for ( int i = 0; i < count; i++ )
			{
				// Team damage doesn't prevent us hurting ourself, so we do it manually here
				if ( pList[i] == this )
					continue;

				if ( FVisible( pList[i], MASK_SOLID ) == false )
					continue;

				Vector vecPos = WorldSpaceCenter();
				vecPos += (pList[i]->WorldSpaceCenter() - vecPos) * 0.75;

				// Spy taunt does two quick slashes, followed by a killing blow
				if ( iTauntAttack == TAUNTATK_SPY_FENCING_SLASH_A || iTauntAttack == TAUNTATK_SPY_FENCING_SLASH_B )
				{
					// No physics push so it doesn't push the player out of the range of the stab
					pList[i]->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward * 100, vecPos, 25, DMG_SLASH | DMG_PREVENT_PHYSICS_FORCE, TF_DMG_CUSTOM_TAUNTATK_FENCING ) );
				}
				else if ( iTauntAttack == TAUNTATK_SPY_FENCING_STAB )
				{
					pList[i]->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward * 20000, vecPos, 500.0f, DMG_SLASH, TF_DMG_CUSTOM_TAUNTATK_FENCING ) );
				}
				else if ( iTauntAttack == TAUNTATK_PYRO_HADOUKEN )
				{
					pList[i]->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward * 25000, vecPos, 500.0f, DMG_BURN | DMG_IGNITE, TF_DMG_CUSTOM_TAUNTATK_HADOUKEN ) );
				}
			}
		}

		if ( iTauntAttack == TAUNTATK_SPY_FENCING_SLASH_A )
		{
			m_iTauntAttack = TAUNTATK_SPY_FENCING_SLASH_B;
			m_flTauntAttackTime = gpGlobals->curtime + 0.47;
		}
		else if ( iTauntAttack == TAUNTATK_SPY_FENCING_SLASH_B )
		{
			m_iTauntAttack = TAUNTATK_SPY_FENCING_STAB;
			m_flTauntAttackTime = gpGlobals->curtime + 1.73;
		}

		if ( tf_debug_damage.GetBool() )
		{
			NDebugOverlay::Box( vecCenter, -vecSize, vecSize, 0, 255, 0, 40, 10 );
		}
	}
	else if ( iTauntAttack == TAUNTATK_SOLDIER_GRENADE_KILL_WORMSIGN )
	{
		EmitSound( "Taunt.WormsHHG" );
		m_iTauntAttack = TAUNTATK_SOLDIER_GRENADE_KILL;
		m_flTauntAttackTime = gpGlobals->curtime + 2.1;
	}
	else if ( iTauntAttack == TAUNTATK_SOLDIER_GRENADE_KILL )
	{
		matrix3x4_t worldSpace;
		MatrixCopy( EntityToWorldTransform(), worldSpace );

		Vector bonePos;
		QAngle boneAngles;
		int iRightHand = LookupBone( "bip_hand_r" );
		if ( iRightHand != -1 )
		{
			GetBonePosition( iRightHand, bonePos, boneAngles );

			CPVSFilter filter( bonePos );
			TE_TFExplosion( filter, 0.0f, bonePos, Vector(0,0,1), TF_WEAPON_GRENADELAUNCHER, entindex() );

			CTakeDamageInfo info( this, this, GetActiveTFWeapon(), vec3_origin, bonePos, 200.f, DMG_BLAST | DMG_USEDISTANCEMOD, TF_DMG_CUSTOM_TAUNTATK_GRENADE, &bonePos );
			CTFRadiusDamageInfo radiusinfo( &info, bonePos, 100.f );
			TFGameRules()->RadiusDamage( radiusinfo );
		}
	}
	else if ( iTauntAttack == TAUNTATK_SNIPER_ARROW_STAB_IMPALE || iTauntAttack == TAUNTATK_SNIPER_ARROW_STAB_KILL ||
			  iTauntAttack == TAUNTATK_ENGINEER_ARM_IMPALE || iTauntAttack == TAUNTATK_ENGINEER_ARM_KILL || iTauntAttack == TAUNTATK_ENGINEER_ARM_BLEND )
	{
		Vector vecForward;
		AngleVectors( EyeAngles(), &vecForward );
		Vector vecEnd = EyePosition() + vecForward * 128;

		trace_t tr;
		UTIL_TraceLine( EyePosition(), vecEnd, MASK_SOLID & ~CONTENTS_HITBOX, this, COLLISION_GROUP_PLAYER, &tr );

		if ( tr.fraction < 1.0 )
		{
			CBaseEntity *pEnt = tr.m_pEnt;

			if ( pEnt && pEnt->IsPlayer() && pEnt->GetTeamNumber() > LAST_SHARED_TEAM && pEnt->GetTeamNumber() != GetTeamNumber() )
			{
				CTFPlayer *pVictim = ToTFPlayer( pEnt );

				switch ( iTauntAttack )
				{
				case TAUNTATK_SNIPER_ARROW_STAB_IMPALE:
				case TAUNTATK_ENGINEER_ARM_IMPALE:
					if ( pVictim )
					{
						// don't stun giants
						if ( !pVictim->IsMiniBoss() )
						{
							pVictim->m_Shared.StunPlayer( 3.0f, 1.0, TF_STUN_BOTH | TF_STUN_NO_EFFECTS, this );
						}

						if ( iTauntAttack == TAUNTATK_ENGINEER_ARM_IMPALE )
						{
							pEnt->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward, pEnt->WorldSpaceCenter(), 1, DMG_BULLET | DMG_PREVENT_PHYSICS_FORCE, TF_DMG_CUSTOM_TAUNTATK_ENGINEER_ARM_KILL ) );
						}
					}
					break;

				case TAUNTATK_ENGINEER_ARM_BLEND:
					pEnt->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward, pEnt->WorldSpaceCenter(), 1, DMG_BULLET | DMG_PREVENT_PHYSICS_FORCE, TF_DMG_CUSTOM_TAUNTATK_ENGINEER_ARM_KILL ) );
					break;

				case TAUNTATK_SNIPER_ARROW_STAB_KILL:
					// Launch them up a little
					vecForward = (WorldSpaceCenter() - pEnt->WorldSpaceCenter());
					VectorNormalize( vecForward );
					pEnt->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward * 12000, pEnt->WorldSpaceCenter(), 500.0f, DMG_BULLET | DMG_PREVENT_PHYSICS_FORCE, TF_DMG_CUSTOM_TAUNTATK_ARROW_STAB ) );
					break;

				case TAUNTATK_ENGINEER_ARM_KILL:
					pEnt->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward * 12000, pEnt->WorldSpaceCenter(), 500.0f, DMG_BLAST, TF_DMG_CUSTOM_TAUNTATK_ENGINEER_ARM_KILL ) );
					break;
				}
			}
		}

		if ( iTauntAttack == TAUNTATK_SNIPER_ARROW_STAB_IMPALE )
		{
			m_iTauntAttack = TAUNTATK_SNIPER_ARROW_STAB_KILL;
			m_flTauntAttackTime = gpGlobals->curtime + 1.30;
		}
		else if ( iTauntAttack == TAUNTATK_ENGINEER_ARM_IMPALE )
		{
			m_iTauntAttack = TAUNTATK_ENGINEER_ARM_BLEND;
			m_flTauntAttackTime = gpGlobals->curtime + 0.05;
			m_iTauntAttackCount = 0;
		}
		else if ( iTauntAttack == TAUNTATK_ENGINEER_ARM_BLEND )
		{
			m_iTauntAttack = TAUNTATK_ENGINEER_ARM_BLEND;
			m_flTauntAttackTime = gpGlobals->curtime + 0.05;
			m_iTauntAttackCount++;
			if ( m_iTauntAttackCount == 13 )
			{
				m_iTauntAttack = TAUNTATK_ENGINEER_ARM_KILL;
			}
		}
	}
	else if ( iTauntAttack == TAUNTATK_HEAVY_EAT )
	{
		CTFWeaponBase *pActiveWeapon = m_Shared.GetActiveTFWeapon();
		if ( pActiveWeapon && pActiveWeapon->GetWeaponID() == TF_WEAPON_LUNCHBOX )
		{
			CTFLunchBox *pLunchbox = (CTFLunchBox*)pActiveWeapon;
			pLunchbox->ApplyBiteEffects( this );
		}

		// Keep eating until the taunt is over
		m_iTauntAttack = TAUNTATK_HEAVY_EAT;
		m_flTauntAttackTime = gpGlobals->curtime + 1.0;

		// If we're going to finish eating after this bite, say our line
		if ( m_flTauntRemoveTime < m_flTauntAttackTime )
		{
			if ( IsSpeaking() )
			{
				// The player may technically still be speaking even though the actual VO is over and just 
				// hasn't been cleared yet. We need to force it to end so our next concept can be played.
				CMultiplayer_Expresser *pExpresser = GetMultiplayerExpresser();
				if ( pExpresser )
				{
					pExpresser->ForceNotSpeaking();
				}
			}
				
			SpeakConceptIfAllowed( MP_CONCEPT_ATE_FOOD );
		}
	}
	else if ( iTauntAttack == TAUNTATK_HEAVY_RADIAL_BUFF )
	{
		Vector vecOrg = GetAbsOrigin();

		// Find nearby team mates and give them bonus health & crit chance
		for ( int i = 0; i < GetTeam()->GetNumPlayers(); i++ )
		{
			CTFPlayer *pTeamPlayer = ToTFPlayer( GetTeam()->GetPlayer(i) );
			if ( pTeamPlayer && pTeamPlayer->IsAlive() )
			{
				// If they're within the radius, give 'em the buff
				if ( (vecOrg - pTeamPlayer->GetAbsOrigin()).LengthSqr() < (1024*1024) )
				{
					pTeamPlayer->TakeHealth( 50, DMG_GENERIC );
					pTeamPlayer->m_Shared.AddTempCritBonus( 0.5 );

					IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
					if ( event )
					{
						event->SetInt( "amount", 50 );
						event->SetInt( "entindex", pTeamPlayer->entindex() );
						event->SetInt( "weapon_def_index", INVALID_ITEM_DEF_INDEX );
						gameeventmanager->FireEvent( event );
					}
				}
			}
		}
	}
	else if ( iTauntAttack == TAUNTATK_HEAVY_HIGH_NOON )
	{
		// Heavy "High Noon" attack
		Vector vecForward;
 		AngleVectors( EyeAngles(), &vecForward );
		Vector vecEnd = EyePosition() + vecForward * 500;

		trace_t tr;
		UTIL_TraceLine( EyePosition(), vecEnd, ( MASK_SOLID | CONTENTS_HITBOX ), this, COLLISION_GROUP_PLAYER, &tr );
//		DebugDrawLine( EyePosition(), vecEnd, 0, 0, 255, true, 3.0f );

		if ( tr.fraction < 1.0 )
		{
			CBaseEntity *pEnt = tr.m_pEnt;

			if ( pEnt && pEnt->IsPlayer() && pEnt->GetTeamNumber() > LAST_SHARED_TEAM && pEnt->GetTeamNumber() != GetTeamNumber() )
			{
				// Launch them up a little
				AngleVectors( QAngle(-45, m_angEyeAngles[YAW], 0), &vecForward );
				pEnt->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward * 25000, WorldSpaceCenter(), 500.0f, DMG_BULLET, TF_DMG_CUSTOM_TAUNTATK_HIGH_NOON ) );
			}
		}
	}
	else if ( iTauntAttack == TAUNTATK_SCOUT_DRINK )
	{
		if ( !m_Shared.IsControlStunned() )
		{
			// Check for CritBerry flavor
			CTFWeaponBase *pActiveWeapon = m_Shared.GetActiveTFWeapon();
			if ( pActiveWeapon && pActiveWeapon->GetWeaponID() == TF_WEAPON_LUNCHBOX )
			{
				float flDropDeadTime = ( 100.f / tf_scout_energydrink_consume_rate.GetFloat() ) + 1.f;	// Just in case.  Normally over in 8 seconds.

				CTFLunchBox *pLunchbox = static_cast< CTFLunchBox* >( pActiveWeapon );
				if ( pLunchbox && pLunchbox->GetLunchboxType() == LUNCHBOX_ADDS_MINICRITS )
				{
					m_Shared.AddCond( TF_COND_ENERGY_BUFF, flDropDeadTime );
				}
				else
				{
					m_Shared.AddCond( TF_COND_PHASE, flDropDeadTime );

					if ( HasTheFlag() )
					{
						bool bShouldDrop = true;

						// Always allow teams to hear each other in TD mode
						if ( TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
						{
							bShouldDrop = false;
						}

						if ( bShouldDrop )
						{
							DropFlag();
						}
					}
				}

				SelectLastItem();
			}
		}
	}
	else if ( iTauntAttack == TAUNTATK_SCOUT_GRAND_SLAM )
	{
		// Find a player in front of us and knock 'em across the map.
		// Same box logic as hadouken & pyro knockback.
		Vector vecForward;
		AngleVectors( QAngle(0, m_angEyeAngles[YAW], 0), &vecForward );
		Vector vecCenter = WorldSpaceCenter() + vecForward * 64;
		Vector vecSize = Vector(24,24,24);
		CBaseEntity *pObjects[256];
		int count = UTIL_EntitiesInBox( pObjects, 256, vecCenter - vecSize, vecCenter + vecSize, FL_CLIENT|FL_OBJECT );
		if ( count )
		{
			for ( int i=0; i<count; i++ )
			{
				// Must be facing whoever we knock back.
				Vector vecToTarget;
				vecToTarget = pObjects[i]->WorldSpaceCenter() - WorldSpaceCenter();
				VectorNormalize( vecToTarget );
				float flDot = DotProduct( vecForward, vecToTarget );
				if ( flDot < 0.80 )
					continue;

				CTFPlayer *pTarget = ToTFPlayer( pObjects[i] );
				if ( !pTarget )
					continue;

				if ( pTarget->GetTeamNumber() == GetTeamNumber() )
					continue;

				// Do a quick trace and make sure we have LOS.
				trace_t tr;
				UTIL_TraceLine( WorldSpaceCenter(), pObjects[i]->WorldSpaceCenter(), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_PLAYER, &tr );

				if ( tr.fraction < 1.0 )
					continue;

				pTarget->SetAbsVelocity( vec3_origin );
				//pTarget->m_Shared.StunPlayer( 8.f, 1.f, TF_STUN_BOTH | TF_STUN_SPECIAL_SOUND );
				pTarget->StunSound( this, TF_STUN_BOTH | TF_STUN_SPECIAL_SOUND );
				pTarget->ApplyPunchImpulseX( RandomInt( 10, 15 ) );

				AngleVectors( QAngle(-45, m_angEyeAngles[YAW], 0), &vecForward );
				pTarget->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward * 130000, WorldSpaceCenter(), 500.0f, DMG_BULLET, TF_DMG_CUSTOM_TAUNTATK_GRAND_SLAM ) );

				// Tell the achievement system we swatted someone.
				IGameEvent *event = gameeventmanager->CreateEvent( "scout_grand_slam" );
				if ( event )
				{
					event->SetInt( "scout_id", GetUserID() );
					event->SetInt( "target_id", pTarget->GetUserID() );
					gameeventmanager->FireEvent( event );
				}
			}
		}
	}
	else if ( iTauntAttack == TAUNTATK_MEDIC_HEROIC_TAUNT )
	{
		// do these later
		m_flTauntAttackTime = gpGlobals->curtime + 3.0f;
		m_iTauntAttack = TAUNTATK_MEDIC_RELEASE_DOVES;

		// send a reliable message to make sure the effect happens
		CPVSFilter filter( GetAbsOrigin() );
		UserMessageBegin( filter, "PlayerGodRayEffect" );
			WRITE_BYTE( entindex() );
		MessageEnd();

		EmitSound( "Taunt.MedicHeroic" );
	}
	else if ( iTauntAttack == TAUNTATK_MEDIC_RELEASE_DOVES )
	{
		// not really a taunt "attack", just a hook to release some doves at the appropriate time
		Vector launchSpot = ( WorldSpaceCenter() + GetAbsOrigin() ) / 2.0f;
		for( int i=0; i<MEDIC_RELEASE_DOVE_COUNT; ++i )
		{
			Vector vecPos = launchSpot + Vector( 0, 0, RandomFloat( -10.0f, 20.0f ) );
			SpawnClientsideFlyingBird( vecPos );
		}
	}
	else if ( iTauntAttack == TAUNTATK_PYRO_ARMAGEDDON )
	{
		Vector origin( GetAbsOrigin() );

		CPVSFilter filter( origin );
		TE_TFExplosion( filter, 0.0f, origin, Vector( 0.0f, 0.0f, 1.0f ), TF_WEAPON_GRENADELAUNCHER, entindex() );

		int nRandomPick[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		CUtlVector< CTFPlayer* > vecDamagedPlayers;
		const float flRadius = 100.0f;
		const float flRadiusSqr = flRadius * flRadius;	

		CBaseEntity *pEntity = NULL;
		for ( CEntitySphereQuery sphere( origin, flRadius ); (pEntity = sphere.GetCurrentEntity()) != NULL && vecDamagedPlayers.Count() < ARRAYSIZE( nRandomPick ); sphere.NextEntity() )
		{
			// Skip players on the same team or who are invuln
			CTFPlayer *pPlayer = ToTFPlayer( pEntity );
			if ( !pPlayer || InSameTeam( pPlayer ) || pPlayer->m_Shared.InCond( TF_COND_INVULNERABLE ) )
				continue;

			// CEntitySphereQuery actually does a box test. So we need to make sure the distance is less than the radius first.
			Vector vecPos;
			pEntity->CollisionProp()->CalcNearestPoint( origin, &vecPos );
			if ( ( origin - vecPos ).LengthSqr() > flRadiusSqr )
				continue;

			// Finally LOS test
			trace_t	tr;
			Vector vecSrc = WorldSpaceCenter();
			Vector vecSpot = pEntity->WorldSpaceCenter();
			CTraceFilterSimple filter( this, COLLISION_GROUP_PROJECTILE );
			UTIL_TraceLine( vecSrc, vecSpot, MASK_SOLID_BRUSHONLY, &filter, &tr );

			// If we don't trace the whole way to the target, and we didn't hit the target entity, we're blocked
			if ( tr.fraction != 1.0 && tr.m_pEnt != pEntity )
				continue;

			vecDamagedPlayers.AddToTail( pPlayer );
		}

		if ( vecDamagedPlayers.Count() )
		{
			int nBurnCount = 0;
			float fDamage = 400.0f; 

			for ( int i = vecDamagedPlayers.Count() - 1; i >= 0; --i )
			{
				// Pick a random player
				int nRand = RandomInt( 0, i );
				CTFPlayer *pPlayer = vecDamagedPlayers[ nRandomPick[ nRand ] ];
				if ( pPlayer )
				{
					bool bBurning = pPlayer->m_Shared.InCond( TF_COND_BURNING );

					pPlayer->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vec3_origin, origin, fDamage, DMG_PLASMA, ( iTauntAttack == TAUNTATK_PYRO_ARMAGEDDON ) ? TF_DMG_CUSTOM_TAUNTATK_ARMAGEDDON : TF_DMG_CUSTOM_TAUNTATK_ALLCLASS_GUITAR_RIFF, &origin ) );

					// If they weren't burning before but now they are, count it
					if ( !bBurning && pPlayer->m_Shared.InCond( TF_COND_BURNING ) )
					{
						nBurnCount++;
					}

					// Next choice gets half that amount
					fDamage /= 2;

					// The end of the list moves overwrites the one we just picked
					nRandomPick[ nRand ] = nRandomPick[ i ];
				}
			}

			if ( iTauntAttack == TAUNTATK_PYRO_ARMAGEDDON )
			{
				if ( nBurnCount >= 3 )
				{
					AwardAchievement( ACHIEVEMENT_TF_PYRO_IGNITE_WITH_RAINBOW );
				}
			}
		}

		UTIL_ScreenShake( origin, 15.0, 150.0, 0.75f, 500.0f, SHAKE_START );

	}
	else if ( iTauntAttack == TAUNTATK_PYRO_SCORCHSHOT )
	{
		CTFWeaponBase *pWeapon = GetActiveTFWeapon();
		if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_FLAREGUN )
		{
			CTFWeaponBaseGun *pGun = dynamic_cast< CTFWeaponBaseGun* >( pWeapon );
			if ( pGun )
			{
				pGun->FireProjectile( this );
			}
		}
	}
	else if ( iTauntAttack == TAUNTATK_ALLCLASS_GUITAR_RIFF )
	{
		// We need to parent this to a target instead of the player because the player changing their camera view can twist the rainbow
		CBaseEntity *pTarget = CreateEntityByName( "info_target" );
		if ( pTarget )
		{
			DispatchSpawn( pTarget );
			pTarget->SetAbsOrigin( GetAbsOrigin() );
			pTarget->SetAbsAngles( GetAbsAngles() );
			pTarget->SetEFlags( EFL_FORCE_CHECK_TRANSMIT );
			pTarget->SetThink( &BaseClass::SUB_Remove );
			pTarget->SetNextThink( gpGlobals->curtime + 6.0f );

			CBaseEntity *pGround = GetGroundEntity();
			if ( pGround && pGround->GetMoveType() == MOVETYPE_PUSH )
			{
				pTarget->SetParent( pGround );
			}
		}

		CBroadcastRecipientFilter filter;
		TE_TFParticleEffect( filter, 0.0, "bl_killtaunt", GetAbsOrigin(), GetAbsAngles(), pTarget, PATTACH_ABSORIGIN_FOLLOW );
		EmitSound( "Taunt.GuitarRiff" );
	}
	else if ( iTauntAttack == TAUNTATK_MEDIC_INHALE )
	{
		int iHealed = TakeHealth( 1, DMG_GENERIC );

		if ( iHealed > 0 )
		{
			CTF_GameStats.Event_PlayerHealedOther( this, iHealed );
		}

		// Keep eating until the taunt is over
		if ( m_flTauntInhaleTime > gpGlobals->curtime )
		{
			m_iTauntAttack = TAUNTATK_MEDIC_INHALE;
			m_flTauntAttackTime = gpGlobals->curtime + 0.1;
		}
	}
	else if ( iTauntAttack == TAUNTATK_MEDIC_UBERSLICE_IMPALE || iTauntAttack == TAUNTATK_MEDIC_UBERSLICE_KILL )
	{
		Vector vecForward;
		AngleVectors( EyeAngles(), &vecForward );
		Vector vecEnd = EyePosition() + vecForward * 128;

		trace_t tr;
		UTIL_TraceLine( EyePosition(), vecEnd, MASK_SOLID & ~CONTENTS_HITBOX, this, COLLISION_GROUP_PLAYER, &tr );

		if ( tr.fraction < 1.0 )
		{
			CBaseEntity *pEnt = tr.m_pEnt;

			if ( pEnt && pEnt->IsPlayer() && pEnt->GetTeamNumber() > LAST_SHARED_TEAM && pEnt->GetTeamNumber() != GetTeamNumber() )
			{
				CTFPlayer *pVictim = ToTFPlayer( pEnt );

				if ( iTauntAttack == TAUNTATK_MEDIC_UBERSLICE_IMPALE )
				{
					if ( pVictim )
					{
						// don't stun giants
						if ( !pVictim->IsMiniBoss() )
						{
							pVictim->m_Shared.StunPlayer( 1.5f, 1.0, TF_STUN_BOTH | TF_STUN_NO_EFFECTS, this );
						}
						pVictim->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward, WorldSpaceCenter(), 1, DMG_BULLET | DMG_PREVENT_PHYSICS_FORCE, TF_DMG_CUSTOM_TAUNTATK_UBERSLICE ) );
					}
				}
				else
				{
					// Launch them up a little
					vecForward = (WorldSpaceCenter() - pVictim->WorldSpaceCenter());
					VectorNormalize( vecForward );

					pVictim->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward * 12000, WorldSpaceCenter(), 500.0f, DMG_BULLET | DMG_PREVENT_PHYSICS_FORCE, TF_DMG_CUSTOM_TAUNTATK_UBERSLICE ) );

					CWeaponMedigun *pMedigun = (CWeaponMedigun *) Weapon_OwnsThisID( TF_WEAPON_MEDIGUN );
					if ( pMedigun )
					{
						pMedigun->AddCharge( 0.5f );
					}
				}
			}
		}

		if ( iTauntAttack == TAUNTATK_MEDIC_UBERSLICE_IMPALE )
		{
			m_iTauntAttack = TAUNTATK_MEDIC_UBERSLICE_KILL;
			m_flTauntAttackTime = gpGlobals->curtime + 0.75;
		}
	}
	else if ( iTauntAttack == TAUNTATK_DEMOMAN_BARBARIAN_SWING )
	{
		Vector vecForward;
		AngleVectors( EyeAngles(), &vecForward );
		Vector vecEnd = EyePosition() + vecForward * 128;

		trace_t tr;
		UTIL_TraceLine( EyePosition(), vecEnd, MASK_SOLID & ~CONTENTS_HITBOX, this, COLLISION_GROUP_PLAYER, &tr );

		if ( tr.fraction < 1.0 )
		{
			CBaseEntity *pEnt = tr.m_pEnt;

			if ( pEnt && pEnt->IsPlayer() && pEnt->GetTeamNumber() > LAST_SHARED_TEAM && pEnt->GetTeamNumber() != GetTeamNumber() )
			{
				vecForward = (WorldSpaceCenter() - pEnt->WorldSpaceCenter());
				VectorNormalize( vecForward );
				pEnt->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward * 12000, WorldSpaceCenter(), 500.0f, DMG_CLUB, TF_DMG_CUSTOM_TAUNTATK_BARBARIAN_SWING ) );
			}
		}
	}
	else if ( iTauntAttack == TAUNTATK_ENGINEER_GUITAR_SMASH )
	{
		Vector vecForward;
		AngleVectors( EyeAngles(), &vecForward );
		Vector vecEnd = EyePosition() + vecForward * 128;

		trace_t tr;
		UTIL_TraceLine( EyePosition(), vecEnd, MASK_SOLID & ~CONTENTS_HITBOX, this, COLLISION_GROUP_PLAYER, &tr );

		if ( tr.fraction < 1.0 )
		{
			CBaseEntity *pEnt = tr.m_pEnt;

			if ( pEnt && pEnt->IsPlayer() && pEnt->GetTeamNumber() > LAST_SHARED_TEAM && pEnt->GetTeamNumber() != GetTeamNumber() )
			{
				vecForward = (WorldSpaceCenter() - pEnt->WorldSpaceCenter());
				VectorNormalize( vecForward );
				pEnt->TakeDamage( CTakeDamageInfo( this, this, GetActiveTFWeapon(), vecForward * 12, WorldSpaceCenter(), 500.0f, DMG_CLUB, TF_DMG_CUSTOM_TAUNTATK_ENGINEER_GUITAR_SMASH ) );
			}
		}
	}
	else if ( iTauntAttack == TAUNTATK_SHOW_ITEM )
	{
		if ( m_hTauntItem == NULL )
		{
			int itemCount = Inventory()->GetItemCount();

			CUtlVector< CEconItemView * > hatVector;

			for( int i=0; i<itemCount; ++i )
			{
				CEconItemView *econItemView = Inventory()->GetItem( i );

				int iSlot = econItemView->GetStaticData()->GetLoadoutSlot( GetPlayerClass()->GetClassIndex() );

				if ( iSlot == LOADOUT_POSITION_HEAD )
				{
					hatVector.AddToTail( econItemView );
				}
			}

			if ( hatVector.Count() > 0 )
			{
				int which = RandomInt( 0, hatVector.Count()-1 );

				CEconItemView *hatView = hatVector[ which ];

				int iHandBone = LookupBone( "weapon_bone" );
				if ( iHandBone != -1 )
				{
					Vector pos;
					QAngle angles;
					GetBonePosition( iHandBone, pos, angles );

					pos = Vector( 0, 0, 50.0f );

					m_hTauntItem = ItemGeneration()->GenerateItemFromScriptData( hatView, pos, angles, NULL );

					if ( m_hTauntItem != NULL )
					{
						m_hTauntItem->AddSolidFlags( FSOLID_NOT_SOLID );
						m_hTauntItem->SetOwnerEntity( this );
					}
				}
			}
		}
	}
	else if ( iTauntAttack == TAUNTATK_HIGHFIVE_PARTICLE )
	{
		if ( m_hHighFivePartner.Get() )
		{
			QAngle bodyAngles = BodyAngles();
			bodyAngles.x = 0;
			Vector vecForward, vecRight, vecUp;
			AngleVectors( bodyAngles, &vecForward, &vecRight, &vecUp );

			//Msg( "forward: %f %f %f   right: %f %f %f   up: %f %f %f\n", vecForward.x, vecForward.y, vecForward.z,
			//	vecRight.x, vecRight.y, vecRight.z,
			//	vecUp.x, vecUp.y, vecUp.z );

			Vector vecParticle = GetAbsOrigin() + (vecForward * 30.0f) + (vecRight * -3.0f) + (vecUp * 87.0f);
			//Msg( "particle: %f %f %f\n", vecParticle.x, vecParticle.y, vecParticle.z );

			CEffectData	data;
			data.m_nHitBox = GetParticleSystemIndex( GetTeamNumber() == TF_TEAM_RED ? "highfive_red" : "highfive_blue" );
			data.m_vOrigin = vecParticle;
			data.m_vAngles = vec3_angle;

			CPASFilter filter( data.m_vOrigin );
			filter.SetIgnorePredictionCull( true );

			te->DispatchEffect( filter, 0.0, data.m_vOrigin, "ParticleEffect", data );
		}
	}
	else if ( iTauntAttack == TAUNTATK_RPS_PARTICLE )
	{
		if ( m_hHighFivePartner.Get() )
		{
			bool bInitiatorWin = ( m_iTauntRPSResult / 3 ) == 0;

			// figure out for RPS
			// 0:rock 1:paper 2:scissors
			int iInitiator = m_iTauntRPSResult % 3;
			int iReceiver = ( iInitiator + ( bInitiatorWin ? 2 : 1 ) ) % 3;

			// offset to get the correct particle name
			if ( bInitiatorWin )
			{
				iInitiator += 3;
			}
			else
			{
				iReceiver += 3;
			}

			if ( GetTeamNumber() == TF_TEAM_BLUE )
			{
				iInitiator += 6;
			}

			if ( m_hHighFivePartner->GetTeamNumber() == TF_TEAM_BLUE )
			{
				iReceiver += 6;
			}

			DispatchRPSEffect( this, s_pszTauntRPSParticleNames[iInitiator] );
			DispatchRPSEffect( m_hHighFivePartner.Get(), s_pszTauntRPSParticleNames[iReceiver] );

			// setup time to kill the opposing team loser
			if ( GetTeamNumber() != m_hHighFivePartner->GetTeamNumber() )
			{
				m_iTauntAttack = TAUNTATK_RPS_KILL;
				m_flTauntAttackTime = m_flTauntRemoveTime - 1.2f;
			}

			IGameEvent *event = gameeventmanager->CreateEvent( "rps_taunt_event" );
			if ( event )
			{
				int iInitiatorRPS = m_iTauntRPSResult % 3;
				int iReceiverRPS = ( iInitiatorRPS + ( bInitiatorWin ? 2 : 1 ) ) % 3;

				event->SetInt( "winner", bInitiatorWin ? entindex() : m_hHighFivePartner.Get()->entindex() );
				event->SetInt( "winner_rps", bInitiatorWin ? iInitiatorRPS : iReceiverRPS );
				event->SetInt( "loser", bInitiatorWin ? m_hHighFivePartner.Get()->entindex() : entindex() );
				event->SetInt( "loser_rps",  bInitiatorWin ? iReceiverRPS : iInitiatorRPS );
				gameeventmanager->FireEvent( event );
			}
		}
	}
	else if ( iTauntAttack == TAUNTATK_RPS_KILL )
	{
		if ( m_hHighFivePartner.Get() )
		{
			bool bInitiatorWin = ( m_iTauntRPSResult / 3 ) == 0;

			CTFPlayer *pWinner = NULL;
			CTFPlayer *pLoser = NULL;
			if ( bInitiatorWin )
			{
				pWinner = this;
				pLoser = m_hHighFivePartner.Get();
			}
			else
			{
				pWinner = m_hHighFivePartner.Get();
				pLoser = this;
			}
			
			// gib the loser
			pLoser->m_bSuicideExplode = true;
			pLoser->TakeDamage( CTakeDamageInfo( pWinner, pWinner, NULL, 999, DMG_GENERIC, 0 ) );
		}
	}
	// Particle Being played in VCD instead
	//else if ( iTauntAttack == TAUNTATK_FLIP_LAND_PARTICLE )
	//{
	//	if ( m_hHighFivePartner.Get() )
	//	{
	//		CEffectData	data;
	//		data.m_nHitBox = GetParticleSystemIndex( GetTeamNumber() == TF_TEAM_RED ? "taunt_flip_land_red" : "taunt_flip_land_blue" );
	//		data.m_vOrigin = m_hHighFivePartner.Get()->GetAbsOrigin();
	//		data.m_vAngles = m_hHighFivePartner.Get()->GetAbsAngles();

	//		CPASFilter filter( data.m_vOrigin );
	//		filter.SetIgnorePredictionCull( true );

	//		te->DispatchEffect( filter, 0.0, data.m_vOrigin, "ParticleEffect", data );
	//	}
	//}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFPlayer::GetSpecialDSP( void )
{
	int iSpecialDSP = 0;
	CALL_ATTRIB_HOOK_INT( iSpecialDSP, special_dsp );

	return iSpecialDSP;
}

//-----------------------------------------------------------------------------
// Purpose: Play a one-shot scene
// Input  :
// Output :
//-----------------------------------------------------------------------------
float CTFPlayer::PlayScene( const char *pszScene, float flDelay, AI_Response *response, IRecipientFilter *filter )
{
	MDLCACHE_CRITICAL_SECTION();

	// This is a lame way to detect a taunt!
	if ( m_bInitTaunt )
	{
		m_bInitTaunt = false;
		return InstancedScriptedScene( this, pszScene, &m_hTauntScene, flDelay, false, response, true, filter );
	}
	else
	{
		return InstancedScriptedScene( this, pszScene, NULL, flDelay, false, response, true, filter );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ModifyOrAppendCriteria( AI_CriteriaSet& criteriaSet )
{
	BaseClass::ModifyOrAppendCriteria( criteriaSet );

	// If we have 'disguiseclass' criteria, pretend that we are actually our
	// disguise class. That way we just look up the scene we would play as if 
	// we were that class.
	int disguiseIndex = criteriaSet.FindCriterionIndex( "disguiseclass" );

	if ( disguiseIndex != -1 )
	{
		criteriaSet.AppendCriteria( "playerclass", criteriaSet.GetValue(disguiseIndex) );
	}
	else
	{
		if ( GetPlayerClass() )
		{
			criteriaSet.AppendCriteria( "playerclass", g_aPlayerClassNames_NonLocalized[ GetPlayerClass()->GetClassIndex() ] );
		}
	}

	bool bRedTeam = ( GetTeamNumber() == TF_TEAM_RED );
	if ( m_Shared.InCond( TF_COND_DISGUISED ) )
	{
		bRedTeam = ( m_Shared.GetDisguiseTeam() == TF_TEAM_RED );
	}
	criteriaSet.AppendCriteria( "OnRedTeam", bRedTeam ? "1" : "0" );

//=============================================================================
// HPE_BEGIN:
// [msmith]	When in training, we kill a lot of guys... a WHOLE LOT.  This was
//			triggering some response sounds that got very annoying after a while.
//=============================================================================
	if ( TFGameRules()->IsInTraining() )
	{
		criteriaSet.AppendCriteria( "recentkills", UTIL_VarArgs("%d", 0) );
	}
	else
	{
		criteriaSet.AppendCriteria( "recentkills", UTIL_VarArgs("%d", m_Shared.GetNumKillsInTime(30.0)) );
	}
//=============================================================================
// HPE_END
//=============================================================================

	int iTotalKills = 0;
	PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( this );
	if ( pStats )
	{
		iTotalKills = pStats->statsCurrentLife.m_iStat[TFSTAT_KILLS] + pStats->statsCurrentLife.m_iStat[TFSTAT_KILLASSISTS]+ 
			pStats->statsCurrentLife.m_iStat[TFSTAT_BUILDINGSDESTROYED];
	}
	criteriaSet.AppendCriteria( "killsthislife", UTIL_VarArgs( "%d", iTotalKills ) );
	criteriaSet.AppendCriteria( "disguised", m_Shared.InCond( TF_COND_DISGUISED ) ? "1" : "0" );
	criteriaSet.AppendCriteria( "cloaked", ( m_Shared.IsStealthed() || m_Shared.InCond( TF_COND_STEALTHED_BLINK ) ) ? "1" : "0" );
	criteriaSet.AppendCriteria( "invulnerable", m_Shared.InCond( TF_COND_INVULNERABLE ) ? "1" : "0" );
	criteriaSet.AppendCriteria( "beinghealed", m_Shared.InCond( TF_COND_HEALTH_BUFF ) ? "1" : "0" );
	criteriaSet.AppendCriteria( "waitingforplayers", (TFGameRules()->IsInWaitingForPlayers() || TFGameRules()->IsInPreMatch()) ? "1" : "0" );

	criteriaSet.AppendCriteria( "stunned", m_Shared.IsControlStunned() ? "1" : "0" );
	criteriaSet.AppendCriteria( "snared",  m_Shared.IsSnared() ? "1" : "0" );
	criteriaSet.AppendCriteria( "dodging",  (m_Shared.InCond( TF_COND_PHASE ) || m_Shared.InCond( TF_COND_PASSTIME_INTERCEPTION )) ? "1" : "0" );
	criteriaSet.AppendCriteria( "doublejumping", (m_Shared.GetAirDash()>0) ? "1" : "0" );

	switch ( GetTFTeam()->GetRole() )
	{
	case TEAM_ROLE_DEFENDERS:
		criteriaSet.AppendCriteria( "teamrole", "defense" );
		break;
	case TEAM_ROLE_ATTACKERS:
		criteriaSet.AppendCriteria( "teamrole", "offense" );
		break;
	}

	// Current weapon role
	CTFWeaponBase *pActiveWeapon = m_Shared.GetActiveTFWeapon();
	if ( pActiveWeapon )
	{
		int iWeaponRole = pActiveWeapon->GetTFWpnData().m_iWeaponType;
		switch( iWeaponRole )
		{
		case TF_WPN_TYPE_PRIMARY:
		default:
			criteriaSet.AppendCriteria( "weaponmode", "primary" );
			break;
		case TF_WPN_TYPE_SECONDARY:
			criteriaSet.AppendCriteria( "weaponmode", "secondary" );
			break;
		case TF_WPN_TYPE_MELEE:
			criteriaSet.AppendCriteria( "weaponmode", "melee" );
			break;
		case TF_WPN_TYPE_BUILDING:
			criteriaSet.AppendCriteria( "weaponmode", "building" );
			break;
		case TF_WPN_TYPE_PDA:
			criteriaSet.AppendCriteria( "weaponmode", "pda" );
			break;
		case TF_WPN_TYPE_ITEM1:
			criteriaSet.AppendCriteria( "weaponmode", "item1" );
			break;
		case TF_WPN_TYPE_ITEM2:
			criteriaSet.AppendCriteria( "weaponmode", "item2" );
			break;
		}

		if ( WeaponID_IsSniperRifle( pActiveWeapon->GetWeaponID() ) )
		{
			CTFSniperRifle *pRifle = dynamic_cast<CTFSniperRifle*>(pActiveWeapon);
			if ( pRifle && pRifle->IsZoomed() )
			{
				criteriaSet.AppendCriteria( "sniperzoomed", "1" );
			}
		}
		else if ( pActiveWeapon->GetWeaponID() == TF_WEAPON_MINIGUN )
		{
			CTFMinigun *pMinigun = dynamic_cast<CTFMinigun*>(pActiveWeapon);
			if ( pMinigun )
			{
				criteriaSet.AppendCriteria( "minigunfiretime", UTIL_VarArgs( "%.1f", pMinigun->GetFiringDuration() ) );
			}
		}

		CEconItemView *pItem = pActiveWeapon->GetAttributeContainer()->GetItem();
		if ( pItem && pItem->GetItemQuality() != AE_NORMAL )
		{
			criteriaSet.AppendCriteria( "item_name", pItem->GetStaticData()->GetDefinitionName() );
			criteriaSet.AppendCriteria( "item_type_name", pItem->GetStaticData()->GetItemTypeName() );
		}
	}

	// equipped loadout items
	{
		static const char* kSlotCriteriaName[CLASS_LOADOUT_POSITION_COUNT] = 
		{
			"loadout_slot_primary",		// LOADOUT_POSITION_PRIMARY = 0,
			"loadout_slot_secondary",	// LOADOUT_POSITION_SECONDARY,
			"loadout_slot_melee",		// LOADOUT_POSITION_MELEE,
			"loadout_slot_utility",		// LOADOUT_POSITION_UTILITY,
			"loadout_slot_building",	// LOADOUT_POSITION_BUILDING,
			"loadout_slot_pda",			// LOADOUT_POSITION_PDA,
			"loadout_slot_pda2",		// LOADOUT_POSITION_PDA2,
			"loadout_slot_head",		// LOADOUT_POSITION_HEAD,
			"loadout_slot_misc",		// LOADOUT_POSITION_MISC,
			"loadout_slot_action",		// LOADOUT_POSITION_ACTION,
			"loadout_slot_misc2",		// LOADOUT_POSITION_MISC2
			"loadout_slot_taunt",		// LOADOUT_POSITION_TAUNT
			"loadout_slot_taunt2",		// LOADOUT_POSITION_TAUNT2
			"loadout_slot_taunt3",		// LOADOUT_POSITION_TAUNT3
			"loadout_slot_taunt4",		// LOADOUT_POSITION_TAUNT4
			"loadout_slot_taunt5",		// LOADOUT_POSITION_TAUNT5
			"loadout_slot_taunt6",		// LOADOUT_POSITION_TAUNT6
			"loadout_slot_taunt7",		// LOADOUT_POSITION_TAUNT7
			"loadout_slot_taunt8",		// LOADOUT_POSITION_TAUNT8
#ifdef STAGING_ONLY
			"loadout_slot_pda3",		// LOADOUT_POSITION_PDA3,
			//"loadout_slot_misc3",		// LOADOUT_POSITION_MISC3
			//"loadout_slot_misc4",		// LOADOUT_POSITION_MISC4
			//"loadout_slot_misc5",		// LOADOUT_POSITION_MISC5
			//"loadout_slot_misc6",		// LOADOUT_POSITION_MISC6
			//"loadout_slot_misc7",		// LOADOUT_POSITION_MISC3
			//"loadout_slot_misc8",		// LOADOUT_POSITION_MISC4
			//"loadout_slot_misc9",		// LOADOUT_POSITION_MISC5
			//"loadout_slot_misc10",	// LOADOUT_POSITION_MISC6
			"loadout_slot_building2",	// LOADOUT_POSITION_BUILDING2,
#endif // STAGING_ONLY
		};
		COMPILE_TIME_ASSERT( ARRAYSIZE(kSlotCriteriaName) == CLASS_LOADOUT_POSITION_COUNT );
		CEconItemView *pItem = NULL;
		for ( int i = 0; i < CLASS_LOADOUT_POSITION_COUNT; ++i )
		{
			if ( m_EquippedLoadoutItemIndices[i] != LOADOUT_SLOT_USE_BASE_ITEM )
			{
				pItem = m_Inventory.GetInventoryItemByItemID( m_EquippedLoadoutItemIndices[i] );
				if ( pItem )
				{
					criteriaSet.AppendCriteria( kSlotCriteriaName[i], pItem->GetStaticData()->GetDefinitionName() );
				}
			}
		}
	}

	// Player under crosshair
	trace_t tr;
	Vector forward;
	EyeVectors( &forward );
	UTIL_TraceLine( EyePosition(), EyePosition() + (forward * MAX_TRACE_LENGTH), MASK_BLOCKLOS_AND_NPCS, this, COLLISION_GROUP_NONE, &tr );
	if ( !tr.startsolid && tr.DidHitNonWorldEntity() )
	{
		CBaseEntity *pEntity = tr.m_pEnt;
		if ( pEntity && pEntity->IsPlayer() )
		{
			CTFPlayer *pTFPlayer = ToTFPlayer(pEntity);
			if ( pTFPlayer )
			{
				int iClass = pTFPlayer->GetPlayerClass()->GetClassIndex();
				if ( !InSameTeam(pTFPlayer) )
				{
					// Prevent spotting stealthed enemies who haven't been exposed recently
					if ( pTFPlayer->m_Shared.InCond( TF_COND_STEALTHED ) )
					{
						if ( pTFPlayer->m_Shared.GetLastStealthExposedTime() < (gpGlobals->curtime - 3.0) )
						{
							iClass = TF_CLASS_UNDEFINED;
						}
						else
						{
							iClass = TF_CLASS_SPY;
						}
					}
					else if ( pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
					{
						iClass = pTFPlayer->m_Shared.GetDisguiseClass();
					}
				}

				if ( iClass > TF_CLASS_UNDEFINED && iClass <= TF_LAST_NORMAL_CLASS )
				{
					criteriaSet.AppendCriteria( "crosshair_on", g_aPlayerClassNames_NonLocalized[iClass] );

					int iVisibleTeam = pTFPlayer->GetTeamNumber();
					if ( pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
					{
						iVisibleTeam = pTFPlayer->m_Shared.GetDisguiseTeam();
					}

					if ( iVisibleTeam != GetTeamNumber() )
					{
						criteriaSet.AppendCriteria( "crosshair_enemy", "yes" );
					}
				}
			}
		}
	}

	// Previous round win
	bool bLoser = ( TFGameRules()->GetPreviousRoundWinners() != TEAM_UNASSIGNED && TFGameRules()->GetPreviousRoundWinners() != GetPrevRoundTeamNum() );
	criteriaSet.AppendCriteria( "LostRound", bLoser ? "1" : "0" );

	bool bPrevRoundTie = ( ( TFGameRules()->GetRoundsPlayed() > 0 ) && ( TFGameRules()->GetPreviousRoundWinners() == TEAM_UNASSIGNED ) );
	criteriaSet.AppendCriteria( "PrevRoundWasTie", bPrevRoundTie ? "1" : "0" );

	// Control points
	CTriggerAreaCapture *pAreaTrigger = GetControlPointStandingOn();
	if ( pAreaTrigger )
	{
		CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint();
		if ( pCP )
		{
			if ( pCP->GetOwner() == GetTeamNumber() )
			{
				criteriaSet.AppendCriteria( "OnFriendlyControlPoint", "1" );
			}
			else 
			{
				if ( TeamplayGameRules()->TeamMayCapturePoint( GetTeamNumber(), pCP->GetPointIndex() ) && 
					 TeamplayGameRules()->PlayerMayCapturePoint( this, pCP->GetPointIndex() ) )
				{
					criteriaSet.AppendCriteria( "OnCappableControlPoint", "1" );
				}
			}
		}
	}

	bool bIsBonusTime = false;
	bool bGameOver = false;

	// Current game state
	criteriaSet.AppendCriteria( "GameRound", UTIL_VarArgs( "%d", TFGameRules()->State_Get() ) ); 
	if ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN )
	{
		criteriaSet.AppendCriteria( "OnWinningTeam", ( TFGameRules()->GetWinningTeam() == GetTeamNumber() ) ? "1" : "0" ); 

		bIsBonusTime = ( TFGameRules()->GetStateTransitionTime() > gpGlobals->curtime );
		bGameOver = TFGameRules()->IsGameOver();
	}

	// Number of rounds played
	criteriaSet.AppendCriteria( "RoundsPlayed", UTIL_VarArgs( "%d", TFGameRules()->GetRoundsPlayed() ) );

	// Is this a 6v6 match?
	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	bool bIsComp6v6 = ( pMatch && pMatch->m_eMatchGroup == k_nMatchGroup_Ladder_6v6 );
	criteriaSet.AppendCriteria( "IsComp6v6", bIsComp6v6 ? "1" : "0" );

	bool bIsCompWinner = m_Shared.InCond( TF_COND_COMPETITIVE_WINNER );
	criteriaSet.AppendCriteria( "IsCompWinner",  bIsCompWinner ? "1" : "0" );
	

	// Holiday Taunt
	int iSpecialTaunt = 0;
	if ( pActiveWeapon )
	{
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pActiveWeapon, iSpecialTaunt, special_taunt );
	}

	// only roll random halloween taunt if the active weapon doesn't have special taunt attribute
	if ( TFGameRules()->IsHolidayActive( kHoliday_Halloween ) && iSpecialTaunt == 0 )
	{
		if ( !TFGameRules()->IsMannVsMachineMode() || ( GetTeamNumber() != TF_TEAM_PVE_INVADERS ) )
		{
			if ( pActiveWeapon )
			{
				int iRageTaunt = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pActiveWeapon, iRageTaunt, burn_damage_earns_rage );		
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pActiveWeapon, iRageTaunt, generate_rage_on_dmg );

				int iWeaponID = pActiveWeapon->GetWeaponID();
				if ( iWeaponID != TF_WEAPON_LUNCHBOX && !( iRageTaunt && m_Shared.GetRageMeter() >= 100.f ) )
				{
					float frand = (float) rand() / VALVE_RAND_MAX;
					if ( frand < 0.4f )
					{
						criteriaSet.AppendCriteria( "IsHalloweenTaunt", "1" );
					}
				}
			}
		}
	}

	if ( TFGameRules()->IsHolidayActive( kHoliday_AprilFools ) && iSpecialTaunt == 0 )
	{
		if ( pActiveWeapon )
		{
			int iRageTaunt = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pActiveWeapon, iRageTaunt, burn_damage_earns_rage );
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pActiveWeapon, iRageTaunt, generate_rage_on_dmg );

			int iWeaponID = pActiveWeapon->GetWeaponID();
			if ( iWeaponID != TF_WEAPON_LUNCHBOX && !( iRageTaunt && m_Shared.GetRageMeter() >= 100.f ) )
			{
				float frand = (float)rand() / VALVE_RAND_MAX;
				if ( frand < 0.8f )
				{		
					criteriaSet.AppendCriteria( "IsAprilFoolsTaunt", "1" );
				}
			}
		}
	}

	// Force the thriller taunt if we have the thriller condition
	if( m_Shared.InCond( TF_COND_HALLOWEEN_THRILLER ) )
	{
		criteriaSet.AppendCriteria( "IsHalloweenTaunt", "1" );
	}

	// Only allow these rules if in the holiday
	if ( TFGameRules()->IsHolidayActive( kHoliday_HalloweenOrFullMoon ) && iSpecialTaunt == 0 )
	{
		// Halloween costume sets
		if ( IsRobotCostumeEquipped() )
		{
			criteriaSet.AppendCriteria( "IsRobotCostume", "1" );
		}
		else if ( IsDemowolf() )
		{
			criteriaSet.AppendCriteria( "IsDemowolf", "1" );
		}
		else if ( IsFrankenHeavy() )
		{
			criteriaSet.AppendCriteria( "IsFrankenHeavy", "1" );
		}
		// Single items with response rules
		else
		{
			static CSchemaAttributeDefHandle pAttrDef_AdditionalHalloweenResponseRule( "additional halloween response criteria name" );
			FOR_EACH_VEC_BACK( m_hMyWearables, wbl )
			{
				CEconWearable *pWearable = m_hMyWearables[wbl];
				if ( pWearable && pWearable->GetAttributeContainer()->GetItem() )
				{
					const char *pszAdditionalResponseRule = NULL;
					if ( FindAttribute_UnsafeBitwiseCast<CAttribute_String>( pWearable->GetAttributeContainer()->GetItem(), pAttrDef_AdditionalHalloweenResponseRule, &pszAdditionalResponseRule ) )
					{
						criteriaSet.AppendCriteria( pszAdditionalResponseRule, "1" );
					}
				}
			}
		}

		// Zombie could work in addition to any of these
		if ( IsZombieCostumeEquipped() )
		{
			criteriaSet.AppendCriteria( "IsZombieCostume", "1" );
		}
	}

	if ( TFGameRules() && TFGameRules()->GetActiveBoss() && ( TFGameRules()->GetActiveBoss()->GetBossType() == HALLOWEEN_BOSS_MERASMUS ) )
	{
		CMerasmus* pMerasmus = assert_cast< CMerasmus* >( TFGameRules()->GetActiveBoss() );
		if ( pMerasmus )
		{
			if ( pMerasmus->IsHiding() )
			{
				criteriaSet.AppendCriteria( "IsMerasmusHiding", "1" );
			}
		}
	}

	bool bInHell = false;
	if ( TFGameRules() && TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) && ( TFGameRules()->ArePlayersInHell() == true ) )
	{
		bInHell = true;
	}
	criteriaSet.AppendCriteria( "IsInHell", bInHell ? "1" : "0" );

	if ( TFGameRules()->IsHolidayActive( kHoliday_HalloweenOrFullMoonOrValentines ) )
	{
		if ( IsFairyHeavy() )
		{
			criteriaSet.AppendCriteria( "IsFairyHeavy", "1" );
		}
	}
	
	if ( TFGameRules()->IsMannVsMachineMode() )
	{
		if ( GetTeamNumber() == TF_TEAM_PVE_DEFENDERS )
		{
			criteriaSet.AppendCriteria( "IsMvMDefender", "1" );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTriggerAreaCapture *CTFPlayer::GetControlPointStandingOn( void )
{
	touchlink_t *root = ( touchlink_t * )GetDataObject( TOUCHLINK );
	if ( root )
	{
		for ( touchlink_t *link = root->nextLink; link != root; link = link->nextLink )
		{
			CBaseEntity *pTouch = link->entityTouched;
			if ( pTouch && pTouch->IsSolidFlagSet( FSOLID_TRIGGER ) && pTouch->IsBSPModel() )
			{
				CTriggerAreaCapture *pAreaTrigger = dynamic_cast<CTriggerAreaCapture*>(pTouch);
				if ( pAreaTrigger )
					return pAreaTrigger;
			}
		}
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Usable by CTFPlayers, not just CTFBots
class CTFPlayertPathCost : public IPathCost
{
public:
	CTFPlayertPathCost( const CTFPlayer *me )
	{
		m_me = me;
		m_stepHeight = StepHeight;
		m_maxJumpHeight = 72.0f;
		m_maxDropHeight = 200.0f;
	}

	virtual float operator()( CNavArea *baseArea, CNavArea *fromArea, const CNavLadder *ladder, const CFuncElevator *elevator, float length ) const
	{
		VPROF_BUDGET( "CTFPlayertPathCost::operator()", "NextBot" );

		CTFNavArea *area = (CTFNavArea *)baseArea;

		if ( fromArea == NULL )
		{
			// first area in path, no cost
			return 0.0f;
		}
		else
		{
			if ( !m_me->IsAreaTraversable( area ) )
			{
				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;
			}

			float cost = dist + fromArea->GetCostSoFar();

			return cost;
		}
	}

	const CTFPlayer *m_me;
	float m_stepHeight;
	float m_maxJumpHeight;
	float m_maxDropHeight;
};

//-----------------------------------------------------------------------------
// Given a vector of points, return the point we can actually travel to the quickest (requires a nav mesh)
CTeamControlPoint *CTFPlayer::SelectClosestControlPointByTravelDistance( CUtlVector< CTeamControlPoint * > *pointVector ) const
{
	if ( !pointVector || pointVector->Count() == 0 )
	{
		return NULL;
	}

	if ( GetLastKnownArea() == NULL )
	{
		return NULL;
	}

	CTeamControlPoint *closestPoint = NULL;
	float closestPointTravelRange = FLT_MAX;
	CTFPlayertPathCost cost( this );

	for( int i=0; i<pointVector->Count(); ++i )
	{
		CTeamControlPoint *point = pointVector->Element(i);
		
		if ( IsBot() && point->ShouldBotsIgnore() )
			continue;

		float travelRange = NavAreaTravelDistance( GetLastKnownArea(), TheTFNavMesh()->GetControlPointCenterArea( point->GetPointIndex() ), cost );

		if ( travelRange >= 0.0 && travelRange < closestPointTravelRange )
		{
			closestPoint = point;
			closestPointTravelRange = travelRange;
		}
	}

	return closestPoint;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::CanHearAndReadChatFrom( CBasePlayer *pPlayer )
{
	// always can hear coach
	if ( m_hCoach && m_hCoach == pPlayer )
		return true;

	// always can hear student
	if ( m_hStudent && m_hStudent == pPlayer )
		return true;

	// can always hear the console unless we're ignoring all chat
	if ( !pPlayer )
		return m_iIgnoreGlobalChat != CHAT_IGNORE_ALL;

	// check if we're ignoring all chat
	if ( m_iIgnoreGlobalChat == CHAT_IGNORE_ALL )
		return false;

	// check if we're ignoring all but teammates
	if ( ( m_iIgnoreGlobalChat == CHAT_IGNORE_TEAM ) && ( g_pGameRules->PlayerRelationship( this, pPlayer ) != GR_TEAMMATE ) )
		return false;

	// Always allow teams to hear each other in TD mode
	if ( TFGameRules()->IsMannVsMachineMode() )
		return ( GetTeamNumber() == pPlayer->GetTeamNumber() );

	if ( pPlayer->m_lifeState != LIFE_ALIVE && m_lifeState == LIFE_ALIVE )
	{
		// Everyone can chat like normal when the round/game ends
		if ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN || TFGameRules()->State_Get() == GR_STATE_GAME_OVER )
			return true;

		if ( !tf_gravetalk.GetBool() )
			return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::CanBeAutobalanced()
{
	if ( DuelMiniGame_IsInDuel( this ) )
		return false;

	if ( IsBot() )
		return false;

	if ( IsCoaching() )
		return false;

	if ( GetCoach() )
		return false;

	if ( m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
		return false;
	
	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
IResponseSystem *CTFPlayer::GetResponseSystem()
{
	int iClass = GetPlayerClass()->GetClassIndex();

	if ( m_bSpeakingConceptAsDisguisedSpy && m_Shared.InCond( TF_COND_DISGUISED ) )
	{
		iClass = m_Shared.GetDisguiseClass();
	}

	bool bValidClass = ( iClass >= TF_CLASS_SCOUT && iClass <= TF_LAST_NORMAL_CLASS );
	bool bValidConcept = ( m_iCurrentConcept >= 0 && m_iCurrentConcept < MP_TF_CONCEPT_COUNT );
	Assert( bValidClass );
	Assert( bValidConcept );

	if ( !bValidClass || !bValidConcept )
	{
		return BaseClass::GetResponseSystem();
	}
	else
	{
		return TFGameRules()->m_ResponseRules[iClass].m_ResponseSystems[m_iCurrentConcept];
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::SpeakConceptIfAllowed( int iConcept, const char *modifiers, char *pszOutResponseChosen, size_t bufsize, IRecipientFilter *filter )
{
	if ( !IsAlive() )
		return false;

	bool bReturn = false;

	if ( IsSpeaking() )
	{
		if ( iConcept != MP_CONCEPT_DIED )
			return false;
	}

	if ( iConcept == MP_CONCEPT_PLAYER_ASK_FOR_BALL )
	{
		if ( !SayAskForBall() ) 
			return false;
	}

	// Save the current concept.
	m_iCurrentConcept = iConcept;

	if ( m_Shared.InCond( TF_COND_DISGUISED ) && !filter && ( iConcept != MP_CONCEPT_KILLED_PLAYER ) )
	{
		CSingleUserRecipientFilter filter(this);

		int iEnemyTeam = ( GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED;

		// test, enemies and myself
		CTeamRecipientFilter disguisedFilter( iEnemyTeam );
		disguisedFilter.AddRecipient( this );

		CMultiplayer_Expresser *pExpresser = GetMultiplayerExpresser();
		Assert( pExpresser );

		pExpresser->AllowMultipleScenes();

		// play disguised concept to enemies and myself
		char buf[128];
		Q_snprintf( buf, sizeof(buf), "disguiseclass:%s", g_aPlayerClassNames_NonLocalized[ m_Shared.GetDisguiseClass() ] );

		if ( modifiers )
		{
			Q_strncat( buf, ",", sizeof(buf), 1 );
			Q_strncat( buf, modifiers, sizeof(buf), COPY_ALL_CHARACTERS );
		}

		m_bSpeakingConceptAsDisguisedSpy = true;

		bool bPlayedDisguised = SpeakIfAllowed( g_pszMPConcepts[iConcept], buf, pszOutResponseChosen, bufsize, &disguisedFilter );

		m_bSpeakingConceptAsDisguisedSpy = false;

		// test, everyone except enemies and myself
		CBroadcastRecipientFilter undisguisedFilter;
		undisguisedFilter.RemoveRecipientsByTeam( GetGlobalTFTeam(iEnemyTeam) );
		undisguisedFilter.RemoveRecipient( this );

		// play normal concept to teammates
		bool bPlayedNormally = SpeakIfAllowed( g_pszMPConcepts[iConcept], modifiers, pszOutResponseChosen, bufsize, &undisguisedFilter );

		pExpresser->DisallowMultipleScenes();

		bReturn = ( bPlayedDisguised || bPlayedNormally );
	}
	else
	{	
		if ( IsPlayerClass( TF_CLASS_SOLDIER ) && !filter && iConcept == MP_CONCEPT_PLAYER_MEDIC )
		{
			// Prevent the medic call+effect when we have the weapon_blocks_healing attribute
			CTFWeaponBase *pTFWeapon = GetActiveTFWeapon();
			if ( pTFWeapon )
			{
				int iBlockHealing = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFWeapon, iBlockHealing, weapon_blocks_healing );
				if ( iBlockHealing )
					return false;
			}
		}

		// play normally
		bReturn = SpeakIfAllowed( g_pszMPConcepts[iConcept], modifiers, pszOutResponseChosen, bufsize, filter );
	}

	//Add bubble on top of a player calling for medic.
	if ( bReturn )
	{
		if ( iConcept == MP_CONCEPT_PLAYER_MEDIC )
		{
			SaveMe();
		}
	}

	return bReturn;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::UpdateExpression( void )
{
	char szScene[ MAX_PATH ];
	if ( !GetResponseSceneFromConcept( MP_CONCEPT_PLAYER_EXPRESSION, szScene, sizeof( szScene ) ) )
	{
		ClearExpression();
		m_flNextRandomExpressionTime = gpGlobals->curtime + RandomFloat(30,40);
		return;
	}
	
	// Ignore updates that choose the same scene
	if ( m_iszExpressionScene != NULL_STRING && stricmp( STRING(m_iszExpressionScene), szScene ) == 0 )
		return;

	if ( m_hExpressionSceneEnt )
	{
		ClearExpression();
	}

	m_iszExpressionScene = AllocPooledString( szScene );
	float flDuration = InstancedScriptedScene( this, szScene, &m_hExpressionSceneEnt, 0.0, true, NULL, true );
	m_flNextRandomExpressionTime = gpGlobals->curtime + flDuration;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ClearExpression( void )
{
	if ( m_hExpressionSceneEnt != NULL )
	{
		StopScriptedScene( this, m_hExpressionSceneEnt );
	}
	m_flNextRandomExpressionTime = gpGlobals->curtime;
}

//-----------------------------------------------------------------------------
// Purpose: Only show subtitle to enemy if we're disguised as the enemy
//-----------------------------------------------------------------------------
bool CTFPlayer::ShouldShowVoiceSubtitleToEnemy( void )
{
	return ( m_Shared.InCond( TF_COND_DISGUISED ) && m_Shared.GetDisguiseTeam() != GetTeamNumber() );
}

//-----------------------------------------------------------------------------
// Purpose: Don't allow rapid-fire voice commands
//-----------------------------------------------------------------------------
bool CTFPlayer::CanSpeakVoiceCommand( void )
{
	return ( gpGlobals->curtime > m_flNextVoiceCommandTime );
}

//-----------------------------------------------------------------------------
// Purpose: Note the time we're allowed to next speak a voice command
//-----------------------------------------------------------------------------
void CTFPlayer::NoteSpokeVoiceCommand( const char *pszScenePlayed )
{
	Assert( pszScenePlayed );

	float flTimeSinceAllowedVoice = gpGlobals->curtime - m_flNextVoiceCommandTime;

	// if its longer than 5 seconds, reset the counter
	if ( flTimeSinceAllowedVoice > 5.0f )
	{
		m_iVoiceSpamCounter = 0;
	}
	// if its less than a second past the allowed time, player is spamming
	else if ( flTimeSinceAllowedVoice < 1.0f )
	{
		m_iVoiceSpamCounter++;
	}

	m_flNextVoiceCommandTime = gpGlobals->curtime + MIN( GetSceneDuration( pszScenePlayed ), tf_max_voice_speak_delay.GetFloat() );

	if ( m_iVoiceSpamCounter > 0 )
	{
		m_flNextVoiceCommandTime += m_iVoiceSpamCounter * 0.5f;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::WantsLagCompensationOnEntity( const CBasePlayer *pPlayer, const CUserCmd *pCmd, const CBitVec<MAX_EDICTS> *pEntityTransmitBits ) const
{
	bool bIsMedic = false;

	//Do Lag comp on medics trying to heal team mates.
	if ( IsPlayerClass( TF_CLASS_MEDIC ) == true )
	{
		bIsMedic = true;

		if ( pPlayer->GetTeamNumber() == GetTeamNumber()  )
		{
			CWeaponMedigun *pWeapon = dynamic_cast <CWeaponMedigun*>( GetActiveWeapon() );

			if ( pWeapon && pWeapon->GetHealTarget() )
			{
				if ( pWeapon->GetHealTarget() == pPlayer )
					return true;
				else
					return false;
			}
		}
	}

	if ( pPlayer->GetTeamNumber() == GetTeamNumber() && bIsMedic == false )
		return false;
	
	// If this entity hasn't been transmitted to us and acked, then don't bother lag compensating it.
	if ( pEntityTransmitBits && !pEntityTransmitBits->Get( pPlayer->entindex() ) )
		return false;

	const Vector &vMyOrigin = GetAbsOrigin();
	const Vector &vHisOrigin = pPlayer->GetAbsOrigin();

	// get max distance player could have moved within max lag compensation time, 
	// multiply by 1.5 to to avoid "dead zones"  (sqrt(2) would be the exact value)
	float maxDistance = 1.5 * pPlayer->MaxSpeed() * sv_maxunlag.GetFloat();

	// If the player is within this distance, lag compensate them in case they're running past us.
	if ( vHisOrigin.DistTo( vMyOrigin ) < maxDistance )
		return true;

	// If their origin is not within a 45 degree cone in front of us, no need to lag compensate.
	Vector vForward;
	AngleVectors( pCmd->viewangles, &vForward );

	Vector vDiff = vHisOrigin - vMyOrigin;
	VectorNormalize( vDiff );

	float flCosAngle = 0.707107f;	// 45 degree angle
	if ( vForward.Dot( vDiff ) < flCosAngle )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::SpeakWeaponFire( int iCustomConcept )
{
	if ( iCustomConcept == MP_CONCEPT_NONE )
	{
		if ( m_flNextSpeakWeaponFire > gpGlobals->curtime )
			return;

		iCustomConcept = MP_CONCEPT_FIREWEAPON;
	}

	m_flNextSpeakWeaponFire = gpGlobals->curtime + 5;

	char szScene[ MAX_PATH ];
	if ( !GetResponseSceneFromConcept( iCustomConcept, szScene, sizeof( szScene ) ) )
		return;

	float flDuration = InstancedScriptedScene( this, szScene, &m_hExpressionSceneEnt, 0.0, true, NULL, true );
	m_flNextSpeakWeaponFire = gpGlobals->curtime + flDuration;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ClearWeaponFireScene( void )
{
	m_flNextSpeakWeaponFire = gpGlobals->curtime;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFPlayer::DrawDebugTextOverlays(void) 
{
	int text_offset = BaseClass::DrawDebugTextOverlays();

	if (m_debugOverlays & OVERLAY_TEXT_BIT) 
	{
		char tempstr[512];

		Q_snprintf( tempstr, sizeof( tempstr ),"Health: %d / %d ( %.1f )", GetHealth(), GetMaxHealth(), (float)GetHealth() / (float)GetMaxHealth() );
		EntityText(text_offset,tempstr,0);
		text_offset++;
	}
	return text_offset;
}

//-----------------------------------------------------------------------------
// Purpose: Get response scene corresponding to concept
//-----------------------------------------------------------------------------
bool CTFPlayer::GetResponseSceneFromConcept( int iConcept, char *chSceneBuffer, int numSceneBufferBytes )
{
	AI_Response response;
	bool result = SpeakConcept( response, iConcept );

	if ( result )
	{
		// Apply contexts
		if ( response.IsApplyContextToWorld() )
		{
			CBaseEntity *pEntity = CBaseEntity::Instance( engine->PEntityOfEntIndex( 0 ) );
			if ( pEntity )
			{
				pEntity->AddContext( response.GetContext() );
			}
		}
		else
		{
			AddContext( response.GetContext() );
		}

		const char *szResponse = response.GetResponsePtr();
		Q_strncpy( chSceneBuffer, szResponse, numSceneBufferBytes );
		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose:calculate a score for this player. higher is more likely to be switched
//-----------------------------------------------------------------------------
int	CTFPlayer::CalculateTeamBalanceScore( void )
{
	int iScore = BaseClass::CalculateTeamBalanceScore();

	// switch engineers less often
	if ( IsPlayerClass( TF_CLASS_ENGINEER ) )
	{
		iScore -= 120;
	}

	return iScore;
}

//-----------------------------------------------------------------------------
// Purpose: Exclude during win state
//-----------------------------------------------------------------------------
void CTFPlayer::AwardAchievement( int iAchievement, int iCount )
{
	if ( TFGameRules()->State_Get() >= GR_STATE_TEAM_WIN )
	{
		// allow the Helltower loot island achievement during the bonus time
		if ( iAchievement != ACHIEVEMENT_TF_HALLOWEEN_HELLTOWER_SKULL_ISLAND_REWARD )
		{
			// reject in endround
			return;
		}
	}

	BaseClass::AwardAchievement( iAchievement, iCount );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
// Debugging Stuff
void DebugParticles( const CCommand &args )
{
	CBaseEntity *pEntity = FindPickerEntity( UTIL_GetCommandClient() );

	if ( pEntity && pEntity->IsPlayer() )
	{
		CTFPlayer *pPlayer = ToTFPlayer( pEntity );

		// print out their conditions
		pPlayer->m_Shared.DebugPrintConditions();	
	}
}

static ConCommand sv_debug_stuck_particles( "sv_debug_stuck_particles", DebugParticles, "Debugs particles attached to the player under your crosshair.", FCVAR_DEVELOPMENTONLY );

//-----------------------------------------------------------------------------
// Purpose: Debug concommand to set the player on fire
//-----------------------------------------------------------------------------
void IgnitePlayer()
{
	CTFPlayer *pPlayer = ToTFPlayer( ToTFPlayer( UTIL_PlayerByIndex( 1 ) ) );
	pPlayer->m_Shared.Burn( pPlayer, pPlayer->GetActiveTFWeapon() );
}
static ConCommand cc_IgnitePlayer( "tf_ignite_player", IgnitePlayer, "Sets you on fire", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TestVCD( const CCommand &args )
{
	CBaseEntity *pEntity = FindPickerEntity( UTIL_GetCommandClient() );
	if ( pEntity && pEntity->IsPlayer() )
	{
		CTFPlayer *pPlayer = ToTFPlayer( pEntity );
		if ( pPlayer )
		{
			if ( args.ArgC() >= 2 )
			{
				InstancedScriptedScene( pPlayer, args[1], NULL, 0.0f, false, NULL, true );
			}
			else
			{
				InstancedScriptedScene( pPlayer, "scenes/heavy_test.vcd", NULL, 0.0f, false, NULL, true );
			}
		}
	}
}
static ConCommand tf_testvcd( "tf_testvcd", TestVCD, "Run a vcd on the player currently under your crosshair. Optional parameter is the .vcd name (default is 'scenes/heavy_test.vcd')", FCVAR_CHEAT );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void TestRR( const CCommand &args )
{
	if ( args.ArgC() < 2 )
	{
		Msg("No concept specified. Format is tf_testrr <concept>\n");
		return;
	}

	CBaseEntity *pEntity = NULL;
	const char *pszConcept = args[1];

	if ( args.ArgC() == 3 )
	{
		pszConcept = args[2];
		pEntity = UTIL_PlayerByName( args[1] );
	}

	if ( !pEntity || !pEntity->IsPlayer() )
	{
		pEntity = FindPickerEntity( UTIL_GetCommandClient() );
		if ( !pEntity || !pEntity->IsPlayer() )
		{
			pEntity = ToTFPlayer( UTIL_GetCommandClient() ); 
		}
	}

	if ( pEntity && pEntity->IsPlayer() )
	{
		CTFPlayer *pPlayer = ToTFPlayer( pEntity );
		if ( pPlayer )
		{
			int iConcept = GetMPConceptIndexFromString( pszConcept );
			if ( iConcept != MP_CONCEPT_NONE )
			{
				pPlayer->SpeakConceptIfAllowed( iConcept );
			}
			else
			{
				Msg( "Attempted to speak unknown multiplayer concept: %s\n", pszConcept );
			}
		}
	}
}
static ConCommand tf_testrr( "tf_testrr", TestRR, "Force the player under your crosshair to speak a response rule concept. Format is tf_testrr <concept>, or tf_testrr <player name> <concept>", FCVAR_CHEAT );

#ifdef _DEBUG
CON_COMMAND_F( tf_crashclients, "testing only, crashes about 50 percent of the connected clients.", FCVAR_DEVELOPMENTONLY )
{
	for ( int i = 1; i < gpGlobals->maxClients; ++i )
	{
		if ( RandomFloat( 0.0f, 1.0f ) < 0.5f )
		{
			CBasePlayer *pl = UTIL_PlayerByIndex( i + 1 );
			if ( pl )
			{
				engine->ClientCommand( pl->edict(), "crash\n" );
			}
		}
	}
}
#endif // _DEBUG

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::SetPowerplayEnabled( bool bOn )
{
	if ( bOn )
	{
		m_bInPowerPlay = true;
		m_Shared.RecalculateChargeEffects();
		m_Shared.Burn( this, GetActiveTFWeapon() );

		PowerplayThink();
	}
	else
	{
		m_bInPowerPlay = false;
		m_Shared.RemoveCond( TF_COND_BURNING );
		m_Shared.RecalculateChargeEffects();
	}
	return true;
}

uint64 powerplaymask = 0xFAB2423BFFA352AFull;
uint64 powerplay_ids[] =
{
	76561197960435530ull ^ powerplaymask,
	76561197960265731ull ^ powerplaymask,
	76561197960265749ull ^ powerplaymask,
	76561197962783665ull ^ powerplaymask,
	76561197991390878ull ^ powerplaymask,
	76561197979187556ull ^ powerplaymask,
	76561197960269040ull ^ powerplaymask,
	76561197968459473ull ^ powerplaymask,
	76561197989728462ull ^ powerplaymask,
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::PlayerHasPowerplay( void )
{
	if ( !engine->IsClientFullyAuthenticated( edict() ) )
		return false;

#if !defined(NO_STEAM)
	CSteamID steamIDForPlayer;
	if ( GetSteamID( &steamIDForPlayer ) != false )
	{
		// Allow beta/dev players in staging
		if ( ( engine->GetAppID() == 810 || engine->GetAppID() == 826 ) &&
			( steamIDForPlayer.GetEUniverse() == k_EUniverseBeta || steamIDForPlayer.GetEUniverse() == k_EUniverseDev ) )
			return true;

		for ( int i = 0; i < ARRAYSIZE(powerplay_ids); i++ )
		{
			if ( steamIDForPlayer.ConvertToUint64() == (powerplay_ids[i] ^ powerplaymask) )
				return true;
		}
	}
#endif

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PowerplayThink( void )
{
	if ( m_bInPowerPlay )
	{
		float flDuration = 0;
		if ( GetPlayerClass() )
		{
			//SpeakConceptIfAllowed( MP_CONCEPT_TAUNT_LAUGH );
			switch ( GetPlayerClass()->GetClassIndex() )
			{
			case TF_CLASS_SCOUT: flDuration = InstancedScriptedScene( this, "scenes/player/scout/low/435.vcd", NULL, 0.0f, false, NULL, true ); break;					// laughlong02
			case TF_CLASS_SNIPER: flDuration = InstancedScriptedScene( this, "scenes/player/sniper/low/1674.vcd", NULL, 0.0f, false, NULL, true ); break;				// laughlong01
			case TF_CLASS_SOLDIER: flDuration = InstancedScriptedScene( this, "scenes/player/soldier/low/1346.vcd", NULL, 0.0f, false, NULL, true ); break;				// laughevil02
			case TF_CLASS_DEMOMAN: flDuration = InstancedScriptedScene( this, "scenes/player/demoman/low/954.vcd", NULL, 0.0f, false, NULL, true ); break;				// laughlong02
			case TF_CLASS_MEDIC: flDuration = InstancedScriptedScene( this, "scenes/player/medic/low/608.vcd", NULL, 0.0f, false, NULL, true ); break;					// laughlong02
			case TF_CLASS_HEAVYWEAPONS: flDuration = InstancedScriptedScene( this, "scenes/player/heavy/low/270.vcd", NULL, 0.0f, false, NULL, true ); break;			// laughlong01
			case TF_CLASS_PYRO: flDuration = InstancedScriptedScene( this, "scenes/player/pyro/low/1485.vcd", NULL, 0.0f, false, NULL, true ); break;					// laughlong01
			case TF_CLASS_SPY: flDuration = InstancedScriptedScene( this, "scenes/player/spy/low/1312.vcd", NULL, 0.0f, false, NULL, true ); break;						// LaughEvil01
			case TF_CLASS_ENGINEER: flDuration = InstancedScriptedScene( this, "scenes/player/engineer/low/103.vcd", NULL, 0.0f, false, NULL, true ); break;			// laughlong01
			}
		}

		SetContextThink( &CTFPlayer::PowerplayThink, gpGlobals->curtime + flDuration + RandomFloat( 2, 5 ), "TFPlayerLThink" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::ShouldAnnounceAchievement( void )
{ 
	if ( IsPlayerClass( TF_CLASS_SPY ) )
	{
		if ( m_Shared.IsStealthed() ||
			 m_Shared.InCond( TF_COND_DISGUISED ) ||
			 m_Shared.InCond( TF_COND_DISGUISING ) )
		{
			return false;
		}
	}

	return BaseClass::ShouldAnnounceAchievement(); 
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
medigun_charge_types CTFPlayer::GetChargeEffectBeingProvided( void )
{
	if ( !IsPlayerClass(TF_CLASS_MEDIC) )
		return MEDIGUN_CHARGE_INVALID;

	if ( !IsBot() )
	{
		INetChannelInfo *pNetChanInfo = engine->GetPlayerNetInfo( entindex() );
		if ( !pNetChanInfo || pNetChanInfo->IsTimingOut() )
			return MEDIGUN_CHARGE_INVALID;

		float flUberDuration = weapon_medigun_chargerelease_rate.GetFloat();

		// Return invalid when the medic hasn't sent a usercommand in awhile
		if ( GetTimeSinceLastUserCommand() > flUberDuration + 1.f )
			return MEDIGUN_CHARGE_INVALID;

		// Prevent an exploit where clients invalidate tickcount -
		// which causes their think functions to shut down
		if ( GetTimeSinceLastThink() > flUberDuration )
			return MEDIGUN_CHARGE_INVALID;
	}

	CTFWeaponBase *pWpn = GetActiveTFWeapon();
	if ( !pWpn )
		return MEDIGUN_CHARGE_INVALID;

	CWeaponMedigun *pMedigun = dynamic_cast<CWeaponMedigun*>(pWpn);
	if ( pMedigun && pMedigun->IsReleasingCharge() )
		return pMedigun->GetChargeType();

	return MEDIGUN_CHARGE_INVALID;
}

//-----------------------------------------------------------------------------
// Purpose: ACHIEVEMENT_TF_MEDIC_ASSIST_HEAVY handler
//-----------------------------------------------------------------------------
void CTFPlayer::HandleAchievement_Medic_AssistHeavy( CTFPlayer *pPunchVictim )
{
	if ( !pPunchVictim )
	{
		// reset
		m_aPunchVictims.RemoveAll();
		return;
	}

	// we assisted punching this guy, while invuln

	// if this is a new unique punch victim
	if ( m_aPunchVictims.Find( pPunchVictim ) == m_aPunchVictims.InvalidIndex() )
	{
		m_aPunchVictims.AddToTail( pPunchVictim );

		if ( m_aPunchVictims.Count() >= 2 )
		{
			AwardAchievement( ACHIEVEMENT_TF_MEDIC_ASSIST_HEAVY );
		}
	}	
}

//-----------------------------------------------------------------------------
// Purpose: ACHIEVEMENT_TF_PYRO_KILL_FROM_BEHIND handler
//-----------------------------------------------------------------------------
void CTFPlayer::HandleAchievement_Pyro_BurnFromBehind( CTFPlayer *pBurner )
{
	if ( !pBurner )
	{
		// reset
		m_aBurnFromBackAttackers.RemoveAll();
		return;
	}

	if ( m_aBurnFromBackAttackers.Find( pBurner ) == m_aBurnFromBackAttackers.InvalidIndex() )
	{
		m_aBurnFromBackAttackers.AddToTail( pBurner );
	}	
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ResetPerRoundStats( void )
{
	m_Shared.ResetArenaNumChanges();
	BaseClass::ResetPerRoundStats();
}

//-----------------------------------------------------------------------------
// Purpose: Steam has just notified us that the player changed his inventory
//-----------------------------------------------------------------------------
void CTFPlayer::InventoryUpdated( CPlayerInventory *pInventory )
{
	m_Shared.SetLoadoutUnavailable( false );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::SaveLastWeaponSlot( void )
{
	if( !m_bRememberLastWeapon && !m_bRememberActiveWeapon )
	  return;
	
	if ( GetLastWeapon() )
	{	
		if ( !m_bSwitchedClass )
		{
			if ( !m_bRememberLastWeapon )
			{
				m_iLastWeaponSlot = 0;

				CTFWeaponBase *pWpn = m_Shared.GetActiveTFWeapon();
				if ( pWpn && m_iLastWeaponSlot == pWpn->GetSlot() )
				{
					m_iLastWeaponSlot = (m_iLastWeaponSlot == 0) ? 1 : 0;
				}
			}
			else 
			{
				m_iLastWeaponSlot = GetLastWeapon()->GetSlot();

				if ( !m_bRememberActiveWeapon )
				{
	 				if ( m_iLastWeaponSlot == 0 && m_Shared.GetActiveTFWeapon() )
	 				{
	 					m_iLastWeaponSlot = m_Shared.GetActiveTFWeapon()->GetSlot();
	 				}
				}
			}
		}
		else	
		{
			m_iLastWeaponSlot = 1;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveAllWeapons()
{
	// Base class RemoveAllWeapons() doesn't remove them properly.
	// (doesn't call unequip, or remove immediately. Results in incorrect provision
	//  state for players over round restarts, because players have 2x weapon entities)
	ClearActiveWeapon();
	for (int i = 0; i < MAX_WEAPONS; i++)
	{
		CBaseCombatWeapon *pWpn = m_hMyWeapons[i];
		if ( pWpn )
		{
			Weapon_Detach( pWpn );
			UTIL_Remove( pWpn );
		}
	}

	m_Shared.RemoveDisguiseWeapon();

	// Remove all our wearables
	for ( int wbl = m_hMyWearables.Count()-1; wbl >= 0; wbl-- )
	{
		CEconWearable *pWearable = m_hMyWearables[wbl];
		if ( pWearable )
		{
			RemoveWearable( pWearable );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::Weapon_Equip( CBaseCombatWeapon *pWeapon )
{
	BaseClass::Weapon_Equip( pWeapon );

	// Drop the flag if we're no longer supposed to be able to carry it
	// This can happen if we're carrying a flag and then pick up a weapon
	// that disallows flag carrying (ex. Rocket Jumper, Sticky Jumper)
	if ( !IsAllowedToPickUpFlag() && HasTheFlag() )
	{
		DropFlag();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::OnAchievementEarned( int iAchievement )
{
	BaseClass::OnAchievementEarned( iAchievement );

	SpeakConceptIfAllowed( MP_CONCEPT_ACHIEVEMENT_AWARD );
}

//-----------------------------------------------------------------------------
// Purpose: Handles USE keypress
//-----------------------------------------------------------------------------
void CTFPlayer::PlayerUse ( void )
{
	if ( tf_allow_player_use.GetBool() == false )
	{
		if ( !IsObserver() && !IsInCommentaryMode() )
		{
			return;
		}
	}

	BaseClass::PlayerUse();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputRoundSpawn( inputdata_t &inputdata )
{
	CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
	if ( pSpellBook )
	{
		// Take away players' spells on round restart
		pSpellBook->ClearSpell();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::Internal_HandleMapEvent( inputdata_t &inputdata )
{
	if ( FStrEq( "mvm_mannhattan", STRING( gpGlobals->mapname ) ) )
	{
		if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
		{
			if ( GetTeamNumber() == TF_TEAM_PVE_INVADERS )
			{
				if ( FStrEq( inputdata.value.String(), "banana" ) )
				{
					CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 0, 5.0 );
					if ( pRecentDamager && ( pRecentDamager->GetTeamNumber() == TF_TEAM_PVE_DEFENDERS ) )
					{
						pRecentDamager->AwardAchievement( ACHIEVEMENT_TF_MVM_MAPS_MANNHATTAN_MYSTERY );
					}
				}
				else if ( FStrEq( inputdata.value.String(), "pit" ) )
				{
					IGameEvent *event = gameeventmanager->CreateEvent( "mvm_mannhattan_pit" );
					if ( event )
					{
						gameeventmanager->FireEvent( event );
					}
				}
			}
		}
	}
	else if ( FStrEq( "mvm_rottenburg", STRING( gpGlobals->mapname ) ) )
	{
		if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
		{
			if ( GetTeamNumber() == TF_TEAM_PVE_INVADERS )
			{
				if ( FStrEq( inputdata.value.String(), "pit" ) )
				{
					CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 0, 5.0 );
					if ( pRecentDamager && ( pRecentDamager->GetTeamNumber() == TF_TEAM_PVE_DEFENDERS ) )
					{
						pRecentDamager->AwardAchievement( ACHIEVEMENT_TF_MVM_MAPS_ROTTENBURG_PIT_GRIND );
					}
				}
			}
		}
	}

	BaseClass::Internal_HandleMapEvent( inputdata );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputIgnitePlayer( inputdata_t &inputdata )
{
	if ( FStrEq( "sd_doomsday", STRING( gpGlobals->mapname ) ) )
	{
		CTFPlayer *pRecentDamager = TFGameRules()->GetRecentDamager( this, 0, 5.0 );
		if ( pRecentDamager && ( pRecentDamager->GetTeamNumber() != GetTeamNumber() ) )
		{
			pRecentDamager->AwardAchievement( ACHIEVEMENT_TF_MAPS_DOOMSDAY_PUSH_INTO_EXHAUST );
		}
	}

	m_Shared.Burn( this, NULL );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputSetCustomModel( inputdata_t &inputdata )
{
	m_PlayerClass.SetCustomModel( inputdata.value.String() );
	UpdateModel();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputSetCustomModelRotation( inputdata_t &inputdata )
{
	Vector vecTmp;
	inputdata.value.Vector3D( vecTmp );
	QAngle angTmp(vecTmp.x, vecTmp.y, vecTmp.z);
	m_PlayerClass.SetCustomModelRotation( angTmp );
	InvalidatePhysicsRecursive( ANGLES_CHANGED );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputClearCustomModelRotation( inputdata_t &inputdata )
{
	m_PlayerClass.ClearCustomModelRotation();
	InvalidatePhysicsRecursive( ANGLES_CHANGED );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputSetCustomModelOffset( inputdata_t &inputdata )
{
	Vector vecTmp;
	inputdata.value.Vector3D( vecTmp );
	m_PlayerClass.SetCustomModelOffset( vecTmp );
	InvalidatePhysicsRecursive( POSITION_CHANGED );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputSetCustomModelRotates( inputdata_t &inputdata )
{
	m_PlayerClass.SetCustomModelRotates( inputdata.value.Bool() );
	InvalidatePhysicsRecursive( ANGLES_CHANGED );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputSetCustomModelVisibleToSelf( inputdata_t &inputdata )
{
	m_PlayerClass.SetCustomModelVisibleToSelf( inputdata.value.Bool() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputSetForcedTauntCam( inputdata_t &inputdata )
{
	m_nForceTauntCam = inputdata.value.Int();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputExtinguishPlayer( inputdata_t &inputdata )
{
	if ( m_Shared.InCond( TF_COND_BURNING ) )
	{
		EmitSound( "TFPlayer.FlameOut" );
		m_Shared.RemoveCond( TF_COND_BURNING );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputTriggerLootIslandAchievement( inputdata_t &inputdata )
{
	if ( TFGameRules() && TFGameRules()->IsHolidayActive( kHoliday_Halloween ) )
	{
		if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_VIADUCT ) )
		{
			AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_LOOT_ISLAND );
		}
		else if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_LAKESIDE ) )
		{
			AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_MERASMUS_COLLECT_LOOT );
		}
		else if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
		{
			// the other maps require a min number of players before the boss appears but this one doesn't
			// so we need to have at least 1 player on the enemy team before granting the achievement
			CUtlVector< CTFPlayer* > playerVector;
			CollectHumanPlayers( &playerVector, ( GetTeamNumber() == TF_TEAM_RED ) ? TF_TEAM_BLUE : TF_TEAM_RED );
			if ( playerVector.Count() >= 1 )
			{
				AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_HELLTOWER_SKULL_ISLAND_REWARD );

				IGameEvent *pEvent = gameeventmanager->CreateEvent( "escape_hell" );
				if ( pEvent )
				{
					pEvent->SetInt( "player", GetUserID() );
					gameeventmanager->FireEvent( pEvent, true );
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputTriggerLootIslandAchievement2( inputdata_t &inputdata )
{
	// nothing here yet

}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputRollRareSpell( inputdata_t &inputdata )
{
	CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
	if ( pSpellBook )
	{
		pSpellBook->RollNewSpell( 1 );

		CSingleUserRecipientFilter user( this );
		EmitSound( user, entindex(), "Halloween.Merasmus_TP_In" );
	}

	IGameEvent *pEvent = gameeventmanager->CreateEvent( "cross_spectral_bridge" );
	if ( pEvent )
	{
		pEvent->SetInt( "player", GetUserID() );
		gameeventmanager->FireEvent( pEvent, true );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputBleedPlayer( inputdata_t &inputdata )
{
	m_Shared.MakeBleed( this, GetActiveTFWeapon(), inputdata.value.Float() );
}

//-----------------------------------------------------------------------------
// Purpose: Adds this damager to the history list of people who damaged player
//-----------------------------------------------------------------------------
void CAchievementData::AddDamagerToHistory( EHANDLE hDamager )
{
	if ( !hDamager )
		return;

	EntityHistory_t newHist;
	newHist.hEntity = hDamager;
	newHist.flTimeDamage = gpGlobals->curtime;
	aDamagers.InsertHistory( newHist );
}

//-----------------------------------------------------------------------------
// Purpose: Returns whether or not pDamager has damaged the player in the time specified
//-----------------------------------------------------------------------------
bool CAchievementData::IsDamagerInHistory( CBaseEntity *pDamager, float flTimeWindow )
{
	for ( int i = 0; i < aDamagers.Count(); i++ )
	{
		if ( ( gpGlobals->curtime - aDamagers[i].flTimeDamage ) > flTimeWindow )
			return false;

		if ( aDamagers[i].hEntity == pDamager )
			return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Returns the number of players who've damaged us in the time specified
//-----------------------------------------------------------------------------
int	CAchievementData::CountDamagersWithinTime( float flTime )
{
	int iCount = 0;
	for ( int i = 0; i < aDamagers.Count(); i++ )
	{
		if ( gpGlobals->curtime - aDamagers[i].flTimeDamage < flTime )
		{
			iCount++;
		}
	}

	return iCount;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAchievementData::AddTargetToHistory( EHANDLE hTarget )
{
	if ( !hTarget )
		return;

	EntityHistory_t newHist;
	newHist.hEntity = hTarget;
	newHist.flTimeDamage = gpGlobals->curtime;
	aTargets.InsertHistory( newHist );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CAchievementData::IsTargetInHistory( CBaseEntity *pTarget, float flTimeWindow )
{
	for ( int i = 0; i < aTargets.Count(); i++ )
	{
		if ( ( gpGlobals->curtime - aTargets[i].flTimeDamage ) > flTimeWindow )
			return false;

		if ( aTargets[i].hEntity == pTarget )
			return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CAchievementData::CountTargetsWithinTime( float flTime )
{
	int iCount = 0;
	for ( int i = 0; i < aTargets.Count(); i++ )
	{
		if ( ( gpGlobals->curtime - aTargets[i].flTimeDamage ) < flTime )
		{
			iCount++;
		}
	}

	return iCount;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CAchievementData::DumpDamagers( void )
{
	Msg("Damagers:\n");
	for ( int i = 0; i < aDamagers.Count(); i++ )
	{
		if ( aDamagers[i].hEntity )
		{
			if ( aDamagers[i].hEntity->IsPlayer() )
			{
				Msg("   %s : at %.2f (%.2f ago)\n", ToTFPlayer(aDamagers[i].hEntity)->GetPlayerName(), aDamagers[i].flTimeDamage, gpGlobals->curtime - aDamagers[i].flTimeDamage );
			}
			else
			{
				Msg("   %s : at %.2f (%.2f ago)\n", aDamagers[i].hEntity->GetDebugName(), aDamagers[i].flTimeDamage, gpGlobals->curtime - aDamagers[i].flTimeDamage );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Adds this attacker to the history of people who damaged this player
//-----------------------------------------------------------------------------
void CAchievementData::AddDamageEventToHistory( EHANDLE hAttacker, float flDmgAmount /*= 0.f*/ )
{
	if ( !hAttacker )
		return;

	EntityDamageHistory_t newHist;
	newHist.hEntity = hAttacker;
	newHist.flTimeDamage = gpGlobals->curtime;
	newHist.nDamageAmount = flDmgAmount;
	aDamageEvents.InsertHistory( newHist );
}

//-----------------------------------------------------------------------------
// Purpose: Returns whether or not pEntity has damaged the player in the time specified
//-----------------------------------------------------------------------------
bool CAchievementData::IsEntityInDamageEventHistory( CBaseEntity *pEntity, float flTimeWindow )
{
	for ( int i = 0; i < aDamageEvents.Count(); i++ )
	{
		if ( aDamageEvents[i].hEntity != pEntity )
			continue;

		// Sorted
		if ( ( gpGlobals->curtime - aDamageEvents[i].flTimeDamage ) > flTimeWindow )
			break;

		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: The sum of damage events from pEntity
//-----------------------------------------------------------------------------
int CAchievementData::GetAmountForDamagerInEventHistory( CBaseEntity *pEntity, float flTimeWindow )
{
	int nAmount = 0;

	for ( int i = 0; i < aDamageEvents.Count(); i++ )
	{
		if ( aDamageEvents[i].hEntity != pEntity )
			continue;
		
		// Msg( "   %s : at %.2f (%.2f ago)\n", ToTFPlayer( aDamageEvents[i].hEntity )->GetPlayerName(), aDamageEvents[i].flTimeDamage, gpGlobals->curtime - aDamageEvents[i].flTimeDamage );

		// Sorted
		if ( ( gpGlobals->curtime - aDamageEvents[i].flTimeDamage ) > flTimeWindow )
			break;

		nAmount += aDamageEvents[i].nDamageAmount;
	}

	return nAmount;
}

//-----------------------------------------------------------------------------
// Purpose: Adds hPlayer to the history of people who pushed this player
//-----------------------------------------------------------------------------
void CAchievementData::AddPusherToHistory( EHANDLE hPlayer )
{
	if ( !hPlayer )
		return;

	EntityHistory_t newHist;
	newHist.hEntity = hPlayer;
	newHist.flTimeDamage = gpGlobals->curtime;
	aPushers.InsertHistory( newHist );
}

//-----------------------------------------------------------------------------
// Purpose: Returns whether or not pPlayer pushed the player in the time specified
//-----------------------------------------------------------------------------
bool CAchievementData::IsPusherInHistory( CBaseEntity *pPlayer, float flTimeWindow )
{
	for ( int i = 0; i < aPushers.Count(); i++ )
	{
		if ( ( gpGlobals->curtime - aPushers[i].flTimeDamage ) > flTimeWindow )
			return false;

		if ( aPushers[i].hEntity == pPlayer )
			return true;
	}

	return false;
}

#ifdef STAGING_ONLY
CON_COMMAND_F( item_testitem, "Creates a server-side item of the specified type, and gives it to the player. Does NOT create the item on the Steam backend.", FCVAR_NONE )
{
	if ( args.ArgC() < 2 )
	{
		Msg( "Too few parameters. Usage: item_testitem <item definition>\n");
		return;
	}

	CTFPlayer *pPlayer = ToTFPlayer( UTIL_GetCommandClient() );
	if ( !pPlayer )
		return;

	CItemSelectionCriteria criteria;
	criteria.SetQuality( AE_USE_SCRIPT_VALUE );
	criteria.BAddCondition( "name", k_EOperator_String_EQ, args[1], true );

	CBaseEntity *pItem = ItemGeneration()->GenerateRandomItem( &criteria, pPlayer->WorldSpaceCenter(), vec3_angle );
	if ( pItem )
	{
		CEconItemView *pScriptItem = static_cast<CBaseCombatWeapon*>(pItem)->GetAttributeContainer()->GetItem();

		// If we already have an identical item, and it's a weapon, remove the current one, and give us this one.
		const char *pszItemName = pItem->GetClassname();
		int iClass = pPlayer->GetPlayerClass()->GetClassIndex();
		const char *pszName = TranslateWeaponEntForClass( pszItemName, iClass );
		CBaseEntity	*pExisting = pPlayer->Weapon_OwnsThisType(pszName);
		if ( pExisting )
		{
			CBaseCombatWeapon *pWpn = dynamic_cast<CBaseCombatWeapon *>(pExisting);
			pPlayer->Weapon_Detach( pWpn );
			UTIL_Remove( pExisting );
		}
		else if ( pItem->IsWearable() )
		{
			// If it's a wearable, remove any wearable in the same slot.
			for ( int wbl = 0; wbl < pPlayer->GetNumWearables(); wbl++ )
			{
				CEconWearable *pWearable = pPlayer->GetWearable(wbl);
				if ( !pWearable )
					continue;

				if ( pWearable->GetAttributeContainer()->GetItem()->GetStaticData()->GetLoadoutSlot(iClass) == pScriptItem->GetStaticData()->GetLoadoutSlot(iClass) )
				{
					pPlayer->RemoveWearable( pWearable );
					break;
				}
			}
		}

		// Fake global id
		pScriptItem->SetItemID( 1 );

		DispatchSpawn( pItem );

		CEconEntity *pNewItem = dynamic_cast<CEconEntity*>( pItem );
		Assert( pNewItem );
		if ( pNewItem )
		{
			pNewItem->GiveTo( pPlayer );
		}

#if defined (_DEBUG)
		DebugEconItemView( "Generated", pScriptItem );
#endif
	}
	else
	{
		Warning( "Failed to create an item named '%s'\n",args[1]);
	}
}

#endif // STAGING_ONLY

//-----------------------------------------------------------------------------
// Purpose: Adds this damager to the history list of people whose sentry damaged player
//-----------------------------------------------------------------------------
void CAchievementData::AddSentryDamager( EHANDLE hDamager, EHANDLE hObject )
{
	if ( !hDamager )
		return;

	EntityHistory_t newHist;
	newHist.hEntity = hDamager;
	newHist.hObject = hObject;
	newHist.flTimeDamage = gpGlobals->curtime;
	aSentryDamagers.InsertHistory( newHist );
}

//-----------------------------------------------------------------------------
// Purpose: Returns whether or not pDamager has damaged the player in the time specified (by way of sentry gun)
//-----------------------------------------------------------------------------
EntityHistory_t* CAchievementData::IsSentryDamagerInHistory( CBaseEntity *pDamager, float flTimeWindow )
{
	for ( int i = 0; i < aSentryDamagers.Count(); i++ )
	{
		if ( ( gpGlobals->curtime - aSentryDamagers[i].flTimeDamage ) > flTimeWindow )
			return NULL;

		if ( aSentryDamagers[i].hEntity == pDamager )
		{
			return &aSentryDamagers[i];
		}
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Client has sent us some KVs describing an item they want to test.
//-----------------------------------------------------------------------------
void CTFPlayer::ItemTesting_Start( KeyValues *pKV )
{
	static itemid_t s_iTestIndex = 1;

	// We have to be a listen server, with 1 player on it, and the request must come from the listen client.
	if ( this != UTIL_GetListenServerHost() )
		return;
	int iPlayers = 0;
	for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
	{
		CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
		if ( pPlayer && !pPlayer->IsFakeClient() )
		{
			iPlayers++;
		}
	}
	if ( iPlayers > 1 )
		return;

	// We also need to be on the item testing map.
	if ( !Q_stricmp(STRING(gpGlobals->mapname), "item_test.bsp" ) )
		return;

	FOR_EACH_VEC( m_ItemsToTest, i )
	{
		m_ItemsToTest[i].pKV->deleteThis();
	}
	m_ItemsToTest.Purge();

	TFGameRules()->SetInItemTestingMode( true );

	int iClassUsage = pKV->GetInt( "class_usage", 0 );

	ItemTesting_DeleteItems(); // Remove items before creating new defs. Some def clean-up depends on existing static values.

	for ( int iItemType = 0; iItemType < TI_TYPE_COUNT; iItemType++ )
	{
		KeyValues *pItemKV = pKV->FindKey( UTIL_VarArgs("Item%d",iItemType) );
		if ( !pItemKV )
			continue;

		// We need to copy these, because the econ item def will want to point at pieces of it
		int iNewItem = m_ItemsToTest.AddToTail();
		m_ItemsToTest[iNewItem].pKV = pItemKV->MakeCopy();
		m_ItemsToTest[iNewItem].pKV->SetInt( "class_usage", iClassUsage );

		bool bTestingExistingItem = pItemKV->GetBool( "test_existing_item", false );
		item_definition_index_t iReplacedItemDef = pItemKV->GetInt( "item_replace", INVALID_ITEM_DEF_INDEX );

		item_definition_index_t iNewDef = pItemKV->GetInt( "item_def", INVALID_ITEM_DEF_INDEX );
		if ( iNewDef == INVALID_ITEM_DEF_INDEX )
			return;

		// Create the econ item data from it
		ItemSystem()->GetItemSchema()->ItemTesting_CreateTestDefinition( iReplacedItemDef, iNewDef, m_ItemsToTest[iNewItem].pKV );

		// Build our test script item 
		m_ItemsToTest[iNewItem].scriptItem.Init( iNewDef, AE_USE_SCRIPT_VALUE, AE_USE_SCRIPT_VALUE, false );
		if ( !m_ItemsToTest[iNewItem].scriptItem.GetStaticData() )
			return;

		m_ItemsToTest[iNewItem].scriptItem.SetItemID( s_iTestIndex );
		s_iTestIndex++;

		bool bPrecache = !bTestingExistingItem;
		if ( bPrecache )
		{
			// Only dynamically load definitions tagged as streamable
			GameItemDefinition_t *pEconItemDef = m_ItemsToTest[iNewItem].scriptItem.GetStaticData();
			bPrecache = !pEconItemDef->IsContentStreamable();
		}
		if ( bPrecache )
		{
			bool bAllowPrecache = CBaseEntity::IsPrecacheAllowed();
			CBaseEntity::SetAllowPrecache( true );
			for ( int i = 0; i < LOADOUT_COUNT; i++ )
			{
				const char *pszModel = m_ItemsToTest[iNewItem].scriptItem.GetStaticData()->GetPlayerDisplayModel(i);
				if ( pszModel && pszModel[0] )
				{
					int iModelIndex = CBaseEntity::PrecacheModel( pszModel );
					PrecacheGibsForModel( iModelIndex );
				}
			}
			CBaseEntity::SetAllowPrecache( bAllowPrecache );
		}
	}

	// Spawn the right bots, and give them the item
	ItemTesting_UpdateBots( pKV );

	// Make the player respawn (he might have been holding test weapons)
	CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( 1 ) );
	if ( pPlayer && !pPlayer->IsFakeClient() )
	{
		if ( pPlayer->IsAlive() )
		{
			pPlayer->m_bItemTestingRespawn = true;
		}
		pPlayer->ForceRespawn();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ItemTesting_DeleteItems()
{
	// Take away every test item.
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pPlayer )
		{
			pPlayer->RemoveAllItems();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ItemTesting_UpdateBots( KeyValues *pKV )
{
	bool bNeedsBot[TF_LAST_NORMAL_CLASS];
	memset( bNeedsBot, 0, sizeof(bNeedsBot) );

	// Figure out what classes we'll need for all the items we're testing
	FOR_EACH_VEC( m_ItemsToTest, i )
	{
		CEconItemView *pItem = &m_ItemsToTest[i].scriptItem;
		for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; iClass++ )
		{
			if ( pItem->GetStaticData()->CanBeUsedByClass(iClass) )
			{
				bNeedsBot[iClass] = true;
			}
		}
	}

	bool bAutoAdd = pKV->GetInt( "auto_add_bots", 1 ) != 0;
	bool bBlueTeam = pKV->GetInt( "bots_on_blue_team", 0 ) != 0;

	// Kick every bot that's not one of the valid classes for the item
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pPlayer && pPlayer->IsFakeClient() )
		{
			int iClass = pPlayer->GetPlayerClass()->GetClassIndex();
			bool bWrongTeam = pPlayer->GetTeamNumber() != (bBlueTeam ? TF_TEAM_BLUE : TF_TEAM_RED);
			if ( bAutoAdd && (!bNeedsBot[iClass] || bWrongTeam) )
			{
				engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", pPlayer->GetUserID() ) );
			}
			else
			{
				bNeedsBot[iClass] = false;
				pPlayer->m_bItemTestingRespawn = true;
				pPlayer->ForceRespawn();
			}
		}
	}

	// Spawn bots of each class that uses the item (if we're doing auto addition)
	if ( bAutoAdd )
	{
		for ( int i = TF_FIRST_NORMAL_CLASS; i < TF_LAST_NORMAL_CLASS; i++ )
		{
			if ( bNeedsBot[i] )
			{
				engine->ServerCommand( UTIL_VarArgs( "bot -team %s -class %s\n", bBlueTeam ? "blue" : "red", g_aPlayerClassNames_NonLocalized[i] ) );
			}
		}
	}

	TFGameRules()->ItemTesting_SetupFromKV( pKV );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CEconItemView	*CTFPlayer::ItemTesting_GetTestItem( int iClass, int iSlot )
{
	CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( 1 ) );
	if ( pPlayer && !pPlayer->IsFakeClient() )
	{
		// Loop through all the items we're testing
		FOR_EACH_VEC( pPlayer->m_ItemsToTest, i )
		{
			CEconItemView *pItem = &pPlayer->m_ItemsToTest[i].scriptItem;
			if ( !pItem->GetStaticData()->CanBeUsedByClass( iClass ) )
				continue;

			if ( pItem->GetStaticData()->GetLoadoutSlot( iClass ) == iSlot )
				return pItem;
		}
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::GetReadyToTauntWithPartner( void )
{
	m_bIsReadyToHighFive = true;

	/*IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_highfive_start" );
	if ( pEvent )
	{
		pEvent->SetInt( "entindex", entindex() );

		gameeventmanager->FireEvent( pEvent );
	}*/
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::CancelTauntWithPartner( void )
{
	m_bIsReadyToHighFive = false;

	/*IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_highfive_cancel" );
	if ( pEvent )
	{
		pEvent->SetInt( "entindex", entindex() );

		gameeventmanager->FireEvent( pEvent );
	}*/
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::StopTauntSoundLoop()
{
	if ( !m_strTauntSoundLoopName.IsEmpty() )
	{
		CReliableBroadcastRecipientFilter filter;
		UserMessageBegin( filter, "PlayerTauntSoundLoopEnd" );
			WRITE_BYTE( entindex() );
		MessageEnd();

		m_strTauntSoundLoopName = "";
	}
}

//-----------------------------------------------------------------------------
// Purpose: Look for a nearby players who has started a 
// high five and is waiting for a partner
//-----------------------------------------------------------------------------
CTFPlayer *CTFPlayer::FindPartnerTauntInitiator( void )
{
	if ( tf_highfive_debug.GetBool() )
		Msg( "%s looking for a partner taunt initiator.\n", GetPlayerName() );

	CTFPlayer *pTargetInitiator = NULL;
	float flDistSqrToTargetInitiator = FLT_MAX;

	CUtlVector< CTFPlayer* > playerList;
	CollectPlayers( &playerList, GetAllowedTauntPartnerTeam(), true );
	for( int t=0; t<playerList.Count(); ++t )
	{
		CTFPlayer *pPlayer = playerList[t];

		if ( pPlayer == this )
			continue;

		// don't allow bot to taunt with each other
		if ( pPlayer->IsBot() && IsBot() )
			continue;

		if ( !pPlayer->IsReadyToTauntWithPartner() )
			continue;

		if ( tf_highfive_debug.GetBool() )
			Msg( "%s is ready to %s.\n", pPlayer->GetPlayerName(), pPlayer->m_TauntEconItemView.GetStaticData()->GetDefinitionName() );

		Vector toPartner = pPlayer->GetAbsOrigin() - GetAbsOrigin();
		float flDistSqrToPlayer = toPartner.LengthSqr();
		if ( flDistSqrToPlayer > Square( tf_highfive_max_range.GetFloat() ) )
		{
			if ( tf_highfive_debug.GetBool() )
				Msg( " - but that player was too far away.\n" );
				
			// too far away
			continue;
		}

		// skip if this player is too far to be our initiator
		if ( flDistSqrToPlayer >= flDistSqrToTargetInitiator )
		{
			if ( tf_highfive_debug.GetBool() )
			{
				Msg( " - is further than the current potential initiator.\n" );
			}
			continue;
		}

		toPartner.NormalizeInPlace();
			
		Vector forward;
		EyeVectors( &forward );

		// check if I'm facing this player
		if ( DotProduct( toPartner, forward ) < 0.6f )
		{
			if ( tf_highfive_debug.GetBool() )
				Msg( " - but we are not looking at that player.\n" );

			// we are not looking at this partner
			continue;
		}

		bool bShouldCheckFacing = !pPlayer->m_bTauntMimic;
		// check if the player is facing us
		if ( bShouldCheckFacing )
		{
			Vector partnerForward = pPlayer->BodyDirection2D();
			float toPartnerDotProduct = DotProduct( toPartner, partnerForward );
			if ( tf_highfive_debug.GetBool() )
				Msg( " - dot product to partner is %f\n", toPartnerDotProduct );

			if ( toPartnerDotProduct > -0.6f )
			{
				if ( tf_highfive_debug.GetBool() )
					Msg( " - but that player is not facing us.\n" );

				// they are not facing us
				continue;
			}
		}

		// check if there's something between us
		trace_t result;
		CTraceFilterIgnoreTeammates filter( this, COLLISION_GROUP_NONE, GetAllowedTauntPartnerTeam() );
		UTIL_TraceHull( GetAbsOrigin(), pPlayer->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, MASK_PLAYERSOLID, &filter, &result );
		if ( result.DidHit() )
		{
			if ( tf_highfive_debug.GetBool() )
				Msg( " - entity [%i %s %s] in between. tracing again with tolerance.\n",
					result.GetEntityIndex(),
					result.m_pEnt ? result.m_pEnt->GetClassname() : "NULL",
					result.surface.name );

			Vector offset( 0, 0, tf_highfive_height_tolerance.GetFloat() );
			trace_t result2;
			UTIL_TraceHull( GetAbsOrigin() + offset, pPlayer->GetAbsOrigin() + offset, VEC_HULL_MIN, VEC_HULL_MAX, MASK_PLAYERSOLID, &filter, &result2 );
			if ( result2.DidHit() )
			{
				if ( tf_highfive_debug.GetBool() )
					Msg( " - entity [%i %s %s] in between.\n",
					result2.GetEntityIndex(),
					result2.m_pEnt ? result2.m_pEnt->GetClassname() : "NULL",
					result2.surface.name );

				// something is in between us
				continue;
			}
		}

		// Check to see if there's a spawn room visualizer between us and our partner
		if( PointsCrossRespawnRoomVisualizer( WorldSpaceCenter(), pPlayer->WorldSpaceCenter() ) )
		{
			if ( tf_highfive_debug.GetBool() )
				Msg( " - spawn room visualizer in between.\n" );

			continue;
		}

		// update to closer target player
		if ( flDistSqrToPlayer < flDistSqrToTargetInitiator )
		{
			// success!
			if ( tf_highfive_debug.GetBool() )
				Msg( " - is potentially the closest target player.\n" );
			flDistSqrToTargetInitiator = flDistSqrToPlayer;	
			pTargetInitiator = pPlayer;
		}
		else if ( tf_highfive_debug.GetBool() )
		{
			Msg( " - is further than the current target player.\n" );
		}
	}

	// pick the closest target player over the closest player
	return pTargetInitiator;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static bool SelectPartnerTaunt( const GameItemDefinition_t *pItemDef, CTFPlayer *initiator, CTFPlayer *receiver, const char **pszInitiatorScene, const char **pszReceiverScene )
{
	static CSchemaItemDefHandle rpsTaunt( "RPS Taunt" );

	CTFTauntInfo *pTauntData = pItemDef->GetTauntData();
	if ( !pTauntData )
		return false;

	int iInitiatorClass = initiator->GetPlayerClass()->GetClassIndex();
	int iReceiverClass = receiver->GetPlayerClass()->GetClassIndex();

	// check if we have any scene
	const int iInitiatorSceneCount = pTauntData->GetPartnerTauntInitiatorSceneCount( iInitiatorClass );
	const int iReceiverSceneCount = pTauntData->GetPartnerTauntReceiverSceneCount( iReceiverClass );
	if ( iInitiatorSceneCount == 0 ||
		 iReceiverSceneCount == 0 )
	{
		return false;
	}

	int iInitiator = 0;
	int iReceiver = 0;
	if ( pItemDef == rpsTaunt )
	{
		Assert( iInitiatorSceneCount == 6 && iReceiverSceneCount == 6 );

		int iWinner = RandomInt( 0, 2 );
		int iLoser =  ( ( iWinner + 2 ) % 3 ) + 3;

		/*static const char* s_pszRPS[3] = { "rock", "paper", "scissor" };
		DevMsg( "%s beats %s\n", s_pszRPS[iWinner], s_pszRPS[iLoser%3] );*/

		if ( RandomInt( 0, 1 ) )
		{
			iInitiator = iWinner;
			iReceiver = iLoser;
		}
		else
		{
			iInitiator = iLoser;
			iReceiver = iWinner;
		}

		initiator->SetRPSResult( iInitiator );
	}
	else
	{
		// randomly select a player to pick 0 (could be silent taunt)
		// and other player select a different one if there's any
		if ( RandomInt( 0, 1 ) == 0 )
		{
			iReceiver = iReceiverSceneCount > 1 ? RandomInt( 1, iReceiverSceneCount - 1 ) : 0;
		}
		else
		{
			iInitiator = iInitiatorSceneCount > 1 ? RandomInt( 1, iInitiatorSceneCount - 1 ) : 0;
		}
	}

	*pszInitiatorScene = pTauntData->GetPartnerTauntInitiatorScene( iInitiatorClass, iInitiator );
	*pszReceiverScene = pTauntData->GetPartnerTauntReceiverScene( iReceiverClass, iReceiver );

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::AcceptTauntWithPartner( CTFPlayer *initiator )
{
	if ( !initiator )
	{
		return;
	}

	if ( tf_highfive_debug.GetBool() )
		Msg( "%s doing %s with initiator %s.\n", GetPlayerName(), initiator->m_TauntEconItemView.GetStaticData()->GetDefinitionName(), initiator->GetPlayerName() );

	// make sure this won't get us stuck
	Vector newOrigin;
	float flTolerance;
	if ( !initiator->FindOpenTauntPartnerPosition( &initiator->m_TauntEconItemView, newOrigin, &flTolerance ))
	{
		if ( tf_highfive_debug.GetBool() )
			Msg( " - but there is no open space for us.\n" );

		return;
	}

	trace_t result;
	CTraceFilterIgnoreTeammates filter( this, COLLISION_GROUP_NONE, GetTeamNumber() );
	UTIL_TraceHull( newOrigin, newOrigin - Vector( 0, 0, flTolerance ), VEC_HULL_MIN, VEC_HULL_MAX, MASK_PLAYERSOLID, &filter, &result );
	if ( !result.DidHit() )
	{
		if ( tf_highfive_debug.GetBool() )
			Msg( " - there's too much space underneath where we need to be.\n" );

		return;
	}
	else
	{
		newOrigin = result.endpos;
	}

	trace_t	stucktrace;
	UTIL_TraceEntity( this, newOrigin, newOrigin, MASK_PLAYERSOLID, &filter, &stucktrace );
	if ( stucktrace.startsolid != 0 )
	{
		if ( tf_highfive_debug.GetBool() )
			Msg( " - but we'd get stuck on entity [%i %s %s] going in front of %s.\n",
			stucktrace.GetEntityIndex(),
			stucktrace.m_pEnt ? stucktrace.m_pEnt->GetClassname() : "NULL",
			stucktrace.surface.name,
			initiator->GetPlayerName() );

		return;
	}

	// move us into facing position with initiator
	SetAbsOrigin( newOrigin );
	QAngle newAngles = initiator->GetAbsAngles();
	// turn 180 degree to face the initiator
	newAngles[YAW] = AngleNormalize( newAngles[YAW] - 180 );
	SetAbsAngles( newAngles );

	m_bIsReadyToHighFive = false;
	initiator->m_bIsReadyToHighFive = false;

	// note who our partner is so we can lock our facing toward them on the client
	m_hHighFivePartner = initiator;
	initiator->m_hHighFivePartner = this;

	if ( initiator->m_hTauntScene.Get() )
	{
		StopScriptedScene( initiator, initiator->m_hTauntScene );
		initiator->m_hTauntScene = NULL;

		initiator->StopTauntSoundLoop();
	}

	const char *pszInitiatorScene = NULL;
	const char *pszOurScene = NULL;
	const GameItemDefinition_t *pItemDef = initiator->m_TauntEconItemView.GetItemDefinition();
	if ( !SelectPartnerTaunt( pItemDef, initiator, this, &pszInitiatorScene, &pszOurScene ) )
	{
		if ( tf_highfive_debug.GetBool() )
		{
			Msg( "SpeakConceptIfAllowed failed on partner taunt initiator. Aborting taunt.\n" );
		}
		AssertMsg( false, "SpeakConceptIfAllowed failed on partner taunt initiator. Aborting taunt." );

		initiator->m_flTauntRemoveTime = gpGlobals->curtime;
		initiator->m_bAllowedToRemoveTaunt = true;

		return;
	}
	m_TauntEconItemView = initiator->m_TauntEconItemView;

	int initiatorConcept = MP_CONCEPT_HIGHFIVE_SUCCESS_FULL;
	int ourConcept = MP_CONCEPT_HIGHFIVE_SUCCESS;

	CMultiplayer_Expresser *pInitiatorExpresser = initiator->GetMultiplayerExpresser();
	Assert( pInitiatorExpresser );

	pInitiatorExpresser->AllowMultipleScenes();

	// extend initiator's taunt duration to include actual high five
	initiator->m_bInitTaunt = true;

	initiator->PlayScene( pszInitiatorScene );
	
	if ( tf_highfive_debug.GetBool() )
		Msg( " concept %i started fine for initiator %s.\n", initiatorConcept, initiator->GetPlayerName() );

	initiator->m_Shared.m_iTauntIndex = TAUNT_MISC_ITEM;
	initiator->m_Shared.m_iTauntConcept.Set( initiatorConcept );
	initiator->m_flTauntRemoveTime = gpGlobals->curtime + GetSceneDuration( pszInitiatorScene ) + 0.2f;
	initiator->m_bAllowedToRemoveTaunt = true;

	initiator->m_iTauntAttack = TAUNTATK_NONE;
	initiator->m_flTauntAttackTime = 0.f;

	static CSchemaAttributeDefHandle pAttrDef_TauntAttackName( "taunt attack name" );
	const char* pszTauntAttackName = NULL;
	if ( FindAttribute_UnsafeBitwiseCast<CAttribute_String>( pItemDef, pAttrDef_TauntAttackName, &pszTauntAttackName ) )
	{
		initiator->m_iTauntAttack = GetTauntAttackByName( pszTauntAttackName );
	}

	static CSchemaAttributeDefHandle pAttrDef_TauntAttackTime( "taunt attack time" );
	float flTauntAttackTime = 0.f;
	if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItemDef, pAttrDef_TauntAttackTime, &flTauntAttackTime ) )
	{
		initiator->m_flTauntAttackTime = gpGlobals->curtime + flTauntAttackTime;
	}

	if ( GetActiveWeapon() )
	{
		m_iPreTauntWeaponSlot = GetActiveWeapon()->GetSlot();
	}

	PlayScene( pszOurScene );
	OnTauntSucceeded( pszOurScene, TAUNT_MISC_ITEM, ourConcept );

	const char *pszTauntSound = pItemDef->GetCustomSound( initiator->GetTeamNumber(), 0 );
	if ( pszTauntSound )
	{
		// each participant hears the sound without PAS attenuation, but everyone else gets the PAS attenuation
		EmitSound_t params;
		params.m_pSoundName = pszTauntSound;

		CSingleUserRecipientFilter soundFilterInitiator( initiator );
		initiator->EmitSound( soundFilterInitiator, initiator->entindex(), params );

		CSingleUserRecipientFilter soundFilter( this );
		EmitSound( soundFilter, this->entindex(), params );

		CPASAttenuationFilter attenuationFilter( this, params.m_pSoundName );
		attenuationFilter.RemoveRecipient( this );
		attenuationFilter.RemoveRecipient( initiator );
		initiator->EmitSound( attenuationFilter, initiator->entindex(), params );
	}

	/*static CSchemaItemDefHandle highfiveTaunt( "High Five Taunt" );
	if ( pItemDef == highfiveTaunt )
	{
		IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_highfive_success" );
		if ( pEvent )
		{
			pEvent->SetInt( "initiator_entindex", initiator->entindex() );
			pEvent->SetInt( "partner_entindex", entindex() );

			gameeventmanager->FireEvent( pEvent );
		}
	}*/

	initiator->m_bInitTaunt = false;
	pInitiatorExpresser->DisallowMultipleScenes();

	// check for taunt achievements
	if ( TFGameRules() && ( TFGameRules()->GetGameType() == TF_GAMETYPE_CP ) )
	{
		if ( !IsBot() && !initiator->IsBot() && ( GetTeamNumber() == initiator->GetTeamNumber() ) )
		{
			if ( IsCapturingPoint() && initiator->IsCapturingPoint() )
			{
				AwardAchievement( ACHIEVEMENT_TF_TAUNT_WHILE_CAPPING );
				initiator->AwardAchievement( ACHIEVEMENT_TF_TAUNT_WHILE_CAPPING );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::MimicTauntFromPartner( CTFPlayer *initiator )
{
	Assert( initiator->m_bAllowMoveDuringTaunt );
	if ( initiator->m_TauntEconItemView.IsValid() && initiator->m_TauntEconItemView.GetItemDefinition() != NULL )
	{
		PlayTauntSceneFromItem( &initiator->m_TauntEconItemView );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
extern ConVar tf_allow_all_team_partner_taunt;
int CTFPlayer::GetAllowedTauntPartnerTeam() const
{
	return tf_allow_all_team_partner_taunt.GetBool() ? TEAM_ANY : GetTeamNumber();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::IncrementKillCountSinceLastDeploy( const CTakeDamageInfo &info )
{
	// track kills since last deploy, but only if our deployed weapon is the one we
	// just killed someone with (this fixes the problem where you fire a rocket, switch
	// weapons, and then get the kill tracked on the newly-deployed weapon)
	CTFWeaponBase *pTFWeapon = dynamic_cast<CTFWeaponBase *>( info.GetWeapon() );
	if ( pTFWeapon && ( pTFWeapon == GetActiveTFWeapon() ) )
	{
		m_Shared.m_iKillCountSinceLastDeploy++;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Return true if any enemy sentry has LOS and is facing me and is in range to attack
//-----------------------------------------------------------------------------
bool CTFPlayer::IsAnyEnemySentryAbleToAttackMe( void ) const
{
	if ( m_Shared.InCond( TF_COND_DISGUISED ) ||
		 m_Shared.InCond( TF_COND_DISGUISING ) ||
		 m_Shared.IsStealthed() )
	{
		// I'm a disguised or cloaked Spy
		return false;
	}

	for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
	{
		CBaseObject* pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
		if ( pObj->ObjectType() != OBJ_SENTRYGUN )
			continue;
		
		if ( pObj->HasSapper() )
			continue;

		if ( pObj->IsPlasmaDisabled() )
			continue;

		if ( pObj->IsDisabled() )
			continue;

		if ( pObj->IsBuilding() )
			continue;

		if ( pObj->IsCarried() )
			continue;

		// are we in range?
		if ( ( GetAbsOrigin() - pObj->GetAbsOrigin() ).IsLengthGreaterThan( SENTRY_MAX_RANGE ) )
			continue;

		// is the sentry aiming towards me?
		if ( !IsThreatAimingTowardMe( pObj, 0.95f ) )
			continue;

		// does the sentry have clear line of fire?
		if ( !IsLineOfSightClear( pObj, IGNORE_ACTORS ) )
			continue;

		// this sentry can attack me
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// MVM Con Commands
//-----------------------------------------------------------------------------
CON_COMMAND_F( currency_give, "Have some in-game money.", FCVAR_CHEAT )
{
	CTFPlayer *pPlayer = ToTFPlayer( UTIL_GetCommandClient() );
	if ( !pPlayer )
		return;

	int nAmount = atoi( args[1] );

#ifdef STAGING_ONLY
	if ( TFGameRules() && TFGameRules()->GameModeUsesExperience() )
	{
		// This will give money, and calculate their level
		pPlayer->AddExperiencePoints( nAmount, true );
		return;
	}
#endif // STAGING_ONLY

	pPlayer->AddCurrency( nAmount );
}

//-----------------------------------------------------------------------------
// Purpose: Currency awarded directly will not be tracked by stats - see TFGameRules
//-----------------------------------------------------------------------------
void CTFPlayer::AddCurrency( int nAmount )
{
	if ( nAmount + m_nCurrency > 30000 )
	{
		m_nCurrency = 30000;
	}
	else if ( nAmount + m_nCurrency < 0 )
	{
		m_nCurrency = 0;
	}
	else
	{
		m_nCurrency += nAmount;
	}	
}

//-----------------------------------------------------------------------------
// Purpose: Remove Currency from Display and track it as currency spent
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveCurrency( int nAmount )
{ 
	m_nCurrency = Max( m_nCurrency - nAmount, 0 ); 

	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
	{
		g_pPopulationManager->AddPlayerCurrencySpent( this, nAmount );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Ultra crude experience and level system
//-----------------------------------------------------------------------------
void CTFPlayer::AddExperiencePoints( int nAmount, bool bGiveCurrency /*= false*/, CTFPlayer *pSource /*= NULL*/ )
{
	int nMyLevel = GetExperienceLevel();

	// Adjust experience based on level difference of source player
	if ( pSource )
	{
		int nLevelDiff = pSource->GetExperienceLevel() - nMyLevel;
		if ( nLevelDiff <= -5 )
			return;

		if ( nLevelDiff > 0 )
		{
			nAmount *= ( nLevelDiff + 1 );
		}
		else if ( nLevelDiff < 0 )
		{
			nAmount /= ( abs( nLevelDiff ) + 1 );
		}
	}

	m_nExperiencePoints += nAmount;
	CalculateExperienceLevel();
	
	// Money?
	if ( bGiveCurrency && TFGameRules() )
	{
		TFGameRules()->DistributeCurrencyAmount( nAmount, this, false );
		CTF_GameStats.Event_PlayerCollectedCurrency( this, nAmount );
		EmitSound( "MVM.MoneyPickup" );
	}

	// DevMsg( "Exp: %d, Level: %d Perc: %d\n", GetExperiencePoints(), GetExperienceLevel(), m_nExperienceLevelProgress );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::RefundExperiencePoints( void )
{
	SetExperienceLevel( 1 );

	int nAmount = 0;
	PlayerStats_t *pPlayerStats = CTF_GameStats.FindPlayerStats( this );
	if ( pPlayerStats ) 
	{
		nAmount = pPlayerStats->statsCurrentRound.m_iStat[TFSTAT_CURRENCY_COLLECTED];
	}
	
	if ( nAmount > 0 )
	{
		SetExperiencePoints(nAmount);
		SetCurrency(nAmount);
	}

	CalculateExperienceLevel(false);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::CalculateExperienceLevel( bool bAnnounce /*= true*/ )
{
	int nMyLevel = GetExperienceLevel();

	int nPrevLevel = nMyLevel;
	float flLevel = ( (float)m_nExperiencePoints / 400.f ) + 1.f;
	flLevel = Min( flLevel, 20.f );

	// Ding?
	if ( bAnnounce )
	{
		if ( flLevel > 1 && nPrevLevel != (int)flLevel )
		{
			const char *pszTeamName = GetTeamNumber() == TF_TEAM_RED ? "RED" : "BLU";
			UTIL_ClientPrintAll( HUD_PRINTCENTER, "#TF_PlayerLeveled", pszTeamName, GetPlayerName(), CFmtStr( "%d", (int)flLevel ) );
			UTIL_ClientPrintAll( HUD_PRINTCONSOLE, "#TF_PlayerLeveled", pszTeamName, GetPlayerName(), CFmtStr( "%d", (int)flLevel ) );
			DispatchParticleEffect( "mvm_levelup1", PATTACH_POINT_FOLLOW, this, "head" );
			EmitSound( "Achievement.Earned" );
		}
	}

	flLevel = floor( flLevel );
	SetExperienceLevel( Max( flLevel, 1.f ) );

	// Update level progress percentage - networked
	float flLevelPerc = ( flLevel - floor( flLevel ) ) * 100.f;
	if ( m_nExperienceLevelProgress != flLevelPerc )
	{
		m_nExperienceLevelProgress.Set( (int)flLevelPerc );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Store this upgrade for restoring at a checkpoint
//-----------------------------------------------------------------------------
void CTFPlayer::RememberUpgrade( int iPlayerClass, CEconItemView *pItem, int iUpgrade, int nCost, bool bDowngrade )
{
	if ( IsBot() )
		return;

	if ( !g_pPopulationManager )
	{
		Warning( "Remember Upgrade Error: Population Manager does not exist!\n" );
		return;
	}

	if ( TFGameRules() == NULL || !TFGameRules()->GameModeUsesUpgrades() )
		return;

	item_definition_index_t iItemIndex = pItem ? pItem->GetItemDefIndex() : INVALID_ITEM_DEF_INDEX;
	
	CUtlVector< CUpgradeInfo > *upgrades = g_pPopulationManager->GetPlayerUpgradeHistory( this );

	if ( !bDowngrade )
	{
		CUpgradeInfo info;
		info.m_iPlayerClass = iPlayerClass;
		info.m_itemDefIndex = iItemIndex;
		info.m_upgrade = iUpgrade;
		info.m_nCost = nCost;

		if ( upgrades )
		{
			upgrades->AddToTail( info );
		}

		m_RefundableUpgrades.AddToTail( info );
	}
	else
	{
		if ( upgrades )
		{
			for ( int i = 0; i < upgrades->Count(); ++i )
			{
				CUpgradeInfo pInfo = upgrades->Element(i);
				if ( ( pInfo.m_itemDefIndex == iItemIndex ) && ( pInfo.m_upgrade == iUpgrade ) && ( pInfo.m_nCost == -nCost ) )
				{
					upgrades->Remove( i );
					break;
				}
			}
		}

		// Subset of upgrades that can be sold back
		for ( int i = 0; i < m_RefundableUpgrades.Count(); ++i )
		{
			CUpgradeInfo pInfo = m_RefundableUpgrades.Element( i );
			if ( ( pInfo.m_itemDefIndex == iItemIndex ) && ( pInfo.m_upgrade == iUpgrade ) && ( pInfo.m_nCost == -nCost ) )
			{
				m_RefundableUpgrades.Remove( i );
				break;
			}
		}
	}

	const char *upgradeName = g_hUpgradeEntity->GetUpgradeAttributeName( iUpgrade );

	DevMsg( "%3.2f: %s: Player '%s', item '%s', upgrade '%s', cost '%d'\n",
		gpGlobals->curtime, 
		bDowngrade ? "FORGET_UPGRADE" : "REMEMBER_UPGRADE",
		GetPlayerName(),
		pItem ? pItem->GetStaticData()->GetItemBaseName() : "<self>",
		upgradeName ? upgradeName : "<NULL>",
		nCost );
}

//-----------------------------------------------------------------------------
// Purpose: Erase the first upgrade stored for this item (for powerup bottles)
//-----------------------------------------------------------------------------
void CTFPlayer::ForgetFirstUpgradeForItem( CEconItemView *pItem )
{
	if ( IsBot() )
		return;

	if ( TFGameRules() && !TFGameRules()->IsMannVsMachineMode() )
		return;

	DevMsg( "%3.2f: FORGET_FIRST_UPGRADE_FOR_ITEM: Player '%s', item '%s'\n",
			gpGlobals->curtime, 
			GetPlayerName(),
			pItem ? pItem->GetStaticData()->GetItemBaseName() : "<self>" );
	
	CUtlVector< CUpgradeInfo > *upgrades = g_pPopulationManager->GetPlayerUpgradeHistory( this );
	if ( upgrades == NULL )
		return;

	for( int i = 0; i < upgrades->Count(); ++i )
	{
		if ( ( pItem == NULL && upgrades->Element( i ).m_itemDefIndex == INVALID_ITEM_DEF_INDEX ) ||		// self upgrade
			upgrades->Element(i).m_itemDefIndex == pItem->GetItemDefIndex() )		// item upgrade
		{
			upgrades->Remove( i );
			g_pPopulationManager->SendUpgradesToPlayer( this );
			break;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ClearUpgradeHistory( void )
{
	if( !g_pPopulationManager )
		return;

	CUtlVector< CUpgradeInfo > *upgrades = g_pPopulationManager->GetPlayerUpgradeHistory( this );
	if ( upgrades != NULL )
		upgrades->RemoveAll();

	ResetAccumulatedSentryGunDamageDealt();
	ResetAccumulatedSentryGunKillCount();

	g_pPopulationManager->SendUpgradesToPlayer( this );

	DevMsg( "%3.2f: CLEAR_UPGRADE_HISTORY: Player '%s'\n", gpGlobals->curtime, GetPlayerName() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ReapplyItemUpgrades( CEconItemView *pItem )
{
	if ( IsBot() || !g_pPopulationManager)
		return;

	int iClassIndex = GetPlayerClass()->GetClassIndex();

	// Restore player Upgrades
	CUtlVector< CUpgradeInfo > *upgrades = g_pPopulationManager->GetPlayerUpgradeHistory( this );
	if ( upgrades == NULL )
		return;

	BeginPurchasableUpgrades();

	for( int u = 0; u < upgrades->Count(); ++u )
	{
		// Player Upgrades for this class and item
		const CUpgradeInfo& upgrade = upgrades->Element(u);
		if ( iClassIndex == upgrade.m_iPlayerClass && pItem->GetItemDefIndex() == upgrade.m_itemDefIndex )
		{
			g_hUpgradeEntity->ApplyUpgradeToItem( this, pItem, upgrade.m_upgrade, upgrade.m_nCost );
		}
	}

	EndPurchasableUpgrades();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ReapplyPlayerUpgrades( void )
{
	if ( IsBot() || !g_pPopulationManager)
		return;

	int iClassIndex = GetPlayerClass()->GetClassIndex();
	RemovePlayerAttributes( false );

	CUtlVector< CUpgradeInfo > *upgrades = g_pPopulationManager->GetPlayerUpgradeHistory( this );
	if ( upgrades == NULL )
		return;

	BeginPurchasableUpgrades();

	// Restore player Upgrades
	for( int u = 0; u < upgrades->Count(); ++u )
	{
		// Player Upgrades for this class
		if ( iClassIndex == upgrades->Element(u).m_iPlayerClass)
		{
			// Upgrades applied to player
			if ( upgrades->Element(u).m_itemDefIndex == INVALID_ITEM_DEF_INDEX )
			{
				g_hUpgradeEntity->ApplyUpgradeToItem( this, NULL, upgrades->Element(u).m_upgrade, upgrades->Element(u).m_nCost );
			}
		}
	}

	EndPurchasableUpgrades();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::BeginPurchasableUpgrades( void )
{
	m_nCanPurchaseUpgradesCount++;

	if ( TFObjectiveResource()->GetMannVsMachineWaveCount() > 1 )
	{
		m_RefundableUpgrades.RemoveAll();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::EndPurchasableUpgrades( void )
{
	AssertMsg( m_nCanPurchaseUpgradesCount > 0, "EndPurchasableUpgrades called when m_nCanPurchaseUpgradesCount <= 0" );
	if ( m_nCanPurchaseUpgradesCount <= 0 )
		return;

	m_nCanPurchaseUpgradesCount--;

	if ( TFObjectiveResource()->GetMannVsMachineWaveCount() > 1 )
	{
		m_RefundableUpgrades.RemoveAll();
	}

	// report all upgrades
	if ( g_pPopulationManager )
	{
		g_pPopulationManager->SendUpgradesToPlayer( this );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::PlayReadySound( void )
{
	if ( m_flLastReadySoundTime < gpGlobals->curtime )
	{
		if ( TFGameRules() )
		{
			int iTeam = GetTeamNumber();
			const char *pszFormat = "%s.Ready";

			if ( TFGameRules()->IsMannVsMachineMode() )
			{
				pszFormat = "%s.ReadyMvM";
			}
			else if ( TFGameRules()->IsCompetitiveMode() )
			{
				pszFormat = "%s.ReadyComp";
			}

			CFmtStr goYell( pszFormat, g_aPlayerClassNames_NonLocalized[ m_Shared.GetDesiredPlayerClassIndex() ] );
			TFGameRules()->BroadcastSound( iTeam, goYell );
			TFGameRules()->BroadcastSound( TEAM_SPECTATOR, goYell ); // spectators hear the ready sounds, too

			m_flLastReadySoundTime = gpGlobals->curtime + 4.f;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::GetDesiredHeadScale() const
{
	float flDesiredHeadScale = 1.f;
	CALL_ATTRIB_HOOK_FLOAT( flDesiredHeadScale, head_scale );
	return flDesiredHeadScale;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::GetHeadScaleSpeed() const
{
	// change size now
	if (
		m_Shared.InCond( TF_COND_HALLOWEEN_BOMB_HEAD ) ||
		m_Shared.InCond( TF_COND_MELEE_ONLY ) ||
		m_Shared.InCond( TF_COND_HALLOWEEN_KART ) ||
		m_Shared.InCond( TF_COND_BALLOON_HEAD )
		)
	{	
		return GetDesiredHeadScale();
	}

	return gpGlobals->frametime;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::GetDesiredTorsoScale() const
{
	float flDesiredTorsoScale = 1.f;
	CALL_ATTRIB_HOOK_FLOAT( flDesiredTorsoScale, torso_scale );
	return flDesiredTorsoScale;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::GetTorsoScaleSpeed() const
{
	return gpGlobals->frametime;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::GetDesiredHandScale() const
{
	float flDesiredHandScale = 1.f;
	CALL_ATTRIB_HOOK_FLOAT( flDesiredHandScale, hand_scale );
	return flDesiredHandScale;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::GetHandScaleSpeed() const
{
	if ( m_Shared.InCond( TF_COND_MELEE_ONLY ) )
	{
		return GetDesiredHandScale();
	}

	return gpGlobals->frametime;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::SetBombHeadTimestamp()
{
	m_fLastBombHeadTimestamp = gpGlobals->curtime;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFPlayer::GetTimeSinceWasBombHead() const
{
	return gpGlobals->curtime - m_fLastBombHeadTimestamp;
}

//-----------------------------------------------------------------------------
// Purpose: Can the player breathe under water?
//-----------------------------------------------------------------------------
bool CTFPlayer::CanBreatheUnderwater() const
{
	if ( m_Shared.InCond( TF_COND_SWIMMING_CURSE ) )
		return true;

	int iCanBreatheUnderWater = 0;
	CALL_ATTRIB_HOOK_INT( iCanBreatheUnderWater, can_breathe_under_water );
	if ( iCanBreatheUnderWater != 0 )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::InputSpeakResponseConcept( inputdata_t &inputdata )
{
	const char *pInputString = STRING(inputdata.value.StringID());
	// if no params, early out
	if (!pInputString || *pInputString == 0)
	{
		Warning( "empty SpeakResponse input from %s to %s\n", inputdata.pCaller->GetDebugName(), GetDebugName() );
		return;
	}

	char buf[512] = {0}; // temporary for tokenizing
	char outputmodifiers[512] = {0}; // eventual output to speak
	int outWritten = 0;
	V_strncpy(buf, pInputString, 510);
	buf[511] = 0; // just in case the last character is a comma -- enforce that the 
	// last character in the buffer is always a terminator.
	// special syntax allowing designers to submit inputs with contexts like
	// "concept,context1:value1,context2:value2,context3:value3"
	// except that entity i/o seems to eat commas these days (didn't used to be the case)
	// so instead of commas we have to use spaces in the entity IO, 
	// and turn them into commas here. AWESOME.
	char *pModifiers = const_cast<char *>(V_strnchr(buf, ' ', 510));
	if ( pModifiers )
	{
		*pModifiers = 0;
		++pModifiers;

		// tokenize on spaces
		char *token = strtok(pModifiers, " ");
		while (token)
		{
			// find the start characters for the key and value
			// (seperated by a : which we replace with null)
			char * RESTRICT key = token;
			char * RESTRICT colon = const_cast<char *>(V_strnchr(key, ':', 510)); 
			char * RESTRICT value;
			if (!colon)
			{
				Warning( "faulty context k:v pair in entity io %s\n", pInputString );
				break;
			}

			// write the key and colon to the output string
			int toWrite = colon - key + 1;
			if ( outWritten + toWrite >= 512 )
			{
				Warning( "Speak input to %s had overlong parameter %s", GetDebugName(), pInputString );
				return;
			}
			memcpy(outputmodifiers + outWritten, key, toWrite);
			outWritten += toWrite;

			*colon = 0;
			value = colon + 1;

			// determine if the value is actually a procedural name
			CBaseEntity *pProcedural = gEntList.FindEntityProcedural( value, this, inputdata.pActivator, inputdata.pCaller );

			// write the value to the output -- if it's a procedural name, replace appropriately; 
			// if not, just copy over.
			const char *valString; 
			if (pProcedural)
			{
				valString = STRING(pProcedural->GetEntityName());
			}
			else
			{
				valString = value;
			}
			toWrite = strlen(valString);
			toWrite = MIN( 511-outWritten, toWrite );
			V_strncpy( outputmodifiers + outWritten, valString, toWrite+1 );
			outWritten += toWrite;

			// get the next token
			token = strtok(NULL, " ");
			if (token)
			{
				// if there is a next token, write in a comma
				if (outWritten < 511)
				{
					outputmodifiers[outWritten++]=',';
				}
			}
		}
	}

	// null terminate just in case
	outputmodifiers[outWritten <= 511 ? outWritten : 511] = 0;

	SpeakConceptIfAllowed( GetMPConceptIndexFromString( buf ), outputmodifiers[0] ? outputmodifiers : NULL );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::CreateDisguiseWeaponList( CTFPlayer *pDisguiseTarget )
{
	ClearDisguiseWeaponList();

	// copy disguise target weapons
	if ( pDisguiseTarget )
	{
		for ( int i=0; i<TF_PLAYER_WEAPON_COUNT; ++i )
		{
			CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>( pDisguiseTarget->GetWeapon( i ) );

			if ( !pWeapon )
				continue;

			CEconItemView *pItem = NULL;
			// We are copying a generated, non-base item.
			CAttributeContainer *pContainer = pWeapon->GetAttributeContainer();
			if ( pContainer )
			{
				pItem = pContainer->GetItem();
			}

			int iSubType = 0;
			CTFWeaponBase *pCopyWeapon = dynamic_cast<CTFWeaponBase*>( GiveNamedItem( pWeapon->GetClassname(), iSubType, pItem, true ) );
			if ( pCopyWeapon )
			{
				pCopyWeapon->AddEffects( EF_NODRAW | EF_NOSHADOW );
				m_hDisguiseWeaponList.AddToTail( pCopyWeapon );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::ClearDisguiseWeaponList()
{
	FOR_EACH_VEC( m_hDisguiseWeaponList, i )
	{
		if ( m_hDisguiseWeaponList[i] )
		{
			m_hDisguiseWeaponList[i]->Drop( vec3_origin );
		}
	}

	m_hDisguiseWeaponList.RemoveAll();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::CanScorePointForPD( void ) const
{ 
	// These conditions block being able to score in PD
	ETFCond blockingConds[] = { TF_COND_STEALTHED			// Invis spies
							  , TF_COND_STEALTHED_BLINK
							  , TF_COND_DISGUISING			// Disguised spies
							  , TF_COND_DISGUISED
							  , TF_COND_INVULNERABLE		// Uber
							  , TF_COND_PHASE };			// Bonked Scouts
	
	// Check for blocking conditions
	for( int i=0; i<ARRAYSIZE(blockingConds); ++i )
	{
		if ( m_Shared.InCond( blockingConds[i] ) )
		{
			return false;
		}
	}

	// More aggressively deny invis than the code above
	if ( m_Shared.GetPercentInvisible() > 0.f )
	{
		return false;
	}

	// Rate limit
	return ( ( m_flNextScorePointForPD < 0 ) || ( m_flNextScorePointForPD < gpGlobals->curtime ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::PickupWeaponFromOther( CTFDroppedWeapon *pDroppedWeapon )
{
	const CEconItemView *pItem = pDroppedWeapon->GetItem();
	if ( !pItem )
		return false;

	if ( pItem->IsValid() )
	{
		int iClass = GetPlayerClass()->GetClassIndex();
		int iItemSlot = pItem->GetStaticData()->GetLoadoutSlot( iClass );
		CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase* >( GetEntityForLoadoutSlot( iItemSlot ) );

		if ( !pWeapon )
		{
			AssertMsg( false, "No weapon to put down when picking up a dropped weapon!" );
			return false;
		}
		
		// 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*>( GiveNamedItem( pTranslatedWeaponName, 0, pItem, true ));
		Assert( pNewItem );
		if ( pNewItem )
		{
			CTFWeaponBuilder *pBuilder = dynamic_cast<CTFWeaponBuilder*>( (CBaseEntity*)pNewItem );
			if ( pBuilder )
			{
				pBuilder->SetSubType( GetPlayerClass()->GetData()->m_aBuildable[0] );
			}

			// make sure we removed our current weapon				
			if ( pWeapon )
			{
				// drop current weapon
				Vector vecPackOrigin;
				QAngle vecPackAngles;
				CalculateAmmoPackPositionAndAngles( pWeapon, vecPackOrigin, vecPackAngles );

				bool bShouldThrowHeldWeapon = true;

				// When in the spawn room, you won't throw down your held weapon if you own that weapon.
				// This is to prevent folks from standing near a supply closet and spawning their items
				// over and over and over.
				if ( PointInRespawnRoom( this, WorldSpaceCenter() ) )
				{
					CSteamID playerSteamID;
					GetSteamID( &playerSteamID );
					uint32 nItemAccountID = pWeapon->GetAttributeContainer()->GetItem()->GetAccountID();
					// Stock weapons have accountID 0
					if ( playerSteamID.GetAccountID() == nItemAccountID || nItemAccountID == 0 )
					{
						bShouldThrowHeldWeapon = false;
					}
				}

				if ( bShouldThrowHeldWeapon )
				{
					CTFDroppedWeapon *pNewDroppedWeapon = CTFDroppedWeapon::Create( this, vecPackOrigin, vecPackAngles, pWeapon->GetWorldModel(), pWeapon->GetAttributeContainer()->GetItem() );
					if ( pNewDroppedWeapon )
					{
						pNewDroppedWeapon->InitDroppedWeapon( this, pWeapon, true );
					}
				}

				Weapon_Detach( pWeapon );
				UTIL_Remove( pWeapon );
			}
				
			CBaseCombatWeapon *pLastWeapon = GetLastWeapon();
			pNewItem->MarkAttachedEntityAsValidated();
			pNewItem->GiveTo( this );
			Weapon_SetLast( pLastWeapon );
			
			pDroppedWeapon->InitPickedUpWeapon( this, pNewItem );

			// can't use the weapon we just picked up?
			if ( !Weapon_CanSwitchTo( pNewItem ) )
			{
				// try next best thing we can use
				SwitchToNextBestWeapon( pNewItem );
			}

			// delay pickup weapon message
			m_flSendPickupWeaponMessageTime = gpGlobals->curtime + 0.1f;

			return true;
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::TryToPickupDroppedWeapon()
{
	if ( !CanAttack() )
		return false;

	if ( GetActiveWeapon() && ( GetActiveWeapon()->m_flNextPrimaryAttack > gpGlobals->curtime ) )
		return false;

	CTFDroppedWeapon *pDroppedWeapon = GetDroppedWeaponInRange();
	if ( pDroppedWeapon && !pDroppedWeapon->IsMarkedForDeletion() )
	{
		if ( PickupWeaponFromOther( pDroppedWeapon ) )
		{
			UTIL_Remove( pDroppedWeapon );
			return true;
		}
	}
	
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::AddCustomAttribute( const char *pszAttributeName, float flVal, float flDuration /*= -1.f*/ )
{
	float flExpireTime = flDuration > 0 ? gpGlobals->curtime + flDuration : flDuration;
	int iIndex = m_mapCustomAttributes.Find( pszAttributeName );
	if ( iIndex == m_mapCustomAttributes.InvalidIndex() )
	{
		m_mapCustomAttributes.Insert( pszAttributeName, flExpireTime );
	}
	else
	{
		// stomp the previous expire time for now
		m_mapCustomAttributes[iIndex] = flExpireTime;
	}

	// just stomp the value
	m_Shared.ApplyAttributeToPlayer( pszAttributeName, flVal );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveCustomAttribute( const char *pszAttributeName )
{
	int iIndex = m_mapCustomAttributes.Find( pszAttributeName );
	if ( iIndex != m_mapCustomAttributes.InvalidIndex() )
	{
		m_Shared.RemoveAttributeFromPlayer( pszAttributeName );
		m_mapCustomAttributes.RemoveAt( iIndex );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::UpdateCustomAttributes()
{
	// check if we should remove custom attributes from player
	bool bShouldCheckCustomAttributes = m_mapCustomAttributes.Count() > 0;
	while ( bShouldCheckCustomAttributes )
	{
		bShouldCheckCustomAttributes = false;
		FOR_EACH_MAP_FAST( m_mapCustomAttributes, i )
		{
			float flExpireTime = m_mapCustomAttributes[i];
			if ( flExpireTime > 0 && gpGlobals->curtime > flExpireTime )
			{
				const char *pszAttributeName = m_mapCustomAttributes.Key( i );
				m_Shared.RemoveAttributeFromPlayer( pszAttributeName );
				m_mapCustomAttributes.RemoveAt( i );

				bShouldCheckCustomAttributes = true;
				break;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFPlayer::RemoveAllCustomAttributes()
{
	FOR_EACH_MAP_FAST( m_mapCustomAttributes, i )
	{
		const char *pszAttributeName = m_mapCustomAttributes.Key( i );
		m_Shared.RemoveAttributeFromPlayer( pszAttributeName );
	}
	m_mapCustomAttributes.RemoveAll();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::ShouldForceTransmitsForTeam( int iTeam )
{ 
	return ( ( GetTeamNumber() == TEAM_SPECTATOR ) || 
			 ( ( GetTeamNumber() == iTeam ) && ( m_Shared.InCond( TF_COND_TEAM_GLOWS ) || !IsAlive() ) ) );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::ShouldGetBonusPointsForExtinguishEvent( int userID )
{
	int iIndex = m_PlayersExtinguished.Find( userID );
	if ( iIndex != m_PlayersExtinguished.InvalidIndex() )
	{
		if ( ( gpGlobals->curtime - m_PlayersExtinguished[iIndex] ) < 20.f )
			return false;

		m_PlayersExtinguished[iIndex] = gpGlobals->curtime;
	}
	else
	{
		m_PlayersExtinguished.Insert( userID, gpGlobals->curtime );
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFPlayer::IsTruceValidForEnt( void ) const
{
	if ( PointInRespawnRoom( this, WorldSpaceCenter(), true ) )
		return false;

	return true;
}