1HEADmaster

1 files changed, 12134 insertions, 0 deletions

diff --git a/game/client/tf/c_tf_player.cpp b/game/client/tf/c_tf_player.cpp
new file mode 100644
index 0000000..e3c52ad
--- /dev/null
+++ b/game/client/tf/c_tf_player.cpp
@@ -0,0 +1,12134 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#include "cbase.h"
+#include "c_tf_player.h"
+#include "c_user_message_register.h"
+#include "view.h"
+#include "iclientvehicle.h"
+#include "ivieweffects.h"
+#include "input.h"
+#include "IEffects.h"
+#include "fx.h"
+#include "c_basetempentity.h"
+#include "hud_macros.h"
+#include "engine/ivdebugoverlay.h"
+#include "smoke_fog_overlay.h"
+#include "playerandobjectenumerator.h"
+#include "bone_setup.h"
+#include "in_buttons.h"
+#include "r_efx.h"
+#include "dlight.h"
+#include "shake.h"
+#include "cl_animevent.h"
+#include "animation.h"
+#include "choreoscene.h"
+#include "tf_weaponbase.h"
+#include "c_tf_playerresource.h"
+#include "toolframework/itoolframework.h"
+#include "tier1/KeyValues.h"
+#include "tier0/vprof.h"
+#include "prediction.h"
+#include "effect_dispatch_data.h"
+#include "c_te_effect_dispatch.h"
+#include "tf_fx_muzzleflash.h"
+#include "tf_gamerules.h"
+#include "view_scene.h"
+#include "c_baseobject.h"
+#include "toolframework_client.h"
+#include "materialsystem/imaterialvar.h"
+#include "soundenvelope.h"
+#include "voice_status.h"
+#include "clienteffectprecachesystem.h"
+#include "functionproxy.h"
+#include "toolframework_client.h"
+#include "choreoevent.h"
+#include "vguicenterprint.h"
+#include "eventlist.h"
+#include "input.h"
+#include "tf_weapon_medigun.h"
+#include "tf_weapon_pipebomblauncher.h"
+#include "tf_weapon_shovel.h"
+#include "tf_hud_mediccallers.h"
+#include "in_main.h"
+#include "c_team.h"
+#include "collisionutils.h"
+// for spy material proxy
+#include "tf_proxyentity.h"
+#include "materialsystem/imaterial.h"
+#include "materialsystem/imaterialvar.h"
+#include "materialsystem/itexturecompositor.h"
+#include "c_tf_team.h"
+#include "tf_item_inventory.h"
+#include "model_types.h"
+#include "dt_utlvector_recv.h"
+#include "tf_item_wearable.h"
+#include "cam_thirdperson.h"
+#include "c_tf_projectile_arrow.h"
+#include "econ_entity.h"
+#include "ihasowner.h"
+#include "tf_hud_itemeffectmeter.h"
+#include "replay/vgui/replayinputpanel.h"
+#include "tf_replay.h"
+#include "netadr.h"
+#include "input.h"
+
+#include "gcsdk/gcclientsdk.h"
+#include "econ_gcmessages.h"
+#include "rtime.h"
+#include "networkstringtable_clientdll.h"
+#include "replay/ireplaymanager.h"
+#include "gc_clientsystem.h"
+#include "c_entitydissolve.h"
+#include "tf_viewmodel.h"
+#include "player_vs_environment/c_tf_upgrades.h"
+#include "sourcevr/isourcevirtualreality.h"
+#include "tempent.h"
+#include "confirm_dialog.h"
+#include "c_tf_weapon_builder.h"
+#include "tf_shared_content_manager.h"
+#include "baseanimatedtextureproxy.h"
+#include "econ_entity.h"
+#include "halloween/tf_weapon_spellbook.h"
+#include "tf_weapon_grapplinghook.h"
+#include "tf_logic_robot_destruction.h"
+#include "econ_notifications.h"
+#include "tf_weapon_buff_item.h"
+#include "tf_dropped_weapon.h"
+#include "tf_hud_notification_panel.h"
+#include "tf_dropped_weapon.h"
+#include "tf_hud_passtime_reticle.h"
+#include "passtime_convars.h"
+#include "c_tf_passtime_logic.h"
+#include "tf_weapon_passtime_gun.h"
+#include "eiface.h"
+#include "filesystem.h"
+#include "debugoverlay_shared.h"
+#include "tf_hud_chat.h"
+#include "tf_item_powerup_bottle.h"
+#include <vgui_controls/AnimationController.h>
+
+#ifdef STAGING_ONLY
+#include "tf_matchmaking_shared.h"
+#include "tier2/keyvaluesmacros.h"
+#endif // STAGING_ONLY
+
+#if defined( REPLAY_ENABLED )
+#include "replay/ienginereplay.h"
+#endif
+
+#if defined( CTFPlayer )
+#undef CTFPlayer
+#endif
+
+#include "materialsystem/imesh.h"		//for materials->FindMaterial
+#include "iviewrender.h"				//for view->
+
+// NVNT haptics system interface
+#include "c_tf_haptics.h"
+
+// memdbgon must be the last include file in a .cpp file!!!
+#include "tier0/memdbgon.h"
+
+
+using namespace GCSDK;
+
+static_assert( TEAM_UNASSIGNED == 0, "If this assert fires, update the assert and the enum in ctexturecompositor.cpp which specifies team colors" );
+static_assert( TF_TEAM_RED == 2, "If this assert fires, update the assert and the enum in ctexturecompositor.cpp which specifies team colors" );
+static_assert( TF_TEAM_BLUE == 3, "If this assert fires, update the assert and the enum in ctexturecompositor.cpp which specifies team colors" );
+
+// Forward decl
+CEconItemView *GetEconItemViewFromProxyEntity( void *pEntity );
+C_TFPlayer *GetOwnerFromProxyEntity( void *pEntity );
+
+// --------------------------------------------------------------------------------
+// Local Convar Helper Function
+// --------------------------------------------------------------------------------
+void VisionMode_ChangeCallback( IConVar *pConVar, char const *pOldString, float flOldValue )
+{
+	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( pLocalPlayer )
+	{
+		pLocalPlayer->CalculateVisionUsingCurrentFlags();
+	}
+}
+
+#ifdef _DEBUG
+CON_COMMAND_F ( tf_test_bomb, "Test halloween bomb", 0 )
+{
+	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pLocalPlayer )
+		return;
+
+	C_TFPlayer *pPlayer = ToTFPlayer( pLocalPlayer );
+	if ( !pPlayer )
+		return;
+
+	pPlayer->CreateBombonomiconHint();
+}
+
+ConVar test_vision_off( "test_vision_off", "0", FCVAR_NONE, "Force vision modes off!", VisionMode_ChangeCallback );
+ConVar test_pyrovision( "test_pyrovision", "0", FCVAR_NONE, "Force Pyrovision on!", VisionMode_ChangeCallback );
+ConVar test_romevision( "test_romevision", "0", FCVAR_NONE, "Force Romevision on!", VisionMode_ChangeCallback );
+ConVar test_halloweenvision( "test_halloweenvision", "0", FCVAR_NONE, "Force halloween vision on!", VisionMode_ChangeCallback );
+#endif
+
+// These are all permanently STAGING_ONLY
+#ifdef STAGING_ONLY
+	ConVar tf_paint_kit_disable( "tf_paint_kit_disable", "0", FCVAR_NONE, "Set to disable using paintkits completely." );
+	ConVar tf_paint_kit_team_override( "tf_paint_kit_team_override", "-1", FCVAR_NONE, "Set to -1:disabled, 0:TF_TEAM_RED, 1:TF_TEAM_BLUE" );
+	ConVar tf_paint_kit_seed_override( "tf_paint_kit_seed_override", "0", FCVAR_NONE, "Set to none-0 will force composite weapon skin to use this as random seed number." );
+	ConVar tf_paint_kit_force_regen( "tf_paint_kit_force_regen", "0", FCVAR_NONE, "Set to 1 to force regen after every generation. (dev only)" );
+	ConVar tf_paint_kit_generating_icons( "tf_paint_kit_generating_icons", "0", FCVAR_NONE, "Only Set by the Icon Generating System." );
+	extern ConVar tf_paint_kit_force_wear;
+
+	KeyValues *s_kvOverridePaintkit = NULL;
+	bool s_bIsPaintkitOverrideSet = false;
+
+	void LoadPaintKit( const char* pszFile )
+	{
+		//scripts\items\unencrypted\paintkits
+		static char pszPaintkitFile[MAX_PATH] = { '\0' };
+		if ( pszFile )
+		{
+			V_sprintf_safe( pszPaintkitFile, "scripts/items/unencrypted/paintkits/%s.paintkit", pszFile );
+		}
+
+		if ( pszPaintkitFile[0] == '\0' )
+			return;
+
+		// Make sure we have a file system
+		if ( !g_pFullFileSystem || !g_pFullFileSystem->FileExists( pszPaintkitFile ) )
+		{
+			Msg( "Unable to load %s from File System \n", pszPaintkitFile );
+			return;
+		}
+
+		if ( s_kvOverridePaintkit )
+		{
+			s_kvOverridePaintkit->deleteThis();
+			s_kvOverridePaintkit = NULL;
+		}
+
+		// Parse the KeyValues
+		s_kvOverridePaintkit = new KeyValues( "paintkit" );
+		if ( !s_kvOverridePaintkit->LoadFromFile( g_pFullFileSystem, pszPaintkitFile ) )
+		{
+			Msg( "Unable to read KeyValues from %s \n", pszPaintkitFile );
+			return;
+		}
+
+		HandleKeyValuesMacros( s_kvOverridePaintkit );
+
+		Msg( "Setting %s as Paintkit override.\nCall with no args to disable\ntf_paint_kit_force_regen set to 1\n", pszPaintkitFile );
+		s_bIsPaintkitOverrideSet = true;
+	}
+
+	CON_COMMAND_F( tf_paint_kit_override_file, "Set a override paintkit file", FCVAR_NONE )
+	{
+		// Enable force regen
+		tf_paint_kit_force_regen.SetValue( 1 );
+		s_bIsPaintkitOverrideSet = false;
+
+		// Take the con var
+		if ( args.ArgC() <= 1 )
+		{
+			Msg( "No paintkit file specified, turning override off.\nYou may want to set tf_paint_kit_force_regen to 0\n" );
+			return;
+		}
+
+		const char *pszFile = args.Arg( 1 );
+		LoadPaintKit( pszFile );
+	}
+
+	CON_COMMAND( tf_paint_kit_override_refresh, "Refresh the current override paint kit file" )
+	{
+		if ( !s_bIsPaintkitOverrideSet )
+			return;
+
+		LoadPaintKit( NULL );
+	}
+
+#endif
+
+ConVar tf_playergib_forceup( "tf_playersgib_forceup", "1.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "Upward added velocity for gibs." );
+ConVar tf_playergib_force( "tf_playersgib_force", "500.0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "Gibs force." );
+ConVar tf_playergib_maxspeed( "tf_playergib_maxspeed", "400", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY, "Max gib speed." );
+
+ConVar tf_always_deathanim( "tf_always_deathanim", "0", FCVAR_CHEAT, "Force death anims to always play." );
+
+ConVar tf_clientsideeye_lookats( "tf_clientsideeye_lookats", "1", FCVAR_NONE, "When on, players will turn their pupils to look at nearby players." );
+
+extern ConVar tf_halloween_kart_boost_recharge;
+extern ConVar tf_halloween_kart_boost_duration;
+
+extern ConVar cl_thirdperson;
+
+#ifdef STAGING_ONLY
+ConVar test_local_player_skin_override( "test_local_player_skin_override", "-1", FCVAR_CHEAT, "If >= 0, force this skin index to be used by the local player model." );
+ConVar tf_test_setkillcount( "tf_test_setkillcount", "0", FCVAR_NONE, "Force a kill streak count for eye glow testing" );
+
+extern ConVar tf_random_item_min;
+extern ConVar tf_random_item_max;
+
+extern ConVar tf_killstreak_eyeglow;
+extern ConVar tf_killstreak_color;
+extern ConVar tf_eyeglow_wip;
+
+ConVar tf_sheen_all( "tf_sheen_all", "0", FCVAR_NONE, "When on, enables sheens on all weapons" );
+ConVar tf_sheen_fast( "tf_sheen_fast", "0", FCVAR_NONE, "When on, no delay's between sheens" );
+ConVar tf_sheen_shader_override( "tf_sheen_shader_override", "0", FCVAR_NONE, "Set for shader effect override" );
+
+ConVar tf_sheen_color_override_r( "tf_sheen_color_override_r", "0", FCVAR_HIDDEN, "Set by ConCommand tf_sheen_color_override" );
+ConVar tf_sheen_color_override_g( "tf_sheen_color_override_g", "0", FCVAR_HIDDEN, "Set by ConCommand tf_sheen_color_override" );
+ConVar tf_sheen_color_override_b( "tf_sheen_color_override_b", "0", FCVAR_HIDDEN, "Set by ConCommand tf_sheen_color_override" );
+ConVar tf_sheen_color_override_a( "tf_sheen_color_override_a", "0", FCVAR_HIDDEN, "Set by ConCommand tf_sheen_color_override" );
+
+CON_COMMAND_F ( tf_sheen_color_override, "Sheen Color Override RGBA 0-255", 0 )
+{
+	if ( args.ArgC() < 5 )
+	{
+		Msg( "requires 4 inputs, r g b a (in 0 - 255 range) \n" );
+		return;
+	}
+
+	float r = atof( args.Arg(1) ) / 255.0f;
+	float g = atof( args.Arg(2) ) / 255.0f;
+	float b = atof( args.Arg(3) ) / 255.0f;
+	float a = atof( args.Arg(4) ) / 255.0f;
+
+	tf_sheen_color_override_r.SetValue( r );
+	tf_sheen_color_override_g.SetValue( g );
+	tf_sheen_color_override_b.SetValue( b );
+	tf_sheen_color_override_a.SetValue( a );
+}
+
+ConVar cl_taunt_max_turn_speed( "cl_taunt_max_turn_speed", "0", FCVAR_HIDDEN | FCVAR_CHEAT );
+ConVar cl_halloween_kart_turn_speed( "cl_halloween_kart_turn_speed", "100" );
+#endif // Staging only
+
+ConVar tf_sheen_framerate( "tf_sheen_framerate", "25", FCVAR_NONE | FCVAR_HIDDEN, "Set Sheen Frame Rate" );
+
+extern ConVar tf_killstreak_alwayson;
+
+ConVar tf_sheen_alpha_firstperson( "tf_sheen_alpha_firstperson", "0.1", FCVAR_NONE, "Set the Alpha Value for first person sheens" );
+ConVar tf_killstreakeyes_minkills( "tf_killstreakeyes_minkills", "5", FCVAR_DEVELOPMENTONLY, "min kills to get base eyeglow" );
+ConVar tf_killstreakeyes_maxkills( "tf_killstreakeyes_maxkills", "10", FCVAR_DEVELOPMENTONLY, "kills to get the max eye glow effect" );
+
+//ConVar spectate_random_server_basetime( "spectate_random_server_basetime", "240", FCVAR_DEVELOPMENTONLY );
+
+ConVar cl_autorezoom( "cl_autorezoom", "1", FCVAR_USERINFO | FCVAR_ARCHIVE, "When set to 1, sniper rifle will re-zoom after firing a zoomed shot." );
+ConVar tf_remember_activeweapon( "tf_remember_activeweapon", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE | FCVAR_USERINFO, "Setting this to 1 will make the active weapon persist between lives." );
+ConVar tf_remember_lastswitched( "tf_remember_lastswitched", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE | FCVAR_USERINFO, "Setting this to 1 will make the 'last weapon' persist between lives." );
+ConVar cl_autoreload( "cl_autoreload", "1", FCVAR_USERINFO | FCVAR_ARCHIVE, "When set to 1, clip-using weapons will automatically be reloaded whenever they're not being fired." );
+
+ConVar tf_respawn_on_loadoutchanges( "tf_respawn_on_loadoutchanges", "1", FCVAR_ARCHIVE, "When set to 1, you will automatically respawn whenever you change loadouts inside a respawn zone." );
+
+ConVar sb_dontshow_maxplayer_warning( "sb_dontshow_maxplayer_warning", "0", FCVAR_ARCHIVE );
+ConVar sb_close_browser_on_connect( "sb_close_browser_on_connect", "1", FCVAR_ARCHIVE );
+
+ConVar tf_spectate_pyrovision( "tf_spectate_pyrovision", "0", FCVAR_ARCHIVE, "When on, spectator will see the world with Pyrovision active", VisionMode_ChangeCallback );
+ConVar tf_replay_pyrovision( "tf_replay_pyrovision", "0", FCVAR_ARCHIVE, "When on, replays will be seen with Pyrovision active", VisionMode_ChangeCallback );
+
+ConVar tf_taunt_first_person( "tf_taunt_first_person", "0", FCVAR_NONE, "1 = taunts remain first-person" );
+
+ConVar tf_romevision_opt_in( "tf_romevision_opt_in", "0", FCVAR_ARCHIVE, "Enable Romevision in Mann vs. Machine mode when available." );
+ConVar tf_romevision_skip_prompt( "tf_romevision_skip_prompt", "0", FCVAR_ARCHIVE, "If nonzero, skip the prompt about sharing Romevision." );
+
+#ifdef STAGING_ONLY
+extern ConVar tf_bountymode_showhealth;
+#endif // STAGING_ONLY
+
+#define BDAY_HAT_MODEL		"models/effects/bday_hat.mdl"
+#define BOMB_HAT_MODEL		"models/props_lakeside_event/bomb_temp_hat.mdl"
+#define BOMBONOMICON_MODEL  "models/props_halloween/bombonomicon.mdl"
+
+IMaterial	*g_pHeadLabelMaterial[2] = { NULL, NULL }; 
+void	SetupHeadLabelMaterials( void );
+
+extern CBaseEntity *BreakModelCreateSingle( CBaseEntity *pOwner, breakmodel_t *pModel, const Vector &position, 
+										   const QAngle &angles, const Vector &velocity, const AngularImpulse &angVelocity, int nSkin, const breakablepropparams_t &params );
+
+extern int EconWear_ToIntCategory( float flWear );
+
+const char *g_pszHeadGibs[] =
+{
+	"",
+	"models/player\\gibs\\scoutgib007.mdl",
+	"models/player\\gibs\\snipergib005.mdl",
+	"models/player\\gibs\\soldiergib007.mdl",
+	"models/player\\gibs\\demogib006.mdl",
+	"models/player\\gibs\\medicgib007.mdl",
+	"models/player\\gibs\\heavygib007.mdl",
+	"models/player\\gibs\\pyrogib008.mdl",
+	"models/player\\gibs\\spygib007.mdl",
+	"models/player\\gibs\\engineergib006.mdl",
+};
+
+const char *g_pszBotHeadGibs[] =
+{
+	"",
+	"models/bots\\gibs\\scoutbot_gib_head.mdl",
+	"models/bots\\gibs\\sniperbot_gib_head.mdl",
+	"models/bots\\gibs\\soldierbot_gib_head.mdl",
+	"models/bots\\gibs\\demobot_gib_head.mdl",
+	"models/bots\\gibs\\medicbot_gib_head.mdl",
+	"models/bots\\gibs\\heavybot_gib_head.mdl",
+	"models/bots\\gibs\\pyrobot_gib_head.mdl",
+	"models/bots\\gibs\\spybot_gib_head.mdl",
+	"models/bots\\gibs\\engineerbot_gib_head.mdl",
+};
+
+const char *pszHeadLabelNames[] =
+{
+	"effects/speech_voice_red",
+	"effects/speech_voice_blue"
+};
+
+extern SkyBoxMaterials_t s_PyroSkyboxMaterials;
+
+#define TF_PLAYER_HEAD_LABEL_RED 0
+#define TF_PLAYER_HEAD_LABEL_BLUE 1
+
+CLIENTEFFECT_REGISTER_BEGIN( PrecacheInvuln )
+CLIENTEFFECT_MATERIAL( "models/effects/invulnfx_blue.vmt" )
+CLIENTEFFECT_MATERIAL( "models/effects/invulnfx_red.vmt" )
+CLIENTEFFECT_REGISTER_END()
+
+// *********************************************************************************************************
+// KillStreak Effect Data
+// *********************************************************************************************************
+struct killstreak_params_t
+{
+	killstreak_params_t ( int iShaderIndex, const char *pTexture, bool bHasTeamColor,
+		int sheen_r,  int sheen_g,  int sheen_b,  int sheen_a, 
+		int color1_r, int color1_g, int color1_b, int color1_a, 
+		int color2_r, int color2_g, int color2_b, int color2_a
+		) {
+			m_iShaderIndex = iShaderIndex;
+			m_pTexture = pTexture;
+
+			m_bHasTeamColor = bHasTeamColor;
+
+			m_sheen_r = (float)sheen_r / 255.0f;
+			m_sheen_g = (float)sheen_g / 255.0f;
+			m_sheen_b = (float)sheen_b / 255.0f; 
+			m_sheen_a = (float)sheen_a / 255.0f;
+
+			m_color1_r = (float)color1_r / 255.0f;
+			m_color1_g = (float)color1_g / 255.0f;
+			m_color1_b = (float)color1_b / 255.0f; 
+			m_color1_a = (float)color1_a / 255.0f;
+
+			m_color2_r = (float)color2_r / 255.0f;
+			m_color2_g = (float)color2_g / 255.0f;
+			m_color2_b = (float)color2_b / 255.0f; 
+			m_color2_a = (float)color2_a / 255.0f;
+	}
+
+	int			m_iShaderIndex;
+	bool		m_bHasTeamColor;
+	const char *m_pTexture;
+	float m_sheen_r, m_sheen_g, m_sheen_b, m_sheen_a;
+	float m_color1_r, m_color1_g, m_color1_b, m_color1_a;
+	float m_color2_r, m_color2_g, m_color2_b, m_color2_a;
+};
+
+// *********************************************************************************************************
+// Base Sheen Colors (Team Red)
+static const killstreak_params_t g_KillStreakEffectsBase[] =
+{
+	killstreak_params_t( 0, NULL, false,	0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0, 0 ),	// Empty (Index 0)
+	killstreak_params_t( 0, "Effects/AnimatedSheen/animatedsheen0", true,	200, 20,  15,  255, 255, 118, 118, 255, 255, 35,  28,  255 ),
+	killstreak_params_t( 0, "Effects/AnimatedSheen/animatedsheen0", false,	242, 172, 10,  255, 255, 237, 138, 255, 255, 213, 65,  255 ),
+	killstreak_params_t( 0, "Effects/AnimatedSheen/animatedsheen0", false,	255, 75,  5,   255, 255, 111, 5,   255, 255, 137, 31,  255 ),
+	killstreak_params_t( 0, "Effects/AnimatedSheen/animatedsheen0", false,	100, 255, 10,  255, 230, 255, 60,  255, 193, 255, 61,  255 ),
+	killstreak_params_t( 0, "Effects/AnimatedSheen/animatedsheen0", false,	40,  255, 70,  255, 103, 255, 121, 255, 165, 255, 193, 255 ),
+	killstreak_params_t( 0, "Effects/AnimatedSheen/animatedsheen0", false,	105, 20,  255, 255, 105, 20,  255, 255, 185, 145, 255, 255 ),
+	killstreak_params_t( 0, "Effects/AnimatedSheen/animatedsheen0", false,	255, 30,  255, 255, 255, 120, 255, 255, 255, 176, 217, 255 ),
+};
+// *********************************************************************************************************
+// Optional Team Color
+static const killstreak_params_t g_KillStreakEffectsBlue[] =
+{
+	killstreak_params_t( 0, NULL, false,	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ),	// Empty (Index 0)
+	killstreak_params_t( 0, "Effects/AnimatedSheen/animatedsheen0", true, 40, 98, 200, 255, 0, 92, 255, 255, 134, 203, 243, 255 ),
+};
+
+// thirdperson medieval
+static ConVar tf_medieval_thirdperson( "tf_medieval_thirdperson", "0", FCVAR_CLIENTDLL | FCVAR_ARCHIVE , "Turns on third-person camera in medieval mode." );
+static ConVar tf_medieval_cam_idealdist( "tf_medieval_cam_idealdist", "125", FCVAR_CLIENTDLL | FCVAR_CHEAT );	 // thirdperson distance
+static ConVar tf_medieval_cam_idealdistright( "tf_medieval_cam_idealdistright", "25", FCVAR_CLIENTDLL | FCVAR_CHEAT );	 // thirdperson distance
+static ConVar tf_medieval_cam_idealdistup( "tf_medieval_cam_idealdistup", "-10", FCVAR_CLIENTDLL | FCVAR_CHEAT );	 // thirdperson distance
+static ConVar tf_medieval_cam_idealpitch( "tf_medieval_cam_idealpitch", "0", FCVAR_CLIENTDLL | FCVAR_CHEAT );	 // thirdperson pitch
+extern ConVar cam_idealpitch;
+extern ConVar tf_allow_taunt_switch;
+
+static void PromptAcceptReviveCallback( bool bCancel, void *pContext )
+{
+	if ( bCancel )
+	{
+		KeyValues *kv = new KeyValues( "MVM_Revive_Response" );
+		kv->SetBool( "accepted", false );
+		engine->ServerCmdKeyValues( kv );
+	}
+}
+
+
+C_TFPlayerPreviewEffect g_PlayerPreviewEffect;
+
+
+C_TFPlayerPreviewEffect::C_TFPlayerPreviewEffect() :
+	m_nPreviewEffect(PREVIEW_EFFECT_NONE)
+,	m_nTeam(-1)
+{
+}
+
+void C_TFPlayerPreviewEffect::SetTeam(int nTeam)
+{
+	if ( nTeam == m_nTeam )
+		return;
+
+	m_nTeam = nTeam;
+
+	const char *pszMaterial = NULL;
+	switch ( m_nTeam )
+	{
+	case TF_TEAM_BLUE:	
+		pszMaterial = "models/effects/invulnfx_blue.vmt";
+		break;
+	case TF_TEAM_RED:	
+		pszMaterial = "models/effects/invulnfx_red.vmt";
+		break;
+	default:
+		break;
+	}
+	if ( pszMaterial )
+	{
+		m_InvulnerableMaterial.Init( pszMaterial, TEXTURE_GROUP_CLIENT_EFFECTS );
+	}
+	else
+	{
+		m_InvulnerableMaterial.Shutdown();
+	}
+}
+
+void C_TFPlayerPreviewEffect::Reset()
+{
+	SetEffect(PREVIEW_EFFECT_NONE);
+	SetTeam(-1);
+}
+
+
+C_EntityDissolve *DissolveEffect( C_BaseEntity *pTarget, float flTime );
+
+void SetAppropriateCamera( C_TFPlayer *pPlayer )
+{
+	if ( pPlayer->IsLocalPlayer() == false )
+		return;
+
+	if ( TFGameRules() &&
+		( ( TFGameRules()->IsInMedievalMode() && tf_medieval_thirdperson.GetBool() )
+		|| pPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) ) )
+	{
+		g_ThirdPersonManager.SetForcedThirdPerson( true );
+		Vector offset( tf_medieval_cam_idealdist.GetFloat(), tf_medieval_cam_idealdistright.GetFloat(), tf_medieval_cam_idealdistup.GetFloat() );
+		g_ThirdPersonManager.SetDesiredCameraOffset( offset );
+		cam_idealpitch.SetValue( tf_medieval_cam_idealpitch.GetFloat() );
+
+		::input->CAM_ToThirdPerson();
+
+		pPlayer->ThirdPersonSwitch( true );
+	}
+	else
+	{
+		g_ThirdPersonManager.SetForcedThirdPerson( false );
+	}
+}
+
+// -------------------------------------------------------------------------------- //
+// Player animation event. Sent to the client when a player fires, jumps, reloads, etc..
+// -------------------------------------------------------------------------------- //
+
+class C_TEPlayerAnimEvent : public C_BaseTempEntity
+{
+public:
+	DECLARE_CLASS( C_TEPlayerAnimEvent, C_BaseTempEntity );
+	DECLARE_CLIENTCLASS();
+
+	virtual void PostDataUpdate( DataUpdateType_t updateType )
+	{
+		VPROF( "C_TEPlayerAnimEvent::PostDataUpdate" );
+
+		// Create the effect.
+		if ( m_iPlayerIndex == TF_PLAYER_INDEX_NONE )
+			return;
+
+		EHANDLE hPlayer = cl_entitylist->GetNetworkableHandle( m_iPlayerIndex );
+		if ( !hPlayer )
+			return;
+
+		C_TFPlayer *pPlayer = dynamic_cast< C_TFPlayer* >( hPlayer.Get() );
+		if ( pPlayer && !pPlayer->IsDormant() )
+		{
+			// Ignore anim events that are also played on the client.
+			PlayerAnimEvent_t animEvent = (PlayerAnimEvent_t) m_iEvent.Get();
+			switch ( animEvent )
+			{
+			case PLAYERANIMEVENT_STUN_BEGIN:
+			case PLAYERANIMEVENT_STUN_MIDDLE:
+			case PLAYERANIMEVENT_STUN_END:
+			case PLAYERANIMEVENT_PASSTIME_THROW_BEGIN:
+			case PLAYERANIMEVENT_PASSTIME_THROW_MIDDLE:
+			case PLAYERANIMEVENT_PASSTIME_THROW_END:
+			case PLAYERANIMEVENT_PASSTIME_THROW_CANCEL:
+				break; // ignore these
+			default:
+				pPlayer->DoAnimationEvent( animEvent, m_nData );
+				break;
+			};
+		}	
+	}
+
+public:
+	CNetworkVar( int, m_iPlayerIndex );
+	CNetworkVar( int, m_iEvent );
+	CNetworkVar( int, m_nData );
+};
+
+IMPLEMENT_CLIENTCLASS_EVENT( C_TEPlayerAnimEvent, DT_TEPlayerAnimEvent, CTEPlayerAnimEvent );
+
+//-----------------------------------------------------------------------------
+// Data tables and prediction tables.
+//-----------------------------------------------------------------------------
+BEGIN_RECV_TABLE_NOBASE( C_TEPlayerAnimEvent, DT_TEPlayerAnimEvent )
+	RecvPropInt( RECVINFO( m_iPlayerIndex ) ),
+	RecvPropInt( RECVINFO( m_iEvent ) ),
+	RecvPropInt( RECVINFO( m_nData ) )
+END_RECV_TABLE()
+
+
+//=============================================================================
+//
+// Ragdoll
+//
+// ----------------------------------------------------------------------------- //
+// Client ragdoll entity.
+// ----------------------------------------------------------------------------- //
+ConVar cl_ragdoll_physics_enable( "cl_ragdoll_physics_enable", "1", 0, "Enable/disable ragdoll physics." );
+ConVar cl_ragdoll_fade_time( "cl_ragdoll_fade_time", "15", FCVAR_CLIENTDLL );
+ConVar cl_ragdoll_forcefade( "cl_ragdoll_forcefade", "0", FCVAR_CLIENTDLL );
+ConVar cl_ragdoll_pronecheck_distance( "cl_ragdoll_pronecheck_distance", "64", FCVAR_GAMEDLL );
+
+class C_TFRagdoll : public C_BaseFlex
+{
+public:
+
+	DECLARE_CLASS( C_TFRagdoll, C_BaseFlex );
+	DECLARE_CLIENTCLASS();
+	
+	C_TFRagdoll();
+	~C_TFRagdoll();
+
+	virtual void OnDataChanged( DataUpdateType_t type );
+
+	IRagdoll* GetIRagdoll() const;
+
+	void ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName );
+
+	void ClientThink( void );
+
+	// Deal with recording
+	virtual void GetToolRecordingState( KeyValues *msg );
+
+	void StartFadeOut( float fDelay );
+	void EndFadeOut();
+	void DissolveEntity( CBaseEntity* pEnt );
+
+	EHANDLE GetPlayerHandle( void ) 	
+	{
+		if ( m_iPlayerIndex == TF_PLAYER_INDEX_NONE )
+			return NULL;
+		return cl_entitylist->GetNetworkableHandle( m_iPlayerIndex );
+	}
+
+	bool IsRagdollVisible();
+	float GetBurnStartTime() { return m_flBurnEffectStartTime; }
+
+	virtual void BuildTransformations( CStudioHdr *hdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed );
+
+	virtual void SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights );
+
+	bool IsDeathAnim() { return m_bDeathAnim; }
+
+	int GetDamageCustom() { return m_iDamageCustom; }
+
+	virtual bool GetAttachment( int iAttachment, matrix3x4_t &attachmentToWorld );
+
+	int GetClass() { return m_iClass; }
+
+	float GetPercentInvisible( void ) { return m_flPercentInvisible; }
+	bool IsCloaked( void ) { return m_bCloaked; }
+
+	int GetRagdollTeam( void ){ return m_iTeam; }
+
+	float GetHeadScale() const { return m_flHeadScale; }
+	float GetTorsoScale() const { return m_flTorsoScale; }
+	float GetHandScale() const { return m_flHandScale; }
+
+private:
+	
+	C_TFRagdoll( const C_TFRagdoll & ) {}
+
+	void Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity );
+
+	void CreateTFRagdoll();
+	void CreateTFGibs( bool bDestroyRagdoll = true, bool bCurrentPosition = false );
+	void CreateWearableGibs( bool bDisguiseWearables );
+	void CreateTFHeadGib();
+
+	virtual float FrameAdvance( float flInterval );
+
+	bool IsDecapitation();
+	bool IsHeadSmash();
+
+	virtual int	InternalDrawModel( int flags );
+
+private:
+
+	CNetworkVector( m_vecRagdollVelocity );
+	CNetworkVector( m_vecRagdollOrigin );
+	int	  m_iPlayerIndex;
+	float m_fDeathTime;
+	bool  m_bFadingOut;
+	bool  m_bGib;
+	bool  m_bBurning;
+	bool  m_bElectrocuted;
+	bool  m_bBatted;
+	bool  m_bDissolving;
+	bool  m_bFeignDeath;
+	bool  m_bWasDisguised;
+	bool  m_bCloaked;
+	bool  m_bBecomeAsh;
+	int	  m_iDamageCustom;
+	bool  m_bGoldRagdoll;
+	bool  m_bIceRagdoll;
+	CountdownTimer m_freezeTimer;
+	CountdownTimer m_frozenTimer;
+	int	  m_iTeam;
+	int	  m_iClass;
+	float m_flBurnEffectStartTime;	// start time of burning, or 0 if not burning
+	bool  m_bRagdollOn;
+	bool  m_bDeathAnim;				
+	bool  m_bOnGround;
+	bool  m_bFixedConstraints;
+	matrix3x4_t m_mHeadAttachment;
+	bool  m_bBaseTransform;
+	float m_flPercentInvisible;
+	float m_flTimeToDissolve;
+	bool  m_bCritOnHardHit;	// plays the red mist particle effect
+	float m_flHeadScale;
+	float m_flTorsoScale;
+	float m_flHandScale;
+
+	CMaterialReference		m_MaterialOverride;
+
+	CUtlVector<CHandle<CEconWearable > > m_hRagWearables;		// These look like they are no longer used?
+
+	CUtlVector< CHandle< CEconWearable > > m_hClientWearables;	// wearables on the ragdoll that are "following" it
+
+	bool  m_bCreatedWhilePlaybackSkipping;
+};
+
+IMPLEMENT_CLIENTCLASS_DT_NOBASE( C_TFRagdoll, DT_TFRagdoll, CTFRagdoll )
+	RecvPropVector( RECVINFO(m_vecRagdollOrigin) ),
+	RecvPropInt( RECVINFO( m_iPlayerIndex ) ),
+	RecvPropVector( RECVINFO(m_vecForce) ),
+	RecvPropVector( RECVINFO(m_vecRagdollVelocity) ),
+	RecvPropInt( RECVINFO( m_nForceBone ) ),
+	RecvPropBool( RECVINFO( m_bGib ) ),
+	RecvPropBool( RECVINFO( m_bBurning ) ),
+	RecvPropBool( RECVINFO( m_bElectrocuted ) ),
+	RecvPropBool( RECVINFO( m_bFeignDeath ) ),
+	RecvPropBool( RECVINFO( m_bWasDisguised ) ),
+	RecvPropBool( RECVINFO( m_bOnGround ) ),
+	RecvPropBool( RECVINFO( m_bCloaked ) ),
+	RecvPropBool( RECVINFO( m_bBecomeAsh ) ),
+	RecvPropInt( RECVINFO( m_iDamageCustom ) ),
+	RecvPropInt( RECVINFO( m_iTeam ) ),
+	RecvPropInt( RECVINFO( m_iClass ) ),		
+	RecvPropUtlVector( RECVINFO_UTLVECTOR( m_hRagWearables ), 8,	RecvPropEHandle(NULL, 0, 0) ),
+	RecvPropBool( RECVINFO( m_bGoldRagdoll ) ),
+	RecvPropBool( RECVINFO( m_bIceRagdoll ) ),
+	RecvPropBool( RECVINFO( m_bCritOnHardHit ) ),
+	RecvPropFloat( RECVINFO( m_flHeadScale ) ),
+	RecvPropFloat( RECVINFO( m_flTorsoScale ) ),
+	RecvPropFloat( RECVINFO( m_flHandScale ) ),
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  :  - 
+//-----------------------------------------------------------------------------
+C_TFRagdoll::C_TFRagdoll()
+{
+	m_iPlayerIndex = TF_PLAYER_INDEX_NONE;
+	m_fDeathTime = -1;
+	m_bFadingOut = false;
+	m_bGib = false;
+	m_bBurning = false;
+	m_bElectrocuted = false;
+	m_bBatted = false;
+	m_bDissolving = false;
+	m_bFeignDeath = false;
+	m_bWasDisguised = false;
+	m_bCloaked = false;
+	m_bBecomeAsh = false;
+	m_flBurnEffectStartTime = 0.0f;
+	m_iDamageCustom = 0;
+	m_bGoldRagdoll = false;
+	m_bIceRagdoll = false;
+	m_freezeTimer.Invalidate();
+	m_frozenTimer.Invalidate();
+	m_iTeam = -1;
+	m_iClass = -1;
+	m_nForceBone = -1;
+	m_bRagdollOn = false;
+	m_bDeathAnim = false;
+	m_bOnGround = false;
+	m_bBaseTransform = false;
+	m_bFixedConstraints = false;
+	m_flTimeToDissolve = 0.3f;
+	m_bCritOnHardHit = false;
+	m_flHeadScale = 1.f;
+	m_flTorsoScale = 1.f;
+	m_flHandScale = 1.f;
+
+	UseClientSideAnimation();
+
+	m_bCreatedWhilePlaybackSkipping = engine->IsSkippingPlayback();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  :  - 
+//-----------------------------------------------------------------------------
+C_TFRagdoll::~C_TFRagdoll()
+{
+	PhysCleanupFrictionSounds( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pSourceEntity - 
+//-----------------------------------------------------------------------------
+void C_TFRagdoll::Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity )
+{
+	if ( !pSourceEntity )
+		return;
+	
+	VarMapping_t *pSrc = pSourceEntity->GetVarMapping();
+	VarMapping_t *pDest = GetVarMapping();
+    	
+	// Find all the VarMapEntry_t's that represent the same variable.
+	for ( int i = 0; i < pDest->m_Entries.Count(); i++ )
+	{
+		VarMapEntry_t *pDestEntry = &pDest->m_Entries[i];
+		for ( int j=0; j < pSrc->m_Entries.Count(); j++ )
+		{
+			VarMapEntry_t *pSrcEntry = &pSrc->m_Entries[j];
+			if ( !Q_strcmp( pSrcEntry->watcher->GetDebugName(), pDestEntry->watcher->GetDebugName() ) )
+			{
+				pDestEntry->watcher->Copy( pSrcEntry->watcher );
+				break;
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Setup vertex weights for drawing
+//-----------------------------------------------------------------------------
+void C_TFRagdoll::SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights )
+{
+	// While we're dying, we want to mimic the facial animation of the player. Once they're dead, we just stay as we are.
+	EHANDLE hPlayer = GetPlayerHandle();
+	if ( ( hPlayer && hPlayer->IsAlive()) || !hPlayer )
+	{
+		BaseClass::SetupWeights( pBoneToWorld, nFlexWeightCount, pFlexWeights, pFlexDelayedWeights );
+	}
+	else if ( hPlayer )
+	{
+		hPlayer->SetupWeights( pBoneToWorld, nFlexWeightCount, pFlexWeights, pFlexDelayedWeights );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pTrace - 
+//			iDamageType - 
+//			*pCustomImpactName - 
+//-----------------------------------------------------------------------------
+void C_TFRagdoll::ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
+{
+	VPROF( "C_TFRagdoll::ImpactTrace" );
+	IPhysicsObject *pPhysicsObject = VPhysicsGetObject();
+	if( !pPhysicsObject )
+		return;
+
+	Vector vecDir;
+	VectorSubtract( pTrace->endpos, pTrace->startpos, vecDir );
+
+	if ( iDamageType == DMG_BLAST )
+	{
+		// Adjust the impact strength and apply the force at the center of mass.
+		vecDir *= 4000;
+		pPhysicsObject->ApplyForceCenter( vecDir );
+	}
+	else
+	{
+		// Find the apporx. impact point.
+		Vector vecHitPos;  
+		VectorMA( pTrace->startpos, pTrace->fraction, vecDir, vecHitPos );
+		VectorNormalize( vecDir );
+
+		// Adjust the impact strength and apply the force at the impact point..
+		vecDir *= 4000;
+		pPhysicsObject->ApplyForceOffset( vecDir, vecHitPos );	
+	}
+
+	m_pRagdoll->ResetRagdollSleepAfterTime();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  :  - 
+//-----------------------------------------------------------------------------
+void C_TFRagdoll::CreateTFRagdoll()
+{
+	// Get the player.
+	C_TFPlayer *pPlayer = NULL;
+	EHANDLE hPlayer = GetPlayerHandle();
+	if ( hPlayer )
+	{
+		pPlayer = dynamic_cast<C_TFPlayer*>( hPlayer.Get() );
+	}
+
+	int nModelIndex = -1;
+
+	if ( pPlayer && pPlayer->GetPlayerClass() && !pPlayer->ShouldDrawSpyAsDisguised() )
+	{
+		nModelIndex = modelinfo->GetModelIndex( pPlayer->GetPlayerClass()->GetModelName() );
+	}
+	else
+	{
+		TFPlayerClassData_t *pData = GetPlayerClassData( m_iClass );
+		if ( pData )
+		{
+			nModelIndex = modelinfo->GetModelIndex( pData->GetModelName() );
+		}
+	}
+
+	if ( pPlayer )
+	{
+		m_flHeadScale = pPlayer->GetHeadScale();
+		m_flTorsoScale = pPlayer->GetTorsoScale();
+		m_flHandScale = pPlayer->GetHandScale();
+	}
+
+	if ( nModelIndex != -1 )
+	{
+		SetModelIndex( nModelIndex );	
+
+		if ( m_iTeam == TF_TEAM_RED )
+		{
+			m_nSkin = 0;
+		}
+		else
+		{
+			m_nSkin = 1;
+		}
+	}
+
+	// Check for any special player skin override behaviour.
+	if ( pPlayer && pPlayer->BRenderAsZombie() )
+	{
+		C_TFPlayer::AdjustSkinIndexForZombie( m_iClass, m_nSkin );
+	}
+
+	// We check against new-style (special flag to indicate goldification) and old style (custom damage type)
+	// to maintain old demos involving the golden wrench.
+	if ( m_bGoldRagdoll || m_iDamageCustom == TF_DMG_CUSTOM_GOLD_WRENCH )
+	{
+		EmitSound( "Saxxy.TurnGold" );
+		m_bFixedConstraints = true;
+	}
+
+	if ( m_bIceRagdoll )
+	{
+		EmitSound( "Icicle.TurnToIce" );
+		ParticleProp()->Create( "xms_icicle_impact_dryice", PATTACH_ABSORIGIN_FOLLOW );
+		m_freezeTimer.Start( RandomFloat( 0.1f, 0.75f ) );
+		m_frozenTimer.Start( RandomFloat( 9.0f, 11.0f ) );
+	}
+
+#ifdef _DEBUG
+	DevMsg( 2, "CreateTFRagdoll %d %d\n", gpGlobals->framecount, pPlayer ? pPlayer->entindex() : 0 );
+#endif
+
+	if ( pPlayer && !pPlayer->IsDormant() )
+	{
+		// Move my current model instance to the ragdoll's so decals are preserved.
+		pPlayer->SnatchModelInstance( this );
+
+		VarMapping_t *varMap = GetVarMapping();
+
+		// Copy all the interpolated vars from the player entity.
+		// The entity uses the interpolated history to get bone velocity.		
+		if ( !pPlayer->IsLocalPlayer() && pPlayer->IsInterpolationEnabled() )
+		{
+			Interp_Copy( pPlayer );
+
+			SetAbsAngles( pPlayer->GetRenderAngles() );
+			GetRotationInterpolator().Reset();
+
+			m_flAnimTime = pPlayer->m_flAnimTime;
+			SetSequence( pPlayer->GetSequence() );
+			m_flPlaybackRate = pPlayer->GetPlaybackRate();
+		}
+		else
+		{
+			// This is the local player, so set them in a default
+			// pose and slam their velocity, angles and origin
+			SetAbsOrigin( /* m_vecRagdollOrigin : */ pPlayer->GetRenderOrigin() );			
+			SetAbsAngles( pPlayer->GetRenderAngles() );
+			SetAbsVelocity( m_vecRagdollVelocity );
+
+			// Hack! Find a neutral standing pose or use the idle.
+			int iSeq = LookupSequence( "RagdollSpawn" );
+			if ( iSeq == -1 )
+			{
+				Assert( false );
+				iSeq = 0;
+			}			
+			SetSequence( iSeq );
+			SetCycle( 0.0 );
+
+			Interp_Reset( varMap );
+		}
+
+		if ( !m_bFeignDeath || m_bWasDisguised )
+		{
+			pPlayer->RecalcBodygroupsIfDirty();
+			m_nBody = pPlayer->GetBody();
+		}
+	}
+	else
+	{
+		// Overwrite network origin so later interpolation will use this position.
+		SetNetworkOrigin( m_vecRagdollOrigin );
+		SetAbsOrigin( m_vecRagdollOrigin );
+		SetAbsVelocity( m_vecRagdollVelocity );
+
+		Interp_Reset( GetVarMapping() );
+	}
+
+	if ( IsCloaked() )
+	{
+		AddEffects( EF_NOSHADOW );
+	}
+
+	// Play a death anim depending on the custom damage type.
+	bool bPlayDeathInAir = false;
+	int iDeathSeq = -1;
+	if ( pPlayer && !m_bGoldRagdoll )
+	{
+		iDeathSeq = pPlayer->m_Shared.GetSequenceForDeath( this, m_bBurning, m_iDamageCustom );
+
+		if ( m_bDissolving && !m_bGib )
+		{
+			bPlayDeathInAir = true;
+			iDeathSeq = LookupSequence( "dieviolent" );
+		}
+
+		// did we find a death sequence?
+		if ( iDeathSeq > -1 && (m_iDamageCustom != TF_DMG_CUSTOM_TAUNTATK_BARBARIAN_SWING) &&
+			(m_iDamageCustom != TF_DMG_CUSTOM_TAUNTATK_ENGINEER_GUITAR_SMASH) && (m_iDamageCustom != TF_DMG_CUSTOM_TAUNTATK_ALLCLASS_GUITAR_RIFF) )
+		{
+			// we only want to show the death anims 25% of the time, unless this is a demoman kill taunt
+			// always play backstab animations for the ice ragdoll
+			if ( !m_bIceRagdoll && !tf_always_deathanim.GetBool() && (RandomFloat( 0, 1 ) > 0.25f) )
+			{
+				iDeathSeq = -1;
+			}
+		}
+	}
+
+	bool bPlayDeathAnim = cl_ragdoll_physics_enable.GetBool() && (iDeathSeq > -1) && pPlayer;
+
+	if ( !m_bOnGround && bPlayDeathAnim && !bPlayDeathInAir )
+		bPlayDeathAnim = false; // Don't play most death anims in the air (headshot, etc).
+
+	if ( bPlayDeathAnim )
+	{
+		// Set our position for a death anim.
+		SetAbsOrigin( pPlayer->GetRenderOrigin() );			
+		SetAbsAngles( pPlayer->GetRenderAngles() );
+		SetAbsVelocity( Vector(0,0,0) );
+		m_vecForce = Vector(0,0,0);
+
+		// Play the death anim.
+		ResetSequence( iDeathSeq );
+		m_bDeathAnim = true;
+	}
+	else if ( m_bIceRagdoll )
+	{
+		// couldn't play death anim because we were in midair - go ridig immediately
+		m_freezeTimer.Invalidate();
+		m_frozenTimer.Invalidate();
+		m_bFixedConstraints = true;
+	}
+
+	// Fade out the ragdoll in a while
+	StartFadeOut( cl_ragdoll_fade_time.GetFloat() );
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+
+	// Copy over impact attachments.
+	if ( pPlayer )
+	{
+		pPlayer->CreateBoneAttachmentsFromWearables( this, m_bWasDisguised );
+		pPlayer->MoveBoneAttachments( this );
+	}
+
+
+	if ( m_iDamageCustom == TF_DMG_CUSTOM_KART )
+	{
+		m_vecForce *= 100.0f;
+		SetAbsVelocity( GetAbsVelocity() + m_vecForce );
+		ApplyAbsVelocityImpulse( m_vecForce );
+	}
+
+	// Save ragdoll information.
+	if ( cl_ragdoll_physics_enable.GetBool() && !m_bDeathAnim )
+	{
+		// Make us a ragdoll..
+		m_nRenderFX = kRenderFxRagdoll;
+
+		matrix3x4_t boneDelta0[MAXSTUDIOBONES];
+		matrix3x4_t boneDelta1[MAXSTUDIOBONES];
+		matrix3x4_t currentBones[MAXSTUDIOBONES];
+		const float boneDt = 0.05f;
+
+		// We have to make sure that we're initting this client ragdoll off of the same model.
+		// GetRagdollInitBoneArrays uses the *player* Hdr, which may be a different model than
+		// the ragdoll Hdr, if we try to create a ragdoll in the same frame that the player
+		// changes their player model.
+		CStudioHdr *pRagdollHdr = GetModelPtr();
+		CStudioHdr *pPlayerHdr = pPlayer ? pPlayer->GetModelPtr() : NULL;
+
+		bool bChangedModel = false;
+
+		if ( pRagdollHdr && pPlayerHdr )
+		{
+			bChangedModel = pRagdollHdr->GetVirtualModel() != pPlayerHdr->GetVirtualModel();
+
+			// Assert( !bChangedModel && "C_TFRagdoll::CreateTFRagdoll: Trying to create ragdoll with a different model than the player it's based on" );
+		}
+
+		bool bBoneArraysInited;
+		if ( pPlayer && !pPlayer->IsDormant() && !bChangedModel )
+		{
+			bBoneArraysInited = pPlayer->GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
+		}
+		else
+		{
+			bBoneArraysInited = GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
+		}
+		
+		if ( bBoneArraysInited )
+		{
+			InitAsClientRagdoll( boneDelta0, boneDelta1, currentBones, boneDt, m_bFixedConstraints );
+		}
+	}
+	else
+	{
+		ClientLeafSystem()->SetRenderGroup( GetRenderHandle(), RENDER_GROUP_TRANSLUCENT_ENTITY );
+	}
+
+	if ( m_bBurning )
+	{
+		m_flBurnEffectStartTime = gpGlobals->curtime;
+		ParticleProp()->Create( "burningplayer_corpse", PATTACH_ABSORIGIN_FOLLOW );
+	}
+
+	if ( m_bElectrocuted )
+	{
+		const char *pEffectName = ( m_iTeam == TF_TEAM_RED ) ? "electrocuted_red" : "electrocuted_blue";
+		ParticleProp()->Create( pEffectName, PATTACH_ABSORIGIN_FOLLOW );
+		C_BaseEntity::EmitSound( "TFPlayer.MedicChargedDeath" );
+	}
+
+	if ( m_bBecomeAsh && !m_bDissolving && !m_bGib )
+	{
+		ParticleProp()->Create( "drg_fiery_death", PATTACH_ABSORIGIN_FOLLOW );
+		m_flTimeToDissolve = 0.5f;
+	}
+
+	if ( pPlayer->HasBombinomiconEffectOnDeath() && !m_bGib && !m_bDissolving )
+	{
+		m_flTimeToDissolve = 1.2f;
+	}
+
+	// Birthday mode.
+	if ( pPlayer && TFGameRules() && TFGameRules()->IsBirthday() )
+	{
+		AngularImpulse angularImpulse( RandomFloat( 0.0f, 120.0f ), RandomFloat( 0.0f, 120.0f ), 0.0 );
+		breakablepropparams_t breakParams( m_vecRagdollOrigin, GetRenderAngles(), m_vecRagdollVelocity, angularImpulse );
+		breakParams.impactEnergyScale = 1.0f;
+		pPlayer->DropPartyHat( breakParams, m_vecRagdollVelocity.GetForModify() );
+	}
+
+	const char *materialOverrideFilename = NULL;
+
+	if ( m_bFixedConstraints )
+	{
+		if ( m_bGoldRagdoll )
+		{
+			// Gold texture...we've been turned into a golden corpse!
+			materialOverrideFilename = "models/player/shared/gold_player.vmt";
+		}
+	}
+
+	if ( m_bIceRagdoll )
+	{
+		// Ice texture...we've been turned into an ice statue!
+		materialOverrideFilename = "models/player/shared/ice_player.vmt";
+	}
+
+	if ( materialOverrideFilename )
+	{
+		// Ice texture...we've been turned into an ice statue!
+		m_MaterialOverride.Init( materialOverrideFilename, TEXTURE_GROUP_CLIENT_EFFECTS );
+
+		// override all of our wearables, too
+		for ( C_BaseEntity *pEntity = ClientEntityList().FirstBaseEntity(); pEntity; pEntity = ClientEntityList().NextBaseEntity(pEntity) )
+		{
+			if ( pEntity->GetFollowedEntity() == this )
+			{
+				CEconEntity *pItem = dynamic_cast< CEconEntity * >( pEntity );
+				if ( pItem )
+				{
+					pItem->SetMaterialOverride( m_iTeam, materialOverrideFilename );
+				}
+			}
+		}
+	}
+}
+
+float C_TFRagdoll::FrameAdvance( float flInterval )
+{
+	// if we're in the process of becoming an ice statue, freeze
+	if ( m_freezeTimer.HasStarted() && !m_freezeTimer.IsElapsed() )
+	{
+		// play the backstab anim until the timer is up
+		return BaseClass::FrameAdvance( flInterval );
+	}
+
+	if ( m_frozenTimer.HasStarted() )
+	{
+		if ( m_frozenTimer.IsElapsed() )
+		{
+			// holding frozen time is up - turn to a stiff ragdoll and fall over
+			m_frozenTimer.Invalidate();
+
+			m_nRenderFX = kRenderFxRagdoll;
+
+			matrix3x4_t boneDelta0[MAXSTUDIOBONES];
+			matrix3x4_t boneDelta1[MAXSTUDIOBONES];
+			matrix3x4_t currentBones[MAXSTUDIOBONES];
+			const float boneDt = 0.1f;
+			GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
+			InitAsClientRagdoll( boneDelta0, boneDelta1, currentBones, boneDt, true );
+
+			SetAbsVelocity( Vector( 0,0,0 ) );
+			m_bRagdollOn = true;
+		}
+		else
+		{
+			// don't move at all
+			return 0.0f;
+		}
+	}
+
+	float fRes = BaseClass::FrameAdvance( flInterval );
+
+	if ( !m_bRagdollOn && IsSequenceFinished() && m_bDeathAnim )
+	{
+		m_nRenderFX = kRenderFxRagdoll;
+
+		matrix3x4_t boneDelta0[MAXSTUDIOBONES];
+		matrix3x4_t boneDelta1[MAXSTUDIOBONES];
+		matrix3x4_t currentBones[MAXSTUDIOBONES];
+		const float boneDt = 0.1f;
+		if ( !GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt ) )
+		{
+			Warning( "C_TFRagdoll::FrameAdvance GetRagdollInitBoneArrays failed.\n" );
+		}
+		else
+		{
+			InitAsClientRagdoll( boneDelta0, boneDelta1, currentBones, boneDt );
+		}
+
+		SetAbsVelocity( Vector( 0,0,0 ) );
+		m_bRagdollOn = true;
+
+		// Make it fade out.
+		StartFadeOut( cl_ragdoll_fade_time.GetFloat() );
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+	}
+
+	return fRes;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFRagdoll::CreateTFHeadGib( void )
+{
+	C_TFPlayer *pPlayer = NULL;
+	EHANDLE hPlayer = GetPlayerHandle();
+	if ( hPlayer )
+	{
+		pPlayer = dynamic_cast<C_TFPlayer*>( hPlayer.Get() );
+	}
+	if ( pPlayer && ((pPlayer->m_hFirstGib == NULL) || m_bFeignDeath) )
+	{
+		Vector vecVelocity = m_vecForce + m_vecRagdollVelocity;
+		VectorNormalize( vecVelocity );
+
+		pPlayer->CreatePlayerGibs( m_vecRagdollOrigin, vecVelocity, m_vecForce.Length(), m_bBurning, false, true );
+		// Decap Death Camera is disorienting on range Decaps (aka bullets)
+		// Use normal Deathcam
+		if ( m_iDamageCustom == TF_DMG_CUSTOM_HEADSHOT_DECAPITATION )
+		{
+			pPlayer->m_hHeadGib = NULL;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFRagdoll::CreateTFGibs( bool bDestroyRagdoll, bool bCurrentPosition )
+{
+	C_TFPlayer *pPlayer = NULL;
+	EHANDLE hPlayer = GetPlayerHandle();
+	if ( hPlayer )
+	{
+		pPlayer = dynamic_cast<C_TFPlayer*>( hPlayer.Get() );
+	}
+	
+	if ( pPlayer && pPlayer->HasBombinomiconEffectOnDeath() )
+	{
+		m_vecForce *= 2.0f;
+		m_vecForce.z *= 3.0f;
+
+		DispatchParticleEffect( TFGameRules()->IsHolidayActive( kHoliday_Halloween ) ? "bombinomicon_burningdebris_halloween" : "bombinomicon_burningdebris", 
+								bCurrentPosition ? GetAbsOrigin() : m_vecRagdollOrigin, GetAbsAngles() );
+		EmitSound( "Bombinomicon.Explode" );
+	}
+
+	if ( pPlayer && ((pPlayer->m_hFirstGib == NULL) || m_bFeignDeath) )
+	{
+		Vector vecVelocity = m_vecForce + m_vecRagdollVelocity;
+		VectorNormalize( vecVelocity );
+		pPlayer->CreatePlayerGibs( bCurrentPosition ? pPlayer->GetRenderOrigin() : m_vecRagdollOrigin, vecVelocity, m_vecForce.Length(), m_bBurning );
+	}
+
+	if ( pPlayer )
+	{
+		if ( TFGameRules() && TFGameRules()->IsBirthdayOrPyroVision() )
+		{
+			DispatchParticleEffect( "bday_confetti", pPlayer->GetAbsOrigin() + Vector(0,0,32), vec3_angle );
+
+			if ( TFGameRules() && TFGameRules()->IsBirthday() )
+			{
+				C_BaseEntity::EmitSound( "Game.HappyBirthday" );
+			}
+		}
+		else if ( m_bCritOnHardHit && !UTIL_IsLowViolence() )
+		{
+			DispatchParticleEffect( "tfc_sniper_mist", pPlayer->WorldSpaceCenter(), vec3_angle );
+		}
+	}
+
+	if ( bDestroyRagdoll )
+	{
+		EndFadeOut();
+	}
+	else
+	{
+		SetRenderMode( kRenderNone );
+		UpdateVisibility();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Separate from CreateTFGibs so we can easily remove it if we don't like it...
+//-----------------------------------------------------------------------------
+void C_TFRagdoll::CreateWearableGibs( bool bDisguiseWearables )
+{
+	C_TFPlayer *pPlayer = NULL;
+	EHANDLE hPlayer = GetPlayerHandle();
+	if ( hPlayer )
+	{
+		pPlayer = dynamic_cast<C_TFPlayer*>( hPlayer.Get() );
+	}
+	if ( !pPlayer )
+		return;
+
+	Vector vecVelocity = m_vecForce + m_vecRagdollVelocity;
+	VectorNormalize( vecVelocity );
+	pPlayer->CreatePlayerGibs( m_vecRagdollOrigin, vecVelocity, m_vecForce.Length(), m_bBurning, true, false, bDisguiseWearables );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : type - 
+//-----------------------------------------------------------------------------
+void C_TFRagdoll::OnDataChanged( DataUpdateType_t type )
+{
+	BaseClass::OnDataChanged( type );
+
+	if ( type == DATA_UPDATE_CREATED )
+	{
+		bool bCreateRagdoll = true;
+
+		// Get the player.
+		EHANDLE hPlayer = GetPlayerHandle();
+		if ( hPlayer )
+		{
+			// If we're getting the initial update for this player (e.g., after resetting entities after
+			//  lots of packet loss, then don't create gibs, ragdolls if the player and it's gib/ragdoll
+			//  both show up on same frame.
+			if ( abs( hPlayer->GetCreationTick() - gpGlobals->tickcount ) < TIME_TO_TICKS( 1.0f ) )
+			{
+				bCreateRagdoll = false;
+			}
+		}
+		else if ( C_BasePlayer::GetLocalPlayer() )
+		{
+			// Ditto for recreation of the local player
+			if ( abs( C_BasePlayer::GetLocalPlayer()->GetCreationTick() - gpGlobals->tickcount ) < TIME_TO_TICKS( 1.0f ) )
+			{
+				bCreateRagdoll = false;
+			}
+		}
+
+		// Prevent replays from creating ragdolls on the first frame of playback after skipping through playback.
+		// If a player died (leaving a ragdoll) previous to the first frame of replay playback,
+		// their ragdoll wasn't yet initialized because OnDataChanged events are queued but not processed
+		// until the first render. 
+		if ( engine->IsPlayingDemo() )
+		{
+			bCreateRagdoll = !m_bCreatedWhilePlaybackSkipping;
+		}
+
+		if ( GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_GRAND_SLAM )
+		{
+			m_bBatted = true;
+		}
+		
+		C_TFPlayer *pPlayer = ToTFPlayer( hPlayer.Get() );
+		bool bMiniBoss = ( pPlayer && pPlayer->IsMiniBoss() ) ? true : false;
+
+		if ( GetDamageCustom() == TF_DMG_CUSTOM_PLASMA )
+		{
+			if ( !m_bBecomeAsh && !bMiniBoss )
+			{
+				m_bDissolving = true;
+			}
+
+			m_bGib = false;
+		}
+
+		if ( GetDamageCustom() == TF_DMG_CUSTOM_PLASMA_CHARGED )
+		{
+			if ( !m_bBecomeAsh && !bMiniBoss )
+			{
+				m_bDissolving = true;
+			}
+
+			m_bGib = true;
+			SetNextClientThink( CLIENT_THINK_ALWAYS );
+		}
+
+		// Don't gib zombies, always just ragdoll
+		if ( pPlayer )
+		{
+			if ( pPlayer->BRenderAsZombie() )
+			{
+				m_bGib = false;
+			}
+			pPlayer->UpdateMVMEyeGlowEffect( false );
+		}
+
+		if ( bCreateRagdoll )
+		{
+			if ( m_bGib )
+			{
+				CreateTFGibs( !m_bDissolving );
+			}
+			else
+			{
+				CreateTFRagdoll();
+				if ( IsDecapitation() )
+				{
+					CreateTFHeadGib();
+					EmitSound( "TFPlayer.Decapitated" );
+
+					bool bBlood = true;
+					if ( TFGameRules() && ( TFGameRules()->UseSillyGibs() || 
+											( TFGameRules()->IsMannVsMachineMode() && hPlayer && hPlayer->GetTeamNumber() == TF_TEAM_PVE_INVADERS ) ) )
+					{
+						bBlood = false;
+					}
+
+					if ( bBlood )
+					{
+						ParticleProp()->Create( "blood_decap", PATTACH_POINT_FOLLOW, "head" );
+					}
+				}
+			}
+
+			m_bNoModelParticles = true;
+
+			// Drop wearables (hats, etc)
+			CreateWearableGibs( m_bWasDisguised );			
+		}
+	}
+	else 
+	{
+		if ( !cl_ragdoll_physics_enable.GetBool() )
+		{
+			// Don't let it set us back to a ragdoll with data from the server.
+			m_nRenderFX = kRenderFxNone;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+int C_TFRagdoll::InternalDrawModel( int flags )
+{
+	if ( m_MaterialOverride.IsValid() )
+	{
+		modelrender->ForcedMaterialOverride( m_MaterialOverride );
+	}
+
+	int ret = BaseClass::InternalDrawModel( flags );
+
+	if ( m_MaterialOverride.IsValid() )
+	{
+		modelrender->ForcedMaterialOverride( NULL );
+	}
+
+	return ret;
+}
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+bool C_TFRagdoll::IsDecapitation()
+{
+	return (cl_ragdoll_fade_time.GetFloat() > 5.f) && 
+		((m_iDamageCustom == TF_DMG_CUSTOM_DECAPITATION) 
+		|| (m_iDamageCustom == TF_DMG_CUSTOM_TAUNTATK_BARBARIAN_SWING)
+		|| (m_iDamageCustom == TF_DMG_CUSTOM_DECAPITATION_BOSS) 
+		|| (m_iDamageCustom == TF_DMG_CUSTOM_HEADSHOT_DECAPITATION)
+		|| (m_iDamageCustom == TF_DMG_CUSTOM_MERASMUS_DECAPITATION) );
+}
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+bool C_TFRagdoll::IsHeadSmash()
+{
+	return ((cl_ragdoll_fade_time.GetFloat() > 5.f) && (m_iDamageCustom == TF_DMG_CUSTOM_TAUNTATK_ENGINEER_GUITAR_SMASH));
+}
+
+//-----------------------------------------------------------------------------
+// 
+//-----------------------------------------------------------------------------
+bool C_TFRagdoll::GetAttachment( int iAttachment, matrix3x4_t &attachmentToWorld )
+{
+	int iHeadAttachment = LookupAttachment( "head" );
+	if ( IsDecapitation() && (iAttachment == iHeadAttachment) )
+	{
+		MatrixCopy( m_mHeadAttachment, attachmentToWorld );
+		return true;
+	}
+	else
+	{
+		return BaseClass::GetAttachment( iAttachment, attachmentToWorld );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  :  - 
+// Output : IRagdoll*
+//-----------------------------------------------------------------------------
+IRagdoll* C_TFRagdoll::GetIRagdoll() const
+{
+	return m_pRagdoll;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  :  - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_TFRagdoll::IsRagdollVisible()
+{
+	Vector vMins = Vector(-1,-1,-1);	//WorldAlignMins();
+	Vector vMaxs = Vector(1,1,1);	//WorldAlignMaxs();
+		
+	Vector origin = GetAbsOrigin();
+	
+	if( !engine->IsBoxInViewCluster( vMins + origin, vMaxs + origin) )
+	{
+		return false;
+	}
+	else if( engine->CullBox( vMins + origin, vMaxs + origin ) )
+	{
+		return false;
+	}
+
+	return true;
+}
+#define DISSOLVE_FADE_IN_START_TIME			0.0f
+#define DISSOLVE_FADE_IN_END_TIME			1.0f
+#define DISSOLVE_FADE_OUT_MODEL_START_TIME	1.9f
+#define DISSOLVE_FADE_OUT_MODEL_END_TIME	2.0f
+#define DISSOLVE_FADE_OUT_START_TIME		2.0f
+#define DISSOLVE_FADE_OUT_END_TIME			2.0f
+
+void C_TFRagdoll::ClientThink( void )
+{
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+
+	// Store off the un-shrunken head location for blood spurts.
+	if ( IsDecapitation() ) 
+	{
+		int iAttach = LookupAttachment( "head" );
+
+		m_bBaseTransform = true;
+		BaseClass::GetAttachment( iAttach, m_mHeadAttachment );
+		m_bBaseTransform = false;
+
+		m_BoneAccessor.SetReadableBones( 0 );
+		SetupBones( NULL, -1, BONE_USED_BY_ATTACHMENT, gpGlobals->curtime );
+	}
+
+	if ( m_bCloaked && m_flPercentInvisible < 1.f )
+	{
+		m_flPercentInvisible += gpGlobals->frametime;
+		if ( m_flPercentInvisible > 1.f )
+		{
+			m_flPercentInvisible = 1.f;
+		}
+	}
+
+	C_TFPlayer *pPlayer = ToTFPlayer( GetPlayerHandle() );
+	bool bBombinomicon = ( pPlayer && pPlayer->HasBombinomiconEffectOnDeath() );
+
+	if ( !m_bGib )
+	{
+		if ( m_bDissolving )
+		{
+			m_bDissolving = false;
+			m_flTimeToDissolve = 1.2f;
+
+			DissolveEntity( this );
+			EmitSound( "TFPlayer.Dissolve" );
+
+			// Dissolve all cosmetics as well
+			for ( C_BaseEntity *pEntity = ClientEntityList().FirstBaseEntity(); pEntity; pEntity = ClientEntityList().NextBaseEntity(pEntity) )
+			{
+				if ( pEntity->GetFollowedEntity() == this )
+				{
+					CEconEntity *pItem = dynamic_cast< CEconEntity * >( pEntity );
+					if ( pItem )
+					{
+						DissolveEntity( pItem );
+					}
+				}
+			}
+		}
+		else if ( bBombinomicon && ( GetFlags() & FL_DISSOLVING ) )
+		{
+			m_flTimeToDissolve -= gpGlobals->frametime;
+			if ( m_flTimeToDissolve <= 0 )
+			{
+				CreateTFGibs( true, true );
+			}
+		}
+		else if ( m_bBecomeAsh )
+		{
+			m_flTimeToDissolve -= gpGlobals->frametime;
+			if ( m_flTimeToDissolve <= 0 )
+			{
+				if ( bBombinomicon )
+				{
+					CreateTFGibs( true, true );
+				}
+				else
+				{
+					// Hide the ragdoll and stop everything but the ash particle effect
+					AddEffects( EF_NODRAW );
+					ParticleProp()->StopParticlesNamed( "drg_fiery_death", true, true );
+
+					// Hide all cosmetics
+					for ( C_BaseEntity *pEntity = ClientEntityList().FirstBaseEntity(); pEntity; pEntity = ClientEntityList().NextBaseEntity(pEntity) )
+					{
+						if ( pEntity->GetFollowedEntity() == this )
+						{
+							CEconEntity *pItem = dynamic_cast< CEconEntity * >( pEntity );
+							if ( pItem )
+							{
+								pItem->AddEffects( EF_NODRAW );
+							}
+						}
+					}
+				}
+				return;
+			}
+		}
+		else if ( bBombinomicon )
+		{
+			m_flTimeToDissolve -= gpGlobals->frametime;
+			if ( m_flTimeToDissolve <= 0 )
+			{
+				CreateTFGibs( true, true );
+				return;
+			}
+		}
+	}
+	// Gibbing
+	else
+	{
+		if ( m_bDissolving )
+		{
+			m_flTimeToDissolve -= gpGlobals->frametime;
+			if ( m_flTimeToDissolve <= 0 )
+			{
+				m_bDissolving = false;
+
+				if ( pPlayer )
+				{
+					if ( bBombinomicon )
+					{
+						CreateTFGibs( true, true );
+					}
+					else
+					{
+						for ( int i=0; i<pPlayer->m_hSpawnedGibs.Count(); i++ )
+						{
+							C_BaseEntity* pGib = pPlayer->m_hSpawnedGibs[i].Get();
+							if ( pGib )
+							{
+								pGib->SetAbsVelocity( vec3_origin );
+								DissolveEntity( pGib );
+								pGib->ParticleProp()->StopParticlesInvolving( pGib );
+							}
+						}
+					}
+				}
+				EndFadeOut();
+			}
+			return;
+		}
+	}
+
+	// Fade us away...
+	if ( m_bFadingOut == true )
+	{
+		int iAlpha = GetRenderColor().a;
+		int iFadeSpeed = 600.0f;
+
+		iAlpha = MAX( iAlpha - ( iFadeSpeed * gpGlobals->frametime ), 0 );
+
+		SetRenderMode( kRenderTransAlpha );
+		SetRenderColorA( iAlpha );
+
+		if ( iAlpha == 0 )
+		{
+			// Remove clientside ragdoll.
+			EndFadeOut();
+		}
+		return;
+	}
+
+	// If the player is looking at us, delay the fade.
+	if ( IsRagdollVisible() )
+	{
+		if ( cl_ragdoll_forcefade.GetBool() )
+		{
+			m_bFadingOut = true;
+			float flDelay = cl_ragdoll_fade_time.GetFloat() * 0.33f;
+			m_fDeathTime = gpGlobals->curtime + flDelay;
+
+			RemoveAllDecals();
+		}
+
+		// Fade out after the specified delay.
+		StartFadeOut( cl_ragdoll_fade_time.GetFloat() * 0.33f );
+		return;
+	}
+
+	// Remove us if our death time has passed.
+	if ( m_fDeathTime < gpGlobals->curtime )
+	{
+		EndFadeOut();
+		return;
+	}
+
+	// Fire an event if we were batted by the scout's taunt kill and we have come to rest.
+	if ( m_bBatted )
+	{
+		Vector vVelocity;
+		EstimateAbsVelocity( vVelocity );
+		if ( vVelocity.LengthSqr() == 0.f )
+		{
+			m_bBatted = false;
+			IGameEvent *event = gameeventmanager->CreateEvent( "scout_slamdoll_landed" );
+			if ( event )
+			{
+				Vector absOrigin = GetAbsOrigin();
+				event->SetInt( "target_index", m_iPlayerIndex );
+				event->SetFloat( "x", absOrigin.x );
+				event->SetFloat( "y", absOrigin.y );
+				event->SetFloat( "z", absOrigin.z );
+				gameeventmanager->FireEventClientSide( event );
+			}
+		}
+	}
+}
+
+// Deal with recording
+void C_TFRagdoll::GetToolRecordingState( KeyValues *msg )
+{
+#ifndef _XBOX
+	BaseClass::GetToolRecordingState( msg );
+
+	if ( m_MaterialOverride.IsValid() )
+	{
+		msg->SetString( "materialOverride", m_MaterialOverride->GetName() );
+	}
+#endif
+}
+
+void C_TFRagdoll::DissolveEntity( CBaseEntity* pEnt )
+{
+	C_EntityDissolve *pDissolve = DissolveEffect( pEnt, gpGlobals->curtime );
+	if ( pDissolve )
+	{
+		pDissolve->SetRenderMode( kRenderTransColor );
+		pDissolve->m_nRenderFX = kRenderFxNone;
+		pDissolve->SetRenderColor( 255, 255, 255, 255 );
+
+		Vector vColor;
+		if ( m_iTeam == TF_TEAM_BLUE )
+		{
+			vColor = TF_PARTICLE_WEAPON_RED_1 * 255;
+			pDissolve->SetEffectColor( vColor );
+		}
+		else
+		{
+			vColor = TF_PARTICLE_WEAPON_BLUE_1 * 255;
+			pDissolve->SetEffectColor( vColor );
+		}
+
+		pDissolve->m_vDissolverOrigin = GetAbsOrigin();
+
+		pDissolve->m_flFadeInStart = DISSOLVE_FADE_IN_START_TIME;
+		pDissolve->m_flFadeInLength = DISSOLVE_FADE_IN_END_TIME - DISSOLVE_FADE_IN_START_TIME;
+
+		pDissolve->m_flFadeOutModelStart = DISSOLVE_FADE_OUT_MODEL_START_TIME;
+		pDissolve->m_flFadeOutModelLength = DISSOLVE_FADE_OUT_MODEL_END_TIME - DISSOLVE_FADE_OUT_MODEL_START_TIME;
+
+		pDissolve->m_flFadeOutStart = DISSOLVE_FADE_OUT_START_TIME;
+		pDissolve->m_flFadeOutLength = DISSOLVE_FADE_OUT_END_TIME - DISSOLVE_FADE_OUT_START_TIME;
+	}
+}
+
+void C_TFRagdoll::StartFadeOut( float fDelay )
+{
+	if ( !cl_ragdoll_forcefade.GetBool() )
+	{
+		m_fDeathTime = gpGlobals->curtime + fDelay;
+	}
+	SetNextClientThink( CLIENT_THINK_ALWAYS );
+}
+
+
+void C_TFRagdoll::EndFadeOut()
+{
+	SetNextClientThink( CLIENT_THINK_NEVER );
+	ClearRagdoll();
+	SetRenderMode( kRenderNone );
+	UpdateVisibility();
+	DestroyBoneAttachments();
+
+	// Remove attached effect entity
+	C_BaseEntity *pEffect = GetEffectEntity();
+	if ( pEffect )
+	{
+		pEffect->SUB_Remove();
+	}
+
+	ParticleProp()->StopEmission();
+	
+	// Hide attached wearables.
+	// These are server objects so they'll go away when the actual server ragdoll dies.
+	for ( int i=0; i<m_hRagWearables.Count(); ++i )
+	{
+		if ( m_hRagWearables[i] )
+		{
+			m_hRagWearables[i]->AddEffects( EF_NODRAW );
+			m_hRagWearables[i]->SetMoveType( MOVETYPE_NONE );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for spy invisiblity material
+//-----------------------------------------------------------------------------
+class CSpyInvisProxy : public CBaseInvisMaterialProxy
+{
+public:
+	CSpyInvisProxy( void );
+	virtual bool		Init( IMaterial *pMaterial, KeyValues* pKeyValues ) OVERRIDE;
+	virtual void		OnBind( C_BaseEntity *pBaseEntity ) OVERRIDE;
+	virtual void		OnBindNotEntity( void *pRenderable ) OVERRIDE;
+
+private:
+	IMaterialVar		*m_pCloakColorTint;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CSpyInvisProxy::CSpyInvisProxy( void )
+{
+	m_pCloakColorTint = NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get pointer to the color value
+// Input  : *pMaterial - 
+//-----------------------------------------------------------------------------
+bool CSpyInvisProxy::Init( IMaterial *pMaterial, KeyValues* pKeyValues )
+{
+	// Need to get the material var
+	bool bInvis = CBaseInvisMaterialProxy::Init( pMaterial, pKeyValues );
+
+	bool bTint;
+	m_pCloakColorTint = pMaterial->FindVar( "$cloakColorTint", &bTint );
+
+	return ( bInvis && bTint );
+}
+
+ConVar tf_teammate_max_invis( "tf_teammate_max_invis", "0.95", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  :
+//-----------------------------------------------------------------------------
+void CSpyInvisProxy::OnBind( C_BaseEntity *pBaseEntity )
+{
+	if( !m_pPercentInvisible || !m_pCloakColorTint )
+		return;
+
+	float fInvis = 0.0f;
+
+	C_TFPlayer *pPlayer = ToTFPlayer( pBaseEntity );
+
+	if ( !pPlayer )
+	{
+		C_TFPlayer *pOwningPlayer = ToTFPlayer( pBaseEntity->GetOwnerEntity() );
+
+		C_TFRagdoll *pRagdoll = dynamic_cast< C_TFRagdoll* >( pBaseEntity );
+		if ( pRagdoll && pRagdoll->IsCloaked() )
+		{
+			fInvis = pRagdoll->GetPercentInvisible();
+		}
+		else if ( pOwningPlayer )
+		{
+			// mimic the owner's invisibility
+			fInvis = pOwningPlayer->GetEffectiveInvisibilityLevel();
+		}
+	}
+	else
+	{
+		float r = 1.0f, g = 1.0f, b = 1.0f;
+		fInvis = pPlayer->GetEffectiveInvisibilityLevel();
+
+		switch( pPlayer->GetTeamNumber() )
+		{
+		case TF_TEAM_RED:
+			r = 1.0; g = 0.5; b = 0.4;
+			break;
+
+		case TF_TEAM_BLUE:
+		default:
+			r = 0.4; g = 0.5; b = 1.0;
+			break;
+		}
+
+		m_pCloakColorTint->SetVecValue( r, g, b );
+	}
+
+	m_pPercentInvisible->SetFloatValue( fInvis );
+}
+
+void CSpyInvisProxy::OnBindNotEntity( void *pRenderable )
+{
+	CBaseInvisMaterialProxy::OnBindNotEntity( pRenderable );
+
+	if ( m_pCloakColorTint )
+	{
+		m_pCloakColorTint->SetVecValue( 1.f, 1.f, 1.f );
+	}
+}
+
+EXPOSE_INTERFACE( CSpyInvisProxy, IMaterialProxy, "spy_invis" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for invulnerability material
+//			Returns 1 if the player is invulnerable, and 0 if the player is losing / doesn't have invuln.
+//-----------------------------------------------------------------------------
+class CProxyInvulnLevel : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity )
+	{
+		Assert( m_pResult );
+
+		float flResult = 1.0;
+
+		C_TFPlayer *pPlayer = NULL;
+		C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
+		if ( !pEntity )
+		{
+			if ( g_PlayerPreviewEffect.GetEffect() == C_TFPlayerPreviewEffect::PREVIEW_EFFECT_UBER )
+			{
+				flResult = 1.0f;
+			}
+			m_pResult->SetFloatValue( flResult );
+			return;
+		}
+
+		if ( pEntity->IsPlayer()  )
+		{
+			pPlayer = dynamic_cast< C_TFPlayer* >( pEntity );
+		}
+		else
+		{
+			IHasOwner *pOwnerInterface = dynamic_cast< IHasOwner* >( pEntity );
+			if ( pOwnerInterface )
+			{
+				pPlayer = ToTFPlayer( pOwnerInterface->GetOwnerViaInterface() );
+			}
+		}
+
+		if ( pPlayer && pPlayer->m_Shared.IsInvulnerable() && pPlayer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
+		{
+			flResult = 0.0;
+		}
+
+		m_pResult->SetFloatValue( flResult );
+
+		if ( ToolsEnabled() )
+		{
+			ToolFramework_RecordMaterialParams( GetMaterial() );
+		}
+	}
+};
+
+EXPOSE_INTERFACE( CProxyInvulnLevel, IMaterialProxy, "InvulnLevel" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for burning material on player models
+//			Returns 0.0->1.0 for level of burn to show on player skin
+//-----------------------------------------------------------------------------
+class CProxyBurnLevel : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity )
+	{
+		Assert( m_pResult );
+
+		float flResult = 0.0;
+
+		C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
+		if ( !pEntity )
+		{
+			if ( g_PlayerPreviewEffect.GetEffect() == C_TFPlayerPreviewEffect::PREVIEW_EFFECT_BURN )
+			{
+				flResult = 1.0f;
+			}
+			m_pResult->SetFloatValue( flResult );
+			return;
+		}
+
+		// default to zero
+		float flBurnStartTime = 0;
+	
+		if ( pEntity->IsPlayer() )
+		{
+			C_TFPlayer *pPlayer = assert_cast< C_TFPlayer* >( pEntity );
+			// is the player burning?
+			if (  pPlayer->m_Shared.InCond( TF_COND_BURNING ) )
+			{
+				flBurnStartTime = pPlayer->m_flBurnEffectStartTime;
+			}
+		}
+		else
+		{
+			// is the ragdoll burning?
+			C_TFRagdoll *pRagDoll = dynamic_cast< C_TFRagdoll* >( pEntity );
+			if ( pRagDoll )
+			{
+				flBurnStartTime = pRagDoll->GetBurnStartTime();
+			}
+		}
+		
+		// if player/ragdoll is burning, set the burn level on the skin
+		if ( flBurnStartTime > 0 )
+		{
+			float flBurnPeakTime = flBurnStartTime + 0.3;
+			float flTempResult;
+			if ( gpGlobals->curtime < flBurnPeakTime )
+			{
+				// fade in from 0->1 in 0.3 seconds
+				flTempResult = RemapValClamped( gpGlobals->curtime, flBurnStartTime, flBurnPeakTime, 0.0, 1.0 );
+			}
+			else
+			{
+				// fade out from 1->0 in the remaining time until flame extinguished
+				flTempResult = RemapValClamped( gpGlobals->curtime, flBurnPeakTime, flBurnStartTime + TF_BURNING_FLAME_LIFE, 1.0, 0.0 );
+			}	
+
+			// We have to do some more calc here instead of in materialvars.
+			flResult = 1.0 - abs( flTempResult - 1.0 );
+		}
+
+		m_pResult->SetFloatValue( flResult );
+
+		if ( ToolsEnabled() )
+		{
+			ToolFramework_RecordMaterialParams( GetMaterial() );
+		}
+	}
+};
+
+EXPOSE_INTERFACE( CProxyBurnLevel, IMaterialProxy, "BurnLevel" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for turning player models yellow (jarate) 
+//			Returns 0.0->1.0 for level of yellow to show on player skin
+//-----------------------------------------------------------------------------
+class CProxyUrineLevel : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity )
+	{
+		Assert( m_pResult );
+
+		// default to zero
+		Vector vResult = Vector( 1, 1, 1 );
+
+		C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
+		if ( !pEntity )
+		{
+			if ( g_PlayerPreviewEffect.GetEffect() == C_TFPlayerPreviewEffect::PREVIEW_EFFECT_URINE )
+			{
+				if ( g_PlayerPreviewEffect.GetTeam() == TF_TEAM_RED )
+				{
+					vResult = Vector ( 6, 9, 2 );
+				}
+				else	
+				{
+					vResult = Vector ( 7, 5, 1 );
+				}
+			}
+			m_pResult->SetVecValue( vResult.x, vResult.y, vResult.z );
+			return;
+		}
+
+		C_TFPlayer *pPlayer = NULL;
+		if ( pEntity->IsPlayer() )
+		{
+			pPlayer = assert_cast< C_TFPlayer* >( pEntity );
+		}
+		else if ( pEntity->GetOwnerEntity() && pEntity->GetOwnerEntity()->IsPlayer() )
+		{
+			pPlayer = assert_cast< C_TFPlayer* >( pEntity->GetOwnerEntity() );
+		}
+
+		if ( pPlayer )
+		{
+			// is the player peed on?
+			if (  pPlayer->m_Shared.InCond( TF_COND_URINE ) )
+			{
+				int iVisibleTeam = pPlayer->GetTeamNumber();
+				if ( pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
+				{
+					if ( !pPlayer->IsLocalPlayer() && iVisibleTeam != GetLocalPlayerTeam() )
+					{
+						iVisibleTeam = pPlayer->m_Shared.GetDisguiseTeam();
+					}
+				}
+				if ( iVisibleTeam == TF_TEAM_RED )
+				{
+					vResult = Vector ( 6, 9, 2 );
+				}
+				else	
+				{
+					vResult = Vector ( 7, 5, 1 );
+				}
+			}
+			else
+			{
+				vResult = Vector( 1, 1, 1 );
+			}
+		}
+
+		m_pResult->SetVecValue( vResult.x, vResult.y, vResult.z );
+
+		if ( ToolsEnabled() )
+		{
+			ToolFramework_RecordMaterialParams( GetMaterial() );
+		}
+	}
+};
+
+EXPOSE_INTERFACE( CProxyUrineLevel, IMaterialProxy, "YellowLevel" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: CritBoosted FX
+//			
+//-----------------------------------------------------------------------------
+class CProxyModelGlowColor : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity )
+	{
+		Assert( m_pResult );
+
+		C_TFPlayer *pPlayer = NULL;
+		C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
+		if ( !pEntity )
+		{
+			Vector vResult = Vector( 1, 1, 1 );
+#if 0 // It looks like this code path is never used
+			if ( g_PlayerPreviewEffect.GetEffect() == C_TFPlayerPreviewEffect::PREVIEW_EFFECT_CRIT )
+			{
+				if ( g_PlayerPreviewEffect.GetTeam() == TF_TEAM_RED )
+				{
+					vResult = Vector ( 80, 8, 5 );
+				}
+				else	
+				{
+					vResult = Vector ( 5, 20, 80 );
+				}
+			}
+#endif // 0
+			m_pResult->SetVecValue( vResult.x, vResult.y, vResult.z );
+			return;
+		}
+
+		// default to [1 1 1]
+		Vector vResult = Vector( 1, 1, 1 );
+		int iVisibleTeam = 0;
+
+		IHasOwner *pOwnerInterface = dynamic_cast< IHasOwner* >( pEntity );
+		if ( pOwnerInterface )
+		{
+			pPlayer = ToTFPlayer( pOwnerInterface->GetOwnerViaInterface() );
+		}
+
+		if ( pPlayer )
+		{
+			iVisibleTeam = pPlayer->GetTeamNumber();
+			if (  pPlayer->m_Shared.IsCritBoosted() )
+			{
+				// never show critboosted effect on a disguised spy (unless it's me)
+				if ( !pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) || pPlayer->IsLocalPlayer() )
+				{
+					if ( iVisibleTeam == TF_TEAM_RED )
+					{
+						vResult = Vector ( 80, 8, 5 );
+					}
+					else	
+					{
+						vResult = Vector ( 5, 20, 80 );
+					}
+				}
+				pPlayer->m_Shared.m_bChargeGlowing = false;
+			}
+			else if ( pPlayer->m_Shared.IsHypeBuffed() )
+			{
+				vResult = Vector( 50, 2, 48 );
+				pPlayer->m_Shared.m_bChargeGlowing = false;
+			}
+			else if ( pPlayer->m_Shared.InCond( TF_COND_OFFENSEBUFF ) || pPlayer->m_Shared.InCond( TF_COND_ENERGY_BUFF ) )
+			{
+				// Temporarily hijacking this proxy for buff FX.
+				if ( iVisibleTeam == TF_TEAM_RED )
+				{
+					vResult = Vector ( 226, 150, 62 );
+				}
+				else
+				{
+					vResult = Vector( 29, 202, 135 );
+				}
+				pPlayer->m_Shared.m_bChargeGlowing = false;
+			}
+			else
+			{
+				if ( pPlayer->m_Shared.InCond( TF_COND_SHIELD_CHARGE ) || (pPlayer->m_Shared.GetNextMeleeCrit() != MELEE_NOCRIT) )
+				{
+					float flGlow;
+					if ( pPlayer->m_Shared.InCond( TF_COND_SHIELD_CHARGE ) )
+					{
+						// Ramp up the charge glow while charging.
+						flGlow = (100.f - pPlayer->m_Shared.GetDemomanChargeMeter()) / 100.f;
+					}
+					else
+					{
+						// Cool down the charge glow after charging.
+						flGlow = 1.f - MIN((gpGlobals->curtime - pPlayer->m_Shared.m_flLastNoChargeTime - 1.5f) / 0.3f,1);
+					}
+					if ( iVisibleTeam == TF_TEAM_RED )
+					{
+						vResult = Vector( MAX(80*flGlow,1), MAX(8*flGlow,1), MAX(5*flGlow,1) );
+					}
+					else
+					{
+						vResult = Vector( MAX(5*flGlow,1), MAX(20*flGlow,1), MAX(80*flGlow,1) );
+					}
+					pPlayer->m_Shared.m_bChargeGlowing = true;
+				}
+				else if ( pPlayer->m_Shared.m_bChargeGlowing )
+				{
+					// Cool down the charge glow after charging.
+					float flGlow = 1.f - MIN( (gpGlobals->curtime - pPlayer->m_Shared.m_flLastNoChargeTime) / 0.3f, 1.f );
+
+					if ( flGlow <= 0 )
+					{
+						pPlayer->m_Shared.m_bChargeGlowing = false;
+					}
+
+					if ( iVisibleTeam == TF_TEAM_RED )
+					{
+						vResult = Vector( MAX(80*flGlow,1), MAX(8*flGlow,1), MAX(5*flGlow,1) );
+					}
+					else
+					{
+						vResult = Vector( MAX(5*flGlow,1), MAX(20*flGlow,1), MAX(80*flGlow,1) );
+					}
+				}
+				else
+				{
+					vResult = Vector( 1, 1, 1 );
+				}
+			}
+
+		}
+		m_pResult->SetVecValue( vResult.x, vResult.y, vResult.z );
+
+		if ( ToolsEnabled() )
+		{
+			ToolFramework_RecordMaterialParams( GetMaterial() );
+		}
+	}
+};
+
+EXPOSE_INTERFACE( CProxyModelGlowColor, IMaterialProxy, "ModelGlowColor" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//-----------------------------------------------------------------------------
+// Purpose: Proxy used to tell the material it's on a community weapon
+//-----------------------------------------------------------------------------
+class CProxyCommunityWeapon : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity )
+	{
+		Assert( m_pResult );
+		if ( pC_BaseEntity )
+		{
+			C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
+			if ( pEntity )
+			{
+				CEconEntity *pItem = dynamic_cast< CEconEntity* >( pEntity );
+				if ( pItem )
+				{
+					CEconItemView *pScriptItem = pItem->GetAttributeContainer()->GetItem();
+					if ( pScriptItem && pScriptItem->GetStaticData() )
+					{
+						if ( pScriptItem->GetItemQuality() == AE_COMMUNITY )
+						{
+							m_pResult->SetIntValue( 1 );
+							return;
+						}
+					}
+				}
+			}
+		}
+
+		m_pResult->SetIntValue( 0 );
+
+		if ( ToolsEnabled() )
+		{
+			ToolFramework_RecordMaterialParams( GetMaterial() );
+		}
+	}
+};
+
+EXPOSE_INTERFACE( CProxyCommunityWeapon, IMaterialProxy, "CommunityWeapon" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for scaling the beating heart texture to make it pulse
+//-----------------------------------------------------------------------------
+class CProxyHeartbeatScale : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity )
+	{
+		Assert( m_pResult );
+
+		const float pi = 3.141592f;
+		const float twoPI = 2.0f * pi;
+
+		float s1 = sin( gpGlobals->curtime * twoPI );
+		s1 = clamp( s1, 0.0f, 1.0f );
+		s1 *= s1;
+		s1 *= s1;
+		s1 = clamp( s1, 0.5f, 1.0f );
+		s1 -= 0.5f;
+		s1 *= 2.0f;
+
+		float s2 = sin( ( gpGlobals->curtime + 0.25f ) * twoPI );
+		s2 = clamp( s2, 0.0f, 1.0f );
+		s2 *= s2;
+		s2 *= s2;
+		s2 = clamp( s2, 0.5f, 1.0f );
+		s2 -= 0.5f;
+		s2 *= 2.0f;
+
+		float beat = MAX( s1, s2 );
+
+		const float scale = 0.6f;
+		const float loBeat = 1.0f * scale;
+		const float hiBeat = 0.8f * scale;
+
+		float scaledBeat = loBeat + ( hiBeat - loBeat ) * beat;
+
+		m_pResult->SetFloatValue( scaledBeat );
+
+		if ( ToolsEnabled() )
+		{
+			ToolFramework_RecordMaterialParams( GetMaterial() );
+		}
+	}
+};
+
+EXPOSE_INTERFACE( CProxyHeartbeatScale, IMaterialProxy, "HeartbeatScale" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+#ifdef _DEBUG
+ConVar tf_benefactor_gift_count( "tf_benefactor_gift_count", "-1", FCVAR_CHEAT, "For testing" );
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for scaling the beating heart based on the number of gifts player has given
+//			Returns a texture scale factor where 1 is max size (big benefactor) and factor gets larger the fewer gifts you've given
+//-----------------------------------------------------------------------------
+class CProxyBenefactorLevel : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity )
+	{
+		Assert( m_pResult );
+
+		CEconItemView *pScriptItem = NULL;
+
+		IClientRenderable *pRend = (IClientRenderable *)pC_BaseEntity;
+		C_BaseEntity *pEntity = pRend->GetIClientUnknown()->GetBaseEntity();
+		if ( pEntity )
+		{
+			CEconEntity *pItem = dynamic_cast< CEconEntity* >( pEntity );
+			if ( pItem )
+			{
+				pScriptItem = pItem->GetAttributeContainer()->GetItem();
+			}
+		}
+
+		if ( pScriptItem )
+		{
+			static CSchemaAttributeDefHandle pAttrDef_KillEater( "kill eater" );
+
+			// Use the kill-eater prefix if the weapon has one.
+			uint32 unKillCount;
+			if ( !pScriptItem->FindAttribute( pAttrDef_KillEater, &unKillCount ) )
+				return;
+
+#ifdef _DEBUG
+			int testCount = tf_benefactor_gift_count.GetInt();
+			if ( testCount >= 0 )
+			{
+				unKillCount = (uint32)testCount;
+			}
+#endif
+
+			if ( unKillCount == 0 )
+			{
+				// heartless
+				m_pResult->SetFloatValue( 1000.0f );
+			}
+			else
+			{
+				const int maxBenefatorLevel = 250;
+
+				float value = (float)unKillCount / (float)maxBenefatorLevel;
+
+				value = clamp( value, 0.0f, 1.0f );
+
+				// a linear scale doesn't show the size change until the very end - nonlinearize it
+				value = sin( value * 1.57f );
+				value = sin( value * 1.57f );
+
+				// this seems backwards because this is a texture scaling factor
+				// the bigger the number, the smaller the textured image is (tiles more in same space)
+				const float minValue = 5.0f;
+				const float maxValue = 1.0f;
+
+				m_pResult->SetFloatValue( minValue + ( maxValue - minValue ) * value );
+			}
+		}
+
+		if ( ToolsEnabled() )
+		{
+			ToolFramework_RecordMaterialParams( GetMaterial() );
+		}
+	}
+};
+
+EXPOSE_INTERFACE( CProxyBenefactorLevel, IMaterialProxy, "BenefactorLevel" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for scaling the oscilloscope on the Building Rescue Gun
+// Flattens the Wave when the player has no energy
+//-----------------------------------------------------------------------------
+class CProxyBuildingRescueLevel : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity )
+	{
+		Assert( m_pResult );
+
+		C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
+		if ( !pPlayer )
+			return;
+
+		int iIncreasedRangeCost = 0;
+		CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iIncreasedRangeCost, building_teleporting_pickup );		
+		if ( iIncreasedRangeCost == 0 )
+			return;
+
+		CTFWeaponBase * pWeapon = pPlayer->GetActiveTFWeapon();
+		if ( !pWeapon )
+			return;
+
+		int iAmmo = pPlayer->GetAmmoCount( TF_AMMO_METAL );
+
+		float scale = 1.0f;
+		if ( iAmmo < iIncreasedRangeCost )
+		{
+			scale = 10.0f;
+		}
+		else 
+		{
+			scale = ( 3.0f - ((float)(iAmmo - iIncreasedRangeCost) / (float)(pPlayer->GetMaxAmmo( TF_AMMO_METAL ) - iIncreasedRangeCost) * 3.0f ) + 1.0f );
+		}
+
+		VMatrix mat, temp;
+
+		Vector2D center( 0.5, 0.5 );
+		MatrixBuildTranslation( mat, -center.x, -center.y, 0.0f );
+
+		// scale
+		{
+			MatrixBuildScale( temp, 1.0f, scale, 1.0f );
+			MatrixMultiply( temp, mat, mat );
+		}
+
+		MatrixBuildTranslation( temp, center.x, center.y, 0.0f );
+		MatrixMultiply( temp, mat, mat );
+
+		m_pResult->SetMatrixValue( mat );
+
+		if ( ToolsEnabled() )
+		{
+			ToolFramework_RecordMaterialParams( GetMaterial() );
+		}
+	}
+};
+
+EXPOSE_INTERFACE( CProxyBuildingRescueLevel, IMaterialProxy, "BuildingRescueLevel" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+//-----------------------------------------------------------------------------
+// Used to pulse the Vaccinator's uber shield
+//-----------------------------------------------------------------------------
+class CProxyResistShield : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity )
+	{
+		Assert( m_pResult );
+
+		IClientRenderable *pRend = (IClientRenderable *)pC_BaseEntity;
+		C_BaseEntity *pEntity = pRend->GetIClientUnknown()->GetBaseEntity();
+		if ( pEntity )
+		{
+			C_LocalTempEntity* pTempEnt = dynamic_cast<C_LocalTempEntity*>(pEntity);
+			if ( pTempEnt )
+			{
+				C_BaseEntity *pBaseEnt = cl_entitylist->GetEnt( pTempEnt->clientIndex );
+				// This should be the owning player
+				C_TFPlayer* pTFPlayer = ToTFPlayer( pBaseEnt );
+				if( pTFPlayer )
+				{
+					float flTimeSince = gpGlobals->curtime - pTFPlayer->GetLastResistTime();
+					float flOut = RemapValClamped( flTimeSince, 0, 0.4f, 7.f, -4.f );
+					m_pResult->SetVecValue( flOut, flOut, flOut, 1.f );
+					return;
+				}
+			}
+		}
+
+	
+		m_pResult->SetVecValue( 1.0, 1.0, 1.0, 1.0 );	
+	}
+};
+
+EXPOSE_INTERFACE( CProxyResistShield, IMaterialProxy, "ShieldFalloff" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for pulsing the Wheatly Sappers eye glow when he talks
+//-----------------------------------------------------------------------------
+class CProxyWheatlyEyeGlow : public CResultProxy
+{
+public:
+	void OnBind( void *pC_BaseEntity )
+	{
+		Assert( m_pResult );
+
+		C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
+		if ( !pPlayer )
+			return;
+
+		const float flBase = 0.4f;
+		const float flMinTalking = 0.6f;
+		const float flMaxTalking = 1.3f;
+		const float flAdjustUp = 0.01f;
+		const float flAdjustDown = -0.006f;
+
+		static float s_flCurr = 0.2f;
+		static float s_flDir = 0.2f;
+		
+		const float flEyeHold = 1.9f;
+		const float flMinEyes = 0.1f;
+		const float flMaxEyes = 0.35f;
+		const float flEyeAdjust = 0.005f;
+
+		static float s_flEyePose = 0.0f;
+		static float s_flNextEyeChange = 0;
+		static float s_flEyeDir = 0.005f;
+
+		C_TFWeaponSapper *pWeapon = dynamic_cast< C_TFWeaponSapper* >( pPlayer->Weapon_GetWeaponByType( TF_WPN_TYPE_BUILDING ) );
+		if ( pWeapon )
+		{
+			if ( pWeapon->IsWheatleyTalking() )
+			{
+				float flNoise = RandomGaussianFloat( 0.0f, 0.01f );
+				s_flCurr += s_flDir + flNoise;
+				if ( s_flCurr > flMaxTalking && s_flDir > 0 )
+				{
+					s_flDir = flAdjustDown;
+				}
+				else if ( s_flCurr < flMinTalking && s_flDir < 0 )
+				{
+					s_flDir = flAdjustUp;
+				}
+
+				// Animate to eye's and hold for a few seconds
+				float currTime = gpGlobals->curtime;
+				if ( currTime > s_flNextEyeChange) 
+				{
+					s_flEyePose += s_flEyeDir;
+
+					if ( s_flEyePose > flMaxEyes && s_flEyeDir > 0 )
+					{
+						s_flNextEyeChange = currTime + flEyeHold;
+						s_flEyeDir = -flEyeAdjust;
+					}
+					if ( s_flEyePose < flMinEyes && s_flEyeDir < 0 )
+					{
+						s_flNextEyeChange = currTime + flEyeHold;
+						s_flEyeDir = flEyeAdjust;
+					}
+				}
+			}
+			else
+			{
+				// adjust towards base
+				s_flCurr += flAdjustDown;
+				if ( s_flCurr < flBase )
+				{
+					s_flCurr = flBase;
+					s_flDir = flAdjustUp;
+				}
+
+				if ( s_flEyePose > 0 )
+				{
+					s_flEyePose -= flEyeAdjust;
+				}
+				s_flEyeDir = flEyeAdjust;
+			}
+
+			CBaseViewModel *pViewModel = pPlayer->GetViewModel(0);
+			if ( pViewModel )
+			{
+				pViewModel->SetPoseParameter( "eyelids", s_flEyePose );
+			}
+		}
+
+		m_pResult->SetFloatValue( s_flCurr );
+
+		if ( ToolsEnabled() )
+		{
+			ToolFramework_RecordMaterialParams( GetMaterial() );
+		}
+	}
+};
+
+EXPOSE_INTERFACE( CProxyWheatlyEyeGlow, IMaterialProxy, "WheatlyEyeGlow" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//-----------------------------------------------------------------------------
+CEconItemView *GetEconItemViewFromProxyEntity( void *pEntity )
+{
+	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
+
+	IClientRenderable *pRend = (IClientRenderable *)pEntity;
+	CBaseEntity *pBaseEntity = pRend ? pRend->GetIClientUnknown()->GetBaseEntity() : NULL;
+	
+	// If an entity, find out what types it is and get the econ item view
+	if ( pBaseEntity )
+	{
+		// Generic Entity that has an Item ( Weapons / Hats )
+		IHasAttributes *pAttribInterface = GetAttribInterface( pBaseEntity );
+		if ( pAttribInterface )
+			return pAttribInterface->GetAttributeContainer()->GetItem();
+
+		// ViewModel Attachment (aka view model Weapon)
+		C_ViewmodelAttachmentModel *pViewModelAttachment = dynamic_cast<C_ViewmodelAttachmentModel*>( pBaseEntity );
+		if ( pViewModelAttachment && pViewModelAttachment->GetOuter() )
+		{
+			return pViewModelAttachment->GetOuter()->GetAttributeContainer()->GetItem();
+		}
+
+		CTFViewModel *pViewModel = dynamic_cast<CTFViewModel*>( pBaseEntity );
+		if ( pViewModel && pViewModel->GetWeapon() )
+		{
+			return pViewModel->GetWeapon()->GetAttributeContainer()->GetItem();
+		}
+
+		CTFDroppedWeapon *pDroppedWeapon = dynamic_cast<CTFDroppedWeapon*>( pBaseEntity );
+		if ( pDroppedWeapon && pDroppedWeapon->GetItem() && pDroppedWeapon->GetItem()->GetItemDefIndex() != INVALID_ITEM_DEF_INDEX )
+		{
+			return pDroppedWeapon->GetItem();
+		}
+	}
+	// No direct entity, might be a EconItem (PlayerModelPanels)
+	else
+	{
+		CEconItemView *pItem = dynamic_cast< CEconItemView* >( pRend );
+		if ( pItem )
+		{
+			return pItem;
+		}
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+C_TFPlayer *GetOwnerFromProxyEntity( void *pEntity )
+{
+	tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
+
+	IClientRenderable *pRend = ( IClientRenderable * ) pEntity;
+	CBaseEntity *pBaseEntity = pRend ? pRend->GetIClientUnknown()->GetBaseEntity() : NULL;
+
+	// If an entity, find out what types it is and get the econ item view
+	if ( pBaseEntity )
+	{
+		CBaseEntity* pOwner = pBaseEntity->GetOwnerEntity();
+		if ( pOwner )
+			return dynamic_cast<C_TFPlayer*>( pOwner->GetOwnerEntity() );
+	}
+
+	return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Used to animate the weapon sheen effect for kill streak attr items
+//-----------------------------------------------------------------------------
+class CProxyAnimatedWeaponSheen : public CBaseAnimatedTextureProxy
+{
+public:
+	CProxyAnimatedWeaponSheen() {}
+	virtual ~CProxyAnimatedWeaponSheen() {}
+
+	bool Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+	{
+		bool foundVar = false;
+		m_flNextStartTime = 0;
+		m_flScaleX = -1;
+		m_flScaleY = -1;
+		m_flSheenOffsetX = 0;
+		m_flSheenOffsetY = 0;
+		m_iSheenDir = 0;
+
+		m_pScaleXVar = NULL;
+		m_pScaleYVar = NULL;
+		m_pOffsetXVar = NULL;
+		m_pOffsetYVar = NULL;
+		m_pDirectionVar = NULL;
+		m_pSheenIndexVar = NULL;
+
+		// Get Tint
+		m_pTintVar = pMaterial->FindVar( "$sheenmaptint", &foundVar );
+		if( !foundVar )
+			return false;
+
+		m_pSheenIndexVar = pMaterial->FindVar( "$sheenindex", &foundVar );
+		if( !foundVar )
+			return false;
+
+		// Material vars for scale and offset
+		// Need to get the material var
+		m_pScaleXVar = pMaterial->FindVar( "$sheenmapmaskscaleX", &foundVar );
+		if( !foundVar )
+			return false;
+
+		m_pScaleYVar = pMaterial->FindVar( "$sheenmapmaskscaleY", &foundVar );
+		if( !foundVar )
+			return false;
+
+		m_pOffsetXVar = pMaterial->FindVar( "$sheenmapmaskoffsetX", &foundVar );
+		if( !foundVar )
+			return false;
+
+		m_pOffsetYVar = pMaterial->FindVar( "$sheenmapmaskoffsetY", &foundVar );
+		if( !foundVar )
+			return false;
+
+		m_pDirectionVar = pMaterial->FindVar( "$sheenmapmaskdirection", &foundVar );
+		if( !foundVar )
+			return false;
+
+		m_pSheenVar = pMaterial->FindVar( "$sheenmap", &foundVar );
+		if ( !foundVar )
+			return false;
+		
+		m_pSheenMaskVar = pMaterial->FindVar( "$sheenmapmask", &foundVar );
+		if ( !foundVar )
+			return false;
+
+		return CBaseAnimatedTextureProxy::Init( pMaterial, pKeyValues );
+	}
+
+	void OnBind( void *pEntity )
+	{
+		Assert( m_AnimatedTextureVar );
+		if ( m_AnimatedTextureVar->GetType() != MATERIAL_VAR_TYPE_TEXTURE )
+			return;
+
+		// if no entity, just check the owner
+		if ( !pEntity )
+		{
+			// Might be gunslinger, hard to get this item so 
+			return;
+		}
+
+		static CSchemaAttributeDefHandle pAttr_killstreak( "killstreak idleeffect" );	
+		if ( !pAttr_killstreak )
+			return;
+
+		IClientRenderable *pRend = (IClientRenderable *)pEntity;
+		// Find the weapon and player and see if it has the attribute
+		if ( !pRend )
+			return;
+
+		ITexture *pTexture;
+		pTexture = m_AnimatedTextureVar->GetTextureValue();
+		int numFrames = pTexture->GetNumAnimationFrames();
+
+		if ( numFrames <= 0 )
+		{
+			Assert( !"0 frames in material calling animated texture proxy" );
+			return;
+		}
+
+		C_BaseEntity *pBaseEntity = pRend->GetIClientUnknown()->GetBaseEntity();
+		const CEconItemView *pItem = dynamic_cast< CEconItemView* >( pRend );
+
+		uint32 unAttrValue = 0;
+		uint32 unEffectValue = 0;
+
+		// !TEST!
+#ifdef STAGING_ONLY
+		if ( tf_killstreak_alwayson.GetBool() )
+		{
+			unEffectValue = 1;
+		}
+		if ( tf_sheen_all.GetFloat() != 0 ) 
+		{
+			unEffectValue = tf_sheen_all.GetInt();
+		}
+#endif // STAGING_ONLY
+
+		// Find the tf player owner
+		bool bIsFirstPerson = false;
+		C_TFPlayer* pTFPlayer = NULL;
+		if ( pItem )	// ItemModelPanels
+		{
+			if ( !pBaseEntity )
+			{
+				pItem->FindAttribute( pAttr_killstreak, &unAttrValue );
+				unEffectValue = (int)((float&)unAttrValue);
+			}
+			else
+			{
+				CALL_ATTRIB_HOOK_INT_ON_OTHER( pBaseEntity, unAttrValue, killstreak_idleeffect );
+			}
+			
+			if ( ( unEffectValue ) && pBaseEntity && pBaseEntity->GetOwnerEntity() )
+			{
+				pTFPlayer = ToTFPlayer( pBaseEntity->GetOwnerEntity() );
+			}
+			else
+			{
+				pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
+			}
+		}
+		else	
+		{
+			CTFWeaponBase* pWeapon = dynamic_cast<CTFWeaponBase*>( pBaseEntity );
+			if ( !pWeapon )
+			{
+				for ( int i = 0; i < 1; ++i )
+				{
+					CEconWearable* pWearable = dynamic_cast<CEconWearable*>( pBaseEntity );
+					if ( pWearable )
+					{
+						pItem = pWearable->GetAttributeContainer()->GetItem();
+						pTFPlayer = ToTFPlayer( pWearable->GetOwnerEntity() );
+						break;
+					}
+					C_ViewmodelAttachmentModel *pModel = dynamic_cast<C_ViewmodelAttachmentModel*>( pBaseEntity );
+					if ( pModel )
+					{
+						if ( pModel->GetOuter() )
+						{
+							pItem = pModel->GetOuter()->GetAttributeContainer()->GetItem();
+							pBaseEntity = pBaseEntity->GetOwnerEntity();
+							if ( pItem )
+							{
+								pTFPlayer = ToTFPlayer( pModel->GetOuter()->GetOwnerEntity() );
+							}
+						}
+						break;
+					}
+
+					// not a weapon, is a viewmodel
+					IHasOwner *pHasOwner = dynamic_cast<IHasOwner*>( pBaseEntity );
+					if ( pHasOwner )
+					{
+						// View model owner is player, so get the players active weapon
+						CBaseEntity *pOwner = pHasOwner->GetOwnerViaInterface();
+						pTFPlayer = ToTFPlayer( pOwner );
+						if ( pTFPlayer )
+						{
+							pWeapon = pTFPlayer->GetActiveTFWeapon();
+							if ( pWeapon )
+							{
+								pItem = pWeapon->GetAttributeContainer()->GetItem();
+								pBaseEntity = pWeapon;
+							}
+							bIsFirstPerson = true;
+						}
+					}
+					else if ( pBaseEntity && pBaseEntity->IsPlayer( ) )
+					{
+						pTFPlayer = ToTFPlayer( pBaseEntity );
+						pWeapon = pTFPlayer->GetActiveTFWeapon();
+						if ( pWeapon )
+						{
+							pItem = pWeapon->GetAttributeContainer()->GetItem();
+							pBaseEntity = pWeapon;
+						}
+					}
+				}	// for 
+			}
+			else
+			{
+				pItem = pWeapon->GetAttributeContainer()->GetItem();
+				pBaseEntity = pWeapon;
+				pTFPlayer = ToTFPlayer( pWeapon->GetOwner() );
+			}
+
+			// I have an econ item, does it have the attr
+			if ( ( pBaseEntity && pItem ) || unEffectValue )
+			{
+				CALL_ATTRIB_HOOK_INT_ON_OTHER( pBaseEntity, unAttrValue, killstreak_idleeffect );
+
+				if ( !unEffectValue )
+				{
+					unEffectValue = unAttrValue;
+				}
+				
+				// Use the Spies target if disguised and we're on different teams
+				if ( pTFPlayer && pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pTFPlayer->GetTeamNumber() != GetLocalPlayerTeam() )
+				{
+					pTFPlayer = ToTFPlayer( pTFPlayer->m_Shared.GetDisguiseTarget() );
+					if ( pTFPlayer && pTFPlayer->m_Shared.GetDisguiseWeapon() )
+					{
+						pItem = pTFPlayer->m_Shared.GetDisguiseWeapon()->GetAttributeContainer()->GetItem();
+						pBaseEntity = pTFPlayer->m_Shared.GetDisguiseWeapon();
+					}
+				}
+			}
+		}
+
+		float flNextStartTime = 0;
+		if ( pTFPlayer )
+		{
+			// if player is taunting, make sure they can start animating
+			if ( pTFPlayer->IsTaunting() && flNextStartTime > gpGlobals->curtime )
+			{
+				pTFPlayer->m_flNextSheenStartTime = gpGlobals->curtime;
+			}
+			flNextStartTime = pTFPlayer->m_flNextSheenStartTime;
+		}
+		else
+		{
+			flNextStartTime = m_flNextStartTime;
+		}
+
+		// !TEST!
+#ifdef STAGING_ONLY
+		if ( tf_killstreak_alwayson.GetBool() )
+		{
+			unEffectValue = 1;
+		}
+
+		if ( tf_sheen_all.GetFloat() != 0 ) 
+		{
+			unEffectValue = tf_sheen_all.GetInt();
+		}
+#endif // STAGING_ONLY
+
+		// Not ready, so just exit
+		if ( !pItem || !unEffectValue || flNextStartTime > gpGlobals->curtime || unEffectValue > ARRAYSIZE( g_KillStreakEffectsBase ) - 1 )
+		{
+			RunNoProxy();
+			return;
+		}
+
+		// Negative Value implies it has not been set, set it now
+		if ( m_flScaleX < 0 )
+		{
+			if ( !InitParams( pRend, pBaseEntity ) )
+			{
+				RunNoProxy();
+				return;
+			}
+		}
+
+		// NOTE: Must not use relative time based methods here
+		// because the bind proxy can be called many times per frame.
+		// Prevent multiple Wrap callbacks to be sent for no wrap mode
+		float startTime = pTFPlayer ? pTFPlayer->m_flNextSheenStartTime : 0;
+		float deltaTime = gpGlobals->curtime - startTime;
+		float prevTime = deltaTime - gpGlobals->frametime;
+
+		// Clamp..
+		if (deltaTime < 0.0f)
+			deltaTime = 0.0f;
+		if (prevTime < 0.0f)
+			prevTime = 0.0f;
+
+		// Code Frame rate to be 25
+		float frame = tf_sheen_framerate.GetInt() * deltaTime;	
+		float prevFrame = tf_sheen_framerate.GetInt() * prevTime;
+
+		int intFrame = ((int)frame) % numFrames; 
+		int intPrevFrame = ((int)prevFrame) % numFrames;
+
+		// Report wrap situation...
+		if ( intPrevFrame > intFrame )
+		{
+			// Set frame to zero and set the time for the next
+			intFrame = 0;
+			if ( pTFPlayer )
+			{
+				pTFPlayer->m_flNextSheenStartTime = gpGlobals->curtime + GetTimeBetweenAnims( pTFPlayer );
+			}
+			else
+			{
+				m_flNextStartTime = gpGlobals->curtime + GetTimeBetweenAnims( NULL );
+			}
+		}
+
+		float color[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+		killstreak_params_t sheenParams = GetSheenParams( unEffectValue, pTFPlayer ? pTFPlayer->GetTeamNumber() == TF_TEAM_BLUE : false );
+		color[ 0 ] = sheenParams.m_sheen_r;
+		color[ 1 ] = sheenParams.m_sheen_g;
+		color[ 2 ] = sheenParams.m_sheen_b;
+		color[ 3 ] = sheenParams.m_sheen_a;
+
+#ifdef STAGING_ONLY
+		if ( tf_sheen_color_override_a.GetFloat() > 0 )
+		{
+			color[0] = tf_sheen_color_override_r.GetFloat();
+			color[1] = tf_sheen_color_override_g.GetFloat();
+			color[2] = tf_sheen_color_override_b.GetFloat();
+			color[3] = tf_sheen_color_override_a.GetFloat();
+		}
+#endif // STAGING_ONLY
+
+		if ( bIsFirstPerson )
+		{
+			color[ 3 ] = tf_sheen_alpha_firstperson.GetFloat();
+			m_pTintVar->SetVecValue( color, 4 );
+		}
+		else
+		{
+			m_pTintVar->SetVecValue( color, 4 );
+		}
+		
+		// Set vars
+		m_AnimatedTextureFrameNumVar->SetIntValue( intFrame );
+		m_pScaleXVar->SetFloatValue( m_flScaleX );			// Only need to set once?
+		m_pScaleYVar->SetFloatValue( m_flScaleY );
+		m_pOffsetXVar->SetFloatValue( m_flSheenOffsetX );
+		m_pOffsetYVar->SetFloatValue( m_flSheenOffsetY );
+		m_pDirectionVar->SetIntValue( m_iSheenDir );
+
+		int iShaderIndex = sheenParams.m_iShaderIndex;
+
+		// Australium weapons always use iShaderIndex 1
+		const CEconStyleInfo *pStyle = pItem->GetStaticData()->GetStyleInfo( pItem->GetItemStyle() );
+		if ( pStyle && !pStyle->IsSelectable() )
+		{
+			iShaderIndex = 1;
+		}
+
+#ifdef STAGING_ONLY
+		if ( tf_sheen_shader_override.GetInt() > 0 )
+		{
+			iShaderIndex = tf_sheen_shader_override.GetInt();
+		}
+#endif // staging_only
+		
+		m_pSheenIndexVar->SetIntValue( iShaderIndex );
+
+		if ( ToolsEnabled() )
+		{
+			ToolFramework_RecordMaterialParams( GetMaterial() );
+		}
+	}
+
+	// the last time the animation was run (or will allowed to be run)
+	float GetAnimationStartTime( void* pBaseEntity )
+	{
+		return 0;
+	}
+
+	float GetTimeBetweenAnims ( C_TFPlayer* pTFPlayer )
+	{
+		const float MAX_SHEEN_WAIT = 5.0f;
+		const float MAX_KILLS = 5.0f;
+
+#ifdef STAGING_ONLY
+		if ( tf_sheen_fast.GetBool() )
+			return 0;
+#endif
+
+		if ( !pTFPlayer )
+			return MAX_SHEEN_WAIT;
+
+		if ( pTFPlayer->IsTaunting() )
+			return 0;
+
+		// Set the time between sheens based on kill streak
+		int iStreak = pTFPlayer->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills );
+
+		if ( iStreak >= MAX_KILLS )
+			return 0;
+
+		if ( iStreak == 0 )
+			return MAX_SHEEN_WAIT;
+
+		// as player gets more kills, time decreases
+		return ( 1.0f - ( iStreak / MAX_KILLS ) ) * MAX_SHEEN_WAIT;
+	}
+
+	killstreak_params_t GetSheenParams( uint32 unEffectValue, bool bIsTeamBlue )
+	{
+		Assert( unEffectValue > 0 && unEffectValue < ARRAYSIZE( g_KillStreakEffectsBase ) );
+		killstreak_params_t params = g_KillStreakEffectsBase[ unEffectValue ];
+
+		if ( bIsTeamBlue && params.m_bHasTeamColor )
+		{
+			Assert( unEffectValue > 0 && unEffectValue < ARRAYSIZE( g_KillStreakEffectsBlue ) );
+			return g_KillStreakEffectsBlue[ unEffectValue ];
+		}
+		return params;	
+	}
+
+	bool InitParams( IClientRenderable *pRend, C_BaseEntity *pBaseEntity )
+	{
+		// Negative Value implies it has not been set, set it now
+		if ( m_flScaleX < 0 )
+		{
+			Vector vMin, vMax;
+			
+			// Check if the baseEntity is ready
+			if ( pBaseEntity )
+			{
+				CBaseAnimating *pAnimating = dynamic_cast< CBaseAnimating * > ( pBaseEntity );
+				if ( !pAnimating || !pAnimating->GetModelPtr() || pAnimating->GetModelPtr()->GetNumSeq() < pAnimating->GetSequence() )
+				{
+					return false;
+				}
+			}
+
+			pRend->GetRenderBounds( vMin, vMax );
+			m_flScaleX = vMax.x - vMin.x;
+			m_flSheenOffsetX = vMin.x;
+
+			m_flScaleY = vMax.z - vMin.z;
+			m_flSheenOffsetY = vMin.z;
+			m_iSheenDir = 0;
+
+			if ( vMax.y - vMin.y > m_flScaleX )
+			{
+				m_flScaleX = vMax.y - vMin.y;
+				m_flSheenOffsetX = vMin.y;
+
+				m_flScaleY = vMax.x - vMin.x;
+				m_flSheenOffsetY = vMin.x;
+
+				m_iSheenDir = 1;
+			}
+
+			if ( vMax.z - vMin.z > m_flScaleX )
+			{
+				m_flScaleX = vMax.z - vMin.z;
+				m_flSheenOffsetX = vMin.z;
+
+				m_flScaleY = vMax.y - vMin.y;
+				m_flSheenOffsetY = vMin.y;
+
+				m_iSheenDir = 2;
+			}
+		}
+		return true;
+	}
+
+	void Cleanup()
+	{
+		m_pTintVar = NULL;
+		CBaseAnimatedTextureProxy::Cleanup();
+	}
+
+	void RunNoProxy ()
+	{
+		m_pTintVar->SetVecValue( 0, 0, 0 ); 
+		m_AnimatedTextureFrameNumVar->SetIntValue( 0 );
+		m_pSheenIndexVar->SetIntValue( 0 );
+	}
+
+private:
+
+	IMaterialVar *m_pSheenIndexVar;
+	IMaterialVar *m_pTintVar;
+
+	IMaterialVar *m_pSheenVar;			// Overloaded for Weapon Pattern
+	IMaterialVar *m_pSheenMaskVar;		// Weapon Pattern Mask
+
+	IMaterialVar *m_pScaleXVar;
+	IMaterialVar *m_pScaleYVar;
+	IMaterialVar *m_pOffsetXVar;
+	IMaterialVar *m_pOffsetYVar;
+	IMaterialVar *m_pDirectionVar;
+
+	float m_flNextStartTime;		// Used in the rare case of playermodelpanels with no local player
+
+	float m_flScaleX;
+	float m_flScaleY;
+	float m_flSheenOffsetX;
+	float m_flSheenOffsetY;
+	int m_iSheenDir;
+};
+
+EXPOSE_INTERFACE( CProxyAnimatedWeaponSheen, IMaterialProxy, "AnimatedWeaponSheen" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+// StatTrack Proxy
+
+//-----------------------------------------------------------------------------
+// StatTrakIllum proxy
+//-----------------------------------------------------------------------------
+class CStatTrakIllumProxy : public CResultProxy
+{
+public:
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pC_BaseEntity );
+
+private:
+	CFloatInput	m_flMinVal;
+	CFloatInput	m_flMaxVal;
+};
+
+
+bool CStatTrakIllumProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if ( !CResultProxy::Init( pMaterial, pKeyValues ) )
+		return false;
+
+	if ( !m_flMinVal.Init( pMaterial, pKeyValues, "minVal", 0.5 ) )
+		return false;
+
+	if ( !m_flMaxVal.Init( pMaterial, pKeyValues, "maxVal", 1 ) )
+		return false;
+
+	return true;
+}
+
+void CStatTrakIllumProxy::OnBind( void *pC_BaseEntity )
+{
+
+	if ( !pC_BaseEntity )
+		return;
+
+	C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
+	if ( pEntity )
+	{
+		// StatTrak modules are children of their accompanying viewmodels
+		C_BaseViewModel *pViewModel = dynamic_cast<C_BaseViewModel*>( pEntity->GetMoveParent() );
+		if ( pViewModel )
+		{
+			//SetFloatResult( Lerp( pViewModel->GetStatTrakGlowMultiplier(), m_flMinVal.GetFloat(), m_flMaxVal.GetFloat() ) );
+			SetFloatResult( 0.75f );
+			return;
+		}
+	}
+
+}
+
+EXPOSE_INTERFACE( CStatTrakIllumProxy, IMaterialProxy, "StatTrakIllum" IMATERIAL_PROXY_INTERFACE_VERSION );
+//-----------------------------------------------------------------------------
+// StatTrak 'kill odometer' support: given a numerical value expressed as a string, pick a texture frame to represent a given digit
+//-----------------------------------------------------------------------------
+class CStatTrakDigitProxy : public CResultProxy
+{
+public:
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pC_BaseEntity );
+
+	virtual bool HelperOnBindGetStatTrakScore( void *pC_BaseEntity, int *piScore );
+
+private:
+	CFloatInput	m_flDisplayDigit; // the particular digit we want to display
+	CFloatInput	m_flTrimZeros;
+};
+
+
+bool CStatTrakDigitProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	if ( !CResultProxy::Init( pMaterial, pKeyValues ) )
+		return false;
+
+	if ( !m_flDisplayDigit.Init( pMaterial, pKeyValues, "displayDigit", 0 ) )
+		return false;
+
+	if ( !m_flTrimZeros.Init( pMaterial, pKeyValues, "trimZeros", 0 ) )
+		return false;
+
+	return true;
+}
+
+bool CStatTrakDigitProxy::HelperOnBindGetStatTrakScore( void *pC_BaseEntity, int *piScore )
+{
+	if ( !pC_BaseEntity )
+		return false;
+
+	if ( !piScore )
+		return false;
+
+	bool bReturnValue = false;
+	uint32 unScore = 0;
+	C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
+	if ( pEntity )
+	{
+		// StatTrak modules are children of their accompanying viewmodels
+		C_ViewmodelAttachmentModel *pViewModel = dynamic_cast<C_ViewmodelAttachmentModel*>( pEntity->GetMoveParent() );
+		if ( pViewModel )
+		{
+			//C_TFPlayer *pPlayer = ToTFPlayer( pViewModel->GetOwnerEntity() );
+			//if ( pPlayer )
+			CTFWeaponBase *pWeap = dynamic_cast<CTFWeaponBase*>( pViewModel->GetOwnerEntity() );
+			if ( pWeap )
+			{
+				
+				// Use the strange prefix if the weapon has one.
+				if ( pWeap->GetAttributeContainer()->GetItem()->FindAttribute( GetKillEaterAttr_Score( 0 ), &unScore ) )
+				{
+					*piScore = unScore;
+					bReturnValue = true;
+				}
+			}
+		}
+	}
+	else
+	{
+		// No Base entity, may be a straight econ item view (item model panel)
+		IClientRenderable *pRend = (IClientRenderable *)pC_BaseEntity;
+		if ( pRend )
+		{
+			const CEconItemView *pItem = dynamic_cast< CEconItemView* >( pRend );
+			if ( pItem && pItem->FindAttribute( GetKillEaterAttr_Score( 0 ), &unScore ) )
+			{
+				*piScore = unScore;
+				bReturnValue = true;
+			}
+		}
+	}
+	return bReturnValue;
+}
+
+#ifdef STAGING_ONLY
+ConVar tf_stattrak_test_score( "tf_stattrak_test_score", "-1", FCVAR_CHEAT, "" );
+#endif // STAGING_ONLY
+
+void CStatTrakDigitProxy::OnBind( void *pC_BaseEntity )
+{
+	int nKillEaterAltScore = 0;
+
+	bool bHasScoreToDisplay = HelperOnBindGetStatTrakScore( pC_BaseEntity, &nKillEaterAltScore );
+	if ( !bHasScoreToDisplay )
+	{	// Error?
+		//SetFloatResult( (int)fmod( gpGlobals->curtime, 10.0f ) );
+		SetFloatResult( 0 );
+		return;
+	}
+
+#ifdef STAGING_ONLY
+	if ( tf_stattrak_test_score.GetInt() > -1 )
+	{
+		nKillEaterAltScore = tf_stattrak_test_score.GetInt();
+	}
+#endif // STAGING_ONLY
+
+	int iDesiredDigit = (int)m_flDisplayDigit.GetFloat();
+
+	// trim preceding zeros
+	if ( m_flTrimZeros.GetFloat() > 0 )
+	{
+		if ( pow( 10.0f, iDesiredDigit ) > nKillEaterAltScore )
+		{
+			SetFloatResult( 10.0f ); //assumed blank frame
+			return;
+		}
+	}
+
+	// get the [0-9] value of the digit we want
+	int iDigitCount = MIN( iDesiredDigit, 10 );
+	for ( int i = 0; i < iDigitCount; i++ )
+	{
+		nKillEaterAltScore /= 10;
+	}
+	nKillEaterAltScore %= 10;
+
+	SetFloatResult( nKillEaterAltScore );
+}
+
+EXPOSE_INTERFACE( CStatTrakDigitProxy, IMaterialProxy, "StatTrakDigit" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+//-----------------------------------------------------------------------------
+// Stattrak Icon proxy
+//-----------------------------------------------------------------------------
+class CStatTrakIconProxy : public CResultProxy
+{
+public:
+	virtual bool Init( IMaterial *pMaterial, KeyValues *pKeyValues );
+	virtual void OnBind( void *pC_BaseEntity );
+
+private:
+	//CFloatInput	m_flMinVal;
+
+};
+
+
+bool CStatTrakIconProxy::Init( IMaterial *pMaterial, KeyValues *pKeyValues )
+{
+	/*if ( !CResultProxy::Init( pMaterial, pKeyValues ) )
+		return false;
+
+	if ( !m_flMinVal.Init( pMaterial, pKeyValues, "minVal", 0.5 ) )
+		return false;
+
+	if ( !m_flMaxVal.Init( pMaterial, pKeyValues, "maxVal", 1 ) )
+		return false;*/
+
+	return CResultProxy::Init( pMaterial, pKeyValues );
+}
+
+ConVar tf_stattrak_icon_offset_x( "tf_stattrak_icon_offset_x", "0", FCVAR_DEVELOPMENTONLY );
+ConVar tf_stattrak_icon_offset_y( "tf_stattrak_icon_offset_y", "0", FCVAR_DEVELOPMENTONLY );
+ConVar tf_stattrak_icon_scale( "tf_stattrak_icon_scale", "1.0", FCVAR_DEVELOPMENTONLY );
+
+void CStatTrakIconProxy::OnBind( void *pC_BaseEntity )
+{
+	// Find the StatTracker Type and Lookup the offset, for now hacks!
+	//if ( !pC_BaseEntity )
+	//	return;
+
+	//C_BaseEntity *pEntity = BindArgToEntity( pC_BaseEntity );
+	//if ( pEntity )
+	//{
+	//	// StatTrak modules are children of their accompanying viewmodels
+	//	C_BaseViewModel *pViewModel = dynamic_cast<C_BaseViewModel*>( pEntity->GetMoveParent() );
+	//	if ( pViewModel )
+	//	{
+	//		//SetFloatResult( Lerp( pViewModel->GetStatTrakGlowMultiplier(), m_flMinVal.GetFloat(), m_flMaxVal.GetFloat() ) );
+	//		SetFloatResult( 0.75f );
+	//		return;
+	//	}
+	//}
+
+
+	Vector2D center( 0.5, 0.5 );
+	Vector2D translation( 0, 0 );
+
+	VMatrix mat, temp;
+	mat.Identity();
+	//if ( m_pCenterVar )
+	//{
+	//	m_pCenterVar->GetVecValue( center.Base(), 2 );
+	//}
+	//MatrixBuildTranslation( mat, -center.x, -center.y, 0.0f );
+
+	//if ( m_pScaleVar )
+	//{
+	//	Vector2D scale;
+	//	m_pScaleVar->GetVecValue( scale.Base(), 2 );
+	//	MatrixBuildScale( temp, scale.x, scale.y, 1.0f );
+	//	MatrixMultiply( temp, mat, mat );
+	//}
+
+	//if ( m_pRotateVar )
+	//{
+	//	float angle = m_pRotateVar->GetFloatValue();
+	//	MatrixBuildRotateZ( temp, angle );
+	//	MatrixMultiply( temp, mat, mat );
+	//}
+	//MatrixBuildTranslation( temp, center.x, center.y, 0.0f );
+	//MatrixMultiply( temp, mat, mat );
+
+	//if ( m_pTranslateVar )
+	{
+		//m_pTranslateVar->GetVecValue( translation.Base(), 2 );
+		MatrixBuildTranslation( temp, tf_stattrak_icon_offset_x.GetFloat(), tf_stattrak_icon_offset_y.GetFloat(), 0.0f );
+		MatrixMultiply( temp, mat, mat );
+	}
+
+	m_pResult->SetMatrixValue( mat );
+
+	if ( ToolsEnabled() )
+	{
+		ToolFramework_RecordMaterialParams( GetMaterial() );
+	}
+
+}
+
+EXPOSE_INTERFACE( CStatTrakIconProxy, IMaterialProxy, "StatTrakIcon" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+struct TextureVarSetter
+{
+	TextureVarSetter( IMaterialVar* pDestVar, ITexture* pDefaultTexture ) 
+	: m_pDestVar( pDestVar )
+	, m_pTexture( pDefaultTexture )
+	{ 
+		Assert( pDestVar && pDefaultTexture ); 
+	}
+
+	void SetTexture( ITexture* pTexture ) { m_pTexture = pTexture; }
+
+	~TextureVarSetter()
+	{
+		m_pDestVar->SetTextureValue( m_pTexture );
+	}
+
+	IMaterialVar* m_pDestVar;
+	ITexture* m_pTexture;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: Used for weapon skins.
+//-----------------------------------------------------------------------------
+class CWeaponSkinProxy : public IMaterialProxy
+{
+public:
+	CWeaponSkinProxy( void )
+	: m_pMaterial( NULL )
+	, m_pBaseTextureVar( NULL )
+	, m_pBaseTextureOrig( NULL )
+	, m_nGeneration( CRTime::RTime32TimeCur() )
+	{
+	}
+
+	~CWeaponSkinProxy()
+	{
+		SafeRelease( &m_pBaseTextureOrig );
+	}
+
+	inline ITexture* GetWeaponSkinBaseLowRes( bool bPlayerIsLocalPlayer, itemid_t nID, int iTeam ) const
+	{
+		if ( !bPlayerIsLocalPlayer )
+			return NULL;
+		
+		CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();
+		if ( !pLocalInv )
+			return NULL;
+
+		return pLocalInv->GetWeaponSkinBaseLowRes( nID, iTeam );
+	}
+
+	inline bool TestAndSetBaseTexture()
+	{
+		if ( m_pBaseTextureOrig )
+		{
+			return true;
+		}
+
+		Assert( m_pBaseTextureVar != NULL );
+
+		// If the material is in the process of being async loaded, the var won't be a 
+		// texture yet, it'll be a string. 
+		if ( !m_pBaseTextureVar->IsTexture() )
+			return false;
+
+		ITexture* baseTexture = m_pBaseTextureVar->GetTextureValue();
+		Assert( baseTexture != NULL );
+		SafeAssign( &m_pBaseTextureOrig, baseTexture );
+		return true;
+	}
+
+	virtual bool Init( IMaterial *pMaterial, KeyValues* pKeyValues )
+	{
+		// We don't support DX8
+		ConVarRef mat_dxlevel( "mat_dxlevel" );
+		if ( mat_dxlevel.GetInt() < 90 )
+			return false;
+
+		Assert( pMaterial );
+		m_pMaterial = pMaterial;
+
+		bool bFound = false;
+		m_pBaseTextureVar = m_pMaterial->FindVar( "$basetexture", &bFound );
+		if ( !bFound ) 
+			return false;
+
+		// If we are doing load on demand, this might not be ready yet. 
+		// If not, then don't set it so the OnBind code knows not to rely on it.
+		// We don't actually care if the code succeeds here.
+		TestAndSetBaseTexture();
+	
+		return true;
+
+	}
+
+	virtual void OnBind( void *pC_BaseEntity )
+	{
+		tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s", __FUNCTION__ );
+
+		// If the base texture isn't ready yet, we cannot composite. So just bail out. Not even sure what 
+		// we could feasibly do in this case to workaround this, we don't have a texture to use yet.
+		if ( !TestAndSetBaseTexture() )
+			return;
+
+		Assert( m_pBaseTextureVar );
+
+		// This will set the texture when it goes out of scope. We can override with other textures along the way.
+		// This handles the return cases gracefully.
+		TextureVarSetter setter( m_pBaseTextureVar, m_pBaseTextureOrig );
+
+	#ifdef STAGING_ONLY
+		// If we're not doing paintkits, exit out now (to set the base texture correctly).
+		if ( tf_paint_kit_disable.GetBool() )
+			return;
+	#endif // STAGING_ONLY
+
+		CEconItemView *pItem = GetEconItemViewFromProxyEntity( pC_BaseEntity );
+		if ( !pItem )
+			return;
+
+		C_TFPlayer *pOwner = GetOwnerFromProxyEntity( pC_BaseEntity );
+		int desiredW = m_pBaseTextureOrig->GetActualWidth();
+		int desiredH = m_pBaseTextureOrig->GetActualHeight();
+		const bool cbPlayerIsLocalPlayer = C_TFPlayer::GetLocalTFPlayer() && pOwner == C_TFPlayer::GetLocalTFPlayer();
+
+		// Doing material overrides from the econ definitions can cause the same 
+		// item to be referred to from multiple materials. The code treats the 
+		// override material as the controller material. 
+		const IMaterial* pMaterialOverride = pItem->GetMaterialOverride( pItem->GetTeamNumber() );
+		const bool cbIsControllingMaterial = pMaterialOverride == NULL || pMaterialOverride == m_pMaterial;
+
+		// if we're not using high res, check if we should down res
+		// We may force low res for some composites. 
+		if ( pItem->ShouldWeaponSkinUseLowRes() || ( !pItem->ShouldWeaponSkinUseHighRes() && !cbPlayerIsLocalPlayer ) )
+		{
+			const int cDropMips = 2;
+			desiredW = Max( 1, desiredW >> cDropMips );
+			desiredH = Max( 1, desiredH >> cDropMips );
+		}
+
+		// If the object's generation isn't equal to when we told it, we need to regenerate it.
+		if ( cbIsControllingMaterial && ( pItem->GetWeaponSkinGeneration() != m_nGeneration || pItem->GetWeaponSkinGenerationTeam() != pItem->GetTeamNumber() ) )
+		{
+			// Skip this so we dont see a pop in staging
+#ifdef STAGING_ONLY
+			if ( !tf_paint_kit_force_regen.GetBool() )
+#endif
+			{
+				pItem->SetWeaponSkinBase( NULL );
+				pItem->SetWeaponSkinBaseCompositor( NULL );
+			}
+		}
+
+		ITexture* pWeaponSkinBase = pItem->GetWeaponSkinBase();
+
+		// If we have already completed the composite and stored it (or if there was an error)
+		// indicate that here.
+		if ( pWeaponSkinBase )
+		{
+			{
+				setter.SetTexture( pWeaponSkinBase );
+				// If the texture is the correct res already, we're done!
+#ifdef STAGING_ONLY
+				if ( !tf_paint_kit_force_regen.GetBool() && desiredW == pWeaponSkinBase->GetActualWidth() && desiredH == pWeaponSkinBase->GetActualHeight() )
+#else
+				if ( desiredW == pWeaponSkinBase->GetActualWidth() && desiredH == pWeaponSkinBase->GetActualHeight() )
+#endif
+					return;
+			}
+		}
+
+		// If we're doing material overrides, we may get in twice--but the non-controlling material should
+		// bail out now.
+		if ( !cbIsControllingMaterial )
+			return;
+
+		ITextureCompositor* pWeaponSkinBaseCompositor = pItem->GetWeaponSkinBaseCompositor();
+
+		bool bUseLowRes = false;
+
+		if ( pWeaponSkinBaseCompositor )
+		{
+			ECompositeResolveStatus status = pWeaponSkinBaseCompositor->GetResolveStatus();
+
+			bool cleanupCompositor = false;
+
+			switch ( status )
+			{
+			case ECRS_Idle: 
+				Assert( !"Unexpected state, shouldn't be idle here." );
+				break;
+
+			case ECRS_Scheduled:
+				// This is fine, this happens when multiple views ask for the same composite on the 
+				// same frame. For example, a Model Panel and the world view. 
+				bUseLowRes = true;
+				break;
+
+			case ECRS_PendingTextureLoads:
+				// Totally fine, try again later.
+				bUseLowRes = true;
+				break;
+
+			case ECRS_PendingComposites:
+				// Totally fine, try again later.
+				bUseLowRes = true;
+				break;
+
+			case ECRS_Error:
+				// Had an error, just show the current base texture forever. 
+				// Is this a reasonable error handler? Seems like it is, though maybe
+				// we want to show the error texture for at least dev mode.
+				Assert( !"Error while compositing, should figure out wtf.");
+				pItem->SetWeaponSkinBase( m_pBaseTextureOrig );
+				cleanupCompositor = true;
+				break;
+
+			case ECRS_Complete:
+				// Success! Use the new texture for all time. Or whatever.
+				pWeaponSkinBase = pWeaponSkinBaseCompositor->GetResultTexture();
+				pItem->SetWeaponSkinBase( pWeaponSkinBase );
+				setter.SetTexture( pWeaponSkinBase );
+				cleanupCompositor = true;
+				break;
+
+			default:
+				Assert( !"Unexpected return value from ITextureCompositor::GetResolveStatus" );
+				break;
+			};
+
+			if ( cleanupCompositor )
+			{
+				pItem->SetWeaponSkinBaseCompositor( NULL );
+				pWeaponSkinBaseCompositor = NULL;
+			}
+
+			if ( bUseLowRes )
+			{
+				ITexture* pTex = GetWeaponSkinBaseLowRes( cbPlayerIsLocalPlayer, pItem->GetItemID(), pItem->GetTeamNumber() );
+				if ( pTex )
+					setter.SetTexture( pTex );
+			}
+
+			return;
+		}
+
+		// Start the composite. 
+		KeyValues* rootKV = NULL;
+		float flWear = 0;
+		if ( !pItem->GetCustomPaintKitWear( flWear ) )
+		{
+			return;
+		}
+		int nWear = EconWear_ToIntCategory( flWear );
+
+	#ifdef STAGING_ONLY
+		if ( tf_paint_kit_force_wear.GetInt() > 0 )
+		{
+			nWear = Min( tf_paint_kit_force_wear.GetInt(), 5 );
+		}
+	#endif // STAGING_ONLY
+
+		const char* pItemName = "unknown";
+		const GameItemDefinition_t* tfItemDef = pItem->GetItemDefinition();
+		if ( tfItemDef )
+		{
+			const char* pMaybeName = tfItemDef->GetPaintKitName();
+			if ( pMaybeName ) 
+				pItemName = pMaybeName;
+			rootKV = tfItemDef->GetPaintKitWearDefinition( nWear );
+		}
+
+		uint32 nCompositeFlags = 0;
+	#ifdef STAGING_ONLY
+		if ( s_bIsPaintkitOverrideSet == true )
+		{
+			// Fetch the wear level KV
+			const char *vArgs = VarArgs( "wear_level_%d", nWear );
+			FOR_EACH_SUBKEY( s_kvOverridePaintkit, wearKv )
+			{
+				if ( !V_strcmp( vArgs, wearKv->GetName() ) )
+				{
+					rootKV = wearKv;
+					break;
+				}
+			}
+			nCompositeFlags = TEX_COMPOSITE_CREATE_FLAGS_FORCE;
+		}
+
+		if ( tf_paint_kit_generating_icons.GetBool() )
+		{
+			nCompositeFlags = TEX_COMPOSITE_CREATE_FLAGS_FORCE;
+		}
+	#endif // STAGING_ONLY
+
+		if ( rootKV )
+		{
+			uint64 seed = pItem->GetOriginalID();
+	#ifdef STAGING_ONLY
+			if ( tf_paint_kit_seed_override.GetInt() != 0 )
+			{
+				seed = tf_paint_kit_seed_override.GetInt();
+			}
+	#endif // STAGING_ONLY
+
+			Assert( pItem->GetTeamNumber() != TEAM_UNASSIGNED );
+			int teamNum = pItem->GetTeamNumber() != TEAM_UNASSIGNED ? pItem->GetTeamNumber() : TF_TEAM_RED;
+	#ifdef STAGING_ONLY
+			if ( tf_paint_kit_team_override.GetInt() >= 0 )
+			{
+				teamNum = tf_paint_kit_team_override.GetInt() == 0 ? TF_TEAM_RED : TF_TEAM_BLUE;
+				pItem->SetTeamNumber( teamNum );
+			}
+	#endif // STAGING_ONLY
+
+			char finalItemName[_MAX_PATH];
+			V_sprintf_safe( finalItemName, "%s_wear_%02d", pItemName, nWear );
+
+			SafeAssign( &pWeaponSkinBaseCompositor, materials->NewTextureCompositor( desiredW, desiredH, finalItemName, teamNum, seed, rootKV, nCompositeFlags ) );
+			if ( pWeaponSkinBaseCompositor )
+			{
+				pWeaponSkinBaseCompositor->ScheduleResolve();
+				pItem->SetWeaponSkinGeneration( m_nGeneration );
+				pItem->SetWeaponSkinGenerationTeam( teamNum );
+
+				if ( pWeaponSkinBaseCompositor->GetResolveStatus() != ECRS_Complete )
+				{
+					// Normal case
+					pItem->SetWeaponSkinBaseCompositor( pWeaponSkinBaseCompositor );
+
+					// Try to sub out the low res, if it's ready.
+					ITexture* pTex = GetWeaponSkinBaseLowRes( cbPlayerIsLocalPlayer, pItem->GetItemID(), pItem->GetTeamNumber() );
+					if ( pTex )
+						setter.SetTexture( pTex );
+				}
+				else 
+				{
+					// Had a cache hit, so add the texture here.
+					pWeaponSkinBase = pWeaponSkinBaseCompositor->GetResultTexture();
+					pItem->SetWeaponSkinBase( pWeaponSkinBase );
+					setter.SetTexture( pWeaponSkinBase );
+				}
+
+				SafeRelease( pWeaponSkinBaseCompositor );
+				return;
+			} 
+		}
+
+	}
+
+	virtual void Release() { delete this; }
+	virtual IMaterial *	GetMaterial() { return m_pMaterial; }
+
+private:
+	IMaterial			*m_pMaterial;
+
+	IMaterialVar		*m_pBaseTextureVar;
+	ITexture			*m_pBaseTextureOrig;
+
+	RTime32				m_nGeneration;
+
+	bool				m_bForceUpdate;
+};
+
+EXPOSE_INTERFACE( CWeaponSkinProxy, IMaterialProxy, "WeaponSkin" IMATERIAL_PROXY_INTERFACE_VERSION );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: RecvProxy that converts the Player's object UtlVector to entindexes
+//-----------------------------------------------------------------------------
+void RecvProxy_PlayerObjectList( const CRecvProxyData *pData, void *pStruct, void *pOut )
+{
+	C_TFPlayer *pPlayer = (C_TFPlayer*)pStruct;
+	CBaseHandle *pHandle = (CBaseHandle*)(&(pPlayer->m_aObjects[pData->m_iElement])); 
+	RecvProxy_IntToEHandle( pData, pStruct, pHandle );
+}
+
+void RecvProxyArrayLength_PlayerObjects( void *pStruct, int objectID, int currentArrayLength )
+{
+	C_TFPlayer *pPlayer = (C_TFPlayer*)pStruct;
+
+	if ( pPlayer->m_aObjects.Count() != currentArrayLength )
+	{
+		pPlayer->m_aObjects.SetSize( currentArrayLength );
+	}
+
+	pPlayer->ForceUpdateObjectHudState();
+}
+
+EXTERN_RECV_TABLE( DT_ScriptCreatedItem );
+
+// specific to the local player
+BEGIN_RECV_TABLE_NOBASE( C_TFPlayer, DT_TFLocalPlayerExclusive )
+	RecvPropVectorXY( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
+	RecvPropFloat( RECVINFO_NAME( m_vecNetworkOrigin[2], m_vecOrigin[2] ) ),
+	RecvPropArray2( 
+		RecvProxyArrayLength_PlayerObjects,
+		RecvPropInt( "player_object_array_element", 0, SIZEOF_IGNORE, 0, RecvProxy_PlayerObjectList ), 
+		MAX_OBJECTS_PER_PLAYER, 
+		0, 
+		"player_object_array"	),
+
+	RecvPropFloat( RECVINFO( m_angEyeAngles[0] ) ),				// No longer used by the local player, could be omitted. Preserved for backwards-compat for now.
+//	RecvPropFloat( RECVINFO( m_angEyeAngles[1] ) ),
+
+	RecvPropBool( RECVINFO( m_bIsCoaching ) ),
+	RecvPropEHandle( RECVINFO( m_hCoach ) ),
+	RecvPropEHandle( RECVINFO( m_hStudent ) ),
+
+	RecvPropInt( RECVINFO( m_nCurrency ) ),
+	RecvPropInt( RECVINFO( m_nExperienceLevel ) ),
+	RecvPropInt( RECVINFO( m_nExperienceLevelProgress ) ),
+	RecvPropInt( RECVINFO( m_bMatchSafeToLeave ) ),
+
+END_RECV_TABLE()
+
+// all players except the local player
+BEGIN_RECV_TABLE_NOBASE( C_TFPlayer, DT_TFNonLocalPlayerExclusive )
+	RecvPropVectorXY( RECVINFO_NAME( m_vecNetworkOrigin, m_vecOrigin ) ),
+	RecvPropFloat( RECVINFO_NAME( m_vecNetworkOrigin[2], m_vecOrigin[2] ) ),
+
+	RecvPropFloat( RECVINFO( m_angEyeAngles[0] ) ),
+	RecvPropFloat( RECVINFO( m_angEyeAngles[1] ) ),
+
+END_RECV_TABLE()
+
+//-----------------------------------------------------------------------------
+// Purpose: Data that gets sent to attached medics
+//-----------------------------------------------------------------------------
+BEGIN_RECV_TABLE_NOBASE( C_TFPlayer, DT_TFSendHealersDataTable )
+	RecvPropInt( RECVINFO( m_nActiveWpnClip ) ),
+END_RECV_TABLE()
+
+IMPLEMENT_CLIENTCLASS_DT( C_TFPlayer, DT_TFPlayer, CTFPlayer )
+
+	RecvPropBool(RECVINFO(m_bSaveMeParity)),
+	RecvPropBool(RECVINFO(m_bIsMiniBoss)),
+	RecvPropBool(RECVINFO(m_bIsABot)),
+	RecvPropInt(RECVINFO(m_nBotSkill)),
+
+	// This will create a race condition will the local player, but the data will be the same so.....
+	RecvPropInt( RECVINFO( m_nWaterLevel ) ),
+	RecvPropEHandle( RECVINFO( m_hRagdoll ) ),
+	RecvPropDataTable( RECVINFO_DT( m_PlayerClass ), 0, &REFERENCE_RECV_TABLE( DT_TFPlayerClassShared ) ),
+	RecvPropDataTable( RECVINFO_DT( m_Shared ), 0, &REFERENCE_RECV_TABLE( DT_TFPlayerShared ) ),
+	RecvPropEHandle( RECVINFO(m_hItem ) ),
+
+	RecvPropDataTable( "tflocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_TFLocalPlayerExclusive) ),
+	RecvPropDataTable( "tfnonlocaldata", 0, 0, &REFERENCE_RECV_TABLE(DT_TFNonLocalPlayerExclusive) ),
+
+	RecvPropBool( RECVINFO( m_bAllowMoveDuringTaunt ) ),
+	RecvPropBool( RECVINFO( m_bIsReadyToHighFive ) ),
+	RecvPropEHandle( RECVINFO( m_hHighFivePartner ) ),
+	RecvPropInt( RECVINFO( m_nForceTauntCam ) ),
+	RecvPropFloat( RECVINFO( m_flTauntYaw ) ),
+	RecvPropInt( RECVINFO( m_nActiveTauntSlot ) ),
+	RecvPropInt( RECVINFO( m_iTauntItemDefIndex ) ),
+	RecvPropFloat( RECVINFO( m_flCurrentTauntMoveSpeed ) ),
+	RecvPropFloat( RECVINFO( m_flVehicleReverseTime ) ),
+
+	RecvPropFloat( RECVINFO( m_flLastDamageTime ) ),
+
+	RecvPropBool( RECVINFO( m_bInPowerPlay ) ),
+
+	RecvPropInt( RECVINFO( m_iSpawnCounter ) ),
+	RecvPropBool( RECVINFO( m_bArenaSpectator ) ),
+
+	RecvPropDataTable( RECVINFO_DT( m_AttributeManager ), 0, &REFERENCE_RECV_TABLE(DT_AttributeManager) ),
+	RecvPropFloat( RECVINFO( m_flHeadScale ) ),
+	RecvPropFloat( RECVINFO( m_flTorsoScale ) ),
+	RecvPropFloat( RECVINFO( m_flHandScale ) ),
+
+	RecvPropBool( RECVINFO( m_bUseBossHealthBar ) ),
+
+	RecvPropBool( RECVINFO( m_bUsingVRHeadset ) ),
+
+	RecvPropBool( RECVINFO( m_bForcedSkin ) ),
+	RecvPropInt( RECVINFO( m_nForcedSkin ) ),
+
+	RecvPropBool( RECVINFO( m_bGlowEnabled ) ),
+
+	RecvPropDataTable("TFSendHealersDataTable", 0, 0, &REFERENCE_RECV_TABLE( DT_TFSendHealersDataTable ) ),
+	RecvPropFloat( RECVINFO( m_flKartNextAvailableBoost ) ),
+	RecvPropInt( RECVINFO( m_iKartHealth ) ),
+	RecvPropInt( RECVINFO( m_iKartState ) ),
+	RecvPropEHandle( RECVINFO( m_hGrapplingHookTarget ) ),
+	RecvPropEHandle( RECVINFO( m_hSecondaryLastWeapon ) ),
+	RecvPropBool( RECVINFO( m_bUsingActionSlot ) ),
+	RecvPropFloat( RECVINFO( m_flInspectTime ) ),
+	RecvPropInt( RECVINFO( m_iCampaignMedals ) ),
+	RecvPropInt( RECVINFO( m_iPlayerSkinOverride ) ),
+END_RECV_TABLE()
+
+
+BEGIN_PREDICTION_DATA( C_TFPlayer )
+	DEFINE_PRED_TYPEDESCRIPTION( m_Shared, CTFPlayerShared ),
+	DEFINE_PRED_FIELD( m_nSkin, FIELD_INTEGER, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE ),
+	DEFINE_PRED_FIELD( m_nBody, FIELD_INTEGER, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE ),
+	DEFINE_PRED_FIELD( m_nSequence, FIELD_INTEGER, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
+	DEFINE_PRED_FIELD( m_flPlaybackRate, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
+	DEFINE_PRED_FIELD( m_flCycle, FIELD_FLOAT, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
+	DEFINE_PRED_ARRAY_TOL( m_flEncodedController, FIELD_FLOAT, MAXSTUDIOBONECTRLS, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE, 0.02f ),
+	DEFINE_PRED_FIELD( m_nNewSequenceParity, FIELD_INTEGER, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
+	DEFINE_PRED_FIELD( m_nResetEventsParity, FIELD_INTEGER, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE | FTYPEDESC_NOERRORCHECK ),
+	DEFINE_PRED_FIELD( m_nMuzzleFlashParity, FIELD_CHARACTER, FTYPEDESC_OVERRIDE | FTYPEDESC_PRIVATE  ),
+	DEFINE_PRED_FIELD( m_hOffHandWeapon, FIELD_EHANDLE, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flTauntYaw, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flCurrentTauntMoveSpeed, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flVehicleReverseTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+	DEFINE_PRED_FIELD( m_flInspectTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),
+END_PREDICTION_DATA()
+
+// ------------------------------------------------------------------------------------------ //
+// C_TFPlayer implementation.
+// ------------------------------------------------------------------------------------------ //
+
+C_TFPlayer::C_TFPlayer() : 
+	m_iv_angEyeAngles( "C_TFPlayer::m_iv_angEyeAngles" ),
+	m_mapOverheadEffects( DefLessFunc( const char * ) )
+{
+	m_pAttributes = this;
+
+	m_PlayerAnimState = CreateTFPlayerAnimState( this );
+	m_Shared.Init( this );
+
+	m_iIDEntIndex = 0;
+
+	AddVar( &m_angEyeAngles, &m_iv_angEyeAngles, LATCH_SIMULATION_VAR );
+
+	memset( m_pKartParticles, NULL, sizeof( m_pKartParticles ) );
+	memset( m_pKartSounds, NULL, sizeof( m_pKartSounds ) );
+
+	m_pMVMEyeGlowEffect[ 0 ] = NULL;
+	m_pMVMEyeGlowEffect[ 1 ] = NULL;
+
+	m_pEyeGlowEffect[ 0 ] = NULL;
+	m_pEyeGlowEffect[ 1 ] = NULL;
+	m_pszEyeGlowEffectName[0] = '\0';
+	m_vEyeGlowColor1.Zero();
+	m_vEyeGlowColor2.Zero();
+	m_flNextSheenStartTime = 0;
+	
+	m_pTeleporterEffect = NULL;
+	m_pBurningSound = NULL;
+	m_pBurningEffect = NULL;
+	m_pUrineEffect = NULL;
+	m_pMilkEffect = NULL;
+	m_pSoldierOffensiveBuffEffect = NULL;
+	m_pSoldierDefensiveBuffEffect = NULL;
+	m_pSoldierOffensiveHealthRegenBuffEffect = NULL;
+	m_pSoldierNoHealingDamageBuffEffect = NULL;
+	m_pCritBoostEffect = NULL;
+	m_flBurnEffectStartTime = 0;
+	m_pDisguisingEffect = NULL;
+	m_pSaveMeEffect = NULL;
+	m_pTauntWithMeEffect = NULL;
+	m_hOldObserverTarget = NULL;
+	m_iOldObserverMode = OBS_MODE_NONE;
+	m_pStunnedEffect = NULL;
+	m_pPhaseStandingEffect = NULL;
+	m_pRadiusHealEffect = NULL;
+	m_pKingRuneRadiusEffect = NULL;
+	m_pKingBuffRadiusEffect = NULL;
+	m_pRunePlagueEffect = NULL;
+	m_pMegaHealEffect = NULL;
+	m_pTempShield = NULL;
+
+	m_pMVMBotRadiowave = NULL;
+
+	m_pRuneChargeReadyEffect = NULL;
+
+	m_aGibs.Purge();
+	m_aNormalGibs.PurgeAndDeleteElements();
+	m_aSillyGibs.Purge();
+
+	m_bCigaretteSmokeActive = false;
+
+	m_hRagdoll.Set( NULL );
+
+	m_iPreviousMetal = 0;
+	m_bIsDisplayingNemesisIcon = false;
+	m_bIsDisplayingDuelingIcon = false;
+	m_bIsDisplayingIconForIT = false;
+	m_bShouldShowBirthdayEffect = false;
+
+	m_bWasTaunting = false;
+	m_angTauntPredViewAngles.Init();
+	m_angTauntEngViewAngles.Init();
+	m_pTauntSoundLoop = NULL;
+
+	m_flWaterImpactTime = 0.0f;
+	m_rtSpottedInPVSTime = 0;
+	m_rtJoinedSpectatorTeam = 0;
+	m_rtJoinedNormalTeam = 0;
+
+	m_flWaterEntryTime = 0;
+	m_nOldWaterLevel = WL_NotInWater;
+	m_bWaterExitEffectActive = false;
+
+	m_bUpdateObjectHudState = false;
+
+	m_flSaveMeExpireTime = 0;
+
+	m_bWasHealedByLocalPlayer = false;
+
+	m_bDuckJumpInterp = false;
+	m_flFirstDuckJumpInterp = 0.0f;
+	m_flLastDuckJumpInterp = 0.0f;
+	m_flDuckJumpInterp = 0.0f;
+
+	m_bIsCoaching = false;
+	m_pStudentGlowEffect = NULL;
+	m_pPowerupGlowEffect = NULL;
+
+	m_nBotSkill = -1;
+	m_nOldBotSkill = -1;
+	m_nOldMaxHealth = -1;
+
+	m_bIsCalculatingMaximumSpeed = false;
+
+	m_bBodygroupsDirty = false;
+	
+	m_pBlastJumpLoop = NULL;
+	m_flBlastJumpLaunchTime = 0.f;
+
+	m_nExperienceLevel = 0;
+	m_nExperienceLevelProgress = 0;
+	m_nPrevExperienceLevel = 0;
+
+	m_bMatchSafeToLeave = true;
+
+	for( int i=0; i<kBonusEffect_Count; ++i )
+	{
+		m_flNextMiniCritEffectTime[i] = 0;
+	}
+
+	m_flHeadScale = 1.f;
+	m_flTorsoScale = 1.f;
+	m_flHandScale = 1.f;
+
+	m_bIsMiniBoss = false;
+	m_bUseBossHealthBar = false;
+	m_bUsingVRHeadset = false;
+
+	m_bForcedSkin = false;
+	m_nForcedSkin = 0;
+
+	m_flChangeClassTime = 0.f;
+
+	m_hRevivePrompt = NULL;
+
+	m_bIsDisplayingTranqMark = false;
+	m_eDisplayingRuneIcon = RUNE_NONE;
+
+	m_pKart = NULL;
+	m_iOldKartHealth = 0;
+
+	m_bUsingActionSlot = false;
+	m_iCampaignMedals = 0;
+
+	m_flInspectTime = 0.f;
+
+	m_bNotifiedWeaponInspectThisLife = false;
+
+	m_pPasstimePlayerReticle = NULL;
+	m_pPasstimeAskForBallReticle = NULL;
+
+	m_iPlayerSkinOverride = 0;
+
+	ListenForGameEvent( "player_hurt" );
+	ListenForGameEvent( "hltv_changed_mode" );
+	ListenForGameEvent( "hltv_changed_target" );
+	ListenForGameEvent( "post_inventory_application" );
+	ListenForGameEvent( "rocket_jump" );
+	ListenForGameEvent( "rocket_jump_landed" );
+	ListenForGameEvent( "sticky_jump" );
+	ListenForGameEvent( "sticky_jump_landed" );
+	ListenForGameEvent( "player_spawn" );
+	ListenForGameEvent( "damage_resisted" );
+	ListenForGameEvent( "revive_player_notify" );
+	ListenForGameEvent( "revive_player_stopped" );
+	ListenForGameEvent( "player_changeclass" );
+	ListenForGameEvent( "player_abandoned_match" );
+#ifdef STAGING_ONLY
+	ListenForGameEvent( "player_death" );
+#endif
+
+	//AddPhonemeFile
+	engine->AddPhonemeFile( "scripts/game_sounds_vo_phonemes.txt" );
+	engine->AddPhonemeFile( "scripts/game_sounds_vo_phonemes_local.txt" );	// Stomp over english for phoneme data
+	engine->AddPhonemeFile( NULL );			// Null indicates to engine that we are done loading phonemes if there are any present
+}
+
+C_TFPlayer::~C_TFPlayer()
+{
+	ShowNemesisIcon( false );
+	ShowDuelingIcon( false );
+	m_PlayerAnimState->Release();
+
+	if ( m_pBlastJumpLoop )
+	{
+		CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+		controller.SoundDestroy( m_pBlastJumpLoop );
+		m_pBlastJumpLoop = NULL;
+	}
+
+	StopTauntSoundLoop();
+
+	delete m_pPasstimePlayerReticle;
+	delete m_pPasstimeAskForBallReticle;
+
+	if ( IsLocalPlayer() )
+	{
+		g_ItemEffectMeterManager.ClearExistingMeters();
+
+		if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
+		{
+			g_pClientMode->GetViewportAnimationController()->StartAnimationSequence( "CompetitiveGame_RestoreChatWindow", false );
+		}
+	}
+}
+
+// NOTE: This is NOT called every time the player respawns!!
+// only the first time we spawn a player into the world
+void C_TFPlayer::Spawn( void )
+{
+	m_AttributeManager.SetPlayer( this );
+	m_AttributeList.SetManager( &m_AttributeManager );
+
+	BaseClass::Spawn();
+
+	/*
+	// some extra stuff here because s_pLocalPlayer is not yet initialized
+	int iLocalPlayerIndex = engine->GetLocalPlayer();
+
+	if ( entindex() == iLocalPlayerIndex && !m_LeaveServerTimer.HasStarted() )
+	{
+		ConVarRef random_spec_server_mode( "random_spec_server_mode" );
+		if ( random_spec_server_mode.IsValid() && random_spec_server_mode.GetBool() )
+		{
+			m_LeaveServerTimer.Start( spectate_random_server_basetime.GetFloat() );
+		}
+	}
+	*/
+
+	UpdateInventory( true );
+
+	UpdateMVMEyeGlowEffect( true );
+
+	SetShowHudMenuTauntSelection( false );
+
+	CleanUpAnimationOnSpawn();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::InventoryUpdated( CPlayerInventory *pInventory )
+{ 
+	if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() )
+	{
+		CHudUpgradePanel *pUpgradePanel = GET_HUDELEMENT( CHudUpgradePanel );
+		if ( pUpgradePanel && pUpgradePanel->IsVisible() )
+		{
+			pUpgradePanel->PlayerInventoryChanged( this );
+		}
+	}
+
+	return;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Request this player's inventories from the steam backend
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateInventory( bool bInit )
+{
+#if !defined(NO_STEAM)
+	if ( bInit )
+	{
+		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_bInventoryReceived = !bInvalid;
+#endif
+}
+
+C_TFPlayer* C_TFPlayer::GetLocalTFPlayer()
+{
+	return ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
+}
+
+const QAngle& C_TFPlayer::GetRenderAngles()
+{
+	if ( IsRagdoll() )
+	{
+		return vec3_angle;
+	}
+	else
+	{
+		return m_PlayerAnimState->GetRenderAngles();
+	}
+}
+
+bool C_TFPlayer::CanDisplayAllSeeEffect( EAttackBonusEffects_t effect ) const
+{ 
+	if( effect >= EAttackBonusEffects_t(0) && effect < kBonusEffect_Count )
+	{
+		return gpGlobals->curtime > m_flNextMiniCritEffectTime[ effect ];
+	}
+
+	return true;
+}
+
+void C_TFPlayer::SetNextAllSeeEffectTime( EAttackBonusEffects_t effect, float flTime )
+{ 
+	if( effect >= EAttackBonusEffects_t(0) && effect < kBonusEffect_Count )
+	{
+		if ( gpGlobals->curtime > m_flNextMiniCritEffectTime[ effect ] )
+		{
+			m_flNextMiniCritEffectTime[ effect ] = flTime;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateOnRemove( void )
+{
+	// Stop the taunt.
+	if ( m_bWasTaunting )
+	{
+		// Need to go ahead and call both. Otherwise, if we changelevel while we're taunting or 
+		// otherwise in "game wants us in third person mode", we will stay in third person mode 
+		// in the new map.
+		TurnOffTauntCam();
+		TurnOffTauntCam_Finish();
+	}
+
+	// HACK!!! ChrisG needs to fix this in the particle system.
+	ParticleProp()->OwnerSetDormantTo( true );
+	ParticleProp()->StopParticlesInvolving( this );
+
+	m_Shared.RemoveAllCond();
+
+	m_Inventory.RemoveListener( this );
+
+	BaseClass::UpdateOnRemove();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns max health for this player
+//-----------------------------------------------------------------------------
+int C_TFPlayer::GetMaxHealth( void ) const
+{	
+	return ( g_TF_PR ) ? g_TF_PR->GetMaxHealth( entindex() ) : 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns max buffed health for this player
+//-----------------------------------------------------------------------------
+int C_TFPlayer::GetMaxHealthForBuffing( void ) const
+{
+	return ( g_TF_PR ) ? g_TF_PR->GetMaxHealthForBuffing( entindex() ) : 1;
+}
+
+//-----------------------------------------------------------------------------
+// Deal with recording
+//-----------------------------------------------------------------------------
+void C_TFPlayer::GetToolRecordingState( KeyValues *msg )
+{
+#ifndef _XBOX
+	BaseClass::GetToolRecordingState( msg );
+	BaseEntityRecordingState_t *pBaseEntityState = (BaseEntityRecordingState_t*)msg->GetPtr( "baseentity" );
+
+	bool bDormant = IsDormant();
+	bool bDead = !IsAlive();
+	bool bSpectator = ( GetTeamNumber() == TEAM_SPECTATOR );
+	bool bNoRender = ( GetRenderMode() == kRenderNone );
+	bool bDeathCam = (GetObserverMode() == OBS_MODE_DEATHCAM);
+	bool bNoDraw = IsEffectActive(EF_NODRAW);
+
+	bool bVisible = 
+		!bDormant && 
+		!bDead && 
+		!bSpectator &&
+		!bNoRender &&
+		!bDeathCam &&
+		!bNoDraw;
+
+	bool changed = m_bToolRecordingVisibility != bVisible;
+	// Remember state
+	m_bToolRecordingVisibility = bVisible;
+
+	pBaseEntityState->m_bVisible = bVisible;
+	if ( changed && !bVisible )
+	{
+		// If the entity becomes invisible this frame, we still want to record a final animation sample so that we have data to interpolate
+		//  toward just before the logs return "false" for visiblity.  Otherwise the animation will freeze on the last frame while the model
+		//  is still able to render for just a bit.
+		pBaseEntityState->m_bRecordFinalVisibleSample = true;
+	}
+#endif
+}
+
+
+void C_TFPlayer::UpdateClientSideAnimation()
+{
+	// Update the animation data. It does the local check here so this works when using
+	// a third-person camera (and we don't have valid player angles).
+	if ( this == C_TFPlayer::GetLocalTFPlayer() )
+	{
+		// m_angEyeAngles comes from the server, and updates are infrequent, so use the local values instead.
+		QAngle LocalEyeAngles = EyeAngles();
+		m_PlayerAnimState->Update( LocalEyeAngles[YAW], LocalEyeAngles[PITCH] );
+	}
+	else
+	{
+		m_PlayerAnimState->Update( m_angEyeAngles[YAW], m_angEyeAngles[PITCH] );
+	}
+
+	// StatTrak Module Test
+	// Update ViewModels
+	// We only update the view model for the local player.
+	//if ( IsLocalPlayer() )
+	{
+		CTFWeaponBase *pWeapon = GetActiveTFWeapon();
+		if ( pWeapon )
+		{
+			pWeapon->UpdateAllViewmodelAddons();
+		}
+	}
+
+	BaseClass::UpdateClientSideAnimation();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::SetDormant( bool bDormant )
+{
+	// If I'm burning, stop the burning sounds
+	if ( !IsDormant() && bDormant )
+	{
+		if ( m_pBurningSound) 
+		{
+			StopBurningSound();
+		}
+		if ( m_bIsDisplayingNemesisIcon )
+		{
+			ShowNemesisIcon( false );
+		}
+		if ( m_bIsDisplayingDuelingIcon )
+		{
+			ShowDuelingIcon( false );
+		}
+		if ( m_bIsDisplayingIconForIT )
+		{
+			ShowIconForIT( false );
+		}
+		UpdatedMarkedForDeathEffect( true );
+		UpdateRuneIcon( true );
+
+#ifdef STAGING_ONLY
+		if ( m_bIsDisplayingTranqMark )
+		{
+			UpdateTranqMark( false, true );
+		}
+#endif // STAGING_ONLY
+		if ( m_bShouldShowBirthdayEffect )
+		{
+			ShowBirthdayEffect( false );
+		}
+	}
+
+	if ( IsDormant() && !bDormant )
+	{
+		SetBodygroupsDirty();
+
+		if ( IsTaunting() )
+		{
+			float flCycle = 0.f;
+			if ( m_flTauntDuration > 0.f )
+			{
+				float dt = gpGlobals->curtime - m_flTauntStartTime;
+				while ( dt >= m_flTauntDuration )
+				{
+					dt -= m_flTauntDuration;
+				}
+				flCycle = dt / m_flTauntDuration;
+				flCycle = clamp( flCycle, 0.f, 1.0f );
+			}
+
+			m_PlayerAnimState->ResetGestureSlot( GESTURE_SLOT_VCD );
+			m_PlayerAnimState->AddVCDSequenceToGestureSlot( GESTURE_SLOT_VCD, m_nTauntSequence, flCycle, true );
+		}
+	}
+
+	if ( bDormant == false )
+	{
+		m_rtSpottedInPVSTime = steamapicontext && steamapicontext->SteamUtils() ? steamapicontext->SteamUtils()->GetServerRealTime() : CRTime::RTime32TimeCur();
+	}
+
+	// Deliberately skip base combat weapon
+	C_BaseEntity::SetDormant( bDormant );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::OnPreDataChanged( DataUpdateType_t updateType )
+{
+	BaseClass::OnPreDataChanged( updateType );
+
+	m_iOldHealth = m_iHealth;
+	m_iOldPlayerClass = m_PlayerClass.GetClassIndex();
+	m_iOldSpawnCounter = m_iSpawnCounter;
+	m_bOldSaveMeParity = m_bSaveMeParity;
+	m_nOldWaterLevel = GetWaterLevel();
+
+	m_iOldTeam = GetTeamNumber();
+	C_TFPlayerClass *pClass = GetPlayerClass();
+	m_iOldClass = pClass ? pClass->GetClassIndex() : TF_CLASS_UNDEFINED;
+	m_bDisguised = m_Shared.InCond( TF_COND_DISGUISED );
+	m_iOldDisguiseTeam = m_Shared.GetDisguiseTeam();
+	m_iOldDisguiseClass = m_Shared.GetDisguiseClass();
+
+	m_flPrevTauntYaw = m_flTauntYaw;
+
+	m_nPrevTauntSlot = m_nActiveTauntSlot;
+	m_iPrevTauntItemDefIndex = m_iTauntItemDefIndex;
+
+	if ( !IsReplay() )
+	{
+		m_iOldObserverMode = GetObserverMode();
+		m_hOldObserverTarget = GetObserverTarget();
+	}
+
+	m_nOldCurrency = m_nCurrency;
+
+	m_Shared.OnPreDataChanged();
+
+	m_bOldCustomModelVisible = m_PlayerClass.CustomModelIsVisibleToSelf();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::OnDataChanged( DataUpdateType_t updateType )
+{
+	// C_BaseEntity assumes we're networking the entity's angles, so pretend that it
+	// networked the same value we already have.
+	SetNetworkAngles( GetLocalAngles() );
+	
+	BaseClass::OnDataChanged( updateType );
+
+	if ( updateType == DATA_UPDATE_CREATED )
+	{
+		SetNextClientThink( CLIENT_THINK_ALWAYS );
+
+		InitInvulnerableMaterial();
+		
+		// There used to be code here to switch to first person. This breaks thirdperson mode
+		// and karts when we have to get a full client update--don't do it here anymore.
+		// We may need to do something more clever if this breaks something.
+	}
+	else
+	{
+		if ( m_iOldTeam != GetTeamNumber() || m_iOldDisguiseTeam != m_Shared.GetDisguiseTeam() )
+		{
+			InitInvulnerableMaterial();
+		}
+		
+		if ( m_iOldDisguiseClass != m_Shared.GetDisguiseClass() )
+		{
+			RemoveAllDecals();
+		}
+
+		if ( m_nOldBotSkill != m_nBotSkill )
+		{
+			UpdateMVMEyeGlowEffect( true );
+
+			m_nOldBotSkill = m_nBotSkill;
+		}
+
+		if ( m_nOldMaxHealth != GetMaxHealth() )
+		{
+			UpdateMVMEyeGlowEffect( true );
+
+			m_nOldMaxHealth = GetMaxHealth();
+		}
+
+		if ( m_nPrevTauntSlot != m_nActiveTauntSlot || m_iPrevTauntItemDefIndex != m_iTauntItemDefIndex )
+		{
+			UpdateTauntItem();
+		}
+
+		if ( m_iOldKartHealth != m_iKartHealth )
+		{
+			UpdateKartEffects();
+		}
+
+		if ( m_iOldKartState != m_iKartState )
+		{
+			UpdateKartState();
+		}
+	}
+
+	GetAttributeManager()->OnDataChanged( updateType );
+
+	// Check for full health and remove decals.
+	if ( ( m_iHealth > m_iOldHealth && m_iHealth >= GetMaxHealth() ) || m_Shared.IsInvulnerable() )
+	{
+		// If we were just fully healed, remove all decals
+		RemoveAllDecals();
+	}
+
+	if ( ( m_iOldHealth != m_iHealth ) || ( m_iOldTeam != GetTeamNumber() ) )
+	{
+		UpdateGlowColor();
+	}
+	bool bNeedsStudentGlow = m_hCoach && m_hCoach->IsLocalPlayer() && m_hCoach->m_bIsCoaching;
+	bool bHasStudentGlow = m_pStudentGlowEffect != NULL;
+	if ( bNeedsStudentGlow != bHasStudentGlow )
+	{
+		UpdateGlowEffect();
+	}
+
+	if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
+	{
+		if ( m_Shared.InCond( TF_COND_KING_BUFFED ) )
+		{
+			const char *m_szRadiusEffect;
+			int nTeamNumber = GetTeamNumber();
+			if ( IsPlayerClass( TF_CLASS_SPY ) && m_Shared.InCond( TF_COND_DISGUISED ) )
+			{
+				if ( !IsLocalPlayer() && GetTeamNumber() == GetLocalPlayerTeam() ) // Always display own team colors even when disguised, unless it's you (same rules as uber skin)
+				{
+					nTeamNumber = GetLocalPlayerTeam();
+				}
+				else
+				{
+					nTeamNumber = m_Shared.GetDisguiseTeam();
+				}
+			}
+
+			if ( nTeamNumber == TF_TEAM_RED )
+			{
+				m_szRadiusEffect = "powerup_king_red";
+			}
+			else
+			{
+				m_szRadiusEffect = "powerup_king_blue";
+			}
+			if ( !m_pKingBuffRadiusEffect )
+			{
+				m_pKingBuffRadiusEffect = ParticleProp()->Create( m_szRadiusEffect, PATTACH_ABSORIGIN_FOLLOW );
+			}
+		}
+		else if ( m_pKingBuffRadiusEffect )
+		{
+			m_Shared.EndKingBuffRadiusEffect();
+		}
+
+		bool bNeedsPowerupGlow = ShouldShowPowerupGlowEffect();
+		bool bHasPowerupGlow = m_pPowerupGlowEffect != NULL;
+		if ( bNeedsPowerupGlow != bHasPowerupGlow )
+		{
+			UpdateGlowEffect();
+		}
+	}
+
+	// Detect class changes
+	if ( m_iOldPlayerClass != m_PlayerClass.GetClassIndex() )
+	{
+		OnPlayerClassChange();
+	}
+
+	bool bJustSpawned = false;
+
+	if ( m_iOldSpawnCounter != m_iSpawnCounter )
+	{
+		ClientPlayerRespawn();
+
+		bJustSpawned = true;
+	}
+
+	if ( m_bSaveMeParity != m_bOldSaveMeParity )
+	{
+		// Player has triggered a save me command
+		CreateSaveMeEffect();
+	}
+
+	// To better support old demos, which have some screwed up flags, we just ignore various things if we're a SourceTV client.
+	if ( !IsHLTV() )
+	{
+		if ( m_Shared.InCond( TF_COND_BURNING ) && !m_pBurningSound )
+		{
+			StartBurningSound();
+		}
+
+		bool bShouldShowIconForIT = TFGameRules() && TFGameRules()->IsIT( this ) && !IsLocalPlayer();
+		if ( bShouldShowIconForIT != m_bIsDisplayingIconForIT )
+		{
+			ShowIconForIT( bShouldShowIconForIT );
+		}
+
+		bool bShouldShowBirthdayEffect = false;//TFGameRules() && ( TFGameRules()->GetBirthdayPlayer() == this ) && !IsLocalPlayer();
+		if ( bShouldShowBirthdayEffect != m_bShouldShowBirthdayEffect )
+		{
+			ShowBirthdayEffect( bShouldShowBirthdayEffect );
+		}
+
+		bool bShouldShowDuelingIcon = ShouldShowDuelingIcon();
+		if ( bShouldShowDuelingIcon != m_bIsDisplayingDuelingIcon )
+		{
+			ShowDuelingIcon( bShouldShowDuelingIcon );
+		}
+
+		// See if we should show or hide nemesis icon for this player
+		bool bShouldDisplayNemesisIcon = ( !bShouldShowDuelingIcon && !m_bIsDisplayingIconForIT && ShouldShowNemesisIcon() );
+		if ( bShouldDisplayNemesisIcon != m_bIsDisplayingNemesisIcon )
+		{
+			ShowNemesisIcon( bShouldDisplayNemesisIcon );
+		}
+
+		m_Shared.OnDataChanged();
+
+		if ( m_bDisguised != m_Shared.InCond( TF_COND_DISGUISED ) )
+		{
+			m_flDisguiseEndEffectStartTime = MAX( m_flDisguiseEndEffectStartTime, gpGlobals->curtime );
+
+			// Update visibility of any worn items.
+			UpdateWearables();
+			SetBodygroupsDirty();
+
+			// Remove decals.
+			RemoveAllDecals();
+
+			if ( GetPlayerClass()->GetClassIndex() == TF_CLASS_SPY )
+			{
+				if ( m_Shared.InCond( TF_COND_DISGUISED ) )
+				{
+					UpdateMVMEyeGlowEffect( false );
+				}
+				else
+				{
+					UpdateMVMEyeGlowEffect( true );
+				}
+			}
+		}
+	}
+
+	int nNewWaterLevel = GetWaterLevel();
+
+	if ( nNewWaterLevel != m_nOldWaterLevel )
+	{
+		if ( ( m_nOldWaterLevel == WL_NotInWater ) && ( nNewWaterLevel > WL_NotInWater ) )
+		{
+			// Set when we do a transition to/from partially in water to completely out
+			m_flWaterEntryTime = gpGlobals->curtime;
+		}
+
+		// If player is now up to his eyes in water and has entered the water very recently (not just bobbing eyes in and out), play a bubble effect.
+		if ( ( nNewWaterLevel == WL_Eyes ) && ( gpGlobals->curtime - m_flWaterEntryTime ) < 0.5f ) 
+		{
+			CNewParticleEffect *pEffect = ParticleProp()->Create( "water_playerdive", PATTACH_ABSORIGIN_FOLLOW );
+			ParticleProp()->AddControlPoint( pEffect, 1, NULL, PATTACH_WORLDORIGIN, NULL, WorldSpaceCenter() );
+		}		
+		// If player was up to his eyes in water and is now out to waist level or less, play a water drip effect
+		else if ( m_nOldWaterLevel == WL_Eyes && ( nNewWaterLevel < WL_Eyes ) && !bJustSpawned )
+		{
+			CNewParticleEffect *pWaterExitEffect = ParticleProp()->Create( "water_playeremerge", PATTACH_ABSORIGIN_FOLLOW );
+			ParticleProp()->AddControlPoint( pWaterExitEffect, 1, this, PATTACH_ABSORIGIN_FOLLOW );
+			m_bWaterExitEffectActive = true;
+		}
+	}
+
+	if ( IsLocalPlayer() )
+	{
+		if ( updateType == DATA_UPDATE_CREATED )
+		{
+			SetupHeadLabelMaterials();
+			GetClientVoiceMgr()->SetHeadLabelOffset( 50 );
+		}
+
+		if ( m_iOldTeam != GetTeamNumber() )
+		{
+			IGameEvent *event = gameeventmanager->CreateEvent( "localplayer_changeteam" );
+			if ( event )
+			{
+				gameeventmanager->FireEventClientSide( event );
+			}
+			if ( IsX360() )
+			{
+				const char *pTeam = NULL;
+				switch( GetTeamNumber() )
+				{
+					case TF_TEAM_RED:
+						pTeam = "red";
+						break;
+
+					case TF_TEAM_BLUE:
+						pTeam = "blue";
+						break;
+
+					case TEAM_SPECTATOR:
+						pTeam = "spectate";
+						break;
+				}
+
+				if ( pTeam )
+				{
+					engine->ChangeTeam( pTeam );
+				}
+			}
+
+			// let the server know that we're using a VR headset
+			if ( UseVR() )
+			{
+				KeyValues *kv = new KeyValues( "UsingVRHeadset" );
+				engine->ServerCmdKeyValues( kv );
+			}
+		}
+
+		if ( !IsPlayerClass(m_iOldClass) )
+		{
+			m_flChangeClassTime = gpGlobals->curtime;
+
+			IGameEvent *event = gameeventmanager->CreateEvent( "localplayer_changeclass" );
+			if ( event )
+			{
+				event->SetInt( "updateType", updateType );
+				gameeventmanager->FireEventClientSide( event );
+			}
+
+#ifdef STAGING_ONLY
+			// Spy Tranq Mark
+			// Update tranq mark if you were or are a spy
+			if ( m_iOldClass == TF_CLASS_SPY || IsPlayerClass( TF_CLASS_SPY ) )
+			{
+				bool bShowTranqMark = IsPlayerClass( TF_CLASS_SPY );
+				for ( int iPlayerIndex = 1; iPlayerIndex <= MAX_PLAYERS; ++iPlayerIndex )
+				{
+					C_TFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
+					if ( pTFPlayer )
+					{
+						pTFPlayer->UpdateTranqMark( bShowTranqMark );
+					}
+				}
+			}
+#endif // STAGING_ONLY
+		}
+
+		bool bUpdateAttachedWeapons = (GetObserverTarget() != m_hOldObserverTarget);
+		if ( m_iOldObserverMode != GetObserverMode() )
+		{
+			if ( m_iOldObserverMode == OBS_MODE_NONE )
+			{
+				IGameEvent *event = gameeventmanager->CreateEvent( "localplayer_becameobserver" );
+				if ( event )
+				{
+					gameeventmanager->FireEventClientSide( event );
+				}
+				// NVNT send spectator nav
+				if ( haptics )
+					haptics->SetNavigationClass("spectate");
+			}
+			else if ( m_iOldObserverMode < OBS_MODE_FIXED && GetObserverMode() >= OBS_MODE_FIXED )
+			{
+#if defined( REPLAY_ENABLED )
+				// If the player is entering a title for a replay, defer displaying the items screen until afterwards
+				if ( !IsReplayInputPanelVisible() )
+#endif
+				{
+					// Show items we've picked up when we exit freezecam, or after deathcam on suicide
+					TFInventoryManager()->ShowItemsPickedUp();
+				}
+			}
+
+			if ( m_iOldObserverMode == OBS_MODE_IN_EYE || GetObserverMode() == OBS_MODE_IN_EYE )
+			{
+				bUpdateAttachedWeapons = true;
+			}
+
+			if ( m_iOldObserverMode == OBS_MODE_IN_EYE )
+			{
+				CBaseEntity* pObserveTarget = GetObserverTarget();
+				if( pObserveTarget )
+				{
+					pObserveTarget->UpdateVisibility();
+				}
+			}
+			// NVNT send onfoot nav if observer mode is none.
+			if(GetObserverMode()==OBS_MODE_NONE &&haptics)
+			{
+				haptics->SetNavigationClass("on_foot");
+			}
+
+			if ( IsReplay() )
+			{
+				m_iOldObserverMode = GetObserverMode();
+			}
+		}
+
+		if ( bUpdateAttachedWeapons )
+		{
+			C_TFPlayer *pTFOldObserverTarget = ToTFPlayer( m_hOldObserverTarget.Get() );
+			if ( m_hOldObserverTarget != GetObserverTarget() && pTFOldObserverTarget )
+			{
+				C_TFWeaponBase *pWeapon = pTFOldObserverTarget->m_Shared.GetActiveTFWeapon();
+				if ( pWeapon )
+				{
+					pWeapon->UpdateAttachmentModels();
+				}
+
+				// Update visibility of any worn items.
+				pTFOldObserverTarget->UpdateWearables();
+				pTFOldObserverTarget->SetBodygroupsDirty();
+
+				if ( IsReplay() )
+				{
+					m_hOldObserverTarget = GetObserverTarget();
+				}
+			}
+
+			C_TFPlayer *pTFObserverTarget = ToTFPlayer( GetObserverTarget() );
+			if ( pTFObserverTarget )
+			{
+				C_TFWeaponBase *pWeapon = pTFObserverTarget->m_Shared.GetActiveTFWeapon();
+				if ( pWeapon )
+				{
+					pWeapon->UpdateAttachmentModels();
+				}
+
+				// Update visibility of any worn items.
+				pTFObserverTarget->UpdateWearables();
+				pTFObserverTarget->SetBodygroupsDirty();
+			}
+		}
+
+		if ( m_iOldClass == TF_CLASS_SPY && 
+		   ( m_bDisguised != m_Shared.InCond( TF_COND_DISGUISED ) || m_iOldDisguiseClass != m_Shared.GetDisguiseClass() ) )
+		{
+			IGameEvent *event = gameeventmanager->CreateEvent( "localplayer_changedisguise" );
+			if ( event )
+			{
+				event->SetBool( "disguised", m_Shared.InCond( TF_COND_DISGUISED ) );
+				gameeventmanager->FireEventClientSide( event );
+			}
+		}
+
+		// If our metal amount changed, send a game event
+		int iCurrentMetal = GetAmmoCount( TF_AMMO_METAL );	
+
+		if ( iCurrentMetal != m_iPreviousMetal )
+		{
+			//msg
+			IGameEvent *event = gameeventmanager->CreateEvent( "player_account_changed" );
+			if ( event )
+			{
+				event->SetInt( "old_account", m_iPreviousMetal );
+				event->SetInt( "new_account", iCurrentMetal );
+				gameeventmanager->FireEventClientSide( event );
+			}
+
+			m_iPreviousMetal = iCurrentMetal;
+		}
+
+		// did the local player get any health?
+		if ( m_iHealth > m_iOldHealth )
+		{
+			IGameEvent *event = gameeventmanager->CreateEvent( "localplayer_healed" );
+			if ( event )
+			{
+				event->SetInt( "amount", m_iHealth - m_iOldHealth );
+				gameeventmanager->FireEventClientSide( event );
+			}
+		}
+
+		if ( m_nOldCurrency != m_nCurrency )
+		{
+			IGameEvent *event = gameeventmanager->CreateEvent( "player_currency_changed" );
+			if ( event )
+			{
+				event->SetInt( "currency", m_nCurrency );
+				gameeventmanager->FireEventClientSide( event );
+			}
+		}
+
+		if ( m_bOldCustomModelVisible != m_PlayerClass.CustomModelIsVisibleToSelf() )
+		{
+			UpdateVisibility();
+		}
+	}
+
+	C_TFWeaponBase *pOldActiveWeapon = assert_cast< CTFWeaponBase* >( m_hOldActiveWeapon.Get() ); 
+	C_TFWeaponBase *pActiveWeapon = GetActiveTFWeapon(); 
+
+	if ( pOldActiveWeapon != pActiveWeapon )
+	{
+		// make sure weapons data are up to date before doing anything here
+		UpdateClientData();
+		if ( pOldActiveWeapon )
+		{
+			pOldActiveWeapon->UpdateVisibility();
+		}
+
+		if ( pActiveWeapon )
+		{
+			pActiveWeapon->UpdateVisibility();
+
+			if ( GetLocalTFPlayer() == this && pActiveWeapon->CanInspect() )
+			{
+				HandleInspectHint();
+			}
+		}
+
+		m_hOldActiveWeapon = pActiveWeapon;
+
+		// Update HandPoses if needed
+		CBaseAnimating *pWeaponModel = GetRenderedWeaponModel();
+		if ( !pWeaponModel )
+			return;
+
+		int iPose = 0;
+		CALL_ATTRIB_HOOK_INT_ON_OTHER( pActiveWeapon, iPose, righthand_pose_parameter );
+		
+		float flMin, flMax = 0;
+		int iPoseParam = LookupPoseParameter( "r_hand_grip" );
+		if ( iPoseParam > 0 )
+		{
+			// SetPoseParameter() normalize's values.  r_hand_grip is special and goes beyond 0..1 so we have to counter act the normalization
+			GetPoseParameterRange( iPoseParam, flMin, flMax );
+			SetPoseParameter( iPoseParam, iPose * flMax );		
+		}
+		pWeaponModel->SetPoseParameter( "r_hand_grip", iPose );
+	}
+
+	// Some time in this network transmit we changed the size of the object array.
+	// recalc the whole thing and update the hud
+	if ( m_bUpdateObjectHudState )
+	{
+		IGameEvent *event = gameeventmanager->CreateEvent( "building_info_changed" );
+		if ( event )
+		{
+			event->SetInt( "building_type", -1 );
+			gameeventmanager->FireEventClientSide( event );
+		}
+	
+		m_bUpdateObjectHudState = false;
+	}
+
+	if ( m_iOldTeam != GetTeamNumber() )
+	{
+		if ( GetTeamNumber() == TEAM_SPECTATOR )
+		{
+			m_rtJoinedSpectatorTeam = steamapicontext && steamapicontext->SteamUtils() ? steamapicontext->SteamUtils()->GetServerRealTime() : CRTime::RTime32TimeCur();
+		}
+		else if ( m_iOldTeam != TF_TEAM_RED && m_iOldTeam != TF_TEAM_BLUE )
+		{
+			m_rtJoinedNormalTeam = steamapicontext && steamapicontext->SteamUtils() ? steamapicontext->SteamUtils()->GetServerRealTime() : CRTime::RTime32TimeCur();
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateTauntItem()
+{
+	if ( m_nActiveTauntSlot == LOADOUT_POSITION_INVALID )
+	{
+		if ( m_iTauntItemDefIndex != INVALID_ITEM_DEF_INDEX )
+		{
+			m_TauntEconItemView.Init( m_iTauntItemDefIndex, AE_UNIQUE, 1 );
+		}
+		else
+		{
+			m_TauntEconItemView.Invalidate();
+		}
+	}
+	else
+	{
+		int iClass = GetPlayerClass()->GetClassIndex();
+
+		CEconItemView *pMiscItemView = Inventory() ? Inventory()->GetItemInLoadout( iClass, m_nActiveTauntSlot ) : NULL;
+		if ( pMiscItemView )
+		{
+			m_TauntEconItemView = *pMiscItemView;
+		}
+	}
+
+	if ( m_TauntEconItemView.IsValid() )
+	{
+		ParseSharedTauntDataFromEconItemView( &m_TauntEconItemView );
+	}
+}
+
+ConVar tf_halloween_kart_sound_slow_pitch( "tf_halloween_kart_sound_slow_pitch", "30.f", FCVAR_CHEAT | FCVAR_REPLICATED );
+ConVar tf_halloween_kart_sound_fast_pitch( "tf_halloween_kart_sound_fast_pitch", "80.f", FCVAR_CHEAT | FCVAR_REPLICATED );
+extern ConVar tf_halloween_kart_dash_speed;
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateKartEffects()
+{
+	if ( m_hKartDamageEffect )
+	{
+		ParticleProp()->StopEmission( m_hKartDamageEffect );
+		m_hKartDamageEffect = NULL;
+	}
+
+	if ( !m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
+		return;
+
+	m_iOldKartHealth = m_iKartHealth;
+
+	const char *pszEffect = "";
+	if ( m_iKartHealth > 150 )
+	{
+		pszEffect = "kartdamage_4";
+		m_hKartDamageEffect = ParticleProp()->Create( pszEffect, PATTACH_ABSORIGIN_FOLLOW, INVALID_PARTICLE_ATTACHMENT, Vector(0,0,40) );	
+	}
+}
+
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateKartState()
+{
+	if ( !m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
+		return;
+
+	m_iOldKartState = m_iKartState;
+
+	// turn brake on and off
+
+	if ( m_iKartState & CTFPlayerShared::kKartState_Braking ) 
+	{
+		StartKartBrakeEffect();
+	}
+	else 
+	{
+		StopKartBrakeEffect();
+	}
+}
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateKartSounds()
+{
+	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+	// Create our engine sound if we dont have one and need one
+	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
+	{
+		if ( m_pKartSounds[ KART_SOUND_ENGINE_LOOP ] == NULL )
+		{
+			CBroadcastRecipientFilter filter;
+			m_pKartSounds[ KART_SOUND_ENGINE_LOOP ] = controller.SoundCreate( filter, entindex(), "BumperCar.GoLoop" );
+			controller.Play( m_pKartSounds[ KART_SOUND_ENGINE_LOOP ], 1.f, 1.f );
+		}
+	}
+	else if ( m_pKartSounds[ KART_SOUND_ENGINE_LOOP ] )
+	{
+		controller.SoundDestroy( m_pKartSounds[ KART_SOUND_ENGINE_LOOP ] );
+		m_pKartSounds[ KART_SOUND_ENGINE_LOOP ] = NULL;
+	}
+
+	if ( m_pKartSounds[ KART_SOUND_ENGINE_LOOP ] )
+	{
+		float flTargetPitch = RemapValClamped( GetCurrentTauntMoveSpeed(), 0.f, tf_halloween_kart_dash_speed.GetFloat(), tf_halloween_kart_sound_slow_pitch.GetFloat(), tf_halloween_kart_sound_fast_pitch.GetFloat() );
+		controller.SoundChangePitch( m_pKartSounds[ KART_SOUND_ENGINE_LOOP ], flTargetPitch, 0.1f );
+	}
+
+	// Uncomment this (if) when we have a tire screech sound
+	//if ( ( m_iKartState & CTFPlayerShared::kKartState_Driving ) && GetCurrentTauntMoveSpeed() < 300.f )
+	//{
+	//	if ( m_pKartSounds[ KART_SOUND_BURNOUT_LOOP ] == NULL )
+	//	{
+	//		CBroadcastRecipientFilter filter;
+	//		m_pKartSounds[ KART_SOUND_BURNOUT_LOOP ] = controller.SoundCreate( filter, entindex(), "BumperCar.GoLoop" );
+	//		controller.Play( m_pKartSounds[ KART_SOUND_BURNOUT_LOOP ], 1.f, 80.f );
+	//	}
+	//}
+	//else if ( m_pKartSounds[ KART_SOUND_BURNOUT_LOOP ] )
+	//{
+	//	controller.SoundDestroy( m_pKartSounds[ KART_SOUND_BURNOUT_LOOP ] );
+	//	m_pKartSounds[ KART_SOUND_BURNOUT_LOOP ] = NULL;
+	//}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::InitInvulnerableMaterial( void )
+{
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( !pLocalPlayer )
+		return;
+
+	const char *pszMaterial = NULL;
+
+	int iVisibleTeam = GetTeamNumber();
+	// if this player is disguised and on the other team, use disguise team
+	if ( m_Shared.InCond( TF_COND_DISGUISED ) && !InSameTeam( pLocalPlayer ) )
+	{
+		iVisibleTeam = m_Shared.GetDisguiseTeam();
+	}
+
+	switch ( iVisibleTeam )
+	{
+	case TF_TEAM_BLUE:	
+		pszMaterial = "models/effects/invulnfx_blue.vmt";
+		break;
+	case TF_TEAM_RED:	
+		pszMaterial = "models/effects/invulnfx_red.vmt";
+		break;
+	default:
+		break;
+	}
+
+	if ( pszMaterial )
+	{
+		m_InvulnerableMaterial.Init( pszMaterial, TEXTURE_GROUP_CLIENT_EFFECTS );
+	}
+	else
+	{
+		m_InvulnerableMaterial.Shutdown();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::StartBurningSound( void )
+{
+	CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+
+	if ( !m_pBurningSound )
+	{
+		CLocalPlayerFilter filter;
+		m_pBurningSound = controller.SoundCreate( filter, entindex(), "Player.OnFire" );
+	}
+
+	controller.Play( m_pBurningSound, 0.0, 100 );
+	controller.SoundChangeVolume( m_pBurningSound, 1.0, 0.1 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::StopBurningSound( void )
+{
+	if ( m_pBurningSound )
+	{
+		CSoundEnvelopeController::GetController().SoundDestroy( m_pBurningSound );
+		m_pBurningSound = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::StopBlastJumpLoopSound( int iUserID )
+{
+	if ( m_pBlastJumpLoop )
+	{
+		if ( GetUserID() == iUserID )
+		{
+			CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+			controller.SoundDestroy( m_pBlastJumpLoop );
+			m_pBlastJumpLoop = NULL;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateRecentlyTeleportedEffect( void )
+{
+	bool bShow = m_Shared.ShouldShowRecentlyTeleported();
+
+	if ( bShow )
+	{			
+		// NVNT if this is the local player notify haptics system of this teleporter
+		//   teleporting.
+		if(IsLocalPlayer()&&!tfHaptics.wasBeingTeleported) {
+			if ( haptics )
+				haptics->ProcessHapticEvent(2,"Game","player_teleport");
+			tfHaptics.wasBeingHealed = true;
+		}
+		if ( !m_pTeleporterEffect )
+		{
+			const char *pszEffectName = NULL;
+
+			int iTeam = GetTeamNumber();
+			if ( m_Shared.InCond( TF_COND_DISGUISED ) )
+			{
+				iTeam = m_Shared.GetDisguiseTeam();
+			}
+
+			switch( iTeam )
+			{
+			case TF_TEAM_BLUE:
+				pszEffectName = "player_recent_teleport_blue";
+				break;
+			case TF_TEAM_RED:
+				pszEffectName = "player_recent_teleport_red";
+				break;
+			default:
+				break;
+			}
+
+			if ( TFGameRules()->IsMannVsMachineMode() && IsABot() )
+			{
+#if 0 // Nice idea, but it's chewing into our particle budget, and because bots currently spawn in ubered it's nearly invisible.
+				pszEffectName = "bot_recent_teleport_blue";
+#else
+				pszEffectName = NULL;
+#endif
+			}
+
+			if ( pszEffectName )
+			{
+				m_pTeleporterEffect = ParticleProp()->Create( pszEffectName, PATTACH_ABSORIGIN_FOLLOW );
+			}
+		}
+	}
+	else
+	{
+		// NVNT if this is the local player and we were being teleported
+		// flag that we are no longer teleporting.
+		if(IsLocalPlayer()&&tfHaptics.wasBeingTeleported) {
+			tfHaptics.wasBeingHealed = false;
+		}
+
+		if ( m_pTeleporterEffect )
+		{
+			ParticleProp()->StopEmission( m_pTeleporterEffect );
+			m_pTeleporterEffect = NULL;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdatedMarkedForDeathEffect( bool bForceStop )
+{
+
+	// Dont show the particle over the local player's head.  They have the icon that shows
+	// up over their health in the HUD which serves this purpose.
+	if ( IsLocalPlayer() )
+		return;
+
+	bool bShow = m_Shared.InCond( TF_COND_MARKEDFORDEATH ) || m_Shared.InCond( TF_COND_MARKEDFORDEATH_SILENT ) || m_Shared.InCond( TF_COND_PASSTIME_PENALTY_DEBUFF );
+
+	// force stop
+	if ( bForceStop || m_Shared.IsStealthed() || m_Shared.InCond( TF_COND_DISGUISED ) )
+	{
+		bShow = false;
+	}
+
+	if ( !bShow )
+	{
+		// Stop and then go
+		RemoveOverheadEffect( "mark_for_death", true );
+	}
+
+	if ( bShow )
+	{
+		AddOverheadEffect( "mark_for_death" );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Show an icon above the player's head to let other players know which Powerup Rune they are carrying 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateRuneIcon( bool bForceStop /*= false */ )
+{
+	// Don't show the particle over the local player's head.  They have the icon that shows
+	// up over their health in the HUD which serves this purpose.
+	if ( IsLocalPlayer() )
+	 	return;
+
+	const RuneTypes_t carryingRuneType = m_Shared.GetCarryingRuneType();
+	const bool bAllowedToShow = ( m_Shared.IsCarryingRune() && !m_Shared.IsStealthed() );
+	int iTeam = IsEnemyPlayer() && m_Shared.InCond( TF_COND_DISGUISED ) ? m_Shared.GetDisguiseTeam() : GetTeamNumber();
+
+	if ( !bAllowedToShow || bForceStop || ( carryingRuneType != m_eDisplayingRuneIcon ) )
+	{
+		// remove all particle for both team just in case
+		for ( int i=0; i<RUNE_TYPES_MAX; ++i )
+		{
+			RuneTypes_t type = RuneTypes_t(i);
+			RemoveOverheadEffect( GetPowerupIconName( type, TF_TEAM_RED ), true );
+			RemoveOverheadEffect( GetPowerupIconName( type, TF_TEAM_BLUE ), true );
+		}
+		m_eDisplayingRuneIcon = RUNE_NONE;
+	}
+
+	if ( bAllowedToShow && ( carryingRuneType != m_eDisplayingRuneIcon ) )
+	{
+		const char* pszEffect = NULL;
+		if ( carryingRuneType > RUNE_NONE && carryingRuneType < RUNE_TYPES_MAX )
+		{
+			pszEffect = GetPowerupIconName( carryingRuneType, iTeam );
+		}
+		else
+		{
+#ifdef STAGING_ONLY			
+			Assert( !"unexepected value in GetCarryingRuneType, probably a bug" );
+			pszEffect = "(null)"; // so we don't crash in the messages below.
+			Msg( "GetCarryingRuneType had surprising value: %d for player %s\n", carryingRuneType, GetPlayerName() );
+#endif
+		}
+
+		if ( AddOverheadEffect( pszEffect ) )
+		{
+			m_eDisplayingRuneIcon = carryingRuneType;
+		}
+#ifdef STAGING_ONLY				
+		else
+		{
+			Msg( "ParticleProp()->Create failed for some reason for powerup %s, for player %s.\n", pszEffect, GetPlayerName() );
+		}
+#endif
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::OnPlayerClassChange( void )
+{
+	// Init the anim movement vars
+	m_PlayerAnimState->SetRunSpeed( GetPlayerClass()->GetMaxSpeed() );
+	m_PlayerAnimState->SetWalkSpeed( GetPlayerClass()->GetMaxSpeed() * 0.5 );
+
+	if ( IsLocalPlayer() )
+	{
+		g_ItemEffectMeterManager.SetPlayer( this );
+	}
+	ShowNemesisIcon( false );
+	ShowDuelingIcon( false );
+
+	SetAppropriateCamera( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::InitPhonemeMappings()
+{
+	CStudioHdr *pStudio = GetModelPtr();
+	if ( pStudio )
+	{
+		char szBasename[MAX_PATH];
+		Q_StripExtension( pStudio->pszName(), szBasename, sizeof( szBasename ) );
+		char szExpressionName[MAX_PATH];
+		Q_snprintf( szExpressionName, sizeof( szExpressionName ), "%s/phonemes/phonemes", szBasename );
+		if ( FindSceneFile( szExpressionName ) )
+		{
+			SetupMappings( szExpressionName );	
+		}
+		else
+		{
+			BaseClass::InitPhonemeMappings();
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ResetFlexWeights( CStudioHdr *pStudioHdr )
+{
+	if ( !pStudioHdr || pStudioHdr->numflexdesc() == 0 )
+		return;
+
+	// Reset the flex weights to their starting position.
+	LocalFlexController_t iController;
+	for ( iController = LocalFlexController_t(0); iController < pStudioHdr->numflexcontrollers(); ++iController )
+	{
+		SetFlexWeight( iController, 0.0f );
+	}
+
+	// Reset the prediction interpolation values.
+	m_iv_flexWeight.Reset();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CalcInEyeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov )
+{
+	QAngle myEyeAngles;
+	VectorCopy( EyeAngles(), myEyeAngles );
+	BaseClass::CalcInEyeCamView( eyeOrigin, eyeAngles, fov );
+
+	/*
+	// if we are coaching, we override the eye angles with our original ones
+	// @note Tom Bui: we don't try to capture the "up" button event, because that doesn't seem so reliable
+	if ( m_bIsCoaching )
+	{
+		const float kLerpTime = 1.0f;
+		if ( ( m_nButtons & IN_JUMP ) != 0 )
+		{
+			VectorCopy( myEyeAngles, eyeAngles );
+			engine->SetViewAngles( eyeAngles );
+			m_flCoachLookAroundLerpTime = kLerpTime;
+			m_angCoachLookAroundEyeAngles = myEyeAngles;
+		}
+		else if ( m_flCoachLookAroundLerpTime > 0 )
+		{
+			m_flCoachLookAroundLerpTime -= gpGlobals->frametime;
+			float flPercent = ( kLerpTime - m_flCoachLookAroundLerpTime / kLerpTime );
+			eyeAngles = Lerp( flPercent, m_angCoachLookAroundEyeAngles, eyeAngles );
+			engine->SetViewAngles( eyeAngles );
+		}
+	}
+	*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+CStudioHdr *C_TFPlayer::OnNewModel( void )
+{
+	CStudioHdr *hdr = BaseClass::OnNewModel();
+
+	// Initialize the gibs.
+	InitPlayerGibs();
+
+	InitializePoseParams();
+
+	// Init flexes, cancel any scenes we're playing
+	ClearSceneEvents( NULL, false );
+
+	// Reset the flex weights.
+	ResetFlexWeights( hdr );
+
+	// Reset the players animation states, gestures
+	if ( m_PlayerAnimState )
+	{
+		m_PlayerAnimState->OnNewModel();
+	}
+
+	if ( hdr )
+	{
+		InitPhonemeMappings();
+	}
+
+	if ( IsPlayerClass( TF_CLASS_SPY ) )
+	{
+		m_iSpyMaskBodygroup = FindBodygroupByName( "spyMask" );
+	}
+	else
+	{
+		m_iSpyMaskBodygroup = -1;
+	}
+
+	return hdr;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Is this player an enemy to the local player
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::IsEnemyPlayer( void )
+{
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+	if ( !pLocalPlayer )
+		return false;
+
+	int iTeam = pLocalPlayer->GetTeamNumber();
+
+	// if we are coaching, use the team of the student
+	if ( pLocalPlayer->m_hStudent && pLocalPlayer->m_bIsCoaching )
+	{
+		iTeam = pLocalPlayer->m_hStudent->GetTeamNumber();
+	}
+
+	switch( iTeam )
+	{
+	case TF_TEAM_RED:
+		return ( GetTeamNumber() == TF_TEAM_BLUE );
+	
+	case TF_TEAM_BLUE:
+		return ( GetTeamNumber() == TF_TEAM_RED );
+
+	default:
+		break;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays a nemesis icon on this player to the local player
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ShowNemesisIcon( bool bShow )
+{
+	if ( bShow )
+	{
+		const char *pszEffect = NULL;
+		switch ( GetTeamNumber() )
+		{
+		case TF_TEAM_RED:
+			pszEffect = "particle_nemesis_red";
+			break;
+		case TF_TEAM_BLUE:
+			pszEffect = "particle_nemesis_blue";
+			break;
+		default:
+			return;	// shouldn't get called if we're not on a team; bail out if it does
+		}
+		AddOverheadEffect( pszEffect );
+	}
+	else
+	{
+		// stop effects for both team colors (to make sure we remove effects in event of team change)
+		RemoveOverheadEffect( "particle_nemesis_red", true );
+		RemoveOverheadEffect( "particle_nemesis_blue", true );
+	}
+	m_bIsDisplayingNemesisIcon = bShow;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays a dueling icon on this player to the local player
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ShowDuelingIcon( bool bShow )
+{
+	if ( bShow )
+	{
+		const char *pszEffect = NULL;
+		switch ( GetTeamNumber() )
+		{
+		case TF_TEAM_RED:
+			pszEffect = "duel_red";
+			break;
+		case TF_TEAM_BLUE:
+			pszEffect = "duel_blue";
+			break;
+		default:
+			return;	// shouldn't get called if we're not on a team; bail out if it does
+		}
+		AddOverheadEffect( pszEffect );
+	}
+	else
+	{
+		// stop effects for both team colors (to make sure we remove effects in event of team change)
+		RemoveOverheadEffect( "duel_red", true );
+		RemoveOverheadEffect( "duel_blue", true );
+	}
+	m_bIsDisplayingDuelingIcon = bShow;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays an icon denoting this player as "IT" to the local player
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ShowIconForIT( bool bShow )
+{
+	if ( bShow )
+	{
+		AddOverheadEffect( "halloween_boss_victim" );
+	}
+	else
+	{
+		RemoveOverheadEffect( "halloween_boss_victim", true );
+	}
+	m_bIsDisplayingIconForIT = bShow;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Displays an icon denoting this player as the Birthday Player to the local player
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ShowBirthdayEffect( bool bShow )
+{
+/*
+	if ( bShow )
+	{
+		ParticleProp()->Create( "birthday_player_circling", PATTACH_POINT_FOLLOW, "head" );
+		DispatchParticleEffect( "bday_confetti", GetAbsOrigin() + Vector(0,0,32), vec3_angle );
+	}
+	else
+	{
+		ParticleProp()->StopParticlesNamed( "birthday_player_circling", true );
+	}
+*/
+	m_bShouldShowBirthdayEffect = bShow;
+}
+
+bool C_TFPlayer::HasBombinomiconEffectOnDeath( void )
+{
+	int iBombinomicomEffectOnDeath = 0;
+	CALL_ATTRIB_HOOK_INT( iBombinomicomEffectOnDeath, bombinomicon_effect_on_death );
+
+	return ( iBombinomicomEffectOnDeath != 0 );
+}
+
+#ifdef STAGING_ONLY
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateTranqMark( bool bShow, bool bForceStop /*= false */ )
+{
+	// Dont show the particle over the local player's head.  They have the icon that shows
+	// up over their health in the HUD which serves this purpose.
+	// only show this mark to spies
+	C_TFPlayer *pLocalPlayer = GetLocalTFPlayer();
+	if ( IsLocalPlayer() || !pLocalPlayer || !pLocalPlayer->IsPlayerClass( TF_CLASS_SPY ) )
+	{
+		bShow = false;
+	}
+
+	int iTranq = 0;
+	CALL_ATTRIB_HOOK_INT_ON_OTHER( pLocalPlayer, iTranq, override_projectile_type );
+	if ( iTranq != TF_PROJECTILE_TRANQ )
+	{
+		bShow = false;
+	}
+
+	if ( bShow && !m_bIsDisplayingTranqMark && m_Shared.InCond( TF_COND_TRANQ_MARKED ) )
+	{
+		AddOverheadEffect( "marked_for_tranq" );
+		m_bIsDisplayingTranqMark = true;
+	}
+	else
+	{
+		if ( m_bIsDisplayingTranqMark || bForceStop || ( !m_Shared.InCond( TF_COND_TRANQ_MARKED ) ) )
+		{
+			RemoveOverheadEffect( "marked_for_tranq", true );
+			m_bIsDisplayingTranqMark = false;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateSpyClassStealParticle( bool bShow )
+{
+	if ( bShow )
+	{
+		const char * pParticleName = NULL;
+		if ( GetTeamNumber() == TF_TEAM_RED )
+		{
+			pParticleName = "spy_stolen_smoke_red";
+		}
+		else
+		{
+			pParticleName = "spy_stolen_smoke_blue";
+		}
+		AddOverheadEffect( pParticleName );
+	}
+	else
+	{
+		// Turn off both in the case of team change
+		RemoveOverheadEffect( "spy_stolen_smoke_red", true );
+		RemoveOverheadEffect( "spy_stolen_smoke_blue", true );
+	}
+}
+
+#endif // STAGING_ONLY
+
+#define	TF_TAUNT_PITCH	0
+#define TF_TAUNT_YAW	1
+#define TF_TAUNT_DIST	2
+
+#define TF_TAUNT_MAXYAW		135
+#define TF_TAUNT_MINYAW		-135
+#define TF_TAUNT_MAXPITCH	90
+#define TF_TAUNT_MINPITCH	0
+#define TF_TAUNT_IDEALLAG	4.0f
+
+static Vector TF_TAUNTCAM_HULL_MIN( -9.0f, -9.0f, -9.0f );
+static Vector TF_TAUNTCAM_HULL_MAX( 9.0f, 9.0f, 9.0f );
+
+static ConVar tf_tauntcam_yaw( "tf_tauntcam_yaw", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+static ConVar tf_tauntcam_pitch( "tf_tauntcam_pitch", "0", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+static ConVar tf_tauntcam_dist( "tf_tauntcam_dist", "150", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+static ConVar tf_tauntcam_speed( "tf_tauntcam_speed", "300", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
+
+ConVar tf_halloween_kart_cam_dist( "tf_halloween_kart_cam_dist", "225", FCVAR_CHEAT );
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::TurnOnTauntCam( void )
+{
+	if ( !IsLocalPlayer() )
+		return;
+
+	if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
+		return;
+
+	m_flTauntCamTargetDist = ( m_flTauntCamTargetDist != 0.0f ) ? m_flTauntCamTargetDist : tf_tauntcam_dist.GetFloat();
+	m_flTauntCamTargetDistUp = ( m_flTauntCamTargetDistUp != 0.0f ) ? m_flTauntCamTargetDistUp : 0.f;
+
+	m_flTauntCamCurrentDist = 0.f;
+	m_flTauntCamCurrentDistUp = 0.f;
+
+	// Save the old view angles.
+	engine->GetViewAngles( m_angTauntEngViewAngles );
+	prediction->GetViewAngles( m_angTauntPredViewAngles );
+
+	m_TauntCameraData.m_flPitch = 0;
+	m_TauntCameraData.m_flYaw =  0;
+	m_TauntCameraData.m_flDist = m_flTauntCamTargetDist;
+	m_TauntCameraData.m_flLag = 1.f;
+	m_TauntCameraData.m_vecHullMin.Init( -9.0f, -9.0f, -9.0f );
+	m_TauntCameraData.m_vecHullMax.Init( 9.0f, 9.0f, 9.0f );
+
+	if ( tf_taunt_first_person.GetBool() )
+	{
+		// Remain in first-person.
+	}
+	else
+	{
+		g_ThirdPersonManager.SetDesiredCameraOffset( Vector( 0, 0, 0 ) );
+		g_ThirdPersonManager.SetOverridingThirdPerson( true );
+	
+		::input->CAM_ToThirdPerson();
+		ThirdPersonSwitch( true );
+		UpdateKillStreakEffects( m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills ) );
+	}
+
+	m_bTauntInterpolating = true;
+
+	if ( m_hItem )
+	{
+		m_hItem->UpdateVisibility();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::TurnOnTauntCam_Finish( void )
+{
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::TurnOffTauntCam( void )
+{
+	if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
+		return;
+
+	// We want to interpolate back into the guy's head.
+	if ( g_ThirdPersonManager.GetForcedThirdPerson() == false )
+	{
+		m_flTauntCamTargetDist = 0.f;
+		m_TauntCameraData.m_flDist = m_flTauntCamTargetDist;
+	}
+
+	g_ThirdPersonManager.SetOverridingThirdPerson( false );
+
+	if ( g_ThirdPersonManager.GetForcedThirdPerson() )
+	{
+		TurnOffTauntCam_Finish();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::TurnOffTauntCam_Finish( void )
+{
+	if ( !IsLocalPlayer() )
+		return;	
+
+	if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
+		return;
+
+	const Vector& vecOffset = g_ThirdPersonManager.GetCameraOffsetAngles();
+	tf_tauntcam_pitch.SetValue( vecOffset[PITCH] - m_angTauntPredViewAngles[PITCH] );
+	tf_tauntcam_yaw.SetValue( vecOffset[YAW] - m_angTauntPredViewAngles[YAW] );
+	
+	QAngle angles;
+
+	angles[PITCH] = vecOffset[PITCH];
+	angles[YAW] = vecOffset[YAW];
+	angles[DIST] = vecOffset[DIST];
+
+	if( g_ThirdPersonManager.WantToUseGameThirdPerson() == false )
+	{
+		::input->CAM_ToFirstPerson();
+		ThirdPersonSwitch( false );
+		UpdateKillStreakEffects( m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills ) );
+		angles = vec3_angle;
+	}
+
+	::input->CAM_SetCameraThirdData( NULL, angles );
+
+	// Reset the old view angles.
+//	engine->SetViewAngles( m_angTauntEngViewAngles );
+//	prediction->SetViewAngles( m_angTauntPredViewAngles );
+
+	// Force the feet to line up with the view direction post taunt.
+	// If you are forcing aim yaw, your code is almost definitely broken if you don't include a delay between 
+	// teleporting and forcing yaw. This is due to an unfortunate interaction between the command lookback window,
+	// and the fact that m_flEyeYaw is never propogated from the server to the client.
+	// TODO: Fix this after Halloween 2014.
+	m_PlayerAnimState->m_bForceAimYaw = true;
+
+	m_bTauntInterpolating = false;
+
+	if ( GetViewModel() )
+	{
+		GetViewModel()->UpdateVisibility();
+	}
+
+	if ( m_hItem )
+	{
+		m_hItem->UpdateVisibility();
+	}
+
+	SetAppropriateCamera( this );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::HandleTaunting( void )
+{
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+	// This code is only for the local player.
+	Assert( pLocalPlayer == NULL || pLocalPlayer == this );
+
+	// Clear the taunt slot.
+	if (	!m_bWasTaunting &&
+			(	
+				m_Shared.InCond( TF_COND_TAUNTING ) ||
+				m_Shared.IsControlStunned() ||
+				m_Shared.IsLoser() ||
+				m_bIsReadyToHighFive ||
+				m_nForceTauntCam ||
+				m_Shared.InCond( TF_COND_HALLOWEEN_BOMB_HEAD ) ||
+				m_Shared.InCond( TF_COND_HALLOWEEN_GIANT ) ||
+				m_Shared.InCond( TF_COND_HALLOWEEN_TINY ) ||
+				m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) ||
+				m_Shared.InCond( TF_COND_HALLOWEEN_KART ) ||
+				m_Shared.InCond( TF_COND_MELEE_ONLY ) ||
+				m_Shared.InCond( TF_COND_SWIMMING_CURSE )
+			)
+		) 
+	{
+		m_bWasTaunting = true;
+
+		// Handle the camera for the local player.
+		if ( pLocalPlayer )
+		{
+
+			TurnOnTauntCam();
+		}
+	}
+
+	if (	( !IsAlive() && m_nForceTauntCam < 2 ) || 
+			(
+				m_bWasTaunting && !m_Shared.InCond( TF_COND_TAUNTING ) && !m_Shared.IsControlStunned() && 
+				!m_Shared.InCond( TF_COND_PHASE ) && !m_Shared.IsLoser() && !m_bIsReadyToHighFive &&
+				!m_nForceTauntCam && !m_Shared.InCond( TF_COND_HALLOWEEN_BOMB_HEAD ) &&
+				!m_Shared.InCond( TF_COND_HALLOWEEN_THRILLER ) &&
+				!m_Shared.InCond( TF_COND_HALLOWEEN_GIANT ) &&
+				!m_Shared.InCond( TF_COND_HALLOWEEN_TINY ) &&
+				!m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) &&
+				!m_Shared.InCond( TF_COND_HALLOWEEN_KART ) &&
+				!m_Shared.InCond( TF_COND_MELEE_ONLY ) &&
+				!m_Shared.InCond( TF_COND_SWIMMING_CURSE )
+			)
+		)
+	{
+		m_bWasTaunting = false;
+
+		// Clear the vcd slot.
+		m_PlayerAnimState->ResetGestureSlot( GESTURE_SLOT_VCD );
+
+		// Handle the camera for the local player.
+		if ( pLocalPlayer )
+		{
+			TurnOffTauntCam();
+		}
+	}
+
+	TauntCamInterpolation();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handles third person camera interpolation directly 
+// so we can manage enter & exit behavior without hacking the camera.
+//-----------------------------------------------------------------------------
+void C_TFPlayer::TauntCamInterpolation()
+{
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+	if ( pLocalPlayer && m_bTauntInterpolating )
+	{
+		if ( m_flTauntCamCurrentDist != m_flTauntCamTargetDist )
+		{
+			m_flTauntCamCurrentDist += Sign( m_flTauntCamTargetDist - m_flTauntCamCurrentDist ) * gpGlobals->frametime * tf_tauntcam_speed.GetFloat();
+			m_flTauntCamCurrentDist = clamp( m_flTauntCamCurrentDist, m_flTauntCamCurrentDist, m_flTauntCamTargetDist );
+		}
+		
+		if ( m_flTauntCamCurrentDistUp != m_flTauntCamTargetDistUp )
+		{
+			m_flTauntCamCurrentDistUp += Sign( m_flTauntCamTargetDistUp - m_flTauntCamCurrentDistUp ) * gpGlobals->frametime * tf_tauntcam_speed.GetFloat();
+			m_flTauntCamCurrentDistUp = clamp( m_flTauntCamCurrentDistUp, m_flTauntCamCurrentDistUp, m_flTauntCamTargetDistUp );
+		}
+
+		const Vector& vecCamOffset = g_ThirdPersonManager.GetCameraOffsetAngles();
+
+		Vector vecOrigin = pLocalPlayer->GetLocalOrigin();
+		vecOrigin += pLocalPlayer->GetViewOffset();
+
+		Vector vecForward, vecUp;
+		AngleVectors( QAngle( vecCamOffset[PITCH], vecCamOffset[YAW], 0 ), &vecForward, NULL, &vecUp );
+
+		trace_t trace;
+		UTIL_TraceHull( vecOrigin, vecOrigin - ( vecForward * m_flTauntCamCurrentDist ) + ( vecUp * m_flTauntCamCurrentDistUp ), Vector( -9.f, -9.f, -9.f ), 
+			Vector( 9.f, 9.f, 9.f ), MASK_SOLID_BRUSHONLY, pLocalPlayer, COLLISION_GROUP_DEBRIS, &trace );
+
+		if ( trace.fraction < 1.0 )
+			m_flTauntCamCurrentDist *= trace.fraction;
+
+		QAngle angCameraOffset = QAngle( vecCamOffset[PITCH], vecCamOffset[YAW], m_flTauntCamCurrentDist );
+		::input->CAM_SetCameraThirdData( &m_TauntCameraData, angCameraOffset ); // Override camera distance interpolation.
+
+		g_ThirdPersonManager.SetDesiredCameraOffset( Vector( m_flTauntCamCurrentDist, 0, m_flTauntCamCurrentDistUp ) );
+
+		if ( m_flTauntCamCurrentDist == m_flTauntCamTargetDist && m_flTauntCamCurrentDistUp == m_flTauntCamTargetDistUp )
+		{
+			if ( m_flTauntCamTargetDist == 0.f )
+				TurnOffTauntCam_Finish();
+			else
+				TurnOnTauntCam_Finish();
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::PlayTauntSoundLoop( const char *pszSoundLoopName )
+{
+	if ( pszSoundLoopName && *pszSoundLoopName )
+	{
+		CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+		CPASAttenuationFilter filter( this );
+		m_pTauntSoundLoop = controller.SoundCreate( filter, entindex(), pszSoundLoopName );
+		controller.Play( m_pTauntSoundLoop, 1.0, 100 );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::StopTauntSoundLoop()
+{
+	if ( m_pTauntSoundLoop )
+	{
+		CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+		controller.SoundDestroy( m_pTauntSoundLoop );
+		m_pTauntSoundLoop = NULL;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Indicates whether the spy's cigarette should be burning or not.
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::CanLightCigarette( void )
+{
+	// Used to be a massive if-conditional.
+	// Expanded for readability.
+	if ( !IsPlayerClass( TF_CLASS_SPY ) )
+		return false;
+
+	if ( !IsAlive() )
+		return false;
+
+	// Don't light if we are disguised and an enemy (not the spy model).
+	if ( m_Shared.InCond( TF_COND_DISGUISED ) && IsEnemyPlayer() )
+	{
+		if ( m_Shared.GetDisguiseClass() != TF_CLASS_SPY )
+		{
+			return false;
+		}
+	}
+
+	// don't light for MvM Spy robots
+	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && GetTeamNumber() == TF_TEAM_PVE_INVADERS )
+		return false;
+
+	// Don't light if we are invis.
+	if ( GetPercentInvisible() > 0 )
+		return false;
+
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+	// Don't light for the local player.
+	if ( ( pLocalPlayer == this ) || !pLocalPlayer )
+		return false;
+
+	// Don't light if we're spectating in first person mode.
+	if ( (pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE) && (pLocalPlayer->GetObserverTarget() == this) )
+		return false;
+
+	// Don't light if we're covered in urine.
+	if ( m_Shared.InCond( TF_COND_URINE ) )
+		return false;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Flash the bomb hat at ever increasing frequency
+//-----------------------------------------------------------------------------
+void C_TFPlayer::HalloweenBombHeadUpdate( void )
+{
+	if ( m_Shared.InCond( TF_COND_HALLOWEEN_BOMB_HEAD ) )
+	{
+		if ( !m_hHalloweenBombHat && gpGlobals->curtime > m_flBombDelay )
+		{
+			m_hHalloweenBombHat = C_PlayerAttachedModel::Create( BOMB_HAT_MODEL, this, LookupAttachment("head"), vec3_origin, PAM_PERMANENT, 0 );
+			m_hHalloweenBombHat->FollowEntity( this, true );
+		}
+
+		if ( m_hHalloweenBombHat )
+		{
+			m_hHalloweenBombHat->m_nSkin = m_Shared.m_nHalloweenBombHeadStage;
+		}
+	}
+	else
+	{
+		if ( m_hHalloweenBombHat )
+		{
+			m_hHalloweenBombHat->StopFollowingEntity();
+			m_hHalloweenBombHat->Release();
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::ShouldPlayerDrawParticles( void )
+{
+#ifdef STAGING_ONLY
+	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( pLocalTFPlayer && pLocalTFPlayer->m_Shared.InCond( TF_COND_STEALTHED_PHASE ) )
+		return false;
+#endif // TF_CLIENT_DLL
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Check if passed in player is on the local player's friends list
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::IsPlayerOnSteamFriendsList( C_BasePlayer *pPlayer )
+{
+	C_BasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+	if ( !pLocalPlayer )
+		return false;
+
+	if ( !pPlayer )
+		return false;
+
+	if ( !steamapicontext->SteamFriends() || !steamapicontext->SteamUtils() )
+		return false;
+
+	player_info_t pi;
+	if ( engine->GetPlayerInfo( pPlayer->entindex(), &pi ) && pi.friendsID )
+	{
+		CSteamID steamID( pi.friendsID, 1, GetUniverse(), k_EAccountTypeIndividual );
+		if ( steamapicontext->SteamFriends()->HasFriend( steamID, k_EFriendFlagImmediate ) )
+			return true;
+	}
+
+	return false;
+}
+
+#ifdef STAGING_ONLY
+ConVar tf_debug_moving_taunt( "tf_debug_moving_taunt", "1" );
+#endif // STAGING_ONLY
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ClientThink()
+{
+	// Pass on through to the base class.
+	BaseClass::ClientThink();
+
+	UpdateIDTarget();
+
+	UpdateLookAt();
+
+	UpdateOverheadEffects();
+
+#ifdef STAGING_ONLY
+	if ( tf_debug_moving_taunt.GetBool() )
+#endif // STAGING_ONLY
+	{
+		if ( !IsTaunting() && m_PlayerAnimState->IsGestureSlotActive( GESTURE_SLOT_VCD ) )
+		{
+#ifdef STAGING_ONLY
+			CAnimationLayer *pLayer = m_PlayerAnimState->GetGestureSlotLayer( GESTURE_SLOT_VCD );
+			if ( pLayer )
+			{
+				const char *pszSequenceName = GetSequenceName( pLayer->m_nSequence );
+				Warning( "'%s' is playing '%s' sequence when not taunting.\n", GetPlayerName(), pszSequenceName );
+			}
+#endif // STAGING_ONLY
+			m_PlayerAnimState->ResetGestureSlot( GESTURE_SLOT_VCD );
+		}
+	}
+
+	// NVNT update state based effects (prior to healer clear)
+	if ( haptics &&haptics->HasDevice() && IsLocalPlayer()) 
+	{
+		tfHaptics.HapticsThink(this);
+	}
+
+	// Clear our healer, it'll be reset by the medigun client think if we're being healed
+	m_hHealer = NULL;
+
+	// Start smoke if we're not invisible or disguised.
+	if ( CanLightCigarette() )
+	{
+		if ( !m_bCigaretteSmokeActive )
+		{
+			int iSmokeAttachment = LookupAttachment( "cig_smoke" );
+			ParticleProp()->Create( "cig_smoke", PATTACH_POINT_FOLLOW, iSmokeAttachment );
+			m_bCigaretteSmokeActive = true;
+		}
+	}
+	else	// stop the smoke otherwise if its active
+	{
+		if ( m_bCigaretteSmokeActive )
+		{
+			ParticleProp()->StopParticlesNamed( "cig_smoke", false );
+			m_bCigaretteSmokeActive = false;
+		}
+	}
+
+	if ( m_bWaterExitEffectActive && !IsAlive() )
+	{
+		ParticleProp()->StopParticlesNamed( "water_playeremerge", false );
+		m_bWaterExitEffectActive = false;
+	}
+
+	// Kill the effect if either
+	// a) the player is dead
+	// b) the enemy disguised spy is now invisible
+
+	if ( !IsAlive() ||
+		( m_Shared.InCond( TF_COND_DISGUISED ) && IsEnemyPlayer() && ( GetPercentInvisible() > 0 ) ) )
+	{
+		StopSaveMeEffect( true );
+	}
+
+	if ( ShouldTauntHintIconBeVisible() )
+	{
+		CreateTauntWithMeEffect();
+	}
+	else
+	{
+		StopTauntWithMeEffect();
+	}
+
+	if ( IsLocalPlayer() )
+	{
+		g_ItemEffectMeterManager.Update( this );
+	}
+
+	if ( m_Shared.InCond( TF_COND_DEMO_BUFF ) )
+	{
+		m_Shared.ClientDemoBuffThink();
+	}
+
+	if ( m_pBlastJumpLoop )
+	{
+		CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+		if ( !IsAlive() )
+		{
+			controller.SoundDestroy( m_pBlastJumpLoop );
+			m_pBlastJumpLoop = NULL;
+		}
+		else
+		{
+			float flTimeAloft = gpGlobals->curtime - m_flBlastJumpLaunchTime;
+			float flPitch = RemapValClamped( flTimeAloft, 0.1f, 3.f, 200.f, 100.f );
+			float flVolume = RemapValClamped( flTimeAloft, 0.1f, 2.f, 0.25f, 0.95f );
+			controller.SoundChangePitch( m_pBlastJumpLoop, flPitch, 0.1f );
+			controller.SoundChangeVolume( m_pBlastJumpLoop, flVolume, 0.1f );
+		}
+	}
+
+	if ( HasTheFlag() && GetGlowObject() )
+	{
+		C_TFItem *pFlag = GetItem();
+		if ( pFlag->ShouldHideGlowEffect() )
+		{
+			GetGlowObject()->SetEntity( NULL );
+		}
+		else
+		{
+			GetGlowObject()->SetEntity( this );
+		}
+	}
+#ifdef STAGING_ONLY
+/*	
+	// this code was added for a new sniper rifle that was being looked at, but it breaks glows for existing players by always
+	// turning off the glow if the weapon doesn't think it needs to be on. this needs to be fixed before we can use it.
+	// some mods use the glows and the SourceTV clients see player glows when they're watching a match.
+	else
+	{
+		bool bGlow = false;
+
+		C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
+		if ( pLocalTFPlayer && pLocalTFPlayer->m_Shared.InCond( TF_COND_ZOOMED ) && !( pLocalTFPlayer->InSameTeam( this ) || m_Shared.GetDisguiseTeam() == pLocalTFPlayer->GetTeamNumber() ) )
+		{
+			int iGlowEnemiesInScope = 0;
+			CALL_ATTRIB_HOOK_INT_ON_OTHER( pLocalTFPlayer, iGlowEnemiesInScope, add_sniper_glow_enemies_in_scope );
+			if ( iGlowEnemiesInScope != 0 )
+			{
+				trace_t tr;
+				UTIL_TraceLine( pLocalTFPlayer->EyePosition(), EyePosition(), MASK_BLOCKLOS, pLocalTFPlayer, COLLISION_GROUP_NONE, &tr );
+				if ( !tr.DidHit() )
+				{
+					bGlow = true;
+				}
+			}
+		}
+
+		if ( bGlow )
+		{
+			float r, g, b;
+			GetGlowEffectColor( &r, &g, &b );
+			EnableGlowEffect( r, g, b );
+		}
+		else
+		{
+			DestroyGlowEffect();
+		}
+	}
+*/
+#endif // STAGING_ONLY
+
+	m_Shared.ClientKillStreakBuffThink();
+
+/*
+	if ( m_LeaveServerTimer.HasStarted() && m_LeaveServerTimer.IsElapsed() )
+	{
+		engine->ExecuteClientCmd( "disconnect" );
+	}
+*/
+
+	if ( m_Shared.IsEnteringOrExitingFullyInvisible() )
+	{
+		UpdateSpyStateChange();
+	}
+
+	// Predict Halloween Kart
+	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) && !m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
+	{
+		if ( IsLocalPlayer() && cl_predict->GetBool() )
+		{
+			cl_predict->SetValue( false );
+		}
+
+		//if ( m_nButtons & IN_ATTACK )
+		//{
+		//	// 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 )
+		//	{
+		//		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() );
+		//	}
+		//}
+	}
+	else
+	{
+		// Make Sure its on otherwise
+		if ( IsLocalPlayer() && !cl_predict->GetBool() )
+		{
+			cl_predict->SetValue( true );
+		}
+	}
+
+	// update rune charge particle
+	if ( m_Shared.IsRuneCharged() && !m_pRuneChargeReadyEffect && !m_Shared.IsStealthed() )
+	{
+		m_pRuneChargeReadyEffect = ParticleProp()->Create( "powerup_supernova_ready", PATTACH_ABSORIGIN_FOLLOW );
+	}
+	else if ( m_pRuneChargeReadyEffect && ( m_Shared.IsStealthed() || !m_Shared.IsRuneCharged() ) )
+	{
+		ParticleProp()->StopEmission( m_pRuneChargeReadyEffect );
+		m_pRuneChargeReadyEffect = NULL;
+	}
+
+	UpdateRuneIcon();
+
+	UpdatedMarkedForDeathEffect();
+
+	if ( TFGameRules() && TFGameRules()->IsPasstimeMode() )
+	{
+	    // 
+	    // Passtime player reticle
+	    //
+	    if ( !IsLocalPlayer() && !m_pPasstimePlayerReticle )
+	    {
+		    m_pPasstimePlayerReticle = new C_PasstimePlayerReticle( this );
+	    }
+	    if ( m_pPasstimePlayerReticle )
+	    {
+		    m_pPasstimePlayerReticle->OnClientThink();
+	    }
+    
+	    // 
+	    // Passtime ask for ball reticle
+	    //
+	    if ( !IsLocalPlayer() && !m_pPasstimeAskForBallReticle )
+	    {
+		    m_pPasstimeAskForBallReticle = new C_PasstimeAskForBallReticle( this );
+	    }
+	    if ( m_pPasstimeAskForBallReticle )
+	    {
+		    m_pPasstimeAskForBallReticle->OnClientThink();
+	    }
+    
+		// 
+		// Passtime ask for ball button
+		//
+	    if ( m_nButtons & IN_ATTACK3 )
+	    {
+		    engine->ClientCmd("voicemenu 1 8");
+	    }
+	}
+}
+
+void C_TFPlayer::Touch( CBaseEntity *pOther )
+{
+	BaseClass::Touch( pOther );
+
+	C_TFPlayer *pVictim = ToTFPlayer( pOther );
+
+	if ( pVictim )
+	{
+		// ****************************************************************************************************************
+		// Halloween Karts
+		// Predict Dash Crash
+		if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART_DASH ) )
+		{
+			Vector vAim = GetLocalVelocity();
+			vAim.NormalizeInPlace();
+			vAim.z += 0.50f;
+			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 );
+
+			ray.Init( vOrigin, vOrigin + vAim * 16, GetPlayerMins(), GetPlayerMaxs() );
+			enginetrace->TraceRay( ray, MASK_SOLID, &pFilter, &pTrace );
+
+			Vector vecForceDirection;
+			vecForceDirection = vAim;
+			if ( pTrace.m_pEnt == pVictim )
+			{
+				// Stop moving
+				SetAbsVelocity( vec3_origin );
+				SetCurrentTauntMoveSpeed( 0 );
+				m_Shared.RemoveCond( TF_COND_HALLOWEEN_KART_DASH );
+			}
+		}
+	}
+}
+
+//
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::GetPredictable( void ) const
+{
+	// Halloween Kart Hackery to Get prediction system to behave the way we want we though prediction is actually off
+	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
+	{
+		return true;
+	}
+	return BaseClass::GetPredictable();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateLookAt( void )
+{
+	bool bFoundViewTarget = false;
+
+	Vector vForward;
+	AngleVectors( GetLocalAngles(), &vForward );
+
+	Vector vMyOrigin =  GetAbsOrigin();
+
+	Vector vecLookAtTarget = vec3_origin;
+
+	if ( tf_clientsideeye_lookats.GetBool() )
+	{
+		for( int iClient = 1; iClient <= gpGlobals->maxClients; ++iClient )
+		{
+			CBaseEntity *pEnt = UTIL_PlayerByIndex( iClient );
+			if ( !pEnt || !pEnt->IsPlayer() )
+				continue;
+
+			if ( !pEnt->IsAlive() )
+				continue;
+
+			if ( pEnt == this )
+				continue;
+
+			Vector vDir = pEnt->GetAbsOrigin() - vMyOrigin;
+
+			if ( vDir.Length() > 300 ) 
+				continue;
+
+			VectorNormalize( vDir );
+
+			if ( DotProduct( vForward, vDir ) < 0.0f )
+				continue;
+
+			vecLookAtTarget = pEnt->EyePosition();
+			bFoundViewTarget = true;
+			break;
+		}
+	}
+
+	if ( bFoundViewTarget == false )
+	{
+		// no target, look forward
+		vecLookAtTarget = GetAbsOrigin() + vForward * 512;
+	}
+
+	// orient eyes
+	m_viewtarget = vecLookAtTarget;
+
+	/*
+	// blinking
+	if (m_blinkTimer.IsElapsed())
+	{
+		m_blinktoggle = !m_blinktoggle;
+		m_blinkTimer.Start( RandomFloat( 1.5f, 4.0f ) );
+	}
+	*/
+
+	/*
+	// Figure out where we want to look in world space.
+	QAngle desiredAngles;
+	Vector to = vecLookAtTarget - EyePosition();
+	VectorAngles( to, desiredAngles );
+
+	// Figure out where our body is facing in world space.
+	QAngle bodyAngles( 0, 0, 0 );
+	bodyAngles[YAW] = GetLocalAngles()[YAW];
+
+	float flBodyYawDiff = bodyAngles[YAW] - m_flLastBodyYaw;
+	m_flLastBodyYaw = bodyAngles[YAW];
+
+	// Set the head's yaw.
+	float desired = AngleNormalize( desiredAngles[YAW] - bodyAngles[YAW] );
+	desired = clamp( -desired, m_headYawMin, m_headYawMax );
+	m_flCurrentHeadYaw = ApproachAngle( desired, m_flCurrentHeadYaw, 130 * gpGlobals->frametime );
+
+	// Counterrotate the head from the body rotation so it doesn't rotate past its target.
+	m_flCurrentHeadYaw = AngleNormalize( m_flCurrentHeadYaw - flBodyYawDiff );
+
+	SetPoseParameter( m_headYawPoseParam, m_flCurrentHeadYaw );
+
+	// Set the head's yaw.
+	desired = AngleNormalize( desiredAngles[PITCH] );
+	desired = clamp( desired, m_headPitchMin, m_headPitchMax );
+
+	m_flCurrentHeadPitch = ApproachAngle( -desired, m_flCurrentHeadPitch, 130 * gpGlobals->frametime );
+	m_flCurrentHeadPitch = AngleNormalize( m_flCurrentHeadPitch );
+	SetPoseParameter( m_headPitchPoseParam, m_flCurrentHeadPitch );
+	*/
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Try to steer away from any players and objects we might interpenetrate
+//-----------------------------------------------------------------------------
+#define TF_AVOID_MAX_RADIUS_SQR		5184.0f			// Based on player extents and max buildable extents.
+#define TF_OO_AVOID_MAX_RADIUS_SQR	0.00019f
+
+ConVar tf_max_separation_force ( "tf_max_separation_force", "256", FCVAR_DEVELOPMENTONLY );
+
+extern ConVar cl_forwardspeed;
+extern ConVar cl_backspeed;
+extern ConVar cl_sidespeed;
+
+void C_TFPlayer::AvoidPlayers( CUserCmd *pCmd )
+{
+	// Turn off the avoid player code.
+	if ( !tf_avoidteammates.GetBool() || !tf_avoidteammates_pushaway.GetBool() )
+		return;
+
+	// Don't test if the player doesn't exist or is dead.
+	if ( IsAlive() == false )
+		return;
+
+	C_TFTeam *pTeam = (C_TFTeam*)GetTeam();
+	if ( !pTeam )
+		return;
+	
+	CHudUpgradePanel *pHudVote = GET_HUDELEMENT( CHudUpgradePanel );
+	if ( pHudVote && pHudVote->IsActive() )
+	{
+		return;
+	}
+
+	// Up vector.
+	static Vector vecUp( 0.0f, 0.0f, 1.0f );
+
+	Vector vecTFPlayerCenter = GetAbsOrigin();
+	Vector vecTFPlayerMin = GetPlayerMins();
+	Vector vecTFPlayerMax = GetPlayerMaxs();
+	float flZHeight = vecTFPlayerMax.z - vecTFPlayerMin.z;
+	vecTFPlayerCenter.z += 0.5f * flZHeight;
+	VectorAdd( vecTFPlayerMin, vecTFPlayerCenter, vecTFPlayerMin );
+	VectorAdd( vecTFPlayerMax, vecTFPlayerCenter, vecTFPlayerMax );
+
+	// Find an intersecting player or object.
+	int nAvoidPlayerCount = 0;
+	C_TFPlayer *pAvoidPlayerList[MAX_PLAYERS];
+
+	C_TFPlayer *pIntersectPlayer = NULL;
+	CBaseObject *pIntersectObject = NULL;
+	float flAvoidRadius = 0.0f;
+
+	Vector vecAvoidCenter, vecAvoidMin, vecAvoidMax;
+	for ( int i = 0; i < pTeam->GetNumPlayers(); ++i )
+	{
+		C_TFPlayer *pAvoidPlayer = static_cast< C_TFPlayer * >( pTeam->GetPlayer( i ) );
+		if ( pAvoidPlayer == NULL )
+			continue;
+		// Is the avoid player me?
+		if ( pAvoidPlayer == this )
+			continue;
+
+		// Save as list to check against for objects.
+		pAvoidPlayerList[nAvoidPlayerCount] = pAvoidPlayer;
+		++nAvoidPlayerCount;
+
+		// Check to see if the avoid player is dormant.
+		if ( pAvoidPlayer->IsDormant() )
+			continue;
+
+		// Is the avoid player solid?
+		if ( pAvoidPlayer->IsSolidFlagSet( FSOLID_NOT_SOLID ) )
+			continue;
+
+		Vector t1, t2;
+
+		vecAvoidCenter = pAvoidPlayer->GetAbsOrigin();
+		vecAvoidMin = pAvoidPlayer->GetPlayerMins();
+		vecAvoidMax = pAvoidPlayer->GetPlayerMaxs();
+		flZHeight = vecAvoidMax.z - vecAvoidMin.z;
+		vecAvoidCenter.z += 0.5f * flZHeight;
+		VectorAdd( vecAvoidMin, vecAvoidCenter, vecAvoidMin );
+		VectorAdd( vecAvoidMax, vecAvoidCenter, vecAvoidMax );
+
+		if ( IsBoxIntersectingBox( vecTFPlayerMin, vecTFPlayerMax, vecAvoidMin, vecAvoidMax ) )
+		{
+			// Need to avoid this player.
+			if ( !pIntersectPlayer )
+			{
+				pIntersectPlayer = pAvoidPlayer;
+				break;
+			}
+		}
+	}
+
+	// We didn't find a player - look for objects to avoid.
+	if ( !pIntersectPlayer )
+	{
+		for ( int iPlayer = 0; iPlayer < nAvoidPlayerCount; ++iPlayer )
+		{	
+			// Stop when we found an intersecting object.
+			if ( pIntersectObject )
+				break;
+
+			for ( int iObject = 0; iObject < pTeam->GetNumObjects(); ++iObject )
+			{
+				CBaseObject *pAvoidObject = pTeam->GetObject( iObject );
+				if ( !pAvoidObject )
+					continue;
+
+				// Check to see if the object is dormant.
+				if ( pAvoidObject->IsDormant() )
+					continue;
+
+				// Is the object solid.
+				if ( pAvoidObject->IsSolidFlagSet( FSOLID_NOT_SOLID ) )
+					continue;
+
+				// If we shouldn't avoid it, see if we intersect it.
+				if ( pAvoidObject->ShouldPlayersAvoid() )
+				{
+					vecAvoidCenter = pAvoidObject->WorldSpaceCenter();
+					vecAvoidMin = pAvoidObject->WorldAlignMins();
+					vecAvoidMax = pAvoidObject->WorldAlignMaxs();
+					VectorAdd( vecAvoidMin, vecAvoidCenter, vecAvoidMin );
+					VectorAdd( vecAvoidMax, vecAvoidCenter, vecAvoidMax );
+
+					if ( IsBoxIntersectingBox( vecTFPlayerMin, vecTFPlayerMax, vecAvoidMin, vecAvoidMax ) )
+					{
+						// Need to avoid this object.
+						pIntersectObject = pAvoidObject;
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	// Anything to avoid?
+	if ( !pIntersectPlayer && !pIntersectObject )
+	{
+		m_Shared.SetSeparation( false );
+		m_Shared.SetSeparationVelocity( vec3_origin );
+		return;
+	}
+
+	// Calculate the push strength and direction.
+	Vector vecDelta;
+
+	// Avoid a player - they have precedence.
+	if ( pIntersectPlayer )
+	{
+		VectorSubtract( pIntersectPlayer->WorldSpaceCenter(), vecTFPlayerCenter, vecDelta );
+
+		Vector vRad = pIntersectPlayer->WorldAlignMaxs() - pIntersectPlayer->WorldAlignMins();
+		vRad.z = 0;
+
+		flAvoidRadius = vRad.Length();
+	}
+	// Avoid a object.
+	else
+	{
+		VectorSubtract( pIntersectObject->WorldSpaceCenter(), vecTFPlayerCenter, vecDelta );
+
+		Vector vRad = pIntersectObject->WorldAlignMaxs() - pIntersectObject->WorldAlignMins();
+		vRad.z = 0;
+
+		flAvoidRadius = vRad.Length();
+	}
+
+	float flPushStrength = RemapValClamped( vecDelta.Length(), flAvoidRadius, 0, 0, tf_max_separation_force.GetInt() ); //flPushScale;
+
+	//Msg( "PushScale = %f\n", flPushStrength );
+
+	// Check to see if we have enough push strength to make a difference.
+	if ( flPushStrength < 0.01f )
+		return;
+
+	Vector vecPush;
+	if ( GetAbsVelocity().Length2DSqr() > 0.1f )
+	{
+		Vector vecVelocity = GetAbsVelocity();
+		vecVelocity.z = 0.0f;
+		CrossProduct( vecUp, vecVelocity, vecPush );
+		VectorNormalize( vecPush );
+	}
+	else
+	{
+		// We are not moving, but we're still intersecting.
+		QAngle angView = pCmd->viewangles;
+		angView.x = 0.0f;
+		AngleVectors( angView, NULL, &vecPush, NULL );
+	}
+
+	// Move away from the other player/object.
+	Vector vecSeparationVelocity;
+	if ( vecDelta.Dot( vecPush ) < 0 )
+	{
+		vecSeparationVelocity = vecPush * flPushStrength;
+	}
+	else
+	{
+		vecSeparationVelocity = vecPush * -flPushStrength;
+	}
+
+	// Don't allow the max push speed to be greater than the max player speed.
+	float flMaxPlayerSpeed = MaxSpeed();
+	float flCropFraction = 1.33333333f;
+
+	if ( ( GetFlags() & FL_DUCKING ) && ( GetGroundEntity() != NULL ) )
+	{	
+		flMaxPlayerSpeed *= flCropFraction;
+	}	
+
+	float flMaxPlayerSpeedSqr = flMaxPlayerSpeed * flMaxPlayerSpeed;
+
+	if ( vecSeparationVelocity.LengthSqr() > flMaxPlayerSpeedSqr )
+	{
+		vecSeparationVelocity.NormalizeInPlace();
+		VectorScale( vecSeparationVelocity, flMaxPlayerSpeed, vecSeparationVelocity );
+	}
+
+	QAngle vAngles = pCmd->viewangles;
+	vAngles.x = 0;
+	Vector currentdir;
+	Vector rightdir;
+
+	AngleVectors( vAngles, &currentdir, &rightdir, NULL );
+
+	Vector vDirection = vecSeparationVelocity;
+
+	VectorNormalize( vDirection );
+
+	float fwd = currentdir.Dot( vDirection );
+	float rt = rightdir.Dot( vDirection );
+
+	float forward = fwd * flPushStrength;
+	float side = rt * flPushStrength;
+
+	//Msg( "fwd: %f - rt: %f - forward: %f - side: %f\n", fwd, rt, forward, side );
+
+	m_Shared.SetSeparation( true );
+	m_Shared.SetSeparationVelocity( vecSeparationVelocity );
+
+	pCmd->forwardmove	+= forward;
+	pCmd->sidemove		+= side;
+
+	// Clamp the move to within legal limits, preserving direction. This is a little
+	// complicated because we have different limits for forward, back, and side
+
+	//Msg( "PRECLAMP: forwardmove=%f, sidemove=%f\n", pCmd->forwardmove, pCmd->sidemove );
+
+	float flForwardScale = 1.0f;
+	if ( pCmd->forwardmove > fabs( cl_forwardspeed.GetFloat() ) )
+	{
+		flForwardScale = fabs( cl_forwardspeed.GetFloat() ) / pCmd->forwardmove;
+	}
+	else if ( pCmd->forwardmove < -fabs( cl_backspeed.GetFloat() ) )
+	{
+		flForwardScale = fabs( cl_backspeed.GetFloat() ) / fabs( pCmd->forwardmove );
+	}
+
+	float flSideScale = 1.0f;
+	if ( fabs( pCmd->sidemove ) > fabs( cl_sidespeed.GetFloat() ) )
+	{
+		flSideScale = fabs( cl_sidespeed.GetFloat() ) / fabs( pCmd->sidemove );
+	}
+
+	float flScale = MIN( flForwardScale, flSideScale );
+	pCmd->forwardmove *= flScale;
+	pCmd->sidemove *= flScale;
+
+	//Msg( "Pforwardmove=%f, sidemove=%f\n", pCmd->forwardmove, pCmd->sidemove );
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : flInputSampleTime - 
+//			*pCmd - 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::CreateMove( float flInputSampleTime, CUserCmd *pCmd )
+{
+	static QAngle angMoveAngle( 0.0f, 0.0f, 0.0f );
+	static float flTauntTurnSpeed = 0.f;
+	
+	bool bNoTaunt = true;
+	bool bInTaunt = m_Shared.InCond( TF_COND_TAUNTING ) || m_Shared.InCond( TF_COND_HALLOWEEN_THRILLER );
+
+	if ( m_Shared.InCond( TF_COND_FREEZE_INPUT ) )
+	{
+		pCmd->viewangles = angMoveAngle; // use the last save angles
+		pCmd->forwardmove = 0.0f;
+		pCmd->sidemove = 0.0f;
+		pCmd->upmove = 0.0f;
+		pCmd->buttons = 0;
+		pCmd->weaponselect = 0;
+		pCmd->weaponsubtype = 0;
+		pCmd->mousedx = 0;
+		pCmd->mousedy = 0;
+	}
+
+	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
+	{
+		m_Shared.CreateVehicleMove( flInputSampleTime, pCmd );
+	}
+	else if ( bInTaunt )
+	{
+		if ( tf_allow_taunt_switch.GetInt() <= 1 )
+		{
+			pCmd->weaponselect = 0;
+		}
+
+		int nCurrentButtons = pCmd->buttons;
+		pCmd->buttons = 0;
+
+		if ( !CanMoveDuringTaunt() )
+		{
+			pCmd->forwardmove = 0.0f;
+			pCmd->sidemove = 0.0f;
+			pCmd->upmove = 0.0f;
+
+			VectorCopy( angMoveAngle, pCmd->viewangles );
+		}
+		else
+		{
+			float flSign = pCmd->sidemove != 0.f ? 1.f : -1.f;
+			float flMaxTurnSpeed = m_flTauntTurnSpeed;
+#ifdef STAGING_ONLY
+			flMaxTurnSpeed = cl_taunt_max_turn_speed.GetFloat() > 0.f ? cl_taunt_max_turn_speed.GetFloat() : flMaxTurnSpeed;
+			if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
+			{
+				flMaxTurnSpeed = cl_halloween_kart_turn_speed.GetFloat();
+			}
+#endif // STAGING_ONLY
+			if ( m_flTauntTurnAccelerationTime > 0.f )
+			{
+				flTauntTurnSpeed = clamp( flTauntTurnSpeed + flSign * ( flInputSampleTime / m_flTauntTurnAccelerationTime ) * flMaxTurnSpeed, 0.f, flMaxTurnSpeed );
+			}
+			else
+			{
+				flTauntTurnSpeed = flMaxTurnSpeed;
+			}
+			
+			float flSmoothTurnSpeed = 0.f;
+			if ( flMaxTurnSpeed > 0.f )
+			{
+				flSmoothTurnSpeed = SimpleSpline( flTauntTurnSpeed / flMaxTurnSpeed ) * flMaxTurnSpeed;
+			}
+
+			// only let these button through
+			if ( pCmd->sidemove < 0 )
+			{
+				angMoveAngle += QAngle( 0.f, flSmoothTurnSpeed * flInputSampleTime, 0.f );
+			}
+			else if( pCmd->sidemove > 0 )
+			{
+				angMoveAngle += QAngle( 0.f, -flSmoothTurnSpeed * flInputSampleTime, 0.f );
+			}
+			pCmd->buttons = nCurrentButtons & ( IN_MOVELEFT | IN_MOVERIGHT | IN_FORWARD | IN_BACK );
+			pCmd->sidemove = 0.0f;
+
+			VectorCopy( angMoveAngle, pCmd->viewangles );
+		}
+
+		// allow remap taunt keys to go through
+		CTFTauntInfo *pTaunt = m_TauntEconItemView.GetStaticData()->GetTauntData();
+		if ( pTaunt )
+		{
+			for ( int i=0; i<pTaunt->GetTauntInputRemapCount(); ++i )
+			{
+				const CTFTauntInfo::TauntInputRemap_t& tauntRemap = pTaunt->GetTauntInputRemapScene( i );
+				if ( nCurrentButtons & tauntRemap.m_iButton )
+				{
+					pCmd->buttons |= tauntRemap.m_iButton;
+				}
+			}
+		}
+
+		bNoTaunt = false;
+	}
+	else
+	{
+		flTauntTurnSpeed = 0.f;
+		VectorCopy( pCmd->viewangles, angMoveAngle );
+	}
+
+	BaseClass::CreateMove( flInputSampleTime, pCmd );
+
+	// Don't avoid players if in the middle of a high five. This prevents high-fivers from becoming separated.
+	if ( !bInTaunt || ( !m_bIsReadyToHighFive && !CTFPlayerSharedUtils::ConceptIsPartnerTaunt( m_Shared.m_iTauntConcept ) ) )
+	{
+		AvoidPlayers( pCmd );
+	}
+
+	return bNoTaunt;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: This prevents some anims from being thrown out when the client is in prediction simulation.
+// Stun anims, for example, (additive gestures) are synchronized by time and can keep playing on the client
+// to prevent pauses during the stun loop.
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::PlayAnimEventInPrediction( PlayerAnimEvent_t event )
+{
+	if ( !cl_predict->GetBool() )
+		return true;
+
+	switch ( event )
+	{
+	case PLAYERANIMEVENT_STUN_BEGIN:
+	case PLAYERANIMEVENT_STUN_MIDDLE:
+	case PLAYERANIMEVENT_STUN_END:
+	case PLAYERANIMEVENT_PASSTIME_THROW_BEGIN:
+	case PLAYERANIMEVENT_PASSTIME_THROW_MIDDLE:
+	case PLAYERANIMEVENT_PASSTIME_THROW_END:
+	case PLAYERANIMEVENT_PASSTIME_THROW_CANCEL:
+		return true;
+	default:
+		return false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
+{
+	if ( IsLocalPlayer() )
+	{
+		if ( !prediction->IsFirstTimePredicted() && !PlayAnimEventInPrediction( event ) )
+			return;
+	}
+
+	MDLCACHE_CRITICAL_SECTION();
+	m_PlayerAnimState->DoAnimationEvent( event, nData );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CreateBombonomiconHint()
+{
+	if ( IsLocalPlayer() && IsAlive() )
+	{
+		m_hBombonomiconHint = C_MerasmusBombEffect::Create( BOMBONOMICON_MODEL, this, Vector(-40, 0, 120), QAngle(30, 0, 0), 100.0, 4.0, PRM_SPIN_Z );
+		m_flBombDelay = gpGlobals->curtime + 2.0f;
+		m_hBombonomiconHint->SetModelScale( 0.5f );
+
+		CSingleUserRecipientFilter filter(this);
+		CSoundParameters params;
+		if ( CBaseEntity::GetParametersForSound( "Halloween.BombinomiconSpin", params, NULL ) )
+		{
+			EmitSound_t es( params );
+			EmitSound( filter, m_hBombonomiconHint->entindex(), es );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::DestroyBombonomiconHint()
+{
+	if ( IsLocalPlayer() )
+	{
+		if ( m_hBombonomiconHint )
+		{
+			m_hBombonomiconHint->Release();
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Similar to OnNewModel. only reset animation related data
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CleanUpAnimationOnSpawn()
+{
+	CStudioHdr *hdr = GetModelPtr();
+	if ( !hdr )
+		return;
+
+	InitializePoseParams();
+
+	// Init flexes, cancel any scenes we're playing
+	ClearSceneEvents( NULL, false );
+
+	// Reset the flex weights.
+	ResetFlexWeights( GetModelPtr() );
+
+	// Reset the players animation states, gestures
+	if ( m_PlayerAnimState )
+	{
+		m_PlayerAnimState->ClearAnimationState();
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::IsABot( void )
+{
+	if ( m_bIsABot )
+		return true;
+
+	if ( g_PR && g_PR->IsFakePlayer( entindex() ) )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+Vector C_TFPlayer::GetObserverCamOrigin( void )
+{
+	if ( !IsAlive() )
+	{
+		if ( m_hFirstGib )
+		{
+			IPhysicsObject *pPhysicsObject = m_hFirstGib->VPhysicsGetObject();
+			if( pPhysicsObject )
+			{
+				Vector vecMassCenter = pPhysicsObject->GetMassCenterLocalSpace();
+				Vector vecWorld;
+				m_hFirstGib->CollisionProp()->CollisionToWorldSpace( vecMassCenter, &vecWorld );
+				return (vecWorld);
+			}
+			return m_hFirstGib->GetRenderOrigin();
+		}
+
+		return GetDeathViewPosition();
+	}
+
+	return BaseClass::GetObserverCamOrigin();	
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Consider the viewer and other factors when determining resulting
+// invisibility
+//-----------------------------------------------------------------------------
+float C_TFPlayer::GetEffectiveInvisibilityLevel( void )
+{
+	float flPercentInvisible = GetPercentInvisible();
+
+	// Crude way to limit Halloween spell
+	bool bHalloweenSpellStealth = TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) && m_Shared.InCond( TF_COND_STEALTHED_USER_BUFF );
+	bool bLimitedInvis = !IsEnemyPlayer() || bHalloweenSpellStealth;
+
+#ifdef STAGING_ONLY
+	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( pLocalTFPlayer && pLocalTFPlayer->m_Shared.InCond( TF_COND_STEALTHED_PHASE ) && pLocalTFPlayer != this )
+	{
+		bLimitedInvis = false;
+	}
+#endif // STAGING_ONLY
+
+	// If this is a teammate of the local player or viewer is observer,
+	// dont go above a certain max invis
+	if ( bLimitedInvis )
+	{
+		float flMax = tf_teammate_max_invis.GetFloat();
+		if ( flPercentInvisible > flMax )
+		{
+			flPercentInvisible = flMax;
+		}
+	}
+	else
+	{
+		// If this player just killed me, show them slightly
+		// less than full invis in the deathcam and freezecam
+
+		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+		if ( pLocalPlayer )
+		{
+			int iObserverMode = pLocalPlayer->GetObserverMode();
+
+			if ( ( iObserverMode == OBS_MODE_FREEZECAM || iObserverMode == OBS_MODE_DEATHCAM ) && 
+				pLocalPlayer->GetObserverTarget() == this )
+			{
+				float flMax = tf_teammate_max_invis.GetFloat();
+				if ( flPercentInvisible > flMax )
+				{
+					flPercentInvisible = flMax;
+				}
+			}
+		}
+	}
+
+	return flPercentInvisible;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::SetBodygroupsDirty( void )
+{
+	m_bBodygroupsDirty = true;
+
+	CTFViewModel *pVM = dynamic_cast<CTFViewModel *>( GetViewModel() );
+	if ( pVM )
+	{
+		pVM->m_bBodygroupsDirty = true;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::RecalcBodygroupsIfDirty( void )
+{
+	if ( m_bBodygroupsDirty )
+	{
+		m_Shared.RecalculatePlayerBodygroups();
+		m_bBodygroupsDirty = false;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_TFPlayer::DrawModel( int flags )
+{
+	// If we're a dead player with a fresh ragdoll, don't draw
+	if ( m_nRenderFX == kRenderFxRagdoll )
+		return 0;
+
+	RecalcBodygroupsIfDirty();
+
+	// Don't draw the model at all if we're fully invisible
+	if ( GetEffectiveInvisibilityLevel() >= 1.0f )
+	{
+		if ( m_hHalloweenBombHat && ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() < 90 ) && !m_hHalloweenBombHat->IsEffectActive( EF_NODRAW ) )
+		{
+			m_hHalloweenBombHat->SetEffects( EF_NODRAW );
+		}
+		return 0;
+	}
+	else
+	{
+		if ( m_hHalloweenBombHat && ( g_pMaterialSystemHardwareConfig->GetDXSupportLevel() < 90 ) && m_hHalloweenBombHat->IsEffectActive( EF_NODRAW ) )
+		{
+			m_hHalloweenBombHat->RemoveEffects( EF_NODRAW );
+		}
+	}
+
+	CMatRenderContextPtr pRenderContext( materials );
+	bool bDoEffect = false;
+
+	float flAmountToChop = 0.0;
+	if ( m_Shared.InCond( TF_COND_DISGUISING ) )
+	{
+		flAmountToChop = ( gpGlobals->curtime - m_flDisguiseEffectStartTime ) *
+			( 1.0 / TF_TIME_TO_DISGUISE );
+	}
+	else
+	{
+		if ( m_Shared.InCond( TF_COND_DISGUISED ) )
+		{
+			float flETime = gpGlobals->curtime - m_flDisguiseEffectStartTime;
+			if ( ( flETime > 0.0 ) && ( flETime < TF_TIME_TO_SHOW_DISGUISED_FINISHED_EFFECT ) )
+			{
+				flAmountToChop = 1.0 - ( flETime * ( 1.0/TF_TIME_TO_SHOW_DISGUISED_FINISHED_EFFECT ) );
+			}
+		}
+	}
+
+	bDoEffect = ( flAmountToChop > 0.0 ) && ( ! IsLocalPlayer() );
+#if ( SHOW_DISGUISE_EFFECT == 0  )
+	bDoEffect = false;
+#endif
+	bDoEffect = false;
+	if ( bDoEffect )
+	{
+		Vector vMyOrigin =  GetAbsOrigin();
+		BoxDeformation_t mybox;
+		mybox.m_ClampMins = vMyOrigin - Vector(100,100,100);
+		mybox.m_ClampMaxes = vMyOrigin + Vector(500,500,72 * ( 1 - flAmountToChop ) );
+		pRenderContext->PushDeformation( &mybox );
+	}
+
+	int ret = BaseClass::DrawModel( flags );
+
+	if ( bDoEffect )
+		pRenderContext->PopDeformation();
+	return ret;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ProcessMuzzleFlashEvent()
+{
+	CBasePlayer *pLocalPlayer = C_BasePlayer::GetLocalPlayer();
+
+	// Reenable when the weapons have muzzle flash attachments in the right spot.
+	bool bInToolRecordingMode = ToolsEnabled() && clienttools->IsInRecordingMode();
+	if ( this == pLocalPlayer && !bInToolRecordingMode )
+		return; // don't show own world muzzle flash for localplayer
+
+	if ( pLocalPlayer && pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
+	{
+		// also don't show in 1st person spec mode
+		if ( pLocalPlayer->GetObserverTarget() == this )
+			return;
+	}
+
+	C_TFWeaponBase *pWeapon = m_Shared.GetActiveTFWeapon();
+	if ( !pWeapon )
+		return;
+
+	pWeapon->ProcessMuzzleFlashEvent();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_TFPlayer::GetIDTarget() const
+{
+	return m_iIDEntIndex;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::SetForcedIDTarget( int iTarget )
+{
+	m_iForcedIDTarget = iTarget;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update this client's targetid entity
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateIDTarget()
+{
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( !pLocalPlayer || !IsLocalPlayer() )
+		return;
+
+	// don't show IDs if mp_fadetoblack is on
+	if ( GetTeamNumber() > TEAM_SPECTATOR && mp_fadetoblack.GetBool() && !IsAlive() )
+	{
+		m_iIDEntIndex = 0;
+		return;
+	}
+
+	if ( m_iForcedIDTarget )
+	{
+		m_iIDEntIndex = m_iForcedIDTarget;
+		return;
+	}
+
+	// If we're in deathcam, ID our killer
+	if ( (GetObserverMode() == OBS_MODE_DEATHCAM || GetObserverMode() == OBS_MODE_CHASE) && GetObserverTarget() && GetObserverTarget() != GetLocalTFPlayer() )
+	{
+		m_iIDEntIndex = GetObserverTarget()->entindex();
+		return;
+	}
+
+	// Clear old target and find a new one
+	m_iIDEntIndex = 0;
+
+	trace_t tr;
+	Vector vecStart, vecEnd;
+	VectorMA( MainViewOrigin(), MAX_TRACE_LENGTH, MainViewForward(), vecEnd );
+	VectorMA( MainViewOrigin(), 10,   MainViewForward(), vecStart );
+
+	// If we're in observer mode, ignore our observer target. Otherwise, ignore ourselves.
+	if ( IsObserver() )
+	{
+		UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, GetObserverTarget(), COLLISION_GROUP_NONE, &tr );
+	}
+	else
+	{
+		// Add DEBRIS when a medic has revive (for tracing against revive markers)
+		int iReviveMedic = 0;
+		CALL_ATTRIB_HOOK_INT( iReviveMedic, revive );
+		if ( TFGameRules() && TFGameRules()->GameModeUsesUpgrades() && pLocalPlayer->IsPlayerClass( TF_CLASS_MEDIC ) )
+		{
+			iReviveMedic = 1;
+		}
+
+		int nMask = MASK_SOLID | CONTENTS_DEBRIS;
+		UTIL_TraceLine( vecStart, vecEnd, nMask, this, COLLISION_GROUP_NONE, &tr );
+	}
+
+	bool bIsEnemyPlayer = false;
+
+	if ( tr.m_pEnt && tr.m_pEnt->IsPlayer() )
+	{
+		// It's okay to start solid against enemies because we sometimes press right against them
+		bIsEnemyPlayer = GetTeamNumber() != tr.m_pEnt->GetTeamNumber();
+	}
+
+	if ( ( !tr.startsolid || bIsEnemyPlayer ) && tr.DidHitNonWorldEntity() )
+	{
+		C_BaseEntity *pEntity = tr.m_pEnt;
+
+		if ( pEntity && ( pEntity != this ) )
+		{
+			m_iIDEntIndex = pEntity->entindex();
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Display appropriate hints for the target we're looking at
+//-----------------------------------------------------------------------------
+void C_TFPlayer::DisplaysHintsForTarget( C_BaseEntity *pTarget )
+{
+	// If the entity provides hints, ask them if they have one for this player
+	ITargetIDProvidesHint *pHintInterface = dynamic_cast<ITargetIDProvidesHint*>(pTarget);
+	if ( pHintInterface )
+	{
+		pHintInterface->DisplayHintTo( this );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_TFPlayer::GetRenderTeamNumber( void )
+{
+	return m_nSkin;
+}
+
+static Vector WALL_MIN(-WALL_OFFSET,-WALL_OFFSET,-WALL_OFFSET);
+static Vector WALL_MAX(WALL_OFFSET,WALL_OFFSET,WALL_OFFSET);
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+Vector C_TFPlayer::GetDeathViewPosition()
+{
+	Vector origin = EyePosition();
+
+	C_TFRagdoll *pRagdoll = static_cast<C_TFRagdoll*>( m_hRagdoll.Get() );
+	if ( pRagdoll )
+	{
+		if ( pRagdoll->IsDeathAnim() )
+		{
+			origin.z += VEC_DEAD_VIEWHEIGHT_SCALED( this ).z*4;
+		}
+		else
+		{
+			IRagdoll *pIRagdoll = GetRepresentativeRagdoll();
+			if ( pIRagdoll )
+			{
+				origin = pIRagdoll->GetRagdollOrigin();
+				origin.z += VEC_DEAD_VIEWHEIGHT_SCALED( this ).z; // look over ragdoll, not through
+			}
+		}
+	}
+
+	return origin;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CalcDeathCamView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov)
+{
+	CBaseEntity	* killer = GetObserverTarget();
+	C_BaseAnimating *pKillerAnimating = killer ? killer->GetBaseAnimating() : NULL;
+
+	// Swing to face our killer within half the death anim time
+	float interpolation = ( gpGlobals->curtime - m_flDeathTime ) / (TF_DEATH_ANIMATION_TIME * 0.5);
+	interpolation = clamp( interpolation, 0.0f, 1.0f );
+	interpolation = SimpleSpline( interpolation );
+
+	float flMinChaseDistance = CHASE_CAM_DISTANCE_MIN;
+	float flMaxChaseDistance = CHASE_CAM_DISTANCE_MAX;
+
+	if ( pKillerAnimating )
+	{
+		float flScaleSquared = pKillerAnimating->GetModelScale() * pKillerAnimating->GetModelScale();
+		flMinChaseDistance *= flScaleSquared;
+		flMaxChaseDistance *= flScaleSquared;
+	}
+
+	m_flObserverChaseDistance += gpGlobals->frametime * 48.0f;
+	m_flObserverChaseDistance = clamp( m_flObserverChaseDistance, flMinChaseDistance, flMaxChaseDistance );
+
+	QAngle aForward = eyeAngles = EyeAngles();
+	Vector origin = GetDeathViewPosition();
+
+	if ( m_hHeadGib )
+	{
+		// View from our decapitated head.
+		IPhysicsObject *pPhysicsObject = m_hHeadGib->VPhysicsGetObject();
+		if( pPhysicsObject )
+		{
+			Vector vecMassCenter = pPhysicsObject->GetMassCenterLocalSpace();
+			Vector vecWorld;
+			m_hHeadGib->CollisionProp()->CollisionToWorldSpace( vecMassCenter, &vecWorld );
+			m_hHeadGib->AddEffects( EF_NODRAW );
+
+			eyeOrigin = vecWorld + Vector(0,0,6);
+
+			QAngle aHead = m_hHeadGib->GetAbsAngles();
+			Vector vBody;
+			if ( m_hRagdoll )
+			{
+				// Turn to face our ragdoll.
+				vBody = m_hRagdoll->GetAbsOrigin() - eyeOrigin;
+			}
+			else
+			{
+				vBody = m_hHeadGib->GetAbsOrigin();
+			}
+			QAngle aBody; VectorAngles( vBody, aBody );
+			InterpolateAngles( aHead, aBody, eyeAngles, interpolation );
+			return;
+		}
+	}
+
+	if ( killer && (killer != this) ) 
+	{
+		Vector vKiller = killer->EyePosition() - origin;
+		QAngle aKiller;
+		VectorAngles( vKiller, aKiller );
+		InterpolateAngles( aForward, aKiller, eyeAngles, interpolation );
+	}
+
+	Vector vForward;
+	AngleVectors( eyeAngles, &vForward );
+
+	VectorNormalize( vForward );
+
+	VectorMA( origin, -m_flObserverChaseDistance, vForward, eyeOrigin );
+
+	trace_t trace; // clip against world
+	C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
+	UTIL_TraceHull( origin, eyeOrigin, WALL_MIN, WALL_MAX, MASK_SOLID, this, COLLISION_GROUP_NONE, &trace );
+	C_BaseEntity::PopEnableAbsRecomputations();
+
+	if (trace.fraction < 1.0)
+	{
+		eyeOrigin = trace.endpos;
+		m_flObserverChaseDistance = VectorLength(origin - eyeOrigin);
+	}
+
+	fov = GetFOV();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Do nothing multiplayer_animstate takes care of animation.
+// Input  : playerAnim - 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::SetAnimation( PLAYER_ANIM playerAnim )
+{
+	return;
+}
+
+float C_TFPlayer::GetMinFOV() const
+{
+	// Min FOV for Sniper Rifle
+	return 20;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+const QAngle& C_TFPlayer::EyeAngles()
+{
+	if ( IsLocalPlayer() && g_nKillCamMode == OBS_MODE_NONE )
+	{
+		return BaseClass::EyeAngles();
+	}
+	else
+	{
+		return m_angEyeAngles;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &color - 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::GetTeamColor( Color &color )
+{
+	color[3] = 255;
+
+	if ( GetTeamNumber() == TF_TEAM_RED )
+	{
+		color[0] = 159;
+		color[1] = 55;
+		color[2] = 34;
+	}
+	else if ( GetTeamNumber() == TF_TEAM_BLUE )
+	{
+		color[0] = 76;
+		color[1] = 109;
+		color[2] = 129;
+	}
+	else
+	{
+		color[0] = 255;
+		color[1] = 255;
+		color[2] = 255;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : bCopyEntity - 
+// Output : C_BaseAnimating *
+//-----------------------------------------------------------------------------
+C_BaseAnimating *C_TFPlayer::BecomeRagdollOnClient()
+{
+	// Let the C_TFRagdoll take care of this.
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  :  - 
+// Output : IRagdoll*
+//-----------------------------------------------------------------------------
+IRagdoll* C_TFPlayer::GetRepresentativeRagdoll() const
+{
+	if ( m_hRagdoll.Get() )
+	{
+		C_TFRagdoll *pRagdoll = static_cast<C_TFRagdoll*>( m_hRagdoll.Get() );
+		if ( !pRagdoll )
+			return NULL;
+
+		return pRagdoll->GetIRagdoll();
+	}
+	else
+	{
+		return NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::InitPlayerGibs( void )
+{
+	// Clear out the gib list and create a new one.
+	m_aGibs.Purge();
+	m_aNormalGibs.PurgeAndDeleteElements();
+	m_aSillyGibs.Purge();
+
+	int nModelIndex = GetPlayerClass()->HasCustomModel() ? modelinfo->GetModelIndex( GetPlayerClass()->GetModelName() ) : GetModelIndex();
+	BuildGibList( m_aGibs, nModelIndex, 1.0f, COLLISION_GROUP_NONE );
+
+	if ( TFGameRules() && TFGameRules()->IsBirthday() )
+	{
+		for ( int i = 0; i < m_aGibs.Count(); i++ )
+		{
+			if ( RandomFloat(0,1) < 0.75 )
+			{
+				V_strcpy_safe( m_aGibs[i].modelName, g_pszBDayGibs[ RandomInt(0,ARRAYSIZE(g_pszBDayGibs)-1) ] );
+			}
+		}
+	}
+
+	// Copy the normal gibs list to be saved for later when swapping with Pyro Vision
+	FOR_EACH_VEC ( m_aGibs, i )
+	{
+		char *cloneStr = new char [ 512 ];
+		Q_strncpy( cloneStr, m_aGibs[i].modelName, 512 );
+		m_aNormalGibs.AddToTail( cloneStr );
+
+		// Create a list of silly gibs
+		int iRandIndex = RandomInt(4,ARRAYSIZE(g_pszBDayGibs)-1);
+		m_aSillyGibs.AddToTail( iRandIndex );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose : Checks vision flags and ensures the proper gib models are loaded for vision mode
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CheckAndUpdateGibType( void )
+{
+	// check the first gib, if it's different copy them all over
+	if ( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_PYRO ) || ( TFGameRules() && TFGameRules()->UseSillyGibs() ) )
+	{
+		if ( Q_strcmp( m_aGibs[0].modelName, g_pszBDayGibs[ m_aSillyGibs[0] ]) != 0 )
+		{
+			FOR_EACH_VEC( m_aGibs, i )
+			{
+				V_strcpy_safe( m_aGibs[i].modelName, g_pszBDayGibs[ m_aSillyGibs[i] ] );
+			}
+		}
+	}
+	else 
+	{
+		if ( Q_strcmp( m_aGibs[0].modelName, m_aNormalGibs[0]) != 0 )
+		{
+			FOR_EACH_VEC( m_aGibs, i )
+			{
+				V_strcpy_safe( m_aGibs[i].modelName, m_aNormalGibs[i] );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : &vecOrigin - 
+//			&vecVelocity - 
+//			&vecImpactVelocity - 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CreatePlayerGibs( const Vector &vecOrigin, const Vector &vecVelocity, float flImpactScale, bool bBurning, bool bWearableGibs, bool bOnlyHead, bool bDisguiseGibs )
+{
+	// Make sure we have Gibs to create.
+	if ( m_aGibs.Count() == 0 )
+		return;
+
+	AngularImpulse angularImpulse( RandomFloat( 0.0f, 120.0f ), RandomFloat( 0.0f, 120.0f ), 0.0 );
+
+	Vector vecBreakVelocity = vecVelocity;
+	vecBreakVelocity.z += tf_playergib_forceup.GetFloat();
+	VectorNormalize( vecBreakVelocity );
+	vecBreakVelocity *= tf_playergib_force.GetFloat();
+
+	// Cap the impulse.
+	float flSpeed = vecBreakVelocity.Length();
+	if ( flSpeed > tf_playergib_maxspeed.GetFloat() )
+	{
+		VectorScale( vecBreakVelocity, tf_playergib_maxspeed.GetFloat() / flSpeed, vecBreakVelocity );
+	}
+
+	breakablepropparams_t breakParams( vecOrigin, GetRenderAngles(), vecBreakVelocity, angularImpulse );
+	breakParams.impactEnergyScale = 1.0f;//
+
+	// Break up the player.
+	if ( !bWearableGibs )
+	{
+		// Gib the player's body.
+		m_hHeadGib = NULL;
+		m_hSpawnedGibs.Purge();
+
+		bool bHasCustomModel = GetPlayerClass()->HasCustomModel();
+		int nModelIndex = bHasCustomModel ? modelinfo->GetModelIndex( GetPlayerClass()->GetModelName() ) : GetModelIndex();
+
+		if ( bOnlyHead )
+		{
+			if ( UTIL_IsLowViolence() )
+			{
+				// No bloody gibs with pyro-vision goggles
+				return;
+			}
+
+			// Create only a head gib.
+			CUtlVector<breakmodel_t> headGib;
+			int nClassIndex = GetPlayerClass()->GetClassIndex();
+			if ( bHasCustomModel )
+			{
+				for ( int i=0; i<m_aGibs.Count(); ++i )
+				{
+					if ( Q_strcmp( m_aGibs[i].modelName, g_pszBotHeadGibs[nClassIndex] ) == 0 )
+					{
+						headGib.AddToHead( m_aGibs[i] );
+					}
+				}
+			}
+			else
+			{
+				for ( int i=0; i<m_aGibs.Count(); ++i )
+				{
+					if ( Q_strcmp( m_aGibs[i].modelName, g_pszHeadGibs[nClassIndex] ) == 0 )
+					{
+						headGib.AddToHead( m_aGibs[i] );
+					}
+				}
+			}
+			
+			m_hFirstGib = CreateGibsFromList( headGib, nModelIndex, NULL, breakParams, this, -1 , false, true, &m_hSpawnedGibs, bBurning );
+			m_hHeadGib = m_hFirstGib;
+			if ( m_hFirstGib )
+			{
+				IPhysicsObject *pPhysicsObject = m_hFirstGib->VPhysicsGetObject();
+				if( pPhysicsObject )
+				{
+					// Give the head some rotational damping so it doesn't roll so much (for the player's view).
+					float damping, rotdamping;
+					pPhysicsObject->GetDamping( &damping, &rotdamping );
+					rotdamping *= 6.f;
+					pPhysicsObject->SetDamping( &damping, &rotdamping );
+				}
+			}
+		}
+		else
+		{
+			CheckAndUpdateGibType();
+			m_hFirstGib = CreateGibsFromList( m_aGibs, nModelIndex, NULL, breakParams, this, -1 , false, true, &m_hSpawnedGibs, bBurning );
+		}
+		DropPartyHat( breakParams, vecBreakVelocity );
+	}
+	else
+	{
+		// Gib up the player's clothing.
+		for ( int i=0; i<GetNumWearables(); ++i )
+		{
+			C_TFWearable *pItem = dynamic_cast<C_TFWearable*> (GetWearable(i));
+
+			if ( !pItem )
+				continue;
+
+			// Don't try to drop items which haven't loaded yet
+			if ( !pItem->GetModel() || !pItem->GetModelPtr() )
+				continue;
+
+			// Only drop wearable gibs for wearables that are flagged as droppable.
+			if ( pItem->GetDropType() != ITEM_DROP_TYPE_DROP )
+				continue;
+
+			if ( pItem->IsDisguiseWearable() && !bDisguiseGibs )
+				continue;
+
+			if ( !pItem->IsDisguiseWearable() && bDisguiseGibs )
+				continue;
+
+			DropWearable( pItem, breakParams );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::DropWearable( C_TFWearable *pItem, const breakablepropparams_t &params )
+{
+	// Get the position from the rootbone of the wearable entity itself
+	Vector position;
+	matrix3x4_t rootBone;
+	if ( !pItem->IsDynamicModelLoading() && pItem->GetRootBone( rootBone ) )
+	{
+		MatrixPosition( rootBone, position );
+	}
+	else
+	{
+		position = pItem->GetAbsOrigin();
+	}
+
+	// Don't spawn wearables out of bounds
+	if ( !IsEntityPositionReasonable( position ) )
+	{
+		return;
+	}
+
+	const model_t *pModel = modelinfo->GetModel( pItem->GetModelIndex() );
+
+	// Check that the entity wouldn't be spawned in a wall
+	Vector mins, maxs;
+	modelinfo->GetModelRenderBounds( pModel, mins, maxs );
+
+	trace_t trace;
+	CTraceFilterNoNPCsOrPlayer filter( this, COLLISION_GROUP_NONE );
+	UTIL_TraceHull( position, position, mins, maxs, MASK_SOLID, &filter, &trace );
+
+	if ( trace.startsolid )
+	{
+		return;
+	}
+
+	// Velocity
+	Vector objectVelocity = params.velocity;
+	float flScale = VectorNormalize( objectVelocity );
+	objectVelocity.x += RandomFloat( -1.f, 1.0f );
+	objectVelocity.y += RandomFloat( -1.0f, 1.0f );
+	objectVelocity.z += RandomFloat( 0.0f, 1.0f );
+	VectorNormalize( objectVelocity );
+	objectVelocity *= flScale;
+
+	// Now create the TF2 wearable gib
+	C_EconWearableGib *pEntity = new C_EconWearableGib();
+	if ( !pEntity )
+		return;
+
+	const char *pszModelName = modelinfo->GetModelName( pModel );
+
+	pEntity->SetModelName( AllocPooledString( pszModelName ) );
+	pEntity->SetAbsOrigin( position );
+	pEntity->SetAbsAngles( pItem->GetAbsAngles() );
+	pEntity->SetOwnerEntity( this );
+	pEntity->ChangeTeam( GetTeamNumber() );						// our gibs will match our team; this will probably not be used for anything besides team coloring
+	// Copy the script created item data over
+	pEntity->GetAttributeContainer()->SetItem( pItem->GetAttributeContainer()->GetItem() );
+
+	if ( !pEntity->Initialize( false ) )
+	{
+		pEntity->Release();
+		return;
+	}
+
+	pEntity->m_nSkin = m_nSkin;
+	pEntity->StartFadeOut( 15.0f );
+
+	IPhysicsObject *pPhysicsObject = pEntity->VPhysicsGetObject();
+	if ( !pPhysicsObject )
+	{
+		pEntity->Release();
+		return;
+	}
+
+	// randomize velocity by 5%
+	float rndf = RandomFloat( -0.025, 0.025 );
+	Vector rndVel = objectVelocity + rndf*objectVelocity;
+	pPhysicsObject->AddVelocity( &rndVel, &params.angularVelocity );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::DropPartyHat( breakablepropparams_t &breakParams, Vector &vecBreakVelocity )
+{
+	// Turning off party hats because we've moving to real hats
+	return;
+
+/*
+	if ( m_hPartyHat )
+	{
+		breakmodel_t breakModel;
+		Q_strncpy( breakModel.modelName, BDAY_HAT_MODEL, sizeof(breakModel.modelName) );
+		breakModel.health = 1;
+		breakModel.fadeTime = RandomFloat(5,10);
+		breakModel.fadeMinDist = 0.0f;
+		breakModel.fadeMaxDist = 0.0f;
+		breakModel.burstScale = breakParams.defBurstScale;
+		breakModel.collisionGroup = COLLISION_GROUP_DEBRIS;
+		breakModel.isRagdoll = false;
+		breakModel.isMotionDisabled = false;
+		breakModel.placementName[0] = 0;
+		breakModel.placementIsBone = false;
+		breakModel.offset = GetAbsOrigin() - m_hPartyHat->GetAbsOrigin();
+		BreakModelCreateSingle( this, &breakModel, m_hPartyHat->GetAbsOrigin(), m_hPartyHat->GetAbsAngles(), vecBreakVelocity, breakParams.angularVelocity, m_hPartyHat->m_nSkin, breakParams );
+
+		m_hPartyHat->Release();
+	}
+*/
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: How many buildables does this player own
+//-----------------------------------------------------------------------------
+int	C_TFPlayer::GetObjectCount( void )
+{
+	return m_aObjects.Count();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a specific buildable that this player owns
+//-----------------------------------------------------------------------------
+C_BaseObject *C_TFPlayer::GetObject( int index_ )
+{
+	return m_aObjects[index_].Get();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Get a specific buildable that this player owns
+//-----------------------------------------------------------------------------
+C_BaseObject *C_TFPlayer::GetObjectOfType( int iObjectType, int iObjectMode ) const
+{
+	int iCount = m_aObjects.Count();
+
+	for ( int i=0;i<iCount;i++ )
+	{
+		C_BaseObject *pObj = m_aObjects[i].Get();
+
+		if ( !pObj )
+			continue;
+
+		if ( pObj->IsDormant() || pObj->IsMarkedForDeletion() )
+			continue;
+
+		if ( pObj->GetType() != iObjectType )
+			continue;
+
+		if ( pObj->GetObjectMode() != iObjectMode )
+			continue;
+
+		return pObj;
+	}
+	
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : collisionGroup - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::ShouldCollide( int collisionGroup, int contentsMask ) const
+{
+	if ( ( ( collisionGroup == COLLISION_GROUP_PLAYER_MOVEMENT ) && tf_avoidteammates.GetBool() ) ||
+		collisionGroup == TFCOLLISION_GROUP_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 );
+}
+
+float C_TFPlayer::GetPercentInvisible( void )
+{
+	return m_Shared.GetPercentInvisible();
+}
+
+void C_TFPlayer::AdjustSkinIndexForZombie( int iClassIndex, int &iSkinIndex )
+{
+	// We only know how to adjust the 4 standard base skins (red/blue * normal/invuln)
+	Assert( iSkinIndex >= 0 && iSkinIndex < 4 );
+
+	if ( iClassIndex == TF_CLASS_SPY )
+	{
+		// Spy has a bunch of extra skins used to adjust the mask
+		iSkinIndex += 22;
+	}
+	else
+	{
+		// 4: red zombie
+		// 5: blue zombie
+		// 6: red zombie invuln
+		// 7: blue zombie invuln
+		iSkinIndex += 4;
+	}
+}
+
+bool C_TFPlayer::BRenderAsZombie( bool bWeaponsCheck /*= false */  )
+{
+	// Only if the local player is optining in.
+	if ( !IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_HALLOWEEN, bWeaponsCheck ) )
+		return false;
+
+	// Should we render as somebody else?
+	bool bRenderDisguised = false;
+	if ( m_Shared.InCond( TF_COND_DISGUISED ) )
+	{
+
+		// When disguised, our teammates will see us with a mask.
+		// Don't show us as a zombie in that state, because the zombie parts
+		// (like every other cosmetic) disappear.
+		if ( !IsEnemyPlayer() )
+			return false;
+
+		// Ditto when we are disguised as an enemy spy.  We always use the mask
+		// in that case and hide cosmetics
+		if ( m_Shared.GetDisguiseClass() == TF_CLASS_SPY )
+			return false;
+
+		bRenderDisguised = true;
+	}
+
+	int iPlayerSkinOverride = bRenderDisguised ? m_Shared.GetDisguisedSkinOverride() : GetSkinOverride();
+
+	return iPlayerSkinOverride == 1;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_TFPlayer::GetSkin()
+{
+	C_TFPlayer *pLocalPlayer = GetLocalTFPlayer();
+
+	if ( !pLocalPlayer )
+		return 0;
+
+	// Allow server plugins to override
+	if ( m_bForcedSkin )
+		return m_nForcedSkin;
+
+	int iVisibleTeam = GetTeamNumber();
+
+	// if this player is disguised and on the other team, use disguise team
+	if ( m_Shared.InCond( TF_COND_DISGUISED_AS_DISPENSER ) && IsEnemyPlayer() && ( GetFlags() & FL_DUCKING ) && ( GetGroundEntity() != NULL ) )
+	{
+		iVisibleTeam = ( iVisibleTeam == TF_TEAM_RED ? TF_TEAM_BLUE : TF_TEAM_RED );
+	}
+	else if ( m_Shared.InCond( TF_COND_DISGUISED ) && IsEnemyPlayer() )
+	{
+		iVisibleTeam = m_Shared.GetDisguiseTeam();
+	}
+
+	int nSkin;
+
+	switch( iVisibleTeam )
+	{
+	case TF_TEAM_RED:
+		nSkin = 0;
+		break;
+
+	case TF_TEAM_BLUE:
+		nSkin = 1;
+		break;
+
+	default:
+		nSkin = 0;
+		break;
+	}
+
+	// Assume we'll switch skins to show the spy mask
+	bool bCheckSpyMask = true;
+
+	// 3 and 4 are invulnerable
+	if ( m_Shared.IsInvulnerable() && 
+		 ( !m_Shared.InCond( TF_COND_INVULNERABLE_HIDE_UNLESS_DAMAGED ) || gpGlobals->curtime < GetLastDamageTime() + 2.0f ) )
+	{
+		nSkin += 2;
+		bCheckSpyMask = false;
+	}
+
+	// Check for any special player skin override behaviour.
+	if ( BRenderAsZombie() )
+	{
+		int iClass = GetPlayerClass()->GetClassIndex();
+		if ( m_Shared.InCond( TF_COND_DISGUISED ) )
+		{
+			Assert( IsEnemyPlayer() );
+			iClass = m_Shared.GetDisguiseClass();
+		}
+
+		AdjustSkinIndexForZombie( iClass, nSkin );
+		bCheckSpyMask = false; // no spy masks for zombies
+	}
+
+	if ( bCheckSpyMask && m_Shared.InCond( TF_COND_DISGUISED ) )
+	{
+		if ( !IsEnemyPlayer() )
+		{
+			nSkin += 4 + ( ( m_Shared.GetDisguiseClass() - TF_FIRST_NORMAL_CLASS ) * 2 );
+		}
+		else if ( m_Shared.GetDisguiseClass() == TF_CLASS_SPY )
+		{
+			nSkin += 4 + ( ( m_Shared.GetDisguiseMask() - TF_FIRST_NORMAL_CLASS ) * 2 );
+		}
+	}
+
+	// Check for testing override
+	#ifdef STAGING_ONLY
+		if ( ( this == pLocalPlayer ) && ( test_local_player_skin_override.GetInt() >= 0 ) )
+			nSkin = test_local_player_skin_override.GetInt();
+	#endif
+
+	return nSkin;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : iClass - 
+// Output : Returns true on success, false on failure.
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::IsPlayerClass( int iClass ) const
+{
+	const C_TFPlayerClass *pClass = GetPlayerClass();
+	if ( !pClass )
+		return false;
+
+	return ( pClass->GetClassIndex() == iClass );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Don't take damage decals while stealthed
+//-----------------------------------------------------------------------------
+void C_TFPlayer::AddDecal( const Vector& rayStart, const Vector& rayEnd,
+							const Vector& decalCenter, int hitbox, int decalIndex, bool doTrace, trace_t& tr, int maxLODToDecal )
+{
+	if ( m_Shared.IsStealthed() )
+	{
+		return;
+	}
+
+	if ( m_Shared.InCond( TF_COND_DISGUISED ) )
+	{
+		return;
+	}
+
+	if ( m_Shared.IsInvulnerable() )
+	{ 
+		Vector vecDir = rayEnd - rayStart;
+		VectorNormalize(vecDir);
+		g_pEffects->Ricochet( rayEnd - (vecDir * 8), -vecDir );
+		return;
+	}
+
+#ifdef TF_RAID_MODE
+	// no decals for the BLUE team in Raid mode
+	// (temp workaround for decals causing the glows to not draw correctly)
+	if ( TFGameRules() && TFGameRules()->IsRaidMode() )
+	{
+		if ( GetTeamNumber() == TF_TEAM_BLUE )
+		{
+			return;
+		}
+	}
+#endif // TF_RAID_MODE
+
+	// don't decal from inside the player
+	if ( tr.startsolid )
+	{
+		return;
+	}
+
+	BaseClass::AddDecal( rayStart, rayEnd, decalCenter, hitbox, decalIndex, doTrace, tr, maxLODToDecal );
+}
+
+//-----------------------------------------------------------------------------
+// Called every time the player respawns
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ClientPlayerRespawn( void )
+{
+	if ( IsLocalPlayer() )
+	{
+		// MCJOHN - For testing, dump out all of the textures whenever we respawn
+		STAGING_ONLY_EXEC( engine->ClientCmd_Unrestricted( "mat_evict_all" ) );
+
+		// Dod called these, not sure why
+		//MoveToLastReceivedPosition( true );
+		//ResetLatched();
+
+		// Reset the camera.
+		HandleTaunting();
+		
+		ResetToneMapping(1.0);
+
+		// Release the duck toggle key
+		KeyUp( &in_ducktoggle, NULL ); 
+
+		IGameEvent *event = gameeventmanager->CreateEvent( "localplayer_respawn" );
+		if ( event )
+		{
+			gameeventmanager->FireEventClientSide( event );
+		}
+		// NVNT revert tf haptics
+		tfHaptics.Revert();
+
+#if defined( REPLAY_ENABLED )
+		if ( GetPlayerClass()->GetClassIndex() != TF_CLASS_UNDEFINED )
+		{
+			// Notify replay history manager that the local player has spawned.
+			// NOTE: This won't do anything if replay isn't enabled, isn't recording, etc.
+			g_pClientReplayContext->OnPlayerSpawn();
+		}
+#endif
+
+		SetAppropriateCamera( this );
+
+		if ( m_hRevivePrompt )
+		{
+			m_hRevivePrompt->MarkForDeletion();
+			m_hRevivePrompt = NULL;
+		}
+
+		m_bNotifiedWeaponInspectThisLife = false;
+	}
+
+	UpdateVisibility();
+
+	DestroyBoneAttachments();
+
+	UpdateDemomanEyeEffect( 0 );
+
+	UpdateKillStreakEffects( 0 );
+
+	UpdateMVMEyeGlowEffect( true );
+
+	m_hHeadGib = NULL;
+	m_hFirstGib = NULL;
+	m_hSpawnedGibs.Purge();
+
+	m_fMetersRan = 0;
+
+	SetShowHudMenuTauntSelection( false );
+
+	CleanUpAnimationOnSpawn();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::ShouldDraw()
+{
+	if ( IsLocalPlayer() )
+	{
+		if ( m_PlayerClass.HasCustomModel() && !m_PlayerClass.CustomModelIsVisibleToSelf() )
+			return false;
+	}
+
+	if ( this == C_TFPlayer::GetLocalTFPlayer() )
+	{
+		if ( this->m_Shared.InCond( TF_COND_ZOOMED ) )
+		{
+			return false;
+		}
+	}
+
+	return BaseClass::ShouldDraw();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_TFPlayer::GetVisionFilterFlags( bool bWeaponsCheck /*= false */  )
+{
+#if defined( REPLAY_ENABLED )
+	extern IEngineClientReplay *g_pEngineClientReplay;
+	if ( g_pEngineClientReplay->IsPlayingReplayDemo() )
+	{
+		if ( tf_replay_pyrovision.GetBool() ) 
+		{
+			return TF_VISION_FILTER_PYRO;
+		}
+		return 0x00;
+	}
+#endif
+
+	int nVisionOptInFlags = 0;
+	CALL_ATTRIB_HOOK_INT( nVisionOptInFlags, vision_opt_in_flags );
+
+	if ( IsLocalPlayer() )
+	{
+		// Force our vision filter to a specific setting
+		if ( bWeaponsCheck && m_nForceVisionFilterFlags != 0 )
+		{
+			return m_nForceVisionFilterFlags;
+		}
+
+#ifdef _DEBUG
+		int nFlags = 0;
+		if ( test_pyrovision.GetBool() )
+		{
+			nFlags |= TF_VISION_FILTER_PYRO;
+		}
+
+		if ( test_halloweenvision.GetBool() )
+		{
+			nFlags |= TF_VISION_FILTER_HALLOWEEN;
+		}
+
+		if ( test_romevision.GetBool() )
+		{
+			nFlags |= TF_VISION_FILTER_ROME;
+		}
+
+		if ( nFlags != 0 )
+		{
+			return nFlags;
+		}
+
+		if ( test_vision_off.GetBool() )
+		{
+			return 0x00;
+		}
+#endif
+		// Check the PyroVision Convar
+		if ( GetTeamNumber() == TEAM_SPECTATOR )
+		{
+			if ( tf_spectate_pyrovision.GetBool() ) 
+			{
+				nVisionOptInFlags |= TF_VISION_FILTER_PYRO;
+			}
+		}
+	}
+
+	// check for holidays and add them in to the mix
+	// Halloween / Fullmoon vision
+	if ( TFGameRules()->IsHolidayActive( kHoliday_HalloweenOrFullMoon ) )
+	{
+		nVisionOptInFlags |= TF_VISION_FILTER_HALLOWEEN;
+	}
+
+	// opt-in for romevision?
+	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && 
+		 TFSharedContentManager() && TFSharedContentManager()->IsSharedVisionAvailable( TF_VISION_FILTER_ROME ) && 
+		 tf_romevision_opt_in.GetBool() )
+	{
+		nVisionOptInFlags |= TF_VISION_FILTER_ROME;
+	}
+
+	return nVisionOptInFlags;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : updateType - 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CalculateVisionUsingCurrentFlags( void )
+{
+	if ( IsLocalPlayer() )
+	{
+		for( int iClient = 1; iClient <= gpGlobals->maxClients; ++iClient )
+		{
+			C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iClient ) );
+			if ( !pPlayer || !pPlayer->IsPlayer() )
+				continue;
+
+			if ( !pPlayer->IsAlive() )
+				continue;
+
+			pPlayer->UpdateWearables();
+			pPlayer->SetBodygroupsDirty();
+			if ( pPlayer->GetActiveWeapon() )
+			{
+				pPlayer->GetActiveWeapon()->RestartParticleEffect();
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CreateSaveMeEffect( MedicCallerType nType /*= CALLER_TYPE_NORMAL*/ )
+{
+	// Don't create them for the local player in first-person view.
+	if ( IsLocalPlayer() && InFirstPersonView() )
+		return;
+
+	if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
+		return;
+
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+	// If I'm disguised as the enemy, play to all players
+	if ( m_Shared.InCond( TF_COND_DISGUISED ) && m_Shared.GetDisguiseTeam() != GetTeamNumber() && !m_Shared.IsStealthed() )
+	{
+		// play to all players
+	}
+	else
+	{
+		// only play to teammates
+		if ( pLocalPlayer && pLocalPlayer->GetTeamNumber() != GetTeamNumber() )
+			return;
+	}
+
+	StopSaveMeEffect();
+
+	float flHealth = float( GetHealth() ) / float( GetMaxHealth() );
+	Vector vHealth;
+	vHealth.x = flHealth;
+	vHealth.y = flHealth;
+	vHealth.z = flHealth;
+
+	if ( nType == CALLER_TYPE_AUTO )
+	{
+		m_pSaveMeEffect = ParticleProp()->Create( "speech_mediccall_auto", PATTACH_POINT_FOLLOW, "head" );
+		EmitSound( "Medic.AutoCallerAnnounce" );
+	}
+	else
+	{
+		m_pSaveMeEffect = ParticleProp()->Create( "speech_mediccall", PATTACH_POINT_FOLLOW, "head" );
+	}
+
+	if ( m_pSaveMeEffect )
+	{
+		m_pSaveMeEffect->SetControlPoint( 1, vHealth );
+	}
+	
+	// If the local player is a medic, add this player to our list of medic callers
+	if ( pLocalPlayer && pLocalPlayer->IsPlayerClass( TF_CLASS_MEDIC ) && pLocalPlayer->IsAlive() == true )
+	{
+		Vector vecPos;
+		if ( GetAttachmentLocal( LookupAttachment( "head" ), vecPos ) )
+		{
+			vecPos += Vector(0,0,18);	// Particle effect is 18 units above the attachment
+			CTFMedicCallerPanel::AddMedicCaller( this, 5.0, vecPos, nType );
+		}
+	}
+
+	IGameEvent *event = gameeventmanager->CreateEvent( "player_calledformedic" );
+	if ( event )
+	{
+		event->SetInt( "userid", GetUserID() );
+		gameeventmanager->FireEventClientSide( event );
+	}
+
+	m_flSaveMeExpireTime = gpGlobals->curtime + 5.0f;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::StopSaveMeEffect( bool bForceRemoveInstantly /*= false*/ )
+{
+	if ( m_pSaveMeEffect )
+	{
+		if ( bForceRemoveInstantly )
+		{
+			ParticleProp()->StopEmissionAndDestroyImmediately( m_pSaveMeEffect );
+		}
+		else
+		{
+			ParticleProp()->StopEmission( m_pSaveMeEffect );
+		}
+		
+		m_pSaveMeEffect = NULL;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CreateTauntWithMeEffect()
+{
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( !pLocalPlayer || this == pLocalPlayer )
+		return;
+
+	if ( TFGameRules() && TFGameRules()->ShowMatchSummary() )
+		return;
+
+	if ( !m_pTauntWithMeEffect )
+	{
+		const char *pszImageName;
+		const char *pszParticleName;
+		if ( GetTeamNumber() != pLocalPlayer->GetTeamNumber() )
+		{
+			pszImageName = "../Effects/speech_taunt";
+			pszParticleName = "speech_taunt_all";
+		}
+		else if ( GetTeamNumber() == TF_TEAM_RED )
+		{
+			pszImageName = "../Effects/speech_taunt_red";
+			pszParticleName = "speech_taunt_red";
+		}
+		else
+		{
+			pszImageName = "../Effects/speech_taunt_blue";
+			pszParticleName = "speech_taunt_blue";
+		}
+		m_pTauntWithMeEffect = ParticleProp()->Create( pszParticleName, PATTACH_POINT_FOLLOW, "head" );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::StopTauntWithMeEffect()
+{
+	if ( m_pTauntWithMeEffect )
+	{
+		ParticleProp()->StopEmissionAndDestroyImmediately( m_pTauntWithMeEffect );		
+		m_pTauntWithMeEffect = NULL;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CreateKart()
+{
+	Assert( !m_pKart );
+
+	m_pKart = new C_BaseAnimating();
+	if ( m_pKart )
+	{
+		m_pKart->SetModel( "models/player/items/taunts/bumpercar/parts/bumpercar.mdl" );
+		m_pKart->m_nSkin = GetTeamNumber() == TF_TEAM_RED ? 0 : 1;
+
+		// Add to the client entity list. This has to be done before we attach to the parent or 
+		// else we won't wind up on their "also shadow these children" list.
+		ClientEntityList().AddNonNetworkableEntity(m_pKart);
+
+		m_pKart->FollowEntity(this, true);
+		m_pKart->CreateShadow();
+
+		TrackAngRotation( false );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::RemoveKart()
+{
+	StopKartEffect();
+
+	if ( m_pKart )
+	{
+		// Cleanup our shadows.
+		m_pKart->DestroyShadow();
+
+		// Remove from the client entity list.
+		ClientEntityList().RemoveEntity( m_pKart->GetClientHandle() );
+		m_pKart->Release();
+		m_pKart = NULL;
+
+		TrackAngRotation( true );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CreateKartEffect( const char *pszEffectName )
+{
+	if ( !m_pKart )
+		return;
+
+#ifdef DEBUG
+	for ( int i=0; i<ARRAYSIZE( m_pKartParticles ); ++i )
+	{
+		Assert( !m_pKartParticles[i] );
+	}
+#endif // DEBUG
+
+	m_pKartParticles[ KART_PARTICLE_LEFT_LIGHT ] = m_pKart->ParticleProp()->Create( pszEffectName , PATTACH_POINT_FOLLOW, "bumpercar_wheel_left" );
+	m_pKartParticles[ KART_PARTICLE_RIGHT_LIGHT ] = m_pKart->ParticleProp()->Create( pszEffectName , PATTACH_POINT_FOLLOW, "bumpercar_wheel_right" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::StopKartEffect()
+{
+	if ( !m_pKart )
+		return;
+
+	for ( int i=0; i<ARRAYSIZE( m_pKartParticles ); ++i )
+	{
+		if ( m_pKartParticles[i] )
+		{
+			m_pKart->ParticleProp()->StopEmission( m_pKartParticles[i] );
+			m_pKartParticles[i] = NULL;
+		}
+	}
+}
+//-----------------------------------------------------------------------------
+void C_TFPlayer::StartKartBrakeEffect()
+{
+	if ( !m_pKart )
+		return;
+
+	if ( !m_pKartParticles[KART_PARTICLE_LEFT_WHEEL] )
+	{
+		m_pKartParticles[KART_PARTICLE_LEFT_WHEEL] = m_pKart->ParticleProp()->Create( "kart_braking_sparks" , PATTACH_POINT_FOLLOW, "left_rear_wheel" );
+	}
+
+	if ( !m_pKartParticles[KART_PARTICLE_RIGHT_WHEEL] )
+	{
+		m_pKartParticles[KART_PARTICLE_RIGHT_WHEEL] = m_pKart->ParticleProp()->Create( "kart_braking_sparks", PATTACH_POINT_FOLLOW, "right_rear_wheel" );
+	}
+}
+//-----------------------------------------------------------------------------
+void C_TFPlayer::StopKartBrakeEffect() 
+{
+	if ( !m_pKart )
+		return;
+
+	if ( m_pKartParticles[KART_PARTICLE_LEFT_WHEEL] )
+	{
+		m_pKart->ParticleProp()->StopEmission( m_pKartParticles[KART_PARTICLE_LEFT_WHEEL] );
+	}
+
+	if ( m_pKartParticles[KART_PARTICLE_RIGHT_WHEEL] )
+	{
+		m_pKart->ParticleProp()->StopEmission( m_pKartParticles[KART_PARTICLE_RIGHT_WHEEL] );
+	}
+
+}
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::IsOverridingViewmodel( void )
+{
+	C_TFPlayer *pPlayer = this;
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( pLocalPlayer && pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE && 
+		 pLocalPlayer->GetObserverTarget() && pLocalPlayer->GetObserverTarget()->IsPlayer() )
+	{
+		pPlayer = assert_cast<C_TFPlayer*>(pLocalPlayer->GetObserverTarget());
+	}
+
+	if ( pPlayer->m_Shared.IsInvulnerable() )
+		return true;
+
+	return BaseClass::IsOverridingViewmodel();
+}
+
+void C_TFPlayer::OverrideView( CViewSetup *pSetup )
+{
+	BaseClass::OverrideView( pSetup );
+
+	TFPlayerClassData_t *pData = GetPlayerClass()->GetData();
+
+	if ( pData  && g_ThirdPersonManager.WantToUseGameThirdPerson() )
+	{
+		Vector vecOffset = pData->m_vecThirdPersonOffset;
+
+		g_ThirdPersonManager.SetDesiredCameraOffset( vecOffset );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Draw my viewmodel in some special way
+//-----------------------------------------------------------------------------
+int	C_TFPlayer::DrawOverriddenViewmodel( C_BaseViewModel *pViewmodel, int flags )
+{
+	int ret = 0;
+
+	C_TFPlayer *pPlayer = this;
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( pLocalPlayer && pLocalPlayer->GetObserverMode() == OBS_MODE_IN_EYE && 
+		pLocalPlayer->GetObserverTarget() && pLocalPlayer->GetObserverTarget()->IsPlayer() )
+	{
+		pPlayer = assert_cast<C_TFPlayer*>(pLocalPlayer->GetObserverTarget());
+	}
+
+	if ( pPlayer->m_Shared.IsInvulnerable() )
+	{
+		if ( flags & STUDIO_RENDER )
+		{
+			// Force the invulnerable material
+			modelrender->ForcedMaterialOverride( *pPlayer->GetInvulnMaterialRef() );
+		}
+
+		// We allow our weapon to then override this if it wants to.
+		// This allows c_* weapons to draw themselves.
+		C_BaseCombatWeapon *pWeapon = pViewmodel->GetOwningWeapon();
+		if ( pWeapon && pWeapon->IsOverridingViewmodel() )
+		{
+			ret = pWeapon->DrawOverriddenViewmodel( pViewmodel, flags );
+		}
+		else
+		{
+			ret = pViewmodel->DrawOverriddenViewmodel( flags );
+		}
+
+		if ( flags & STUDIO_RENDER )
+		{
+			modelrender->ForcedMaterialOverride( NULL );
+		}
+	}
+
+	return ret;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ApplyBoneMatrixTransform( matrix3x4_t& transform )
+{
+	BaseClass::ApplyBoneMatrixTransform ( transform );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void BuildBigHeadTransformations( CBaseAnimating *pObject, CStudioHdr *hdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed, float flScale )
+{
+	if ( !pObject || flScale == 1.f )
+		return;
+
+	// Scale the head.
+	int iHeadBone = pObject->LookupBone( "bip_head" );
+	if ( iHeadBone == -1 )
+		return;
+
+	matrix3x4_t  &transform = pObject->GetBoneForWrite( iHeadBone );
+	Vector head_position;
+	MatrixGetTranslation( transform, head_position );
+
+	// Scale the head.
+	MatrixScaleBy ( flScale, transform );
+
+	const int cMaxNumHelms = 2;
+	int iHelmIndex[cMaxNumHelms];
+	iHelmIndex[0] = pObject->LookupBone( "prp_helmet" );
+	iHelmIndex[1] = pObject->LookupBone( "prp_hat" );
+
+	for ( int i = 0; i < cMaxNumHelms; i++ )
+	{
+		if ( iHelmIndex[i] != -1 )
+		{
+			matrix3x4_t &transformhelmet = pObject->GetBoneForWrite( iHelmIndex[i] );
+			MatrixScaleBy ( flScale, transformhelmet );
+
+			Vector helmet_position;
+			MatrixGetTranslation( transformhelmet, helmet_position );
+			Vector offset = helmet_position - head_position;
+			MatrixSetTranslation ( ( offset * flScale ) + head_position, transformhelmet );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void BuildDecapitatedTransformations( CBaseAnimating *pObject, CStudioHdr *hdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed )
+{
+	if ( !pObject )
+		return;
+
+	// Scale the head to nothing.
+	int iHeadBone = pObject->LookupBone( "bip_head" );
+	if ( iHeadBone != -1 )
+	{	
+		matrix3x4_t  &transform = pObject->GetBoneForWrite( iHeadBone );
+		MatrixScaleByZero ( transform );
+	}
+
+	int iHelm = pObject->LookupBone( "prp_helmet" );
+	if ( iHelm != -1 )
+	{
+		// Scale the helmet.
+		matrix3x4_t  &transformhelmet = pObject->GetBoneForWrite( iHelm );
+		MatrixScaleByZero ( transformhelmet );
+	}
+
+	iHelm = pObject->LookupBone( "prp_hat" );
+	if ( iHelm != -1 )
+	{
+		matrix3x4_t  &transformhelmet = pObject->GetBoneForWrite( iHelm );
+		MatrixScaleByZero ( transformhelmet );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void BuildNeckScaleTransformations( CBaseAnimating *pObject, CStudioHdr *hdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed, float flScale, int iClass )
+{
+	if ( !pObject || flScale == 1.f )
+		return;
+
+	int iNeck = pObject->LookupBone( "bip_neck" );
+	if ( iNeck == -1 )
+		return;
+
+	matrix3x4_t &neck_transform = pObject->GetBoneForWrite( iNeck );
+
+	Vector spine_position, neck_position, head_position, position, offset(0, 0, 0);
+	if ( iClass != TF_CLASS_HEAVYWEAPONS )
+	{
+		// Compress the neck into the spine.
+		int iSpine = pObject->LookupBone( "bip_spine_3" );
+		if ( iSpine != -1 )
+		{
+			matrix3x4_t &spine_transform = pObject->GetBoneForWrite( iSpine );
+			MatrixPosition( spine_transform, spine_position );
+			MatrixPosition( neck_transform, neck_position );
+			position = flScale * ( neck_position - spine_position );
+			MatrixSetTranslation( spine_position + position, neck_transform );
+		}
+	}
+
+	if ( iClass == TF_CLASS_SPY )
+	{
+		int iCig = pObject->LookupBone( "prp_cig" );
+		if ( iCig != -1 )
+		{
+			matrix3x4_t  &cig_transform = pObject->GetBoneForWrite( iCig );
+			MatrixScaleByZero ( cig_transform );
+		}
+	}
+
+	// Compress the head into the neck.
+	int iHead = pObject->LookupBone( "bip_head" );
+	if ( iHead != -1 )
+	{
+		matrix3x4_t  &head_transform = pObject->GetBoneForWrite( iHead );
+		MatrixPosition( head_transform, head_position );
+		MatrixPosition( neck_transform, neck_position );
+		offset = head_position - neck_position;
+		MatrixSetTranslation( neck_position, head_transform );
+	}
+
+	// Store helmet bone offset.
+	int iHelm = pObject->LookupBone( "prp_helmet" );
+	if ( iHelm != -1 ) 
+	{
+		matrix3x4_t  &helmet_transform = pObject->GetBoneForWrite( iHelm );
+		MatrixPosition( helmet_transform, position );
+		MatrixSetTranslation( position - offset, helmet_transform );
+	}
+
+	// Store alternate helmet bone offset.
+	iHelm = pObject->LookupBone( "prp_hat" );
+	if ( iHelm != -1 )
+	{
+		matrix3x4_t  &hat_transform = pObject->GetBoneForWrite( iHelm );
+		MatrixPosition( hat_transform, position );
+		MatrixSetTranslation( position - offset, hat_transform );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Get child bones from a specified bone index
+//-----------------------------------------------------------------------------
+void AppendChildren_R( CUtlVector< const mstudiobone_t * > *pChildBones, const studiohdr_t *pHdr, int nBone )
+{
+	if ( !pChildBones || !pHdr )
+		return;
+
+    // Child bones have to have a larger bone index than their parent, so start searching from nBone + 1
+    for ( int i = nBone + 1; i < pHdr->numbones; ++i )
+    {
+        const mstudiobone_t *pBone = pHdr->pBone( i );
+        if ( pBone->parent == nBone )
+        {
+            pChildBones->AddToTail( pBone );
+            // If you just want immediate children don't recurse, this will do a depth first traversal, could do
+			// breadth first by adding all children first and then looping through the added bones and recursing
+            AppendChildren_R( pChildBones, pHdr, i );
+        }
+    }
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void BuildTorsoScaleTransformations( CBaseAnimating *pObject, CStudioHdr *hdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed, float flScale, int iClass )
+{
+	if ( !pObject || flScale == 1.f )
+		return;
+
+	int iPelvis = pObject->LookupBone( "bip_pelvis" );
+	if ( iPelvis == -1 )
+		return;
+
+	const studiohdr_t *pHdr = modelinfo->GetStudiomodel( pObject->GetModel() );
+
+	int iTargetBone = iPelvis;
+
+	// must be in this order
+	static const char *s_torsoBoneNames[] =
+	{
+		"bip_spine_0",
+		"bip_spine_1",
+		"bip_spine_2",
+		"bip_spine_3",
+		"bip_neck"
+	};
+
+	// Compress torso bones toward pelvis in order.
+	for ( int i=0; i<ARRAYSIZE( s_torsoBoneNames ); ++i )
+	{
+		int iMoveBone = pObject->LookupBone( s_torsoBoneNames[i] );
+		if ( iMoveBone == -1 )
+		{
+			return;
+		}
+
+		const matrix3x4_t &targetBone_transform = pObject->GetBone( iTargetBone );
+		Vector vTargetBonePos;
+		MatrixPosition( targetBone_transform, vTargetBonePos );
+
+		matrix3x4_t &moveBone_transform = pObject->GetBoneForWrite( iMoveBone );
+		Vector vMoveBonePos;
+		MatrixPosition( moveBone_transform, vMoveBonePos );
+		Vector vNewMovePos = vTargetBonePos + flScale * ( vMoveBonePos - vTargetBonePos );
+		MatrixSetTranslation( vNewMovePos, moveBone_transform );
+
+		iTargetBone = iMoveBone;
+
+		Vector vOffset = vNewMovePos - vMoveBonePos;
+
+		// apply to all its child bones
+		CUtlVector< const mstudiobone_t * > vecChildBones;
+		AppendChildren_R( &vecChildBones, pHdr, iMoveBone );
+		for ( int j=0; j<vecChildBones.Count(); ++j )
+		{
+			int iChildBone = pObject->LookupBone( vecChildBones[j]->pszName() );
+			if ( iChildBone == -1 )
+				continue;
+
+			matrix3x4_t &childBone_transform = pObject->GetBoneForWrite( iChildBone );
+			Vector vChildPos;
+			MatrixPosition( childBone_transform, vChildPos );
+			MatrixSetTranslation( vChildPos + vOffset, childBone_transform );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void BuildHandScaleTransformations( CBaseAnimating *pObject, CStudioHdr *hdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed, float flScale )
+{
+	if ( !pObject || flScale == 1.f )
+		return;
+
+	const studiohdr_t *pHdr = modelinfo->GetStudiomodel( pObject->GetModel() );
+
+	// must be in this order
+	static const char *s_handBoneNames[] =
+	{
+		"bip_hand_L",
+		"bip_hand_R"
+	};
+
+	// scale hand bones
+	for ( int i=0; i<ARRAYSIZE( s_handBoneNames ); ++i )
+	{
+		int iHand = pObject->LookupBone( s_handBoneNames[i] );
+		if ( iHand == -1 )
+		{
+			continue;
+		}
+
+		matrix3x4_t& transform = pObject->GetBoneForWrite( iHand );
+		MatrixScaleBy( flScale, transform );
+
+		// apply to all its child bones
+		CUtlVector< const mstudiobone_t * > vecChildBones;
+		AppendChildren_R( &vecChildBones, pHdr, iHand );
+		for ( int j=0; j<vecChildBones.Count(); ++j )
+		{
+			int iChildBone = pObject->LookupBone( vecChildBones[j]->pszName() );
+			if ( iChildBone == -1 )
+				continue;
+
+			matrix3x4_t &childBone_transform = pObject->GetBoneForWrite( iChildBone );
+			MatrixScaleBy( flScale, childBone_transform );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::BuildTransformations( CStudioHdr *hdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed )
+{
+	BaseClass::BuildTransformations( hdr, pos, q, cameraTransform, boneMask, boneComputed );
+
+	if ( GetGroundEntity() == NULL )
+	{
+		Vector hullSizeNormal = VEC_HULL_MAX_SCALED( this ) - VEC_HULL_MIN_SCALED( this );
+		Vector hullSizeCrouch = VEC_DUCK_HULL_MAX_SCALED( this ) - VEC_DUCK_HULL_MIN_SCALED( this );
+		Vector duckOffset = ( hullSizeNormal - hullSizeCrouch );
+
+		// The player is in the air.
+		if ( GetFlags() & FL_DUCKING )
+		{
+			if ( !m_bDuckJumpInterp )
+			{
+				m_flFirstDuckJumpInterp = gpGlobals->curtime;
+			}
+			m_bDuckJumpInterp = true;
+			m_flLastDuckJumpInterp = gpGlobals->curtime;
+
+			float flRatio = MIN( 0.15f, gpGlobals->curtime - m_flFirstDuckJumpInterp ) / 0.15f;
+			m_flDuckJumpInterp = 1.f - flRatio;
+		}
+		else if ( m_bDuckJumpInterp )
+		{
+			float flRatio = MIN( 0.15f, gpGlobals->curtime - m_flLastDuckJumpInterp ) / 0.15f;
+			m_flDuckJumpInterp = -(1.f - flRatio);
+			if ( m_flDuckJumpInterp == 0.f )
+			{
+				// Turn off interpolation when we return to our normal, unducked location.
+				m_bDuckJumpInterp = false;
+			}
+		}
+
+		if ( m_bDuckJumpInterp && m_flDuckJumpInterp != 0.f )
+		{
+			duckOffset *= m_flDuckJumpInterp;
+			for (int i = 0; i < hdr->numbones(); i++) 
+			{
+				if ( !( hdr->boneFlags( i ) & boneMask ) )
+					continue;
+
+				matrix3x4_t &transform = GetBoneForWrite( i );
+				Vector bone_pos;
+				MatrixGetTranslation( transform, bone_pos );
+				MatrixSetTranslation( bone_pos - duckOffset, transform );
+			}
+		}
+	}
+	else if ( m_bDuckJumpInterp )
+	{
+		m_bDuckJumpInterp = false;
+	}
+
+	m_BoneAccessor.SetWritableBones( BONE_USED_BY_ANYTHING );
+	float flHeadScale = m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) ? 1.5 : m_flHeadScale;
+	BuildBigHeadTransformations( this, hdr, pos, q, cameraTransform, boneMask, boneComputed, flHeadScale );
+	BuildTorsoScaleTransformations( this, hdr, pos, q, cameraTransform, boneMask, boneComputed, m_flTorsoScale, GetPlayerClass()->GetClassIndex() );
+	BuildHandScaleTransformations( this, hdr, pos, q, cameraTransform, boneMask, boneComputed, m_flHandScale );
+
+	BuildFirstPersonMeathookTransformations( hdr, pos, q, cameraTransform, boneMask, boneComputed, "bip_head" );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFRagdoll::BuildTransformations( CStudioHdr *hdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed )
+{
+	BaseClass::BuildTransformations( hdr, pos, q, cameraTransform, boneMask, boneComputed );
+
+	m_BoneAccessor.SetWritableBones( BONE_USED_BY_ANYTHING );
+	BuildBigHeadTransformations( this, hdr, pos, q, cameraTransform, boneMask, boneComputed, m_flHeadScale );
+	BuildTorsoScaleTransformations( this, hdr, pos, q, cameraTransform, boneMask, boneComputed, m_flTorsoScale, GetClass() );
+	BuildHandScaleTransformations( this, hdr, pos, q, cameraTransform, boneMask, boneComputed, m_flHandScale );
+
+	if ( IsDecapitation() && !m_bBaseTransform )
+	{
+		m_BoneAccessor.SetWritableBones( BONE_USED_BY_ANYTHING );
+		BuildDecapitatedTransformations( this, hdr, pos, q, cameraTransform, boneMask, boneComputed );
+	}
+
+	if ( IsHeadSmash() && !m_bBaseTransform )
+	{
+		m_BoneAccessor.SetWritableBones( BONE_USED_BY_ANYTHING );
+		BuildNeckScaleTransformations( this, hdr, pos, q, cameraTransform, boneMask, boneComputed, 0.5f, GetClass() );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::SetHealer( C_TFPlayer *pHealer, float flChargeLevel )
+{
+	if ( pHealer && IsPlayerClass( TF_CLASS_SPY ) )
+	{
+		IGameEvent *event = gameeventmanager->CreateEvent( "player_healedbymedic" );
+
+		if ( event )
+		{
+			event->SetInt( "medic", pHealer->entindex() );
+			gameeventmanager->FireEventClientSide( event );
+		}
+	}
+
+
+	// We may be getting healed by multiple healers. Show the healer
+	// who's got the highest charge level.
+	if ( m_hHealer )
+	{
+		if ( m_flHealerChargeLevel > flChargeLevel )
+			return;
+	}
+
+	m_hHealer = pHealer;
+	m_flHealerChargeLevel = flChargeLevel;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::MedicIsReleasingCharge( void )
+{
+	if ( IsPlayerClass(TF_CLASS_MEDIC) )
+	{
+		CTFWeaponBase *pWpn = GetActiveTFWeapon();
+
+		if ( pWpn == NULL )
+			return false;
+
+		CWeaponMedigun *pMedigun = dynamic_cast <CWeaponMedigun*>( pWpn );
+
+		if ( pMedigun )
+			return pMedigun->IsReleasingCharge();
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::CanShowClassMenu( void )
+{
+	if ( IsHLTV() )
+		return false;
+		
+	if( TFGameRules()  )
+	{
+		if ( TFGameRules()->IsInArenaMode() == true && tf_arena_use_queue.GetBool() == true )
+		{
+			return !m_bArenaSpectator;
+		}
+
+		// Dont allow the change class menu to come up when we're doing the doors and things.  There's really weird
+		// sorting issues that go on even though the class menu is supposed to draw under the match status panel.
+		if ( TFGameRules()->IsCompetitiveMode() )
+		{
+			float flRestartTime = TFGameRules()->GetRoundRestartTime() - gpGlobals->curtime;
+			if ( flRestartTime > 0.f && flRestartTime < 10.f )
+			{
+				return false;
+			}
+		}
+	}
+	
+	return ( GetTeamNumber() > LAST_SHARED_TEAM );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::CanShowTeamMenu( void )
+{
+	if ( IsHLTV() )
+		return false;
+
+#ifdef STAGING_ONLY
+	if ( TFGameRules() && TFGameRules()->IsCompetitiveMode() )
+#else
+	if ( TFGameRules() && ( TFGameRules()->IsCompetitiveMode() || TFGameRules()->IsPowerupMode() ) )
+#endif // STAGING_ONLY
+	
+		return false;
+
+	return ( GetTeamNumber() != TEAM_UNASSIGNED );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::InitializePoseParams( void )
+{
+	/*
+	m_headYawPoseParam = LookupPoseParameter( "head_yaw" );
+	GetPoseParameterRange( m_headYawPoseParam, m_headYawMin, m_headYawMax );
+
+	m_headPitchPoseParam = LookupPoseParameter( "head_pitch" );
+	GetPoseParameterRange( m_headPitchPoseParam, m_headPitchMin, m_headPitchMax );
+	*/
+
+	CStudioHdr *hdr = GetModelPtr();
+	Assert( hdr );
+	if ( !hdr )
+		return;
+
+	for ( int i = 0; i < hdr->GetNumPoseParameters() ; i++ )
+	{
+		SetPoseParameter( hdr, i, 0.0 );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+Vector C_TFPlayer::GetChaseCamViewOffset( CBaseEntity *target )
+{
+	if ( target->IsBaseObject() )
+	{
+		CBaseObject* pObj = dynamic_cast<CBaseObject*>( target );
+		if ( pObj && pObj->IsMiniBuilding() )
+			return Vector(0,0,40);
+		else
+			return Vector(0,0,64);
+	}
+
+	return BaseClass::GetChaseCamViewOffset( target );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called from PostDataUpdate to update the model index
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ValidateModelIndex( void )
+{
+	if ( m_Shared.InCond( TF_COND_DISGUISED_AS_DISPENSER ) && IsEnemyPlayer() && ( GetFlags() & FL_DUCKING ) && ( GetGroundEntity() != NULL ) )
+	{
+		m_nModelIndex = modelinfo->GetModelIndex( "models/buildables/dispenser_light.mdl" );
+
+		if ( C_BasePlayer::GetLocalPlayer() != this )
+		{
+			SetAbsAngles( vec3_angle );
+		}
+	}
+	else if ( m_Shared.InCond( TF_COND_DISGUISED ) && IsEnemyPlayer() )
+	{
+		TFPlayerClassData_t *pData = GetPlayerClassData( m_Shared.GetDisguiseClass() );
+		m_nModelIndex = modelinfo->GetModelIndex( pData->GetModelName() );
+	}
+	else if ( m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
+	{
+		if ( GetTeamNumber() == TF_TEAM_BLUE )
+		{
+			m_nModelIndex = modelinfo->GetModelIndex( "models/props_halloween/ghost_no_hat.mdl" );
+		}
+		else
+		{
+			m_nModelIndex = modelinfo->GetModelIndex( "models/props_halloween/ghost_no_hat_red.mdl" );
+		}
+	}
+	else
+	{
+		C_TFPlayerClass *pClass = GetPlayerClass();
+		if ( pClass )
+		{
+			m_nModelIndex = modelinfo->GetModelIndex( pClass->GetModelName() );
+		}
+	}
+
+	if ( m_iSpyMaskBodygroup > -1 && GetModelPtr() != NULL && IsPlayerClass( TF_CLASS_SPY ) )
+	{
+		if ( m_Shared.InCond( TF_COND_DISGUISED ) || m_Shared.InCond( TF_COND_DISGUISED_AS_DISPENSER ) )
+		{
+			if ( !IsEnemyPlayer() || (m_Shared.GetDisguiseClass() == TF_CLASS_SPY) )
+			{
+				SetBodygroup( m_iSpyMaskBodygroup, 1 );
+			}
+		}
+		else
+		{
+			SetBodygroup( m_iSpyMaskBodygroup, 0 );
+		}
+	}
+
+	BaseClass::ValidateModelIndex();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Simulate the player for this frame
+//-----------------------------------------------------------------------------
+void C_TFPlayer::Simulate( void )
+{
+	//Frame updates
+	if ( this == C_BasePlayer::GetLocalPlayer() )
+	{
+		//Update the flashlight
+		Flashlight();
+	}
+
+	// TF doesn't do step sounds based on velocity, instead using anim events
+	// So we deliberately skip over the base player simulate, which calls them.
+	BaseClass::BaseClass::Simulate();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+#define PLAYER_HALFWIDTH	 10
+#define SURFACE_SNOW		 91
+void C_TFPlayer::FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options )
+{
+	if ( event == 7001 )
+	{
+		// Force a footstep sound
+		m_flStepSoundTime = 0;
+		Vector vel;
+		EstimateAbsVelocity( vel );
+		surfacedata_t *t_pSurface = GetGroundSurface();
+		UpdateStepSound( t_pSurface, GetAbsOrigin(), vel );
+		
+		if ( t_pSurface && !this->m_Shared.IsStealthed() && !this->m_Shared.InCond( TF_COND_DISGUISED ) && ( ( vel.x < -150 || vel.x > 150 ) || ( vel.y < -150 || vel.y > 150 ) ) )
+		{
+			// check for snow underfoot and trigger particle and decal fx
+			if ( t_pSurface->game.material == SURFACE_SNOW )
+			{
+				ParticleProp()->Create("snow_steppuff01", PATTACH_ABSORIGIN, 0 );
+				Vector right;
+				AngleVectors( angles, 0, &right, 0 );
+
+				// Figure out where the top of the stepping leg is 
+				trace_t tr;
+				Vector hipOrigin;
+ 				VectorMA( origin, m_IsFootprintOnLeft ? -PLAYER_HALFWIDTH : PLAYER_HALFWIDTH, right, hipOrigin );
+
+				// Find where that leg hits the ground
+				UTIL_TraceLine( hipOrigin, hipOrigin + Vector(0, 0, -COORD_EXTENT * 1.74), 
+					MASK_SOLID_BRUSHONLY, NULL, COLLISION_GROUP_NONE, &tr);
+
+				// Create the decal
+				CPVSFilter filter( tr.endpos );
+				UTIL_DecalTrace( &tr, m_IsFootprintOnLeft ? "footprintL_snow" : "footprintR_snow" );
+
+				m_IsFootprintOnLeft = !m_IsFootprintOnLeft;
+			}
+
+			// Halloween-specific bonus footsteps
+			int iHalloweenFootstepType = 0;
+			if ( TF_IsHolidayActive( kHoliday_HalloweenOrFullMoon ) )
+			{
+				CALL_ATTRIB_HOOK_INT( iHalloweenFootstepType, halloween_footstep_type );
+			}
+
+			if ( m_nFootStamps > 0 )
+			{
+				// White stamps!
+				iHalloweenFootstepType = 0xFFFFFFFF;
+			}
+
+			if ( iHalloweenFootstepType != 0 )
+			{
+				SpawnHalloweenSpellFootsteps( PATTACH_ABSORIGIN, iHalloweenFootstepType );
+			}
+
+			if ( m_nFootStamps > 0 )
+			{
+				m_nFootStamps--;
+			}
+		}
+	}
+	else if ( event == AE_WPN_HIDE )
+	{
+		if ( GetActiveWeapon() )
+		{
+			int iDisableWeaponHidingForAnimations = 0;
+			CALL_ATTRIB_HOOK_INT_ON_OTHER( GetActiveWeapon(), iDisableWeaponHidingForAnimations, disable_weapon_hiding_for_animations );
+			if ( iDisableWeaponHidingForAnimations == 0 )
+			{
+				GetActiveWeapon()->SetWeaponVisible( false );
+			}
+		}
+	}
+	else if ( event == AE_WPN_UNHIDE )
+	{
+		if ( m_Shared.IsControlStunned() )
+			return;
+
+		if ( GetActiveWeapon() )
+		{
+			GetActiveWeapon()->SetWeaponVisible( true );
+		}
+	}
+	else if ( event == AE_WPN_PLAYWPNSOUND )
+	{
+		if ( GetActiveWeapon() )
+		{
+			int iSnd = GetWeaponSoundFromString(options);
+			if ( iSnd != -1 )
+			{
+				GetActiveWeapon()->WeaponSound( (WeaponSound_t)iSnd );
+			}
+		}
+	}
+	else if ( event == TF_AE_CIGARETTE_THROW )
+	{
+		CEffectData data;
+		int iAttach = LookupAttachment( options );
+		GetAttachment( iAttach, data.m_vOrigin, data.m_vAngles );
+
+		data.m_vAngles = GetRenderAngles();
+
+		data.m_hEntity = ClientEntityList().EntIndexToHandle( entindex() );
+		DispatchEffect( "TF_ThrowCigarette", data );
+		return;
+	}
+	else if ( event == AE_CL_BODYGROUP_SET_VALUE_CMODEL_WPN )
+	{
+		CTFWeaponBase *pWpn = GetActiveTFWeapon();
+		if ( pWpn )
+		{
+			pWpn->GetAppropriateWorldOrViewModel()->FireEvent( origin, angles, AE_CL_BODYGROUP_SET_VALUE, options );
+		}
+	}
+	else if ( event == AE_TAUNT_ENABLE_MOVE )
+	{
+		m_bAllowMoveDuringTaunt = true;
+	}
+	else if ( event == AE_TAUNT_DISABLE_MOVE )
+	{
+		m_bAllowMoveDuringTaunt = false;
+	}
+	else
+		BaseClass::FireEvent( origin, angles, event, options );
+}
+
+
+void C_TFPlayer::UpdateStepSound( surfacedata_t *psurface, const Vector &vecOrigin, const Vector &vecVelocity )
+{
+	// don't play footstep sound while in kart
+	if ( m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
+	{
+		return;
+	}
+
+	// don't play footstep sound while taunting
+	if ( IsTaunting() )
+	{
+		return;
+	}
+
+	BaseClass::UpdateStepSound( psurface, vecOrigin, vecVelocity );
+}
+
+
+CNewParticleEffect *C_TFPlayer::SpawnHalloweenSpellFootsteps( ParticleAttachment_t eParticleAttachment, int iHalloweenFootstepType )
+{
+	enum EPileOfHalloweenConstantHacks
+	{ 
+		kHalloweenSpell_RGBConstant_HHH			= 2,
+		kHalloweenSpell_RGBConstant_TeamColor	= 1,
+		kHalloweenSpell_RGB_Red					= 12073019,
+		kHalloweenSpell_RGB_Blue				= 5801378,
+	};
+
+	if ( iHalloweenFootstepType == kHalloweenSpell_RGBConstant_HHH )
+		return ParticleProp()->Create( "halloween_boss_foot_impact", eParticleAttachment, 0 );
+
+	CNewParticleEffect *pEffect = ParticleProp()->Create( m_nFootStamps ? "foot_stamp" : "halloween_boss_foot_impact_customcolor", eParticleAttachment, 0 );
+	if ( pEffect )
+	{
+		const int iRGB = iHalloweenFootstepType != kHalloweenSpell_RGBConstant_TeamColor		// special "use team-color" hack value
+			? iHalloweenFootstepType													// use the attribute value as the RGB
+			: GetTeamNumber() == TF_TEAM_BLUE							// which team are we on?
+			? kHalloweenSpell_RGB_Blue
+			: kHalloweenSpell_RGB_Red;
+
+		pEffect->SetControlPoint( 1, Vector( ((iRGB & 0xff0000) >> 16) / 255.0f, ((iRGB & 0xff00) >> 8) / 255.0f, (iRGB & 0xff) / 255.0f ) );
+	}
+
+	return pEffect;
+}
+
+// Shadows
+
+ConVar cl_blobbyshadows( "cl_blobbyshadows", "0", FCVAR_CLIENTDLL );
+ShadowType_t C_TFPlayer::ShadowCastType( void ) 
+{
+	// Removed the GetPercentInvisible - should be taken care off in BindProxy now.
+	if ( !IsVisible() /*|| GetPercentInvisible() > 0.0f*/ )
+		return SHADOWS_NONE;
+
+	if ( IsEffectActive(EF_NODRAW | EF_NOSHADOW) )
+		return SHADOWS_NONE;
+
+	// If in ragdoll mode.
+	if ( m_nRenderFX == kRenderFxRagdoll )
+		return SHADOWS_NONE;
+
+	if ( !ShouldDrawThisPlayer() )
+	{
+		// First-person with viewmodels.
+		return SHADOWS_NONE;
+	}
+
+	if ( cl_blobbyshadows.GetBool() )
+		return SHADOWS_SIMPLE;
+
+	return SHADOWS_RENDER_TO_TEXTURE_DYNAMIC;
+}
+
+float g_flFattenAmt = 24.0;		// Roughly how far out the Heavy's minigun pokes out.
+void C_TFPlayer::GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType )
+{
+	if ( shadowType == SHADOWS_SIMPLE )
+	{
+		// Don't let the render bounds change when we're using blobby shadows, or else the shadow
+		// will pop and stretch.
+		mins = CollisionProp()->OBBMins();
+		maxs = CollisionProp()->OBBMaxs();
+	}
+	else
+	{
+		GetRenderBounds( mins, maxs );
+
+		// We do this because the normal bbox calculations don't take pose params into account, and 
+		// the rotation of the guy's upper torso can place his gun a ways out of his bbox, and 
+		// the shadow will get cut off as he rotates.
+		//
+		// Thus, we give it some padding here.
+		g_flFattenAmt = 36.0f;
+		mins -= Vector( g_flFattenAmt, g_flFattenAmt, 0 );
+		maxs += Vector( g_flFattenAmt, g_flFattenAmt, 0 );
+	}
+}
+
+
+void C_TFPlayer::GetRenderBounds( Vector& theMins, Vector& theMaxs )
+{
+	// TODO POSTSHIP - this hack/fix goes hand-in-hand with a fix in CalcSequenceBoundingBoxes in utils/studiomdl/simplify.cpp.
+	// When we enable the fix in CalcSequenceBoundingBoxes, we can get rid of this.
+	//
+	// What we're doing right here is making sure it only uses the bbox for our lower-body sequences since,
+	// with the current animations and the bug in CalcSequenceBoundingBoxes, are WAY bigger than they need to be.
+	C_BaseAnimating::GetRenderBounds( theMins, theMaxs );
+}
+
+
+bool C_TFPlayer::GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const
+{ 
+	if ( shadowType == SHADOWS_SIMPLE )
+	{
+		// Blobby shadows should sit directly underneath us.
+		pDirection->Init( 0, 0, -1 );
+		return true;
+	}
+	else
+	{
+		return BaseClass::GetShadowCastDirection( pDirection, shadowType );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether this player is the nemesis of the local player
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::IsNemesisOfLocalPlayer()
+{
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( pLocalPlayer )
+	{
+		// return whether this player is dominating the local player
+		return m_Shared.IsPlayerDominated( pLocalPlayer->entindex() );
+	}		
+	return false;
+}
+
+extern ConVar tf_tournament_hide_domination_icons;
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether we should show the dueling icon for this player
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::ShouldShowDuelingIcon()
+{
+	if ( TFGameRules() && TFGameRules()->IsInTournamentMode() && tf_tournament_hide_domination_icons.GetBool() )
+		return false;
+
+	if ( m_PlayerClass.HasCustomModel() )
+		return false;
+
+	extern bool DuelMiniGame_IsDuelingLocalPlayer( C_TFPlayer *pPlayer );
+
+	// we should show the dueling effect on this player if he is dueling the local player,
+	// and is not dead, cloaked or disguised
+	if ( DuelMiniGame_IsDuelingLocalPlayer( this ) && g_PR && g_PR->IsConnected( entindex() ) )
+	{
+		bool bStealthed = m_Shared.IsStealthed();
+		bool bDisguised = m_Shared.InCond( TF_COND_DISGUISED );
+		if ( IsAlive() && !bStealthed && !bDisguised )
+			return true;
+	}
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Returns whether we should show the nemesis icon for this player
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::ShouldShowNemesisIcon()
+{
+	if ( TFGameRules() && TFGameRules()->IsInTournamentMode() && tf_tournament_hide_domination_icons.GetBool() )
+		return false;
+
+	if ( m_PlayerClass.HasCustomModel() )
+		return false;
+
+	// we should show the nemesis effect on this player if he is the nemesis of the local player,
+	// and is not dead, cloaked or disguised
+	if ( IsNemesisOfLocalPlayer() && g_PR && g_PR->IsConnected( entindex() ) )
+	{
+		bool bStealthed = m_Shared.IsStealthed();
+		bool bDisguised = m_Shared.InCond( TF_COND_DISGUISED );
+		if ( IsAlive() && !bStealthed && !bDisguised )
+			return true;
+	}
+
+	return false;
+}
+
+bool C_TFPlayer::IsWeaponLowered( void )
+{
+	CTFWeaponBase *pWeapon = GetActiveTFWeapon();
+
+	if ( !pWeapon )
+		return false;
+
+	CTFGameRules *pRules = TFGameRules();
+
+	// Lower losing team's weapons in bonus round
+	if ( ( pRules->State_Get() == GR_STATE_TEAM_WIN ) && ( pRules->GetWinningTeam() != GetTeamNumber() ) )
+		return true;
+
+	// Hide all view models after the game is over
+	if ( pRules->State_Get() == GR_STATE_GAME_OVER && ( !pRules->IsInTournamentMode() || pRules->IsMannVsMachineMode() ) )
+		return true;
+
+	if ( m_Shared.InCond( TF_COND_PHASE ) )
+		return true;
+
+	if ( m_Shared.InCond( TF_COND_COMPETITIVE_LOSER ) )
+		return true;
+
+	return false;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::StartSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor, CBaseEntity *pTarget )
+{
+	switch ( event->GetType() )
+	{
+	case CChoreoEvent::SEQUENCE:
+	case CChoreoEvent::GESTURE:
+		return StartGestureSceneEvent( info, scene, event, actor, pTarget );
+	default:
+		return BaseClass::StartSceneEvent( info, scene, event, actor, pTarget );
+	}
+}
+
+bool C_TFPlayer::ClearSceneEvent( CSceneEventInfo *info, bool fastKill, bool canceled )
+{
+	switch ( info->m_pEvent->GetType() )
+	{
+	case CChoreoEvent::SEQUENCE:
+	case CChoreoEvent::GESTURE:
+		return StopGestureSceneEvent( info, fastKill, canceled );
+	default:
+		return BaseClass::ClearSceneEvent( info, fastKill, canceled );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::StartGestureSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor, CBaseEntity *pTarget )
+{
+	// Get the (gesture) sequence.
+	info->m_nSequence = LookupSequence( event->GetParameters() );
+	if ( info->m_nSequence < 0 )
+		return false;
+
+	// Player the (gesture) sequence.
+	float flCycle = 0.0f;
+	bool looping = ((GetSequenceFlags( GetModelPtr(), info->m_nSequence ) & STUDIO_LOOPING) != 0);
+	if (!looping)
+	{
+		float dt = scene->GetTime() - event->GetStartTime();
+		m_flTauntDuration = SequenceDuration( info->m_nSequence );
+		flCycle = dt / m_flTauntDuration;
+		flCycle = clamp( flCycle, 0.f, 1.0f );
+	}
+	else
+	{
+		float flStart, flEnd;
+		scene->GetSceneTimes( flStart, flEnd );
+		m_flTauntDuration = flEnd - flStart;
+	}
+
+	m_PlayerAnimState->ResetGestureSlot( GESTURE_SLOT_VCD );
+	m_PlayerAnimState->AddVCDSequenceToGestureSlot( GESTURE_SLOT_VCD, info->m_nSequence, flCycle, true );
+
+	m_nTauntSequence = info->m_nSequence;
+	m_flTauntStartTime = gpGlobals->curtime;
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::StopGestureSceneEvent( CSceneEventInfo *info, bool fastKill, bool canceled )
+{
+	// The ResetGestureSlot call will prevent people from doing running taunts (which they like to do),
+	// so let's only reset the gesture slot if the scene contains a loop (such as the high five pose).
+	bool bSceneContainsLoop = false;
+	for ( int i = 0; i < info->m_pScene->GetNumEvents(); i++ )
+	{
+		CChoreoEvent *pEvent = info->m_pScene->GetEvent( i );
+		if ( pEvent->GetType() == CChoreoEvent::LOOP )
+		{
+			bSceneContainsLoop = true;
+			break;
+		}
+	}
+
+	if( bSceneContainsLoop )
+		m_PlayerAnimState->ResetGestureSlot( GESTURE_SLOT_VCD );
+
+	return true;
+}
+
+
+bool C_TFPlayer::IsAllowedToSwitchWeapons( void )
+{
+	if ( IsWeaponLowered() == true )
+		return false;
+
+	if ( TFGameRules() )
+	{
+		if ( TFGameRules()->IsPasstimeMode() && m_Shared.HasPasstimeBall() )
+			return false;
+
+		if ( TFGameRules()->ShowMatchSummary() )
+			return false;
+	}
+
+	// Can't weapon switch during a taunt.
+	if( m_Shared.InCond( TF_COND_TAUNTING ) && tf_allow_taunt_switch.GetInt() <= 1 )
+		return false;
+
+	return BaseClass::IsAllowedToSwitchWeapons();
+}
+
+IMaterial *C_TFPlayer::GetHeadLabelMaterial( void )
+{
+	if ( g_pHeadLabelMaterial[0] == NULL )
+		SetupHeadLabelMaterials();
+
+	if ( GetTeamNumber() == TF_TEAM_RED )
+	{
+		return g_pHeadLabelMaterial[TF_PLAYER_HEAD_LABEL_RED];
+	}
+	else
+	{
+		return g_pHeadLabelMaterial[TF_PLAYER_HEAD_LABEL_BLUE];
+	}
+
+	return BaseClass::GetHeadLabelMaterial();
+}
+
+void SetupHeadLabelMaterials( void )
+{
+	for ( int i = 0; i < 2; i++ )
+	{
+		if ( g_pHeadLabelMaterial[i] )
+		{
+			g_pHeadLabelMaterial[i]->DecrementReferenceCount();
+			g_pHeadLabelMaterial[i] = NULL;
+		}
+
+		g_pHeadLabelMaterial[i] = materials->FindMaterial( pszHeadLabelNames[i], TEXTURE_GROUP_VGUI );
+		if ( g_pHeadLabelMaterial[i] )
+		{
+			g_pHeadLabelMaterial[i]->IncrementReferenceCount();
+		}
+	}
+}
+
+void C_TFPlayer::ComputeFxBlend( void )
+{
+	BaseClass::ComputeFxBlend();
+
+	float flInvisible = GetPercentInvisible();
+	if ( flInvisible != 0.0f )
+	{
+		// Tell our shadow
+		ClientShadowHandle_t hShadow = GetShadowHandle();
+		if ( hShadow != CLIENTSHADOW_INVALID_HANDLE )
+		{
+			g_pClientShadowMgr->SetFalloffBias( hShadow, flInvisible * 255 );
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CalcView( Vector &eyeOrigin, QAngle &eyeAngles, float &zNear, float &zFar, float &fov )
+{
+	HandleTaunting();
+	BaseClass::CalcView( eyeOrigin, eyeAngles, zNear, zFar, fov );
+}
+
+void SelectDisguise( int iClass, int iTeam );
+
+static void cc_tf_player_lastdisguise( const CCommand &args )
+{
+	C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+	if ( pPlayer == NULL )
+		return;
+
+	// disguise as our last known disguise. desired disguise will be initted to something sensible
+	if ( pPlayer->CanDisguise() || pPlayer->CanDisguise_OnKill() )
+	{
+		// disguise as the previous class, if one exists
+		int nClass = pPlayer->m_Shared.GetDesiredDisguiseClass();
+
+		int iLocalTeam = pPlayer->GetTeamNumber();
+		int iEnemyTeam = ( iLocalTeam == TF_TEAM_BLUE ) ? TF_TEAM_RED : TF_TEAM_BLUE;
+		int nTeam = pPlayer->m_Shared.WasLastDisguiseAsOwnTeam() ? iLocalTeam : iEnemyTeam; 
+
+		//If we pass in "random" or whatever then just make it pick a random class.
+		if ( args.ArgC() > 1 )
+		{
+			nClass = TF_CLASS_UNDEFINED;
+		}
+
+		if ( nClass == TF_CLASS_UNDEFINED )
+		{
+			// they haven't disguised yet, pick a nice one for them.
+			// exclude some undesirable classes
+			do
+			{
+				nClass = random->RandomInt( TF_FIRST_NORMAL_CLASS, TF_LAST_NORMAL_CLASS );
+			} while( nClass == TF_CLASS_SCOUT || nClass == TF_CLASS_SPY );
+
+			nTeam = iEnemyTeam;
+		}
+
+		SelectDisguise( nClass, nTeam );
+		
+	}
+
+}
+static ConCommand lastdisguise( "lastdisguise", cc_tf_player_lastdisguise, "Disguises the spy as the last disguise." );
+
+
+static void cc_tf_player_disguise( const CCommand &args )
+{
+	C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+	if ( pPlayer == NULL )
+		return;
+
+	if ( args.ArgC() >= 3 )
+	{
+		if ( pPlayer->CanDisguise() || pPlayer->CanDisguise_OnKill() )
+		{
+			int nClass = atoi( args[ 1 ] );
+			int nTeam = atoi( args[ 2 ] );
+
+			//Disguise as enemy team
+			if ( nTeam == -1 )
+			{
+				if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
+				{
+					nTeam = TF_TEAM_RED;
+				}
+				else
+				{
+					nTeam = TF_TEAM_BLUE;
+				}
+			}
+			else if ( nTeam == -2 ) //disguise as my own team
+			{
+				nTeam = pPlayer->GetTeamNumber();
+			}
+			else
+			{
+				nTeam = ( nTeam == 1 ) ? TF_TEAM_BLUE : TF_TEAM_RED;
+			}
+			
+			// intercepting the team value and reassigning what gets passed into Disguise()
+			// because the team numbers in the client menu don't match the #define values for the teams
+			SelectDisguise( nClass, nTeam );
+		}
+	}
+}
+
+static ConCommand disguise( "disguise", cc_tf_player_disguise, "Disguises the spy." );
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+static void cc_tf_crashclient()
+{
+	C_TFPlayer *pPlayer = NULL;
+	pPlayer->ComputeFxBlend();
+}
+static ConCommand tf_crashclient( "tf_crashclient", cc_tf_crashclient, "Crashes this client for testing.", FCVAR_DEVELOPMENTONLY );
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ForceUpdateObjectHudState( void )
+{
+	m_bUpdateObjectHudState = true;
+}
+
+#include "c_obj_sentrygun.h"
+
+
+static void cc_tf_debugsentrydmg()
+{
+	C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
+	pPlayer->UpdateIDTarget();
+	int iTarget = pPlayer->GetIDTarget();
+	if ( iTarget > 0 )
+	{
+		C_BaseEntity *pEnt = cl_entitylist->GetEnt( iTarget );
+
+		C_ObjectSentrygun *pSentry = dynamic_cast< C_ObjectSentrygun * >( pEnt );
+
+		if ( pSentry )
+		{
+			pSentry->DebugDamageParticles();
+		}
+	}
+}
+static ConCommand tf_debugsentrydamage( "tf_debugsentrydamage", cc_tf_debugsentrydmg, "", FCVAR_DEVELOPMENTONLY );
+
+/*
+CON_COMMAND_F( spectate_random_server_extend_time, "extend the timer we're spectating this server before we disconnect", FCVAR_DEVELOPMENTONLY )
+{
+	C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( pPlayer )
+	{
+		if ( pPlayer->m_LeaveServerTimer.HasStarted() )
+		{
+			float flTime = spectate_random_server_basetime.GetFloat();
+
+			if ( args.ArgC() > 1 )
+			{
+				flTime = MAX( 0, Q_atof( args[ 1 ] ) );
+			}
+
+			pPlayer->m_LeaveServerTimer.Start( flTime );
+		}
+	}	
+}*/
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::GetTargetIDDataString( bool bIsDisguised, OUT_Z_BYTECAP(iMaxLenInBytes) wchar_t *sDataString, int iMaxLenInBytes, bool &bIsAmmoData, bool &bIsKillStreakData )
+{
+	Assert( iMaxLenInBytes >= sizeof(sDataString[0]) );
+	// Make sure the output string is always initialized to a null-terminated string,
+	// since the conditions below are tricky.
+	sDataString[0] = 0;
+
+	if ( bIsDisguised )
+	{
+		if ( !IsEnemyPlayer() )
+		{
+			// The target is a disguised friendly spy.  They appear to the player with no disguise.  Add the disguise
+			// team & class to the target ID element.
+			bool bDisguisedAsEnemy = ( m_Shared.GetDisguiseTeam() != GetTeamNumber() );
+			const wchar_t *wszAlignment = g_pVGuiLocalize->Find( bDisguisedAsEnemy ? "#TF_enemy" : "#TF_friendly" );
+
+			int classindex = m_Shared.GetDisguiseClass();
+			const wchar_t *wszClassName = g_pVGuiLocalize->Find( g_aPlayerClassNames[classindex] );
+
+			// build a string with disguise information
+			g_pVGuiLocalize->ConstructString( sDataString, iMaxLenInBytes, g_pVGuiLocalize->Find( "#TF_playerid_friendlyspy_disguise" ), 
+				2, wszAlignment, wszClassName );
+		}
+		else if ( IsEnemyPlayer() && (m_Shared.GetDisguiseClass() == TF_CLASS_SPY) )
+		{
+			// The target is an enemy spy disguised as a friendly spy. Show a fake team & class ID element.
+			int classindex = m_Shared.GetDisguiseMask();
+			const wchar_t *wszClassName = g_pVGuiLocalize->Find( g_aPlayerClassNames[classindex] );
+			const wchar_t *wszAlignment = g_pVGuiLocalize->Find( "#TF_enemy" );
+
+			g_pVGuiLocalize->ConstructString( sDataString, iMaxLenInBytes, g_pVGuiLocalize->Find( "#TF_playerid_friendlyspy_disguise" ), 
+				2, wszAlignment, wszClassName );
+		}
+	}
+
+	if ( IsPlayerClass( TF_CLASS_MEDIC ) )
+	{
+		CTFWeaponBase *pMedigun = NULL;
+
+		// Medics put their ubercharge & medigun type into the data string
+		wchar_t wszChargeLevel[ 10 ];
+		_snwprintf( wszChargeLevel, ARRAYSIZE(wszChargeLevel) - 1, L"%.0f", MedicGetChargeLevel( &pMedigun ) * 100 );
+		wszChargeLevel[ ARRAYSIZE(wszChargeLevel)-1 ] = '\0';
+
+		if ( pMedigun && pMedigun->GetAttributeContainer()->GetItem() && pMedigun->GetAttributeContainer()->GetItem()->GetItemQuality() != AE_NORMAL )
+		{
+			g_pVGuiLocalize->ConstructString( sDataString, iMaxLenInBytes, g_pVGuiLocalize->Find( "#TF_playerid_mediccharge_wpn" ), 2, wszChargeLevel, pMedigun->GetAttributeContainer()->GetItem()->GetItemName() );
+		}
+		else
+		{
+			g_pVGuiLocalize->ConstructString( sDataString, iMaxLenInBytes, g_pVGuiLocalize->Find( "#TF_playerid_mediccharge" ), 1, wszChargeLevel );
+		}
+	}
+	else if ( bIsDisguised && (m_Shared.GetDisguiseClass() == TF_CLASS_MEDIC) && IsEnemyPlayer() )
+	{
+		// Show a fake charge level for a disguised enemy medic.
+		g_pVGuiLocalize->ConstructString( sDataString, iMaxLenInBytes, g_pVGuiLocalize->Find( "#TF_playerid_mediccharge" ), 1, L"0" );
+	}
+	else
+	{
+		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+		if ( pLocalPlayer && pLocalPlayer->IsPlayerClass( TF_CLASS_MEDIC ) )
+		{
+			CTFWeaponBase *pTFWeapon = GetActiveTFWeapon();
+			if ( pTFWeapon )
+			{
+				// Check for weapon_blocks_healing
+				int iBlockHealing = 0;
+				CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFWeapon, iBlockHealing, weapon_blocks_healing );
+				if ( iBlockHealing )
+				{
+					if ( pTFWeapon->GetAttributeContainer() && pTFWeapon->GetAttributeContainer()->GetItem() )
+					{
+						g_pVGuiLocalize->ConstructString( sDataString, iMaxLenInBytes, g_pVGuiLocalize->Find( "#TF_playerid_noheal" ), 1, pTFWeapon->GetAttributeContainer()->GetItem()->GetItemName() );
+					}
+					else
+					{
+						g_pVGuiLocalize->ConstructString( sDataString, iMaxLenInBytes, g_pVGuiLocalize->Find( "#TF_playerid_noheal_unknown" ), 0 );
+					}
+				}
+
+				// Show target's clip state to attached medics
+				if ( !sDataString[0] && m_nActiveWpnClip >= 0 )
+				{
+					C_TFPlayer *pTFHealTarget = ToTFPlayer( pLocalPlayer->MedicGetHealTarget() );
+					if ( pTFHealTarget && pTFHealTarget == this )
+					{
+						wchar_t wszClip[10];
+						V_snwprintf( wszClip, ARRAYSIZE(wszClip) - 1, L"%d", m_nActiveWpnClip );
+						g_pVGuiLocalize->ConstructString( sDataString, iMaxLenInBytes, g_pVGuiLocalize->Find( "#TF_playerid_ammo" ), 1, wszClip );
+						bIsAmmoData = true;
+					}
+				}
+			}
+		}
+
+		if ( !bIsAmmoData )
+		{
+			// Check for kill streak data
+			if ( m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills ) > 0 )
+			{
+				bIsKillStreakData = true;
+				wchar_t wszClip[10];
+				V_snwprintf( wszClip, ARRAYSIZE(wszClip) - 1, L"%d", m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills ) );
+				g_pVGuiLocalize->ConstructString( sDataString, iMaxLenInBytes, g_pVGuiLocalize->Find( "#TF_playerid_ammo" ), 1, wszClip );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::ThirdPersonSwitch( bool bThirdperson )
+{
+	BaseClass::ThirdPersonSwitch( bThirdperson );
+
+	// Update our viewmodel whenever we switch view modes
+	C_TFPlayer *pTFObserverTarget = ToTFPlayer( GetObserverTarget() );
+	if ( pTFObserverTarget )
+	{
+		C_TFWeaponBase *pWeapon = pTFObserverTarget->m_Shared.GetActiveTFWeapon();
+		if ( pWeapon )
+		{
+			pWeapon->UpdateAttachmentModels();
+		}
+
+		pTFObserverTarget->UpdateWearables();
+		pTFObserverTarget->SetBodygroupsDirty();
+	}
+
+	// Update our weapon's visibility when we switch
+	C_BaseCombatWeapon* pWeapon = GetActiveWeapon();
+	if ( pWeapon )
+	{
+		pWeapon->UpdateVisibility();
+	}
+
+	// Update visibility of any worn items.
+	UpdateWearables();
+	SetBodygroupsDirty();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Update our active weapon's extra wearable's visibility and shadows
+//			as well as all our wearables.
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateWearables()
+{
+	BaseClass::UpdateWearables();
+
+	CTFWeaponBase* pWeapon = dynamic_cast< CTFWeaponBase* >( GetActiveWeapon() );
+	if ( pWeapon )
+	{
+		pWeapon->UpdateVisibility();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::OnAchievementAchieved( int iAchievement )
+{
+	EmitSound( "Achievement.Earned" );
+
+	BaseClass::OnAchievementAchieved( iAchievement );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Feign Death
+//-----------------------------------------------------------------------------
+void C_TFPlayer::FeignDeath( 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.IsStealthed() )
+		return;
+
+	// Can't feign death if we aren't at full cloak energy.
+	if ( !CanGoInvisible() || ( m_Shared.GetSpyCloakMeter() < 100.0f ) )
+		return;
+
+	// Predict feign death condition effects.
+	m_Shared.AddCond( TF_COND_FEIGN_DEATH );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateSpyStateChange( void )
+{
+	UpdateOverhealEffect();
+	UpdateRecentlyTeleportedEffect();
+	UpdatedMarkedForDeathEffect();
+
+	// Update our resist shield color
+	if ( m_pTempShield && m_Shared.GetCarryingRuneType() == RUNE_RESIST )
+	{
+		m_pTempShield->m_nSkin = ( m_Shared.GetDisplayedTeam() == TF_TEAM_RED ) ? 0 : 1;
+	}
+
+	UpdateRuneIcon( true );
+
+	// Remove Speed lines if Stealthed
+	if ( m_Shared.IsStealthed() )
+	{
+		if ( m_pSpeedBoostEffect )
+		{
+			ParticleProp()->StopEmission( m_pSpeedBoostEffect );
+			m_pSpeedBoostEffect = NULL;
+		}
+
+		m_Shared.EndRadiusHealEffect();
+	}
+
+	// Force Weapon updates
+	if ( GetActiveWeapon() )
+	{
+		GetActiveWeapon()->PreDataUpdate( DATA_UPDATE_DATATABLE_CHANGED );
+	}
+
+	// TranqMark
+	// test : Let Marked spies be seen via the debuff
+	//bool bShow = ( m_Shared.InCond( TF_COND_TRANQ_MARKED )
+	//	&& !m_Shared.IsStealthed();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateOverhealEffect( void )
+{
+	bool bShow = m_Shared.InCond( TF_COND_HEALTH_OVERHEALED );
+	int iTeam = GetTeamNumber();
+
+	if ( IsLocalPlayer() || ( m_Shared.IsStealthed() && !InSameTeam( GetLocalTFPlayer() ) ) )
+	{
+		bShow = false;
+	}
+	else if ( IsPlayerClass( TF_CLASS_SPY ) && !InSameTeam( GetLocalTFPlayer() ) && m_Shared.InCond( TF_COND_DISGUISED ))
+	{
+		iTeam = m_Shared.GetDisguiseTeam();
+	}
+
+	if ( bShow )
+	{
+		if ( !m_pOverHealedEffect )
+		{
+			CreateOverhealEffect( iTeam );
+		}
+		else if ( m_pOverHealedEffect )
+		{
+			ParticleProp()->StopEmission( m_pOverHealedEffect );
+			m_pOverHealedEffect = NULL;
+			CreateOverhealEffect( iTeam );
+		}
+	}
+	else
+	{
+		if ( m_pOverHealedEffect )
+		{
+			ParticleProp()->StopEmission( m_pOverHealedEffect );
+			m_pOverHealedEffect = NULL;
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::CreateOverhealEffect( int iTeam )
+{
+	const char *pEffect = NULL;
+	switch( iTeam )
+	{
+	case TF_TEAM_BLUE:
+		pEffect = "overhealedplayer_blue_pluses";
+		break;
+	case TF_TEAM_RED:
+		pEffect = "overhealedplayer_red_pluses";
+		break;
+	default:
+		break;
+	}
+
+	if ( pEffect )
+	{
+		m_pOverHealedEffect = ParticleProp()->Create( pEffect, PATTACH_ABSORIGIN_FOLLOW );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::SetMetersRan( float fMeters, int iFrame )
+{
+	if ( iFrame != m_iLastRanFrame )
+	{
+		m_iLastRanFrame = iFrame;
+		m_fMetersRan = fMeters;
+	}
+}
+
+bool C_TFPlayer::InSameDisguisedTeam( CBaseEntity *pEnt )
+{
+	if ( pEnt == NULL )
+		return false;
+
+	int iMyApparentTeam = GetTeamNumber();
+	
+	if ( m_bIsCoaching && m_hStudent )
+	{
+		iMyApparentTeam = m_hStudent->GetTeamNumber();
+	}
+
+	if ( m_Shared.InCond( TF_COND_DISGUISED ) )
+	{
+		iMyApparentTeam = m_Shared.GetDisguiseTeam();
+	}
+
+	C_TFPlayer *pPlayerEnt = ToTFPlayer( pEnt );
+	int iTheirApparentTeam = pEnt->GetTeamNumber();
+	if ( pPlayerEnt && pPlayerEnt->m_Shared.InCond( TF_COND_DISGUISED ) )
+	{
+		iTheirApparentTeam = pPlayerEnt->m_Shared.GetDisguiseTeam();
+	}
+
+	return ( iMyApparentTeam == iTheirApparentTeam || GetTeamNumber() == pEnt->GetTeamNumber() || iTheirApparentTeam == GetTeamNumber() );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: When a player's ragdoll is created we want the ragdoll to
+// appear to have any attached wearable items the player had.
+// This uses client side entities instead of the actual wearable items.
+//-----------------------------------------------------------------------------
+static bool IsDecapitationCustomDamageType( int iCustomDamageType )
+{
+	return iCustomDamageType == TF_DMG_CUSTOM_DECAPITATION
+		|| iCustomDamageType == TF_DMG_CUSTOM_TAUNTATK_BARBARIAN_SWING
+		|| iCustomDamageType == TF_DMG_CUSTOM_DECAPITATION_BOSS
+		|| iCustomDamageType == TF_DMG_CUSTOM_MERASMUS_DECAPITATION;
+}
+
+void C_TFPlayer::CreateBoneAttachmentsFromWearables( C_TFRagdoll *pRagdoll, bool bDisguised )
+{
+	if ( bDisguised && !ShouldDrawSpyAsDisguised() )
+	{
+		// the team of disguised spy don't see any wearable
+		return;
+	}
+
+	for ( int wbl = GetNumWearables()-1; wbl >= 0; wbl-- )
+	{
+		C_TFWearable *pItem = dynamic_cast<C_TFWearable*> (GetWearable(wbl));
+		if ( !pItem )
+			continue;
+
+		if ( pItem->IsViewModelWearable() )
+			continue;
+
+		if ( pItem->IsDisguiseWearable() && !bDisguised )
+			continue;
+
+		if ( !pItem->IsDisguiseWearable() && bDisguised )
+			continue;
+
+		pItem->OnWearerDeath();
+
+		if ( pItem->GetDropType() >= ITEM_DROP_TYPE_DROP )
+			continue;
+
+		CAttributeContainer *pCont		   = pItem->GetAttributeContainer();
+		CEconItemView		*pEconItemView = pCont ? pCont->GetItem() : NULL;
+
+		// If this is a decapitated ragdoll, don't attach anything in our head/misc item slots.
+		if ( IsDecapitationCustomDamageType( pRagdoll->GetDamageCustom() ) )
+		{
+			int iLoadoutSlot = pEconItemView
+							 ? pEconItemView->GetStaticData()->GetDefaultLoadoutSlot()
+							 : LOADOUT_POSITION_INVALID;
+
+			if ( iLoadoutSlot == LOADOUT_POSITION_HEAD || iLoadoutSlot == LOADOUT_POSITION_MISC )
+				continue;
+		}
+
+		C_EconWearableGib *pAttachment = new C_EconWearableGib;
+		if ( !pAttachment )
+			return;
+
+		const char *pszModelName = modelinfo->GetModelName( pItem->GetModel() );
+		if ( !pszModelName || pszModelName[ 0 ] == '\0' || pszModelName[ 0 ] == '?' )
+			continue;
+
+		// We need to set the item now, so that it can pull data out during Initialize();
+		if ( pEconItemView )
+		{
+			Assert( pAttachment->GetAttributeContainer() );
+			pAttachment->GetAttributeContainer()->SetItem( pEconItemView );
+		}
+
+		pAttachment->SetModelName( AllocPooledString( pszModelName ) );
+		if ( !pAttachment->Initialize( true ) )
+		{
+			pAttachment->Release();
+			continue;
+		}
+		
+		pAttachment->m_iTeamNum = pRagdoll->GetRagdollTeam();
+		pAttachment->m_nSkin = pItem->GetSkin();
+		pAttachment->AttachEntityToBone( this, -1, Vector(0,0,0), QAngle(0,0,0) );
+		
+		if ( pEconItemView )
+		{
+			if ( pEconItemView->GetStaticData()->UsesPerClassBodygroups( GetTeamNumber() ) )
+			{
+				// Classes start at 1, bodygroups at 0, so we shift them all back 1.
+				pAttachment->SetBodygroup( 1, (pRagdoll->GetClass()-1) );
+			}
+		}
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Loop through all non-standard items carried by this player, and pick the next one.
+//			pLastItem - pointer to the int that stores the last item found, for iteration purposes.
+//-----------------------------------------------------------------------------
+CEconItemView *C_TFPlayer::GetInspectItem( int *pLastItem )
+{
+	int iItemsFound = 0;
+	CEconItemView *pFirstItem = NULL;
+	int nCount = WeaponCount();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		C_BaseCombatWeapon *pWeapon = GetWeapon(i);
+		if ( !pWeapon )
+			continue;
+
+		CEconItemView *pTmp = pWeapon->GetAttributeContainer()->GetItem();
+		if ( !pTmp->IsValid() )
+			continue;
+
+		// don't show hidden items in the inspect panel
+		if ( pTmp->GetItemDefinition() && pTmp->GetItemDefinition()->IsHidden() )
+			continue;
+
+		if ( !pFirstItem )
+		{
+			pFirstItem = pTmp;
+		}
+
+		iItemsFound++;
+		if ( iItemsFound <= *pLastItem )
+			continue;
+
+		// Found the next item, we're done.
+		*pLastItem = iItemsFound;
+		return pTmp;
+	}
+
+	// Check wearables too
+	nCount = GetNumWearables();
+	for ( int i = 0; i < nCount; ++i )
+	{
+		C_EconWearable *pWearable = GetWearable(i);
+		if ( pWearable )
+		{
+			CEconItemView *pTmp = pWearable->GetAttributeContainer()->GetItem();
+			if ( !pTmp->IsValid() )
+				continue;
+
+			if ( !pFirstItem )
+			{
+				pFirstItem = pTmp;
+			}
+
+			iItemsFound++;
+			if ( iItemsFound <= *pLastItem )
+				continue;
+
+			// Found the next item, we're done.
+			*pLastItem = iItemsFound;
+			return pTmp;
+		}
+	}
+
+	// If we didn't find an item, go back to the first one
+	if ( pFirstItem )
+	{
+		*pLastItem = 1;
+		return pFirstItem;
+	}
+
+	return NULL;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::CanUseFirstPersonCommand( void )
+{
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( pLocalPlayer )
+	{
+		if ( pLocalPlayer->m_Shared.InCond( TF_COND_PHASE ) || 
+			 pLocalPlayer->m_Shared.InCond( TF_COND_TAUNTING ) || 
+			 pLocalPlayer->m_Shared.IsControlStunned() ||
+			 pLocalPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
+		{
+			return false;
+		}
+	}
+
+	return BaseClass::CanUseFirstPersonCommand();
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateDemomanEyeEffect( int iDecapitations )
+{
+	if ( m_pEyeEffect )
+	{
+		ParticleProp()->StopEmission( m_pEyeEffect );
+		m_pEyeEffect = NULL;
+	}
+	
+	if ( iDecapitations == 0 )
+		return;
+
+	iDecapitations = MIN( iDecapitations, MAX_DECAPITATIONS );
+	const char* pszEffect = GetDemomanEyeEffectName( iDecapitations );
+
+	if ( pszEffect )
+	{
+		m_pEyeEffect = ParticleProp()->Create( pszEffect, PATTACH_POINT_FOLLOW, "eyeglow_L" );
+	}
+}
+
+//-----------------------------------------------------------------------------
+const char *C_TFPlayer::GetDemomanEyeEffectName( int iDecapitations )
+{
+	if ( iDecapitations < 1 )
+		return NULL;
+
+	switch ( iDecapitations )
+	{
+	case 1:
+		return "eye_powerup_green_lvl_1";
+	case 2:
+		return "eye_powerup_green_lvl_2";
+	case 3:
+		return "eye_powerup_green_lvl_3";
+	default:
+		return "eye_powerup_green_lvl_4";
+	}
+}
+
+//-----------------------------------------------------------------------------
+void GetVectorColorForParticleSystem ( int iSystem, bool bIsBlueTeam, bool bUseColor2, Vector &vecColor )
+{
+	if ( iSystem < 0 || iSystem >= ARRAYSIZE( g_KillStreakEffectsBase ) )
+		return;
+
+	killstreak_params_t params = g_KillStreakEffectsBase[iSystem];
+
+	if ( bIsBlueTeam && g_KillStreakEffectsBase[iSystem].m_bHasTeamColor )
+	{
+		Assert( iSystem > 0 && iSystem < ARRAYSIZE( g_KillStreakEffectsBlue ) );
+		params = g_KillStreakEffectsBlue[iSystem];
+	}
+	
+	if ( bUseColor2 )
+	{
+		vecColor = Vector( params.m_color2_r, params.m_color2_g, params.m_color2_b );
+	}
+	else
+	{
+		vecColor = Vector( params.m_color1_r, params.m_color1_g, params.m_color1_b );
+	}
+	return;
+}
+
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateKillStreakEffects( int iCount, bool bKillScored /* = false */ )
+{
+#ifdef STAGING_ONLY
+	const int LOW_GLOW = 2001;
+#endif
+	const int HIGH_GLOW = 20000;
+
+	// Staging only hack to test eye glows on players
+	if ( m_pEyeGlowEffect[0] )
+	{
+		ParticleProp()->StopEmission( m_pEyeGlowEffect[ 0 ] );
+		m_pEyeGlowEffect[ 0 ] = NULL;
+	}
+	if ( m_pEyeGlowEffect[1] )
+	{
+		ParticleProp()->StopEmission( m_pEyeGlowEffect[ 1 ] );
+		m_pEyeGlowEffect[ 1 ] = NULL;
+	}
+
+	CTFWeaponBase *pActiveWeapon = GetActiveTFWeapon();
+	if ( !pActiveWeapon )
+		return;
+
+	// Disguised Spies, Use targets kill streak.  Otherwise nothing
+	if ( m_Shared.InCond( TF_COND_DISGUISED ) )
+	{
+		C_TFPlayer *pDisguiseTarget = ToTFPlayer( m_Shared.GetDisguiseTarget() );
+		if ( pDisguiseTarget )
+			iCount = pDisguiseTarget->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills );
+		else
+			iCount = 0;
+	}
+
+#ifdef STAGING_ONLY
+	// !TEST!
+	if ( tf_test_setkillcount.GetInt() > 0 )
+	{
+		iCount = tf_test_setkillcount.GetInt();
+	}
+#endif
+
+	// Check if they have the appropriate attribute.
+	int iKillStreakEffectIndex = 0;
+	CALL_ATTRIB_HOOK_INT_ON_OTHER( pActiveWeapon, iKillStreakEffectIndex, killstreak_effect );
+
+	int iKillStreakColorIndex = 0;
+	CALL_ATTRIB_HOOK_INT_ON_OTHER( pActiveWeapon, iKillStreakColorIndex, killstreak_idleeffect );
+
+	// !TEST!
+#ifdef STAGING_ONLY
+	if ( tf_killstreak_eyeglow.GetInt() != 0 )
+	{
+		iKillStreakEffectIndex = tf_killstreak_eyeglow.GetInt();
+	}
+	if ( tf_killstreak_color.GetInt() != 0 )
+	{
+		iKillStreakColorIndex = tf_killstreak_color.GetInt();
+	}
+#endif // staging_only
+
+	// Need a color and eyeeffect to continue, otherwise you only have a sheen at best
+	if ( iKillStreakColorIndex == 0 || iKillStreakEffectIndex == 0 )
+	{
+		// Just in case search weapon wearables for killstreak effects
+		// This only applies for soldier (mantreads) and the demoshields
+		if ( IsPlayerClass( TF_CLASS_SOLDIER ) || IsPlayerClass( TF_CLASS_DEMOMAN ) )
+		{
+			// Iterate over all of our wearables
+			for ( int i = 0; i < GetNumWearables(); ++i )
+			{
+				CEconWearable *pWearable = GetWearable( i );
+				if ( pWearable && pWearable->GetAttributeContainer( )->GetItem( )->GetEquippedPositionForClass( GetPlayerClass( )->GetClassIndex( ) ) == LOADOUT_POSITION_SECONDARY )
+				{
+					CALL_ATTRIB_HOOK_INT_ON_OTHER( pWearable, iKillStreakEffectIndex, killstreak_effect );
+					CALL_ATTRIB_HOOK_INT_ON_OTHER( pWearable, iKillStreakColorIndex, killstreak_idleeffect );
+					break;
+				}
+			}
+		}
+	}
+
+	if ( iKillStreakColorIndex == 0 || iKillStreakEffectIndex == 0 )
+	{
+		m_pszEyeGlowEffectName[0] = '\0';
+		m_vEyeGlowColor1.Zero();
+		return;
+	}
+
+	// Play the pop effect on all kills
+	GetVectorColorForParticleSystem( iKillStreakColorIndex, GetTeamNumber() == TF_TEAM_BLUE, false, m_vEyeGlowColor1 );
+	GetVectorColorForParticleSystem( iKillStreakColorIndex, GetTeamNumber() == TF_TEAM_BLUE, true, m_vEyeGlowColor2 );
+
+	// Do not render in first person
+	if ( !pActiveWeapon->IsFirstPersonView() && bKillScored )
+	{
+		int iAttachment = 0;	
+		iAttachment = LookupAttachment( "eyeglow_R" );
+		if ( iAttachment != INVALID_PARTICLE_ATTACHMENT )
+		{
+			CNewParticleEffect* pEffect = ParticleProp()->Create( "killstreak_t0_lvl1_flash", PATTACH_POINT_FOLLOW, iAttachment );
+			if ( pEffect )
+			{
+				pEffect->SetControlPoint( CUSTOM_COLOR_CP1, m_vEyeGlowColor1 );
+			}
+		}
+
+		if ( GetPlayerClass()->GetClassIndex() != TF_CLASS_DEMOMAN )
+		{
+			iAttachment = LookupAttachment( "eyeglow_L" );
+			if ( iAttachment != INVALID_PARTICLE_ATTACHMENT )
+			{
+				CNewParticleEffect* pEffect = ParticleProp()->Create( "killstreak_t0_lvl1_flash", PATTACH_POINT_FOLLOW, iAttachment );
+				if ( pEffect )
+				{
+					pEffect->SetControlPoint( CUSTOM_COLOR_CP1, m_vEyeGlowColor1 );
+				}
+			}
+		}
+	}
+	
+	// only render eye glows if they have enough kills
+	if ( iCount < tf_killstreakeyes_minkills.GetInt() || m_Shared.InCond( TF_COND_STEALTHED ) )
+	{
+		m_pszEyeGlowEffectName[0] = '\0';
+		return;
+	}
+
+	bool bForceEyeGlow = false;
+#ifdef STAGING_ONLY
+	bForceEyeGlow = tf_eyeglow_wip.GetBool();
+#endif
+
+	int iEyeGlowEffectIndex = iKillStreakEffectIndex;
+	if ( ( iEyeGlowEffectIndex > 0 && iCount > 0 ) || bForceEyeGlow )
+	{
+		// 2,4,6,8 for effects
+		const char* pszEffect = NULL;
+
+		// Verify the system is in the desired range
+#ifdef STAGING_ONLY
+		// Legacy support for when staging had test eye glow indexes
+		if ( iEyeGlowEffectIndex < LOW_GLOW )
+		{
+			iEyeGlowEffectIndex = LOW_GLOW;
+		}
+#endif // STAGING_ONLY
+
+		// This is the wrong type, value is too large should not exist so just bail
+		if ( iEyeGlowEffectIndex > HIGH_GLOW )
+			return;
+
+		// Hack do not have eyeglows for tier0
+		if ( iEyeGlowEffectIndex == 2001 )
+			return;
+
+		// Should we be using a High_glow
+		if ( iCount >= tf_killstreakeyes_maxkills.GetInt() )
+		{
+			iEyeGlowEffectIndex += HIGH_GLOW;
+		}
+
+		attachedparticlesystem_t *pSystem = GetItemSchema()->GetAttributeControlledParticleSystem( iEyeGlowEffectIndex );
+
+		if ( pSystem )
+		{
+			// Check for TeamColor EyeGlows
+			if ( GetTeamNumber() == TF_TEAM_BLUE && V_stristr( pSystem->pszSystemName, "_teamcolor_red" ))
+			{
+				static char pBlue[256];
+				V_StrSubst( pSystem->pszSystemName, "_teamcolor_red", "_teamcolor_blue", pBlue, 256 );
+				pSystem = GetItemSchema()->FindAttributeControlledParticleSystem( pBlue );
+			}
+			else if ( GetTeamNumber() == TF_TEAM_RED && V_stristr( pSystem->pszSystemName, "_teamcolor_blue" ))
+			{
+				// Guard against accidentally giving out the blue team color (support tool)
+				static char pRed[256];
+				V_StrSubst( pSystem->pszSystemName, "_teamcolor_blue", "_teamcolor_red", pRed, 256 );
+				pSystem = GetItemSchema()->FindAttributeControlledParticleSystem( pRed );
+			}
+		}
+
+		if ( pSystem )
+		{
+			pszEffect = pSystem->pszSystemName;
+		}
+
+#ifdef STAGING_ONLY
+		if ( tf_eyeglow_wip.GetBool() )
+		{
+			pszEffect = "killstreak_wip";
+		}
+#endif // STAGING_ONLY
+		
+		if ( pszEffect )
+		{
+			// Do not render in first person
+			if ( !pActiveWeapon->IsFirstPersonView() )
+			{
+				int iAttachment = 0;	
+				iAttachment = LookupAttachment( "eyeglow_R" );
+				if ( iAttachment != INVALID_PARTICLE_ATTACHMENT )
+				{
+					CNewParticleEffect* pEffect = ParticleProp()->Create( pszEffect, PATTACH_POINT_FOLLOW, iAttachment );
+					if ( pEffect )
+					{
+						pEffect->SetControlPoint( CUSTOM_COLOR_CP1, m_vEyeGlowColor1 );
+					}
+					m_pEyeGlowEffect[0] = pEffect;
+				} 
+				
+				// do not put glow on left eye, that is reserved for eyelander
+				if ( GetPlayerClass()->GetClassIndex() != TF_CLASS_DEMOMAN )
+				{
+					iAttachment = LookupAttachment( "eyeglow_L" );
+					if ( iAttachment != INVALID_PARTICLE_ATTACHMENT )
+					{
+						CNewParticleEffect* pEffect = ParticleProp()->Create( pszEffect, PATTACH_POINT_FOLLOW, iAttachment );
+						if ( pEffect )
+						{
+							pEffect->SetControlPoint( CUSTOM_COLOR_CP1, m_vEyeGlowColor1 );
+						}
+						m_pEyeGlowEffect[1] = pEffect;
+					}
+				}
+			}
+			V_strcpy_safe( m_pszEyeGlowEffectName, pszEffect );
+		}
+	}
+	else
+	{
+		m_pszEyeGlowEffectName[0] = '\0';
+	}
+}
+
+void C_TFPlayer::UpdateMVMEyeGlowEffect( bool bVisible )
+{
+	if ( !TFGameRules() || !TFGameRules()->IsMannVsMachineMode() || GetTeamNumber() != TF_TEAM_PVE_INVADERS )
+	{
+		return;
+	}
+	
+	// Remove the eye glows
+	ParticleProp()->StopParticlesNamed( "bot_eye_glow", true );
+	m_pMVMEyeGlowEffect[ 0 ] = NULL;
+	m_pMVMEyeGlowEffect[ 1 ] = NULL;
+
+	if ( bVisible )
+	{
+		// Set color based on skill
+		Vector vColor = m_nBotSkill >= 2 ? Vector( 255, 180, 36 ) : Vector( 0, 240, 255 );
+
+		// Create the effects
+		int nAttachement = LookupAttachment( IsMiniBoss() ? "eye_boss_1" : "eye_1" );
+		if ( nAttachement > 0 )
+		{
+			m_pMVMEyeGlowEffect[ 0 ] = ParticleProp()->Create( "bot_eye_glow", PATTACH_POINT_FOLLOW, nAttachement );
+			if ( m_pMVMEyeGlowEffect[ 0 ] )
+			{
+				m_pMVMEyeGlowEffect[ 0 ]->SetControlPoint( 1, vColor );
+			}
+		}
+
+		nAttachement = LookupAttachment( IsMiniBoss() ? "eye_boss_2" : "eye_2" );
+		if ( nAttachement > 0 )
+		{
+			m_pMVMEyeGlowEffect[ 1 ] = ParticleProp()->Create( "bot_eye_glow", PATTACH_POINT_FOLLOW, nAttachement );
+			if ( m_pMVMEyeGlowEffect[ 1 ] )
+			{
+				m_pMVMEyeGlowEffect[ 1 ]->SetControlPoint( 1, vColor );
+			}
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Check if local player should see spy as disguised body
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::ShouldDrawSpyAsDisguised()
+{
+	if ( C_BasePlayer::GetLocalPlayer() && m_Shared.InCond( TF_COND_DISGUISED ) && 
+		( GetEnemyTeam( GetTeamNumber() ) == C_BasePlayer::GetLocalPlayer()->GetTeamNumber() ) )
+	{
+		if ( m_Shared.GetDisguiseClass() == TF_CLASS_SPY &&
+			m_Shared.GetDisguiseTeam()  == C_BasePlayer::GetLocalPlayer()->GetTeamNumber() )
+		{
+			// This enemy is disguised as a friendly spy.
+			// Show the spy's original bodygroups.
+			return false;
+		}
+		else
+		{
+			// This enemy is disguised. Show the disguise body.
+			return true;
+		}
+	}
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+int C_TFPlayer::GetBody( void )
+{
+	if ( ShouldDrawSpyAsDisguised() )
+	{
+		// This enemy is disguised. Show the disguise body.
+		return m_Shared.GetDisguiseBody();
+	}
+	else
+	{
+		return BaseClass::GetBody();
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const Vector& C_TFPlayer::GetRenderOrigin( void )
+{
+	if ( GetPlayerClass()->HasCustomModel() )
+	{
+		m_vecCustomModelOrigin = BaseClass::GetRenderOrigin() + GetPlayerClass()->GetCustomModelOffset();
+		return m_vecCustomModelOrigin;
+	}
+
+	return BaseClass::GetRenderOrigin();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+ConVar tf_taunt_hint_max_distance( "tf_taunt_hint_max_distance", "256", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT );
+bool C_TFPlayer::ShouldTauntHintIconBeVisible() const
+{
+	C_TFPlayer *pLocalTFPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( !pLocalTFPlayer || pLocalTFPlayer == this || pLocalTFPlayer->IsTaunting() )
+		return false;
+
+	if ( !IsTaunting() || !IsReadyToTauntWithPartner() )
+		return false;
+
+	if ( m_Shared.InCond( TF_COND_TAUNTING ) && m_Shared.GetTauntIndex() == TAUNT_LONG )
+	{
+		return GetAbsOrigin().DistToSqr( pLocalTFPlayer->GetAbsOrigin() ) <  Square( tf_taunt_hint_max_distance.GetFloat() );
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::IsHealthBarVisible( void ) const
+{
+	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
+	{
+		if ( GetTeamNumber() == TF_TEAM_PVE_INVADERS || m_Shared.InCond( TF_COND_REPROGRAMMED ) )
+		{
+			float flRegenAmount = 0;
+			CALL_ATTRIB_HOOK_FLOAT( flRegenAmount, add_health_regen );
+			if ( (int)flRegenAmount != 0 )
+			{
+				return true;
+			}
+		}
+	}
+
+#ifdef STAGING_ONLY
+	if ( TFGameRules() && TFGameRules()->IsBountyMode() && tf_bountymode_showhealth.GetInt() )
+	{
+		return true;
+	}
+#endif // STAGING_ONLY
+
+	return IsMiniBoss();
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+const char* C_TFPlayer::GetBossProgressImageName() const
+{
+	if ( m_bUseBossHealthBar )
+	{
+		return GetPlayerClass()->GetClassIconName();
+	}
+
+	return NULL;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+float C_TFPlayer::GetBossStatusProgress() const
+{
+	float flProgress = float( GetHealth() ) / float( GetMaxHealth() );
+	return flProgress;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Handle karts.
+//-----------------------------------------------------------------------------
+void C_TFPlayer::NotifyShouldTransmit( ShouldTransmitState_t state )
+{
+	BaseClass::NotifyShouldTransmit( state );
+
+	if ( state == SHOULDTRANSMIT_START )
+	{
+		if ( m_Shared.WasInCond( TF_COND_HALLOWEEN_KART ) && m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
+		{
+			// Readd the condition for halloween karts. 
+			// This deals with the situation documented here:
+			// 1) Out of PVS
+			// 2) In PVS, add cart
+			// 3) Out of PVS, remove cart
+			// 4) Returned to PVS, add cart
+			// 
+			// This situation occurs in the halloween 2014 event map, where you are teleported to and from hell
+			// Need to research a better fix, but this one works.
+			m_Shared.ForceRecondNextSync( TF_COND_HALLOWEEN_KART );
+			
+			// Other PVS bugs can probably be fixed here.
+		}
+	}
+}
+
+bool C_TFPlayer::IsEffectRateLimited( EBonusEffectFilter_t effect, const C_TFPlayer* pAttacker ) const
+{
+	// Check if we're rate limited
+	switch( effect )
+	{
+		case kEffectFilter_AttackerOnly:
+		case kEffectFilter_VictimOnly:
+		case kEffectFilter_AttackerAndVictimOnly:
+			return false;
+		case kEffectFilter_AttackerTeam:
+		case kEffectFilter_VictimTeam:
+		case kEffectFilter_BothTeams:
+			// Dont rate limit ourselves
+			if( pAttacker == this )
+				return false;
+
+			return true;
+		default:
+			AssertMsg1( 0, "EBonusEffectFilter_t type not handled in %s", __FUNCTION__ );
+			return false;
+	}
+}
+
+bool C_TFPlayer::ShouldPlayEffect( EBonusEffectFilter_t filter, const C_TFPlayer* pAttacker, const C_TFPlayer* pVictim ) const
+{
+	Assert( pAttacker );
+	Assert( pVictim );
+	if( !pAttacker || !pVictim )
+		return false;
+
+	// Check if the right player relationship
+	switch( filter )
+	{
+		case kEffectFilter_AttackerOnly:
+			return ( pAttacker == this );
+		case kEffectFilter_AttackerTeam:
+			return ( pAttacker->GetTeamNumber() == this->GetTeamNumber() );
+		case kEffectFilter_VictimOnly:
+			return ( pVictim == this );
+		case kEffectFilter_VictimTeam:
+			return ( pVictim->GetTeamNumber() == this->GetTeamNumber() );
+		case kEffectFilter_AttackerAndVictimOnly:
+			return ( pAttacker == this || pVictim == this );
+		case kEffectFilter_BothTeams:
+			return ( pAttacker->GetTeamNumber() == this->GetTeamNumber() || pVictim->GetTeamNumber() == this->GetTeamNumber() );
+
+		default:
+			AssertMsg1( 0, "EBonusEffectFilter_t type not handled in %s", __FUNCTION__ );
+			return false;
+	};
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+void C_TFPlayer::FireGameEvent( IGameEvent *event )
+{
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+
+	if ( FStrEq( event->GetName(), "player_hurt" ) )
+	{
+		static BonusEffect_t bonusEffects[] = 
+		{
+			//		       Sound name					Particle name		Particle filter				Sound filter				Sound plays in attacker's ears for them, the world for everyone else
+			BonusEffect_t( "TFPlayer.CritHit",			"crit_text",		kEffectFilter_AttackerOnly, kEffectFilter_AttackerOnly,	true	),
+			BonusEffect_t( "TFPlayer.CritHitMini",		"minicrit_text",	kEffectFilter_AttackerOnly, kEffectFilter_AttackerOnly,	true	),
+			BonusEffect_t( "TFPlayer.DoubleDonk",		"doubledonk_text",	kEffectFilter_BothTeams,	kEffectFilter_BothTeams,	true	),
+			BonusEffect_t( NULL,						"sploosh_text",		kEffectFilter_BothTeams,	kEffectFilter_BothTeams,	true	)
+		};
+		COMPILE_TIME_ASSERT( ARRAYSIZE( bonusEffects ) == kBonusEffect_Count );
+
+		// These only should affect the local player
+		if ( !pLocalPlayer || pLocalPlayer != this )
+			return;
+
+		// By default we get kBonusEffect_None. We want to use whatever value we get here if it's not kBonusEffect_None.
+		// If it's not, then check for crit or minicrit
+		EAttackBonusEffects_t eBonusEffect = (EAttackBonusEffects_t)event->GetInt( "bonuseffect", (int)kBonusEffect_None );
+		if( eBonusEffect == kBonusEffect_None )
+		{
+			// Keep reading for these fields to keep replays happy
+			eBonusEffect = event->GetBool( "minicrit", false )	? kBonusEffect_MiniCrit : eBonusEffect;
+			eBonusEffect = event->GetBool( "crit", false )		? kBonusEffect_Crit		: eBonusEffect;
+		}
+
+		// No effect to show?  Bail
+		if( eBonusEffect == kBonusEffect_None || eBonusEffect >= kBonusEffect_Count )
+			return;
+
+		const int iAttacker = engine->GetPlayerForUserID( event->GetInt( "attacker" ) );
+		C_TFPlayer *pAttacker = ToTFPlayer( UTIL_PlayerByIndex( iAttacker ) );
+
+		const int iVictim = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
+		C_TFPlayer *pVictim = ToTFPlayer( UTIL_PlayerByIndex( iVictim ) );
+
+		// No pointers to players?  Bail
+		if( !pAttacker || !pVictim )
+			return;
+
+		bool bShowDisguisedCrit = event->GetBool( "showdisguisedcrit", 0 );
+
+		// Victim is disguised and we're not showing disguised effects?  Bail
+		if ( pVictim->m_Shared.InCond( TF_COND_DISGUISED ) && !bShowDisguisedCrit )
+			return;
+
+		// Victim is carrying Resist Powerup, which is immune to crit damage
+		if ( pVictim && pVictim->m_Shared.GetCarryingRuneType() == RUNE_RESIST &&
+			 ( eBonusEffect == kBonusEffect_Crit || eBonusEffect == kBonusEffect_MiniCrit ) )
+		{
+			return;
+		}
+
+		// Support old system.  If "allseecrit" is set that means we want this to show for our whole team.
+		EBonusEffectFilter_t eParticleFilter = bonusEffects[ eBonusEffect ].m_eParticleFilter;
+		EBonusEffectFilter_t eSoundFilter = bonusEffects[ eBonusEffect ].m_eSoundFilter;
+		if( event->GetBool( "allseecrit", false ) )
+		{
+			eParticleFilter = kEffectFilter_AttackerTeam;
+			eSoundFilter	= kEffectFilter_AttackerTeam;
+		}
+
+		// Check if either of our effects are rate limited
+		if( IsEffectRateLimited( eParticleFilter, pAttacker ) || IsEffectRateLimited( eSoundFilter, pAttacker ) )
+		{
+			// Check if we're cooling down
+			if( !pVictim->CanDisplayAllSeeEffect( eBonusEffect ) )
+			{
+				// Too often!  Return
+				return;
+			}
+
+			// Set cooldown period
+			pVictim->SetNextAllSeeEffectTime( eBonusEffect, gpGlobals->curtime + 0.5f );
+		}
+		
+		ConVarRef hud_combattext( "hud_combattext", false );
+		ConVarRef hud_combattext_doesnt_block_overhead_text( "hud_combattext_doesnt_block_overhead_text", false );
+		bool bCombatTextBlocks = hud_combattext.GetBool() && !hud_combattext_doesnt_block_overhead_text.GetBool();
+
+		// Show the effect, unless combat text blocks
+		if( ShouldPlayEffect( eParticleFilter, pAttacker, pVictim ) && !bCombatTextBlocks )
+		{
+			pVictim->ParticleProp()->Create( bonusEffects[ eBonusEffect ].m_pszParticleName, PATTACH_POINT_FOLLOW, "head" );
+		}
+		// Play the sound!
+		if( ShouldPlayEffect( eSoundFilter, pAttacker, pVictim ) && bonusEffects[ eBonusEffect ].m_pszSoundName != NULL )
+		{
+			const bool& bPlayInAttackersEars = bonusEffects[ eBonusEffect ].m_bPlaySoundInAttackersEars;
+
+			// sound effects
+			EmitSound_t params;
+			params.m_flSoundTime = 0;
+			params.m_pflSoundDuration = 0;
+			params.m_pSoundName = bonusEffects[ eBonusEffect ].m_pszSoundName;
+
+			CPASFilter filter( pVictim->GetAbsOrigin() );
+			if( bPlayInAttackersEars && pAttacker == this )
+			{
+				// Don't let the attacker hear this version if its to be played in their ears
+				filter.RemoveRecipient( pAttacker );
+
+				// Play a sound in the ears of the attacker
+				CSingleUserRecipientFilter attackerFilter( pAttacker );
+				EmitSound( attackerFilter, pAttacker->entindex(), params );
+			}
+
+			EmitSound( filter, pVictim->entindex(), params );
+		}
+	}
+	else if ( FStrEq( event->GetName(), "hltv_changed_mode" ) )
+	{
+		int iTarget = event->GetInt( "obs_target" );
+		if ( iTarget == entindex() )
+		{
+			int iOld = event->GetInt( "oldmode" );
+			int iNew = event->GetInt( "newmode" );
+
+			if ( iOld == OBS_MODE_IN_EYE || iNew == OBS_MODE_IN_EYE )
+			{
+				C_TFWeaponBase *pWeapon = m_Shared.GetActiveTFWeapon();
+				if ( pWeapon )
+				{
+					pWeapon->UpdateAttachmentModels();
+				}
+
+				// Update visibility of any worn items.
+				UpdateWearables();
+				SetBodygroupsDirty();
+			}
+		}
+	}
+	else if ( FStrEq( event->GetName(), "hltv_changed_target" ) )
+	{
+		int iOldTarget = event->GetInt( "old_target" );
+		int iTarget = event->GetInt( "obs_target" );
+		if ( iTarget == entindex() || iOldTarget == entindex() )
+		{
+			int iMode = event->GetInt( "mode" );
+			if ( iMode == OBS_MODE_IN_EYE )
+			{
+				C_TFWeaponBase *pWeapon = m_Shared.GetActiveTFWeapon();
+				if ( pWeapon )
+				{
+					pWeapon->UpdateAttachmentModels();
+				}
+			}
+
+			// Update visibility of any worn items.
+			UpdateWearables();
+			SetBodygroupsDirty();
+		}
+	}
+	else if ( FStrEq( event->GetName(), "post_inventory_application" ) )
+	{
+		const int iPlayer = engine->GetPlayerForUserID( event->GetInt( "userid" ) );
+		C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayer ) );
+		if ( pPlayer )
+		{
+			pPlayer->SetBodygroupsDirty();
+		}
+	}
+	else if ( FStrEq( event->GetName(), "rocket_jump" ) || FStrEq( event->GetName(), "sticky_jump" ) )
+	{
+		// Play a special sound when blast jumping with weapons that don't hurt the player
+		const int iUserID = event->GetInt( "userid" );
+		bool bWhistle = event->GetBool( "playsound" );
+		if ( bWhistle && GetUserID() == iUserID )
+		{
+			if ( !m_pBlastJumpLoop )
+			{
+				CBroadcastRecipientFilter filter;
+				CSoundEnvelopeController &controller = CSoundEnvelopeController::GetController();
+				m_pBlastJumpLoop = controller.SoundCreate( filter, entindex(), "BlastJump.Whistle" );
+				controller.Play( m_pBlastJumpLoop, 0.25, 200 );
+				m_flBlastJumpLaunchTime = gpGlobals->curtime;
+			}
+		}
+	}
+	else if ( FStrEq( event->GetName(), "player_spawn" ) )
+	{
+		StopBlastJumpLoopSound( event->GetInt( "userid" ) );
+
+		const int iUserID = event->GetInt( "userid" );
+		if ( pLocalPlayer && GetUserID() == pLocalPlayer->GetUserID() && iUserID == pLocalPlayer->GetUserID() )
+		{
+
+			// ADD EconNotification to equip spellbook here
+			if ( TFGameRules() && TFGameRules()->IsUsingSpells() )
+			{
+				int iCount = NotificationQueue_Count( &CEquipSpellbookNotification::IsNotificationType );
+				CEconItemView *pItem = TFInventoryManager()->GetItemInLoadoutForClass( event->GetInt( "class"), LOADOUT_POSITION_ACTION );
+				// no spell book
+				if ( !pItem || !pItem->GetStaticData()->GetItemClass() || !FStrEq( pItem->GetStaticData()->GetItemClass(), "tf_weapon_spellbook" ) )
+				{
+					if ( iCount == 0 )
+					{
+						CEquipSpellbookNotification *pNotification = new CEquipSpellbookNotification();
+						pNotification->SetText( "#TF_SpellBook_EquipAction" );
+						pNotification->SetLifetime( 10.0f );
+						NotificationQueue_Add( pNotification );
+					}
+				}
+				else
+				{
+					NotificationQueue_Remove( &CEquipSpellbookNotification::IsNotificationType );
+				}
+			}
+			// ADD EconNotification to equip grapplinghook here
+			else if ( TFGameRules() && TFGameRules()->IsUsingGrapplingHook() )
+			{
+				int iCount = NotificationQueue_Count( &CEquipGrapplingHookNotification::IsNotificationType );
+				CEconItemView *pItem = TFInventoryManager()->GetItemInLoadoutForClass( event->GetInt( "class"), LOADOUT_POSITION_ACTION );
+				// no spell book
+				if ( !pItem || !pItem->GetStaticData()->GetItemClass() || !FStrEq( pItem->GetStaticData()->GetItemClass(), "tf_weapon_grapplinghook" ) )
+				{
+					if ( iCount == 0 )
+					{
+						CEquipGrapplingHookNotification *pNotification = new CEquipGrapplingHookNotification();
+						pNotification->SetText( "#TF_GrapplingHook_EquipAction" );
+						pNotification->SetLifetime( 10.0f );
+						NotificationQueue_Add( pNotification );
+					}
+				}
+				else
+				{
+					NotificationQueue_Remove( &CEquipGrapplingHookNotification::IsNotificationType );
+				}
+				
+			}
+			// Add EconNotification to equip Canteen here
+			else if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
+			{
+				int iCount = NotificationQueue_Count( &CEquipMvMCanteenNotification::IsNotificationType );
+				CEconItemView *pItem = TFInventoryManager()->GetItemInLoadoutForClass( event->GetInt( "class" ), LOADOUT_POSITION_ACTION );
+				// no spell book
+				if ( !pItem || !pItem->GetStaticData()->GetItemClass() || !FStrEq( pItem->GetStaticData()->GetItemClass(), "tf_powerup_bottle" ) )
+				{
+					if ( iCount == 0 )
+					{
+						CEquipMvMCanteenNotification *pNotification = new CEquipMvMCanteenNotification();
+						pNotification->SetText( "#TF_Canteen_EquipAction" );
+						pNotification->SetLifetime( 10.0f );
+						NotificationQueue_Add( pNotification );
+					}
+				}
+				else
+				{
+					NotificationQueue_Remove( &CEquipMvMCanteenNotification::IsNotificationType );
+				}
+			}
+		}
+	}
+	else if ( FStrEq( event->GetName(), "rocket_jump_landed" ) || FStrEq( event->GetName(), "sticky_jump_landed" ) )
+	{
+		StopBlastJumpLoopSound( event->GetInt( "userid" ) );
+	}
+	else if( FStrEq( event->GetName(), "damage_resisted" ) )
+	{
+		const int index_ = event->GetInt( "entindex" );
+		if ( index_ == entindex() )
+		{
+			m_flLastResistTime = gpGlobals->curtime;
+		}
+	}
+	else if ( FStrEq( event->GetName(), "revive_player_notify" ) )
+	{
+		if ( !pLocalPlayer )
+			return;
+
+		const int index_ = event->GetInt( "entindex" );
+		if ( pLocalPlayer == this && entindex() == index_ && !m_hRevivePrompt )
+		{
+			const int nMarkerIndex = event->GetInt( "marker_entindex" );
+			CBaseEntity *pMarker = ClientEntityList().GetEnt( nMarkerIndex );
+			if ( pMarker )
+			{
+				m_hRevivePrompt = ShowRevivePrompt( pMarker, "#TF_Prompt_Revive_Title", "#TF_Prompt_Revive_Message", "#TF_Prompt_Revive_Cancel", &PromptAcceptReviveCallback, NULL, NULL );
+				if ( m_hRevivePrompt )
+				{
+					m_hRevivePrompt->SetKeyBoardInputEnabled( false );
+				}
+			}
+		}
+	}
+	else if ( FStrEq( event->GetName(), "revive_player_stopped" ) )
+	{
+		if ( !pLocalPlayer )
+			return;
+
+		if ( m_hRevivePrompt )
+		{
+			m_hRevivePrompt->MarkForDeletion();
+			m_hRevivePrompt = NULL;
+		}
+	}
+	else if ( FStrEq( event->GetName(), "player_changeclass" ) )
+	{
+		if ( TFGameRules() && TFGameRules()->IsMatchTypeCompetitive() )
+		{
+			if ( g_PR &&
+				pLocalPlayer &&
+				pLocalPlayer == this &&
+				TFGameRules() &&
+				TFGameRules()->IsCompetitiveMode() &&
+				TFGameRules()->State_Get() == GR_STATE_RND_RUNNING )
+			{
+				CBaseHudChat *pHudChat = (CBaseHudChat*)GET_HUDELEMENT( CHudChat );
+				if ( pHudChat )
+				{
+					C_BasePlayer *pEventPlayer = UTIL_PlayerByUserId( event->GetInt( "userid" ) );
+					if ( pEventPlayer && pLocalPlayer->GetTeamNumber() == g_PR->GetTeam( pEventPlayer->entindex() ) )
+					{
+						int nClassID = event->GetInt( "class" );
+						if ( nClassID >= 0 && nClassID < ARRAYSIZE( g_aPlayerClassNames ) )
+						{
+							wchar_t wszPlayerName[MAX_PLAYER_NAME_LENGTH];
+							g_pVGuiLocalize->ConvertANSIToUnicode( g_PR->GetPlayerName( pEventPlayer->entindex() ), wszPlayerName, sizeof( wszPlayerName ) );
+
+							wchar_t wszLocalized[100];
+							g_pVGuiLocalize->ConstructString_safe( wszLocalized, g_pVGuiLocalize->Find( "#TF_Class_Change" ), 2, wszPlayerName, g_pVGuiLocalize->Find( g_aPlayerClassNames[nClassID] ) );
+
+							char szLocalized[100];
+							g_pVGuiLocalize->ConvertUnicodeToANSI( wszLocalized, szLocalized, sizeof( szLocalized ) );
+
+							pHudChat->ChatPrintf( pLocalPlayer->entindex(), CHAT_FILTER_NAMECHANGE, "%s", szLocalized );
+						}
+					}
+				}
+			}
+		}
+	}
+	else if ( FStrEq( event->GetName(), "player_abandoned_match" ) )
+	{
+		if ( pLocalPlayer && pLocalPlayer == this )
+		{
+			wchar_t wzNotification[1024] = L"";
+			const wchar_t *pwzTitle = g_pVGuiLocalize->Find( "#TF_Competitive_Abandoned" );
+			g_pVGuiLocalize->ConstructString_safe( wzNotification, pwzTitle, 0 );
+			
+			if ( event->GetBool( "game_over" ) )
+			{
+				ShowMessageBox( "#TF_Competitive_AbandonedTitle", wzNotification, "#GameUI_OK" );
+			}
+			else
+			{
+				CBaseHudChat *pHudChat = (CBaseHudChat*)GET_HUDELEMENT( CHudChat );
+				if ( pHudChat )
+				{
+					char szLocalized[1024];
+					g_pVGuiLocalize->ConvertUnicodeToANSI( wzNotification, szLocalized, sizeof( szLocalized ) );
+					pHudChat->ChatPrintf( pLocalPlayer->entindex(), CHAT_FILTER_SERVERMSG, "%s", szLocalized );
+				}
+			}
+		}
+	}
+#ifdef STAGING_ONLY
+	else if ( FStrEq( event->GetName(), "player_death" ) && tf_random_item_min.GetInt() > 0 && tf_random_item_max.GetInt() > tf_random_item_min.GetInt() )
+	{
+		const int iUserID = event->GetInt( "userid" );
+		if ( pLocalPlayer && GetUserID() == pLocalPlayer->GetUserID() && iUserID == pLocalPlayer->GetUserID() )
+		{
+			// Give random items and tell the user there items have been changed
+			// Get a list of all cosmetics for this class in this item range
+			CUtlVector<CEconItemView*> vecItemViews;
+			//GetItemDef
+			CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();
+			if ( !pLocalInv )
+				return;
+
+			int iClass = GetPlayerClass()->GetClassIndex();
+			for ( int i = 0; i < pLocalInv->GetItemCount(); ++i )
+			{
+				CEconItemView *pItem = pLocalInv->GetItem( i );
+				const GameItemDefinition_t *pItemDef = pItem->GetItemDefinition();
+				if ( IsMiscSlot( pItemDef->GetLoadoutSlot( iClass ) ) && pItemDef->GetDefinitionIndex() >= tf_random_item_min.GetInt() && pItemDef->GetDefinitionIndex() <= tf_random_item_max.GetInt() )
+				{
+					vecItemViews.AddToTail( pItem );
+				}
+			}
+
+			equip_region_mask_t unCumulativeRegionMask = 0;
+
+			// Unequip everything
+			InventoryManager()->UpdateInventoryEquippedState( pLocalInv, INVALID_ITEM_ID, iClass, LOADOUT_POSITION_HEAD );
+			InventoryManager()->UpdateInventoryEquippedState( pLocalInv, INVALID_ITEM_ID, iClass, LOADOUT_POSITION_MISC );
+			InventoryManager()->UpdateInventoryEquippedState( pLocalInv, INVALID_ITEM_ID, iClass, LOADOUT_POSITION_MISC2 );
+
+			// pick a random item slot2
+			for ( int iSlot = 0; iSlot < 3; ++iSlot )
+			{
+				int iLoadoutPos = LOADOUT_POSITION_HEAD;
+				switch ( iSlot )
+				{
+				case 0:					iLoadoutPos = LOADOUT_POSITION_HEAD;					break;
+				case 1:					iLoadoutPos = LOADOUT_POSITION_MISC;					break;
+				case 2:					iLoadoutPos = LOADOUT_POSITION_MISC2;					break;
+				}
+
+				int iRandomItem = RandomInt( 0, vecItemViews.Count() - 1 );
+				for ( int i = 0; i < vecItemViews.Count(); ++i )
+				{
+					CEconItemView *pItemView = vecItemViews[( iRandomItem + i ) % vecItemViews.Count()];
+					equip_region_mask_t unItemEquipMask = pItemView->GetItemDefinition()->GetEquipRegionMask();
+					if ( !( unItemEquipMask & unCumulativeRegionMask ) )
+					{
+						TFInventoryManager()->EquipItemInLoadout( pLocalPlayer->GetPlayerClass()->GetClassIndex(), iLoadoutPos, pItemView->GetID() );
+						vecItemViews.Remove( ( iRandomItem + i ) % vecItemViews.Count() );
+						unCumulativeRegionMask |= unItemEquipMask;
+						break;
+					}
+				}
+			}
+
+			// Notify player there items have changed
+			CEconNotification *pNotification = new CEconNotification();
+			pNotification->SetText( "#TF_Test_ItemsChanged" );
+			pNotification->SetLifetime( 6.0f );
+			NotificationQueue_Add( pNotification );
+		}
+	}
+#endif // STAGING_ONLY
+	BaseClass::FireGameEvent( event );
+}
+
+const char* C_TFPlayer::ModifyEventParticles( const char* token )
+{
+	if ( GetPlayerClass()->IsClass( TF_CLASS_SCOUT ) )
+	{
+		if ( !Q_strcmp( token, "doublejump_puff" ) )
+		{
+			if ( m_Shared.GetAirDash() > 1 )
+			{
+				return "doublejump_puff_alt";
+			}
+		}
+	}
+
+	return BaseClass::ModifyEventParticles( token );
+}
+
+void C_TFPlayer::SetTauntCameraTargets( float back, float up )
+{
+	m_flTauntCamTargetDist = back;
+	m_flTauntCamTargetDistUp = up;
+	// Force this on
+	m_bTauntInterpolating = true;
+}
+
+CampaignMedalDisplayType_t C_TFPlayer::GetCampaignMedalType( void )
+{
+//	static CSchemaItemDefHandle pItemDef_Summer2015Operation( "Activated Summer 2015 Operation Pass" );
+//	static CSchemaItemDefHandle pItemDef_InvasionPass( "Activated Invasion Pass" );
+//	static CSchemaItemDefHandle pItemDef_HalloweenPass( "Activated Halloween Pass" );
+//	static CSchemaItemDefHandle pItemDef_Winter2016Pass( "Activated Operation Tough Break Pass" );
+	CampaignMedalDisplayType_t retVal = CAMPAIGN_MEDAL_DISPLAY_TYPE_NONE;
+/*
+	if ( HasCampaignMedal( CAMPAIGN_MEDAL_WINTER2016 ) )
+	{
+		CTFPlayerInventory *pInv = Inventory();
+		if ( pInv )
+		{
+			for ( int i = 0; i < pInv->GetItemCount(); ++i )
+			{
+				CEconItemView *pItem = pInv->GetItem( i );
+				if ( pItem && ( pItem->GetItemDefinition() == pItemDef_Winter2016Pass ) )
+				{
+					style_index_t iStyle = pItem->GetItemStyle();
+					if ( iStyle != INVALID_STYLE_INDEX )
+					{
+						iStyle += ( ( entindex()%2 < 1 ) ? CAMPAIGN_MEDAL_DISPLAY_TYPE_WINTER2016_GRAVEL1 : CAMPAIGN_MEDAL_DISPLAY_TYPE_WINTER2016_GRAVEL2 ); // styles start at 0 and Winter2016 images start at CAMPAIGN_MEDAL_DISPLAY_TYPE_WINTER2016_GRAVEL1
+						if ( ( iStyle >= (style_index_t)CAMPAIGN_MEDAL_DISPLAY_TYPE_WINTER2016_GRAVEL1 ) && ( iStyle <= (style_index_t)CAMPAIGN_MEDAL_DISPLAY_TYPE_WINTER2016_GOLD2 ) )
+						{
+							retVal = (CampaignMedalDisplayType_t)iStyle;
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	if ( IsPlayingInvasionMap() && HasCampaignMedal( CAMPAIGN_MEDAL_INVASION ) )
+	{
+		retVal = CAMPAIGN_MEDAL_DISPLAY_TYPE_INVASION;
+	}
+	else if ( HasCampaignMedal( CAMPAIGN_MEDAL_HALLOWEEN ) )
+	{
+		CTFPlayerInventory *pInv = Inventory();
+		if ( pInv )
+		{
+			for ( int i = 0; i < pInv->GetItemCount(); ++i )
+			{
+				CEconItemView *pItem = pInv->GetItem( i );
+				if ( pItem && ( pItem->GetItemDefinition() == pItemDef_HalloweenPass ) )
+				{
+					style_index_t iStyle = pItem->GetItemStyle();
+					if ( iStyle != INVALID_STYLE_INDEX )
+					{
+						iStyle += CAMPAIGN_MEDAL_DISPLAY_TYPE_HALLOWEEN_GRAVEL; // styles start at 0 and Halloween images start at CAMPAIGN_MEDAL_DISPLAY_TYPE_HALLOWEEN_GRAVEL
+						if ( ( iStyle >= (style_index_t)CAMPAIGN_MEDAL_DISPLAY_TYPE_HALLOWEEN_GRAVEL ) && ( iStyle <= (style_index_t)CAMPAIGN_MEDAL_DISPLAY_TYPE_HALLOWEEN_GOLD ) )
+						{
+							retVal = (CampaignMedalDisplayType_t)iStyle;
+							break;
+						}
+					}
+				}
+			}
+		}
+	}
+	else if ( HasCampaignMedal( CAMPAIGN_MEDAL_SUMMER2015 ) )
+	{
+		CTFPlayerInventory *pInv = Inventory();
+		if ( pInv )
+		{
+			for ( int i = 0; i < pInv->GetItemCount(); ++i )
+			{
+				CEconItemView *pItem = pInv->GetItem( i );
+				if ( pItem && ( pItem->GetItemDefinition() == pItemDef_Summer2015Operation ) )
+				{
+					style_index_t iStyle = pItem->GetItemStyle();
+					if ( iStyle != INVALID_STYLE_INDEX )
+					{
+						iStyle += 1; // styles start at 0 and images start at 1
+						if ( ( iStyle >= (style_index_t)CAMPAIGN_MEDAL_DISPLAY_TYPE_SUMMER2015_GRAVEL ) && ( iStyle <= (style_index_t)CAMPAIGN_MEDAL_DISPLAY_TYPE_SUMMER2015_GOLD ) )
+						{
+							retVal = (CampaignMedalDisplayType_t)iStyle;
+							break;
+						}
+					}
+				}
+			}
+		}
+	}*/
+
+	return retVal;
+}
+
+const char *C_TFPlayer::GetCampaignMedalImage( void )
+{
+	return g_pszCampaignMedalIcons[GetCampaignMedalType()];
+}
+
+void C_TFPlayer::UpdateGlowEffect( void )
+{
+	DestroyGlowEffect();
+
+	BaseClass::UpdateGlowEffect();
+
+	// create a new effect if we have a coach
+	if ( m_hCoach && m_hCoach->IsLocalPlayer() && m_hCoach->m_bIsCoaching )
+	{
+		float r, g, b;
+		GetGlowEffectColor( &r, &g, &b );
+
+		m_pStudentGlowEffect = new CGlowObject( this, Vector( r, g, b ), 1.0, true );
+	}
+
+	// create a power up effect if needed
+	if ( ShouldShowPowerupGlowEffect() )
+	{
+		float r, g, b;
+		GetPowerupGlowEffectColor( &r, &g, &b );
+
+		m_pPowerupGlowEffect = new CGlowObject( this, Vector( r, g, b ), 1.0, true );
+	}
+}
+
+void C_TFPlayer::DestroyGlowEffect( void )
+{
+	BaseClass::DestroyGlowEffect();
+
+	if ( m_pStudentGlowEffect )
+	{
+		delete m_pStudentGlowEffect;
+		m_pStudentGlowEffect = NULL;
+	}
+
+	if ( m_pPowerupGlowEffect )
+	{
+		delete m_pPowerupGlowEffect;
+		m_pPowerupGlowEffect = NULL;
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::UpdateGlowColor( void )
+{
+	CGlowObject* pGlowObject = GetGlowObject();
+	if ( pGlowObject )
+	{
+		float r, g, b;
+		GetGlowEffectColor( &r, &g, &b );
+
+		pGlowObject->SetColor( Vector( r, g, b ) );
+	}
+
+	if ( m_pPowerupGlowEffect )
+	{
+		float r, g, b;
+		GetPowerupGlowEffectColor( &r, &g, &b );
+
+		m_pPowerupGlowEffect->SetColor( Vector( r, g, b ) );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::GetGlowEffectColor( float *r, float *g, float *b )
+{
+#ifdef TF_CREEP_MODE
+	if ( TFGameRules() && TFGameRules()->IsCreepWaveMode() )
+	{
+		if ( GetTeamNumber() == TF_TEAM_RED )
+		{
+			*r = 255;
+			*g = 0;
+			*b = 0;
+		}
+		else
+		{
+			*r = 0;
+			*g = 0;
+			*b = 255;
+		}
+		return;
+	}
+#endif // TF_CREEP_MODE
+
+	int nTeam = GetTeamNumber();
+
+	C_TFPlayer *pLocalPlayer = GetLocalTFPlayer();
+	// In CTF, show health color glow for alive player
+	if ( pLocalPlayer && pLocalPlayer->IsAlive() && TFGameRules() && ( TFGameRules()->GetGameType() == TF_GAMETYPE_CTF ) && HasTheFlag() )
+	{
+		float flHealth = (float)GetHealth() / (float)GetMaxHealth();
+
+		if ( flHealth > 0.6 )
+		{
+			*r = 0.33f;
+			*g = 0.75f;
+			*b = 0.23f;
+		}
+		else if( flHealth > 0.3 )
+		{
+			*r = 0.75f;
+			*g = 0.72f;
+			*b = 0.23f;
+		}
+		else
+		{
+			*r = 0.75f;
+			*g = 0.23f;
+			*b = 0.23f;
+		}
+		return;
+	}
+
+	if ( !engine->IsHLTV() && ( GetLocalPlayerTeam() >= FIRST_GAME_TEAM ) )
+	{
+		if ( IsPlayerClass( TF_CLASS_SPY ) && m_Shared.InCond( TF_COND_DISGUISED ) && ( GetTeamNumber() != GetLocalPlayerTeam() ) )
+		{
+			nTeam = m_Shared.GetDisguiseTeam();
+		}
+	}
+
+	TFGameRules()->GetTeamGlowColor( nTeam, *r, *g, *b );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::ShouldShowPowerupGlowEffect()
+{
+	// should local player see enemy glow with powerup related
+	C_TFPlayer *pLocalPlayer = GetLocalTFPlayer();
+	if ( pLocalPlayer->IsAlive() && this != pLocalPlayer && GetTeamNumber() != pLocalPlayer->GetTeamNumber() )
+	{
+		// give advantage to local player who doesn't have rune to fight against enemy with rune by glowing their health
+		if ( m_Shared.IsCarryingRune() && !pLocalPlayer->m_Shared.IsCarryingRune() )
+		{
+			// only show glow when the enemy is lower than 30% HP
+			float flHealth = ( float )GetHealth() / ( float )GetMaxHealth();
+			return flHealth <= 0.3 && pLocalPlayer->IsLineOfSightClear( this, IGNORE_ACTORS );
+		}
+		// local player with supernova can see enemy glow within supernova range
+		else if ( pLocalPlayer->m_Shared.GetCarryingRuneType() == RUNE_SUPERNOVA && pLocalPlayer->m_Shared.IsRuneCharged() && !m_Shared.IsStealthed() )
+		{
+			const float flEffectRadiusSqr = Sqr( 1500.f );
+			Vector toPlayer = WorldSpaceCenter() - pLocalPlayer->WorldSpaceCenter();
+			return toPlayer.LengthSqr() <= flEffectRadiusSqr && pLocalPlayer->IsLineOfSightClear( this, IGNORE_ACTORS );
+		}
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::GetPowerupGlowEffectColor( float *r, float *g, float *b )
+{
+	C_TFPlayer *pLocalPlayer = GetLocalTFPlayer();
+	// no need to add extra logics here. we already know that other players are glowing from SUPERNOVA
+	if ( pLocalPlayer->m_Shared.GetCarryingRuneType() == RUNE_SUPERNOVA )
+	{
+		*r = 255;
+		*g = 255;
+		*b = 0;
+	}
+	else
+	{
+		GetGlowEffectColor( r, g, b );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+static ConVar tf_inspect_hint_count( "tf_inspect_hint_count", "0", FCVAR_ARCHIVE );
+void C_TFPlayer::HandleInspectHint()
+{
+	int nNotifyCount = tf_inspect_hint_count.GetInt();
+	if ( nNotifyCount > 10 )
+		return;
+
+	if ( m_bNotifiedWeaponInspectThisLife )
+		return;
+
+	CHudNotificationPanel *pNotifyPanel = GET_HUDELEMENT( CHudNotificationPanel );
+	if ( pNotifyPanel )
+	{
+		wchar_t szNotification[1024]=L"";
+		wchar_t wKeyBind[80] = L"";
+		const wchar_t *wpszFormat = g_pVGuiLocalize->Find( "#Hint_inspect_weapon" );
+		if ( wpszFormat )
+		{
+			const char *key = engine->Key_LookupBinding( "+inspect" );
+			if ( !key || FStrEq( key, "(null)" ) )
+			{
+				key = "< not bound >";
+			}
+
+			g_pVGuiLocalize->ConvertANSIToUnicode( key, wKeyBind, sizeof( wKeyBind ) );
+			g_pVGuiLocalize->ConstructString_safe( szNotification, wpszFormat, 1, wKeyBind );
+			pNotifyPanel->SetupNotifyCustom( szNotification, "", GetTeamNumber() );
+
+			tf_inspect_hint_count.SetValue( nNotifyCount + 1 );
+		}
+
+		m_bNotifiedWeaponInspectThisLife = true;
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+bool C_TFPlayer::AddOverheadEffect( const char *pszEffectName )
+{
+	int index_ = m_mapOverheadEffects.Find( pszEffectName );
+
+	// particle is added already
+	if ( index_ != m_mapOverheadEffects.InvalidIndex() )
+		return false;
+
+	CNewParticleEffect *pEffect = ParticleProp()->Create( pszEffectName, PATTACH_ABSORIGIN_FOLLOW, 0, GetOverheadEffectPosition() );
+	if ( pEffect )
+	{
+		if ( m_mapOverheadEffects.Count() == 0 )
+		{
+			m_flOverheadEffectStartTime = gpGlobals->curtime;
+		}
+
+		m_mapOverheadEffects.Insert( pszEffectName, pEffect );
+
+		return true;
+	}
+
+	return false;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+void C_TFPlayer::RemoveOverheadEffect( const char *pszEffectName, bool bRemoveInstantly )
+{
+	int index_ = m_mapOverheadEffects.Find( pszEffectName );
+
+	// particle is added already
+	if ( index_ != m_mapOverheadEffects.InvalidIndex() )
+	{
+		if ( bRemoveInstantly )
+			ParticleProp()->StopEmissionAndDestroyImmediately( m_mapOverheadEffects[index_] );
+		ParticleProp()->StopParticlesNamed( pszEffectName, bRemoveInstantly );
+		m_mapOverheadEffects.RemoveAt( index_ );
+	}
+}
+
+
+void C_TFPlayer::UpdateOverheadEffects()
+{
+	if ( IsLocalPlayer() )
+		return;
+
+	const int nOverheadEffectCount = m_mapOverheadEffects.Count();
+	if ( nOverheadEffectCount == 0 )
+		return;
+
+	Vector vecOverheadEffectPosition = GetOverheadEffectPosition();
+	C_TFPlayer *pLocalPlayer = GetLocalTFPlayer();
+	if ( !pLocalPlayer )
+		return;
+
+	Vector vecHeadToHead = EyePosition() - pLocalPlayer->EyePosition();
+
+	const float flEffectGap = 24.f;
+	Vector vecRightOffset = CrossProduct( vecHeadToHead, Vector( 0, 0, 1 ) ).Normalized();
+	float flFirstEffectOffset = -flEffectGap * 0.5f * ( nOverheadEffectCount - 1 );
+	int iValidParticleIndex = 0;
+	FOR_EACH_MAP_FAST( m_mapOverheadEffects, i )
+	{
+		HPARTICLEFFECT hEffect = m_mapOverheadEffects[i];
+		if ( hEffect )
+		{
+			float flCurrentOffset = flFirstEffectOffset + flEffectGap * iValidParticleIndex;
+			Vector vecOffset = vecOverheadEffectPosition + flCurrentOffset * vecRightOffset;
+			ParticleProp()->AddControlPoint( hEffect, 0, this, PATTACH_ABSORIGIN_FOLLOW, 0, vecOffset );
+			iValidParticleIndex++;
+		}
+	}
+}
+
+
+Vector C_TFPlayer::GetOverheadEffectPosition()
+{
+	return GetClassEyeHeight() + Vector( 0, 0, 20 );
+}
+
+
+//------------------------------------------------------------------------------
+// The serverbrowser has just added a server to the favorite list.
+// Send this information to the GC.
+static void cc_tf_register_favorite_with_gc( const CCommand &args )
+{
+	netadr_t netaddr( args.ArgS() );
+
+	CGCMsg< MsgGCServerBrowser_Server_t > msg( k_EMsgGCServerBrowser_FavoriteServer );
+	msg.Body().m_unIP = netaddr.GetIPNetworkByteOrder(); // <<<< Note: this is wrong.  But it was wrong before.  And we can fix the data if it is *consistently* wrong.
+	msg.Body().m_usPort = netaddr.GetPort();
+	msg.Body().m_ubSource = k_EGCMsgServerBrowser_FromServerBrowser;
+	GCClientSystem()->BSendMessage( msg );
+}
+static ConCommand tf_register_favorite_with_gc( "rfgc", cc_tf_register_favorite_with_gc, "", FCVAR_HIDDEN );
+
+
+//------------------------------------------------------------------------------
+// The serverbrowser has just added a server to the blacklist.
+// Send this information to the GC.
+static void cc_tf_register_blacklist_with_gc( const CCommand &args )
+{
+	netadr_t netaddr( args.ArgS() );
+
+	CGCMsg< MsgGCServerBrowser_Server_t > msg( k_EMsgGCServerBrowser_BlacklistServer );
+	msg.Body().m_unIP = netaddr.GetIPNetworkByteOrder(); // <<<< Note: this is wrong.  But it was wrong before.  And we can fix the data if it is *consistently* wrong.
+	msg.Body().m_usPort = netaddr.GetPort();
+	msg.Body().m_ubSource = k_EGCMsgServerBrowser_FromServerBrowser;
+	GCClientSystem()->BSendMessage( msg );
+}
+static ConCommand tf_register_blacklist_with_gc( "rbgc", cc_tf_register_blacklist_with_gc, "", FCVAR_HIDDEN );
+
+static void cc_taunt_by_name( const CCommand &args )
+{
+	C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( !pPlayer || !pPlayer->IsAlive() )
+		return;
+
+	const char *pszTauntItemName = args.ArgS();
+
+	int iClass = pPlayer->GetPlayerClass()->GetClassIndex();
+
+	CTFPlayerInventory *pInv = pPlayer->Inventory();
+	if ( !pInv )
+		return;
+
+	CUtlStringList strTauntList;
+	for ( int iSlot = LOADOUT_POSITION_TAUNT; iSlot<= LOADOUT_POSITION_TAUNT8; ++iSlot )
+	{
+		CEconItemView *pItem = pInv->GetItemInLoadout( iClass, iSlot );
+		if ( !pItem || !pItem->IsValid() )
+			continue;
+
+		static char pszItemName[512];
+		g_pVGuiLocalize->ConvertUnicodeToANSI( g_pVGuiLocalize->Find ( pItem->GetStaticData()->GetItemBaseName() ) , pszItemName, sizeof(pszItemName) );
+		strTauntList.CopyAndAddToTail( pszItemName );
+
+		if ( V_stricmp( pszTauntItemName, pszItemName ) == 0 )
+		{
+			int iTauntSlot = iSlot - LOADOUT_POSITION_TAUNT + 1;
+			engine->ClientCmd( CFmtStr( "taunt %d", iTauntSlot ) );
+
+			return;
+		}
+	}
+
+	Msg( "taunt_by_name failed. Taunt [%s] is not equipped in the loadout.\n", pszTauntItemName );
+	Msg( "[Taunt(s) in loadout]\n");
+	for ( int i=0; i<strTauntList.Count(); ++i )
+	{
+		Msg( "%s\n", strTauntList[i] );
+	}
+}
+static ConCommand taunt_by_name( "taunt_by_name", cc_taunt_by_name, "Use equipped taunt by name." );
+
+#ifdef STAGING_ONLY
+CON_COMMAND( force_reset_gesture_slot_vcd, "" )
+{
+	C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
+	if ( pLocalPlayer )
+	{
+		pLocalPlayer->m_PlayerAnimState->ResetGestureSlot( GESTURE_SLOT_VCD );
+	}
+}
+#endif // STAGING_ONLY