tf2/tf2_src/game/shared/tf/tf_gamerules.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: The TF Game rules 
//
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
#include "tf_gamerules.h"
#include "tf_classdata.h"
#include "ammodef.h"
#include "KeyValues.h"
#include "tf_weaponbase.h"
#include "tf_weaponbase_gun.h"
#include "tier0/icommandline.h"
#include "convar_serverbounded.h"
#include "econ_item_system.h"
#include "tf_weapon_grenadelauncher.h"
#include "tf_logic_robot_destruction.h"
#include "tf_logic_player_destruction.h"
#include "tf_matchmaking_shared.h"

#ifdef CLIENT_DLL
	#include <game/client/iviewport.h>
	#include "c_tf_player.h"
	#include "c_tf_objective_resource.h"
	#include <filesystem.h>
	#include "c_tf_team.h"
	#include "dt_utlvector_recv.h"
	#include "tf_autorp.h"
	#include "player_vs_environment/c_tf_upgrades.h"
	#include "video/ivideoservices.h"
	#include "tf_gc_client.h"
	#include "c_tf_playerresource.h"
#else
	#include "basemultiplayerplayer.h"
	#include "voice_gamemgr.h"
	#include "items.h"
	#include "team.h"
	#include "game.h"
	#include "tf_bot_temp.h"
	#include "tf_player.h"
	#include "tf_team.h"
	#include "player_resource.h"
	#include "entity_tfstart.h"
	#include "filesystem.h"
	#include "minigames/tf_duel.h"
	#include "tf_obj.h"
	#include "tf_objective_resource.h"
	#include "tf_player_resource.h"
	#include "team_control_point_master.h"
	#include "team_train_watcher.h"
	#include "playerclass_info_parse.h"
	#include "team_control_point_master.h"
	#include "coordsize.h"
	#include "entity_healthkit.h"
	#include "tf_gamestats.h"
	#include "entity_capture_flag.h"
	#include "tf_player_resource.h"
	#include "tf_obj_sentrygun.h"
	#include "activitylist.h"
	#include "AI_ResponseSystem.h"
	#include "hl2orange.spa.h"
	#include "hltvdirector.h"
	#include "tf_projectile_arrow.h"
	#include "func_suggested_build.h"
	#include "tf_gc_api.h"
	#include "tf_weaponbase_grenadeproj.h"
	#include "engine/IEngineSound.h"
	#include "soundenvelope.h"
	#include "dt_utlvector_send.h"
	#include "tf_tactical_mission.h"
	#include "nav_mesh/tf_nav_area.h"
	#include "bot/tf_bot.h"
	#include "bot/tf_bot_manager.h"
	#include "bot/map_entities/tf_bot_roster.h"
	#include "econ_gcmessages.h"
	#include "vgui/ILocalize.h"
	#include "tier3/tier3.h"
	#include "tf_ammo_pack.h"
	#include "tf_gcmessages.h"
	#include "vote_controller.h"
	#include "tf_voteissues.h"
	#include "halloween/headless_hatman.h"
	#include "halloween/ghost/ghost.h"
	#include "halloween/eyeball_boss/eyeball_boss.h"
	#include "halloween/merasmus/merasmus.h"
	#include "halloween/merasmus/merasmus_dancer.h"
	#include "tf_extra_map_entity.h"
	#include "tf_weapon_grenade_pipebomb.h"
	#include "tf_weapon_flaregun.h"
	#include "tf_weapon_sniperrifle.h"
	#include "tf_weapon_knife.h"
	#include "tf_weapon_jar.h"
	#include "halloween/tf_weapon_spellbook.h"
	
	#include "player_vs_environment/tf_population_manager.h"
	#include "player_vs_environment/monster_resource.h"
	#include "util_shared.h"
	#include "gc_clientsystem.h"

	#include "raid/tf_raid_logic.h"
	#include "player_vs_environment/tf_boss_battle_logic.h"
	#include "player_vs_environment/tf_mann_vs_machine_logic.h"
	#include "player_vs_environment/tf_upgrades.h"

	#include "tf_wheel_of_doom.h"
	#include "tf_halloween_souls_pickup.h"
	#include "halloween/zombie/zombie.h"
	#include "teamplay_round_timer.h"
	#include "halloween/spell/tf_spell_pickup.h"
	#include "tf_weapon_laser_pointer.h"
	#include "effect_dispatch_data.h"
	#include "tf_fx.h"
	#include "econ_game_account_server.h"
	#include "tf_gc_server.h"
	#include "tf_logic_halloween_2014.h"
	#include "tf_obj_sentrygun.h"
	#include "entity_halloween_pickup.h"
	#include "entity_rune.h"
	#include "func_powerupvolume.h"
	#include "workshop/maps_workshop.h"
	#include "tf_passtime_logic.h"
	#include "cdll_int.h"
	#include "halloween/halloween_gift_spawn_locations.h"
	#include "tf_weapon_invis.h"
	#include "tf_gc_server.h"
	#include "gcsdk/msgprotobuf.h"
	#include "tf_party.h"
	#include "tf_autobalance.h"
#endif

#include "tf_mann_vs_machine_stats.h"
#include "tf_upgrades_shared.h"

#include "tf_item_powerup_bottle.h"
#include "tf_weaponbase_gun.h"
#include "tf_weaponbase_melee.h"
#include "tf_wearable_item_demoshield.h"
#include "tf_weapon_buff_item.h"
#include "tf_weapon_flamethrower.h"
#include "tf_weapon_medigun.h"

#include "econ_holidays.h"
#include "rtime.h"
#include "tf_revive.h"
#include "tf_duckleaderboard.h"

#include "passtime_convars.h"

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


#define ITEM_RESPAWN_TIME	10.0f
#define MASK_RADIUS_DAMAGE  ( MASK_SHOT & ~( CONTENTS_HITBOX ) )

// Halloween 2013 VO defines for plr_hightower_event
#define HELLTOWER_TIMER_INTERVAL	( 60 + RandomInt( -30, 30 )	)
#define HELLTOWER_RARE_LINE_CHANCE	0.15	// 15%
#define HELLTOWER_MISC_CHANCE		0.50	// 50%

static int g_TauntCamRagdollAchievements[] = 
{
	0,		// TF_CLASS_UNDEFINED

	0,		// TF_CLASS_SCOUT,	
	0,		// TF_CLASS_SNIPER,
	0,		// TF_CLASS_SOLDIER,
	0,		// TF_CLASS_DEMOMAN,
	ACHIEVEMENT_TF_MEDIC_FREEZECAM_RAGDOLL,		// TF_CLASS_MEDIC,
	0,		// TF_CLASS_HEAVYWEAPONS,
	0,		// TF_CLASS_PYRO,
	ACHIEVEMENT_TF_SPY_FREEZECAM_FLICK,		// TF_CLASS_SPY,
	0,		// TF_CLASS_ENGINEER,

	0,		// TF_CLASS_CIVILIAN,
	0,		// TF_CLASS_COUNT_ALL,
};

static int g_TauntCamAchievements[] = 
{
	0,		// TF_CLASS_UNDEFINED

	0,		// TF_CLASS_SCOUT,	
	ACHIEVEMENT_TF_SNIPER_FREEZECAM_HAT,		// TF_CLASS_SNIPER,
	ACHIEVEMENT_TF_SOLDIER_FREEZECAM_GIBS,		// TF_CLASS_SOLDIER,		(extra check to count the number of gibs onscreen)
	ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_SMILE,		// TF_CLASS_DEMOMAN,
	0,		// TF_CLASS_MEDIC,
	ACHIEVEMENT_TF_HEAVY_FREEZECAM_TAUNT,		// TF_CLASS_HEAVYWEAPONS,  (there's an extra check on this one to see if we're also invuln)
	ACHIEVEMENT_TF_PYRO_FREEZECAM_TAUNTS,		// TF_CLASS_PYRO,
	0,		// TF_CLASS_SPY,
	ACHIEVEMENT_TF_ENGINEER_FREEZECAM_TAUNT,	// TF_CLASS_ENGINEER,
	0,		// TF_CLASS_CIVILIAN,
	0,		// TF_CLASS_COUNT_ALL,
};

// used for classes that have more than one freeze cam achievement (example: Sniper)
static int g_TauntCamAchievements2[] = 
{
	0,		// TF_CLASS_UNDEFINED

	0,		// TF_CLASS_SCOUT,	
	ACHIEVEMENT_TF_SNIPER_FREEZECAM_WAVE,		// TF_CLASS_SNIPER,
	ACHIEVEMENT_TF_SOLDIER_FREEZECAM_TAUNT,		// TF_CLASS_SOLDIER,
	ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_RUMP,		// TF_CLASS_DEMOMAN,
	0,		// TF_CLASS_MEDIC,
	0,		// TF_CLASS_HEAVYWEAPONS,
	0,		// TF_CLASS_PYRO,
	0,		// TF_CLASS_SPY,
	0,		// TF_CLASS_ENGINEER,

	0,		// TF_CLASS_CIVILIAN,
	0,		// TF_CLASS_COUNT_ALL,
};

struct MapInfo_t
{
	const char	*pDiskName;
	const char	*pDisplayName;
	const char	*pGameType;
};

static MapInfo_t s_ValveMaps[] = {
	{ "ctf_2fort",	"2Fort",		"#Gametype_CTF" },
	{ "cp_dustbowl",	"Dustbowl",		"#TF_AttackDefend" },
	{ "cp_granary",	"Granary",		"#Gametype_CP" },
	{ "cp_well",		"Well",			"#Gametype_CP" },
	{ "cp_foundry",	"Foundry",		"#Gametype_CP" },
	{ "cp_gravelpit", "Gravel Pit",	"#TF_AttackDefend" },
	{ "tc_hydro",		"Hydro",		"#TF_TerritoryControl" },
	{ "ctf_well",		"Well",			"#Gametype_CTF" },
	{ "cp_badlands",	"Badlands",		"#Gametype_CP" },
	{ "pl_goldrush",	"Gold Rush",	"#Gametype_Escort" },
	{ "pl_badwater",	"Badwater Basin",	"#Gametype_Escort" },
	{ "plr_pipeline",	"Pipeline",		"#Gametype_EscortRace" },
	{ "cp_gorge",		"Gorge",		"#TF_AttackDefend" },
	{ "ctf_doublecross",		"Double Cross",		"#Gametype_CTF" },
	{ "pl_thundermountain",	"Thunder Mountain",	"#Gametype_Escort" },
	{ "tr_target",	"Target",		"#GameType_Training" },
	{ "tr_dustbowl",	"Dustbowl",		"#GameType_Training" },
	{ "cp_manor_event",	"Mann Manor",	"#TF_AttackDefend" },
	{ "cp_mountainlab",	"Mountain Lab",	"#TF_AttackDefend" },
	{ "cp_degrootkeep",	"DeGroot Keep",	"#TF_MedievalAttackDefend" },
	{ "pl_barnblitz",	"Barnblitz",	"#Gametype_Escort" },
	{ "pl_upward",	"Upward",	"#Gametype_Escort" },
	{ "plr_hightower",	"Hightower",	"#Gametype_EscortRace" },
	{ "koth_viaduct",	"Viaduct",	"#Gametype_Koth" },
	{ "koth_viaduct_event",	"Eyeaduct",	"#Gametype_Koth" },
	{ "koth_king",	"Kong King",	"#Gametype_Koth" },
	{ "koth_lakeside_event",	"Ghost Fort",	"#Gametype_Koth" },
	{ "plr_hightower_event",	"Helltower",	"#Gametype_EscortRace" },
	{ "rd_asteroid",	"Asteroid",	"#Gametype_RobotDestruction" },
	{ "pl_cactuscanyon",	"Cactus Canyon",	"#Gametype_Escort" },
	{ "sd_doomsday",	"Doomsday",	"#Gametype_SD" },
	{ "sd_doomsday_event",	"Carnival of Carnage",	"#Gametype_SD" },
};

static MapInfo_t s_CommunityMaps[] = {
	{ "pl_borneo", "Borneo", "#Gametype_Escort" },
	{ "koth_suijin", "Suijin", "#Gametype_Koth" },
	{ "cp_snowplow", "Snowplow", "#TF_AttackDefend" },
	{ "koth_probed", "Probed", "#Gametype_Koth" },
	{ "pd_watergate", "Watergate", "#Gametype_PlayerDestruction" },
	{ "arena_byre", "Byre", "#Gametype_Arena" },
	{ "ctf_2fort_invasion", "2Fort Invasion", "#Gametype_CTF" },
	{ "cp_sunshine_event", "Sinshine", "#Gametype_CP" },
	{ "pl_millstone_event", "Hellstone", "#Gametype_Escort" },
	{ "cp_gorge_event", "Gorge Event", "#TF_AttackDefend" },
	{ "koth_moonshine_event", "Moonshine Event", "#Gametype_Koth" },
	{ "pl_snowycoast", "Snowycoast", "#Gametype_Escort" },
	{ "cp_vanguard", "Vanguard", "#Gametype_CP" },
	{ "ctf_landfall", "Landfall", "#Gametype_CTF" },
	{ "koth_highpass", "Highpass", "#Gametype_Koth" },
	{ "koth_maple_ridge_event", "Maple Ridge Event", "#Gametype_Koth" },
	{ "pl_fifthcurve_event", "Brimstone", "#Gametype_Escort" },
	{ "pd_pit_of_death_event", "Pit of Death", "#Gametype_PlayerDestruction" },
};

/*

  !! Commented out until we use this data, but we should keep updating it so its current when we need it

struct FeaturedWorkshopMap_t
{
	// The name the map was shipped as in our files (e.g. it was available as maps/<this>.bsp)
	// NOTE After maps are un-shipped we leave them here and don't change this value, this allows mapcycles that have
	// this map to proper redirect to the workshop in the future
	const char *pShippedName;
	// The workshop ID of the map (The public one, not the the private upload they use to send us the sources)
	PublishedFileId_t nWorkshopID;
};

static FeaturedWorkshopMap_t s_FeaturedWorkshopMaps[] = {
	// !! DO NOT remove these after we stop shipping the file -- they exist to ensure users can refer to
	// !! e.g. "koth_suijin" and get redirected to the workshop map once the file is no longer in our depots.

	// Summer 2015 Operation
	{ "pl_borneo",             454139147 },
	{ "koth_suijin",           454188876 },
	{ "cp_snowplow",           454116615 },

	// September 2015 Invasion Community Update
	{ "koth_probed",           454139808 },
	{ "pd_watergate",          456016898 },
	{ "arena_byre",            454142123 },
	{ "ctf_2fort_invasion",    FIXME     }, // No public workshop entry yet

	// Halloween 2015
	{ "cp_sunshine_event",     532473747 },
	{ "pl_millstone_event",    531384846 },
	{ "cp_gorge_event",        527145539 },
	{ "koth_moonshine_event",  534874830 },

	// December 2015 Campaign
	{ "pl_snowycoast",         469072819 },
	{ "cp_vanguard",           462908782 },
	{ "ctf_landfall",          459651881 },
	{ "koth_highpass",         463803443 },

	// Halloween 2016
	{ "koth_maple_ridge_event",	537540619 },
	{ "pl_fifthcurve_event",	764966851 },
	{ "pd_pit_of_death_event",	537319626 },
};

*/

bool IsValveMap( const char *pMapName )
{
	for ( int i = 0; i < ARRAYSIZE( s_ValveMaps ); ++i )
	{
		if ( !Q_stricmp( s_ValveMaps[i].pDiskName, pMapName ) )
		{
			return true;
		}
	}
	return false;
}

extern ConVar mp_capstyle;
extern ConVar sv_turbophysics;

extern ConVar tf_vaccinator_small_resist;
extern ConVar tf_vaccinator_uber_resist;

extern ConVar tf_teleporter_fov_time;
extern ConVar tf_teleporter_fov_start;

#ifdef GAME_DLL
extern ConVar mp_holiday_nogifts;
extern ConVar tf_debug_damage;
extern ConVar tf_damage_range;
extern ConVar tf_damage_disablespread;
extern ConVar tf_populator_damage_multiplier;
extern ConVar tf_mm_trusted;
extern ConVar tf_weapon_criticals;
extern ConVar tf_weapon_criticals_melee;
extern ConVar mp_idledealmethod;
extern ConVar mp_idlemaxtime;

extern ConVar tf_mm_strict;
extern ConVar mp_autoteambalance;

// STAGING_SPY
ConVar tf_feign_death_activate_damage_scale( "tf_feign_death_activate_damage_scale", "0.25", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_feign_death_damage_scale( "tf_feign_death_damage_scale", "0.35", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );
ConVar tf_stealth_damage_reduction( "tf_stealth_damage_reduction", "0.8", FCVAR_CHEAT | FCVAR_DEVELOPMENTONLY );

// training
ConVar training_class( "training_class", "3", FCVAR_REPLICATED, "Class to use in training." );
ConVar training_can_build_sentry( "training_can_build_sentry", "1", FCVAR_REPLICATED, "Player can build sentry as engineer." );
ConVar training_can_build_dispenser( "training_can_build_dispenser", "1", FCVAR_REPLICATED, "Player can build dispenser as engineer." );
ConVar training_can_build_tele_entrance( "training_can_build_tele_entrance", "1", FCVAR_REPLICATED, "Player can build teleporter entrance as engineer." );
ConVar training_can_build_tele_exit( "training_can_build_tele_exit", "1", FCVAR_REPLICATED, "Player can build teleporter exit as engineer." );
ConVar training_can_destroy_buildings( "training_can_destroy_buildings", "1", FCVAR_REPLICATED, "Player can destroy buildings as engineer." );
ConVar training_can_pickup_sentry( "training_can_pickup_sentry", "1", FCVAR_REPLICATED, "Player can pickup sentry gun as engineer." );
ConVar training_can_pickup_dispenser( "training_can_pickup_dispenser", "1", FCVAR_REPLICATED, "Player can pickup dispenser as engineer." );
ConVar training_can_pickup_tele_entrance( "training_can_pickup_tele_entrance", "1", FCVAR_REPLICATED, "Player can pickup teleporter entrance as engineer." );
ConVar training_can_pickup_tele_exit( "training_can_pickup_tele_exit", "1", FCVAR_REPLICATED, "Player can pickup teleporter entrance as engineer." );
ConVar training_can_select_weapon_primary	( "training_can_select_weapon_primary", "1", FCVAR_REPLICATED, "In training player select primary weapon." );
ConVar training_can_select_weapon_secondary	( "training_can_select_weapon_secondary", "1", FCVAR_REPLICATED, "In training player select secondary weapon." );
ConVar training_can_select_weapon_melee		( "training_can_select_weapon_melee", "1", FCVAR_REPLICATED, "In training player select melee weapon." );
ConVar training_can_select_weapon_building	( "training_can_select_weapon_building", "1", FCVAR_REPLICATED, "In training player select building tool." );
ConVar training_can_select_weapon_pda		( "training_can_select_weapon_pda", "1", FCVAR_REPLICATED, "In training player select pda." );
ConVar training_can_select_weapon_item1		( "training_can_select_weapon_item1", "1", FCVAR_REPLICATED, "In training player select item 1." );
ConVar training_can_select_weapon_item2		( "training_can_select_weapon_item2", "1", FCVAR_REPLICATED, "In training player select item 2." );

ConVar tf_birthday_ball_chance( "tf_birthday_ball_chance", "100", FCVAR_REPLICATED, "Percent chance of a birthday beach ball spawning at each round start" );

ConVar tf_halloween_boss_spawn_interval( "tf_halloween_boss_spawn_interval", "480", FCVAR_CHEAT, "Average interval between boss spawns, in seconds" );
ConVar tf_halloween_boss_spawn_interval_variation( "tf_halloween_boss_spawn_interval_variation", "60", FCVAR_CHEAT, "Variation of spawn interval +/-" );

ConVar tf_halloween_eyeball_boss_spawn_interval( "tf_halloween_eyeball_boss_spawn_interval", "180", FCVAR_CHEAT, "Average interval between boss spawns, in seconds" );
ConVar tf_halloween_eyeball_boss_spawn_interval_variation( "tf_halloween_eyeball_boss_spawn_interval_variation", "30", FCVAR_CHEAT, "Variation of spawn interval +/-" );

ConVar tf_merasmus_spawn_interval( "tf_merasmus_spawn_interval", "180", FCVAR_CHEAT, "Average interval between boss spawns, in seconds" );
ConVar tf_merasmus_spawn_interval_variation( "tf_merasmus_spawn_interval_variation", "30", FCVAR_CHEAT, "Variation of spawn interval +/-" );

ConVar tf_halloween_zombie_mob_enabled( "tf_halloween_zombie_mob_enabled", "0", FCVAR_CHEAT, "If set to 1, spawn zombie mobs on non-Halloween Valve maps" );
ConVar tf_halloween_zombie_mob_spawn_interval( "tf_halloween_zombie_mob_spawn_interval", "180", FCVAR_CHEAT, "Average interval between zombie mob spawns, in seconds" );
ConVar tf_halloween_zombie_mob_spawn_count( "tf_halloween_zombie_mob_spawn_count", "20", FCVAR_CHEAT, "How many zombies to spawn" );

ConVar tf_halloween_allow_truce_during_boss_event( "tf_halloween_allow_truce_during_boss_event", "0", FCVAR_NOTIFY, "Determines if RED and BLU can damage each other while fighting Monoculus or Merasmus on non-Valve maps." );

ConVar tf_player_spell_drop_on_death_rate( "tf_player_spell_drop_on_death_rate", "0", FCVAR_REPLICATED );
ConVar tf_player_drop_bonus_ducks( "tf_player_drop_bonus_ducks", "-1", FCVAR_REPLICATED, "-1 Default (Holiday-based)\n0 - Force off\n1 - Force on" );

ConVar tf_player_name_change_time( "tf_player_name_change_time", "60", FCVAR_NOTIFY, "Seconds between name changes." );

ConVar tf_weapon_criticals_distance_falloff( "tf_weapon_criticals_distance_falloff", "0", FCVAR_CHEAT, "Critical weapon damage will take distance into account." );
ConVar tf_weapon_minicrits_distance_falloff( "tf_weapon_minicrits_distance_falloff", "0", FCVAR_CHEAT, "Mini-crit weapon damage will take distance into account." );

ConVar mp_spectators_restricted( "mp_spectators_restricted", "0", FCVAR_NONE, "Prevent players on game teams from joining team spectator if it would unbalance the teams." );

ConVar tf_test_special_ducks( "tf_test_special_ducks", "1", FCVAR_DEVELOPMENTONLY );

ConVar tf_mm_abandoned_players_per_team_max( "tf_mm_abandoned_players_per_team_max", "1", FCVAR_DEVELOPMENTONLY );

#endif // GAME_DLL
ConVar tf_mm_next_map_vote_time( "tf_mm_next_map_vote_time", "30", FCVAR_REPLICATED );

#ifdef STAGING_ONLY
#ifdef GAME_DLL
void cc_tf_truce_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{

	if ( TFGameRules() )
	{
		TFGameRules()->RecalculateTruce();
	}
}
#endif // GAME_DLL
ConVar tf_truce( "tf_truce", "0", FCVAR_REPLICATED, "Force a team truce on or off.", true, 0, true, 1
#ifdef GAME_DLL
	, cc_tf_truce_changed
#endif // GAME_DLL
	);
#endif // STAGING_ONLY

static float g_fEternaweenAutodisableTime = 0.0f;

ConVar tf_spec_xray( "tf_spec_xray", "1", FCVAR_NOTIFY | FCVAR_REPLICATED, "Allows spectators to see player glows. 1 = same team, 2 = both teams" );
ConVar tf_spawn_glows_duration( "tf_spawn_glows_duration", "10", FCVAR_NOTIFY | FCVAR_REPLICATED, "How long should teammates glow after respawning\n" );

#ifdef GAME_DLL
void cc_tf_forced_holiday_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	// Tell the listeners to recalculate the holiday
	IGameEvent *event = gameeventmanager->CreateEvent( "recalculate_holidays" );
	if ( event )
	{
		gameeventmanager->FireEvent( event );
	}
}
#endif // GAME_DLL

ConVar tf_forced_holiday( "tf_forced_holiday", "0", FCVAR_REPLICATED, "Forced holiday, \n   Birthday = 1\n   Halloween = 2\n" //  Christmas = 3\n   Valentines = 4\n   MeetThePyro = 5\n   FullMoon=6
#ifdef GAME_DLL
, cc_tf_forced_holiday_changed
#endif // GAME_DLL
);
ConVar tf_item_based_forced_holiday( "tf_item_based_forced_holiday", "0", FCVAR_REPLICATED, "" 	// like a clone of tf_forced_holiday, but controlled by client consumable item use
#ifdef GAME_DLL
	, cc_tf_forced_holiday_changed
#endif // GAME_DLL
);
ConVar tf_force_holidays_off( "tf_force_holidays_off", "0", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, ""
#ifdef GAME_DLL
, cc_tf_forced_holiday_changed
#endif // GAME_DLL
);
ConVar tf_birthday( "tf_birthday", "0", FCVAR_NOTIFY | FCVAR_REPLICATED );
ConVar tf_spells_enabled( "tf_spells_enabled", "0", FCVAR_NOTIFY | FCVAR_REPLICATED, "Enable to Allow Halloween Spells to be dropped and used by players" );

ConVar tf_caplinear( "tf_caplinear", "1", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "If set to 1, teams must capture control points linearly." );
ConVar tf_stalematechangeclasstime( "tf_stalematechangeclasstime", "20", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Amount of time that players are allowed to change class in stalemates." );
ConVar mp_tournament_redteamname( "mp_tournament_redteamname", "RED", FCVAR_REPLICATED | FCVAR_HIDDEN );
ConVar mp_tournament_blueteamname( "mp_tournament_blueteamname", "BLU", FCVAR_REPLICATED | FCVAR_HIDDEN );

//tagES revisit this later
ConVar tf_attack_defend_map( "tf_attack_defend_map", "0", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );

#ifdef GAME_DLL
void cc_tf_stopwatch_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	IGameEvent *event = gameeventmanager->CreateEvent( "stop_watch_changed" );
	if ( event )
	{
		gameeventmanager->FireEvent( event );
	}
}
#endif // GAME_DLL
ConVar mp_tournament_stopwatch( "mp_tournament_stopwatch", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Use Stopwatch mode while using Tournament mode (mp_tournament)"
#ifdef GAME_DLL
	, cc_tf_stopwatch_changed 
#endif
);
ConVar mp_tournament_readymode( "mp_tournament_readymode", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Enable per-player ready status for tournament mode." );
ConVar mp_tournament_readymode_min( "mp_tournament_readymode_min", "2", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum number of players required on the server before players can toggle ready status." );
ConVar mp_tournament_readymode_team_size( "mp_tournament_readymode_team_size", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum number of players required to be ready per-team before the game can begin." );
ConVar mp_tournament_readymode_countdown( "mp_tournament_readymode_countdown", "10", FCVAR_REPLICATED | FCVAR_NOTIFY, "The number of seconds before a match begins when both teams are ready." );
ConVar mp_windifference( "mp_windifference", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Score difference between teams before server changes maps", true, 0, false, 0 );
ConVar mp_windifference_min( "mp_windifference_min", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum score needed for mp_windifference to be applied", true, 0, false, 0 );

ConVar tf_tournament_classlimit_scout( "tf_tournament_classlimit_scout", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Scouts.\n" );
ConVar tf_tournament_classlimit_sniper( "tf_tournament_classlimit_sniper", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Snipers.\n" );
ConVar tf_tournament_classlimit_soldier( "tf_tournament_classlimit_soldier", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Soldiers.\n" );
ConVar tf_tournament_classlimit_demoman( "tf_tournament_classlimit_demoman", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Demomenz.\n" );
ConVar tf_tournament_classlimit_medic( "tf_tournament_classlimit_medic", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Medics.\n" );
ConVar tf_tournament_classlimit_heavy( "tf_tournament_classlimit_heavy", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Heavies.\n" );
ConVar tf_tournament_classlimit_pyro( "tf_tournament_classlimit_pyro", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Pyros.\n" );
ConVar tf_tournament_classlimit_spy( "tf_tournament_classlimit_spy", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Spies.\n" );
ConVar tf_tournament_classlimit_engineer( "tf_tournament_classlimit_engineer", "-1", FCVAR_REPLICATED, "Tournament mode per-team class limit for Engineers.\n" );
ConVar tf_tournament_classchange_allowed( "tf_tournament_classchange_allowed", "1", FCVAR_REPLICATED, "Allow players to change class while the game is active?.\n" );
ConVar tf_tournament_classchange_ready_allowed( "tf_tournament_classchange_ready_allowed", "1", FCVAR_REPLICATED, "Allow players to change class after they are READY?.\n" );

ConVar tf_classlimit( "tf_classlimit", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Limit on how many players can be any class (i.e. tf_class_limit 2 would limit 2 players per class).\n", true, 0.f, false, 0.f );
ConVar tf_player_movement_restart_freeze( "tf_player_movement_restart_freeze", "1", FCVAR_REPLICATED, "When set, prevent player movement during round restart" );

ConVar tf_autobalance_query_lifetime( "tf_autobalance_query_lifetime", "30", FCVAR_REPLICATED );
ConVar tf_autobalance_xp_bonus( "tf_autobalance_xp_bonus", "150", FCVAR_REPLICATED );

//tagES
#ifdef STAGING_ONLY
ConVar tf_test_match_summary( "tf_test_match_summary", "0", FCVAR_REPLICATED );

#ifdef GAME_DLL
void cc_tf_fake_mm_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	ConVarRef var( pConVar );
	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( (EMatchGroup)var.GetInt() );
	if ( pMatchDesc )
	{
		pMatchDesc->InitServerSettingsForMatch( NULL );
	}
}
#endif // GAME_DLL
ConVar tf_fake_mm_group( "tf_fake_mm_group", "-1", FCVAR_REPLICATED, "Fake what kind of MM group is being played"
#ifdef GAME_DLL	
	, cc_tf_fake_mm_changed
#endif // GAME_DLL
	);
#endif // STAGING_ONLY

#ifdef GAME_DLL

static const float g_flStrangeEventBatchProcessInterval = 30.0f;

ConVar mp_humans_must_join_team("mp_humans_must_join_team", "any", FCVAR_REPLICATED, "Restricts human players to a single team {any, blue, red, spectator}" );

void cc_tf_medieval_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	ConVarRef var( pConVar );
	bool bOldValue = flOldValue > 0;
	if ( var.IsValid() && ( bOldValue != var.GetBool() ) )
	{
		Msg( "Medieval mode changes take effect after the next map change.\n" );
	}
}

#endif
ConVar tf_medieval( "tf_medieval", "0", FCVAR_REPLICATED | FCVAR_NOTIFY, "Enable Medieval Mode.\n", true, 0, true, 1
#ifdef GAME_DLL
				   , cc_tf_medieval_changed
#endif 
				    );

ConVar tf_medieval_autorp( "tf_medieval_autorp", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Enable Medieval Mode auto-roleplaying.\n", true, 0, true, 1 );

ConVar tf_sticky_radius_ramp_time( "tf_sticky_radius_ramp_time", "2.0", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT | FCVAR_REPLICATED, "Amount of time to get full radius after arming" );
ConVar tf_sticky_airdet_radius( "tf_sticky_airdet_radius", "0.85", FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT | FCVAR_REPLICATED, "Radius Scale if detonated in the air" );

#ifdef STAGING_ONLY
ConVar tf_killstreak_alwayson( "tf_killstreak_alwayson", "0", FCVAR_REPLICATED, "enable to have killstreak effects for all players, bots included");

#ifdef GAME_DLL
// Bounty Mode
ConVar tf_bountymode_currency_starting( "tf_bountymode_currency_starting", "1000", FCVAR_ARCHIVE, "How much new players start with when playing Bounty Mode.\n" );
ConVar tf_bountymode_currency_limit( "tf_bountymode_currency_limit", "0", FCVAR_ARCHIVE, "The maximum amount a player can hold in Bounty Mode.\n" );
ConVar tf_bountymode_currency_penalty_ondeath( "tf_bountymode_currency_penalty_ondeath", "0", FCVAR_ARCHIVE, "The percentage of unspent money players lose when they die in Bounty Mode.\n" );
ConVar tf_bountymode_upgrades_wipeondeath( "tf_bountymode_upgrades_wipeondeath", "0", FCVAR_ARCHIVE, "If set to true, wipe player/item upgrades on death.\n" );

void cc_bountymode_changed( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	ConVarRef var( pConVar );
	if ( var.IsValid() && TFGameRules() )
	{
		TFGameRules()->SetBountyMode( var.GetBool() );

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

		mp_restartgame_immediate.SetValue( 1 );

		if ( !g_pPopulationManager )
		{
			CreateEntityByName( "info_populator" );
		}
		
		int nCurrency = tf_bountymode_currency_starting.GetInt();
		if ( nCurrency > 0 )
		{
			// Give everyone starting money
			for ( int i = 0; i <= MAX_PLAYERS; ++i )
			{
				CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
				if ( !pPlayer )
					continue;

				pPlayer->SetCurrency( nCurrency );
			}
		}

		g_MannVsMachineUpgrades.LoadUpgradesFile();
		
		IGameEvent *pEvent = gameeventmanager->CreateEvent( "upgrades_file_changed" );
		if ( pEvent )
		{
			pEvent->SetString( "path", "" ); // Have the client load the default
			gameeventmanager->FireEvent( pEvent );
		}
	}
}
#endif // GAME_DLL

ConVar tf_bountymode( "tf_bountymode", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_ARCHIVE, "Allow upgrades and award currency for mission objectives and killing enemy players.\n", true, 0, true, 1
#ifdef GAME_DLL
					  , cc_bountymode_changed
#endif // GAME_DLL
					  );
#endif // STAGING_ONLY

#ifndef GAME_DLL
extern ConVar cl_burninggibs;
extern ConVar english;
ConVar tf_particles_disable_weather( "tf_particles_disable_weather", "0", FCVAR_ARCHIVE, "Disable particles related to weather effects." );
#endif

// arena mode cvars
ConVar tf_arena_force_class( "tf_arena_force_class", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT, "Forces players to play a random class each time they spawn." );
ConVar tf_arena_change_limit( "tf_arena_change_limit", "1", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY | FCVAR_CHEAT, "Number of times players can change their class when mp_force_random_class is being used." );
ConVar tf_arena_override_cap_enable_time( "tf_arena_override_cap_enable_time", "-1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Overrides the time (in seconds) it takes for the capture point to become enable, -1 uses the level designer specified time." );
ConVar tf_arena_override_team_size( "tf_arena_override_team_size", "0", FCVAR_REPLICATED, "Overrides the maximum team size in arena mode. Set to zero to keep the default behavior of 1/3 maxplayers.");
ConVar tf_arena_first_blood( "tf_arena_first_blood", "1", FCVAR_REPLICATED | FCVAR_NOTIFY, "Rewards the first player to get a kill each round." );
extern ConVar tf_arena_preround_time;
extern ConVar tf_arena_max_streak;
#if defined( _DEBUG ) || defined( STAGING_ONLY )
extern ConVar mp_developer;
#endif // _DEBUG || STAGING_ONLY

//=============================================================================
// HPE_BEGIN
// [msmith] Used for the client to tell the server that we're watching a movie or not.
//			Also contains the name of a movie if it's an in game video.
//=============================================================================
// Training mode cvars
ConVar tf_training_client_message( "tf_training_client_message", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "A simple way for the training client to communicate with the server." );
//=============================================================================
// HPE_END
//=============================================================================

#define TF_ARENA_MODE_FIRST_BLOOD_CRIT_TIME 5.0f
#define TF_ARENA_MODE_FAST_FIRST_BLOOD_TIME 20.0f
#define TF_ARENA_MODE_SLOW_FIRST_BLOOD_TIME 50.0f

#ifdef TF_RAID_MODE
// Raid mode
ConVar tf_gamemode_raid( "tf_gamemode_raid", "0", FCVAR_REPLICATED | FCVAR_NOTIFY );		// client needs access to this for IsRaidMode()
ConVar tf_raid_enforce_unique_classes( "tf_raid_enforce_unique_classes", "0", FCVAR_REPLICATED | FCVAR_NOTIFY );
ConVar tf_raid_respawn_time( "tf_raid_respawn_time", "5", FCVAR_REPLICATED | FCVAR_NOTIFY /*| FCVAR_CHEAT*/, "How long it takes for a Raider to respawn with his team after death." );
ConVar tf_raid_allow_all_classes( "tf_raid_allow_all_classes", "1", FCVAR_REPLICATED | FCVAR_NOTIFY );

ConVar tf_gamemode_boss_battle( "tf_gamemode_boss_battle", "0", FCVAR_REPLICATED | FCVAR_NOTIFY );

#ifdef GAME_DLL
ConVar tf_raid_allow_overtime( "tf_raid_allow_overtime", "0"/*, FCVAR_CHEAT*/ );
#endif // GAME_DLL
#endif // TF_RAID_MODE

enum { kMVM_MaxConnectedPlayers = 10, };

ConVar tf_mvm_min_players_to_start( "tf_mvm_min_players_to_start", "3", FCVAR_REPLICATED | FCVAR_NOTIFY, "Minimum number of players connected to start a countdown timer" );
ConVar tf_mvm_respec_enabled( "tf_mvm_respec_enabled", "1", FCVAR_CHEAT | FCVAR_REPLICATED, "Allow players to refund credits spent on player and item upgrades." );
ConVar tf_mvm_respec_limit( "tf_mvm_respec_limit", "0", FCVAR_CHEAT | FCVAR_REPLICATED, "The total number of respecs a player can earn.  Default: 0 (no limit).", true, 0.f, true, 100.f );
ConVar tf_mvm_respec_credit_goal( "tf_mvm_respec_credit_goal", "2000", FCVAR_CHEAT | FCVAR_REPLICATED, "When tf_mvm_respec_limit is non-zero, the total amount of money the team must collect to earn a respec credit." );
#ifdef STAGING_ONLY
ConVar tf_mvm_buybacks_method( "tf_mvm_buybacks_method", "1", FCVAR_REPLICATED | FCVAR_HIDDEN, "When set to 0, use the traditional, currency-based system.  When set to 1, use finite, charge-based system.", true, 0.0, true, 1.0 );
#else
ConVar tf_mvm_buybacks_method( "tf_mvm_buybacks_method", "0", FCVAR_REPLICATED | FCVAR_HIDDEN, "When set to 0, use the traditional, currency-based system.  When set to 1, use finite, charge-based system.", true, 0.0, true, 1.0 );
#endif 
ConVar tf_mvm_buybacks_per_wave( "tf_mvm_buybacks_per_wave", "3", FCVAR_REPLICATED | FCVAR_HIDDEN, "The fixed number of buybacks players can use per-wave." );


#ifdef GAME_DLL
enum { kMVM_CurrencyPackMinSize = 1, };
#endif // GAME_DLL

extern ConVar mp_tournament;
extern ConVar mp_tournament_post_match_period;

extern ConVar tf_flag_return_on_touch;
extern ConVar tf_flag_return_time_credit_factor;
ConVar tf_grapplinghook_enable( "tf_grapplinghook_enable", "0", FCVAR_REPLICATED );

#ifdef GAME_DLL
CUtlString s_strNextMvMPopFile;
CON_COMMAND_F( tf_mvm_popfile, "Change to a target popfile for MvM", FCVAR_GAMEDLL )
{
	// Listenserver host or rcon access only!
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	if ( args.ArgC() <= 1 )
	{
		if ( TFGameRules() && g_pPopulationManager )
		{
			const char *pszFile = g_pPopulationManager->GetPopulationFilename();
			if ( pszFile && pszFile[0] )
			{
				Msg( "Current popfile is: %s\n", pszFile );
				return;
			}
		}

		Msg( "Missing Popfile name\n" );
		return;
	}

	const char *pszShortName = args.Arg(1);

	if ( !TFGameRules() || !g_pPopulationManager )
	{
		Warning( "Cannot set population file before map load.\n" );
		return;
	}

	// Make sure we have a file system
	if ( !g_pFullFileSystem )
	{
		Msg( "No File System to find Popfile to load\n" );
		return;
	}

	// Form full path
	CUtlString fullPath;

	if ( g_pPopulationManager->FindPopulationFileByShortName( pszShortName, fullPath ) )
	{
		g_pPopulationManager->SetPopulationFilename( fullPath );
		g_pPopulationManager->ResetMap();
		return;
	}

	// Give them a message to make it clear what file we were looking for
	Warning( "Could not find a population file matching: %s.\n", pszShortName );
}

#ifdef STAGING_ONLY
// Never ship this
CON_COMMAND_F( tf_competitive_mode_force_victory, "For testing.", FCVAR_GAMEDLL )
{
	// Listenserver host or rcon access only!
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	CTFPlayer *pPlayer = ToTFPlayer( UTIL_GetCommandClient() );
	if ( !pPlayer )
		return;

	CSteamID steamIDForPlayer;
	if ( !pPlayer->GetSteamID( &steamIDForPlayer ) )
		return;

	// TODO: Rewrite this based on the shipping version of comp/casual
}
#endif // STAGING_ONLY
#endif

static bool BIsCvarIndicatingHolidayIsActive( int iCvarValue, /*EHoliday*/ int eHoliday )
{
	if ( iCvarValue == 0 )
		return false;

	// Unfortunately Holidays are not a proper bitfield
	switch ( eHoliday )
	{
	case kHoliday_TFBirthday:						return iCvarValue == kHoliday_TFBirthday;
	case kHoliday_Halloween:						return iCvarValue == kHoliday_Halloween || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines;
	case kHoliday_Christmas:						return iCvarValue == kHoliday_Christmas;
	case kHoliday_Valentines:						return iCvarValue == kHoliday_Valentines || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines;
	case kHoliday_MeetThePyro:						return iCvarValue == kHoliday_MeetThePyro;
	case kHoliday_FullMoon:							return iCvarValue == kHoliday_FullMoon || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines;
	case kHoliday_HalloweenOrFullMoon:				return iCvarValue == kHoliday_Halloween || iCvarValue == kHoliday_FullMoon || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines;
	case kHoliday_HalloweenOrFullMoonOrValentines:	return iCvarValue == kHoliday_Halloween || iCvarValue == kHoliday_FullMoon || iCvarValue == kHoliday_Valentines || iCvarValue == kHoliday_HalloweenOrFullMoon || iCvarValue == kHoliday_HalloweenOrFullMoonOrValentines;
	case kHoliday_AprilFools:						return iCvarValue == kHoliday_AprilFools;
	case kHoliday_EOTL:								return iCvarValue == kHoliday_EOTL;
	case kHoliday_CommunityUpdate:					return iCvarValue == kHoliday_CommunityUpdate;
	}

	return false;
}

// Fetch holiday setting taking into account convars, etc, but NOT
// taking into consideration the current game rules, map, etc.
//
// This version can be used outside of gameplay, ie., for matchmaking
bool TF_IsHolidayActive( /*EHoliday*/ int eHoliday )
{
	if ( IsX360() || tf_force_holidays_off.GetBool() )
		return false;

	if ( BIsCvarIndicatingHolidayIsActive( tf_forced_holiday.GetInt(), eHoliday ) )
		return true;

	if ( BIsCvarIndicatingHolidayIsActive( tf_item_based_forced_holiday.GetInt(), eHoliday ) )
		return true;

	if ( ( eHoliday == kHoliday_TFBirthday ) && tf_birthday.GetBool() )
		return true;

	if ( TFGameRules() )
	{
		if ( eHoliday == kHoliday_HalloweenOrFullMoon )
		{
			if ( TFGameRules()->IsHolidayMap( kHoliday_Halloween ) )
				return true;
			if ( TFGameRules()->IsHolidayMap( kHoliday_FullMoon ) )
				return true;
		}
		if ( TFGameRules()->IsHolidayMap( eHoliday ) )
		{
			return true;
		}
	}

	return UTIL_IsHolidayActive( eHoliday );
}

#ifdef TF_CREEP_MODE
ConVar tf_gamemode_creep_wave( "tf_gamemode_creep_wave", "0", FCVAR_REPLICATED | FCVAR_NOTIFY );
ConVar tf_creep_wave_player_respawn_time( "tf_creep_wave_player_respawn_time", "10", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_CHEAT, "How long it takes for a player to respawn with his team after death." );
#endif

#ifdef GAME_DLL
// TF overrides the default value of this convar

#ifdef _DEBUG
#define WAITING_FOR_PLAYERS_FLAGS	0
#else
#define WAITING_FOR_PLAYERS_FLAGS	FCVAR_DEVELOPMENTONLY
#endif

ConVar hide_server( "hide_server", "0", FCVAR_GAMEDLL, "Whether the server should be hidden from the master server" );

ConVar mp_waitingforplayers_time( "mp_waitingforplayers_time", (IsX360()?"15":"30"), FCVAR_GAMEDLL | WAITING_FOR_PLAYERS_FLAGS, "WaitingForPlayers time length in seconds" );

ConVar tf_gamemode_arena ( "tf_gamemode_arena", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_cp ( "tf_gamemode_cp", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_ctf ( "tf_gamemode_ctf", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_sd ( "tf_gamemode_sd", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_rd ( "tf_gamemode_rd", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_pd ( "tf_gamemode_pd", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_tc ( "tf_gamemode_tc", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_beta_content ( "tf_beta_content", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_payload ( "tf_gamemode_payload", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_mvm ( "tf_gamemode_mvm", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_passtime ( "tf_gamemode_passtime", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );
ConVar tf_gamemode_misc ( "tf_gamemode_misc", "0", FCVAR_REPLICATED | FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );

ConVar tf_bot_count( "tf_bot_count", "0", FCVAR_NOTIFY | FCVAR_DEVELOPMENTONLY );

#ifdef _DEBUG
ConVar tf_debug_ammo_and_health( "tf_debug_ammo_and_health", "0", FCVAR_CHEAT );
#endif // _DEBUG

static Vector s_BotSpawnPosition;

ConVar tf_gravetalk( "tf_gravetalk", "1", FCVAR_NOTIFY, "Allows living players to hear dead players using text/voice chat.", true, 0, true, 1 );

ConVar tf_ctf_bonus_time ( "tf_ctf_bonus_time", "10", FCVAR_NOTIFY, "Length of team crit time for CTF capture." );

#ifdef _DEBUG
ConVar mp_scrambleteams_debug( "mp_scrambleteams_debug", "0", FCVAR_NONE, "Debug spew." );
#endif // _DEBUG

#ifdef STAGING_ONLY
ConVar mp_tournament_readymode_bots_allowed( "mp_tournament_readymode_bots_allowed", "0", FCVAR_ARCHIVE, "Allow bot data to go through the system for debugging." );
#endif // STAGING_ONLY

extern ConVar tf_mm_servermode;
extern ConVar tf_flag_caps_per_round;

void cc_competitive_mode( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	IGameEvent *event = gameeventmanager->CreateEvent( "competitive_state_changed" );
	if ( event )
	{
		// Server-side here.  Client-side down below in the RecvProxy
		gameeventmanager->FireEvent( event, true );
	}
}
ConVar tf_competitive_preround_duration( "tf_competitive_preround_duration", "3", FCVAR_REPLICATED, "How long we stay in pre-round when in competitive games." );
ConVar tf_competitive_preround_countdown_duration( "tf_competitive_preround_countdown_duration", "10.5", FCVAR_HIDDEN, "How long we stay in countdown when in competitive games." );
ConVar tf_competitive_abandon_method( "tf_competitive_abandon_method", "0", FCVAR_HIDDEN );
ConVar tf_competitive_required_late_join_timeout( "tf_competitive_required_late_join_timeout", "120", FCVAR_DEVELOPMENTONLY,
                                                  "How long to wait for late joiners in matches requiring full player counts before canceling the match" );
ConVar tf_competitive_required_late_join_confirm_timeout( "tf_competitive_required_late_join_confirm_timeout", "30", FCVAR_DEVELOPMENTONLY,
                                                          "How long to wait for the GC to confirm we're in the late join pool before canceling the match" );
#endif // GAME_DLL

#ifdef GAME_DLL
void cc_powerup_mode( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	ConVarRef var( pConVar );
	if ( var.IsValid() )
	{
		if ( !TFGameRules() )
			return;

		if ( var.GetBool() )
		{
			if ( TFGameRules()->IsMannVsMachineMode() )
				return;
		}

		TFGameRules()->SetPowerupMode( var.GetBool() );
		TFGameRules()->State_Transition( GR_STATE_PREROUND );
		tf_flag_caps_per_round.SetValue( var.GetBool() ? 7 : 3 );	// Hack
	}
}

ConVar tf_powerup_mode( "tf_powerup_mode", "0", FCVAR_NOTIFY, "Enable/disable powerup mode. Not compatible with Mann Vs Machine mode", cc_powerup_mode );
ConVar tf_powerup_mode_imbalance_delta( "tf_powerup_mode_imbalance_delta", "24", FCVAR_CHEAT, "Powerup kill score lead one team must have before imbalance measures are initiated" );

ConVar tf_skillrating_update_interval( "tf_skillrating_update_interval", "180", FCVAR_ARCHIVE, "How often to update the GC and OGS." );

extern ConVar mp_teams_unbalance_limit;

static bool g_bRandomMap = false;

void cc_RandomMap( const CCommand& args )
{
	CTFGameRules *pRules = TFGameRules();
	if ( pRules )
	{
		if ( !UTIL_IsCommandIssuedByServerAdmin() )
			return;

		g_bRandomMap = true;
	}
	else
	{
		// There's no game rules object yet, so let's load the map cycle and pick a map.
		char mapcfile[MAX_PATH];
		CMultiplayRules::DetermineMapCycleFilename( mapcfile, sizeof(mapcfile), true );
		if ( !mapcfile[0] )
		{
			Msg( "No mapcyclefile specified. Cannot pick a random map.\n" );
			return;
		}

		CUtlVector<char*> mapList;
		// No gamerules entity yet, since we don't need the fixups to find a map just use the base version
		CMultiplayRules::RawLoadMapCycleFileIntoVector ( mapcfile, mapList );
		if ( !mapList.Count() )
		{
			Msg( "Map cycle file \"%s\" contains no valid maps or cannot be read. Cannot pick a random map.\n", mapcfile );
			return;
		}

		int iMapIndex = RandomInt( 0, mapList.Count() - 1 );
		Msg ( "randommap: selecting map %i out of %i\n", iMapIndex + 1, mapList.Count() );
		engine->ServerCommand( UTIL_VarArgs( "map %s\n", mapList[iMapIndex] ) );

		CMultiplayRules::FreeMapCycleFileVector( mapList );
	}
}

// Simple class for tracking previous gamemode across level transitions
// Allows clean-up of UI/state when going between things like MvM and PvP
class CTFGameModeHistory : public CAutoGameSystem
{
public:
	virtual bool Init()
	{
		m_nPrevState = 0;
		return true;
	}
	void SetPrevState( int nState ) { m_nPrevState = nState; }
	int	 GetPrevState( void ) { return m_nPrevState; }
private:
	int m_nPrevState;
} g_TFGameModeHistory;

static ConCommand randommap( "randommap", cc_RandomMap, "Changelevel to a random map in the mapcycle file" );
#endif	// GAME_DLL

#ifdef GAME_DLL
static bool PlayerHasDuckStreaks( CTFPlayer *pPlayer )
{
	CEconItemView *pActionItem = pPlayer->GetEquippedItemForLoadoutSlot( LOADOUT_POSITION_ACTION );
	if ( !pActionItem )
		return false;

	// Duck Badge Cooldown is based on badge level.  Noisemaker is more like an easter egg
	static CSchemaAttributeDefHandle pAttr_DuckStreaks( "duckstreaks active" );
	uint32 iDuckStreaksActive = 0;

	// Don't care about the level, just if the attribute is found
	return FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pActionItem, pAttr_DuckStreaks, &iDuckStreaksActive ) && iDuckStreaksActive > 0;
}

void ValidateCapturesPerRound( IConVar *pConVar, const char *oldValue, float flOldValue )
{
	ConVarRef var( pConVar );

	if ( var.GetInt() <= 0 )
	{
		// reset the flag captures being played in the current round
		int nTeamCount = TFTeamMgr()->GetTeamCount();
		for ( int iTeam = FIRST_GAME_TEAM; iTeam < nTeamCount; ++iTeam )
		{
			CTFTeam *pTeam = GetGlobalTFTeam( iTeam );
			if ( !pTeam )
				continue;

			pTeam->SetFlagCaptures( 0 );
		}
	}
}

static void Coaching_Start( CTFPlayer *pCoach, CTFPlayer *pStudent )
{
	pCoach->SetIsCoaching( true );
	pCoach->ForceChangeTeam( TEAM_SPECTATOR );
	pCoach->SetObserverTarget( pStudent );
	pCoach->StartObserverMode( OBS_MODE_CHASE );
	pCoach->SetStudent( pStudent );
	pStudent->SetCoach( pCoach );
}

static void Coaching_Stop( CTFPlayer *pCoach )
{
	CTFPlayer *pStudent = pCoach->GetStudent();
	if ( pStudent )
	{
		pStudent->SetCoach( NULL );
	}
	pCoach->SetIsCoaching( false );
	pCoach->SetStudent( NULL );
	pCoach->ForceChangeTeam( TEAM_SPECTATOR );
}

#endif	

ConVar tf_flag_caps_per_round( "tf_flag_caps_per_round", "3", FCVAR_REPLICATED, "Number of captures per round on CTF and PASS Time maps. Set to 0 to disable.", true, 0, false, 0
#ifdef GAME_DLL
							  , ValidateCapturesPerRound
#endif
							  );


/**
 * Player hull & eye position for standing, ducking, etc.  This version has a taller
 * player height, but goldsrc-compatible collision bounds.
 */
static CViewVectors g_TFViewVectors(
	Vector( 0, 0, 72 ),		//VEC_VIEW (m_vView) eye position
							
	Vector(-24, -24, 0 ),	//VEC_HULL_MIN (m_vHullMin) hull min
	Vector( 24,  24, 82 ),	//VEC_HULL_MAX (m_vHullMax) hull max
												
	Vector(-24, -24, 0 ),	//VEC_DUCK_HULL_MIN (m_vDuckHullMin) duck hull min
	Vector( 24,  24, 62 ),	//VEC_DUCK_HULL_MAX	(m_vDuckHullMax) duck hull max
	Vector( 0, 0, 45 ),		//VEC_DUCK_VIEW		(m_vDuckView) duck view
												
	Vector( -10, -10, -10 ),	//VEC_OBS_HULL_MIN	(m_vObsHullMin) observer hull min
	Vector(  10,  10,  10 ),	//VEC_OBS_HULL_MAX	(m_vObsHullMax) observer hull max
												
	Vector( 0, 0, 14 )		//VEC_DEAD_VIEWHEIGHT (m_vDeadViewHeight) dead view height
);							

Vector g_TFClassViewVectors[11] =
{
	Vector( 0, 0, 72 ),		// TF_CLASS_UNDEFINED

	Vector( 0, 0, 65 ),		// TF_CLASS_SCOUT,			// TF_FIRST_NORMAL_CLASS
	Vector( 0, 0, 75 ),		// TF_CLASS_SNIPER,
	Vector( 0, 0, 68 ),		// TF_CLASS_SOLDIER,
	Vector( 0, 0, 68 ),		// TF_CLASS_DEMOMAN,
	Vector( 0, 0, 75 ),		// TF_CLASS_MEDIC,
	Vector( 0, 0, 75 ),		// TF_CLASS_HEAVYWEAPONS,
	Vector( 0, 0, 68 ),		// TF_CLASS_PYRO,
	Vector( 0, 0, 75 ),		// TF_CLASS_SPY,
	Vector( 0, 0, 68 ),		// TF_CLASS_ENGINEER,

	Vector( 0, 0, 65 ),		// TF_CLASS_CIVILIAN,		// TF_LAST_NORMAL_CLASS
};

const CViewVectors *CTFGameRules::GetViewVectors() const
{
	return &g_TFViewVectors;
}

REGISTER_GAMERULES_CLASS( CTFGameRules );

#ifdef CLIENT_DLL
void RecvProxy_MatchSummary( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
	bool bMatchSummary = ( pData->m_Value.m_Int > 0 );
	if ( bMatchSummary && !(*(bool*)(pOut)))
	{
		C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
		if ( pLocalPlayer )
		{
			pLocalPlayer->TurnOffTauntCam();
			pLocalPlayer->TurnOffTauntCam_Finish();;
		}

		IGameEvent *event = gameeventmanager->CreateEvent( "show_match_summary" );
		if ( event )
		{
			gameeventmanager->FireEventClientSide( event );
		}
	}

	*(bool*)(pOut) = bMatchSummary;
}

void RecvProxy_CompetitiveMode( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
	*(bool*)(pOut) = ( pData->m_Value.m_Int > 0 );

	IGameEvent *event = gameeventmanager->CreateEvent( "competitive_state_changed" );
	if ( event )
	{
		// Client-side once it's actually happened
		gameeventmanager->FireEventClientSide( event );
	}
}

void RecvProxy_PlayerVotedForMap( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
	if ( *(int*)(pOut) != pData->m_Value.m_Int )
	{
		*(int*)(pOut) = pData->m_Value.m_Int;

		IGameEvent *event = gameeventmanager->CreateEvent( "player_next_map_vote_change" );
		if ( event )
		{
			event->SetInt( "map_index", pData->m_Value.m_Int );
			event->SetInt( "vote", pData->m_Value.m_Int );
			// Client-side once it's actually happened
			gameeventmanager->FireEventClientSide( event );
		}
	}
}

void RecvProxy_NewMapVoteStateChanged( const CRecvProxyData *pData, void *pStruct, void *pOut )
{
	bool bChange = *(int*)(pOut) != pData->m_Value.m_Int;
	*(int*)(pOut) = pData->m_Value.m_Int;

	if ( bChange )
	{
		IGameEvent *event = gameeventmanager->CreateEvent( "vote_maps_changed" );
		if ( event )
		{
			// Client-side once it's actually happened
			gameeventmanager->FireEventClientSide( event );
		}
	}
}
#endif

BEGIN_NETWORK_TABLE_NOBASE( CTFGameRules, DT_TFGameRules )
#ifdef CLIENT_DLL

	RecvPropInt( RECVINFO( m_nGameType ) ),
	RecvPropInt( RECVINFO( m_nStopWatchState ) ),
	RecvPropString( RECVINFO( m_pszTeamGoalStringRed ) ),
	RecvPropString( RECVINFO( m_pszTeamGoalStringBlue ) ),
	RecvPropTime( RECVINFO( m_flCapturePointEnableTime ) ),

//=============================================================================
// HPE_BEGIN:
// [msmith]	Training status and HUD Type.
//=============================================================================
	RecvPropInt( RECVINFO( m_nHudType ) ),
	RecvPropBool( RECVINFO( m_bIsInTraining ) ),
	RecvPropBool( RECVINFO( m_bAllowTrainingAchievements ) ),
	RecvPropBool( RECVINFO( m_bIsWaitingForTrainingContinue ) ),
//=============================================================================
// HPE_END
//=============================================================================
	RecvPropBool( RECVINFO( m_bIsTrainingHUDVisible ) ),
	RecvPropBool( RECVINFO( m_bIsInItemTestingMode ) ),

	RecvPropEHandle( RECVINFO( m_hBonusLogic ) ),
	RecvPropBool( RECVINFO( m_bPlayingKoth ) ),
	RecvPropBool( RECVINFO( m_bPlayingMedieval ) ),
	RecvPropBool( RECVINFO( m_bPlayingHybrid_CTF_CP ) ),
	RecvPropBool( RECVINFO( m_bPlayingSpecialDeliveryMode ) ),
	RecvPropBool( RECVINFO( m_bPlayingRobotDestructionMode ) ),
	RecvPropEHandle( RECVINFO( m_hRedKothTimer ) ),
	RecvPropEHandle( RECVINFO( m_hBlueKothTimer ) ),
	RecvPropInt( RECVINFO( m_nMapHolidayType ) ),

	RecvPropEHandle( RECVINFO( m_itHandle ) ),
	RecvPropBool( RECVINFO( m_bPlayingMannVsMachine ) ),
	RecvPropEHandle( RECVINFO( m_hBirthdayPlayer ) ),

	RecvPropInt( RECVINFO( m_nBossHealth ) ),
	RecvPropInt( RECVINFO( m_nMaxBossHealth ) ),
	RecvPropInt( RECVINFO( m_fBossNormalizedTravelDistance ) ),
	RecvPropBool( RECVINFO( m_bMannVsMachineAlarmStatus ) ),
	RecvPropBool( RECVINFO( m_bHaveMinPlayersToEnableReady ) ),

	RecvPropBool( RECVINFO( m_bBountyModeEnabled ) ),

	RecvPropInt( RECVINFO( m_nHalloweenEffect ) ),
	RecvPropFloat( RECVINFO( m_fHalloweenEffectStartTime ) ),
	RecvPropFloat( RECVINFO( m_fHalloweenEffectDuration ) ),
	RecvPropInt( RECVINFO( m_halloweenScenario ) ),
	RecvPropBool( RECVINFO( m_bHelltowerPlayersInHell ) ),
	RecvPropBool( RECVINFO( m_bIsUsingSpells ) ),
	RecvPropBool( RECVINFO( m_bCompetitiveMode ), 0, RecvProxy_CompetitiveMode ),
	RecvPropInt( RECVINFO( m_nMatchGroupType ) ),
	RecvPropBool( RECVINFO( m_bMatchEnded ) ),
	RecvPropBool( RECVINFO( m_bPowerupMode ) ),
	RecvPropString( RECVINFO( m_pszCustomUpgradesFile ) ),
	RecvPropBool( RECVINFO( m_bTruceActive ) ),
	RecvPropBool( RECVINFO( m_bShowMatchSummary ), 0, RecvProxy_MatchSummary ),
	RecvPropBool( RECVINFO_NAME( m_bShowMatchSummary, "m_bShowCompetitiveMatchSummary" ), 0, RecvProxy_MatchSummary ),     // Renamed
	RecvPropBool( RECVINFO( m_bTeamsSwitched ) ),
	RecvPropBool( RECVINFO( m_bMapHasMatchSummaryStage ) ),
	RecvPropBool( RECVINFO( m_bPlayersAreOnMatchSummaryStage ) ),
	RecvPropBool( RECVINFO( m_bStopWatchWinner ) ),
	RecvPropArray3( RECVINFO_ARRAY(m_ePlayerWantsRematch), RecvPropInt( RECVINFO(m_ePlayerWantsRematch[0]), 0, RecvProxy_PlayerVotedForMap ) ),
	RecvPropInt( RECVINFO( m_eRematchState ) ),
	RecvPropArray3( RECVINFO_ARRAY(m_nNextMapVoteOptions), RecvPropInt( RECVINFO(m_nNextMapVoteOptions[0]), 0, RecvProxy_NewMapVoteStateChanged ) ),
#else

	SendPropInt( SENDINFO( m_nGameType ), 4, SPROP_UNSIGNED ),
	SendPropInt( SENDINFO( m_nStopWatchState ), 3, SPROP_UNSIGNED ),
	SendPropString( SENDINFO( m_pszTeamGoalStringRed ) ),
	SendPropString( SENDINFO( m_pszTeamGoalStringBlue ) ),
	SendPropTime( SENDINFO( m_flCapturePointEnableTime ) ),

//=============================================================================
// HPE_BEGIN:
// [msmith]	Training status and hud type.
//=============================================================================
	SendPropInt( SENDINFO( m_nHudType ), 3, SPROP_UNSIGNED ),
	SendPropBool( SENDINFO( m_bIsInTraining ) ),
	SendPropBool( SENDINFO( m_bAllowTrainingAchievements ) ),
	SendPropBool( SENDINFO( m_bIsWaitingForTrainingContinue ) ),
//=============================================================================
// HPE_END
//=============================================================================
	SendPropBool( SENDINFO( m_bIsTrainingHUDVisible ) ),
	SendPropBool( SENDINFO( m_bIsInItemTestingMode ) ),

	SendPropEHandle( SENDINFO( m_hBonusLogic ) ),
	SendPropBool( SENDINFO( m_bPlayingKoth ) ),
	SendPropBool( SENDINFO( m_bPlayingMedieval ) ),
	SendPropBool( SENDINFO( m_bPlayingHybrid_CTF_CP ) ),
	SendPropBool( SENDINFO( m_bPlayingSpecialDeliveryMode ) ),
	SendPropBool( SENDINFO( m_bPlayingRobotDestructionMode ) ),
	SendPropEHandle( SENDINFO( m_hRedKothTimer ) ),
	SendPropEHandle( SENDINFO( m_hBlueKothTimer ) ),
	SendPropInt( SENDINFO( m_nMapHolidayType ), 3, SPROP_UNSIGNED ),

	SendPropEHandle( SENDINFO( m_itHandle ) ),
	SendPropBool( SENDINFO( m_bPlayingMannVsMachine ) ),
	SendPropEHandle( SENDINFO( m_hBirthdayPlayer ) ),

	SendPropInt( SENDINFO( m_nBossHealth ) ),
	SendPropInt( SENDINFO( m_nMaxBossHealth ) ),
	SendPropInt( SENDINFO( m_fBossNormalizedTravelDistance ) ),
	SendPropBool( SENDINFO( m_bMannVsMachineAlarmStatus ) ),
	SendPropBool( SENDINFO( m_bHaveMinPlayersToEnableReady ) ),

	SendPropBool( SENDINFO( m_bBountyModeEnabled ) ),

	SendPropInt( SENDINFO( m_nHalloweenEffect ) ),
	SendPropFloat( SENDINFO( m_fHalloweenEffectStartTime ) ),
	SendPropFloat( SENDINFO( m_fHalloweenEffectDuration ) ),
	SendPropInt( SENDINFO( m_halloweenScenario ) ),
	SendPropBool( SENDINFO( m_bHelltowerPlayersInHell ) ),
	SendPropBool( SENDINFO( m_bIsUsingSpells ) ),
	SendPropBool( SENDINFO( m_bCompetitiveMode ) ),
	SendPropBool( SENDINFO( m_bPowerupMode ) ),
	SendPropInt( SENDINFO( m_nMatchGroupType ) ),
	SendPropBool( SENDINFO( m_bMatchEnded ) ),
	SendPropString( SENDINFO( m_pszCustomUpgradesFile ) ),
	SendPropBool( SENDINFO( m_bTruceActive ) ),
	SendPropBool( SENDINFO( m_bShowMatchSummary ) ),
	SendPropBool( SENDINFO( m_bTeamsSwitched ) ),
	SendPropBool( SENDINFO( m_bMapHasMatchSummaryStage ) ),
	SendPropBool( SENDINFO( m_bPlayersAreOnMatchSummaryStage ) ),
	SendPropBool( SENDINFO( m_bStopWatchWinner ) ),
	SendPropArray3( SENDINFO_ARRAY3(m_ePlayerWantsRematch), SendPropInt( SENDINFO_ARRAY(m_ePlayerWantsRematch), -1, SPROP_UNSIGNED | SPROP_VARINT ) ),
	SendPropInt( SENDINFO( m_eRematchState ) ),
	SendPropArray3( SENDINFO_ARRAY3(m_nNextMapVoteOptions), SendPropInt( SENDINFO_ARRAY(m_nNextMapVoteOptions), -1, SPROP_UNSIGNED | SPROP_VARINT ) ),
#endif
END_NETWORK_TABLE()

LINK_ENTITY_TO_CLASS( tf_gamerules, CTFGameRulesProxy );
IMPLEMENT_NETWORKCLASS_ALIASED( TFGameRulesProxy, DT_TFGameRulesProxy )

#ifdef CLIENT_DLL
	void RecvProxy_TFGameRules( const RecvProp *pProp, void **pOut, void *pData, int objectID )
	{
		CTFGameRules *pRules = TFGameRules();
		Assert( pRules );
		*pOut = pRules;
	}

	BEGIN_RECV_TABLE( CTFGameRulesProxy, DT_TFGameRulesProxy )
		RecvPropDataTable( "tf_gamerules_data", 0, 0, &REFERENCE_RECV_TABLE( DT_TFGameRules ), RecvProxy_TFGameRules )
	END_RECV_TABLE()
#else
	void *SendProxy_TFGameRules( const SendProp *pProp, const void *pStructBase, const void *pData, CSendProxyRecipients *pRecipients, int objectID )
	{
		CTFGameRules *pRules = TFGameRules();
		Assert( pRules );
		pRecipients->SetAllRecipients();
		return pRules;
	}

	BEGIN_SEND_TABLE( CTFGameRulesProxy, DT_TFGameRulesProxy )
		SendPropDataTable( "tf_gamerules_data", 0, &REFERENCE_SEND_TABLE( DT_TFGameRules ), SendProxy_TFGameRules )
	END_SEND_TABLE()
#endif

#ifdef GAME_DLL
BEGIN_DATADESC( CTFGameRulesProxy )
//=============================================================================
// HPE_BEGIN:
// [msmith]	Training HUD type
//=============================================================================
	DEFINE_KEYFIELD( m_nHudType, FIELD_INTEGER, "hud_type" ),
//=============================================================================
// HPE_END
//=============================================================================

	DEFINE_KEYFIELD( m_bOvertimeAllowedForCTF, FIELD_BOOLEAN, "ctf_overtime" ),

	// Inputs.
	DEFINE_INPUTFUNC( FIELD_FLOAT, "SetRedTeamRespawnWaveTime", InputSetRedTeamRespawnWaveTime ),
	DEFINE_INPUTFUNC( FIELD_FLOAT, "SetBlueTeamRespawnWaveTime", InputSetBlueTeamRespawnWaveTime ),
	DEFINE_INPUTFUNC( FIELD_FLOAT, "AddRedTeamRespawnWaveTime", InputAddRedTeamRespawnWaveTime ),
	DEFINE_INPUTFUNC( FIELD_FLOAT, "AddBlueTeamRespawnWaveTime", InputAddBlueTeamRespawnWaveTime ),
	DEFINE_INPUTFUNC( FIELD_STRING, "SetRedTeamGoalString", InputSetRedTeamGoalString ),
	DEFINE_INPUTFUNC( FIELD_STRING, "SetBlueTeamGoalString", InputSetBlueTeamGoalString ),
	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetRedTeamRole", InputSetRedTeamRole ),
	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetBlueTeamRole", InputSetBlueTeamRole ),
	DEFINE_INPUTFUNC( FIELD_STRING, "SetRequiredObserverTarget", InputSetRequiredObserverTarget ),
	DEFINE_INPUTFUNC( FIELD_INTEGER, "AddRedTeamScore", InputAddRedTeamScore ),
	DEFINE_INPUTFUNC( FIELD_INTEGER, "AddBlueTeamScore", InputAddBlueTeamScore ),
	DEFINE_INPUTFUNC( FIELD_VOID, "SetRedKothClockActive", InputSetRedKothClockActive ),
	DEFINE_INPUTFUNC( FIELD_VOID, "SetBlueKothClockActive", InputSetBlueKothClockActive ),
	DEFINE_INPUTFUNC( FIELD_FLOAT, "SetCTFCaptureBonusTime", InputSetCTFCaptureBonusTime ),
	DEFINE_INPUTFUNC( FIELD_STRING, "PlayVORed", InputPlayVORed ),
	DEFINE_INPUTFUNC( FIELD_STRING, "PlayVOBlue", InputPlayVOBlue ),
	DEFINE_INPUTFUNC( FIELD_STRING, "PlayVO", InputPlayVO ),
	DEFINE_INPUTFUNC( FIELD_STRING, "HandleMapEvent", InputHandleMapEvent ),
	DEFINE_INPUTFUNC( FIELD_STRING, "SetCustomUpgradesFile", InputSetCustomUpgradesFile ),
	DEFINE_INPUTFUNC( FIELD_INTEGER, "SetRoundRespawnFreezeEnabled", InputSetRoundRespawnFreezeEnabled ),
	DEFINE_INPUTFUNC( FIELD_BOOLEAN, "SetMapForcedTruceDuringBossFight", InputSetMapForcedTruceDuringBossFight ),

	DEFINE_OUTPUT( m_OnWonByTeam1,	"OnWonByTeam1" ),
	DEFINE_OUTPUT( m_OnWonByTeam2,	"OnWonByTeam2" ),
	DEFINE_OUTPUT( m_Team1PlayersChanged,	"Team1PlayersChanged" ),
	DEFINE_OUTPUT( m_Team2PlayersChanged,	"Team2PlayersChanged" ),
	DEFINE_OUTPUT( m_OnPowerupImbalanceTeam1, "OnPowerupImbalanceTeam1" ),
	DEFINE_OUTPUT( m_OnPowerupImbalanceTeam2, "OnPowerupImbalanceTeam2" ),
	DEFINE_OUTPUT( m_OnPowerupImbalanceMeasuresOver, "OnPowerupImbalanceMeasuresOver" ),
	DEFINE_OUTPUT( m_OnStateEnterRoundRunning, "OnStateEnterRoundRunning" ),
	DEFINE_OUTPUT( m_OnStateEnterBetweenRounds, "OnStateEnterBetweenRounds" ),
	DEFINE_OUTPUT( m_OnStateEnterPreRound, "OnStateEnterPreRound" ),
	DEFINE_OUTPUT( m_OnStateExitPreRound, "OnStateExitPreRound" ),
	DEFINE_OUTPUT( m_OnMatchSummaryStart, "OnMatchSummaryStart" ),
	DEFINE_OUTPUT( m_OnTruceStart, "OnTruceStart" ),
	DEFINE_OUTPUT( m_OnTruceEnd, "OnTruceEnd" ),
END_DATADESC()

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFGameRulesProxy::CTFGameRulesProxy()
{
	m_nHudType = TF_HUDTYPE_UNDEFINED;
	m_bOvertimeAllowedForCTF = true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputAddRedTeamScore( inputdata_t &inputdata )
{
	TFTeamMgr()->AddTeamScore( TF_TEAM_RED, inputdata.value.Int() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputAddBlueTeamScore( inputdata_t &inputdata )
{
	TFTeamMgr()->AddTeamScore( TF_TEAM_BLUE, inputdata.value.Int() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRedKothClockActive( inputdata_t &inputdata )
{
	if ( TFGameRules() )
	{
		variant_t sVariant;
		CTeamRoundTimer *pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_BLUE );
		if ( pTimer )
		{
			pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
		}

		pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_RED );
		if ( pTimer )
		{
			pTimer->AcceptInput( "Resume", NULL, NULL, sVariant, 0 );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetCTFCaptureBonusTime( inputdata_t &inputdata )
{
	if ( TFGameRules() )
	{
		TFGameRules()->SetCTFCaptureBonusTime( inputdata.value.Float() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetBlueKothClockActive( inputdata_t &inputdata )
{
	if ( TFGameRules() )
	{
		variant_t sVariant;
		CTeamRoundTimer *pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_BLUE );
		if ( pTimer )
		{
			pTimer->AcceptInput( "Resume", NULL, NULL, sVariant, 0 );
		}

		pTimer = TFGameRules()->GetKothTeamTimer( TF_TEAM_RED );
		if ( pTimer )
		{
			pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRequiredObserverTarget( inputdata_t &inputdata )
{
	const char *pszEntName = inputdata.value.String();
	CBaseEntity *pEnt = NULL;

	if ( pszEntName && pszEntName[0] )
	{
		pEnt = gEntList.FindEntityByName( NULL, pszEntName );
	}

	TFGameRules()->SetRequiredObserverTarget( pEnt );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRedTeamRespawnWaveTime( inputdata_t &inputdata )
{
	TFGameRules()->SetTeamRespawnWaveTime( TF_TEAM_RED, inputdata.value.Float() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetBlueTeamRespawnWaveTime( inputdata_t &inputdata )
{
	TFGameRules()->SetTeamRespawnWaveTime( TF_TEAM_BLUE, inputdata.value.Float() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputAddRedTeamRespawnWaveTime( inputdata_t &inputdata )
{
	TFGameRules()->AddTeamRespawnWaveTime( TF_TEAM_RED, inputdata.value.Float() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputAddBlueTeamRespawnWaveTime( inputdata_t &inputdata )
{
	TFGameRules()->AddTeamRespawnWaveTime( TF_TEAM_BLUE, inputdata.value.Float() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRedTeamGoalString( inputdata_t &inputdata )
{
	TFGameRules()->SetTeamGoalString( TF_TEAM_RED, inputdata.value.String() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetBlueTeamGoalString( inputdata_t &inputdata )
{
	TFGameRules()->SetTeamGoalString( TF_TEAM_BLUE, inputdata.value.String() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRedTeamRole( inputdata_t &inputdata )
{
	CTFTeam *pTeam = TFTeamMgr()->GetTeam( TF_TEAM_RED );
	if ( pTeam )
	{
		pTeam->SetRole( inputdata.value.Int() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetBlueTeamRole( inputdata_t &inputdata )
{
	CTFTeam *pTeam = TFTeamMgr()->GetTeam( TF_TEAM_BLUE );
	if ( pTeam )
	{
		pTeam->SetRole( inputdata.value.Int() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Pass in a VO sound entry to play for RED
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputPlayVORed( inputdata_t &inputdata )
{
	const char *szSoundName = inputdata.value.String();
	if ( szSoundName )
	{
		TFGameRules()->BroadcastSound( TF_TEAM_RED, szSoundName );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Pass in a VO sound entry to play for BLUE
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputPlayVOBlue( inputdata_t &inputdata )
{
	const char *szSoundName = inputdata.value.String();
	if ( szSoundName )
	{
		TFGameRules()->BroadcastSound( TF_TEAM_BLUE, szSoundName );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Pass in a VO sound entry to play
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputPlayVO( inputdata_t &inputdata )
{
	const char *szSoundName = inputdata.value.String();
	if ( szSoundName )
	{
		TFGameRules()->BroadcastSound( 255, szSoundName );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputHandleMapEvent( inputdata_t &inputdata )
{
	if ( TFGameRules() )
	{
		TFGameRules()->HandleMapEvent( inputdata );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetCustomUpgradesFile( inputdata_t &inputdata )
{
	if ( TFGameRules() )
	{
		TFGameRules()->SetCustomUpgradesFile( inputdata );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetRoundRespawnFreezeEnabled( inputdata_t &inputdata )
{
	tf_player_movement_restart_freeze.SetValue( inputdata.value.Bool() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::InputSetMapForcedTruceDuringBossFight( inputdata_t &inputdata )
{
	if ( TFGameRules() )
	{
		TFGameRules()->SetMapForcedTruceDuringBossFight( inputdata.value.Bool() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::Activate()
{
	TFGameRules()->Activate();

//=============================================================================
// HPE_BEGIN:
// [msmith]	We added a HUDTYPE so that the objective and the HUD are independent.
//			This lets us have a non training HUD on a training map.  And a training
//			HUD on another type of map.
//=============================================================================
	if ( m_nHudType != TF_HUDTYPE_UNDEFINED )
	{
		TFGameRules()->SetHUDType( m_nHudType );
	}
//=============================================================================
// HPE_END
//=============================================================================

	TFGameRules()->SetOvertimeAllowedForCTF( m_bOvertimeAllowedForCTF );

	ListenForGameEvent( "teamplay_round_win" );

	BaseClass::Activate();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::TeamPlayerCountChanged( CTFTeam *pTeam )
{
	if ( pTeam == TFTeamMgr()->GetTeam( TF_TEAM_RED ) )
	{
		m_Team1PlayersChanged.Set( pTeam->GetNumPlayers(), this, this );
	}
	else if ( pTeam == TFTeamMgr()->GetTeam( TF_TEAM_BLUE ) )
	{
		m_Team2PlayersChanged.Set( pTeam->GetNumPlayers(), this, this );
	}

	// Tell the clients
	IGameEvent *event = gameeventmanager->CreateEvent( "teams_changed" );
	if ( event )
	{
		gameeventmanager->FireEvent( event );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::PowerupTeamImbalance( int nTeam )
{
	switch ( nTeam )
	{
	case TF_TEAM_RED:
		m_OnPowerupImbalanceTeam1.FireOutput( this, this );
		break;
	case TF_TEAM_BLUE:
		m_OnPowerupImbalanceTeam2.FireOutput( this, this );
		break;
	default:
		m_OnPowerupImbalanceMeasuresOver.FireOutput( this, this );
		break;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::StateEnterRoundRunning( void )
{
	m_OnStateEnterRoundRunning.FireOutput( this, this );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::StateEnterBetweenRounds( void )
{
	m_OnStateEnterBetweenRounds.FireOutput( this, this );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::StateEnterPreRound( void )
{
	m_OnStateEnterPreRound.FireOutput( this, this );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::StateExitPreRound( void )
{
	m_OnStateExitPreRound.FireOutput( this, this );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::MatchSummaryStart( void )
{
	m_OnMatchSummaryStart.FireOutput( this, this );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::TruceStart( void )
{
	m_OnTruceStart.FireOutput( this, this );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::TruceEnd( void )
{
	m_OnTruceEnd.FireOutput( this, this );
}
#endif

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRulesProxy::FireGameEvent( IGameEvent *event )
{
#ifdef GAME_DLL
	const char *pszEventName = event->GetName();

	if ( FStrEq( pszEventName, "teamplay_round_win" ) )
	{
		int iWinningTeam = event->GetInt( "team" );

		switch( iWinningTeam )
		{
		case TF_TEAM_RED:
			m_OnWonByTeam1.FireOutput( this, this );
			break;
		case TF_TEAM_BLUE:
			m_OnWonByTeam2.FireOutput( this, this );
			break;
		default:
			break;
		}
	}
#endif
}

// (We clamp ammo ourselves elsewhere).
ConVar ammo_max( "ammo_max", "5000", FCVAR_REPLICATED );

#ifndef CLIENT_DLL
ConVar sk_plr_dmg_grenade( "sk_plr_dmg_grenade","0");		// Very lame that the base code needs this defined
#endif

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : iDmgType - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFGameRules::Damage_IsTimeBased( int iDmgType )
{
	// Damage types that are time-based.
	return ( ( iDmgType & ( DMG_PARALYZE | DMG_NERVEGAS | DMG_DROWNRECOVER ) ) != 0 );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : iDmgType - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFGameRules::Damage_ShowOnHUD( int iDmgType )
{
	// Damage types that have client HUD art.
	return ( ( iDmgType & ( DMG_DROWN | DMG_BURN | DMG_NERVEGAS | DMG_SHOCK ) ) != 0 );
}
//-----------------------------------------------------------------------------
// Purpose: 
// Input  : iDmgType - 
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CTFGameRules::Damage_ShouldNotBleed( int iDmgType )
{
	// Should always bleed currently.
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFGameRules::Damage_GetTimeBased( void )
{
	int iDamage = ( DMG_PARALYZE | DMG_NERVEGAS | DMG_DROWNRECOVER );
	return iDamage;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFGameRules::Damage_GetShowOnHud( void )
{
	int iDamage = ( DMG_DROWN | DMG_BURN | DMG_NERVEGAS | DMG_SHOCK );
	return iDamage;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int	CTFGameRules::Damage_GetShouldNotBleed( void )
{
	return 0;
}

//-----------------------------------------------------------------------------
// Return true if we are playing a PvE mode
//-----------------------------------------------------------------------------
bool CTFGameRules::IsPVEModeActive( void ) const
{
#ifdef TF_RAID_MODE
	if ( IsRaidMode() || IsBossBattleMode() )
		return true;
#endif

	if ( IsMannVsMachineMode() )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Return true for PvE opponents (ie: enemy bot team)
//-----------------------------------------------------------------------------
bool CTFGameRules::IsPVEModeControlled( CBaseEntity *who ) const
{
	if ( !who )
	{
		return false;
	}

#ifdef GAME_DLL
	if ( IsMannVsMachineMode() )
	{
		return who->GetTeamNumber() == TF_TEAM_PVE_INVADERS ? true : false;
	}

	if ( IsPVEModeActive() )
	{
		return who->GetTeamNumber() == TF_TEAM_RED ? true : false;
	}
#endif

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: Return true if engineers can build quickly now
//-----------------------------------------------------------------------------
bool CTFGameRules::IsQuickBuildTime( void )
{
	return IsMannVsMachineMode() && ( InSetup() || TFObjectiveResource()->GetMannVsMachineIsBetweenWaves() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::GameModeUsesUpgrades( void )
{
	if ( IsMannVsMachineMode() || IsBountyMode() )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::CanPlayerUseRespec( CTFPlayer *pTFPlayer )
{
	if ( !pTFPlayer )
		return false;

	bool bAllowed = IsMannVsMachineRespecEnabled() && State_Get() == GR_STATE_BETWEEN_RNDS;

#ifdef GAME_DLL
	if ( !g_pPopulationManager )
		return false;

	bAllowed &= ( g_pPopulationManager->GetNumRespecsAvailableForPlayer( pTFPlayer ) ) ? true : false;
#else
	if ( !g_TF_PR )
		return false;

	bAllowed &= ( g_TF_PR->GetNumRespecCredits( pTFPlayer->entindex() ) ) ? true : false;
#endif
	
	return bAllowed;
}

bool CTFGameRules::IsCompetitiveMode( void ) const
{
	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
	if ( pMatchDesc )
	{
		return pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_COMPETITIVE
			|| pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_CASUAL;
	}

	return false;
}

bool CTFGameRules::IsMatchTypeCasual( void ) const
{
	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
	if ( pMatchDesc )
	{
		return ( pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_CASUAL );
	}

	return false;
}

bool CTFGameRules::IsMatchTypeCompetitive( void ) const
{
	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
	if ( pMatchDesc )
	{
		return ( pMatchDesc->m_params.m_eMatchType == MATCH_TYPE_COMPETITIVE );
	}

	return false;
}

bool CTFGameRules::BInMatchStartCountdown() const
{
	if ( IsCompetitiveMode() )
	{
		float flTime = GetRoundRestartTime();
		if ( ( flTime > 0.f ) && ( (int)( flTime - gpGlobals->curtime ) <= mp_tournament_readymode_countdown.GetInt() ) )
		{
			return true;
		}
	}

	return false;
}

EMatchGroup CTFGameRules::GetCurrentMatchGroup() const
{
#if defined STAGING_ONLY && defined CLIENT_DLL
	if ( tf_fake_mm_group.GetInt() != -1 )
	{
		return (EMatchGroup)tf_fake_mm_group.GetInt();
	}
#endif

#ifdef GAME_DLL
	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	return pMatch ? pMatch->m_eMatchGroup : k_nMatchGroup_Invalid;
#else
	// Client
	// We only care about what the server says if we are in an MM match.  We pass false
	// into BConnectedToMatch because we want the match group of the server EVEN IF
	// the match is over, but we're still connected.
	return GTFGCClientSystem()->BConnectedToMatchServer( false ) ? (EMatchGroup)m_nMatchGroupType.Get() : k_nMatchGroup_Invalid;
#endif
}

bool CTFGameRules::IsManagedMatchEnded() const
{
#ifdef GAME_DLL
	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	return !pMatch || pMatch->BMatchTerminated();
#else
	// Client
	// We only care about what the server says if we are in an MM match.  (Note that the GC client system calls this to
	// determine if an MM server considers the match over, so beware circular logic)
	return !GTFGCClientSystem()->BConnectedToMatchServer( true ) || m_bMatchEnded;
#endif
}

#ifdef GAME_DLL
//-----------------------------------------------------------------------------
void CTFGameRules::SyncMatchSettings()
{
	// These mirror the MatchInfo for the client's sake.
	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();

	m_nMatchGroupType.Set( pMatch ? pMatch->m_eMatchGroup : k_nMatchGroup_Invalid );
	m_bMatchEnded.Set( IsManagedMatchEnded() );
}

//-----------------------------------------------------------------------------
bool CTFGameRules::StartManagedMatch()
{
	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	if ( !pMatch )
	{
		Warning( "Starting a managed match with no match info\n" );
		return false;
	}

	// Cleanup
	m_eRematchState = NEXT_MAP_VOTE_STATE_NONE;

	/// Sync these before level change, so there's no race condition where clients may connect during/before the
	/// changelevel and see that the match is ended or wrong.
	SyncMatchSettings();

	// Change the the correct map from the match.  If no match specified, perform a fresh load of the current map
	const char *pszMap = pMatch->GetMatchMap();
	if ( !pszMap )
	{
		pszMap = STRING( gpGlobals->mapname );
		Warning( "Managed match did not specify map, using current map (%s)\n", pszMap );
	}

	engine->ServerCommand( CFmtStr( "changelevel %s\n", pszMap ) );

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetCompetitiveMode( bool bValue )
{
	m_bCompetitiveMode.Set( bValue );
	//// Competitive mode is only supported on official servers.
	//// It requires matchmaking, and doesn't allow ad-hoc connections.
	//// If cheats are ever enabled, we force this mode off.

	//tf_mm_trusted.SetValue( bValue );
	//mp_tournament.SetValue( bValue );
	//mp_tournament_readymode.SetValue( bValue );

	//// No ad-hoc connections
	//tf_mm_strict.SetValue( bValue );

	//if ( bValue )
	//{
	//	engine->ServerCommand( "exec server_ladder.cfg\n" );

	//	Assert( tf_mm_servermode.GetInt() == 1 );
	//}

	//// Any state toggle is a reset (so don't spam this call)
	//State_Transition( GR_STATE_PREROUND );
	//SetInWaitingForPlayers( bValue );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::StartCompetitiveMatch( void )
{
	m_flSafeToLeaveTimer = -1.f;

	SetInWaitingForPlayers( false );
	RoundRespawn();
	State_Transition( GR_STATE_RESTART );
	ResetPlayerAndTeamReadyState();
}

//-----------------------------------------------------------------------------
// Purpose: Stops a match for some specified reason
//-----------------------------------------------------------------------------
void CTFGameRules::StopCompetitiveMatch( CMsgGC_Match_Result_Status nCode )
{
	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	int nActiveMatchPlayers = pMatch->GetNumActiveMatchPlayers();
	if ( BAttemptMapVoteRollingMatch() &&
		nCode == CMsgGC_Match_Result_Status_MATCH_SUCCEEDED &&
		nActiveMatchPlayers > 0 )
	{
		ChooseNextMapVoteOptions();
	}
	else
	{
		// If we're not attempting a rolling match, end it
		// TODO ROLLING MATCHES: If we bail between now and RequestNewMatchForLobby, we need to call this or we'll get stuck.
		if ( !IsManagedMatchEnded() )
		{
			GTFGCClientSystem()->EndManagedMatch( /* bKickPlayersToParties */ false );
			Assert( IsManagedMatchEnded() );
			m_bMatchEnded.Set( true );
		}
	}

	if ( nCode == CMsgGC_Match_Result_Status_MATCH_SUCCEEDED )
	{
		IGameEvent *winEvent = gameeventmanager->CreateEvent( "competitive_victory" );
		if ( winEvent )
		{
			gameeventmanager->FireEvent( winEvent );
		}

		//
		// This determines new ratings and creates the GC messages
		//

		CMatchInfo *pInfo = GTFGCClientSystem()->GetMatch();
		if ( pInfo )
		{
			pInfo->CalculateMatchSkillRatingAdjustments( m_iWinningTeam );

			// Performance ranking with medals is currently server-side
			if ( pInfo->CalculatePlayerMatchRankData() )
			{
				// Send scoreboard event with final data
				int nPlayers = pInfo->GetNumTotalMatchPlayers();
				for ( int idx = 0; idx < nPlayers; idx++ )
				{
					IGameEvent *pEvent = gameeventmanager->CreateEvent( "competitive_stats_update" );
					if ( pEvent )
					{
						CMatchInfo::PlayerMatchData_t *pMatchRankData = pInfo->GetMatchDataForPlayer( idx );

						CBasePlayer *pPlayer = UTIL_PlayerBySteamID( pMatchRankData->steamID );
						if ( !pPlayer )
							continue;

						pEvent->SetInt( "index", pPlayer->entindex() );
						pEvent->SetInt( "score_rank", pMatchRankData ? pMatchRankData->nScoreMedal : 0 );		// medal won (if any)
						pEvent->SetInt( "kills_rank", pMatchRankData ? pMatchRankData->nKillsMedal : 0 );		//
						pEvent->SetInt( "damage_rank", pMatchRankData ? pMatchRankData->nDamageMedal : 0 );		//
						pEvent->SetInt( "healing_rank", pMatchRankData ? pMatchRankData->nHealingMedal : 0 );	//
						pEvent->SetInt( "support_rank", pMatchRankData ? pMatchRankData->nSupportMedal : 0 );	//
						gameeventmanager->FireEvent( pEvent );
					}
				}
			}
		}
		else
		{
			Warning( "CalculatePlayerMatchRankData(): General failure (investigate).\n" );
		}

		ReportMatchResultsToGC( nCode );
	}
	else if ( nCode == CMsgGC_Match_Result_Status_MATCH_FAILED_ABANDON )
	{
		// This generates a "safe to leave" notification on clients
		IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_abandoned_match" );
		if ( pEvent )
		{
			pEvent->SetBool( "game_over", ( tf_competitive_abandon_method.GetBool() || State_Get() == GR_STATE_BETWEEN_RNDS ) );
			gameeventmanager->FireEvent( pEvent );
		}

		ReportMatchResultsToGC( nCode );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Fully completes the match
//-----------------------------------------------------------------------------
void CTFGameRules::EndCompetitiveMatch( void )
{
	MatchSummaryEnd();

	Log( "Competitive match ended.  Kicking all players.\n" );
	engine->ServerCommand( "kickall #TF_Competitive_Disconnect\n" );

	// Prepare for next match
	g_fGameOver = false;
	m_bAllowBetweenRounds = true;
	State_Transition( GR_STATE_RESTART );
	SetInWaitingForPlayers( true );
}

//-----------------------------------------------------------------------------
// Purpose: Called during CTFGameRules::Think()
//-----------------------------------------------------------------------------
void CTFGameRules::ManageCompetitiveMode( void )
{
	if ( !IsCompetitiveMode() )
		return;

	// Bring this back when we ship?
// 	// Security check
// 	if ( !tf_skillrating_debug.GetBool() )
// 	{
// 		m_bCompetitiveMode &= tf_mm_trusted.GetBool() &&
// 							  IsInTournamentMode() &&
// 							  !HaveCheatsBeenEnabledDuringLevel();
// 	}

	// We lost trusted status
	if ( !tf_mm_trusted.GetBool() )
	{
		m_nMatchGroupType.Set( k_nMatchGroup_Invalid );
		StopCompetitiveMatch( CMsgGC_Match_Result_Status_MATCH_FAILED_TRUSTED );
		UTIL_ClientPrintAll( HUD_PRINTCENTER, "Exiting Competitive Mode!" );
		Log( "Server lost trusted status.  Exiting Competitive Mode!" );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::ReportMatchResultsToGC( CMsgGC_Match_Result_Status nCode )
{
	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	if ( !pMatch )
		return false;

	GCSDK::CProtoBufMsg< CMsgGC_Match_Result > *pMsg = new GCSDK::CProtoBufMsg< CMsgGC_Match_Result >( k_EMsgGC_Match_Result );

	pMsg->Body().set_match_id( pMatch->m_nMatchID );
	pMsg->Body().set_match_group( pMatch->m_eMatchGroup );
	pMsg->Body().set_status( nCode );
	pMsg->Body().set_duration( CTF_GameStats.m_currentMap.m_Header.m_iTotalTime + ( gpGlobals->curtime - m_flRoundStartTime ) );

	CTeam *pTeam = GetGlobalTeam( TF_TEAM_RED );
	pMsg->Body().set_red_score( pTeam ? pTeam->GetScore() : (uint32)-1 );
	pTeam = GetGlobalTeam( TF_TEAM_BLUE );
	pMsg->Body().set_blue_score( pTeam ? pTeam->GetScore() : (uint32)-1 );
	Assert( m_iWinningTeam >= 0 );
	pMsg->Body().set_winning_team( Max( 0, (int)m_iWinningTeam ) );
	const MapDef_t *pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) );
	pMsg->Body().set_map_index( ( pMap ) ? pMap->m_nDefIndex : 0 );
	pMsg->Body().set_game_type( 1 );	// TODO: eMapGameType

	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( pMatch->m_eMatchGroup );
	if( !pMatchDesc || !pMatchDesc->m_pProgressionDesc )
		return false;

	int nTotalScore = 0;

	CTFPlayerResource *pTFResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource );
	if ( pTFResource )
	{
		pTFResource->UpdatePlayerData();

		for ( int i=0; i < MAX_PLAYERS; ++i )
		{
			nTotalScore += pTFResource->GetTotalScore( i );
		}
	}

	float flBlueScoreRatio = 0.5f;

	const CTFTeam* pTFTeamRed = GetGlobalTFTeam( TF_TEAM_RED );
	const CTFTeam* pTFTeamBlue = GetGlobalTFTeam( TF_TEAM_BLUE );

	// Figure out how much XP to give each team based on the game mode played
	if ( HasMultipleTrains() )
	{
		// In PLR we want to use the distance along the tracks each of the 
		// trains were at the end of each round
		flBlueScoreRatio = RemapValClamped( pTFTeamBlue->GetTotalPLRTrackPercentTraveled(), 0.f, pTFTeamBlue->GetTotalPLRTrackPercentTraveled() + pTFTeamRed->GetTotalPLRTrackPercentTraveled(), 0.f, 1.f );
	}
	else if ( !m_bPlayingKoth && !m_bPowerupMode && ( tf_gamemode_cp.GetInt() || tf_gamemode_sd.GetInt() || tf_gamemode_payload.GetInt() ) )
	{
		// Rounds Won
		// CP -	Points can flow back and forever, so we can't count total caps. And the
		//		state of the game is always the same at match end, so rounds won is our
		//		only real metric.
		// SD -	A flag cap is a round, so we could count caps or rounds here.  Again, the
		//		flag can go back and forth forever, but the match end state is always the same.
		// PL - Count the points captured by each team.  We do this A/D style where each team has
		//		a chance to score points.
		flBlueScoreRatio = RemapValClamped( pTFTeamBlue->GetScore(), 0.f, pTFTeamBlue->GetScore() + pTFTeamRed->GetScore() , 0.f, 1.f );
	}
	else if ( tf_gamemode_ctf.GetInt() || m_bPowerupMode || tf_gamemode_passtime.GetInt() )
	{
		// Flag captures
		// Mannpower is a variant of CTF and Passtime effectively is CTF. In all of these modes
		// we don't use rounds so our best metric is individual flag captures.
		flBlueScoreRatio = RemapValClamped( pTFTeamBlue->GetTotalFlagCaptures(), 0.f, pTFTeamBlue->GetTotalFlagCaptures() + pTFTeamRed->GetTotalFlagCaptures(), 0.f, 1.f );
	}
	else if ( m_bPlayingKoth )
	{
		// Time capped
		// Looking at the capped time for each team will let us give xp in a fair way.  We can
		// actually get as close as 50/50
		float flBlueTimeCapped = pTFTeamBlue->GetKOTHTime();
		float flRedTiemCapped = pTFTeamRed->GetKOTHTime();

		flBlueScoreRatio = RemapValClamped( flBlueTimeCapped, 0.f, flBlueTimeCapped + flRedTiemCapped, 0.f, 1.f );
	}
	else if ( tf_gamemode_rd.GetInt() || tf_gamemode_pd.GetInt() )
	{
		CTFRobotDestructionLogic* pRDLogic = CTFRobotDestructionLogic::GetRobotDestructionLogic();

		// Count bottles/cores scored by each team
		flBlueScoreRatio = RemapValClamped( pRDLogic->GetScore( TF_TEAM_BLUE ), 0.f, pRDLogic->GetScore( TF_TEAM_BLUE ) + pRDLogic->GetScore( TF_TEAM_RED ), 0.f, 1.f );
	}
	else if ( tf_gamemode_tc.GetInt() )
	{
		CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
		
		int nBlueMiniRounds = 0;
		int nRedMiniRounds = 0;

		// Use the number of mini-rounds won by each team
		for( int i=0; i < pMaster->GetNumRounds(); ++ i )
		{
			const CTeamControlPointRound* pRound = pMaster->GetRoundByIndex( i );
			if ( pRound->RoundOwnedByTeam( TF_TEAM_RED ) )
			{
				++nRedMiniRounds;
			}
			else if ( pRound->RoundOwnedByTeam( TF_TEAM_BLUE ) )
			{
				++nBlueMiniRounds;
			}
			else
			{
				Assert( false );
			}
		}


		flBlueScoreRatio = RemapValClamped( nBlueMiniRounds, 0.f, nBlueMiniRounds + nRedMiniRounds, 0.f, 1.f );
	}
	else
	{
		Assert( !"Game mode not handled for team XP bonus!" );
	}

	const float flRedScoreRatio = 1.f - flBlueScoreRatio;
	const int nBlueTeamObjectiveBonus = flBlueScoreRatio * nTotalScore;
	const int nRedTeamObjectiveBonus = flRedScoreRatio * nTotalScore;

	// Player info
	for ( int idxPlayer = 0; idxPlayer < pMatch->GetNumTotalMatchPlayers(); idxPlayer++ )
	{
		CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( idxPlayer );
		if ( !pMatchPlayer->steamID.BIndividualAccount() )
		{
			Assert( false );
			continue;
		}

		CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerBySteamID( pMatchPlayer->steamID ) );
		PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pTFPlayer );

		CMsgGC_Match_Result_Player *pMsgPlayer = pMsg->Body().add_players();
		int nTeam = GetGameTeamForGCTeam( pMatchPlayer->eGCTeam );
		pMsgPlayer->set_steam_id( pMatchPlayer->steamID.ConvertToUint64() );
		pMsgPlayer->set_team( nTeam );
		if ( pTFResource && pTFPlayer )
		{
			pMsgPlayer->set_score( pTFResource->GetTotalScore( pTFPlayer->entindex() ) );
		}
		else
		{
			// They left
		}

		int nPing = 0;
		int nPacketLoss = 0;
		if ( pTFPlayer )
		{
			UTIL_GetPlayerConnectionInfo( pTFPlayer->entindex(), nPing, nPacketLoss );
		}
		pMsgPlayer->set_ping( nPing );
		uint32 unPlayerFlags = 0U;
		if ( pMatchPlayer->bDropped )
		{
			unPlayerFlags |= MATCH_FLAG_PLAYER_LEAVER;
		}
		if ( pMatchPlayer->bLateJoin )
		{
			unPlayerFlags |= MATCH_FLAG_PLAYER_LATEJOIN;
		}
		if ( pMatchPlayer->BDropWasAbandon() )
		{
			unPlayerFlags |= MATCH_FLAG_PLAYER_ABANDONER;
		}
		if ( pMatchPlayer->bPlayed )
		{
			unPlayerFlags |= MATCH_FLAG_PLAYER_PLAYED;
		}

		pMsgPlayer->set_flags( unPlayerFlags );
		// server-side skill system
		FixmeMMRatingBackendSwapping(); // Assuming skill rating is drillo
		pMsgPlayer->set_classes_played( pMatchPlayer->unClassesPlayed );
		pMsgPlayer->set_kills( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_KILLS] : 0 );
		pMsgPlayer->set_damage( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_DAMAGE] : 0 );
		pMsgPlayer->set_healing( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_HEALING] : 0 );
		pMsgPlayer->set_support( pStats ? CalcPlayerSupportScore( &pStats->statsAccumulated, pTFPlayer->entindex() ) : 0 );
		pMsgPlayer->set_score_medal( pMatchPlayer->nScoreMedal );
		pMsgPlayer->set_kills_medal( pMatchPlayer->nKillsMedal );
		pMsgPlayer->set_damage_medal( pMatchPlayer->nDamageMedal );
		pMsgPlayer->set_healing_medal( pMatchPlayer->nHealingMedal );
		pMsgPlayer->set_support_medal( pMatchPlayer->nSupportMedal );
		FixmeMMRatingBackendSwapping(); // Assuming we're using skill rating for rank? Why even include this?
		pMsgPlayer->set_rank( pMatchDesc->m_pProgressionDesc->GetLevelForExperience( pMatchPlayer->unMMSkillRating ).m_nLevelNum );
		pMsgPlayer->set_deaths( pStats ? pStats->statsAccumulated.m_iStat[TFSTAT_DEATHS] : 0 );
		pMsgPlayer->set_party_id( pMatchPlayer->uPartyID );
		uint32 unLeaveTime = ( pMatchPlayer && ( pMatchPlayer->bDropped || pMatchPlayer->BDropWasAbandon() ) ) ? 
							   pMatchPlayer->GetLastActiveEventTime() : 0u;
		pMsgPlayer->set_leave_time( unLeaveTime );
		pMsgPlayer->set_leave_reason( pMatchPlayer->GetDropReason() );
		pMsgPlayer->set_connect_time( pMatchPlayer->rtJoinedMatch );

		// Somebody won! Match finish bonus
		if ( nCode == CMsgGC_Match_Result_Status_MATCH_SUCCEEDED )
		{
			// Give points based on team performance
			int nPerformanceScore = RemapValClamped( pMsgPlayer->score(), 0, nTotalScore / 24, 0, nTeam == TF_TEAM_RED ? nRedTeamObjectiveBonus : nBlueTeamObjectiveBonus );
			pMatch->GiveXPRewardToPlayerForAction( pMatchPlayer->steamID, CMsgTFXPSource::SOURCE_OBJECTIVE_BONUS, nPerformanceScore );
		
			// Everyone gets base completion points
			int nCompletionScore = RemapValClamped( pMsgPlayer->score(), 0, nTotalScore / 24, 0, nTotalScore );
			pMatch->GiveXPRewardToPlayerForAction( pMatchPlayer->steamID, CMsgTFXPSource::SOURCE_COMPLETED_MATCH, nCompletionScore );
		}

		// Copy any pending XP sources they had ready to send up
		for( int i=0; i < pMatchPlayer->GetXPSources().sources_size(); ++i )
		{
			CMsgTFXPSource* pXPSource = pMsgPlayer->add_xp_breakdown();
			pXPSource->CopyFrom( pMatchPlayer->GetXPSources().sources( i ) );
		}
	}

	pMsg->Body().set_win_reason( GetWinReason() );
	uint32 unMatchFlags = 0u;

	if ( pMatch->m_uLobbyFlags & LOBBY_FLAG_LOWPRIORITY )
	{
		unMatchFlags |= MATCH_FLAG_LOWPRIORITY;
	}

	if ( pMatch->m_uLobbyFlags & LOBBY_FLAG_REMATCH )
	{
		unMatchFlags |= MATCH_FLAG_REMATCH;
	}

	pMsg->Body().set_flags( unMatchFlags );
	pMsg->Body().set_bots( pMatch->m_nBotsAdded );

	GTFGCClientSystem()->SendCompetitiveMatchResult( pMsg );

	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::MatchmakingShouldUseStopwatchMode()
{
	CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
	bool bRetVal = !HasMultipleTrains() && ( tf_gamemode_payload.GetBool() || ( pMaster && ( pMaster->PlayingMiniRounds() || pMaster->ShouldSwitchTeamsOnRoundWin() ) ) );
	
	tf_attack_defend_map.SetValue( bRetVal );
	return bRetVal;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameRules::SetPowerupMode( bool bValue )
{
	// Powerup mode uses grapple and changes some gamerule variables.

	if ( bValue )
	{
		tf_grapplinghook_enable.SetValue( 1 );
		tf_flag_return_time_credit_factor.SetValue( 0 );
	}
	else
	{
		tf_grapplinghook_enable.SetValue( 0 );
		tf_flag_return_time_credit_factor.SetValue( 1 );
	}

	m_bPowerupMode = bValue;
}

#ifdef GAME_DLL
//-----------------------------------------------------------------------------
void CTFGameRules::EndManagedMvMMatch( bool bKickPlayersToParties )
{
	// Primarily a pass through so we can ensure our match end state is sync'd -- CPopulationManager manages most of the
	// MvM meta round state
	if ( !IsManagedMatchEnded() )
	{
		GTFGCClientSystem()->EndManagedMatch( bKickPlayersToParties );
		Assert( IsManagedMatchEnded() );
		m_bMatchEnded.Set( true );
	}
}
#endif // GAME_DLL


#ifdef STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose: Enable/Disable Bounty Mode
//-----------------------------------------------------------------------------
void CTFGameRules::SetBountyMode( bool bValue )
{
	if ( m_bBountyModeEnabled.Get() != bValue )
	{
		m_bBountyModeEnabled.Set( bValue );
	}
	
	// If enabling, dynamically create an upgrade entity
	if ( bValue )
	{
		if ( !g_hUpgradeEntity && !m_pUpgrades )
		{
			m_pUpgrades = CBaseEntity::Create( "func_upgradestation", vec3_origin, vec3_angle );
		}
	}

	// If disabling, remove upgrade entity
	if ( !bValue && m_pUpgrades )
	{
		UTIL_Remove( m_pUpgrades );
		m_pUpgrades = NULL;
	}

	IGameEvent *event = gameeventmanager->CreateEvent( "bountymode_toggled" );
	if ( event )
	{
		event->SetBool( "active", bValue );
		gameeventmanager->FireEvent( event );
	}
}

#endif // GAME_DLL
#endif // STAGING_ONLY

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::UsePlayerReadyStatusMode( void )
{
	if ( IsMannVsMachineMode() )
		return true;

	if ( IsCompetitiveMode() )
		return true;

	if ( mp_tournament.GetBool() && mp_tournament_readymode.GetBool() )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::PlayerReadyStatus_HaveMinPlayersToEnable( void )
{
	// we always have enough players if the match wants players to autoready
	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
	if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady )
		return true;

#ifdef GAME_DLL
	// Count connected players
	int nNumPlayers = 0;
	CUtlVector< CTFPlayer* > playerVector;
	CollectPlayers( &playerVector );
	FOR_EACH_VEC( playerVector, i )
	{
		if ( !playerVector[i] )
			continue;

		if ( playerVector[i]->IsFakeClient() )
			continue;

#ifdef STAGING_ONLY
		if ( !mp_tournament_readymode_bots_allowed.GetBool() && playerVector[i]->IsBot() )
			continue;
#else
		if ( playerVector[i]->IsBot() )
			continue;
#endif

		if ( playerVector[i]->IsHLTV() )
			continue;

		if ( playerVector[i]->IsReplay() )
			continue;

		nNumPlayers++;
	}

	// Default
	int nMinPlayers = 1;
	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();

	if ( pMatch && !pMatch->BMatchTerminated() && pMatchDesc->m_params.m_bRequireCompleteMatch )
	{
		nMinPlayers = pMatch->GetCanonicalMatchSize();
	}
	else if ( IsMannVsMachineMode() &&
	          ( engine->IsDedicatedServer() || ( !engine->IsDedicatedServer() && nNumPlayers > 1 ) ) )
	{
		nMinPlayers = tf_mvm_min_players_to_start.GetInt();
	}
	else if ( UsePlayerReadyStatusMode() && engine->IsDedicatedServer() )
	{
		nMinPlayers = mp_tournament_readymode_min.GetInt();
	}

	// Should be renamed to m_bEnableReady, not sure why we encoded our criteria in the names of all associated functions and variables...
	m_bHaveMinPlayersToEnableReady.Set( nNumPlayers >= nMinPlayers );

#endif

	return m_bHaveMinPlayersToEnableReady;
}

#ifdef GAME_DLL
//-----------------------------------------------------------------------------
bool CTFGameRules::PlayerReadyStatus_ArePlayersOnTeamReady( int iTeam )
{
	if ( IsMannVsMachineMode() && iTeam == TF_TEAM_PVE_INVADERS )
		return true;

	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	if ( pMatch )
	{
		int nMatchPlayers = pMatch->GetNumTotalMatchPlayers();
		if ( nMatchPlayers <= 0 )
			return false;

		int iPlayerReadyCount = 0;
		for ( int i = 0; i < nMatchPlayers; i++ )
		{
			CMatchInfo::PlayerMatchData_t *pPlayerData = pMatch->GetMatchDataForPlayer( i );
			if ( !pPlayerData->bDropped && GetGameTeamForGCTeam( pPlayerData->eGCTeam ) == iTeam )
			{
				CBasePlayer *pPlayer = UTIL_PlayerBySteamID( pPlayerData->steamID );
				// XXX(JohnS): Not quite valid yet, We let them join first onto spectate, which is probably a bit
				//             confusing
				//
				// AssertMsg( !pPlayer || ToTFPlayer( pPlayer )->GetTeamNumber() == GetGameTeamForGCTeam( pPlayerData->eGCTeam ),
				//            "Player's GC assigned team does not match their current team" );
				if ( !pPlayer || !m_bPlayerReady[ pPlayer->entindex() ] )
					return false;

				iPlayerReadyCount++;
			}
		}

		const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
		if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady )
		{
			return iPlayerReadyCount > 0 || pMatch->GetNumTotalMatchPlayers() == 1 ;
		}
		else
		{
			int iTeamSize = IsMannVsMachineMode() ? pMatch->GetCanonicalMatchSize() : pMatch->GetCanonicalMatchSize() / 2;
			return iPlayerReadyCount >= iTeamSize;
		}
	}

	// Non-match
	bool bAtLeastOneReady = false;
	for ( int i = 1; i <= MAX_PLAYERS; ++i )
	{
		CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
		if ( !pPlayer || ToTFPlayer( pPlayer )->GetTeamNumber() != iTeam )
			continue;

		if ( !m_bPlayerReady[i] )
		{
			return false;
		}
		else
		{
			bAtLeastOneReady = true;
		}
	}

	// Team isn't ready if there was nobody on it.
	return bAtLeastOneReady;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::PlayerReadyStatus_ShouldStartCountdown( void )
{
	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();

#if defined( STAGING_ONLY )
	// Local testing hack - allow match size of one where just that player is ready
	if ( !IsMannVsMachineMode() && !pMatch && BHavePlayers() && ( IsTeamReady( TF_TEAM_RED ) || IsTeamReady( TF_TEAM_BLUE ) ) )
		return true;
#endif // STAGING_ONLY

	if ( IsMannVsMachineMode() )
	{
		if ( !IsTeamReady( TF_TEAM_PVE_DEFENDERS ) && m_flRestartRoundTime >= gpGlobals->curtime + mp_tournament_readymode_countdown.GetInt() )
		{
			bool bIsTeamReady = PlayerReadyStatus_ArePlayersOnTeamReady( TF_TEAM_PVE_DEFENDERS );
			if ( bIsTeamReady )
			{
				SetTeamReadyState( true, TF_TEAM_PVE_DEFENDERS );
				return true;
			}
		}
	}
	else if ( pMatch &&
	          PlayerReadyStatus_ArePlayersOnTeamReady( TF_TEAM_RED ) &&
	          PlayerReadyStatus_ArePlayersOnTeamReady( TF_TEAM_BLUE ) )
	{
		return true;
	}
	else if ( IsTeamReady( TF_TEAM_RED ) && IsTeamReady( TF_TEAM_BLUE ) )
	{
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::PlayerReadyStatus_ResetState( void )
{
	// Reset the players
	ResetPlayerAndTeamReadyState();

	// Reset the team
	SetTeamReadyState( false, TF_TEAM_RED );
	SetTeamReadyState( false, TF_TEAM_BLUE );

	m_flRestartRoundTime.Set( -1.f );
	mp_restartgame.SetValue( 0 );
	m_bAwaitingReadyRestart = true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::PlayerReadyStatus_UpdatePlayerState( CTFPlayer *pTFPlayer, bool bState )
{
	if ( !UsePlayerReadyStatusMode() )
		return;

	if ( !pTFPlayer )
		return;

	if ( pTFPlayer->GetTeamNumber() < FIRST_GAME_TEAM )
		return;

	if ( State_Get() != GR_STATE_BETWEEN_RNDS )
		return;

	// Don't allow toggling state in the final countdown
	if ( GetRoundRestartTime() > 0.f && GetRoundRestartTime() <= gpGlobals->curtime + TOURNAMENT_NOCANCEL_TIME )
		return;

	// Make sure we have enough to allow ready mode commands
	if ( !PlayerReadyStatus_HaveMinPlayersToEnable() )
		return;

	int nEntIndex = pTFPlayer->entindex();

	// Already this state
	if ( bState == IsPlayerReady( nEntIndex ) )
		return;

	SetPlayerReadyState( nEntIndex, bState );

	if ( !bState )
	{
		// Slam team status to Not Ready for any player that sets Not Ready
		m_bTeamReady.Set( pTFPlayer->GetTeamNumber(), false );

		// If everyone cancels ready state, stop the clock
		bool bAnyoneReady = false;
		for ( int i = 1; i <= MAX_PLAYERS; ++i )
		{
			CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
			if ( !pPlayer )
				continue;

			if ( m_bPlayerReady[i] )
			{
				bAnyoneReady = true;
				break;
			}
		}

		if ( !bAnyoneReady )
		{
			m_flRestartRoundTime.Set( -1.f );
			mp_restartgame.SetValue( 0 );
			ResetPlayerAndTeamReadyState();
		}
	}
	else
	{
		if ( IsMannVsMachineMode() || IsCompetitiveMode() )
		{
			// Reduce timer as each player hits Ready, but only once per-player
			if ( !m_bPlayerReadyBefore[nEntIndex] && m_flRestartRoundTime > gpGlobals->curtime + 60.f )
			{
				float flReduceBy = 30.f;
				if ( m_flRestartRoundTime < gpGlobals->curtime + 90.f )
				{
					// Never reduce below 60 seconds remaining
					flReduceBy = m_flRestartRoundTime - gpGlobals->curtime - 60.f;
				}

				m_flRestartRoundTime -= flReduceBy;
			}
			else if ( m_flRestartRoundTime < 0 && !PlayerReadyStatus_ShouldStartCountdown() )
			{
				m_flRestartRoundTime.Set( gpGlobals->curtime + 150.f );
				m_bAwaitingReadyRestart = false;

				IGameEvent* pEvent = gameeventmanager->CreateEvent( "teamplay_round_restart_seconds" );
				if ( pEvent )
				{
					pEvent->SetInt( "seconds", 150 );
					gameeventmanager->FireEvent( pEvent );
				}
			}
		}

		// Unofficial modes set team ready state here
		CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
		if ( !pMatch && !IsMannVsMachineMode() )
		{
			int nRed = 0;
			int nRedCount = 0;
			int nBlue = 0;
			int nBlueCount = 0;

			for ( int iTeam = FIRST_GAME_TEAM; iTeam < TFTeamMgr()->GetTeamCount(); iTeam++ )
			{
				CTFTeam *pTeam = GetGlobalTFTeam( iTeam );
				if ( pTeam )
				{
					Assert( pTeam->GetTeamNumber() == TF_TEAM_RED || pTeam->GetTeamNumber() == TF_TEAM_BLUE );

					for ( int i = 0; i < pTeam->GetNumPlayers(); ++i )
					{
						if ( !pTeam->GetPlayer(i) )
							continue;

						if ( pTeam->GetTeamNumber() == TF_TEAM_RED && IsPlayerReady( pTeam->GetPlayer(i)->entindex() ) )
						{
							if ( !nRedCount )
							{
								nRedCount = pTeam->GetNumPlayers();
							}

							nRed++;
						}
						else if ( pTeam->GetTeamNumber() == TF_TEAM_BLUE && IsPlayerReady( pTeam->GetPlayer(i)->entindex() ) )
						{
							if ( !nBlueCount )
							{
								nBlueCount = pTeam->GetNumPlayers();
							}

							nBlue++;
						}
					}
				}
			}

			// Check for the convar that requires min team size, or just go with whatever each team has
			int nRedMin = ( mp_tournament_readymode_team_size.GetInt() > 0 ) ? mp_tournament_readymode_team_size.GetInt() : Max( nRedCount, 1 );
			int nBlueMin = ( mp_tournament_readymode_team_size.GetInt() > 0 ) ? mp_tournament_readymode_team_size.GetInt() : Max( nBlueCount, 1 );

			SetTeamReadyState( ( nRed == nRedMin ), TF_TEAM_RED );
			SetTeamReadyState( ( nBlue == nBlueMin ), TF_TEAM_BLUE );
		}

		m_bPlayerReadyBefore[nEntIndex] = true;
	}
}
#endif // GAME_DLL

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFGameRules::IsDefaultGameMode( void )
{
	if ( IsMannVsMachineMode() )
		return false;

	if ( IsInArenaMode() )
		return false;

	if ( IsInMedievalMode() )
		return false;

	if ( IsCompetitiveMode() )
		return false;

	if ( IsInTournamentMode() )
		return false;

	if ( IsInTraining() )
		return false;

	if ( IsInItemTestingMode() )
		return false;

#ifdef STAGING_ONLY
	if ( IsPVEModeActive() )
		return false;
#endif // STAGING_ONLY

#ifdef TF_RAID_MODE
	if ( IsRaidMode() )
		return false;

	if ( IsBossBattleMode() )
		return false;
#endif // TF_RAID_MODE

#ifdef TF_CREEP_MODE
	if ( IsCreepWaveMode() )
		return false;
#endif // TF_CREEP_MODE

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Allows us to give situational discounts, such as secondary weapons
//-----------------------------------------------------------------------------
int CTFGameRules::GetCostForUpgrade( CMannVsMachineUpgrades *pUpgrade, int iItemSlot, int nClass, CTFPlayer *pPurchaser /*= NULL*/ )
{
	Assert( pUpgrade );

	if ( !pUpgrade )
		return 0;

	int iCost = pUpgrade->nCost;

	CEconItemSchema *pSchema = ItemSystem()->GetItemSchema();
	if ( pSchema )
	{
		const CEconItemAttributeDefinition *pAttr = pSchema->GetAttributeDefinitionByName( pUpgrade->szAttrib );
		if ( pAttr )
		{
			if ( ( iItemSlot == LOADOUT_POSITION_PRIMARY && nClass == TF_CLASS_ENGINEER ) ||
				 ( iItemSlot == LOADOUT_POSITION_SECONDARY && nClass != TF_CLASS_DEMOMAN ) ||
				 ( iItemSlot == LOADOUT_POSITION_MELEE && nClass != TF_CLASS_SPY && nClass != TF_CLASS_ENGINEER ) )
			{
				switch ( pAttr->GetDefinitionIndex() )
				{
				case 4:		// clip size bonus
				case 6:		// fire rate bonus
				case 78:	// maxammo secondary increased
				case 180:	// heal on kill
				case 266:	// projectile penetration
				case 335:	// clip size bonus upgrade
				case 397:	// projectile penetration heavy
					iCost *= 0.5f;
					break;
				default:
					break;
				}
			}
			else if ( iItemSlot == LOADOUT_POSITION_ACTION )
			{
				if ( pPurchaser )
				{
					int iCanteenSpec = 0;
					CALL_ATTRIB_HOOK_INT_ON_OTHER( pPurchaser, iCanteenSpec, canteen_specialist );
					if ( iCanteenSpec )
					{

// 						iCost *= ( 1.f - ( iCanteenSpec * 0.1f ) );
// 						iCost = Max( 1, ( iCost - ( iCost % 5 ) ) );

						iCost -= ( 10 * iCanteenSpec );
						iCost = Max( 5, iCost );
					}
				}
			}
		}
	}

	return iCost;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFGameRules::CTFGameRules()
#ifdef GAME_DLL
	: m_mapCoachToStudentMap( DefLessFunc(uint32) )
	, m_flNextStrangeEventProcessTime( g_flStrangeEventBatchProcessInterval )
	, m_mapTeleportLocations( DefLessFunc(string_t) )
	, m_bMapCycleNeedsUpdate( false )
	, m_flSafeToLeaveTimer( -1.f )
	, m_flCompModeRespawnPlayersAtMatchStart( -1.f )
	, m_bMapForcedTruceDuringBossFight( false )
	, m_flNextHalloweenGiftUpdateTime( -1 )
#else
	: m_bRecievedBaseline( false )
#endif
{
#ifdef GAME_DLL
	// Create teams.
	TFTeamMgr()->Init();

	ResetMapTime();

	// Create the team managers
//	for ( int i = 0; i < ARRAYSIZE( teamnames ); i++ )
//	{
//		CTeam *pTeam = static_cast<CTeam*>(CreateEntityByName( "tf_team" ));
//		pTeam->Init( sTeamNames[i], i );
//
//		g_Teams.AddToTail( pTeam );
//	}

	m_flIntermissionEndTime = 0.0f;
	m_flNextPeriodicThink = 0.0f;

	ListenForGameEvent( "teamplay_point_captured" );
	ListenForGameEvent( "teamplay_capture_blocked" );
	ListenForGameEvent( "teamplay_round_win" );
	ListenForGameEvent( "teamplay_flag_event" );
	ListenForGameEvent( "teamplay_round_start" );
	ListenForGameEvent( "player_escort_score" );
	ListenForGameEvent( "player_disconnect" );
	ListenForGameEvent( "teamplay_setup_finished" );
	ListenForGameEvent( "recalculate_truce" );

	Q_memset( m_vecPlayerPositions,0, sizeof(m_vecPlayerPositions) );

	m_iPrevRoundState = -1;
	m_iCurrentRoundState = -1;
	m_iCurrentMiniRoundMask = 0;

	m_iPreviousTeamSize = 0;

	// Lets execute a map specific cfg file
	// ** execute this after server.cfg!
	char szCommand[MAX_PATH] = { 0 };
	// Map names cannot contain quotes or control characters so this is safe but silly that we have to do it.
	Q_snprintf( szCommand, sizeof( szCommand ), "exec \"%s.cfg\"\n", STRING( gpGlobals->mapname ) );
	engine->ServerCommand( szCommand );

	m_flSendNotificationTime = 0.0f;

	m_bOvertimeAllowedForCTF = true;

	m_redPayloadToPush = NULL;
	m_bluePayloadToPush = NULL;
	m_redPayloadToBlock = NULL;
	m_bluePayloadToBlock = NULL;

	SetCTFCaptureBonusTime( -1 );

	m_hasSpawnedToy = false;

	m_flCapInProgressBuffer = 0.f;

	m_bMannVsMachineAlarmStatus = false;
	m_flNextFlagAlarm = 0.0f;
	m_flNextFlagAlert = 0.0f;

	m_doomsdaySetupTimer.Invalidate();
	StopDoomsdayTicketsTimer();

	m_nPowerupKillsRedTeam = 0;
	m_nPowerupKillsBlueTeam = 0;
	m_flTimeToRunImbalanceMeasures = 120.f;
	m_flTimeToStopImbalanceMeasures = 0.f;
	m_bPowerupImbalanceMeasuresRunning = false;

	m_hRequiredObserverTarget = NULL;
	m_bStopWatchWinner.Set( false );

#else // GAME_DLL

	// Vision Filter Translations for swapping out particle effects and models
	SetUpVisionFilterKeyValues();

	m_bSillyGibs = CommandLine()->FindParm( "-sillygibs" ) ? true : false;
	if ( m_bSillyGibs )
	{
		cl_burninggibs.SetValue( 0 );
	}
	// @todo Tom Bui: game_newmap doesn't seem to be used...
	ListenForGameEvent( "game_newmap" );
	ListenForGameEvent( "overtime_nag" );
	ListenForGameEvent( "recalculate_holidays" );
	
#endif

	ClearHalloweenEffectStatus();

	// Initialize the game type
	m_nGameType.Set( TF_GAMETYPE_UNDEFINED );

	m_bPlayingMannVsMachine.Set( false );
	m_bMannVsMachineAlarmStatus.Set( false );
	m_bBountyModeEnabled.Set( false );

	m_bPlayingKoth.Set( false );
	m_bPlayingMedieval.Set( false );
	m_bPlayingHybrid_CTF_CP.Set( false );
	m_bPlayingSpecialDeliveryMode.Set( false );
	m_bPlayingRobotDestructionMode.Set( false );
	m_bPowerupMode.Set( false );

	m_bHelltowerPlayersInHell.Set( false );
	m_bIsUsingSpells.Set( false );
	m_bTruceActive.Set( false );
	m_bTeamsSwitched.Set( false );

	m_halloweenScenario.Set( HALLOWEEN_SCENARIO_NONE );
	m_iGlobalAttributeCacheVersion = 0;

//=============================================================================
// HPE_BEGIN
// [msmith] HUD type
//=============================================================================
	m_nHudType.Set( TF_HUDTYPE_UNDEFINED );
	m_bIsInTraining.Set( false );
	m_bAllowTrainingAchievements.Set( false );
	m_bIsWaitingForTrainingContinue.Set( false );
//=============================================================================
// HPE_END
//=============================================================================
	m_bIsTrainingHUDVisible.Set( false );

	m_bIsInItemTestingMode.Set( false );

	// Set turbo physics on.  Do it here for now.
	sv_turbophysics.SetValue( 1 );

	// Initialize the team manager here, etc...

	// If you hit these asserts its because you added or removed a weapon type 
	// and didn't also add or remove the weapon name or damage type from the
	// arrays defined in tf_shareddefs.cpp
	COMPILE_TIME_ASSERT( TF_WEAPON_COUNT == ARRAYSIZE( g_aWeaponDamageTypes ) );
	COMPILE_TIME_ASSERT( TF_WEAPON_COUNT == ARRAYSIZE( g_aWeaponNames ) );	

	m_iPreviousRoundWinners = TEAM_UNASSIGNED;

	m_pszTeamGoalStringRed.GetForModify()[0] = '\0';
	m_pszTeamGoalStringBlue.GetForModify()[0] = '\0';

	m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET );

	mp_tournament_redteamname.Revert();
	mp_tournament_blueteamname.Revert();

	m_flCapturePointEnableTime = 0.0f;

	m_itHandle = 0;

	m_hBirthdayPlayer = NULL;

	m_nBossHealth = 0;
	m_nMaxBossHealth = 0;
	m_fBossNormalizedTravelDistance = 0.0f;

	m_areHealthAndAmmoVectorsReady = false;

	m_flGravityMultiplier.Set( 1.0 );

	m_pszCustomUpgradesFile.GetForModify()[0] = '\0';

	m_bShowMatchSummary.Set( false );
	m_bMapHasMatchSummaryStage.Set( false );
	m_bPlayersAreOnMatchSummaryStage.Set( false );

	m_bUseMatchHUD = false;
	m_bUsePreRoundDoors = false;

	m_nMatchGroupType.Set( k_nMatchGroup_Invalid );
	m_bMatchEnded.Set( true );

	for ( int i = 1; i <= MAX_PLAYERS; i++ )
	{
		m_ePlayerWantsRematch.Set( i, USER_NEXT_MAP_VOTE_UNDECIDED );
	}

	m_eRematchState = NEXT_MAP_VOTE_STATE_NONE;

#ifdef GAME_DLL

	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	if ( pMatch )
	{
		SyncMatchSettings();
	}

	for ( int i = 0; i < TF_TEAM_COUNT; i++ )
	{
		m_bHasSpawnedSoccerBall[i] = false;
	}

	m_flCheckPlayersConnectingTime = 0;

	m_pUpgrades = NULL;

	// Determine if a halloween event map is active
	// Map active always turns on Halloween
	{
		char szCurrentMap[MAX_MAP_NAME];
		Q_strncpy( szCurrentMap, STRING( gpGlobals->mapname ), sizeof( szCurrentMap ) );

		if ( !Q_stricmp( szCurrentMap, "cp_manor_event" ) )
		{
			m_halloweenScenario.Set( HALLOWEEN_SCENARIO_MANN_MANOR );
		}
		else if ( !Q_stricmp( szCurrentMap, "koth_viaduct_event" ) )
		{
			m_halloweenScenario.Set( HALLOWEEN_SCENARIO_VIADUCT );
		}
		else if ( !Q_stricmp( szCurrentMap, "koth_lakeside_event" ) )
		{
			m_halloweenScenario.Set( HALLOWEEN_SCENARIO_LAKESIDE );
		}
		else if( !Q_stricmp( szCurrentMap, "plr_hightower_event" ) )
		{
			m_halloweenScenario.Set( HALLOWEEN_SCENARIO_HIGHTOWER );
		}
		else if ( !Q_stricmp( szCurrentMap, "sd_doomsday_event" ) )
		{
			m_halloweenScenario.Set( HALLOWEEN_SCENARIO_DOOMSDAY );
		}
	}

	// Our hook for LoadMapCycleFile wont run during the base class constructor that does this initially
	TrackWorkshopMapsInMapCycle();
#endif
}

#ifdef GAME_DLL
void CTFGameRules::Precache( void )
{
	BaseClass::Precache();

	// The Halloween bosses get spawned in code, so they don't get a chance to precache
	// when the map loads.  We'll do the precaching for them here.
	if( IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) )
	{
		CMerasmus::PrecacheMerasmus();
	}
	else if( IsHalloweenScenario( HALLOWEEN_SCENARIO_VIADUCT ) )
	{
		CEyeballBoss::PrecacheEyeballBoss();
	}
	else if( IsHalloweenScenario( HALLOWEEN_SCENARIO_MANN_MANOR ) )
	{
		CHeadlessHatman::PrecacheHeadlessHatman();
	}
	else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		CEyeballBoss::PrecacheEyeballBoss();
		CGhost::PrecacheGhost();
	}
	else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
	{
		CTFPlayer::PrecacheKart();
		CGhost::PrecacheGhost();
		CHeadlessHatman::PrecacheHeadlessHatman();
		CMerasmus::PrecacheMerasmus();
	}

	if ( StringHasPrefix( STRING( gpGlobals->mapname ), "mvm_" ) )
	{
		CTFPlayer::PrecacheMvM();
	}

	CTFPlayer::m_bTFPlayerNeedsPrecache = true;
}
#endif

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
//#ifdef GAME_DLL
//extern void AddHalloweenGiftPositionsForMap( const char *pszMapName, CUtlVector<Vector> &vLocations );
//#endif

void CTFGameRules::LevelInitPostEntity( void )
{
	BaseClass::LevelInitPostEntity();

#ifdef GAME_DLL
	// Refind our proxy, because we might have had it deleted due to a mapmaker placed one
	m_hGamerulesProxy = dynamic_cast<CTFGameRulesProxy*>( gEntList.FindEntityByClassname( NULL, "tf_gamerules" ) );

	// Halloween
	// Flush Halloween Gift Location and grab locations if applicable.  NonHalloween maps will have these as zero
	m_halloweenGiftSpawnLocations.Purge();

	if ( IsHolidayActive( kHoliday_Halloween ) )
	{
		for ( int i=0; i<IHalloweenGiftSpawnAutoList::AutoList().Count(); ++i )
		{
			CHalloweenGiftSpawnLocation* pGift = static_cast< CHalloweenGiftSpawnLocation* >( IHalloweenGiftSpawnAutoList::AutoList()[i] );
			m_halloweenGiftSpawnLocations.AddToTail( pGift->GetAbsOrigin() );
			UTIL_Remove( pGift );
		}

		// Ask Halloween System if there are any locations
		AddHalloweenGiftPositionsForMap( STRING(gpGlobals->mapname), m_halloweenGiftSpawnLocations );
	}

	m_flMatchSummaryTeleportTime = -1.f;

	//tagES
#ifdef STAGING_ONLY
	tf_test_match_summary.SetValue( 0 );
#endif

	const IMatchGroupDescription *pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
	if ( pMatchDesc )
	{
		pMatchDesc->InitGameRulesSettingsPostEntity();
	}

#endif // GAME_DLL
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFGameRules::GetRespawnTimeScalar( int iTeam )
{
	// In PvE mode, we don't modify respawn times
	if ( IsPVEModeActive() )
		return 1.0;

	return BaseClass::GetRespawnTimeScalar( iTeam );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFGameRules::GetRespawnWaveMaxLength( int iTeam, bool bScaleWithNumPlayers )
{
	bool bScale = bScaleWithNumPlayers;

#ifdef TF_RAID_MODE
	if ( IsRaidMode() )
	{
		return tf_raid_respawn_time.GetFloat();
	}
#endif // TF_RAID_MODE

#ifdef TF_CREEP_MODE
	if ( IsCreepWaveMode() )
	{
		return tf_creep_wave_player_respawn_time.GetFloat();
	}
#endif

	if ( IsMannVsMachineMode() )
	{
		bScale = false;
	}

	float flTime = BaseClass::GetRespawnWaveMaxLength( iTeam, bScale );

	CTFRobotDestructionLogic* pRoboLogic = CTFRobotDestructionLogic::GetRobotDestructionLogic();
	if ( pRoboLogic )
	{
		flTime *= ( 1.f - pRoboLogic->GetRespawnScaleForTeam( iTeam ) );
	}

	return flTime;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::FlagsMayBeCapped( void )
{
	if ( State_Get() != GR_STATE_TEAM_WIN && State_Get() != GR_STATE_PREROUND )
		return true;

	return false;
}
 

//-----------------------------------------------------------------------------
// Purpose: Return which Halloween scenario is currently running
//-----------------------------------------------------------------------------
CTFGameRules::HalloweenScenarioType CTFGameRules::GetHalloweenScenario( void ) const
{
	if ( !const_cast< CTFGameRules * >( this )->IsHolidayActive( kHoliday_Halloween ) )
		return HALLOWEEN_SCENARIO_NONE;

	return m_halloweenScenario;
}
 
//-----------------------------------------------------------------------------
bool CTFGameRules::IsUsingSpells( void ) const
{
	if ( tf_spells_enabled.GetBool() )
		return true;

	if ( IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
		return true;

	return m_bIsUsingSpells;
}

//-----------------------------------------------------------------------------
bool CTFGameRules::IsUsingGrapplingHook( void ) const
{
	return tf_grapplinghook_enable.GetBool();
}

//-----------------------------------------------------------------------------
bool CTFGameRules::IsTruceActive( void ) const
{
	return m_bTruceActive;
}

//-----------------------------------------------------------------------------
bool CTFGameRules::CanInitiateDuels( void )
{
	if ( IsInWaitingForPlayers() )
		return false;

	gamerules_roundstate_t roundState = State_Get();
	if ( ( roundState != GR_STATE_RND_RUNNING ) && ( roundState != GR_STATE_PREROUND ) )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFGameRules::GetGameTeamForGCTeam( TF_GC_TEAM nGCTeam )
{
	if ( nGCTeam == TF_GC_TEAM_INVADERS )
	{
		if ( IsCompetitiveMode() )
		{
			return ( m_bTeamsSwitched ) ? TF_TEAM_RED : TF_TEAM_BLUE;
		}

		return TF_TEAM_BLUE;
	}
	else if ( nGCTeam == TF_GC_TEAM_DEFENDERS )
	{
		if ( IsCompetitiveMode() )
		{
			return ( m_bTeamsSwitched ) ? TF_TEAM_BLUE : TF_TEAM_RED;
		}

		return TF_TEAM_RED;
	}

	return TEAM_UNASSIGNED;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
TF_GC_TEAM CTFGameRules::GetGCTeamForGameTeam( int nGameTeam )
{
	if ( nGameTeam == TF_TEAM_BLUE )
	{
		if ( IsCompetitiveMode() )
		{
			return ( m_bTeamsSwitched ) ? TF_GC_TEAM_DEFENDERS : TF_GC_TEAM_INVADERS;
		}

		return TF_GC_TEAM_INVADERS;
	}
	else if ( nGameTeam == TF_TEAM_RED )
	{
		if ( IsCompetitiveMode() )
		{
			return ( m_bTeamsSwitched ) ? TF_GC_TEAM_INVADERS : TF_GC_TEAM_DEFENDERS;
		}

		return TF_GC_TEAM_DEFENDERS;
	}

	return TF_GC_TEAM_NOTEAM;
}

CTFGameRules::EUserNextMapVote CTFGameRules::GetWinningVote( int (&nVotes)[ EUserNextMapVote::NUM_VOTE_STATES ] ) const
{
	// We assume "undecided" is the index just after the last vote option
	COMPILE_TIME_ASSERT( USER_NEXT_MAP_VOTE_UNDECIDED == NEXT_MAP_VOTE_OPTIONS );
	memset( nVotes, 0, sizeof( nVotes ) );
	int nTotalPlayers = 0;

	// Tally up votes.  
	for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
	{
#ifdef CLIENT_DLL

		if ( !g_PR || !g_PR->IsConnected( iPlayerIndex ) ) 
			continue;

#else // GAME_DLL
		// We care about those that are still here.  If you leave, you don't count towards the vote total
		CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
		if ( !pTFPlayer || pTFPlayer->IsBot() )
			continue;


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

		CSteamID steamID;
		pTFPlayer->GetSteamID( &steamID );

		// People without parties *should* be getting a new one soon.  Count them as undecided
		// until their party shows up and they're allowed to make a real vote.
		CTFParty* pParty = GTFGCClientSystem()->GetPartyForPlayer( steamID );
		if ( !pParty )
		{
			++nVotes[ EUserNextMapVote::USER_NEXT_MAP_VOTE_UNDECIDED ];
			++nTotalPlayers;
			continue;
		}

		const CMatchInfo* pMatch = GTFGCClientSystem()->GetMatch();
		Assert( pMatch );
		if ( !pMatch )
		{
			continue;
		}

		// Need to be a match players
		const CMatchInfo::PlayerMatchData_t* pPlayerMatchData = pMatch->GetMatchDataForPlayer( steamID );
		Assert( pPlayerMatchData );
		if ( !pPlayerMatchData )
		{
			// How'd you get here?
			continue;
		}
#endif

		nTotalPlayers++;
		nVotes[ TFGameRules()->PlayerNextMapVoteState( iPlayerIndex ) ]++;
	}

	if ( nVotes[ USER_NEXT_MAP_VOTE_UNDECIDED ] == nTotalPlayers )
	{
		return USER_NEXT_MAP_VOTE_UNDECIDED;
	}
	else
	{
		EUserNextMapVote eWinningVote = USER_NEXT_MAP_VOTE_MAP_0;

		for( int i = 0; i < NEXT_MAP_VOTE_OPTIONS; ++i )
		{
			// The current map is in slot 0.  >= so we favor change.  
			eWinningVote = nVotes[ i ] >= nVotes[ eWinningVote ] 
						 ? (EUserNextMapVote)i
						 : eWinningVote;
		}

		return eWinningVote;
	}	
}

#ifdef GAME_DLL
void CTFGameRules::UpdateNextMapVoteOptionsFromLobby()
{
	for( int i = 0; i < NEXT_MAP_VOTE_OPTIONS; ++i )
	{
		m_nNextMapVoteOptions.Set( i, GTFGCClientSystem()->GetNextMapVoteByIndex( i )->m_nDefIndex );
	}
}

void CTFGameRules::KickPlayersNewMatchIDRequestFailed()
{
	Assert( m_eRematchState == NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE );

	// Let everyone know the rematch failed.
	if ( m_eRematchState == NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE )
	{
		CBroadcastRecipientFilter filter;
		UTIL_ClientPrintFilter( filter, HUD_PRINTTALK, "#TF_Matchmaking_RollingQueue_NewRematch_GCFail" );

		IGameEvent *pEvent = gameeventmanager->CreateEvent( "rematch_failed_to_create" );
		if ( pEvent )
		{
			gameeventmanager->FireEvent( pEvent );
		}
	}

	// The GC failed to get a new MatchID for us.  Let's clear out and reset.
	engine->ServerCommand( "kickall #TF_Competitive_Disconnect\n" );

	// Tell the GC System to end the managed match mode -- we skipped this in StopCompetitiveMatch so we could roll the
	// managed match into a new one.
	Assert( !IsManagedMatchEnded() );
	if ( !IsManagedMatchEnded() )
	{
		GTFGCClientSystem()->EndManagedMatch( /* bKickPlayersToParties */ false );
		Assert( IsManagedMatchEnded() );
		m_bMatchEnded.Set( true );
	}

	// Prepare for next match
	g_fGameOver = false;
	m_bAllowBetweenRounds = true;
	State_Transition( GR_STATE_RESTART );
	SetInWaitingForPlayers( true );
}

//-----------------------------------------------------------------------------
void CTFGameRules::CheckAndSetPartyLeader( CTFPlayer *pTFPlayer, int iTeam )
{
	if ( !pTFPlayer )
		return;

	Assert( iTeam >= FIRST_GAME_TEAM );
	if ( iTeam < FIRST_GAME_TEAM )
		return;

	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	if ( !pMatch )
		return;

	CSteamID steamID;
	if ( !pTFPlayer->GetSteamID( &steamID ) )
		return;

	// TODO:  Whenever a lobby is updated, look at the CTFLobbyMembers and see if
	//		  everyone has the same partyID and then set whoever is the leader to
	//		  have their name be the team name

	//CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( steamID );
	//if ( pMatchPlayer && pMatchPlayer->bPremadeLeader )
	//{
	//	CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource );
	//	if ( pResource )
	//	{
	//		pResource->SetPartyLeaderIndex( iTeam, pTFPlayer->entindex() );
	//	}
	//}
}

//-----------------------------------------------------------------------------
// Purpose: Sets current boss victim
//-----------------------------------------------------------------------------
void CTFGameRules::SetIT( CBaseEntity *who )
{
	if ( IsHolidayActive( kHoliday_Halloween ) && !IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
	{
		CTFPlayer* newIT = ToTFPlayer( who );

		if ( newIT && newIT != m_itHandle.Get() )
		{
			// new IT victim - warn them
			ClientPrint( newIT, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", newIT->GetPlayerName() );
			ClientPrint( newIT, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", newIT->GetPlayerName() );

			CSingleUserReliableRecipientFilter filter( newIT );
			newIT->EmitSound( filter, newIT->entindex(), "Player.YouAreIT" );

			// force them to scream when they become it
			newIT->EmitSound( "Halloween.PlayerScream" );
		}

		CTFPlayer *oldIT = ToTFPlayer( m_itHandle );

		if ( oldIT && oldIT != who && oldIT->IsAlive() )
		{
			// tell old IT player they are safe
			CSingleUserReliableRecipientFilter filter( oldIT );
			oldIT->EmitSound( filter, oldIT->entindex(), "Player.TaggedOtherIT" );

			ClientPrint( oldIT, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" );
			ClientPrint( oldIT, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" );
		}
	}

	m_itHandle = who;
}


//-----------------------------------------------------------------------------
// Purpose: Sets current birthday player
//-----------------------------------------------------------------------------
void CTFGameRules::SetBirthdayPlayer( CBaseEntity *pEntity )
{
/*
	if ( IsBirthday() )
	{
		if ( pEntity && pEntity->IsPlayer() && pEntity != m_hBirthdayPlayer.Get() )
		{
			CTFPlayer *pTFPlayer = ToTFPlayer( pEntity );
			if ( pTFPlayer )
			{
				// new IT victim - warn them
//				ClientPrint( pTFPlayer, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", player->GetPlayerName() );
//				ClientPrint( pTFPlayer, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_WARN_VICTIM", player->GetPlayerName() );

				CSingleUserReliableRecipientFilter filter( pTFPlayer );
				pTFPlayer->EmitSound( filter, pTFPlayer->entindex(), "Game.HappyBirthday" );

				// force them to scream when they become it
//				pTFPlayer->EmitSound( "Halloween.PlayerScream" );
			}
		}

// 		CTFPlayer *oldIT = ToTFPlayer( m_itHandle );
// 
// 		if ( oldIT && oldIT != who && oldIT->IsAlive() )
// 		{
// 			// tell old IT player they are safe
// 			CSingleUserReliableRecipientFilter filter( oldIT );
// 			oldIT->EmitSound( filter, oldIT->entindex(), "Player.TaggedOtherIT" );
// 
// 			ClientPrint( oldIT, HUD_PRINTTALK, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" );
// 			ClientPrint( oldIT, HUD_PRINTCENTER, "#TF_HALLOWEEN_BOSS_LOST_AGGRO" );
// 		}

		m_hBirthdayPlayer = pEntity;
	}
	else
	{
		m_hBirthdayPlayer = NULL;
	}
*/
}


#ifdef GAME_DLL

//-----------------------------------------------------------------------------
// Purpose: remove all projectiles in the world
//-----------------------------------------------------------------------------
void CTFGameRules::RemoveAllProjectiles()
{
	for ( int i=0; i<IBaseProjectileAutoList::AutoList().Count(); ++i )
	{
		UTIL_Remove( static_cast< CBaseProjectile* >( IBaseProjectileAutoList::AutoList()[i] ) );
	}
}

//-----------------------------------------------------------------------------
// Purpose: remove all buildings in the world
//-----------------------------------------------------------------------------
void CTFGameRules::RemoveAllBuildings( bool bExplodeBuildings /*= false*/ )
{
	for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
	{
		CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
		if ( !pObj->IsMapPlaced() )
		{
			// this is separate from the object_destroyed event, which does
			// not get sent when we remove the objects from the world
			IGameEvent *event = gameeventmanager->CreateEvent( "object_removed" );	
			if ( event )
			{
				CTFPlayer *pOwner = pObj->GetOwner();
				event->SetInt( "userid", pOwner ? pOwner->GetUserID() : -1 ); // user ID of the object owner
				event->SetInt( "objecttype", pObj->GetType() ); // type of object removed
				event->SetInt( "index", pObj->entindex() ); // index of the object removed
				gameeventmanager->FireEvent( event );
			}

			if ( bExplodeBuildings )
			{
				pObj->DetonateObject();
			}
			else
			{
				// This fixes a bug in Raid mode where we could spawn where our sentry was but 
				// we didn't get the weapons because they couldn't trace to us in FVisible
				pObj->SetSolid( SOLID_NONE );
				UTIL_Remove( pObj );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: remove all sentries ammo
//-----------------------------------------------------------------------------
void CTFGameRules::RemoveAllSentriesAmmo()
{
	for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
	{
		CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
		if ( pObj->GetType() == OBJ_SENTRYGUN )
		{
			CObjectSentrygun *pSentry = assert_cast< CObjectSentrygun* >( pObj );
			pSentry->RemoveAllAmmo();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Removes all projectiles and buildings from world
//-----------------------------------------------------------------------------
void CTFGameRules::RemoveAllProjectilesAndBuildings( bool bExplodeBuildings /*= false*/ )
{
	RemoveAllProjectiles();
	RemoveAllBuildings( bExplodeBuildings );
}
#endif // GAME_DLL


//-----------------------------------------------------------------------------
// Purpose: Determines whether we should allow mp_timelimit to trigger a map change
//-----------------------------------------------------------------------------
bool CTFGameRules::CanChangelevelBecauseOfTimeLimit( void )
{
	CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;

	// we only want to deny a map change triggered by mp_timelimit if we're not forcing a map reset,
	// we're playing mini-rounds, and the master says we need to play all of them before changing (for maps like Dustbowl)
	if ( !m_bForceMapReset && pMaster && pMaster->PlayingMiniRounds() && pMaster->ShouldPlayAllControlPointRounds() )
	{
		if ( pMaster->NumPlayableControlPointRounds() > 0 )
		{
			return false;
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::CanGoToStalemate( void )
{
	// In CTF, don't go to stalemate if one of the flags isn't at home
	if ( m_nGameType == TF_GAMETYPE_CTF )
	{
		for ( int i=0; i<ICaptureFlagAutoList::AutoList().Count(); ++i )
		{
			CCaptureFlag *pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[i] );
			if ( pFlag->IsDropped() || pFlag->IsStolen() )
				return false;
		}

		// check that one team hasn't won by capping
		if ( CheckCapsPerRound() )
			return false;
	}

	return BaseClass::CanGoToStalemate();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::RestoreActiveTimer( void )
{
	BaseClass::RestoreActiveTimer();

	if ( IsInKothMode() )
	{
		CTeamRoundTimer *pTimer = GetBlueKothRoundTimer();
		if ( pTimer )
		{
			pTimer->SetShowInHud( true );
		}

		pTimer = GetRedKothRoundTimer();
		if ( pTimer )
		{
			pTimer->SetShowInHud( true );
		}
	}
}

// Classnames of entities that are preserved across round restarts
static const char *s_PreserveEnts[] =
{
	"tf_gamerules",
	"tf_team_manager",
	"tf_player_manager",
	"tf_team",
	"tf_objective_resource",
	"keyframe_rope",
	"move_rope",
	"tf_viewmodel",
	"tf_logic_training",
	"tf_logic_training_mode",
#ifdef TF_RAID_MODE
	"tf_logic_raid",
#endif // TF_RAID_MODE
	"tf_powerup_bottle",
	"tf_mann_vs_machine_stats",
	"tf_wearable",
	"tf_wearable_demoshield",
	"tf_wearable_robot_arm",
	"tf_wearable_vm",
	"tf_logic_bonusround",
	"vote_controller",
	"monster_resource",
	"tf_logic_medieval",
	"tf_logic_cp_timer",
	"tf_logic_tower_defense",	// legacy
	"tf_logic_mann_vs_machine",
	"func_upgradestation",
	"entity_rocket",
	"entity_carrier",
	"entity_sign",
	"entity_saucer",
	"tf_halloween_gift_pickup",
	"tf_logic_competitive",
	"", // END Marker
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::Activate()
{
	m_nGameType.Set( TF_GAMETYPE_UNDEFINED );

	tf_gamemode_arena.SetValue( 0 );
	tf_gamemode_cp.SetValue( 0 );
	tf_gamemode_ctf.SetValue( 0 );
	tf_gamemode_sd.SetValue( 0 );
	tf_gamemode_payload.SetValue( 0 );
	tf_gamemode_mvm.SetValue( 0 );
	tf_gamemode_rd.SetValue( 0 );
	tf_gamemode_pd.SetValue( 0 );
	tf_gamemode_tc.SetValue( 0 );
	tf_beta_content.SetValue( 0 );
	tf_gamemode_passtime.SetValue( 0 );
	tf_gamemode_misc.SetValue( 0 );

	tf_bot_count.SetValue( 0 );

#ifdef TF_RAID_MODE
	tf_gamemode_raid.SetValue( 0 );
	tf_gamemode_boss_battle.SetValue( 0 );
#endif
	m_bPlayingMannVsMachine.Set( false );
	m_bBountyModeEnabled.Set( false );
	m_nCurrencyAccumulator = 0;
	m_iCurrencyPool = 0;
	m_bMannVsMachineAlarmStatus.Set( false );
	m_bPlayingKoth.Set( false );
	m_bPlayingMedieval.Set( false );
	m_bPlayingHybrid_CTF_CP.Set( false );
	m_bPlayingSpecialDeliveryMode.Set( false );
	m_bPlayingRobotDestructionMode.Set( false );
	m_bPowerupMode.Set( false );

	m_redPayloadToPush = NULL;
	m_bluePayloadToPush = NULL;
	m_redPayloadToBlock = NULL;
	m_bluePayloadToBlock = NULL;
	
	m_zombieMobTimer.Invalidate();
	m_zombiesLeftToSpawn = 0;

	m_CPTimerEnts.RemoveAll();

	m_nMapHolidayType.Set( kHoliday_None );

	CArenaLogic *pArenaLogic = dynamic_cast< CArenaLogic * > (gEntList.FindEntityByClassname( NULL, "tf_logic_arena" ) );

	if ( pArenaLogic != NULL )
	{
		m_hArenaEntity = pArenaLogic;

		m_nGameType.Set( TF_GAMETYPE_ARENA );

		tf_gamemode_arena.SetValue( 1 );

		Msg( "Executing server arena config file\n" );
		engine->ServerCommand( "exec config_arena.cfg\n" );
	}

#ifdef TF_RAID_MODE
	CRaidLogic *pRaidLogic = dynamic_cast< CRaidLogic * >( gEntList.FindEntityByClassname( NULL, "tf_logic_raid" ) );
	if ( pRaidLogic )
	{
		m_hRaidLogic = pRaidLogic;

		tf_gamemode_raid.SetValue( 1 );

		Msg( "Executing server raid game mode config file\n" );
		engine->ServerCommand( "exec config_raid.cfg\n" );
	}

	CBossBattleLogic *pBossBattleLogic = dynamic_cast< CBossBattleLogic * >( gEntList.FindEntityByClassname( NULL, "tf_logic_boss_battle" ) );
	if ( pBossBattleLogic )
	{
		m_hBossBattleLogic = pBossBattleLogic;

		tf_gamemode_boss_battle.SetValue( 1 );
	}
#endif // TF_RAID_MODE

	// This is beta content if this map has "beta" as a tag in the schema
	{
		const MapDef_t* pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) );
		if ( pMap && pMap->vecTags.HasElement( GetItemSchema()->GetHandleForTag( "beta" ) ) )
		{
			tf_beta_content.SetValue( 1 );
		}
	}

	if ( !Q_strncmp( STRING( gpGlobals->mapname ), "tc_", 3 )  )
	{
		tf_gamemode_tc.SetValue( 1 );
	}
	
	CMannVsMachineLogic *pMannVsMachineLogic = dynamic_cast< CMannVsMachineLogic * >( gEntList.FindEntityByClassname( NULL, "tf_logic_mann_vs_machine" ) );
	CTeamTrainWatcher *pTrainWatch = dynamic_cast<CTeamTrainWatcher*> ( gEntList.FindEntityByClassname( NULL, "team_train_watcher" ) );
	bool bFlag = ICaptureFlagAutoList::AutoList().Count() > 0;
	if ( CTFRobotDestructionLogic::GetRobotDestructionLogic() )
	{
		m_bPlayingRobotDestructionMode.Set( true );
		if ( CTFRobotDestructionLogic::GetRobotDestructionLogic()->GetType() == CTFRobotDestructionLogic::TYPE_ROBOT_DESTRUCTION )
		{
			tf_gamemode_rd.SetValue( 1 );
			m_nGameType.Set( TF_GAMETYPE_RD );
			tf_beta_content.SetValue( 1 );
		}
		else
		{
			tf_gamemode_pd.SetValue( 1 );
			m_nGameType.Set( TF_GAMETYPE_PD );
		}
	}
	else if ( pMannVsMachineLogic )
	{
		m_bPlayingMannVsMachine.Set( true );
		tf_gamemode_mvm.SetValue( 1 );
		m_nGameType.Set( TF_GAMETYPE_MVM );
	}
	else if ( StringHasPrefix( STRING( gpGlobals->mapname ), "sd_" ) )
	{
		m_bPlayingSpecialDeliveryMode.Set( true );
		tf_gamemode_sd.SetValue( 1 );
	}
	else if ( bFlag && !CTFRobotDestructionLogic::GetRobotDestructionLogic() )
	{
		m_nGameType.Set( TF_GAMETYPE_CTF );
		tf_gamemode_ctf.SetValue( 1 );
	}

	else if ( pTrainWatch )
	{
		m_nGameType.Set( TF_GAMETYPE_ESCORT );
		tf_gamemode_payload.SetValue( 1 );
		
		CMultipleEscort *pMultipleEscort = dynamic_cast<CMultipleEscort*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_multiple_escort" ) );
		SetMultipleTrains( pMultipleEscort != NULL );
	}
	else if ( g_hControlPointMasters.Count() && m_nGameType != TF_GAMETYPE_ARENA ) // We have cap points in arena but we're not CP
	{
		m_nGameType.Set( TF_GAMETYPE_CP );
		tf_gamemode_cp.SetValue( 1 );
	}
	
	auto *pPasstime = dynamic_cast<CTFPasstimeLogic*> ( gEntList.FindEntityByClassname( NULL, "passtime_logic" ) );
	if ( pPasstime )
	{
		m_nGameType.Set( TF_GAMETYPE_PASSTIME );
		tf_gamemode_passtime.SetValue( 1 );
	}

	// the game is in training mode if this entity is found
	m_hTrainingModeLogic = dynamic_cast< CTrainingModeLogic * > ( gEntList.FindEntityByClassname( NULL, "tf_logic_training_mode" ) );
	if ( NULL != m_hTrainingModeLogic )
	{
		m_bIsInTraining.Set( true );
		m_bAllowTrainingAchievements.Set( false );
		mp_humans_must_join_team.SetValue( "blue" );
		m_bIsTrainingHUDVisible.Set( true );
		tf_training_client_message.SetValue( (int)TRAINING_CLIENT_MESSAGE_NONE );
	}

	m_bIsInItemTestingMode.Set( false );

	CKothLogic *pKoth = dynamic_cast<CKothLogic*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_koth" ) );
	if ( pKoth )
	{
		m_bPlayingKoth.Set( true );
	}

	CMedievalLogic *pMedieval = dynamic_cast<CMedievalLogic*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_medieval" ) );
	if ( pMedieval || tf_medieval.GetBool() )
	{
		m_bPlayingMedieval.Set( true );
	}

	CCompetitiveLogic *pCompLogic = dynamic_cast< CCompetitiveLogic* > ( gEntList.FindEntityByClassname( NULL, "tf_logic_competitive" ) );
	if ( pCompLogic )
	{
		m_hCompetitiveLogicEntity = pCompLogic;
	}

	CHybridMap_CTF_CP *pHybridMap_CTF_CP = dynamic_cast<CHybridMap_CTF_CP*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_hybrid_ctf_cp" ) );
	if ( pHybridMap_CTF_CP )
	{
		m_bPlayingHybrid_CTF_CP.Set( true );
	}

	CTFHolidayEntity *pHolidayEntity = dynamic_cast<CTFHolidayEntity*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_holiday" ) );
	if ( pHolidayEntity )
	{
		m_nMapHolidayType.Set( pHolidayEntity->GetHolidayType() );
	}

	// bot roster
	m_hBlueBotRoster = NULL;
	m_hRedBotRoster = NULL;
	CHandle<CTFBotRoster> hBotRoster = dynamic_cast< CTFBotRoster* >( gEntList.FindEntityByClassname( NULL, "bot_roster" ) );
	while ( hBotRoster != NULL )
	{
		if ( FStrEq( hBotRoster->m_teamName.ToCStr(), "blue" ) )
		{
			m_hBlueBotRoster = hBotRoster;
		}
		else if ( FStrEq( hBotRoster->m_teamName.ToCStr(), "red" ) )
		{
			m_hRedBotRoster = hBotRoster;
		}
		else
		{
			if ( m_hBlueBotRoster == NULL )
			{
				m_hBlueBotRoster = hBotRoster;
			}
			if ( m_hRedBotRoster == NULL )
			{
				m_hRedBotRoster = hBotRoster;
			}
		}
		hBotRoster = dynamic_cast< CTFBotRoster* >( gEntList.FindEntityByClassname( hBotRoster, "bot_roster" ) );
	}

	CHandle<CCPTimerLogic> hCPTimer = dynamic_cast< CCPTimerLogic* >( gEntList.FindEntityByClassname( NULL, "tf_logic_cp_timer" ) );
	while ( hCPTimer != NULL )
	{
		m_CPTimerEnts.AddToTail( hCPTimer );
		hCPTimer = dynamic_cast< CCPTimerLogic* >( gEntList.FindEntityByClassname( hCPTimer, "tf_logic_cp_timer" ) );
	}

	// hide from the master server if this game is a training game
	// or offline practice
	if ( IsInTraining() || TheTFBots().IsInOfflinePractice() || IsInItemTestingMode() )
	{
		hide_server.SetValue( true );
	}

	m_bVoteCalled = false;
	m_bServerVoteOnReset = false;
	m_flVoteCheckThrottle = 0;

#ifdef STAGING_ONLY
	// Dynamically create an upgrade entity outside MvM
	if ( tf_bountymode.GetBool() && !IsBountyMode() )
	{
		SetBountyMode( true );
	}
#endif // STAGING_ONLY

	if ( tf_powerup_mode.GetBool()  )
	{
		if ( !IsPowerupMode() )
		{
			SetPowerupMode( true );
		}
	}

// 	if ( !IsInTournamentMode() )
// 	{
// 		CExtraMapEntity::SpawnExtraModel();
// 	}

	// If leaving MvM for any other game mode, clean up any sticky UI/state
	if ( IsInTournamentMode() && m_nGameType != TF_GAMETYPE_MVM && g_TFGameModeHistory.GetPrevState() == TF_GAMETYPE_MVM )
	{
		mp_tournament.SetValue( false );
	}

	if ( GameModeUsesUpgrades() && g_pPopulationManager == NULL )
	{
		(CPopulationManager *)CreateEntityByName( "info_populator" );
	}

	if ( tf_gamemode_tc.GetBool() || tf_gamemode_sd.GetBool() || tf_gamemode_pd.GetBool() || m_bPlayingMedieval )
	{
		tf_gamemode_misc.SetValue( 1 );
	}

	CBaseEntity *pStageLogic = gEntList.FindEntityByName( NULL, "competitive_stage_logic_case" );
	if ( pStageLogic )
	{
		m_bMapHasMatchSummaryStage.Set( true );
	}

	m_bCompetitiveMode.Set( false );

	const IMatchGroupDescription *pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
	if ( pMatchDesc )
	{
		pMatchDesc->InitGameRulesSettings();
	}

	CLogicMannPower *pLogicMannPower = dynamic_cast< CLogicMannPower* > ( gEntList.FindEntityByClassname( NULL, "tf_logic_mannpower" ) );
	tf_powerup_mode.SetValue( pLogicMannPower ? 1 : 0 );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::AllowDamage( CBaseEntity *pVictim, const CTakeDamageInfo &info )
{
	bool bRetVal = true;

	if ( ( State_Get() == GR_STATE_TEAM_WIN ) && pVictim )
	{
		if ( pVictim->GetTeamNumber() == GetWinningTeam() )
		{
			CBaseTrigger *pTrigger = dynamic_cast< CBaseTrigger *>( info.GetInflictor() );

			// we don't want players on the winning team to be
			// hurt by team-specific trigger_hurt entities during the bonus time
			if ( pTrigger && pTrigger->UsesFilter() )
			{
				bRetVal = false;
			}
		}
	}

	return bRetVal;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetTeamGoalString( int iTeam, const char *pszGoal )
{
	if ( iTeam == TF_TEAM_RED )
	{
		if ( !pszGoal || !pszGoal[0] )
		{
			m_pszTeamGoalStringRed.GetForModify()[0] = '\0';
		}
		else
		{
			if ( Q_stricmp( m_pszTeamGoalStringRed.Get(), pszGoal ) )
			{
				Q_strncpy( m_pszTeamGoalStringRed.GetForModify(), pszGoal, MAX_TEAMGOAL_STRING );
			}
		}
	}
	else if ( iTeam == TF_TEAM_BLUE )
	{
		if ( !pszGoal || !pszGoal[0] )
		{
			m_pszTeamGoalStringBlue.GetForModify()[0] = '\0';
		}
		else
		{
			if ( Q_stricmp( m_pszTeamGoalStringBlue.Get(), pszGoal ) )
			{
				Q_strncpy( m_pszTeamGoalStringBlue.GetForModify(), pszGoal, MAX_TEAMGOAL_STRING );
			}
		}
	}
}

//=============================================================================
// HPE_BEGIN:
// [msmith]	Added a HUD type so that we can have the hud independent from the
//			game type.  This is useful in training where we want a training hud
//			Instead of the other types of HUD.
//=============================================================================
//-----------------------------------------------------------------------------
// Purpose: Set a HUD type.
//-----------------------------------------------------------------------------
void CTFGameRules::SetHUDType( int nHudType )
{
	if ( nHudType != TF_HUDTYPE_ARENA )
	{
		if ( nHudType >= TF_HUDTYPE_UNDEFINED && nHudType <= TF_HUDTYPE_TRAINING )
		{
			m_nHudType.Set( nHudType );
		}
	}
}
//=============================================================================
// HPE_END
//=============================================================================

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::RoundCleanupShouldIgnore( CBaseEntity *pEnt )
{
	if ( FindInList( s_PreserveEnts, pEnt->GetClassname() ) )
		return true;

	//There has got to be a better way of doing this.
	if ( Q_strstr( pEnt->GetClassname(), "tf_weapon_" ) )
		return true;

	return BaseClass::RoundCleanupShouldIgnore( pEnt );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldCreateEntity( const char *pszClassName )
{
	if ( FindInList( s_PreserveEnts, pszClassName ) )
		return false;

	return BaseClass::ShouldCreateEntity( pszClassName );
}

const char* CTFGameRules::GetStalemateSong( int nTeam )
{
	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		return (nTeam == TF_TEAM_RED) 
			? "Announcer.Helltower_Hell_Red_Stalemate" 
			: "Announcer.Helltower_Hell_Blue_Stalemate";
	}
	else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
	{
		return "Announcer.SD_Event_MurderedToStalemate";
	}

	return "Game.Stalemate";
}

const char* CTFGameRules::WinSongName( int nTeam )
{
	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		return (nTeam == TF_TEAM_RED) 
			? "Announcer.Helltower_Hell_Red_Win" 
			: "Announcer.Helltower_Hell_Blue_Win";
	}

	return "Game.YourTeamWon"; 
}


const char* CTFGameRules::LoseSongName( int nTeam )
{
	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		return (nTeam == TF_TEAM_RED) 
			? "Announcer.Helltower_Hell_Red_Lose" 
			: "Announcer.Helltower_Hell_Blue_Lose";
	}
	else if ( IsMannVsMachineMode() )
	{
		return "music.mvm_lost_wave";
	}
	else
	{
		return BaseClass::LoseSongName( nTeam );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::CleanUpMap( void )
{
#ifdef GAME_DLL
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( !pTFPlayer )
			continue;

		// Remove all player conditions to prevent some dependency bugs
		pTFPlayer->m_Shared.RemoveAllCond();
	}
#endif // GAME_DLL

	BaseClass::CleanUpMap();

	if ( HLTVDirector() )
	{
		HLTVDirector()->BuildCameraList();
	}

#ifdef GAME_DLL
	m_hasSpawnedToy = false;
	for ( int i = 0; i < TF_TEAM_COUNT; i++ )
	{
		m_bHasSpawnedSoccerBall[i] = false;
	}

	// If we're in a mode with upgrades, we force the players to recreate their weapons on next spawn.
	// This clears out any weapon upgrades they had in the previous round.
	if ( g_hUpgradeEntity )
	{
		for ( int i = 1; i <= gpGlobals->maxClients; i++ )
		{
			CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
			if ( !pTFPlayer )
				continue;

			pTFPlayer->ForceItemRemovalOnRespawn();

			// Remove all player upgrades as well
			pTFPlayer->RemovePlayerAttributes( false );
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::RecalculateControlPointState( void )
{
	Assert( ObjectiveResource() );

	if ( !g_hControlPointMasters.Count() )
		return;

	if ( g_pObjectiveResource && g_pObjectiveResource->PlayingMiniRounds() )
		return;

	for ( int iTeam = LAST_SHARED_TEAM+1; iTeam < GetNumberOfTeams(); iTeam++ )
	{
		int iFarthestPoint = GetFarthestOwnedControlPoint( iTeam, true );
		if ( iFarthestPoint == -1 )
			continue;

		// Now enable all spawn points for that spawn point
		for ( int i=0; i<ITFTeamSpawnAutoList::AutoList().Count(); ++i )
		{
			CTFTeamSpawn *pTFSpawn = static_cast< CTFTeamSpawn* >( ITFTeamSpawnAutoList::AutoList()[i] );
			if ( pTFSpawn->GetControlPoint() )
			{
				if ( pTFSpawn->GetTeamNumber() == iTeam )
				{
					if ( pTFSpawn->GetControlPoint()->GetPointIndex() == iFarthestPoint )
					{
						pTFSpawn->SetDisabled( false );
					}
					else
					{
						pTFSpawn->SetDisabled( true );
					}
				}
			}
		}
	}
}

DECLARE_AUTO_LIST( ITFTeleportLocationAutoList )
class CTFTeleportLocation : public CPointEntity, public ITFTeleportLocationAutoList
{
public:
	DECLARE_CLASS( CTFTeleportLocation, CPointEntity );
};

IMPLEMENT_AUTO_LIST( ITFTeleportLocationAutoList );

LINK_ENTITY_TO_CLASS( tf_teleport_location, CTFTeleportLocation );

void SpawnRunes( void )
{
	// Spawn power-up runes when the round starts. Choice of spawn location and Powerup Type is random
	CUtlVector< CTFInfoPowerupSpawn* > vecSpawnPoints; 
	for ( int i = 0; i < IInfoPowerupSpawnAutoList::AutoList().Count(); i++ )
	{
		CTFInfoPowerupSpawn *pSpawnPoint = static_cast< CTFInfoPowerupSpawn* >( IInfoPowerupSpawnAutoList::AutoList()[i] );
		if ( !pSpawnPoint->IsDisabled() && !pSpawnPoint->HasRune() ) 
		{
			vecSpawnPoints.AddToTail( pSpawnPoint );
		}
	}

	Assert( vecSpawnPoints.Count() > 0 ); // We need at least one valid info_powerup_spawn

	// Warn if there aren't enough valid info_powerup_spawns to spawn all powerups
	if ( vecSpawnPoints.Count() < RUNE_TYPES_MAX )
	{
		Warning( "Warning: Not enough valid info_powerup_spawn locations found. You need a minimum of %i valid locations to spawn all Powerups.\n", RUNE_TYPES_MAX );
	}

	// try to spawn each rune type
	for ( int nRuneTypes = 0; nRuneTypes < RUNE_TYPES_MAX && vecSpawnPoints.Count() > 0; nRuneTypes++ )
	{
		int index = RandomInt( 0, vecSpawnPoints.Count() - 1 );
		CTFInfoPowerupSpawn *pSpawnPoint = vecSpawnPoints[index];
		CTFRune *pNewRune = CTFRune::CreateRune( pSpawnPoint->GetAbsOrigin(), (RuneTypes_t) nRuneTypes, TEAM_ANY, false, false );
		pSpawnPoint->SetRune( pNewRune );
		vecSpawnPoints.Remove( index );
	}
}

#ifdef STAGING_ONLY
// Force spawn runes for testing
CON_COMMAND_F( tf_force_spawn_runes, "For testing.", FCVAR_CHEAT )
{
	SpawnRunes();
}
#endif

void CTFGameRules::RespawnPlayers( bool bForceRespawn, bool bTeam, int iTeam )
{
	// Skip the respawn at the beginning of a round in casual/comp mode since we already
	// handled it when the pre-round doors closed over the players' views
	if ( IsCompetitiveMode() && ( GetRoundsPlayed() == 0 ) && bForceRespawn && ( State_Get() == GR_STATE_BETWEEN_RNDS || State_Get() == GR_STATE_PREROUND ) )
	{
		CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
		if ( !pMaster || !pMaster->PlayingMiniRounds() || ( pMaster->GetCurrentRoundIndex() == 0 ) )
			return;
	}

	BaseClass::RespawnPlayers( bForceRespawn, bTeam, iTeam );
}

//-----------------------------------------------------------------------------
// Purpose: Called when a new round is being initialized
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnRoundStart( void )
{
	for ( int i = 0; i < MAX_TEAMS; i++ )
	{
		ObjectiveResource()->SetBaseCP( -1, i );
	}

	for ( int i = 0; i < TF_TEAM_COUNT; i++ )
	{
		m_iNumCaps[i] = 0;
	}

	SetOvertime( false );

	m_hRedKothTimer.Set( NULL );
	m_hBlueKothTimer.Set( NULL );

	// Let all entities know that a new round is starting
	CBaseEntity *pEnt = gEntList.FirstEnt();
	while( pEnt )
	{
		variant_t emptyVariant;
		pEnt->AcceptInput( "RoundSpawn", NULL, NULL, emptyVariant, 0 );

		pEnt = gEntList.NextEnt( pEnt );
	}

	// All entities have been spawned, now activate them
	m_areHealthAndAmmoVectorsReady = false;
	m_ammoVector.RemoveAll();
	m_healthVector.RemoveAll();

	pEnt = gEntList.FirstEnt();
	while( pEnt )
	{
		variant_t emptyVariant;
		pEnt->AcceptInput( "RoundActivate", NULL, NULL, emptyVariant, 0 );

		pEnt = gEntList.NextEnt( pEnt );
	}

	if ( g_pObjectiveResource && !g_pObjectiveResource->PlayingMiniRounds() )
	{
		// Find all the control points with associated spawnpoints
		memset( m_bControlSpawnsPerTeam, 0, sizeof(bool) * MAX_TEAMS * MAX_CONTROL_POINTS );
		for ( int i=0; i<ITFTeamSpawnAutoList::AutoList().Count(); ++i )
		{
			CTFTeamSpawn *pTFSpawn = static_cast< CTFTeamSpawn* >( ITFTeamSpawnAutoList::AutoList()[i] );
			if ( pTFSpawn->GetControlPoint() )
			{
				m_bControlSpawnsPerTeam[ pTFSpawn->GetTeamNumber() ][ pTFSpawn->GetControlPoint()->GetPointIndex() ] = true;
				pTFSpawn->SetDisabled( true );
			}
		}

		RecalculateControlPointState();

		SetRoundOverlayDetails();
	}

	//Do any round specific setup for training logic (resetting the score, messages, etc).
	if ( IsInTraining() )
	{
		if ( m_hTrainingModeLogic )
		{
			m_hTrainingModeLogic->SetupOnRoundStart();
		}
	}

	m_szMostRecentCappers[0] = 0;
	m_halloweenBossTimer.Invalidate();
	m_ghostVector.RemoveAll();

	m_zombieMobTimer.Invalidate();
	m_zombiesLeftToSpawn = 0;

	SetIT( NULL );
	SetBirthdayPlayer( NULL );

	if ( g_pMonsterResource )
	{
		g_pMonsterResource->HideBossHealthMeter();
	}

#ifdef TF_RAID_MODE
	if ( IsBossBattleMode() )
	{
		CTFTeam *enemyTeam = GetGlobalTFTeam( TF_TEAM_RED );
		for( int i=0; i<enemyTeam->GetNumPlayers(); ++i )
		{
			CTFPlayer *who = ToTFPlayer( enemyTeam->GetPlayer( i ) );

			who->ChangeTeam( TEAM_SPECTATOR, false, true );
			who->RemoveAllObjects();
		}
	}
#endif // TF_RAID_MODE

	if ( IsMannVsMachineMode() )
	{
		if ( g_hMannVsMachineLogic )
		{
			g_hMannVsMachineLogic->SetupOnRoundStart();
		}
	}

	m_redPayloadToPush = NULL;
	m_bluePayloadToPush = NULL;
	m_redPayloadToBlock = NULL;
	m_bluePayloadToBlock = NULL;

	// Tell the clients to recalculate the holiday
	IGameEvent *event = gameeventmanager->CreateEvent( "recalculate_holidays" );
	if ( event )
	{
		gameeventmanager->FireEvent( event );
	}

	UTIL_CalculateHolidays();

	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		m_helltowerTimer.Start( HELLTOWER_TIMER_INTERVAL );
	}
	
	// reset hell state
	SetPlayersInHell( false );

	if ( IsPowerupMode() )
	{
		// Reset imbalance detection scores
		m_nPowerupKillsBlueTeam = 0;		
		m_nPowerupKillsRedTeam = 0;
		SpawnRunes();
	}

	m_hHolidayLogic = dynamic_cast<CTFHolidayEntity*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_holiday" ) );
	if ( m_hHolidayLogic.IsValid() )
	{
		m_hHolidayLogic->ResetWinner();
	}

	// cache off teleport locations and remove entities to save edicts
	m_mapTeleportLocations.PurgeAndDeleteElements();
	for ( int i=0; i<ITFTeleportLocationAutoList::AutoList().Count(); ++i )
	{
		CTFTeleportLocation *pLocation = static_cast< CTFTeleportLocation* >( ITFTeleportLocationAutoList::AutoList()[i] );

		int iMap = m_mapTeleportLocations.Find( pLocation->GetEntityName() );
		if ( !m_mapTeleportLocations.IsValidIndex( iMap ) )
		{
			CUtlVector< TeleportLocation_t > *pNew = new CUtlVector< TeleportLocation_t >;
			iMap = m_mapTeleportLocations.Insert( pLocation->GetEntityName(), pNew );
		}

		CUtlVector< TeleportLocation_t > *pLocations = m_mapTeleportLocations[iMap];
		int iLocation = pLocations->AddToTail();
		pLocations->Element( iLocation ).m_vecPosition = pLocation->GetAbsOrigin();
		pLocations->Element( iLocation ).m_qAngles = pLocation->GetAbsAngles();

		UTIL_Remove( pLocation );
	}

	// swap our train model for the EOTL holiday
	if ( IsHolidayActive( kHoliday_EOTL ) )
	{
		for ( int i = 0; i < IPhysicsPropAutoList::AutoList().Count(); i++ )
		{
			CPhysicsProp *pPhysicsProp = static_cast<CPhysicsProp*>( IPhysicsPropAutoList::AutoList()[i] );
			const char *pszTemp = pPhysicsProp->GetModelName().ToCStr();

			if ( FStrEq( pszTemp, "models/props_trainyard/bomb_cart.mdl" ) )
			{
				pPhysicsProp->SetModel( "models/props_trainyard/bomb_eotl_blue.mdl" );
			}
			else if ( FStrEq( pszTemp, "models/props_trainyard/bomb_cart_red.mdl" ) )
			{
				pPhysicsProp->SetModel( "models/props_trainyard/bomb_eotl_red.mdl" );
			}
		}
	}

	m_flMatchSummaryTeleportTime = -1.f;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::RestartTournament( void )
{
	BaseClass::RestartTournament();

	if ( GetStopWatchTimer() )
	{
		UTIL_Remove( GetStopWatchTimer() );
	}

	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( !pTFPlayer || !pTFPlayer->IsAlive() )
			continue;

		pTFPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED, true );
		pTFPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED_BONUS_TIME, true );
		pTFPlayer->m_Shared.RemoveCond( TF_COND_CRITBOOSTED_CTF_CAPTURE, true );
	}

	ItemSystem()->ReloadWhitelist();

	ResetPlayerAndTeamReadyState();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::HandleTeamScoreModify( int iTeam, int iScore )
{
	BaseClass::HandleTeamScoreModify( iTeam, iScore );

	if ( IsInStopWatch() == true )
	{
		if ( GetStopWatchTimer() )
		{
			if ( GetStopWatchTimer()->IsWatchingTimeStamps() == true )
			{
				GetStopWatchTimer()->SetStopWatchTimeStamp();
			}
	
			StopWatchModeThink();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::StopWatchShouldBeTimedWin_Calculate( void )
{
	m_bStopWatchShouldBeTimedWin = false;

	if ( IsInTournamentMode() && IsInStopWatch() && ObjectiveResource() )
	{
		int iStopWatchTimer = ObjectiveResource()->GetStopWatchTimer();
		CTeamRoundTimer *pStopWatch = dynamic_cast< CTeamRoundTimer* >( UTIL_EntityByIndex( iStopWatchTimer ) );
		if ( pStopWatch && !pStopWatch->IsWatchingTimeStamps() )
		{
			CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;

			if ( pMaster == NULL )
				return;

			int iNumPoints = pMaster->GetNumPoints();

			CTFTeam *pAttacker = NULL;
			CTFTeam *pDefender = NULL;

			for ( int i = LAST_SHARED_TEAM+1; i < GetNumberOfTeams(); i++ )
			{
				CTFTeam *pTeam = GetGlobalTFTeam( i );

				if ( pTeam )
				{
					if ( pTeam->GetRole() == TEAM_ROLE_DEFENDERS )
					{
						pDefender = pTeam;
					}

					if ( pTeam->GetRole() == TEAM_ROLE_ATTACKERS )
					{
						pAttacker = pTeam;
					}
				}
			}

			if ( pAttacker == NULL || pDefender == NULL )
				return;

			m_bStopWatchShouldBeTimedWin = ( pDefender->GetScore() == iNumPoints );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::StopWatchShouldBeTimedWin( void )
{
	StopWatchShouldBeTimedWin_Calculate();
	return m_bStopWatchShouldBeTimedWin;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::StopWatchModeThink( void )
{
	if ( IsInTournamentMode() == false || IsInStopWatch() == false )
		return;

	if ( GetStopWatchTimer() == NULL )
		return;

	CTeamRoundTimer *pTimer = GetStopWatchTimer();

	bool bWatchingCaps = pTimer->IsWatchingTimeStamps();
	
	CTFTeam *pAttacker = NULL;
	CTFTeam *pDefender = NULL;

	for ( int i = LAST_SHARED_TEAM+1; i < GetNumberOfTeams(); i++ )
	{
		CTFTeam *pTeam = GetGlobalTFTeam( i );

		if ( pTeam )
		{
			if ( pTeam->GetRole() == TEAM_ROLE_DEFENDERS )
			{
				pDefender = pTeam;
			}

			if ( pTeam->GetRole() == TEAM_ROLE_ATTACKERS )
			{
				pAttacker = pTeam;
			}
		}
	}

	if ( pAttacker == NULL || pDefender == NULL )
		return;

	m_bStopWatchWinner.Set( false );

	if ( bWatchingCaps == false )
	{
		if ( pTimer->GetTimeRemaining() <= 0.0f )
		{
			if ( StopWatchShouldBeTimedWin() )
			{
				if ( pAttacker->GetScore() < pDefender->GetScore() )
				{
					m_bStopWatchWinner.Set( true );
					SetWinningTeam( pDefender->GetTeamNumber(), WINREASON_DEFEND_UNTIL_TIME_LIMIT, true, true );
				}
			}
			else
			{
				if ( pAttacker->GetScore() > pDefender->GetScore() )
				{
					m_bStopWatchWinner.Set( true );
					SetWinningTeam( pAttacker->GetTeamNumber(), WINREASON_ALL_POINTS_CAPTURED, true, true );	
				}
			}

			if ( pTimer->IsTimerPaused() == false )
			{
				variant_t sVariant;
				pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
			}

			m_nStopWatchState.Set( STOPWATCH_OVERTIME );
		}
		else
		{
			if ( pAttacker->GetScore() >= pDefender->GetScore() )
			{
				m_bStopWatchWinner.Set( true );
				SetWinningTeam( pAttacker->GetTeamNumber(), WINREASON_ALL_POINTS_CAPTURED, true, true );
			}
		}
	}
	else
	{
		if ( pTimer->GetTimeRemaining() <= 0.0f )
		{
			m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET );
		}
		else
		{
			m_nStopWatchState.Set( STOPWATCH_RUNNING );
		}
	}

	if ( m_bStopWatchWinner == true )
	{
		UTIL_Remove( pTimer	);
		m_hStopWatchTimer = NULL;
		m_flStopWatchTotalTime = -1.0f;
		m_bStopWatch = false;
		m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET );

		ShouldResetRoundsPlayed( false );
		ShouldResetScores( true, false );
		ResetScores();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::ManageStopwatchTimer( bool bInSetup ) 
{
	if ( IsInTournamentMode() == false )
		return;

	if ( mp_tournament_stopwatch.GetBool() == false )
		return;

	bool bAttacking = false;
	bool bDefending = false;

	for ( int i = LAST_SHARED_TEAM+1; i < GetNumberOfTeams(); i++ )
	{
		CTFTeam *pTeam = GetGlobalTFTeam( i );

		if ( pTeam )
		{
			if ( pTeam->GetRole() == TEAM_ROLE_DEFENDERS )
			{
				bDefending = true;
			}

			if ( pTeam->GetRole() == TEAM_ROLE_ATTACKERS )
			{
				bAttacking = true;
			}
		}
	}

	if ( bDefending == true && bAttacking == true )
	{
		SetInStopWatch( true );
	}
	else
	{
		SetInStopWatch( false );
	}

	if ( IsInStopWatch() == true )
	{
		if ( m_hStopWatchTimer == NULL )
		{
			variant_t sVariant;
			CTeamRoundTimer *pStopWatch = (CTeamRoundTimer*)CBaseEntity::CreateNoSpawn( "team_round_timer", vec3_origin, vec3_angle );
			m_hStopWatchTimer = pStopWatch;

			pStopWatch->SetName( MAKE_STRING("zz_stopwatch_timer") );
			pStopWatch->SetShowInHud( false );
			pStopWatch->SetStopWatch( true );

			if ( m_flStopWatchTotalTime < 0.0f )
			{
				pStopWatch->SetCaptureWatchState( true );
				DispatchSpawn( pStopWatch );
			
				pStopWatch->AcceptInput( "Enable", NULL, NULL, sVariant, 0 );
			}
			else
			{
				DispatchSpawn( pStopWatch );
				pStopWatch->SetCaptureWatchState( false );
				

				sVariant.SetInt( m_flStopWatchTotalTime );
				pStopWatch->AcceptInput( "Enable", NULL, NULL, sVariant, 0 );
				pStopWatch->AcceptInput( "SetTime", NULL, NULL, sVariant, 0 );
				pStopWatch->SetAutoCountdown( true );
			}

			if ( bInSetup == true )
			{
				pStopWatch->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
			}

			ObjectiveResource()->SetStopWatchTimer( pStopWatch );
		}
		else
		{
			if ( bInSetup == false )
			{
				variant_t sVariant;
				m_hStopWatchTimer->AcceptInput( "Resume", NULL, NULL, sVariant, 0 );
			}
			else
			{
				variant_t sVariant;
				m_hStopWatchTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetSetup( bool bSetup ) 
{ 
	if ( m_bInSetup == bSetup )
		return;

	BaseClass::SetSetup( bSetup );

	ManageStopwatchTimer( bSetup );
}

//-----------------------------------------------------------------------------
// Purpose: Called when a new round is off and running
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnRoundRunning( void )
{
	// Let out control point masters know that the round has started
	for ( int i = 0; i < g_hControlPointMasters.Count(); i++ )
	{
		variant_t emptyVariant;
		if ( g_hControlPointMasters[i] )
		{
			g_hControlPointMasters[i]->AcceptInput( "RoundStart", NULL, NULL, emptyVariant, 0 );
		}
	}

	// Reset player speeds after preround lock
	CTFPlayer *pPlayer;
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );

		if ( !pPlayer )
			continue;

		pPlayer->TeamFortress_SetSpeed();
		if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
		{
			if ( !IsInWaitingForPlayers() )
			{
				pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START );
			}

		}
		else if ( !IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
		{
			if ( IsCompetitiveMode() )
			{
				pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START_COMP );
			}
			else
			{
				pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START );
			}
		}

		// warp the coach to student
		if ( pPlayer->GetStudent() )
		{
			pPlayer->SetObserverTarget( pPlayer->GetStudent() );
			pPlayer->StartObserverMode( OBS_MODE_CHASE );
		}

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

		pPlayer->m_Shared.ResetRoundScores();

		// Store the class they started the round as (tf_player captures everything after this)
		if ( pPlayer->GetTeamNumber() >= FIRST_GAME_TEAM )
		{
			CSteamID steamID;
			pPlayer->GetSteamID( &steamID );

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

	if ( IsPlayingSpecialDeliveryMode() && !IsInWaitingForPlayers() )
	{
		if ( !IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
		{
			BroadcastSound( 255, "Announcer.SD_RoundStart" );
		}
	}

	if ( IsMannVsMachineMode() && g_pPopulationManager )
	{
		IGameEvent *event = gameeventmanager->CreateEvent( "mvm_begin_wave" );
		if ( event )
		{
			event->SetInt( "wave_index", g_pPopulationManager->GetWaveNumber() );
			event->SetInt( "max_waves", g_pPopulationManager->GetTotalWaveCount() );
			event->SetInt( "advanced", g_pPopulationManager->IsAdvancedPopFile() ? 1 : 0 );
			gameeventmanager->FireEvent( event );
		}
	}

	if ( IsCompetitiveMode() && !( GetActiveRoundTimer() && ( GetActiveRoundTimer()->GetSetupTimeLength() > 0 ) ) )
	{
		// Announcer VO
		if ( ( TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore() == ( mp_winlimit.GetInt() - 1 ) ) &&
			 ( TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetScore() == ( mp_winlimit.GetInt() - 1 ) ) )
		{
			BroadcastSound( 255, "Announcer.CompFinalGameBeginsFight" );
		}
		else
		{
			BroadcastSound( 255, "Announcer.CompGameBeginsFight" );
		}
	}

	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	if ( pMatch && IsMatchTypeCompetitive() )
	{
		static ConVarRef tf_bot_quota( "tf_bot_quota" );
		tf_bot_quota.SetValue( (int)pMatch->GetCanonicalMatchSize() );
		static ConVarRef tf_bot_quota_mode( "tf_bot_quota_mode" );
		tf_bot_quota_mode.SetValue( "fill" );
	}

	if ( m_hGamerulesProxy )
	{
		m_hGamerulesProxy->StateEnterRoundRunning();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Called before a new round is started (so the previous round can end)
//-----------------------------------------------------------------------------
void CTFGameRules::PreviousRoundEnd( void )
{
	// before we enter a new round, fire the "end output" for the previous round
	if ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] )
	{
		g_hControlPointMasters[0]->FireRoundEndOutput();
	}

	m_iPreviousRoundWinners = GetWinningTeam();
}

//-----------------------------------------------------------------------------
// Purpose: Called when a round has entered stalemate mode (timer has run out)
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnStalemateStart( void )
{
	// Remove everyone's objects
	RemoveAllProjectilesAndBuildings();
	
	if ( IsInArenaMode() == false )
	{
		// Respawn all the players
		RespawnPlayers( true );

		// Disable all the active health packs in the world
		m_hDisabledHealthKits.Purge();
		CHealthKit *pHealthPack = gEntList.NextEntByClass( (CHealthKit *)NULL );
		while ( pHealthPack )
		{
			if ( !pHealthPack->IsDisabled() )
			{
				pHealthPack->SetDisabled( true );
				m_hDisabledHealthKits.AddToTail( pHealthPack );
			}
			pHealthPack = gEntList.NextEntByClass( pHealthPack );
		}
	}
	else
	{
		CArenaLogic *pArenaLogic = dynamic_cast< CArenaLogic * > (gEntList.FindEntityByClassname( NULL, "tf_logic_arena" ) );

		if ( pArenaLogic )
		{
			pArenaLogic->m_OnArenaRoundStart.FireOutput( pArenaLogic, pArenaLogic );

			if ( tf_arena_override_cap_enable_time.GetFloat() > 0 )
			{
				m_flCapturePointEnableTime = gpGlobals->curtime + tf_arena_override_cap_enable_time.GetFloat();
			}
			else
			{
				m_flCapturePointEnableTime = gpGlobals->curtime + pArenaLogic->m_flTimeToEnableCapPoint;
			}

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

			BroadcastSound( 255, "Announcer.AM_RoundStartRandom" );
		}
	}

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

		if ( !pPlayer )
			continue;

		if ( IsInArenaMode() == true )
		{
			pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_ROUND_START );
			pPlayer->TeamFortress_SetSpeed();
		}
		else
		{
			pPlayer->SpeakConceptIfAllowed( MP_CONCEPT_SUDDENDEATH_START );
		}
	}

	m_flStalemateStartTime = gpGlobals->curtime;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnStalemateEnd( void )
{
	// Reenable all the health packs we disabled
	for ( int i = 0; i < m_hDisabledHealthKits.Count(); i++ )
	{
		if ( m_hDisabledHealthKits[i] )
		{
			m_hDisabledHealthKits[i]->SetDisabled( false );
		}
	}

	m_hDisabledHealthKits.Purge();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::InitTeams( void )
{
	BaseClass::InitTeams();

	// clear the player class data
	ResetFilePlayerClassInfoDatabase();
}


class CTraceFilterIgnoreTeammatesWithException : public CTraceFilterSimple
{
	DECLARE_CLASS( CTraceFilterIgnoreTeammatesWithException, CTraceFilterSimple );
public:
	CTraceFilterIgnoreTeammatesWithException( const IHandleEntity *passentity, int collisionGroup, int iIgnoreTeam, const IHandleEntity *pExceptionEntity )
		: CTraceFilterSimple( passentity, collisionGroup ), m_iIgnoreTeam( iIgnoreTeam )
	{
		m_pExceptionEntity = pExceptionEntity;
	}

	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask )
	{
		CBaseEntity *pEntity = EntityFromEntityHandle( pServerEntity );

		if ( pServerEntity == m_pExceptionEntity )
			return true;

		if ( pEntity->IsPlayer() && pEntity->GetTeamNumber() == m_iIgnoreTeam )
		{
			return false;
		}

		return true;
	}

	int m_iIgnoreTeam;
	const IHandleEntity *m_pExceptionEntity;
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::RadiusDamage( CTFRadiusDamageInfo &info )
{
	float flRadSqr = (info.flRadius * info.flRadius);

	int iDamageEnemies = 0;
	int nDamageDealt = 0;
	// Some weapons pass a radius of 0, since their only goal is to give blast jumping ability
	if ( info.flRadius > 0 )
	{
		// Find all the entities in the radius, and attempt to damage them.
		CBaseEntity *pEntity = NULL;
		for ( CEntitySphereQuery sphere( info.vecSrc, info.flRadius ); (pEntity = sphere.GetCurrentEntity()) != NULL; sphere.NextEntity() )
		{
			// Skip the attacker, if we have a RJ radius set. We'll do it post.
			if ( info.flRJRadius && pEntity == info.dmgInfo->GetAttacker() )
				continue;

			// CEntitySphereQuery actually does a box test. So we need to make sure the distance is less than the radius first.
			Vector vecPos;
			pEntity->CollisionProp()->CalcNearestPoint( info.vecSrc, &vecPos );
			if ( (info.vecSrc - vecPos).LengthSqr() > flRadSqr )
				continue;

			int iDamageToEntity = info.ApplyToEntity( pEntity );
			if ( iDamageToEntity )
			{
				// Keep track of any enemies we damaged
				if ( pEntity->IsPlayer() && !pEntity->InSameTeam( info.dmgInfo->GetAttacker() ) )
				{
					nDamageDealt+= iDamageToEntity;
					iDamageEnemies++;
				}
			}
		}
	}

	// If we have a set RJ radius, use it to affect the inflictor. This way Rocket Launchers 
	// with modified damage/radius perform like the base rocket launcher when it comes to RJing.
	if ( info.flRJRadius && info.dmgInfo->GetAttacker() )
	{
		// Set our radius & damage to the base RL
		info.flRadius = info.flRJRadius;
		CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(info.dmgInfo->GetWeapon());
		if ( pWeapon )
		{
			float flBaseDamage = pWeapon->GetTFWpnData().GetWeaponData( TF_WEAPON_PRIMARY_MODE ).m_nDamage;
			info.dmgInfo->SetDamage( flBaseDamage );
			info.dmgInfo->CopyDamageToBaseDamage();
			info.dmgInfo->SetDamagedOtherPlayers( iDamageEnemies );

			// If we dealt damage, check radius life leech
			if ( nDamageDealt > 0 )
			{
				// Heal on hits
				int iModHealthOnHit = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( info.dmgInfo->GetWeapon(), iModHealthOnHit, add_health_on_radius_damage );
				if ( iModHealthOnHit )
				{
					// Scale Health mod with damage dealt, input being the maximum amount of health possible
					float flScale = Clamp( nDamageDealt / flBaseDamage, 0.f, 1.0f );
					iModHealthOnHit = (int)( (float)iModHealthOnHit * flScale );
					int iHealed = info.dmgInfo->GetAttacker()->TakeHealth( iModHealthOnHit, DMG_GENERIC );
					if ( iHealed )
					{
						IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
						if ( event )
						{
							event->SetInt( "amount", iHealed );
							event->SetInt( "entindex", info.dmgInfo->GetAttacker()->entindex() );
							item_definition_index_t healingItemDef = INVALID_ITEM_DEF_INDEX;
							if ( pWeapon->GetAttributeContainer() && pWeapon->GetAttributeContainer()->GetItem() )
							{
								healingItemDef = pWeapon->GetAttributeContainer()->GetItem()->GetItemDefIndex();
							}
							event->SetInt( "weapon_def_index", healingItemDef );
							gameeventmanager->FireEvent( event );
						}
					}
				}
			}
		}

		// Apply ourselves to our attacker, if we're within range
		Vector vecPos;
		info.dmgInfo->GetAttacker()->CollisionProp()->CalcNearestPoint( info.vecSrc, &vecPos );
		if ( (info.vecSrc - vecPos).LengthSqr() <= (info.flRadius * info.flRadius) )
		{
			info.ApplyToEntity( info.dmgInfo->GetAttacker() );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Calculate the damage falloff over distance
//-----------------------------------------------------------------------------
void CTFRadiusDamageInfo::CalculateFalloff( void )
{
	if ( dmgInfo->GetDamageType() & DMG_RADIUS_MAX )
		flFalloff = 0.0;
	else if ( dmgInfo->GetDamageType() & DMG_HALF_FALLOFF )
		flFalloff = 0.5;
	else if ( flRadius )
		flFalloff = dmgInfo->GetDamage() / flRadius;
	else
		flFalloff = 1.0;

	CBaseEntity *pWeapon = dmgInfo->GetWeapon();
	if ( pWeapon != NULL )
	{
		float flFalloffMod = 1.f;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flFalloffMod, mult_dmg_falloff );
		if ( flFalloffMod != 1.f )
		{
			flFalloff += flFalloffMod;
		}
	}

	if ( TFGameRules() && TFGameRules()->IsPowerupMode() )
	{
		CTFPlayer *pOwner = ToTFPlayer( dmgInfo->GetAttacker() );
		if ( pOwner && pOwner->m_Shared.GetCarryingRuneType() == RUNE_PRECISION )
		{
			flFalloff = 1.0;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Attempt to apply the radius damage to the specified entity
//-----------------------------------------------------------------------------
int CTFRadiusDamageInfo::ApplyToEntity( CBaseEntity *pEntity )
{
	if ( pEntity == pEntityIgnore || pEntity->m_takedamage == DAMAGE_NO )
		return 0;

	trace_t	tr;
	CBaseEntity *pInflictor = dmgInfo->GetInflictor();

	// Check that the explosion can 'see' this entity.
	Vector vecSpot = pEntity->BodyTarget( vecSrc, false );
	CTraceFilterIgnorePlayers filterPlayers( pInflictor, COLLISION_GROUP_PROJECTILE );
	CTraceFilterIgnoreFriendlyCombatItems filterCombatItems( pInflictor, COLLISION_GROUP_PROJECTILE, pInflictor->GetTeamNumber() );
	CTraceFilterChain filter( &filterPlayers, &filterCombatItems );

	UTIL_TraceLine( vecSrc, vecSpot, MASK_RADIUS_DAMAGE, &filter, &tr );
	if ( tr.startsolid && tr.m_pEnt )
	{
		// Return when inside an enemy combat shield and tracing against a player of that team ("absorbed")
		if ( tr.m_pEnt->IsCombatItem() && pEntity->InSameTeam( tr.m_pEnt ) && ( pEntity != tr.m_pEnt ) )
			return 0;

		filterPlayers.SetPassEntity( tr.m_pEnt );
		CTraceFilterChain filterSelf( &filterPlayers, &filterCombatItems );
		UTIL_TraceLine( vecSrc, vecSpot, MASK_RADIUS_DAMAGE, &filterSelf, &tr );
	}

	// If we don't trace the whole way to the target, and we didn't hit the target entity, we're blocked
	if ( tr.fraction != 1.0 && tr.m_pEnt != pEntity )
		return 0;

	// Adjust the damage - apply falloff.
	float flAdjustedDamage = 0.0f;
	float flDistanceToEntity;

	// Rockets store the ent they hit as the enemy and have already dealt full damage to them by this time
	if ( pInflictor && ( pEntity == pInflictor->GetEnemy() ) )
	{
		// Full damage, we hit this entity directly
		flDistanceToEntity = 0;
	}
	else if ( pEntity->IsPlayer() )
	{
		// Use whichever is closer, absorigin or worldspacecenter
		float flToWorldSpaceCenter = ( vecSrc - pEntity->WorldSpaceCenter() ).Length();
		float flToOrigin = ( vecSrc - pEntity->GetAbsOrigin() ).Length();

		flDistanceToEntity = MIN( flToWorldSpaceCenter, flToOrigin );
	}
	else
	{
		flDistanceToEntity = ( vecSrc - tr.endpos ).Length();
	}

	flAdjustedDamage = RemapValClamped( flDistanceToEntity, 0, flRadius, dmgInfo->GetDamage(), dmgInfo->GetDamage() * flFalloff );

	CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>(dmgInfo->GetWeapon());
	
	// Grenades & Pipebombs do less damage to ourselves.
	if ( pEntity == dmgInfo->GetAttacker() && pWeapon )
	{
		switch( pWeapon->GetWeaponID() )
		{
			case TF_WEAPON_PIPEBOMBLAUNCHER :
			case TF_WEAPON_GRENADELAUNCHER :
			case TF_WEAPON_CANNON :
			case TF_WEAPON_STICKBOMB :
				flAdjustedDamage *= 0.75f;
				break;
		}
	}

	// If we end up doing 0 damage, exit now.
	if ( flAdjustedDamage <= 0 )
		return 0;

	// the explosion can 'see' this entity, so hurt them!
	if (tr.startsolid)
	{
		// if we're stuck inside them, fixup the position and distance
		tr.endpos = vecSrc;
		tr.fraction = 0.0;
	}

	CTakeDamageInfo adjustedInfo = *dmgInfo;
	adjustedInfo.SetDamage( flAdjustedDamage );

	Vector dir = vecSpot - vecSrc;
	VectorNormalize( dir );

	// If we don't have a damage force, manufacture one
	if ( adjustedInfo.GetDamagePosition() == vec3_origin || adjustedInfo.GetDamageForce() == vec3_origin )
	{
		CalculateExplosiveDamageForce( &adjustedInfo, dir, vecSrc );
	}
	else
	{
		// Assume the force passed in is the maximum force. Decay it based on falloff.
		float flForce = adjustedInfo.GetDamageForce().Length() * flFalloff;
		adjustedInfo.SetDamageForce( dir * flForce );
		adjustedInfo.SetDamagePosition( vecSrc );
	}

	adjustedInfo.ScaleDamageForce( m_flForceScale );

	int nDamageTaken = 0;
	if ( tr.fraction != 1.0 && pEntity == tr.m_pEnt )
	{
		ClearMultiDamage( );
		pEntity->DispatchTraceAttack( adjustedInfo, dir, &tr );
		ApplyMultiDamage();
	}
	else
	{
		nDamageTaken = pEntity->TakeDamage( adjustedInfo );
	}

	// Now hit all triggers along the way that respond to damage.
	pEntity->TraceAttackToTriggers( adjustedInfo, vecSrc, tr.endpos, dir );
	return nDamageTaken;
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : &info - 
//			&vecSrcIn - 
//			flRadius - 
//			iClassIgnore - 
//			*pEntityIgnore - 
//-----------------------------------------------------------------------------
void CTFGameRules::RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrcIn, float flRadius, int iClassIgnore, CBaseEntity *pEntityIgnore )
{
	// This shouldn't be used. Call the version above that takes a CTFRadiusDamageInfo pointer.
	Assert(0);

	CTakeDamageInfo dmgInfo = info;
	Vector vecSrc = vecSrcIn;
	CTFRadiusDamageInfo radiusinfo( &dmgInfo, vecSrc, flRadius, pEntityIgnore );
	RadiusDamage(radiusinfo);
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ApplyOnDamageModifyRules( CTakeDamageInfo &info, CBaseEntity *pVictimBaseEntity, bool bAllowDamage )
{
	info.SetDamageForForceCalc( info.GetDamage() );
	bool bDebug = tf_debug_damage.GetBool();

	CTFPlayer *pVictim = ToTFPlayer( pVictimBaseEntity );
	CBaseEntity *pAttacker = info.GetAttacker();
	CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );

	// damage may not come from a weapon (ie: Bosses, etc)
	// The existing code below already checked for NULL pWeapon, anyways
	CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( info.GetWeapon() );

	bool bShowDisguisedCrit = false;
	bool bAllSeeCrit = false;
	EAttackBonusEffects_t eBonusEffect = kBonusEffect_None;

	if ( pVictim )
	{
		pVictim->SetSeeCrit( false, false, false );
		pVictim->SetAttackBonusEffect( kBonusEffect_None );
	}

	int bitsDamage = info.GetDamageType();

	// Damage type was already crit (Flares / headshot)
	if ( bitsDamage & DMG_CRITICAL )
	{
		info.SetCritType( CTakeDamageInfo::CRIT_FULL );
	}

	// First figure out whether this is going to be a full forced crit for some specific reason. It's
	// important that we do this before figuring out whether we're going to be a minicrit or not.

	// Allow attributes to force critical hits on players with specific conditions
	if ( pVictim )
	{
		// Crit against players that have these conditions
		int iCritDamageTypes = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritDamageTypes, or_crit_vs_playercond );

		if ( iCritDamageTypes )
		{
			// iCritDamageTypes is an or'd list of types. We need to pull each bit out and
			// then test against what that bit in the items_master file maps to.
			for ( int i = 0; condition_to_attribute_translation[i] != TF_COND_LAST; i++ )
			{
				if ( iCritDamageTypes & ( 1 << i ) )
				{
					if ( pVictim->m_Shared.InCond( condition_to_attribute_translation[ i ] ) )
					{
						bitsDamage |= DMG_CRITICAL;
						info.AddDamageType( DMG_CRITICAL );
						info.SetCritType( CTakeDamageInfo::CRIT_FULL );

						if ( condition_to_attribute_translation[i] == TF_COND_DISGUISED || 
							 condition_to_attribute_translation[i] == TF_COND_DISGUISING )
						{
							// if our attribute specifically crits disguised enemies we need to show it on the client
							bShowDisguisedCrit = true;
						}
						break;
					}
				}
			}
		}

		int iCritVsWet = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritVsWet, crit_vs_wet_players );
		if ( iCritVsWet )
		{
			float flWaterExitTime = pVictim->GetWaterExitTime();

			if ( pVictim->m_Shared.InCond( TF_COND_URINE ) ||
				 pVictim->m_Shared.InCond( TF_COND_MAD_MILK ) ||
			   ( pVictim->GetWaterLevel() > WL_NotInWater ) ||
			   ( ( flWaterExitTime > 0 ) && ( gpGlobals->curtime - flWaterExitTime < 5.0f ) ) ) // or they exited the water in the last few seconds
			{
				bitsDamage |= DMG_CRITICAL;
				info.AddDamageType( DMG_CRITICAL );
				info.SetCritType( CTakeDamageInfo::CRIT_FULL );
			}
		}
 
		// Crit against players that don't have these conditions
		int iCritDamageNotTypes = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritDamageNotTypes, or_crit_vs_not_playercond );

		if ( iCritDamageNotTypes )
		{
			// iCritDamageTypes is an or'd list of types. We need to pull each bit out and
			// then test against what that bit in the items_master file maps to.
			for ( int i = 0; condition_to_attribute_translation[i] != TF_COND_LAST; i++ )
			{
				if ( iCritDamageNotTypes & ( 1 << i ) )
				{
					if ( !pVictim->m_Shared.InCond( condition_to_attribute_translation[ i ] ) )
					{
						bitsDamage |= DMG_CRITICAL;
						info.AddDamageType( DMG_CRITICAL );
						info.SetCritType( CTakeDamageInfo::CRIT_FULL );

						if ( condition_to_attribute_translation[ i ] == TF_COND_DISGUISED || 
							 condition_to_attribute_translation[ i ] == TF_COND_DISGUISING )
						{
							// if our attribute specifically crits disguised enemies we need to show it on the client
							bShowDisguisedCrit = true;
						}
						break;
					}
				}
			}
		}

		// Crit burning behind
		int iCritBurning = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritBurning, axtinguisher_properties );
		if ( iCritBurning && pVictim->m_Shared.InCond( TF_COND_BURNING ) )
		{
			// Full crit in back, mini in front
			Vector toEnt = pVictim->GetAbsOrigin() - pTFAttacker->GetAbsOrigin();
			{
				Vector entForward;
				AngleVectors( pVictim->EyeAngles(), &entForward );
				toEnt.z = 0;
				toEnt.NormalizeInPlace();

				if ( DotProduct( toEnt, entForward ) > 0.0f )	// 90 degrees from center (total of 180)
				{
					bitsDamage |= DMG_CRITICAL;
					info.AddDamageType( DMG_CRITICAL );
					info.SetCritType( CTakeDamageInfo::CRIT_FULL );
				}
				else
				{
					bAllSeeCrit = true;
					info.SetCritType( CTakeDamageInfo::CRIT_MINI );
					eBonusEffect = kBonusEffect_MiniCrit;
				}
			}
		}
	}

	int iCritWhileAirborne = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iCritWhileAirborne, crit_while_airborne );
	if ( iCritWhileAirborne && pTFAttacker )
	{
		if ( pTFAttacker->InAirDueToExplosion() )
		{
			bitsDamage |= DMG_CRITICAL;
			info.AddDamageType( DMG_CRITICAL );
			info.SetCritType( CTakeDamageInfo::CRIT_FULL );
		}
	}
	
	// For awarding assist damage stat later
	ETFCond eDamageBonusCond = TF_COND_LAST;

	// Some forms of damage override long range damage falloff
	bool bIgnoreLongRangeDmgEffects = false;

	// Figure out if it's a minicrit or not
	// But we never minicrit ourselves.
	if ( pAttacker != pVictimBaseEntity )
	{
		if ( info.GetCritType() == CTakeDamageInfo::CRIT_NONE )
		{
			CBaseEntity *pInflictor = info.GetInflictor();
			CTFGrenadePipebombProjectile *pBaseGrenade = dynamic_cast< CTFGrenadePipebombProjectile* >( pInflictor );
			CTFBaseRocket *pBaseRocket = dynamic_cast< CTFBaseRocket* >( pInflictor );

			if ( pVictim && ( pVictim->m_Shared.InCond( TF_COND_URINE ) ||
			                  pVictim->m_Shared.InCond( TF_COND_MARKEDFORDEATH ) ||
			                  pVictim->m_Shared.InCond( TF_COND_MARKEDFORDEATH_SILENT ) ||
			                  pVictim->m_Shared.InCond( TF_COND_PASSTIME_PENALTY_DEBUFF ) ) )
			{
				bAllSeeCrit = true;
				info.SetCritType( CTakeDamageInfo::CRIT_MINI );
				eBonusEffect = kBonusEffect_MiniCrit;

				if ( !pVictim->m_Shared.InCond( TF_COND_MARKEDFORDEATH_SILENT ) )
				{
					eDamageBonusCond = pVictim->m_Shared.InCond( TF_COND_URINE ) ? TF_COND_URINE : TF_COND_MARKEDFORDEATH;
				}
			}
			else if ( pTFAttacker && ( pTFAttacker->m_Shared.InCond( TF_COND_OFFENSEBUFF ) || pTFAttacker->m_Shared.InCond( TF_COND_NOHEALINGDAMAGEBUFF ) ) )
			{
				// Attackers buffed by the soldier do mini-crits.
				bAllSeeCrit = true;
				info.SetCritType( CTakeDamageInfo::CRIT_MINI );
				eBonusEffect = kBonusEffect_MiniCrit;

				if ( pTFAttacker->m_Shared.InCond( TF_COND_OFFENSEBUFF ) )
				{
					eDamageBonusCond = TF_COND_OFFENSEBUFF;
				}
			}
			else if ( pTFAttacker && (bitsDamage & DMG_RADIUS_MAX) && pWeapon && ( (pWeapon->GetWeaponID() == TF_WEAPON_SWORD) || (pWeapon->GetWeaponID() == TF_WEAPON_BOTTLE)|| (pWeapon->GetWeaponID() == TF_WEAPON_WRENCH) ) )
			{
				// First sword or bottle attack after a charge is a mini-crit.
				bAllSeeCrit = true;
				info.SetCritType( CTakeDamageInfo::CRIT_MINI );
				eBonusEffect = kBonusEffect_MiniCrit;
			}
			else if ( ( pInflictor && pInflictor->IsPlayer() == false ) && ( ( pBaseRocket && pBaseRocket->GetDeflected() ) || ( pBaseGrenade && pBaseGrenade->GetDeflected() && ( pBaseGrenade->ShouldMiniCritOnReflect() ) ) ) )
			{
				// Reflected rockets, grenades (non-remote detonate), arrows always mini-crit
				info.SetCritType( CTakeDamageInfo::CRIT_MINI );
				eBonusEffect = kBonusEffect_MiniCrit;
			}
			else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_PLASMA_CHARGED )
			{
				// Charged plasma shots do minicrits.
				info.SetCritType( CTakeDamageInfo::CRIT_MINI );
				eBonusEffect = kBonusEffect_MiniCrit;
			}
			else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CLEAVER_CRIT )
			{
				// Long range cleaver hit
				info.SetCritType( CTakeDamageInfo::CRIT_MINI );
				eBonusEffect = kBonusEffect_MiniCrit;
			}
			else if ( pTFAttacker && ( pTFAttacker->m_Shared.InCond( TF_COND_ENERGY_BUFF ) ) )
			{
				// Scouts using crit drink do mini-crits, as well as receive them
				info.SetCritType( CTakeDamageInfo::CRIT_MINI );
				eBonusEffect = kBonusEffect_MiniCrit;
			}
			else if ( ( info.GetDamageType() & DMG_IGNITE ) && pVictim && pVictim->m_Shared.InCond( TF_COND_BURNING ) && info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING_FLARE )
			{
				CTFFlareGun *pFlareGun = dynamic_cast< CTFFlareGun* >( pWeapon );
				if ( pFlareGun && pFlareGun->GetFlareGunType() != FLAREGUN_GRORDBORT )
				{
					info.SetCritType( CTakeDamageInfo::CRIT_MINI );
					eBonusEffect = kBonusEffect_MiniCrit;
				}
			}
			else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_PELLET )
			{
				CBaseEntity *pInflictor = info.GetInflictor();
				CTFProjectile_Flare *pFlare = dynamic_cast< CTFProjectile_Flare* >( pInflictor );
				if ( pFlare && pFlare->IsFromTaunt() && pFlare->GetTimeAlive() < 0.05f )
				{
					// Taunt crits fired from the scorch shot at short range are super powerful!
					info.SetDamage( 400.0f );
				}
			}
			else if( pTFAttacker && pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_CANNON && ( info.GetDamageType() & DMG_BLAST ) )
			{
				CTFGrenadeLauncher* pGrenadeLauncher = static_cast<CTFGrenadeLauncher*>( pWeapon );
				if( pGrenadeLauncher->IsDoubleDonk( pVictim ) )
				{
					info.SetCritType( CTakeDamageInfo::CRIT_MINI );
					eBonusEffect = kBonusEffect_DoubleDonk;
					info.SetDamage( info.GetMaxDamage() ); // Double donk victims score max damage
					EconEntity_OnOwnerKillEaterEvent( pGrenadeLauncher, pTFAttacker, pVictim, kKillEaterEvent_DoubleDonks );
				}
			}
			else
			{
				// Allow Attributes to shortcut out if found, no need to check all of them
				for ( int i = 0; i < 1; ++i )
				{
					// Some weapons force minicrits on burning targets.
					// Does not work for burn but works for ignite
					int iForceMiniCritOnBurning = 0;
					CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iForceMiniCritOnBurning, or_minicrit_vs_playercond_burning );
					if ( iForceMiniCritOnBurning == 1 && pVictim && pVictim->m_Shared.InCond( TF_COND_BURNING ) && !( info.GetDamageType() & DMG_BURN ) )
					{
						bAllSeeCrit = true;
						info.SetCritType( CTakeDamageInfo::CRIT_MINI );
						eBonusEffect = kBonusEffect_MiniCrit;
						break;
					}

					// Some weapons mini-crit airborne targets. Airborne targets are any target that has been knocked 
					// into the air by an explosive force from an enemy.
					int iMiniCritAirborne = 0;
					CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritAirborne, mini_crit_airborne );
					if ( iMiniCritAirborne == 1 && pVictim && pVictim->InAirDueToKnockback() )
					{
						bAllSeeCrit = true;
						info.SetCritType( CTakeDamageInfo::CRIT_MINI );
						eBonusEffect = kBonusEffect_MiniCrit;
						break;
					}

					//// Some weapons minicrit *any* target in the air, regardless of how they got there.
					//int iMiniCritAirborneDeploy = 0;
					//CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritAirborneDeploy, mini_crit_airborne_deploy );
					//if ( iMiniCritAirborneDeploy > 0 &&
					//	 pWeapon &&
					//	 ( gpGlobals->curtime - pWeapon->GetLastDeployTime() ) < iMiniCritAirborneDeploy &&
					//	 //

					//	 pVictim && !( pVictim->GetFlags() & FL_ONGROUND ) &&
					//	 ( pVictim->GetWaterLevel() == WL_NotInWater ) )
					//{
					//	bAllSeeCrit = true;
					//	info.SetCritType( CTakeDamageInfo::CRIT_MINI );
					//	eBonusEffect = kBonusEffect_MiniCrit;
					//	break;
					//}

					if ( pTFAttacker && pVictim )
					{
						// MiniCrit a victims back at close range
						int iMiniCritBackAttack = 0;
						CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iMiniCritBackAttack, closerange_backattack_minicrits );
						Vector toEnt = pVictim->GetAbsOrigin() - pTFAttacker->GetAbsOrigin();
						if ( iMiniCritBackAttack == 1 && toEnt.LengthSqr() < Square( 512.0f ) )
						{
							Vector entForward; 
							AngleVectors( pVictim->EyeAngles(), &entForward );
							toEnt.z = 0;
							toEnt.NormalizeInPlace();

							if ( DotProduct( toEnt, entForward ) > 0.259f )	// 75 degrees from center (total of 150)
							{
								bAllSeeCrit = true;
								info.SetCritType( CTakeDamageInfo::CRIT_MINI );
								eBonusEffect = kBonusEffect_MiniCrit;
								break;
							}
						}
					}
				}
			}

			// Don't do long range distance falloff when pAttacker has Rocket Specialist attrib and directly hits an enemy
			if ( pBaseRocket && pBaseRocket->GetEnemy() && pBaseRocket->GetEnemy() == pVictimBaseEntity )
			{
				int iRocketSpecialist = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pAttacker, iRocketSpecialist, rocket_specialist );
				if ( iRocketSpecialist )
					bIgnoreLongRangeDmgEffects = true;
			}

			// Some Powerups remove distance damage falloff
			if ( pTFAttacker && ( pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_STRENGTH || pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_PRECISION ) )
			{
				bIgnoreLongRangeDmgEffects = true;
			}
		}
	}

	if ( info.GetCritType() == CTakeDamageInfo::CRIT_MINI )
	{
		int iPromoteMiniCritToCrit = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iPromoteMiniCritToCrit, minicrits_become_crits );
		if ( iPromoteMiniCritToCrit == 1 )
		{
			info.SetCritType( CTakeDamageInfo::CRIT_FULL );
			eBonusEffect = kBonusEffect_Crit;
			bitsDamage |= DMG_CRITICAL;
			info.AddDamageType( DMG_CRITICAL );
		}
	}

	if ( pVictim )
	{
		pVictim->SetSeeCrit( bAllSeeCrit, info.GetCritType() == CTakeDamageInfo::CRIT_MINI, bShowDisguisedCrit );
		pVictim->SetAttackBonusEffect( eBonusEffect );
	}

	// If we're invulnerable, force ourselves to only take damage events only, so we still get pushed
	if ( pVictim && pVictim->m_Shared.IsInvulnerable() )
	{
		if ( !bAllowDamage )
		{
			int iOldTakeDamage = pVictim->m_takedamage;
			pVictim->m_takedamage = DAMAGE_EVENTS_ONLY;
			// NOTE: Deliberately skip base player OnTakeDamage, because we don't want all the stuff it does re: suit voice
			pVictim->CBaseCombatCharacter::OnTakeDamage( info );
			pVictim->m_takedamage = iOldTakeDamage;

			// Burn sounds are handled in ConditionThink()
			if ( !(bitsDamage & DMG_BURN ) )
			{
				pVictim->SpeakConceptIfAllowed( MP_CONCEPT_HURT );
			}

			// If this is critical explosive damage, and the Medic giving us invuln triggered 
			// it in the last second, he's earned himself an achievement. 
			if ( (bitsDamage & DMG_CRITICAL) && (bitsDamage & DMG_BLAST) )
			{
				pVictim->m_Shared.CheckForAchievement( ACHIEVEMENT_TF_MEDIC_SAVE_TEAMMATE );
			}

			return false;
		}
	}


	if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB )
	{
		// Jarate backstabber
		int iJarateBackstabber = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iJarateBackstabber, jarate_backstabber );
		if ( iJarateBackstabber > 0 && pTFAttacker )
		{
			pTFAttacker->m_Shared.AddCond( TF_COND_URINE, 10.0f, pVictim );
			pTFAttacker->m_Shared.SetPeeAttacker( pVictim );
			pTFAttacker->SpeakConceptIfAllowed( MP_CONCEPT_JARATE_HIT );
		}

		if ( pVictim && pVictim->CheckBlockBackstab( pTFAttacker ) )
		{
			// The backstab was absorbed by a shield.
			info.SetDamage( 0 );

			// Shake nearby players' screens.
			UTIL_ScreenShake( pVictim->GetAbsOrigin(), 25.f, 150.0, 1.0, 50.f, SHAKE_START );

			// Play the notification sound.
			pVictim->EmitSound( "Player.Spy_Shield_Break" );

			// Unzoom the sniper.
			CTFWeaponBase *pWeapon = pVictim->GetActiveTFWeapon();
			if ( pWeapon && WeaponID_IsSniperRifle( pWeapon->GetWeaponID() ) )
			{
				CTFSniperRifle *pSniperRifle = static_cast< CTFSniperRifle* >( pWeapon );
				if ( pSniperRifle->IsZoomed() )
				{
					pSniperRifle->ZoomOut();
				}
			}

			// Vibrate the spy's knife.
			if ( pTFAttacker && pTFAttacker->GetActiveWeapon() )
			{
				CTFKnife *pKnife = (CTFKnife *) pTFAttacker->GetActiveWeapon();
				if ( pKnife )
				{
					pKnife->BackstabBlocked();
				}
			}

			// Tell the clients involved in the jarate
			CRecipientFilter involved_filter;
			involved_filter.AddRecipient( pVictim );
			involved_filter.AddRecipient( pTFAttacker );

			UserMessageBegin( involved_filter, "PlayerShieldBlocked" );
				WRITE_BYTE( pTFAttacker->entindex() );
				WRITE_BYTE( pVictim->entindex() );
			MessageEnd();
		}
	}

	// Apply attributes that increase damage vs players
	if ( pWeapon )
	{
		float flDamage = info.GetDamage();
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flDamage, mult_dmg_vs_players );

		// Check if we're to boost damage against the same class
		if( pVictim && pTFAttacker )
		{
			int nVictimClass	= pVictim->GetPlayerClass()->GetClassIndex();
			int nAttackerClass	= pTFAttacker->GetPlayerClass()->GetClassIndex();

			// Same class?
			if( nVictimClass == nAttackerClass )
			{
				// Potentially boost damage
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flDamage, mult_dmg_vs_same_class );
			}
		}

		info.SetDamage( flDamage );
	}

	if ( pVictim && !pVictim->m_Shared.InCond( TF_COND_BURNING ) )
	{
		if ( bitsDamage & DMG_CRITICAL )
		{
			if ( pTFAttacker && !pTFAttacker->m_Shared.IsCritBoosted() )
			{
				int iNonBurningCritsDisabled = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iNonBurningCritsDisabled, set_nocrit_vs_nonburning );
				if ( iNonBurningCritsDisabled )
				{
					bitsDamage &= ~DMG_CRITICAL;
					info.SetDamageType( info.GetDamageType() & (~DMG_CRITICAL) );
					info.SetCritType( CTakeDamageInfo::CRIT_NONE );
				}
			}
		}

		float flDamage = info.GetDamage();
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pWeapon, flDamage, mult_dmg_vs_nonburning );
		info.SetDamage( flDamage );
	}

	// Alien Isolation SetBonus Checking
	if ( pVictim && pTFAttacker && pWeapon )
	{
		// Alien->Merc melee bonus
		if ( ( info.GetDamageType() & (DMG_CLUB|DMG_SLASH) ) && info.GetDamageCustom() != TF_DMG_CUSTOM_BASEBALL )
		{
			CTFWeaponBaseMelee *pMelee = dynamic_cast<CTFWeaponBaseMelee*>( pWeapon );
			if ( pMelee )
			{
				int iAttackerAlien = 0;
				int iVictimMerc = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iAttackerAlien, alien_isolation_xeno_bonus_pos );
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iVictimMerc, alien_isolation_merc_bonus_pos );

				if ( iAttackerAlien && iVictimMerc )
				{
					info.SetDamage( info.GetDamage() * 5.0f );
				}
			}
		}

		// Merc->Alien MK50 damage, aka flamethrower
		if ( ( info.GetDamageType() & DMG_IGNITE ) && pWeapon->GetWeaponID() == TF_WEAPON_FLAMETHROWER )
		{
			int iAttackerMerc = 0;
			int iVictimAlien = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iAttackerMerc, alien_isolation_merc_bonus_pos );
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iVictimAlien, alien_isolation_xeno_bonus_pos );

			if ( iAttackerMerc && iVictimAlien )
			{
				info.SetDamage( info.GetDamage() * 3.0f );	
			}
		}
	}

	int iPierceResists = 0;
	CALL_ATTRIB_HOOK_INT_ON_OTHER( pWeapon, iPierceResists, mod_ignore_resists_absorbs );

	// Use defense buffs if it's not a backstab or direct crush damage (telefrage, etc.)
	if ( pVictim && info.GetDamageCustom() != TF_DMG_CUSTOM_BACKSTAB && ( info.GetDamageType() & DMG_CRUSH ) == 0 )
	{
		if ( pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF ) )
		{
			// We take no crits of any kind...
			if( eBonusEffect == kBonusEffect_MiniCrit || eBonusEffect == kBonusEffect_Crit )
				eBonusEffect = kBonusEffect_None;
			info.SetCritType( CTakeDamageInfo::CRIT_NONE );
			bAllSeeCrit = false;
			bShowDisguisedCrit = false;

			pVictim->SetSeeCrit( bAllSeeCrit, false, bShowDisguisedCrit );
			pVictim->SetAttackBonusEffect( eBonusEffect );

			bitsDamage &= ~DMG_CRITICAL;
			info.SetDamageType( bitsDamage );
			info.SetCritType( CTakeDamageInfo::CRIT_NONE );
		}

		if ( !iPierceResists )
		{
			// If we are defense buffed...
			if ( pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF_HIGH ) )
			{
				// We take 75% less damage... still take crits
				info.SetDamage( info.GetDamage() * 0.25f );
			}
			else if ( pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF ) || pVictim->m_Shared.InCond( TF_COND_DEFENSEBUFF_NO_CRIT_BLOCK ) )
			{
				// defense buffs gives 50% to sentry dmg and 35% from all other sources
				CObjectSentrygun *pSentry = ( info.GetInflictor() && info.GetInflictor()->IsBaseObject() ) ? dynamic_cast< CObjectSentrygun* >( info.GetInflictor() ) : NULL;
				if ( pSentry )
				{
					info.SetDamage( info.GetDamage() * 0.50f );
				}
				else
				{
					// And we take 35% less damage...
					info.SetDamage( info.GetDamage() * 0.65f );
				}
			}
		}
	}

	// A note about why crits now go through the randomness/variance code:
	// Normally critical damage is not affected by variance.  However, we always want to measure what that variance 
	// would have been so that we can lump it into the DamageBonus value inside the info.  This means crits actually
	// boost more than 3X when you factor the reduction we avoided.  Example: a rocket that normally would do 50
	// damage due to range now does the original 100, which is then multiplied by 3, resulting in a 6x increase.
	bool bCrit = ( bitsDamage & DMG_CRITICAL ) ?  true : false;

	// If we're not damaging ourselves, apply randomness
	if ( pAttacker != pVictimBaseEntity && !(bitsDamage & (DMG_DROWN | DMG_FALL)) ) 
	{
		float flDamage = info.GetDamage();
		float flDmgVariance = 0.f;

		// Minicrits still get short range damage bonus
		bool bForceCritFalloff = ( bitsDamage & DMG_USEDISTANCEMOD ) && 
								 ( ( bCrit && tf_weapon_criticals_distance_falloff.GetBool() ) || 
								 ( info.GetCritType() == CTakeDamageInfo::CRIT_MINI && tf_weapon_minicrits_distance_falloff.GetBool() ) );
		bool bDoShortRangeDistanceIncrease = !bCrit || info.GetCritType() == CTakeDamageInfo::CRIT_MINI ;
		bool bDoLongRangeDistanceDecrease = !bIgnoreLongRangeDmgEffects && ( bForceCritFalloff || ( !bCrit && info.GetCritType() != CTakeDamageInfo::CRIT_MINI  ) );

		// If we're doing any distance modification, we need to do that first
		float flRandomDamage = info.GetDamage() * tf_damage_range.GetFloat();

		float flRandomDamageSpread = 0.10f;
		float flMin = 0.5 - flRandomDamageSpread;
		float flMax = 0.5 + flRandomDamageSpread;

		if ( bitsDamage & DMG_USEDISTANCEMOD )
		{
			Vector vAttackerPos = pAttacker->WorldSpaceCenter();
			float flOptimalDistance = 512.0;

			// Use Sentry position for distance mod
			CObjectSentrygun *pSentry = dynamic_cast<CObjectSentrygun*>( info.GetInflictor() );
			if ( pSentry )
			{
				vAttackerPos = pSentry->WorldSpaceCenter();
				// Sentries have a much further optimal distance
				flOptimalDistance = SENTRY_MAX_RANGE;
			}
			// The base sniper rifle doesn't have DMG_USEDISTANCEMOD, so this isn't used. Unlockable rifle had it for a bit.
			else if ( pWeapon && WeaponID_IsSniperRifle( pWeapon->GetWeaponID() ) )
			{
				flOptimalDistance *= 2.5f;
			}

			float flDistance = MAX( 1.0, ( pVictimBaseEntity->WorldSpaceCenter() - vAttackerPos).Length() );
				
			float flCenter = RemapValClamped( flDistance / flOptimalDistance, 0.0, 2.0, 1.0, 0.0 );
			if ( ( flCenter > 0.5 && bDoShortRangeDistanceIncrease ) || flCenter <= 0.5 )
			{
				if ( bitsDamage & DMG_NOCLOSEDISTANCEMOD )
				{
					if ( flCenter > 0.5 )
					{
						// Reduce the damage bonus at close range
						flCenter = RemapVal( flCenter, 0.5, 1.0, 0.5, 0.65 );
					}
				}
				flMin = MAX( 0.0, flCenter - flRandomDamageSpread );
				flMax = MIN( 1.0, flCenter + flRandomDamageSpread );

				if ( bDebug )
				{
					Warning("    RANDOM: Dist %.2f, Ctr: %.2f, Min: %.2f, Max: %.2f\n", flDistance, flCenter, flMin, flMax );
				}
			}
			else
			{
				if ( bDebug )
				{
					Warning("    NO DISTANCE MOD: Dist %.2f, Ctr: %.2f, Min: %.2f, Max: %.2f\n", flDistance, flCenter, flMin, flMax );
				}
			}
		}
		//Msg("Range: %.2f - %.2f\n", flMin, flMax );
		float flRandomRangeVal;
		if ( tf_damage_disablespread.GetBool() || ( pTFAttacker && pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_PRECISION ) )
		{
			flRandomRangeVal = flMin + flRandomDamageSpread;
		}
		else
		{
			flRandomRangeVal = RandomFloat( flMin, flMax );
		}

		//if ( bDebug )
		//{
		//	Warning( "            Val: %.2f\n", flRandomRangeVal );
		//}

		// Weapon Based Damage Mod
		if ( pWeapon && pAttacker && pAttacker->IsPlayer() )
		{
			switch ( pWeapon->GetWeaponID() )
			{
			// Rocket launcher only has half the bonus of the other weapons at short range
			// Rocket Launchers
			case TF_WEAPON_ROCKETLAUNCHER :
			case TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT :
			case TF_WEAPON_PARTICLE_CANNON :
				if ( flRandomRangeVal > 0.5 )
				{
					flRandomDamage *= 0.5f;
				}
				break;
			case TF_WEAPON_PIPEBOMBLAUNCHER :	// Stickies
			case TF_WEAPON_GRENADELAUNCHER :
			case TF_WEAPON_CANNON :
			case TF_WEAPON_STICKBOMB:
				if ( !( bitsDamage & DMG_NOCLOSEDISTANCEMOD ) )
				{
					flRandomDamage *= 0.2f;
				}
				break;
			case TF_WEAPON_SCATTERGUN :
			case TF_WEAPON_SODA_POPPER :
			case TF_WEAPON_PEP_BRAWLER_BLASTER :
			//case TF_WEAPON_HANDGUN_SCOUT_PRIMARY :		// Shortstop
				// Scattergun gets 50% bonus at short range
				if ( flRandomRangeVal > 0.5 )
				{
					flRandomDamage *= 1.5f;
				}
				break;
			}
		}

		// Random damage variance.
		flDmgVariance = SimpleSplineRemapValClamped( flRandomRangeVal, 0, 1, -flRandomDamage, flRandomDamage );
		if ( ( bDoShortRangeDistanceIncrease && flDmgVariance > 0.f ) || bDoLongRangeDistanceDecrease )
		{
			flDamage = info.GetDamage() + flDmgVariance;
		}

		if ( bDebug )
		{
			Warning("            Out: %.2f -> Final %.2f\n", flDmgVariance, flDamage );
		}

		/*
		for ( float flVal = flMin; flVal <= flMax; flVal += 0.05 )
		{
			float flOut = SimpleSplineRemapValClamped( flVal, 0, 1, -flRandomDamage, flRandomDamage );
			Msg("Val: %.2f, Out: %.2f, Dmg: %.2f\n", flVal, flOut, info.GetDamage() + flOut );
		}
		*/

		// Burn sounds are handled in ConditionThink()
		if ( !(bitsDamage & DMG_BURN ) && pVictim )
		{
			pVictim->SpeakConceptIfAllowed( MP_CONCEPT_HURT );
		}


		// Save any bonus damage as a separate value
		float flCritDamage = 0.f;
		// Yes, it's weird that we sometimes fabs flDmgVariance.  Here's why: In the case of a crit rocket, we
		// know that number will generally be negative due to dist or randomness.  In this case, we want to track
		// that effect - even if we don't apply it.  In the case of our crit rocket that normally would lose 50 
		// damage, we fabs'd so that we can account for it as a bonus - since it's present in a crit.
		float flBonusDamage = bForceCritFalloff ? 0.f : fabs( flDmgVariance );
		CTFPlayer *pProvider = NULL;

		if ( info.GetCritType() == CTakeDamageInfo::CRIT_MINI )
		{
			// We should never have both of these flags set or Weird Things will happen with the damage numbers
			// that aren't clear to the players. Or us, really.
			Assert( !(bitsDamage & DMG_CRITICAL) );

			if ( bDebug )
			{
				Warning( "    MINICRIT: Dmg %.2f -> ", flDamage );
			}

			COMPILE_TIME_ASSERT( TF_DAMAGE_MINICRIT_MULTIPLIER > 1.f );
			flCritDamage = ( TF_DAMAGE_MINICRIT_MULTIPLIER - 1.f ) * flDamage;

			bitsDamage |= DMG_CRITICAL;
			info.AddDamageType( DMG_CRITICAL );

			// Any condition assist stats to send out?
			if ( eDamageBonusCond < TF_COND_LAST )
			{
				if ( pVictim )
				{
					pProvider = ToTFPlayer( pVictim->m_Shared.GetConditionProvider( eDamageBonusCond ) );
					if ( pProvider )
					{
						CTF_GameStats.Event_PlayerDamageAssist( pProvider, flCritDamage + flBonusDamage );
					}
				}
				if ( pTFAttacker )
				{
					pProvider = ToTFPlayer( pTFAttacker->m_Shared.GetConditionProvider( eDamageBonusCond ) );
					if ( pProvider && pProvider != pTFAttacker )
					{
						CTF_GameStats.Event_PlayerDamageAssist( pProvider, flCritDamage + flBonusDamage );
					}
				}
			}

			if ( bDebug )
			{
				Warning( "reduced to %.2f before crit mult\n", flDamage );
			}
		}

		if ( bCrit )
		{
			if ( info.GetCritType() != CTakeDamageInfo::CRIT_MINI  )
			{
				COMPILE_TIME_ASSERT( TF_DAMAGE_CRIT_MULTIPLIER > 1.f );
				flCritDamage = ( TF_DAMAGE_CRIT_MULTIPLIER - 1.f ) * flDamage;
			}

			if ( bDebug )
			{
				Warning( "    CRITICAL! Damage: %.2f\n", flDamage );
			}

			// Burn sounds are handled in ConditionThink()
			if ( !(bitsDamage & DMG_BURN ) && pVictim )
			{
				pVictim->SpeakConceptIfAllowed( MP_CONCEPT_HURT, "damagecritical:1" );
			}

			if ( pTFAttacker && pTFAttacker->m_Shared.IsCritBoosted() )
			{
				pProvider = ToTFPlayer( pTFAttacker->m_Shared.GetConditionProvider( TF_COND_CRITBOOSTED ) );
				if ( pProvider && pTFAttacker && pProvider != pTFAttacker )
				{
					CTF_GameStats.Event_PlayerDamageAssist( pProvider, flCritDamage + flBonusDamage );	
				}
			}
		}
		
		if ( pAttacker && pAttacker->IsPlayer() )
		{
			// Modify damage based on bonuses
			flDamage *= pTFAttacker->m_Shared.GetTmpDamageBonus();
		}

		// Store the extra damage and update actual damage
		if ( bCrit || info.GetCritType() == CTakeDamageInfo::CRIT_MINI  )
		{
			info.SetDamageBonus( flCritDamage + flBonusDamage, pProvider );	// Order-of-operations sensitive, but fine as long as TF_COND_CRITBOOSTED is last
		}

		// Crit-A-Cola and Steak Sandwich - only increase normal damage
		if ( pVictim && pVictim->m_Shared.InCond( TF_COND_ENERGY_BUFF ) && !bCrit && info.GetCritType() != CTakeDamageInfo::CRIT_MINI  )
		{
			float flDmgMult = 1.f;
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDmgMult, energy_buff_dmg_taken_multiplier );
			flDamage *= flDmgMult;
		}

		info.SetDamage( flDamage + flCritDamage );
	}

	if ( pTFAttacker && pTFAttacker->IsPlayerClass( TF_CLASS_SPY ) )
	{
		if ( pTFAttacker->GetActiveWeapon() )
		{
			int iAddCloakOnHit = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker->GetActiveWeapon(), iAddCloakOnHit, add_cloak_on_hit );
			if ( iAddCloakOnHit > 0 )
			{
				pTFAttacker->m_Shared.AddToSpyCloakMeter( iAddCloakOnHit, true );
			}
		}
	}


	// Apply on-hit attributes
	if ( pVictim && pAttacker && pAttacker->GetTeam() != pVictim->GetTeam() && pAttacker->IsPlayer() && pWeapon )
	{
		pWeapon->ApplyOnHitAttributes( pVictimBaseEntity, pTFAttacker, info );
	}

	// Give assist points to the provider of any stun on the victim - up to half the damage, based on the amount of stun
	if ( pVictim && pVictim->m_Shared.InCond( TF_COND_STUNNED ) )
	{
		CTFPlayer *pProvider = ToTFPlayer( pVictim->m_Shared.GetConditionProvider( TF_COND_STUNNED ) );
		if ( pProvider && pTFAttacker && pProvider != pTFAttacker )
		{
			float flStunAmount = pVictim->m_Shared.GetAmountStunned( TF_STUN_MOVEMENT );
			if ( flStunAmount < 1.f && pVictim->m_Shared.IsControlStunned() )
				flStunAmount = 1.f;

			int nAssistPoints = RemapValClamped( flStunAmount, 0.1f, 1.f, 1, ( info.GetDamage() / 2 ) );
			if ( nAssistPoints )
			{
				CTF_GameStats.Event_PlayerDamageAssist( pProvider, nAssistPoints );	
			}
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static bool CheckForDamageTypeImmunity( int nDamageType, CTFPlayer* pVictim, float &flDamageBase, float &flCritBonusDamage )
{
	bool bImmune = false;
	if( nDamageType & (DMG_BURN|DMG_IGNITE) )
	{
		bImmune = pVictim->m_Shared.InCond( TF_COND_FIRE_IMMUNE );
	}
	else if( nDamageType & (DMG_BULLET|DMG_BUCKSHOT) )
	{
		bImmune = pVictim->m_Shared.InCond( TF_COND_BULLET_IMMUNE );
	}
	else if( nDamageType & DMG_BLAST )
	{
		bImmune = pVictim->m_Shared.InCond( TF_COND_BLAST_IMMUNE );
	}

	if( bImmune )
	{
		flDamageBase = flCritBonusDamage = 0.f;

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

		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static bool CheckMedicResist( ETFCond ePassiveCond, ETFCond eDeployedCond, CTFPlayer* pVictim, float flRawDamage, float& flDamageBase, bool bCrit, float& flCritBonusDamage )
{
	// Might be a tank or some other object that's getting shot
	if( !pVictim || !pVictim->IsPlayer() )
		return false;

	ETFCond eActiveCond;
	// Be in the condition!
	if( pVictim->m_Shared.InCond( eDeployedCond ) )
	{
		eActiveCond = eDeployedCond;
	}
	else if( pVictim->m_Shared.InCond( ePassiveCond ) )
	{
		eActiveCond = ePassiveCond;
	}
	else
	{
		return false;
	}

	// Get our condition provider
	CBaseEntity* pProvider = pVictim->m_Shared.GetConditionProvider( eActiveCond );
	CTFPlayer* pTFProvider = ToTFPlayer( pProvider );
	Assert( pTFProvider );
	
	float flDamageScale = 0.f;
	//float flCritBarDeplete = 0.f;
	bool bUberResist = false;

	if( pTFProvider )
	{
		switch( eActiveCond )
		{
		case TF_COND_MEDIGUN_UBER_BULLET_RESIST:
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_bullet_resist_deployed );
			bUberResist = true;
//			if ( bCrit )
//			{
//				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flCritBarDeplete, medigun_crit_bullet_percent_bar_deplete );
//			}
			break;

		case TF_COND_MEDIGUN_SMALL_BULLET_RESIST:
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_bullet_resist_passive );
			break;

		case TF_COND_MEDIGUN_UBER_BLAST_RESIST:
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_blast_resist_deployed );
			bUberResist = true;
			//if( bCrit )
			//{
			//	CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flCritBarDeplete, medigun_crit_blast_percent_bar_deplete );
			//}
			break;

		case TF_COND_MEDIGUN_SMALL_BLAST_RESIST:
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_blast_resist_passive );
			break;

		case TF_COND_MEDIGUN_UBER_FIRE_RESIST:
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_fire_resist_deployed );
			bUberResist = true;
//			if( bCrit )
//			{
//				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flCritBarDeplete, medigun_crit_fire_percent_bar_deplete );
//			}
			break;

		case TF_COND_MEDIGUN_SMALL_FIRE_RESIST:
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFProvider, flDamageScale, medigun_fire_resist_passive );
			break;
		}
	}

	if ( bUberResist && pVictim->m_Shared.InCond( TF_COND_HEALING_DEBUFF ) )
	{
		flDamageScale *= 0.75f;
	}

	flDamageScale = 1.f - flDamageScale;
	if( flDamageScale < 0.f ) 
		flDamageScale = 0.f;

	//// Dont let the medic heal themselves when they take damage
	//if( pTFProvider && pTFProvider != pVictim )
	//{
	//	// Heal the medic for 10% of the incoming damage
	//	int nHeal = flRawDamage * 0.10f;
	//	// Heal!
	//	int iHealed = pTFProvider->TakeHealth( nHeal, DMG_GENERIC );

	//	// Tell them about it!
	//	if ( iHealed )
	//	{
	//		CTF_GameStats.Event_PlayerHealedOther( pTFProvider, iHealed );
	//	}

	//	IGameEvent *event = gameeventmanager->CreateEvent( "player_healonhit" );
	//	if ( event )
	//	{
	//		event->SetInt( "amount", nHeal );
	//		event->SetInt( "entindex", pTFProvider->entindex() );
	//		gameeventmanager->FireEvent( event ); 
	//	}
	//}

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

	if ( bCrit && pTFProvider && bUberResist )
	{
		flCritBonusDamage = ( pVictim->m_Shared.InCond( TF_COND_HEALING_DEBUFF ) ) ? flCritBonusDamage *= 0.25f : 0.f;

		//CWeaponMedigun* pMedigun = dynamic_cast<CWeaponMedigun*>( pTFProvider->Weapon_OwnsThisID( TF_WEAPON_MEDIGUN ) );
		//if( pMedigun )
		//{
		//	if( pMedigun->GetChargeLevel() > 0.f && pMedigun->IsReleasingCharge() )
		//	{
		//		flCritBonusDamage = 0;
		//	}
		//	pMedigun->SubtractCharge( flCritBarDeplete );
		//}
	}

	// Scale the damage!
	flDamageBase = flDamageBase * flDamageScale;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static void PotentiallyFireDamageMitigatedEvent( const CTFPlayer* pMitigator, const CTFPlayer* pDamaged, const CEconEntity* pMitigationProvidingEconItem, float flBeforeDamage, float flAfterDamage )
{
	int nAmount = flBeforeDamage - flAfterDamage;
	// Nothing mitigated!
	if ( nAmount == 0 )
		return;

	IGameEvent *pEvent = gameeventmanager->CreateEvent( "damage_mitigated" );
	if ( pEvent )
	{
		item_definition_index_t nDefIndex = INVALID_ITEM_DEF_INDEX;
		if ( pMitigationProvidingEconItem && pMitigationProvidingEconItem->GetAttributeContainer() && pMitigationProvidingEconItem->GetAttributeContainer()->GetItem() )
		{
			nDefIndex = pMitigationProvidingEconItem->GetAttributeContainer()->GetItem()->GetItemDefinition()->GetDefinitionIndex();
		}

		pEvent->SetInt( "mitigator", pMitigator ? pMitigator->GetUserID() : -1 );
		pEvent->SetInt( "damaged", pDamaged ? pDamaged->GetUserID() : -1 );
		pEvent->SetInt( "amount", nAmount );
		pEvent->SetInt( "itemdefindex", nDefIndex );
		gameeventmanager->FireEvent( pEvent, true );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFGameRules::ApplyOnDamageAliveModifyRules( const CTakeDamageInfo &info, CBaseEntity *pVictimBaseEntity, DamageModifyExtras_t& outParams )
{
	CTFPlayer *pVictim = ToTFPlayer( pVictimBaseEntity );
	CBaseEntity *pAttacker = info.GetAttacker();
	CTFPlayer *pTFAttacker = ToTFPlayer( pAttacker );

	float flRealDamage = info.GetDamage();

	if ( pVictimBaseEntity && pVictimBaseEntity->m_takedamage != DAMAGE_EVENTS_ONLY && pVictim )
	{
		int iDamageTypeBits = info.GetDamageType() & DMG_IGNITE;

		// Handle attributes that want to change our damage type, but only if we're taking damage from a non-DOT. This
		// stops fire DOT damage from constantly reigniting us. This will also prevent ignites from happening on the
		// damage *from-a-bleed-DOT*, but not from the bleed application attack.
		if ( !IsDOTDmg( info.GetDamageCustom() ) )
		{
			int iAddBurningDamageType = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iAddBurningDamageType, set_dmgtype_ignite );
			if ( iAddBurningDamageType )
			{
				iDamageTypeBits |= DMG_IGNITE;
			}
		}

		// Start burning if we took ignition damage
		outParams.bIgniting = ( ( iDamageTypeBits & DMG_IGNITE ) && ( !pVictim || pVictim->GetWaterLevel() < WL_Waist ) );

		if ( outParams.bIgniting && pVictim )
		{
			if ( pVictim->m_Shared.InCond( TF_COND_DISGUISED ) )
			{
				int iDisguiseNoBurn = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pVictim, iDisguiseNoBurn, disguise_no_burn );
				if ( iDisguiseNoBurn == 1 )
				{
					// Do a hard out in the caller
					return -1;
				}
			}

			if ( pVictim->m_Shared.InCond( TF_COND_FIRE_IMMUNE ) )
			{
				// Do a hard out in the caller
				return -1;
			}
		}

		// When obscured by smoke, attacks have a chance to miss
		if ( pVictim && pVictim->m_Shared.InCond( TF_COND_OBSCURED_SMOKE ) )
		{
			if ( RandomInt( 1, 4 ) >= 2 )
			{
				flRealDamage = 0.f;

				pVictim->SpeakConceptIfAllowed( MP_CONCEPT_DODGE_SHOT );

				if ( pTFAttacker )
				{
					CEffectData	data;
					data.m_nHitBox = GetParticleSystemIndex( "miss_text" );
					data.m_vOrigin = pVictim->WorldSpaceCenter() + Vector( 0.f , 0.f, 32.f );
					data.m_vAngles = vec3_angle;
					data.m_nEntIndex = 0;

					CSingleUserRecipientFilter filter( pTFAttacker );
					te->DispatchEffect( filter, 0.f, data.m_vOrigin, "ParticleEffect", data );
				}

				// No damage
				return -1.f;
			}
		}

		// Proc invicibility upon being hit
		float flUberChance = 0.f;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flUberChance, uber_on_damage_taken );
		if( RandomFloat() < flUberChance )
		{
			pVictim->m_Shared.AddCond( TF_COND_INVULNERABLE_CARD_EFFECT, 3.f );
			// Make sure we don't take any damage
			flRealDamage = 0.f;
		}

		// Resists and Boosts
		float flDamageBonus = info.GetDamageBonus();
		float flDamageBase = flRealDamage - flDamageBonus;
		Assert( flDamageBase >= 0.f );

		int iPierceResists = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iPierceResists, mod_pierce_resists_absorbs );

		// This raw damage wont get scaled.  Used for determining how much health to give resist medics.
		float flRawDamage = flDamageBase;
		
		// Check if we're immune
		outParams.bPlayDamageReductionSound = CheckForDamageTypeImmunity( info.GetDamageType(), pVictim, flDamageBase, flDamageBonus );

		if ( !iPierceResists )
		{
			// Reduce only the crit portion of the damage with crit resist
			bool bCrit = ( info.GetDamageType() & DMG_CRITICAL ) > 0;
			if ( bCrit )
			{
				// Break the damage down and reassemble
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBonus, mult_dmgtaken_from_crit );
			}

			// Apply general dmg type reductions. Should we only ever apply one of these? (Flaregun is DMG_BULLET|DMG_IGNITE, for instance)
			if ( info.GetDamageType() & (DMG_BURN|DMG_IGNITE) )
			{
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_fire );
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim->GetActiveWeapon(), flDamageBase, mult_dmgtaken_from_fire_active );

				// Check for medic resist
				outParams.bPlayDamageReductionSound = CheckMedicResist( TF_COND_MEDIGUN_SMALL_FIRE_RESIST, TF_COND_MEDIGUN_UBER_FIRE_RESIST, pVictim, flRawDamage, flDamageBase, bCrit, flDamageBonus );
			}

			if ( pTFAttacker && pVictim && pVictim->m_Shared.InCond( TF_COND_BURNING ) )
			{
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pTFAttacker->GetActiveWeapon(), flDamageBase, mult_dmg_vs_burning );
			}

			if ( (info.GetDamageType() & (DMG_BLAST) ) )
			{
				bool bReduceBlast = false;

				// If someone else shot us or we're in MvM
				if( pAttacker != pVictimBaseEntity || IsMannVsMachineMode() )
				{
					bReduceBlast = true;
				}

				if ( bReduceBlast )
				{
					CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_explosions );

					// Check for medic resist
					outParams.bPlayDamageReductionSound = CheckMedicResist( TF_COND_MEDIGUN_SMALL_BLAST_RESIST, TF_COND_MEDIGUN_UBER_BLAST_RESIST, pVictim, flRawDamage, flDamageBase, bCrit, flDamageBonus );
				}
			}

			if ( info.GetDamageType() & (DMG_BULLET|DMG_BUCKSHOT) )
			{
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_bullets );

				// Check for medic resist
				outParams.bPlayDamageReductionSound = CheckMedicResist( TF_COND_MEDIGUN_SMALL_BULLET_RESIST, TF_COND_MEDIGUN_UBER_BULLET_RESIST, pVictim, flRawDamage, flDamageBase, bCrit, flDamageBonus );
			}

			if ( info.GetDamageType() & DMG_MELEE )
			{
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, mult_dmgtaken_from_melee );
			}

			if ( pVictim->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && pVictim->m_Shared.InCond( TF_COND_AIMING ) && ( ( pVictim->GetHealth() - flRealDamage ) / pVictim->GetMaxHealth() ) <= 0.5f )
			{
				float flOriginalDamage = flDamageBase;
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flDamageBase, spunup_damage_resistance );
				if ( flOriginalDamage != flDamageBase )
				{
					pVictim->PlayDamageResistSound( flOriginalDamage, flDamageBase );
				}
			}
		}

		// If the damage changed at all play the resist sound
		if ( flDamageBase != flRawDamage )
		{
			outParams.bPlayDamageReductionSound = true;
		}

		// Stomp flRealDamage with resist adjusted values
		flRealDamage = flDamageBase + flDamageBonus;

		// Some Powerups apply a damage multiplier. Backstabs are immune to resist protection
		if ( ( pVictim && info.GetDamageCustom() != TF_DMG_CUSTOM_BACKSTAB ) )
		{
			// Plague bleed damage is immune from resist calculation
			if ( ( !pVictim->m_Shared.InCond( TF_COND_PLAGUE ) && info.GetDamageCustom() != TF_DMG_CUSTOM_BLEEDING ) )
			{
				if ( pVictim->m_Shared.GetCarryingRuneType() == RUNE_RESIST )
				{
					flRealDamage *= 0.5f;
					outParams.bPlayDamageReductionSound = true;
					IGameEvent* event = gameeventmanager->CreateEvent( "damage_resisted" );
					if ( event )
					{
						event->SetInt( "entindex", pVictim->entindex() );
						gameeventmanager->FireEvent( event );
					}
				}
				else if ( ( pVictim->m_Shared.GetCarryingRuneType() == RUNE_VAMPIRE ) )
				{
					flRealDamage *= 0.75f;
					outParams.bPlayDamageReductionSound = true;
				}
				//Plague powerup carrier is resistant to infected enemies
				else if ( pTFAttacker && ( pVictim->m_Shared.GetCarryingRuneType() == RUNE_PLAGUE ) && pTFAttacker->m_Shared.InCond( TF_COND_PLAGUE ) )
				{
					flRealDamage *= 0.5f;
					outParams.bPlayDamageReductionSound = true;
				}
			}
		}


		// End Resists

		// Increased damage taken from all sources
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flRealDamage, mult_dmgtaken );

		if ( info.GetInflictor() && info.GetInflictor()->IsBaseObject() )
		{
			CObjectSentrygun* pSentry = dynamic_cast<CObjectSentrygun*>( info.GetInflictor() );
			if ( pSentry )
			{
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim, flRealDamage, dmg_from_sentry_reduced );
			}
		}

		if ( IsMannVsMachineMode() )
		{
			if ( pTFAttacker && pTFAttacker->IsBot() && pAttacker != pVictimBaseEntity && pVictim && !pVictim->IsBot() )
			{
				flRealDamage *= g_pPopulationManager ? g_pPopulationManager->GetDamageMultiplier() : tf_populator_damage_multiplier.GetFloat();
			}
		}

		// Heavy rage-based knockback+stun effect that also reduces their damage output
		if ( pTFAttacker && pTFAttacker->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
		{
			int iRage = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iRage, generate_rage_on_dmg );
			if ( iRage && pTFAttacker->m_Shared.IsRageDraining() )
			{
				flRealDamage *= 0.5f;
			}
		}

		if ( pVictim && pTFAttacker && info.GetWeapon() )
		{
			CTFWeaponBase *pWeapon = pTFAttacker->GetActiveTFWeapon();
			if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_SNIPERRIFLE && info.GetWeapon() == pWeapon )
			{
				CTFSniperRifle *pRifle = static_cast< CTFSniperRifle* >( info.GetWeapon() );

				float flStun = 1.0f;
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pRifle, flStun, applies_snare_effect );
				if ( flStun != 1.0f )
				{
					float flDuration = pRifle->GetJarateTime();
					pVictim->m_Shared.StunPlayer( flDuration, flStun, TF_STUN_MOVEMENT, pTFAttacker );
				}
			}
		}

		if ( pVictim && pVictim->GetActiveTFWeapon() )
		{
			if ( info.GetDamageType() & (DMG_CLUB) )
			{
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim->GetActiveTFWeapon(), flRealDamage, dmg_from_melee );
			}
			else if ( info.GetDamageType() & (DMG_BLAST|DMG_BULLET|DMG_BUCKSHOT|DMG_IGNITE|DMG_SONIC) )
			{
				float flBeforeDamage = flRealDamage;
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pVictim->GetActiveTFWeapon(), flRealDamage, dmg_from_ranged );
				PotentiallyFireDamageMitigatedEvent( pVictim, pVictim, pVictim->GetActiveTFWeapon(), flBeforeDamage, flRealDamage );
			}
		}

		outParams.bSendPreFeignDamage = false;
		if ( pVictim && pVictim->IsPlayerClass( TF_CLASS_SPY ) && ( info.GetDamageCustom() != TF_DMG_CUSTOM_TELEFRAG ) && !pVictim->IsTaunting() )
		{
			// STAGING_SPY
			// Reduce damage taken if we have recently feigned death.
			if ( pVictim->m_Shared.InCond( TF_COND_FEIGN_DEATH ) || pVictim->m_Shared.IsFeignDeathReady() )
			{
				// Damage reduction is proportional to cloak remaining (60%->20%)
				float flDamageReduction = RemapValClamped( pVictim->m_Shared.GetSpyCloakMeter(), 50.0f, 0.0f, tf_feign_death_damage_scale.GetFloat(), tf_stealth_damage_reduction.GetFloat() );

				// On Activate Reduce Remaining Cloak by 50%
				if ( pVictim->m_Shared.IsFeignDeathReady() )
				{
					flDamageReduction = tf_feign_death_activate_damage_scale.GetFloat();
				}
				outParams.bSendPreFeignDamage = true;

				float flBeforeflRealDamage = flRealDamage;

				flRealDamage *= flDamageReduction;

				CTFWeaponInvis *pWatch = (CTFWeaponInvis *) pVictim->Weapon_OwnsThisID( TF_WEAPON_INVIS );
				PotentiallyFireDamageMitigatedEvent( pVictim, pVictim, pWatch, flBeforeflRealDamage, flRealDamage );

				// Original damage would've killed the player, but the reduced damage wont
				if ( flBeforeflRealDamage >= pVictim->GetHealth() && flRealDamage < pVictim->GetHealth() )
				{
					IGameEvent *pEvent = gameeventmanager->CreateEvent( "deadringer_cheat_death" );
					if ( pEvent )
					{
						pEvent->SetInt( "spy", pVictim->GetUserID() );
						pEvent->SetInt( "attacker", pTFAttacker ? pTFAttacker->GetUserID() : -1 );
						gameeventmanager->FireEvent( pEvent, true );
					}
				}
			}
			// Standard Stealth gives small damage reduction
			else if ( pVictim->m_Shared.InCond( TF_COND_STEALTHED ) )
			{
				flRealDamage *= tf_stealth_damage_reduction.GetFloat();
			}
		}

		if ( flRealDamage == 0.0f )
		{
			// Do a hard out in the caller
			return -1;
		}

		if ( pAttacker == pVictimBaseEntity && (info.GetDamageType() & DMG_BLAST) &&
			 info.GetDamagedOtherPlayers() == 0 && (info.GetDamageCustom() != TF_DMG_CUSTOM_TAUNTATK_GRENADE) )
		{
			// If we attacked ourselves, hurt no other players, and it is a blast,
			// check the attribute that reduces rocket jump damage.
			CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( info.GetAttacker(), flRealDamage, rocket_jump_dmg_reduction );
			outParams.bSelfBlastDmg = true;
		}

		if ( pAttacker == pVictimBaseEntity )
		{
			enum
			{
				kSelfBlastResponse_IgnoreProjectilesFromThisWeapon = 1,		// the sticky jumper doesn't disable damage from other explosive weapons
				kSelfBlastResponse_IgnoreProjectilesFromAllWeapons = 2,		// the rocket jumper doesn't have a special projectile type and so ignores all self-inflicted damage from explosive sources
			};

			if ( info.GetWeapon() )
			{
				int iNoSelfBlastDamage = 0;
				CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iNoSelfBlastDamage, no_self_blast_dmg );

				const bool bIgnoreThisSelfDamage = ( iNoSelfBlastDamage == kSelfBlastResponse_IgnoreProjectilesFromAllWeapons )
					|| ( (iNoSelfBlastDamage == kSelfBlastResponse_IgnoreProjectilesFromThisWeapon) && (info.GetDamageCustom() == TF_DMG_CUSTOM_PRACTICE_STICKY) );
				if ( bIgnoreThisSelfDamage )
				{
					flRealDamage = 0;
				}

				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( info.GetWeapon(), flRealDamage, blast_dmg_to_self );
			}
		}

		// Precision Powerup removes self damage
		if ( pTFAttacker == pVictim && pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_PRECISION )
		{
			flRealDamage = 0.f;
		}

		if ( pTFAttacker && ( pTFAttacker != pVictim ) )
		{
			// Vampire Powerup collects health based on damage received on victim. Does not apply to self damage. Do it here to factor in victim resistance calculations
			if ( pTFAttacker->m_Shared.GetCarryingRuneType() == RUNE_VAMPIRE )
			{
				if ( flRealDamage > 0 )
				{
					if ( pTFAttacker->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_MINIGUN || pTFAttacker->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_FLAMETHROWER )
					{
						pTFAttacker->TakeHealth( ( flRealDamage * 0.6f ), DMG_GENERIC );
					}
					else if ( info.GetDamageType() & DMG_MELEE )
					{
						pTFAttacker->TakeHealth( ( flRealDamage * 1.25f ), DMG_GENERIC );
					}
					else
					{
						pTFAttacker->TakeHealth( flRealDamage, DMG_GENERIC );
					}
				}
			}

			int iHypeOnDamage = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pTFAttacker, iHypeOnDamage, hype_on_damage );
			if ( iHypeOnDamage )
			{
				float flHype = RemapValClamped( flRealDamage, 1.f, 200.f, 1.f, 50.f );
				pTFAttacker->m_Shared.SetScoutHypeMeter( Min( 100.f, flHype + pTFAttacker->m_Shared.GetScoutHypeMeter() ) );
			}
		}
	}

	return flRealDamage;
}

// --------------------------------------------------------------------------------------------------- //
// Voice helper
// --------------------------------------------------------------------------------------------------- //

class CVoiceGameMgrHelper : public IVoiceGameMgrHelper
{
public:
	virtual bool		CanPlayerHearPlayer( CBasePlayer *pListener, CBasePlayer *pTalker, bool &bProximity )
	{
		return TFGameRules()->TFVoiceManager( pListener, pTalker );
	}
};
CVoiceGameMgrHelper g_VoiceGameMgrHelper;
IVoiceGameMgrHelper *g_pVoiceGameMgrHelper = &g_VoiceGameMgrHelper;

// Load the objects.txt file.
class CObjectsFileLoad : public CAutoGameSystem
{
public:
	virtual bool Init()
	{
		LoadObjectInfos( filesystem );
		return true;
	}
} g_ObjectsFileLoad;

// --------------------------------------------------------------------------------------------------- //
// Globals.
// --------------------------------------------------------------------------------------------------- //
/*
// NOTE: the indices here must match TEAM_UNASSIGNED, TEAM_SPECTATOR, TF_TEAM_RED, TF_TEAM_BLUE, etc.
char *sTeamNames[] =
{
	"Unassigned",
	"Spectator",
	"Red",
	"Blue"
};
*/
// --------------------------------------------------------------------------------------------------- //
// Global helper functions.
// --------------------------------------------------------------------------------------------------- //
	
// World.cpp calls this but we don't use it in TF.
void InitBodyQue()
{
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CTFGameRules::~CTFGameRules()
{
	// Note, don't delete each team since they are in the gEntList and will 
	// automatically be deleted from there, instead.
	TFTeamMgr()->Shutdown();
	ShutdownCustomResponseRulesDicts();

	// clean up cached teleport locations
	m_mapTeleportLocations.PurgeAndDeleteElements();

	// reset this only if we quit MvM to minimize the risk of breaking pub tournament
	if ( IsMannVsMachineMode() )
	{
		mp_tournament.SetValue( 0 );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::CheckTauntAchievement( CTFPlayer *pAchiever, int nGibs, int *pTauntCamAchievements )
{
	if ( !pAchiever || !pAchiever->GetPlayerClass() )
		return;

	int iClass = pAchiever->GetPlayerClass()->GetClassIndex();
	if ( pTauntCamAchievements[ iClass ] )
	{
		bool bAwardAchievement = true;

		// for the Heavy achievement, the player needs to also be invuln
		if ( iClass == TF_CLASS_HEAVYWEAPONS && pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_HEAVY_FREEZECAM_TAUNT )
		{
			if ( !pAchiever->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) && !pAchiever->m_Shared.InCond( TF_COND_INVULNERABLE ) )
			{
				bAwardAchievement = false;
			}
		}

		// for the Spy achievement, we must be in the cig lighter taunt
		if ( iClass == TF_CLASS_SPY && pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SPY_FREEZECAM_FLICK )
		{
			if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_PDA_SPY )
			{
				bAwardAchievement = false;
			}
		}

		// for the two Sniper achievements, we need to check for specific taunts
		if ( iClass == TF_CLASS_SNIPER )
		{
			if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SNIPER_FREEZECAM_HAT )
			{
				if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_CLUB )
				{
					bAwardAchievement = false;
				}
			}
			else if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SNIPER_FREEZECAM_WAVE  )
			{
				if ( pAchiever->GetActiveTFWeapon() && WeaponID_IsSniperRifle( pAchiever->GetActiveTFWeapon()->GetWeaponID() ) )
				{
					bAwardAchievement = false;
				}
			}
		}

		// For the Soldier achievements, we need to be doing a specific taunt, or have enough gibs onscreen
		if ( iClass == TF_CLASS_SOLDIER )
		{
			if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SOLDIER_FREEZECAM_TAUNT )
			{
				if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_SHOTGUN_SOLDIER )
				{
					bAwardAchievement = false;
				}
			}
			else if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_SOLDIER_FREEZECAM_GIBS )
			{
				// Need at least 3 gibs on-screen
				if ( nGibs < 3 )
				{
					bAwardAchievement = false;
				}
			}
		}

		// for the two Demoman achievements, we need to check for specific taunts
		if ( iClass == TF_CLASS_DEMOMAN )
		{
			if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_SMILE )
			{
				if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_GRENADELAUNCHER )
				{
					bAwardAchievement = false;
				}
			}
			else if ( pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_DEMOMAN_FREEZECAM_RUMP )
			{
				if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetAttributeContainer() )
				{
					// Needs to be the Scottish Defender
					CEconItemView *pItem = pAchiever->GetActiveTFWeapon()->GetAttributeContainer()->GetItem();
					if ( pItem && pItem->IsValid() && pItem->GetItemDefIndex() != 130 )	// Scottish Defender is item index 130
					{
						bAwardAchievement = false;
					}
				}
			}
		}

		// for the Engineer achievement, we must be in the guitar taunt
		if ( iClass == TF_CLASS_ENGINEER && pTauntCamAchievements[ iClass ] == ACHIEVEMENT_TF_ENGINEER_FREEZECAM_TAUNT )
		{
			if ( pAchiever->GetActiveTFWeapon() && pAchiever->GetActiveTFWeapon()->GetWeaponID() != TF_WEAPON_SENTRY_REVENGE )
			{
				bAwardAchievement = false;
			}
		}

		if ( bAwardAchievement )
		{
			pAchiever->AwardAchievement( pTauntCamAchievements[ iClass ] );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::TFVoiceManager( CBasePlayer *pListener, CBasePlayer *pTalker )
{
	// check coaching--we only want coaches and students to talk and listen to each other!
	CTFPlayer* pTFListener = (CTFPlayer*)pListener;
	CTFPlayer* pTFTalker = (CTFPlayer*)pTalker;
	if ( pTFListener->GetStudent() || pTFListener->GetCoach() || 
			pTFTalker->GetStudent() || pTFTalker->GetCoach() )
	{
		if ( pTFListener->GetStudent() == pTFTalker || pTFTalker->GetStudent() == pTFListener ||
				pTFListener->GetCoach() == pTalker || pTFTalker->GetCoach() == pTFListener )
		{
			return true;
		}
		return false;
	}

	// Always allow teams to hear each other in TD mode
	if ( IsMannVsMachineMode() )
		return true;

	if ( !tf_gravetalk.GetBool() )
	{
		// Dead players can only be heard by other dead team mates but only if a match is in progress
		if ( State_Get() != GR_STATE_TEAM_WIN && State_Get() != GR_STATE_GAME_OVER ) 
		{
			if ( pTalker->IsAlive() == false )
			{
				if ( pListener->IsAlive() == false )
					return ( pListener->InSameTeam( pTalker ) );

				return false;
			}
		}
	}

	return ( pListener->InSameTeam( pTalker ) );

}

//-----------------------------------------------------------------------------
// Purpose: TF2 Specific Client Commands
// Input  :
// Output :
//-----------------------------------------------------------------------------
bool CTFGameRules::ClientCommand( CBaseEntity *pEdict, const CCommand &args )
{
	CTFPlayer *pPlayer = ToTFPlayer( pEdict );

	const char *pcmd = args[0];

	if ( IsInTournamentMode() == true && IsInPreMatch() == true )
	{
		if ( FStrEq( pcmd, "tournament_readystate" ) )
		{
			if ( IsMannVsMachineMode() )
				return true;

			if ( UsePlayerReadyStatusMode() )
				return true;

			if ( args.ArgC() < 2 )
				return true;

			if ( pPlayer->GetTeamNumber() <= LAST_SHARED_TEAM )
				return true;

			int iReadyState = atoi( args[1] );

			//Already this state
			if ( iReadyState == (int)IsTeamReady( pPlayer->GetTeamNumber() ) )
				return true;

			SetTeamReadyState( iReadyState == 1, pPlayer->GetTeamNumber() );

			IGameEvent * event = gameeventmanager->CreateEvent( "tournament_stateupdate" );

			if ( event )
			{
				event->SetInt( "userid", pPlayer->entindex() );
				event->SetInt( "readystate", iReadyState );
				event->SetBool( "namechange", 0 );
				event->SetString( "oldname", " " );
				event->SetString( "newname", " " );

				gameeventmanager->FireEvent( event );
			}

			if ( iReadyState == 0 )
			{
				m_flRestartRoundTime.Set( -1.f ); 
				m_bAwaitingReadyRestart = true;
			}

			return true;
		}

		if ( FStrEq( pcmd, "tournament_teamname" ) )
		{
			if ( IsMannVsMachineMode() )
				return true;

			if ( args.ArgC() < 2 )
				return true;

			if ( pPlayer->GetTeamNumber() <= LAST_SHARED_TEAM )
				return true;

			const char *commandline = args.GetCommandString();

			// find the rest of the command line past the bot index
			commandline = strstr( commandline, args[1] );
			Assert( commandline );

			char szName[MAX_TEAMNAME_STRING + 1] = { 0 };
			Q_strncpy( szName, commandline, sizeof( szName ));


			if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
			{
				if ( FStrEq( szName, mp_tournament_blueteamname.GetString() ) == true )
					return true;

				mp_tournament_blueteamname.SetValue( szName );
			}
			else if ( pPlayer->GetTeamNumber() == TF_TEAM_RED )
			{
				if ( FStrEq( szName, mp_tournament_redteamname.GetString() ) == true )
					return true;

				mp_tournament_redteamname.SetValue( szName );
			}

			IGameEvent * event = gameeventmanager->CreateEvent( "tournament_stateupdate" );

			if ( event )
			{
				event->SetInt( "userid", pPlayer->entindex() );
				event->SetBool( "readystate", 0 );
				event->SetBool( "namechange", 1 );
				event->SetString( "newname", szName );

				gameeventmanager->FireEvent( event );
			}

			return true;
		}

		if ( FStrEq( pcmd, "tournament_player_readystate" ) )
		{
			if ( State_Get() != GR_STATE_BETWEEN_RNDS )
				return true;

			const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
			if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady )
				return true;

			// Make sure we have enough to allow ready mode commands
			if ( !PlayerReadyStatus_HaveMinPlayersToEnable() )
				return true;

			if ( args.ArgC() < 2 )
				return true;

			bool bReady = ( atoi( args[1] ) == 1 );
			PlayerReadyStatus_UpdatePlayerState( pPlayer, bReady );
			if ( bReady )
			{
				pPlayer->PlayReadySound();
			}

			return true;
		}
	}

	if ( FStrEq( pcmd, "objcmd" ) )
	{
		if ( args.ArgC() < 3 )
			return true;

		int entindex = atoi( args[1] );
		edict_t* pEdict = INDEXENT(entindex);
		if ( pEdict )
		{
			CBaseEntity* pBaseEntity = GetContainingEntity(pEdict);
			CBaseObject* pObject = dynamic_cast<CBaseObject*>(pBaseEntity);

			if ( pObject )
			{
				// We have to be relatively close to the object too...

				// BUG! Some commands need to get sent without the player being near the object, 
				// eg delayed dismantle commands. Come up with a better way to ensure players aren't
				// entering these commands in the console.

				//float flDistSq = pObject->GetAbsOrigin().DistToSqr( pPlayer->GetAbsOrigin() );
				//if (flDistSq <= (MAX_OBJECT_SCREEN_INPUT_DISTANCE * MAX_OBJECT_SCREEN_INPUT_DISTANCE))
				{
					// Strip off the 1st two arguments and make a new argument string
					CCommand objectArgs( args.ArgC() - 2, &args.ArgV()[2]);
					pObject->ClientCommand( pPlayer, objectArgs );
				}
			}
		}

		return true;
	}

	// Handle some player commands here as they relate more directly to gamerules state
	if ( FStrEq( pcmd, "nextmap" ) )
	{
		if ( pPlayer->m_flNextTimeCheck < gpGlobals->curtime )
		{
			char szNextMap[MAX_MAP_NAME];

			if ( nextlevel.GetString() && *nextlevel.GetString() )
			{
				Q_strncpy( szNextMap, nextlevel.GetString(), sizeof( szNextMap ) );
			}
			else
			{
				GetNextLevelName( szNextMap, sizeof( szNextMap ) );
			}

			ClientPrint( pPlayer, HUD_PRINTTALK, "#TF_nextmap", szNextMap);

			pPlayer->m_flNextTimeCheck = gpGlobals->curtime + 1;
		}

		return true;
	}
	else if ( FStrEq( pcmd, "timeleft" ) )
	{	
		if ( pPlayer->m_flNextTimeCheck < gpGlobals->curtime )
		{
			if ( mp_timelimit.GetInt() > 0 )
			{
				int iTimeLeft = GetTimeLeft();

				char szMinutes[5];
				char szSeconds[3];

				if ( iTimeLeft <= 0 )
				{
					Q_snprintf( szMinutes, sizeof(szMinutes), "0" );
					Q_snprintf( szSeconds, sizeof(szSeconds), "00" );
				}
				else
				{
					Q_snprintf( szMinutes, sizeof(szMinutes), "%d", iTimeLeft / 60 );
					Q_snprintf( szSeconds, sizeof(szSeconds), "%02d", iTimeLeft % 60 );
				}

				ClientPrint( pPlayer, HUD_PRINTTALK, "#TF_timeleft", szMinutes, szSeconds );
			}
			else
			{
				ClientPrint( pPlayer, HUD_PRINTTALK, "#TF_timeleft_nolimit" );
			}

			pPlayer->m_flNextTimeCheck = gpGlobals->curtime + 1;
		}
		return true;
	}
#ifdef STAGING_ONLY 
	else if ( FStrEq( pcmd, "mvm_allupgrades" ) )
	{
		if ( GameModeUsesUpgrades() && g_hUpgradeEntity )
		{
			g_hUpgradeEntity->GrantOrRemoveAllUpgrades( pPlayer );
		}

		return true;
	}
#endif
	else if( pPlayer->ClientCommand( args ) )
	{
        return true;
	}

	return BaseClass::ClientCommand( pEdict, args );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::LevelShutdown()
{
	if ( IsInTraining() )
	{
		mp_humans_must_join_team.SetValue( "any" );
		training_can_build_sentry.Revert();
		training_can_build_dispenser.Revert();
		training_can_build_tele_entrance.Revert();
		training_can_build_tele_exit.Revert();
		training_can_destroy_buildings.Revert();
		training_can_pickup_sentry.Revert();
		training_can_pickup_dispenser.Revert();
		training_can_pickup_tele_entrance.Revert();
		training_can_pickup_tele_exit.Revert();
		training_can_select_weapon_primary.Revert();
		training_can_select_weapon_secondary.Revert();
		training_can_select_weapon_melee.Revert();
		training_can_select_weapon_building.Revert();
		training_can_select_weapon_pda.Revert();
		training_can_select_weapon_item1.Revert();
		training_can_select_weapon_item2.Revert();
		tf_training_client_message.Revert();
	}
	TheTFBots().LevelShutdown();
	hide_server.Revert();

	DuelMiniGame_LevelShutdown();
	GameCoordinator_NotifyLevelShutdown();

	g_TFGameModeHistory.SetPrevState( m_nGameType );

	if ( m_pUpgrades )
	{
		UTIL_Remove( m_pUpgrades );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::Think()
{

	if ( m_bMapCycleNeedsUpdate )
	{
		m_bMapCycleNeedsUpdate = false;
		LoadMapCycleFile();
	}

	if ( g_fGameOver )
	{
		if ( UsePlayerReadyStatusMode() && !IsMannVsMachineMode() )
		{
			const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );

			static int nLastTimeSent = -1;
			int nTimeLeft = ( m_flStateTransitionTime - gpGlobals->curtime );
			int nTimePassed = gpGlobals->curtime - m_flLastRoundStateChangeTime;
			if ( pMatchDesc && pMatchDesc->m_params.m_pszMatchEndKickWarning && nTimeLeft <= 50 && nTimeLeft % 10 == 0 && nTimeLeft != nLastTimeSent )
			{
				nLastTimeSent = nTimeLeft;
				CBroadcastRecipientFilter filter;
				UTIL_ClientPrintFilter( filter, HUD_PRINTTALK, pMatchDesc->m_params.m_pszMatchEndKickWarning, CFmtStr( "%d", nTimeLeft ) );
			}

			if ( BAttemptMapVoteRollingMatch() )
			{
				const CMatchInfo* pMatch = GTFGCClientSystem()->GetMatch();
				if ( pMatch && pMatch->GetNumActiveMatchPlayers() == 0 )
				{
					Msg( "All players left during next map voting period.  Ending match.\n" );
					GTFGCClientSystem()->EndManagedMatch( /* bKickPlayersToParties */ false );
					Assert( IsManagedMatchEnded() );
					m_bMatchEnded.Set( true );
					return;
				}

				if ( m_eRematchState == NEXT_MAP_VOTE_STATE_WAITING_FOR_USERS_TO_VOTE )
				{
					bool bVotePeriodExpired = false;
					// Judgment time has arrived.  Force a result below
					if ( nTimePassed == tf_mm_next_map_vote_time.GetInt() )
					{
						bVotePeriodExpired = true;
					}

					int nVotes[ EUserNextMapVote::NUM_VOTE_STATES ];
					EUserNextMapVote eWinningVote = GetWinningVote( nVotes );

					if ( bVotePeriodExpired ||
						( nVotes[ USER_NEXT_MAP_VOTE_UNDECIDED ] == 0 && eWinningVote != USER_NEXT_MAP_VOTE_UNDECIDED ) )
					{
						CBroadcastRecipientFilter filter;

						const MapDef_t *pMap = NULL;
						if ( eWinningVote == USER_NEXT_MAP_VOTE_UNDECIDED )
						{
							// Nobody voted!  We're playing on the same map again by default
							pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) );
						}
						else
						{
							pMap = GetItemSchema()->GetMasterMapDefByIndex( GetNextMapVoteOption( eWinningVote ) );
						}

						if ( pMap == NULL )
						{
							Assert( !"We somehow didn't pick a new map to rotate to!  Default to the current one" );
							pMap = GetItemSchema()->GetMasterMapDefByName( STRING( gpGlobals->mapname ) );
						}

						if ( pMap )
						{
							m_eRematchState = NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE;
							GTFGCClientSystem()->RequestNewMatchForLobby( pMap );
						}
					}
				}
				else if ( m_eRematchState == NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE )
				{
					// CTFGCServerSystem is in control at this point
				}
			}

			if ( gpGlobals->curtime > m_flStateTransitionTime || !BHavePlayers() )
			{
				nLastTimeSent = -1;
				if ( pMatchDesc )
				{
					// Matchmaking path
					pMatchDesc->PostMatchClearServerSettings();
				}
				else
				{
					// Readymode (Tournament) path
					g_fGameOver = false;
					m_bAllowBetweenRounds = true;
					State_Transition( GR_STATE_RESTART );
					SetInWaitingForPlayers( true );
				}
				return;
			}
		}

		if ( ( m_flMatchSummaryTeleportTime > 0 ) && ( gpGlobals->curtime > m_flMatchSummaryTeleportTime ) )
		{
			m_flMatchSummaryTeleportTime = -1.f;
			MatchSummaryTeleport();
		}
	}
	else
	{
		if ( gpGlobals->curtime > m_flNextPeriodicThink )
		{
			if ( State_Get() != GR_STATE_BONUS && State_Get() != GR_STATE_TEAM_WIN && State_Get() != GR_STATE_GAME_OVER && IsInWaitingForPlayers() == false )
			{
				if ( CheckCapsPerRound() )
					return;
			}
		}

		// These network variables mirror the MM system's match state for client's sake. Gamerules should still
		// be aware of when these change, either because we caused it or via a callback.  This warning will
		// detect desync. (Ideally we'd have the ability to just share between the client GC system and server
		// GC system directly without passing things through gamerules)
		if ( m_bMatchEnded != IsManagedMatchEnded() )
		{
			Assert( false );
			Warning( "Mirrored Match parameters on gamerules don't match MatchInfo\n" );
			m_bMatchEnded.Set( IsManagedMatchEnded() );
		}

		if ( GTFGCClientSystem()->GetMatch() && GetCurrentMatchGroup() != (EMatchGroup)m_nMatchGroupType.Get() )
		{
			Assert( false );
			Warning( "Mirrored Match parameters on gamerules don't match MatchInfo\n" );
			m_nMatchGroupType.Set( GetCurrentMatchGroup() );
		}

		// Managed matches (MvM and competitive) abandon thing
		CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
		bool bEveryoneSafeToLeave = true;
		if ( pMatch )
		{
			// Send current safe-to-leave flags down from the GCServerSystem
			for ( int i = 1; i <= gpGlobals->maxClients; ++i )
			{
				CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
				if ( !pPlayer )
					{ continue; }

				CSteamID steamID;
				bool bSafe = !pMatch || !pPlayer->GetSteamID( &steamID ) || pMatch->BPlayerSafeToLeaveMatch( steamID );

				pPlayer->SetMatchSafeToLeave( bSafe );
				bEveryoneSafeToLeave = bEveryoneSafeToLeave && bSafe;
			}
		}

		if ( IsCompetitiveMode() )
		{
			const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
			Assert( pMatch ); // Should not be in competitive mode without a match

			//
			// Check if this is mode requires a complete match, but doesn't have one
			//
			bool bEndMatch = false;
			int nActiveMatchPlayers = pMatch->GetNumActiveMatchPlayers();
			int nMissingPlayers = pMatch->GetCanonicalMatchSize() - nActiveMatchPlayers;
			if ( pMatchDesc->m_params.m_bRequireCompleteMatch &&
			     !IsManagedMatchEnded() &&
			     nMissingPlayers )
			{
				// See if we are requesting late join right now, and give that time to work
				if ( pMatchDesc->ShouldRequestLateJoin() )
				{
					// End match if GC system didn't request late join in response to players leaving
					auto *pGCSys = GTFGCClientSystem();
					double flRequestedLateJoin = pGCSys->GetTimeRequestedLateJoin();

					if ( flRequestedLateJoin == -1.f )
					{
						bEndMatch = true;
						Msg( "Failed to request late join, ending competitive match\n" );
					}
					else
					{
						// Otherwise, since we can't proceed without players, apply a timeout after which we'll
						// cancel the match and release these players. The time to wait is shorter if the GC
						// hasn't confirmed our late join request, so we're not spending the full time waiting
						// when the GC is just non-responsive.
						double flTimeWaitingForLateJoin = CRTime::RTime32TimeCur() - flRequestedLateJoin;
						bool bGotLateJoin = pGCSys->BLateJoinEligible();
						double flWaitLimit = bGotLateJoin ? tf_competitive_required_late_join_timeout.GetFloat()
							                                : tf_competitive_required_late_join_confirm_timeout.GetFloat();
						if ( flTimeWaitingForLateJoin > flWaitLimit )
						{
							Msg( "Exceeded wait time limit for late joiners, canceling match\n" );
							bEndMatch = true;
						}
					}
				}
				else
				{
					// Can't request late joiners, tank match if number of active players get below some threshold
					int iRedActive = 0;
					int iBlueActive = 0;
					for ( int idxPlayer = 0; idxPlayer < pMatch->GetNumTotalMatchPlayers(); idxPlayer++ )
					{
						CMatchInfo::PlayerMatchData_t *pMatchPlayer = pMatch->GetMatchDataForPlayer( idxPlayer );
						if ( !pMatchPlayer->bDropped )
						{
							int iTeam = GetGameTeamForGCTeam( pMatchPlayer->eGCTeam );
							if ( iTeam == TF_TEAM_RED )
								iRedActive++;
							else
								iBlueActive++;
						}
					}

					int iTeamSize = pMatch->GetCanonicalMatchSize() / 2;
					if ( iRedActive == 0 || iBlueActive == 0 || ( iTeamSize - iRedActive ) > tf_mm_abandoned_players_per_team_max.GetInt() || ( iTeamSize - iBlueActive ) > tf_mm_abandoned_players_per_team_max.GetInt() )
					{
						Msg( "Match type requires a complete match, but there are not enough active players left and we are not requesting late join.  Stopping match.\n" );
						bEndMatch = true;
					}
				}
			}
			else if ( !IsManagedMatchEnded() && nActiveMatchPlayers < 1 )
			{
				// For non-complete mode, just stop the match if we lose all players
				Msg( "Competitive managed match in progress, but no remaining match players.  Stopping match.\n" );
				bEndMatch = true;
			}

			if ( bEndMatch )
			{
				StopCompetitiveMatch( CMsgGC_Match_Result_Status_MATCH_FAILED_ABANDON );
			}
			else
			{
				// If the match was ended but we're still playing, kick off a timer to remind people that
				// they're in a dead match.
				AssertMsg( !IsManagedMatchEnded() || ( pMatch->BMatchTerminated() && bEveryoneSafeToLeave ),
					        "Expect everyone to be safe to leave and the match info to reflect that after the match is over" );
				bool bGameRunning = ( State_Get() == GR_STATE_BETWEEN_RNDS || State_Get() == GR_STATE_RND_RUNNING );
				bool bDeadMatch = bGameRunning && IsManagedMatchEnded() && pMatch->BMatchTerminated() && bEveryoneSafeToLeave;
				if ( bDeadMatch && ( m_flSafeToLeaveTimer == -.1f ||
					                    m_flSafeToLeaveTimer - gpGlobals->curtime <= 0.f ) )
				{
					// Periodic nag event
					m_flSafeToLeaveTimer = gpGlobals->curtime + 30.f;
					IGameEvent *pEvent = gameeventmanager->CreateEvent( "player_abandoned_match" );
					if ( pEvent )
					{
						pEvent->SetBool( "game_over", false );
						gameeventmanager->FireEvent( pEvent );
					}
				}
			}

			// Handle re-spawning the players after the doors have shut at the beginning of a match
			if ( ( m_flCompModeRespawnPlayersAtMatchStart > 0 ) && ( m_flCompModeRespawnPlayersAtMatchStart < gpGlobals->curtime ) )
			{
				for ( int i = 1; i <= MAX_PLAYERS; i++ )
				{
					CTFPlayer *pPlayer = static_cast<CTFPlayer*>( UTIL_PlayerByIndex( i ) );
					if ( !pPlayer )
						continue;

					pPlayer->RemoveAllOwnedEntitiesFromWorld();
					pPlayer->ForceRespawn();
				}

				m_flCompModeRespawnPlayersAtMatchStart = -1.f;
			}
		}
	}

	if ( g_bRandomMap == true )
	{
		g_bRandomMap = false;

		char szNextMap[MAX_MAP_NAME];
		GetNextLevelName( szNextMap, sizeof(szNextMap), true );
		IncrementMapCycleIndex();

		ChangeLevelToMap( szNextMap );

		return;
	}

	if ( IsInArenaMode() == true )
	{
		if ( m_flSendNotificationTime > 0.0f && m_flSendNotificationTime <= gpGlobals->curtime )
		{
			Arena_SendPlayerNotifications();
		}
	}

	// periodically count up the fake clients and set the bot_count cvar to update server tags
	if ( m_botCountTimer.IsElapsed() )
	{
		m_botCountTimer.Start( 5.0f );

		int botCount = 0;
		for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
		{
			CTFPlayer *player = ToTFPlayer( UTIL_PlayerByIndex( i ) );

			if ( player && player->IsFakeClient() )
			{
				++botCount;
			}
		}

		tf_bot_count.SetValue( botCount );
	}

#ifdef GAME_DLL
#ifdef _DEBUG
	if ( tf_debug_ammo_and_health.GetBool() )
	{
		CBaseEntity *ent;

		for( int i=0; i<m_healthVector.Count(); ++i )
		{
			ent = m_healthVector[i];
			if ( ent )
			{
				NDebugOverlay::Cross3D( ent->WorldSpaceCenter(), 10.0f, 0, 255, 0, true, 0.1f );
			}
		}

		for( int i=0; i<m_ammoVector.Count(); ++i )
		{
			ent = m_ammoVector[i];
			if ( ent )
			{
				NDebugOverlay::Cross3D( ent->WorldSpaceCenter(), 10.0f, 0, 0, 255, true, 0.1f );
			}
		}
	}
#endif // _DEBUG

	if ( g_voteController )
	{
		ManageServerSideVoteCreation();
	}

	// ...
	if ( tf_item_based_forced_holiday.GetInt() == kHoliday_Halloween && engine->Time() >= g_fEternaweenAutodisableTime )
	{
		if ( GCClientSystem() )
		{
			GCSDK::CProtoBufMsg<CMsgGC_GameServer_ServerModificationItemExpired> msg( k_EMsgGC_GameServer_ServerModificationItemExpired );
			msg.Body().set_modification_type( kGameServerModificationItem_Halloween );
			GCClientSystem()->BSendMessage( msg );
		}

		tf_item_based_forced_holiday.SetValue( kHoliday_None );
		FlushAllAttributeCaches();
	}	

	// play the bomb alarm if we need to
	if ( m_bMannVsMachineAlarmStatus )
	{
		if ( m_flNextFlagAlert < gpGlobals->curtime )
		{
			if ( PlayThrottledAlert( 255, "Announcer.MVM_Bomb_Alert_Near_Hatch", 5.0f ) )
			{
				m_flNextFlagAlarm = gpGlobals->curtime + 3.0;
				m_flNextFlagAlert = gpGlobals->curtime + 20.0f;
			}
		}

		if ( m_flNextFlagAlarm < gpGlobals->curtime )
		{
			m_flNextFlagAlarm = gpGlobals->curtime + 3.0;

			BroadcastSound( 255, "MVM.BombWarning" );
		}
	}
	else if ( m_flNextFlagAlarm > 0.0f )
	{
		m_flNextFlagAlarm = 0.0f;
		m_flNextFlagAlert = gpGlobals->curtime + 5.0f;
	}

	if ( m_bPowerupImbalanceMeasuresRunning )
	{
		if ( m_flTimeToStopImbalanceMeasures < gpGlobals->curtime )
		{
			PowerupTeamImbalance( TEAM_UNASSIGNED ); // passing TEAM_UNASSIGNED will fire the ImbalanceMeasuresOver output
			m_bPowerupImbalanceMeasuresRunning = false;
		}
	}

	PeriodicHalloweenUpdate();
	SpawnHalloweenBoss();

	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		if ( ( State_Get() == GR_STATE_RND_RUNNING ) && ( !m_bHelltowerPlayersInHell ) && ( m_helltowerTimer.IsElapsed() ) )
		{
			// Play our Halloween winning/losing lines for the teams
			int iWinningTeam = TEAM_UNASSIGNED;
			bool bRareLine = ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE );
			float flRedProgress = 0.0f, flBlueProgress = 0.0f;
			for ( int i = 0 ; i < ITFTeamTrainWatcher::AutoList().Count() ; ++i )
			{
				CTeamTrainWatcher *pTrainWatcher = static_cast< CTeamTrainWatcher* >( ITFTeamTrainWatcher::AutoList()[i] );
				if ( !pTrainWatcher->IsDisabled() )
				{
					if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_RED )
					{
						flRedProgress = pTrainWatcher->GetTrainDistanceAlongTrack();
					}
					else
					{
						flBlueProgress = pTrainWatcher->GetTrainDistanceAlongTrack();
					}
				}
			}

			if ( flRedProgress > flBlueProgress )
			{
				iWinningTeam = TF_TEAM_RED;
			}
			else if ( flBlueProgress > flRedProgress )
			{
				iWinningTeam = TF_TEAM_BLUE;
			}

			int iRedLine = HELLTOWER_VO_RED_MISC;
			int iBlueLine = HELLTOWER_VO_BLUE_MISC;

			// should we play the misc lines or the winning/losing lines?
			if ( ( iWinningTeam == TEAM_UNASSIGNED ) || ( RandomFloat( 0, 1 ) < HELLTOWER_MISC_CHANCE ) )
			{
				if ( bRareLine )
				{
					iRedLine = HELLTOWER_VO_RED_MISC_RARE;
					iBlueLine = HELLTOWER_VO_BLUE_MISC_RARE;
				}
			}
			else
			{
				// play a winning/losing line
				iRedLine = ( iWinningTeam == TF_TEAM_RED ) ? HELLTOWER_VO_RED_WINNING : HELLTOWER_VO_RED_LOSING;
				iBlueLine = ( iWinningTeam == TF_TEAM_BLUE ) ? HELLTOWER_VO_BLUE_WINNING : HELLTOWER_VO_BLUE_LOSING;

				if ( bRareLine )
				{
					iRedLine = ( iWinningTeam == TF_TEAM_RED ) ? HELLTOWER_VO_RED_WINNING_RARE : HELLTOWER_VO_RED_LOSING_RARE;
					iBlueLine = ( iWinningTeam == TF_TEAM_BLUE ) ? HELLTOWER_VO_BLUE_WINNING_RARE : HELLTOWER_VO_BLUE_LOSING_RARE;

				}
			}

			PlayHelltowerAnnouncerVO( iRedLine, iBlueLine );
			m_helltowerTimer.Start( HELLTOWER_TIMER_INTERVAL );
		}
	}
	else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) )
	{
		if ( ( State_Get() == GR_STATE_RND_RUNNING ) && m_doomsdaySetupTimer.HasStarted() && m_doomsdaySetupTimer.IsElapsed() )
		{
			m_doomsdaySetupTimer.Invalidate();

			const char *pszSound = NULL;
			switch( GetRoundsPlayed() )
			{
			case 0:
				pszSound = "sf14.Merasmus.Start.FirstRound";
				if ( RandomInt( 1, 10 ) == 1 )
				{
					pszSound = "sf14.Merasmus.Start.FirstRoundRare";
				}
				break;
			case 1:
				pszSound = "sf14.Merasmus.Start.SecondRound";
				break;
			case 2:
			default: 
				pszSound = "sf14.Merasmus.Start.ThirdRoundAndBeyond";
				break;
			}

			if ( pszSound && pszSound[0] )
			{
				BroadcastSound( 255, pszSound );
			}
		}
	}

#ifdef TF_RAID_MODE
	// This check is here for Boss battles that don't have a tf_raid_logic entity
	if ( IsBossBattleMode() && !IsInWaitingForPlayers() && State_Get() == GR_STATE_RND_RUNNING )
	{
		CUtlVector< CTFPlayer * > alivePlayerVector;
		CollectPlayers( &alivePlayerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS );

		// if everyone is dead at the same time, they lose
		if ( alivePlayerVector.Count() == 0 )
		{
			SetWinningTeam( TF_TEAM_RED, WINREASON_OPPONENTS_DEAD );
		}
	}
#endif // TF_RAID_MODE

	// Batched strange event message processing?
	if ( engine->Time() > m_flNextStrangeEventProcessTime )
	{
		KillEaterEvents_FlushBatches();
		m_flNextStrangeEventProcessTime = engine->Time() + g_flStrangeEventBatchProcessInterval;
	}

	ManageCompetitiveMode();

#endif // GAME_DLL

//=============================================================================
// HPE_BEGIN:
// [msmith]	Do training summary screen logic.
//=============================================================================
	if ( IsInTraining() == true )
	{
		if ( m_flStateTransitionTime > gpGlobals->curtime )
		{
			int client_message = tf_training_client_message.GetInt();
			switch ( client_message )
			{
				case TRAINING_CLIENT_MESSAGE_IN_SUMMARY_SCREEN:
				{
					//Keep adding time to the restart while we are in the end screen menu so that we never restart the round until
					//the player presses the replay button (or next button to go to the next map).
					m_flStateTransitionTime = gpGlobals->curtime + 5.0f;
				}
				break;
				case TRAINING_CLIENT_MESSAGE_NEXT_MAP:
				{
					LoadNextTrainingMap();
					tf_training_client_message.SetValue( (int)TRAINING_CLIENT_MESSAGE_NONE );
				}
				break;
				case TRAINING_CLIENT_MESSAGE_REPLAY:
				{
					// Reload the map
					engine->ChangeLevel( STRING( gpGlobals->mapname ), NULL );
					tf_training_client_message.SetValue( (int)TRAINING_CLIENT_MESSAGE_NONE );
				}
				break;
			} // switch
		}
	}
//=============================================================================
// HPE_END
//=============================================================================

	// This is ugly, but, population manager needs to sometimes think when we're not simulating, but it is an entity.
	// Really, we need to better split out some kind of "sub-gamerules" class for modes like this.
	if ( IsMannVsMachineMode() && g_pPopulationManager )
	{
		g_pPopulationManager->GameRulesThink();
	}

	BaseClass::Think();
}

#ifdef GAME_DLL
#ifdef STAGING_ONLY
ConVar tf_spawn_halloween_gift_test_enabled( "tf_spawn_halloween_gift_test_enabled", "0", 0, "enable to spawn a gift at the world origin.  You probably want to use ConCommand 'SpawnHalloweenGiftTest'" );

CON_COMMAND_F( tf_spawn_halloween_gift_test, "Test Halloween Gifts", FCVAR_NONE )
{
	ConVarRef gift_test( "tf_spawn_halloween_gift_test_enabled" );
	gift_test.SetValue( 1 );
}
#endif // STAGING_ONLY

void CTFGameRules::PeriodicHalloweenUpdate()
{
	// DEBUG
#ifdef STAGING_ONLY
	if ( tf_spawn_halloween_gift_test_enabled.GetBool() )
	{
		m_flNextHalloweenGiftUpdateTime = gpGlobals->curtime;
		tf_spawn_halloween_gift_test_enabled.SetValue( 0 );
		return;
	}
#endif //staging_only

	// Are we on a Halloween Map?
	// Do we have Halloween Contracts?
	if ( !IsHolidayActive( kHoliday_Halloween ) )
		return;
	
	// Loop through each player that has a quest and spawn them a gift
	if ( m_halloweenGiftSpawnLocations.Count() == 0 )
		return;
	
	// If we've never given out gifts before, set the time
	if ( m_flNextHalloweenGiftUpdateTime < 0 )
	{
		m_flNextHalloweenGiftUpdateTime = gpGlobals->curtime + RandomInt( 7, 12 ) * 60;
		return;
	}

	if ( m_flNextHalloweenGiftUpdateTime > gpGlobals->curtime )
		return;

	m_flNextHalloweenGiftUpdateTime = gpGlobals->curtime + RandomInt( 7, 12 ) * 60;

	CUtlVector< CTFPlayer* > playerVector;
	CollectPlayers( &playerVector );
	FOR_EACH_VEC( playerVector, i )
	{
		Vector vLocation = m_halloweenGiftSpawnLocations.Element( RandomInt( 0, m_halloweenGiftSpawnLocations.Count() - 1 ) );
		CHalloweenGiftPickup *pGift = assert_cast<CHalloweenGiftPickup*>( CBaseEntity::CreateNoSpawn( "tf_halloween_gift_pickup", vLocation, vec3_angle, NULL ) );
		if ( pGift )
		{
			pGift->SetTargetPlayer( playerVector[i] );
			DispatchSpawn( pGift );
		}
	}
	
}
#endif

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::SwitchToNextBestWeapon( CBaseCombatCharacter *pPlayer, CBaseCombatWeapon *pCurrentWeapon )
{
	if ( pPlayer )
	{
		CBaseCombatWeapon *lastWeapon = ToTFPlayer( pPlayer )->GetLastWeapon();	

		if ( lastWeapon != NULL && lastWeapon->HasAnyAmmo() )
		{
			return pPlayer->Weapon_Switch( lastWeapon );
		}
	}

	return BaseClass::SwitchToNextBestWeapon( pPlayer, pCurrentWeapon );
}


#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::PointsMayBeCaptured( void )
{
	if ( IsHolidayActive( kHoliday_Halloween ) && GetActiveBoss() )
	{
		switch ( GetHalloweenScenario() )
		{
		case HALLOWEEN_SCENARIO_VIADUCT:
			{
				// the eyeball prevents point capturing while he's in play
				if ( assert_cast< CEyeballBoss * >( GetActiveBoss() ) )
				{
					return false;
				}
			}
			break;
		case HALLOWEEN_SCENARIO_LAKESIDE:
			{
				// merasmus prevents point capturing while he's in play
				if ( assert_cast< CMerasmus * >( GetActiveBoss() ) )
				{
					return false;
				}
			}
			break;
		}
	}

	if ( IsMannVsMachineMode() )
	{
		return true;
	}

	return BaseClass::PointsMayBeCaptured();
}


extern bool IsSpaceToSpawnHere( const Vector &where );

static bool isZombieMobForceSpawning = false;

#ifdef STAGING_ONLY
// force the boss to spawn where our cursor is pointing
CON_COMMAND_F( tf_halloween_force_zombie_mob, "For testing.", FCVAR_CHEAT )
{
	isZombieMobForceSpawning = true;
}
#endif

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SpawnZombieMob( void )
{
	if ( !tf_halloween_zombie_mob_enabled.GetBool() )
	{
		return;
	}

	// timer was started and has elapsed - time to spawn the boss
	if ( InSetup() || IsInWaitingForPlayers() )
	{
		m_zombieMobTimer.Start( tf_halloween_zombie_mob_spawn_interval.GetFloat() );
		return;
	}

	if ( isZombieMobForceSpawning )
	{
		isZombieMobForceSpawning = false;
		m_zombieMobTimer.Invalidate();
	}

	// spawn pending mob members
	if ( m_zombiesLeftToSpawn > 0 )
	{
		if ( IsSpaceToSpawnHere( m_zombieSpawnSpot ) )
		{
			if ( CZombie::SpawnAtPos( m_zombieSpawnSpot ) )
			{
				--m_zombiesLeftToSpawn;
			}
		}
	}

	// require a minimum number of human players in the game before the boss appears
	CUtlVector< CTFPlayer * > playerVector;
	CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS );
	CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS );

	// only count humans
	int totalPlayers = 0;
	for( int i=0; i<playerVector.Count(); ++i )
	{
		if ( !playerVector[i]->IsBot() )
		{
			++totalPlayers;
		}
	}

	if ( totalPlayers == 0 )
	{
		return;
	}

	// spawn a mob
	if ( m_zombieMobTimer.IsElapsed() )
	{
		m_zombieMobTimer.Start( tf_halloween_zombie_mob_spawn_interval.GetFloat() );

		CUtlVector< CTFNavArea * > ambushVector;	// vector of hidden but near-to-victim areas

		for( int i=0; i<playerVector.Count(); ++i )
		{
			CTFPlayer *player = playerVector[i];

			if ( player->IsBot() )
			{
				continue;
			}

			if ( !player->GetLastKnownArea() )
			{
				continue;
			}

			const float maxSurroundTravelRange = 2000.0f;

			CUtlVector< CNavArea * > areaVector;

			// collect walkable areas surrounding this player
			CollectSurroundingAreas( &areaVector, player->GetLastKnownArea(), maxSurroundTravelRange, StepHeight, StepHeight );

			// keep subset that isn't visible to any player
			for( int j=0; j<areaVector.Count(); ++j )
			{
				CTFNavArea *area = (CTFNavArea *)areaVector[j];

				if ( !area->IsValidForWanderingPopulation() )
				{
					continue;
				}

				if ( area->IsPotentiallyVisibleToTeam( TF_TEAM_BLUE ) || area->IsPotentiallyVisibleToTeam( TF_TEAM_RED ) )
				{
					continue;
				}

				ambushVector.AddToTail( area );
			}
		}

		if ( ambushVector.Count() == 0 )
		{
			// no place to spawn the mob this time
			return;
		}

		for( int retry=0; retry<10; ++retry )
		{
			int which = RandomInt( 0, ambushVector.Count()-1 );
			m_zombieSpawnSpot = ambushVector[ which ]->GetCenter() + Vector( 0, 0, StepHeight );

			if ( !IsSpaceToSpawnHere( m_zombieSpawnSpot ) )
			{
				continue;
			}

			// spawn a mob here
			m_zombiesLeftToSpawn = tf_halloween_zombie_mob_spawn_count.GetInt();
				
			break;
		}
	}
}

//---------------------------------------------------------------------------------------------------------
static bool isBossForceSpawning = false;

// force the boss to spawn where our cursor is pointing
CON_COMMAND_F( tf_halloween_force_boss_spawn, "For testing.", FCVAR_CHEAT )
{
	isBossForceSpawning = true;
}


CON_COMMAND_F( cc_spawn_merasmus_at_level, "Force Merasmus to spawn at a specific difficulty level", FCVAR_CHEAT )
{
	if( args.ArgC() != 2 )
	{
		DevMsg( "Must specify a level\n" );
		return;
	}

	CMerasmus::DBG_SetLevel( atoi(args[1]) );
	
	tf_halloween_force_boss_spawn( args );
}


extern ConVar tf_halloween_bot_min_player_count;

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SpawnHalloweenBoss( void )
{
	if ( !IsHolidayActive( kHoliday_Halloween ) )
		return;

	// only spawn the Halloween Boss on our Halloween maps
	HalloweenBossType bossType = HALLOWEEN_BOSS_INVALID;

	float bossInterval = 0.0f;
	float bossIntervalVariation = 0.0f;

	HalloweenScenarioType scenario = GetHalloweenScenario();
	if ( scenario == HALLOWEEN_SCENARIO_MANN_MANOR )
	{
		bossType = HALLOWEEN_BOSS_HHH;
		bossInterval = tf_halloween_boss_spawn_interval.GetFloat();
		bossIntervalVariation = tf_halloween_boss_spawn_interval_variation.GetFloat();

	}
	else if ( scenario == HALLOWEEN_SCENARIO_VIADUCT )
	{
		bossType = HALLOWEEN_BOSS_MONOCULUS;
		bossInterval = tf_halloween_eyeball_boss_spawn_interval.GetFloat();
		bossIntervalVariation = tf_halloween_eyeball_boss_spawn_interval_variation.GetFloat();
	}
	else if ( scenario == HALLOWEEN_SCENARIO_LAKESIDE )
	{
		bossType = HALLOWEEN_BOSS_MERASMUS;

		if ( CMerasmus::GetMerasmusLevel() <= 3 )
		{
			bossInterval = tf_merasmus_spawn_interval.GetFloat();
			bossIntervalVariation = tf_merasmus_spawn_interval_variation.GetFloat();
		}
		else
		{
			// after level 3, spawn Merasmus every 60 secs
			bossInterval = 60;
			bossIntervalVariation = 0;
		}

		// check if the wheel is still spinning
		CWheelOfDoom* pWheel = assert_cast< CWheelOfDoom* >( gEntList.FindEntityByClassname( NULL, "wheel_of_doom" ) );
		if ( pWheel && !pWheel->IsDoneBoardcastingEffectSound() )
		{
			return;
		}
	}
	//else if ( scenario == HALLOWEEN_SCENARIO_HIGHTOWER )
	//{
	//	bool bWasEnabled = tf_halloween_zombie_mob_enabled.GetBool();
	//	tf_halloween_zombie_mob_enabled.SetValue( true );

	//	// not a boss battle map
	//	SpawnZombieMob();

	//	tf_halloween_zombie_mob_enabled.SetValue( bWasEnabled );

	//	bossType = "eyeball_boss";
	//	bossInterval = tf_halloween_eyeball_boss_spawn_interval.GetFloat();
	//	bossIntervalVariation = tf_halloween_eyeball_boss_spawn_interval_variation.GetFloat();
	//}
	else
	{
		// not a boss battle map
		SpawnZombieMob();

		return;
	}

	// only one boss at a time
	if ( GetActiveBoss() )
	{
		// boss is still out there - restart the timer
		StartHalloweenBossTimer( bossInterval, bossIntervalVariation );
		isBossForceSpawning = false;
		return;
	}

	if ( !m_halloweenBossTimer.IsElapsed() && !isBossForceSpawning )
		return;

	// boss timer has elapsed
	if ( m_halloweenBossTimer.HasStarted() || isBossForceSpawning )
	{
		if ( !isBossForceSpawning )
		{
			// timer was started and has elapsed - time to spawn the boss
			if ( InSetup() || IsInWaitingForPlayers() )
				return;

			// require a minimum number of human players in the game before the boss appears
			CUtlVector< CTFPlayer * > playerVector;
			CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS );
			CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS );

			// only count humans
			int totalPlayers = 0;
			for( int i=0; i<playerVector.Count(); ++i )
			{
				if ( !playerVector[i]->IsBot() )
				{
					++totalPlayers;
				}
			}

			if ( totalPlayers < tf_halloween_bot_min_player_count.GetInt() )
				return;
		}

		Vector bossSpawnPos = vec3_origin;

		// spawn on the currently contested point
		CTeamControlPoint *contestedPoint = NULL;
		CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
		if ( pMaster )
		{
			for( int i=0; i<pMaster->GetNumPoints(); ++i )
			{
				contestedPoint = pMaster->GetControlPoint( i );
				if ( contestedPoint && pMaster->IsInRound( contestedPoint ) )
				{
					if ( ObjectiveResource()->GetOwningTeam( contestedPoint->GetPointIndex() ) == TF_TEAM_BLUE )
						continue;

					// blue are the invaders
					if ( !TeamplayGameRules()->TeamMayCapturePoint( TF_TEAM_BLUE, contestedPoint->GetPointIndex() ) )
						continue;

					break;
				}
			}
		}

		CBaseEntity *pCustomSpawnBossPos = gEntList.FindEntityByClassname( NULL, "spawn_boss" );
		if ( pCustomSpawnBossPos )
		{
			bossSpawnPos = pCustomSpawnBossPos->GetAbsOrigin();
		}
		else if ( contestedPoint )
		{
			bossSpawnPos = contestedPoint->GetAbsOrigin();

			if ( scenario == HALLOWEEN_SCENARIO_VIADUCT || scenario == HALLOWEEN_SCENARIO_LAKESIDE )
			{
				// revert ownership of point to neutral
				contestedPoint->ForceOwner( 0 );

				// pause the timers
				if ( IsInKothMode() )
				{
					variant_t sVariant;
					CTeamRoundTimer *pTimer = GetKothTeamTimer( TF_TEAM_BLUE );
					if ( pTimer )
					{
						pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
					}

					pTimer = GetKothTeamTimer( TF_TEAM_RED );
					if ( pTimer )
					{
						pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );
					}
				}
			}
		}
		else
		{
			// pick a random spot
			CUtlVector< CTFNavArea * > spawnAreaVector;
			for( int i=0; i<TheNavAreas.Count(); ++i )
			{
				CTFNavArea *area = (CTFNavArea *)TheNavAreas[i];

				if ( area->HasAttributeTF( TF_NAV_SPAWN_ROOM_BLUE | TF_NAV_SPAWN_ROOM_RED | TF_NAV_SPAWN_ROOM_EXIT ) )
				{
					// don't spawn in team spawn rooms
					continue;
				}

				// don't use small nav areas
				const float goodSize = 100.0f;
				if ( area->GetSizeX() < goodSize || area->GetSizeY() < goodSize )
				{
					continue;
				}

				spawnAreaVector.AddToTail( area );
			}

			if ( spawnAreaVector.Count() == 0 )
			{
				// no place to spawn (!)
				return;
			}

			int which = RandomInt( 0, spawnAreaVector.Count()-1 );
			bossSpawnPos = spawnAreaVector[ which ]->GetCenter();
		}

		CHalloweenBaseBoss::SpawnBossAtPos( bossType, bossSpawnPos );

		// pick next spawn time
		StartHalloweenBossTimer( bossInterval, bossIntervalVariation );
	
		isBossForceSpawning = false;
	}
	else
	{
		// Merasmus has a more reliable initial spawn time
		if( IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) )
		{
			StartHalloweenBossTimer( bossInterval, bossIntervalVariation );
		}
		else
		{
			// initial spawn time
			m_halloweenBossTimer.Start( 0.5f * RandomFloat( 0.0f, bossInterval + bossIntervalVariation ) );	
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::BeginHaunting( int nDesiredCount, float flMinDuration, float flMaxDuration )
{
	if ( !IsHolidayActive( kHoliday_Halloween ) )
		return;

	if ( !IsHalloweenScenario( HALLOWEEN_SCENARIO_VIADUCT ) && !IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) )
	{
		CTFHolidayEntity *pHolidayEntity = dynamic_cast<CTFHolidayEntity*> ( gEntList.FindEntityByClassname( NULL, "tf_logic_holiday" ) );
		if ( !pHolidayEntity || !pHolidayEntity->ShouldAllowHaunting() )
			return;
	}

	const int desiredGhostCount = nDesiredCount;

	// if there are existing ghosts, extend their time
	CUtlVector< CGhost * > priorGhostVector;
	for( int g=0; g<m_ghostVector.Count(); ++g )
	{
		if ( m_ghostVector[g] != NULL )
		{
			priorGhostVector.AddToTail( m_ghostVector[g] );
		}
	}

	m_ghostVector.RemoveAll();		

	for( int g=0; g<priorGhostVector.Count(); ++g )
	{
		priorGhostVector[g]->SetLifetime( RandomFloat( flMinDuration, flMaxDuration ) );

		m_ghostVector.AddToTail( priorGhostVector[g] );
	}

	if ( m_ghostVector.Count() >= desiredGhostCount )
		return;

	// spawn ghosts away from players
	CUtlVector< CTFPlayer * > playerVector;
	CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS );
	CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS );

	const int ghostCount = desiredGhostCount - m_ghostVector.Count();

	CUtlVector< Vector > spawnVector;

	for( int i=0; i<TheNavAreas.Count(); ++i )
	{
		CTFNavArea *area = (CTFNavArea *)TheNavAreas.Element(i);

		if ( area->HasAttributeTF( TF_NAV_SPAWN_ROOM_BLUE | TF_NAV_SPAWN_ROOM_RED ) )
		{
			// keep out of spawn rooms
			continue;
		}

		Vector spot = area->GetCenter();

		// don't spawn near players (so they aren't instantly scared)
		int p;
		for( p=0; p<playerVector.Count(); ++p )
		{
			if ( ( playerVector[p]->GetAbsOrigin() - spot ).IsLengthLessThan( 1.25f * GHOST_SCARE_RADIUS ) )
			{
				break;
			}
		}

		if ( p == playerVector.Count() )
		{
			spawnVector.AddToTail( spot );
		}
	}

	if ( spawnVector.Count() == 0 )
	{
		return;
	}

	for( int g=0; g<ghostCount; ++g )
	{
		int which = RandomInt( 0, spawnVector.Count()-1 );

		CGhost *ghost = SpawnGhost( spawnVector[ which ], vec3_angle, RandomFloat( flMinDuration, flMaxDuration ) );

		m_ghostVector.AddToTail( ghost );
	}
}

static const int k_RecentPlayerInfoMaxTime = 7200;	// 2 hours

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::PlayerHistory_AddPlayer( CTFPlayer *pTFPlayer )
{
	if ( !pTFPlayer )
		return;

	CSteamID steamID;
	pTFPlayer->GetSteamID( &steamID );
	if ( !steamID.IsValid() || !steamID.BIndividualAccount() )
		return;

	// Exists?
	FOR_EACH_VEC_BACK( m_vecPlayerHistory, i )
	{
		if ( m_vecPlayerHistory[i].steamID == steamID )
		{
			m_vecPlayerHistory[i].flTime = Plat_FloatTime();
			return;
		}

		// Do maintenance here.
		if ( Plat_FloatTime() - m_vecPlayerHistory[i].flTime >= (float)k_RecentPlayerInfoMaxTime )
		{
			m_vecPlayerHistory.Remove( i );
		}
	}

	PlayerHistoryInfo_t info = 
	{ 
		steamID, 
		(float) Plat_FloatTime(), 
		pTFPlayer->GetTeamNumber()
	};
	m_vecPlayerHistory.AddToTail( info );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
PlayerHistoryInfo_t *CTFGameRules::PlayerHistory_GetPlayerInfo( CTFPlayer *pTFPlayer )
{
	if ( !pTFPlayer )
		return NULL;

	CSteamID steamID;
	pTFPlayer->GetSteamID( &steamID );
	if ( !steamID.IsValid() || !steamID.BIndividualAccount() )
		return NULL;

	FOR_EACH_VEC_BACK( m_vecPlayerHistory, i )
	{
		if ( m_vecPlayerHistory[i].steamID == steamID )
			return &m_vecPlayerHistory[i];
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Returns -1 if we don't have the data
//-----------------------------------------------------------------------------
int CTFGameRules::PlayerHistory_GetTimeSinceLastSeen( CTFPlayer *pTFPlayer )
{
	PlayerHistoryInfo_t *pInfo = PlayerHistory_GetPlayerInfo( pTFPlayer );
	if ( !pInfo )
		return -1;

	// We only care about whole seconds
	return (int)( Plat_FloatTime() - pInfo->flTime );
}
#endif

//=============================================================================
// HPE_BEGIN:
// [msmith]	TEMP CODE: needs to be replaced with the final solution for our training mission navigation.
//=============================================================================
void CTFGameRules::LoadNextTrainingMap()
{
	if ( m_hTrainingModeLogic )
	{
		g_fGameOver = true;
		const char* pNextMap = m_hTrainingModeLogic->GetNextMap();
		if ( pNextMap && FStrEq( pNextMap, "" ) == false )
		{
			Msg( "CHANGE LEVEL: %s\n", pNextMap );
			engine->ChangeLevel( pNextMap, NULL );
		}
		else
		{
			Msg( "CHANGE LEVEL: %s\n", STRING( gpGlobals->mapname ) );
			engine->ChangeLevel( STRING( gpGlobals->mapname ), NULL );
		}
		return;
	}
		
	Msg( "CHANGE LEVEL: %s\n", STRING( gpGlobals->mapname ) );
	engine->ChangeLevel( STRING( gpGlobals->mapname ), NULL );
}
//=============================================================================
// HPE_END
//=============================================================================

//Runs think for all player's conditions
//Need to do this here instead of the player so players that crash still run their important thinks
void CTFGameRules::RunPlayerConditionThink ( void )
{
	for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );

		if ( pPlayer )
		{
			pPlayer->m_Shared.ConditionGameRulesThink();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::FrameUpdatePostEntityThink()
{
	BaseClass::FrameUpdatePostEntityThink();

	RunPlayerConditionThink();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::CheckCapsPerRound()
{
	return IsPasstimeMode() 
		? SetPasstimeWinningTeam()
		: SetCtfWinningTeam();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::SetPasstimeWinningTeam()
{
	Assert( IsPasstimeMode() );

	int iScoreLimit = tf_passtime_scores_per_round.GetInt();
	if ( iScoreLimit <= 0 )
	{
		// no score limit set, play forever
		return false;
	}

	// TODO need to generalize the "flag captures" parts of CTFTeam to avoid 
	// this confusing overload of the flag captures concept, or maybe defer 
	// this logic to the specific object that manages the mode.
	CTFTeamManager *pTeamMgr = TFTeamMgr();
	int iBlueScore = pTeamMgr->GetFlagCaptures( TF_TEAM_BLUE );
	int iRedScore = pTeamMgr->GetFlagCaptures( TF_TEAM_RED );
	if ( ( iBlueScore < iScoreLimit ) && ( iRedScore < iScoreLimit ) )
	{
		// no team has exceeded the score limit
		return false;
	}

	int iWinnerTeam = ( iBlueScore > iRedScore )
		? TF_TEAM_BLUE
		: TF_TEAM_RED;
	SetWinningTeam( iWinnerTeam, WINREASON_SCORED );
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::SetCtfWinningTeam()
{
	Assert( !IsPasstimeMode() );
	if ( tf_flag_caps_per_round.GetInt() > 0 )
	{
		int iMaxCaps = -1;
		CTFTeam *pMaxTeam = NULL;

		// check to see if any team has won a "round"
		int nTeamCount = TFTeamMgr()->GetTeamCount();
		for ( int iTeam = FIRST_GAME_TEAM; iTeam < nTeamCount; ++iTeam )
		{
			CTFTeam *pTeam = GetGlobalTFTeam( iTeam );
			if ( !pTeam )
				continue;

			// we might have more than one team over the caps limit (if the server op lowered the limit)
			// so loop through to see who has the most among teams over the limit
			if ( pTeam->GetFlagCaptures() >= tf_flag_caps_per_round.GetInt() )
			{
				if ( pTeam->GetFlagCaptures() > iMaxCaps )
				{
					iMaxCaps = pTeam->GetFlagCaptures();
					pMaxTeam = pTeam;
				}
			}
		}

		if ( iMaxCaps != -1 && pMaxTeam != NULL )
		{
			SetWinningTeam( pMaxTeam->GetTeamNumber(), WINREASON_FLAG_CAPTURE_LIMIT );
			return true;
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::CheckWinLimit( bool bAllowEnd /*= true*/, int nAddValueWhenChecking /*= 0*/ )
{
	if ( IsInPreMatch() )
		return false;

	bool bWinner = false;
	int iTeam = TEAM_UNASSIGNED;
	int iReason = WINREASON_NONE;
	const char *pszReason = "";

	if ( mp_winlimit.GetInt() != 0 )
	{
		if ( ( TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore() + nAddValueWhenChecking ) >= mp_winlimit.GetInt() )
		{
			pszReason = "Team \"BLUE\" triggered \"Intermission_Win_Limit\"\n";
			bWinner = true;
			iTeam = TF_TEAM_BLUE;
			iReason = WINREASON_WINLIMIT;
		}
		else if ( ( TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetScore() + nAddValueWhenChecking ) >= mp_winlimit.GetInt() )
		{
			pszReason = "Team \"RED\" triggered \"Intermission_Win_Limit\"\n";
			bWinner = true;
			iTeam = TF_TEAM_RED;
			iReason = WINREASON_WINLIMIT;
		}
	}

	// has one team go far enough ahead of the other team to trigger the win difference?
	if ( !bWinner )
	{
		int iWinLimit = mp_windifference.GetInt();
		if ( iWinLimit > 0 )
		{
			int iBlueScore = TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore();
			int iRedScore = TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetScore();

			if ( (iBlueScore - iRedScore) >= iWinLimit )
			{
				if ( (mp_windifference_min.GetInt() == 0) || (iBlueScore >= mp_windifference_min.GetInt()) )
				{
					pszReason = "Team \"BLUE\" triggered \"Intermission_Win_Limit\" due to mp_windifference\n";
					bWinner = true;
					iTeam = TF_TEAM_BLUE;
					iReason = WINREASON_WINDIFFLIMIT;
				}
			}
			else if ( (iRedScore - iBlueScore) >= iWinLimit )
			{
				if ( (mp_windifference_min.GetInt() == 0) || (iRedScore >= mp_windifference_min.GetInt()) )
				{
					pszReason = "Team \"RED\" triggered \"Intermission_Win_Limit\" due to mp_windifference\n";
					bWinner = true;
					iTeam = TF_TEAM_RED;
					iReason = WINREASON_WINDIFFLIMIT;
				}
			}
		}
	}

	if ( bWinner )
	{
		if ( bAllowEnd )
		{
			IGameEvent *event = gameeventmanager->CreateEvent( "tf_game_over" );
			if ( event )
			{
				if ( iReason == WINREASON_WINDIFFLIMIT )
				{
					event->SetString( "reason", "Reached Win Difference Limit" );
				}
				else
				{
					event->SetString( "reason", "Reached Win Limit" );
				}
				gameeventmanager->FireEvent( event );
			}

			if ( IsInTournamentMode() == true )
			{
				SetWinningTeam( iTeam, iReason, true, false, true );
			}
			else
			{
				GoToIntermission();
			}

			Assert( V_strlen( pszReason ) );
			UTIL_LogPrintf( "%s", pszReason );
		}
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::CheckRespawnWaves()
{
	BaseClass::CheckRespawnWaves();

	// Look for overrides
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( !pTFPlayer )
			continue;

		if ( pTFPlayer->IsAlive() )
			continue; 

		if ( m_iRoundState == GR_STATE_PREROUND )
			continue;

		// Triggers can force a player to spawn at a specific time
		if ( pTFPlayer->GetRespawnTimeOverride() != -1.f && 
				gpGlobals->curtime > pTFPlayer->GetDeathTime() + pTFPlayer->GetRespawnTimeOverride() )
		{
			pTFPlayer->ForceRespawn();
		}
		else if ( IsPVEModeActive() )
		{
			// special stuff for PVE mode
			if ( !ShouldRespawnQuickly( pTFPlayer ) )
				continue;

			// If the player hasn't been dead the minimum respawn time, he
			// waits until the next wave.
			if ( !HasPassedMinRespawnTime( pTFPlayer ) )
				continue;

			if ( !pTFPlayer->IsReadyToSpawn() )
			{
				// Let the player spawn immediately when they do pick a class
				if ( pTFPlayer->ShouldGainInstantSpawn() )
				{
					pTFPlayer->AllowInstantSpawn();
				}
				continue;
			}

			// Respawn this player
			pTFPlayer->ForceRespawn();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::PlayWinSong( int team )
{
	if ( IsPlayingSpecialDeliveryMode() )
		return;

	bool bGameOver = IsGameOver();

	if ( !IsInStopWatch() || bGameOver )
	{
		// Give the match a chance to play something custom.  It returns true if it handled everything
		const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
		if ( pMatchDesc && pMatchDesc->BPlayWinMusic( team, bGameOver ) )
		{
			return;
		}
	}

	if ( IsInTournamentMode() && IsInStopWatch() && ObjectiveResource() )
	{
		int iStopWatchTimer = ObjectiveResource()->GetStopWatchTimer();
		CTeamRoundTimer *pStopWatch = dynamic_cast< CTeamRoundTimer* >( UTIL_EntityByIndex( iStopWatchTimer ) );
		if ( ( pStopWatch && pStopWatch->IsWatchingTimeStamps() ) || ( !m_bForceMapReset ) )
		{
			BroadcastSound( 255, "MatchMaking.RoundEndStalemateMusic" );
			return;
		}
	}

	CTeamplayRoundBasedRules::PlayWinSong( team );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetWinningTeam( int team, int iWinReason, bool bForceMapReset /* = true */, bool bSwitchTeams /* = false*/, bool bDontAddScore /* = false*/, bool bFinal /*= false*/ )
{
	// matching the value calculated in CTeamplayRoundBasedRules::State_Enter_TEAM_WIN() 
	// for m_flStateTransitionTime and adding 1 second to make sure we're covered
	int nTime = GetBonusRoundTime( bFinal ) + 1;  

	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( !pTFPlayer )
			continue;

		// store our team for the response rules at the next round start
		// (teams might be switched for attack/defend maps)
		pTFPlayer->SetPrevRoundTeamNum( pTFPlayer->GetTeamNumber() );

		if ( team != TEAM_UNASSIGNED )
		{
			if ( pTFPlayer->GetTeamNumber() == team )
			{
				if ( pTFPlayer->IsAlive() )
				{
					pTFPlayer->m_Shared.AddCond( TF_COND_CRITBOOSTED_BONUS_TIME, nTime );
				}
			}
			else
			{
				pTFPlayer->ClearExpression();
#ifdef GAME_DLL
				// Loser karts get max Damage and stun
				if ( pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
				{
					pTFPlayer->AddKartDamage( 666 );
					pTFPlayer->m_Shared.StunPlayer( 1.5f, 1.0f, TF_STUN_BOTH );		// Short full stun then slow
					pTFPlayer->m_Shared.StunPlayer( 10.0f, 0.25f, TF_STUN_MOVEMENT );
				}
#endif //GAME_DLL
			}
		}
	}

	DuelMiniGame_AssignWinners();

#ifdef TF_RAID_MODE
	if ( !IsBossBattleMode() )
	{
		// Don't do a full reset in Raid mode if the defending team didn't win
		if ( IsRaidMode() && team != TF_TEAM_PVE_DEFENDERS )
		{
			bForceMapReset = false;
		}
	}
#endif // TF_RAID_MODE

	SetBirthdayPlayer( NULL );

#ifdef GAME_DLL
	if ( m_bPlayingKoth )
	{
		// Increment BLUE KOTH cap time
		CTeamRoundTimer *pKOTHTimer = TFGameRules()->GetBlueKothRoundTimer();
		GetGlobalTFTeam( TF_TEAM_BLUE )->AddKOTHTime( pKOTHTimer->GetTimerMaxLength() - pKOTHTimer->GetTimeRemaining() );

		// Increment RED KOTH cap time
		pKOTHTimer = TFGameRules()->GetRedKothRoundTimer();
		GetGlobalTFTeam( TF_TEAM_RED )->AddKOTHTime( pKOTHTimer->GetTimerMaxLength() - pKOTHTimer->GetTimeRemaining() );
	}
	else if ( HasMultipleTrains() )
	{
		for ( int i = 0 ; i < ITFTeamTrainWatcher::AutoList().Count() ; ++i )
		{
			CTeamTrainWatcher *pTrainWatcher = static_cast< CTeamTrainWatcher* >( ITFTeamTrainWatcher::AutoList()[i] );
			if ( !pTrainWatcher->IsDisabled() )
			{
				if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_RED )
				{
					GetGlobalTFTeam( TF_TEAM_RED )->AddPLRTrack( pTrainWatcher->GetTrainProgress() );
				}
				else
				{
					GetGlobalTFTeam( TF_TEAM_BLUE )->AddPLRTrack( pTrainWatcher->GetTrainProgress() );
				}
			}
		}
	}
#endif

	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) && CTFMinigameLogic::GetMinigameLogic() )
	{
		CTFMiniGame *pMiniGame = CTFMinigameLogic::GetMinigameLogic()->GetActiveMinigame();
		if ( pMiniGame )
		{
			IGameEvent *event = gameeventmanager->CreateEvent( "minigame_win" );
			if ( event )
			{
				event->SetInt( "team", team );
				event->SetInt( "type", (int)( pMiniGame->GetMinigameType() ) );
				gameeventmanager->FireEvent( event );
			}
		}
	}

	if ( IsPasstimeMode() )
	{
		CTF_GameStats.m_passtimeStats.summary.nRoundEndReason = iWinReason;
		CTF_GameStats.m_passtimeStats.summary.nRoundRemainingSec = (int) GetActiveRoundTimer()->GetTimeRemaining();
		CTF_GameStats.m_passtimeStats.summary.nScoreBlue = GetGlobalTFTeam( TF_TEAM_BLUE )->GetFlagCaptures();
		CTF_GameStats.m_passtimeStats.summary.nScoreRed = GetGlobalTFTeam( TF_TEAM_RED )->GetFlagCaptures();

		// stats reporting happens as a result of BaseClass::SetWinningTeam, but we need to make sure to
		// update ball carry data before stats are reported.
		// FIXME: refactor this so we're not calling it just for its side effects :/
		CPasstimeBall *pBall = g_pPasstimeLogic->GetBall();
		if ( pBall )
		{
			pBall->SetStateOutOfPlay();
		}
	}

	CTeamplayRoundBasedRules::SetWinningTeam( team, iWinReason, bForceMapReset, bSwitchTeams, bDontAddScore, bFinal );

	if ( IsCompetitiveMode() )
	{
		HaveAllPlayersSpeakConceptIfAllowed( IsGameOver() ? MP_CONCEPT_MATCH_OVER_COMP : MP_CONCEPT_GAME_OVER_COMP );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetStalemate( int iReason, bool bForceMapReset /* = true */, bool bSwitchTeams /* = false */ )
{
	DuelMiniGame_AssignWinners();

	if ( IsPasstimeMode() )
	{
		CTF_GameStats.m_passtimeStats.summary.bStalemate = true;
		CTF_GameStats.m_passtimeStats.summary.bSuddenDeath = mp_stalemate_enable.GetBool();
		CTF_GameStats.m_passtimeStats.summary.bMeleeOnlySuddenDeath = mp_stalemate_meleeonly.GetBool();
	}

	BaseClass::SetStalemate( iReason, bForceMapReset, bSwitchTeams );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTFGameRules::GetPreMatchEndTime() const
{
	//TFTODO: implement this.
	return gpGlobals->curtime;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::GoToIntermission( void )
{
	// Tell the clients to recalculate the holiday
	IGameEvent *event = gameeventmanager->CreateEvent( "recalculate_holidays" );
	if ( event )
	{
		gameeventmanager->FireEvent( event );
	}

	UTIL_CalculateHolidays();

	BaseClass::GoToIntermission();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::RecalculateTruce( void )
{
	bool bTruceActive = false;

	// Call a truce if the teams are fighting a Halloween boss
	if ( IsHolidayActive( kHoliday_Halloween ) )
	{
		if ( ( IMerasmusAutoList::AutoList().Count() > 0 ) || ( IEyeballBossAutoList::AutoList().Count() > 0 ) )
		{
			bool bHaveActiveBoss = false;

			for ( int i = 0; i < IMerasmusAutoList::AutoList().Count(); ++i )
			{
				CMerasmus *pBoss = static_cast< CMerasmus* >( IMerasmusAutoList::AutoList()[i] );
				if ( !pBoss->IsMarkedForDeletion() )
				{
					bHaveActiveBoss = true;
				}
			}

			for ( int i = 0; i < IEyeballBossAutoList::AutoList().Count(); ++i )
			{
				CEyeballBoss *pBoss = static_cast< CEyeballBoss* >( IEyeballBossAutoList::AutoList()[i] );
				if ( !pBoss->IsMarkedForDeletion() )
				{
					if ( ( pBoss->GetTeamNumber() != TF_TEAM_RED ) && ( pBoss->GetTeamNumber() != TF_TEAM_BLUE ) )
					{
						bHaveActiveBoss = true;
					}
				}
			}

			if ( bHaveActiveBoss && ( IsValveMap() || tf_halloween_allow_truce_during_boss_event.GetBool() || IsMapForcedTruceDuringBossFight() ) )
			{
				bTruceActive = true;
			}
		}
	}

#ifdef STAGING_ONLY
	if ( tf_truce.GetBool() )
	{
		bTruceActive = true;
	}
#endif

	if ( m_bTruceActive != bTruceActive )
	{
		m_bTruceActive.Set( bTruceActive );

		CReliableBroadcastRecipientFilter filter;
		if ( m_bTruceActive )
		{
			SendHudNotification( filter, HUD_NOTIFY_TRUCE_START, true );
			if ( m_hGamerulesProxy )
			{
				m_hGamerulesProxy->TruceStart();
			}
		}
		else
		{
			SendHudNotification( filter, HUD_NOTIFY_TRUCE_END, true );
			if ( m_hGamerulesProxy )
			{
				m_hGamerulesProxy->TruceEnd();
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::FPlayerCanTakeDamage( CBasePlayer *pPlayer, CBaseEntity *pAttacker, const CTakeDamageInfo &info )
{
	// guard against NULL pointers if players disconnect
	if ( !pPlayer || !pAttacker )
		return false;

	if ( IsTruceActive() && ( pPlayer != pAttacker ) && ( pPlayer->GetTeamNumber() != pAttacker->GetTeamNumber() ) )
	{
		if ( ( ( pAttacker->GetTeamNumber() == TF_TEAM_RED ) && ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE ) ) || ( ( pAttacker->GetTeamNumber() == TF_TEAM_BLUE ) && ( pPlayer->GetTeamNumber() == TF_TEAM_RED ) ) )
		{
			CBaseEntity *pInflictor = info.GetInflictor();
			if ( pInflictor )
			{
				return !( pInflictor->IsTruceValidForEnt() || pAttacker->IsTruceValidForEnt() );
			}
			else
			{
				return !pAttacker->IsTruceValidForEnt();
			}
		}
	}

	// if pAttacker is an object, we can only do damage if pPlayer is our builder
	if ( pAttacker->IsBaseObject() )
	{
		CBaseObject *pObj = ( CBaseObject *)pAttacker;

		if ( pObj->GetBuilder() == pPlayer || pPlayer->GetTeamNumber() != pObj->GetTeamNumber() )
		{
			// Builder and enemies
			return true;
		}
		else
		{
			// Teammates of the builder
			return false;
		}
	}

	// prevent eyeball rockets from hurting teammates if it's a spell
	if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_MONOCULUS && pAttacker->GetTeamNumber() == pPlayer->GetTeamNumber() )
	{
		return false;
	}

	// in PvE modes, if entities are on the same team, they can't hurt each other
	// this is needed since not all entities will be players
	if ( IsPVEModeActive() && 
			pPlayer->GetTeamNumber() == pAttacker->GetTeamNumber() && 
			pPlayer != pAttacker && 
			!info.IsForceFriendlyFire() )
	{
		return false;
	}

	return BaseClass::FPlayerCanTakeDamage( pPlayer, pAttacker, info );
}

Vector DropToGround( 
	CBaseEntity *pMainEnt,
	const Vector &vPos, 
	const Vector &vMins, 
	const Vector &vMaxs )
{
	trace_t trace;
	UTIL_TraceHull( vPos, vPos + Vector( 0, 0, -500 ), vMins, vMaxs, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace );
	return trace.endpos;
}


void TestSpawnPointType( const char *pEntClassName )
{
	// Find the next spawn spot.
	CBaseEntity *pSpot = gEntList.FindEntityByClassname( NULL, pEntClassName );

	while( pSpot )
	{
		// trace a box here
		Vector vTestMins = pSpot->GetAbsOrigin() + VEC_HULL_MIN;
		Vector vTestMaxs = pSpot->GetAbsOrigin() + VEC_HULL_MAX;

		if ( UTIL_IsSpaceEmpty( pSpot, vTestMins, vTestMaxs ) )
		{
			// the successful spawn point's location
			NDebugOverlay::Box( pSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 0, 255, 0, 100, 60 );

			// drop down to ground
			Vector GroundPos = DropToGround( NULL, pSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX );

			// the location the player will spawn at
			NDebugOverlay::Box( GroundPos, VEC_HULL_MIN, VEC_HULL_MAX, 0, 0, 255, 100, 60 );

			// draw the spawn angles
			QAngle spotAngles = pSpot->GetLocalAngles();
			Vector vecForward;
			AngleVectors( spotAngles, &vecForward );
			NDebugOverlay::HorzArrow( pSpot->GetAbsOrigin(), pSpot->GetAbsOrigin() + vecForward * 32, 10, 255, 0, 0, 255, true, 60 );
		}
		else
		{
			// failed spawn point location
			NDebugOverlay::Box( pSpot->GetAbsOrigin(), VEC_HULL_MIN, VEC_HULL_MAX, 255, 0, 0, 100, 60 );
		}

		// increment pSpot
		pSpot = gEntList.FindEntityByClassname( pSpot, pEntClassName );
	}
}

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

void TestSpawns()
{
	TestSpawnPointType( "info_player_teamspawn" );
}
ConCommand cc_TestSpawns( "map_showspawnpoints", TestSpawns, "Dev - test the spawn points, draws for 60 seconds", FCVAR_CHEAT );


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

void cc_ShowRespawnTimes()
{
	CTFGameRules *pRules = TFGameRules();
	CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() );

	if ( pRules && pPlayer )
	{
		float flRedMin = ( pRules->m_TeamRespawnWaveTimes[TF_TEAM_RED] >= 0 ? pRules->m_TeamRespawnWaveTimes[TF_TEAM_RED] : mp_respawnwavetime.GetFloat() );
		float flRedScalar = pRules->GetRespawnTimeScalar( TF_TEAM_RED );
		float flNextRedRespawn = pRules->GetNextRespawnWave( TF_TEAM_RED, NULL ) - gpGlobals->curtime;

		float flBlueMin = ( pRules->m_TeamRespawnWaveTimes[TF_TEAM_BLUE] >= 0 ? pRules->m_TeamRespawnWaveTimes[TF_TEAM_BLUE] : mp_respawnwavetime.GetFloat() );
		float flBlueScalar = pRules->GetRespawnTimeScalar( TF_TEAM_BLUE );
		float flNextBlueRespawn = pRules->GetNextRespawnWave( TF_TEAM_BLUE, NULL ) - gpGlobals->curtime;

		char tempRed[128];
		Q_snprintf( tempRed, sizeof( tempRed ),   "Red:  Min Spawn %2.2f, Scalar %2.2f, Next Spawn In: %.2f\n", flRedMin, flRedScalar, flNextRedRespawn );

		char tempBlue[128];
		Q_snprintf( tempBlue, sizeof( tempBlue ), "Blue: Min Spawn %2.2f, Scalar %2.2f, Next Spawn In: %.2f\n", flBlueMin, flBlueScalar, flNextBlueRespawn );

		ClientPrint( pPlayer, HUD_PRINTTALK, tempRed );
		ClientPrint( pPlayer, HUD_PRINTTALK, tempBlue );
	}
}

ConCommand mp_showrespawntimes( "mp_showrespawntimes", cc_ShowRespawnTimes, "Show the min respawn times for the teams", FCVAR_CHEAT );


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CBaseEntity *CTFGameRules::GetPlayerSpawnSpot( CBasePlayer *pPlayer )
{
	CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
	if ( IsInItemTestingMode() && pTFPlayer->m_bItemTestingRespawn )
	{
		pTFPlayer->m_bItemTestingRespawn = false;
		return NULL;
	}

	// get valid spawn point
	CBaseEntity *pSpawnSpot = pPlayer->EntSelectSpawnPoint();

	// drop down to ground
	Vector GroundPos = DropToGround( pPlayer, pSpawnSpot->GetAbsOrigin(), VEC_HULL_MIN_SCALED( pTFPlayer ), VEC_HULL_MAX_SCALED( pTFPlayer ) );

	// Move the player to the place it said.
	pPlayer->SetLocalOrigin( GroundPos + Vector(0,0,1) );
	pPlayer->SetAbsVelocity( vec3_origin );
	pPlayer->SetLocalAngles( pSpawnSpot->GetLocalAngles() );
	pPlayer->m_Local.m_vecPunchAngle = vec3_angle;
	pPlayer->m_Local.m_vecPunchAngleVel = vec3_angle;
	pPlayer->SnapEyeAngles( pSpawnSpot->GetLocalAngles() );

	return pSpawnSpot;
}

//-----------------------------------------------------------------------------
// Purpose: Checks to see if the player is on the correct team and whether or
//          not the spawn point is available.
//-----------------------------------------------------------------------------
bool CTFGameRules::IsSpawnPointValid( CBaseEntity *pSpot, CBasePlayer *pPlayer, bool bIgnorePlayers, PlayerTeamSpawnMode_t nSpawnMode /* = 0*/ )
{
	bool bMatchSummary = ShowMatchSummary();

	// Check the team.
	// In Item Testing mode, bots all use the Red team spawns, and the player uses Blue
	if ( IsInItemTestingMode() )
	{
		if ( pSpot->GetTeamNumber() != (pPlayer->IsFakeClient() ? TF_TEAM_RED : TF_TEAM_BLUE) )
			return false;
	}
	else
	{
		if ( !bMatchSummary )
		{
			if ( pSpot->GetTeamNumber() != pPlayer->GetTeamNumber() )
				return false;
		}
	}

	if ( !pSpot->IsTriggered( pPlayer ) )
		return false;

	CTFTeamSpawn *pCTFSpawn = dynamic_cast<CTFTeamSpawn*>( pSpot );
	if ( pCTFSpawn )
	{
		if ( pCTFSpawn->IsDisabled() )
			return false;

		if ( pCTFSpawn->GetTeamSpawnMode() && pCTFSpawn->GetTeamSpawnMode() != nSpawnMode )
			return false;

		if ( bMatchSummary )
		{
			if ( pCTFSpawn->AlreadyUsedForMatchSummary() )
				return false; 

			if ( pCTFSpawn->GetMatchSummaryType() == PlayerTeamSpawn_MatchSummary_Winner )
			{
				if ( pPlayer->GetTeamNumber() != GetWinningTeam() )
					return false;
			}
			else if ( pCTFSpawn->GetMatchSummaryType() == PlayerTeamSpawn_MatchSummary_Loser )
			{
				if ( pPlayer->GetTeamNumber() == GetWinningTeam() )
					return false;
			}
			else
			{
				return false;
			}
		}
		else
		{
			if ( pCTFSpawn->GetMatchSummaryType() != PlayerTeamSpawn_MatchSummary_None )
				return false;
		}
	}

	Vector mins = VEC_HULL_MIN_SCALED( pPlayer );
	Vector maxs = VEC_HULL_MAX_SCALED( pPlayer );

	if ( !bIgnorePlayers && !bMatchSummary )
	{
		Vector vTestMins = pSpot->GetAbsOrigin() + mins;
		Vector vTestMaxs = pSpot->GetAbsOrigin() + maxs;
		return UTIL_IsSpaceEmpty( pPlayer, vTestMins, vTestMaxs );
	}

	trace_t trace;
	UTIL_TraceHull( pSpot->GetAbsOrigin(), pSpot->GetAbsOrigin(), mins, maxs, MASK_PLAYERSOLID, pPlayer, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
	if ( trace.fraction == 1 && trace.allsolid != 1 && (trace.startsolid != 1) )
	{
		if ( bMatchSummary )
		{
			if ( pCTFSpawn )
			{
				pCTFSpawn->SetAlreadyUsedForMatchSummary();
			}
		}

		return true;
	}

	return false;
}

Vector CTFGameRules::VecItemRespawnSpot( CItem *pItem )
{
	return pItem->GetOriginalSpawnOrigin();
}

QAngle CTFGameRules::VecItemRespawnAngles( CItem *pItem )
{
	return pItem->GetOriginalSpawnAngles();
}

int CTFGameRules::ItemShouldRespawn( CItem *pItem )
{
	return BaseClass::ItemShouldRespawn( pItem );
}

float CTFGameRules::FlItemRespawnTime( CItem *pItem )
{
	return ITEM_RESPAWN_TIME;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CTFGameRules::GetChatFormat( bool bTeamOnly, CBasePlayer *pPlayer )
{
	if ( !pPlayer )  // dedicated server output
	{
		return NULL;
	}

	const char *pszFormat = NULL;

	// coach?
	CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
	if ( pTFPlayer && pTFPlayer->IsCoaching() )
	{
		pszFormat = "TF_Chat_Coach";
	}
	// team only
	else if ( bTeamOnly == true )
	{
		if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR )
		{
			pszFormat = "TF_Chat_Spec";
		}
		else
		{
			if ( pPlayer->IsAlive() == false && State_Get() != GR_STATE_TEAM_WIN )
			{
				pszFormat = "TF_Chat_Team_Dead";
			}
			else
			{
				const char *chatLocation = GetChatLocation( bTeamOnly, pPlayer );
				if ( chatLocation && *chatLocation )
				{
					pszFormat = "TF_Chat_Team_Loc";
				}
				else
				{
					pszFormat = "TF_Chat_Team";
				}
			}
		}
	}
	// everyone
	else
	{	
		if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR )
		{
			pszFormat = "TF_Chat_AllSpec";	
		}
		else
		{
			if ( pPlayer->IsAlive() == false && State_Get() != GR_STATE_TEAM_WIN )
			{
				pszFormat = "TF_Chat_AllDead";
			}
			else
			{
				pszFormat = "TF_Chat_All";	
			}
		}
	}

	return pszFormat;
}

VoiceCommandMenuItem_t *CTFGameRules::VoiceCommand( CBaseMultiplayerPlayer *pPlayer, int iMenu, int iItem )
{
	CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
	if ( pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
	{
		engine->ClientCommand( pTFPlayer->edict(), "boo" );
		return NULL;
	}

	VoiceCommandMenuItem_t *pItem = BaseClass::VoiceCommand( pPlayer, iMenu, iItem );

	if ( pItem )
	{
		int iActivity = ActivityList_IndexForName( pItem->m_szGestureActivity );

		if ( iActivity != ACT_INVALID )
		{
			if ( pTFPlayer )
			{
				pTFPlayer->DoAnimationEvent( PLAYERANIMEVENT_VOICE_COMMAND_GESTURE, iActivity );

				// Note when we call for a Medic.
				// Hardcoding this for menu 0, item 0 is an ugly hack, but we don't have a good way to 
				// translate this at this level without plumbing a through bunch of stuff (MSB)
				if ( iMenu == 0 && iItem == 0 )
				{
					pTFPlayer->NoteMedicCall();
				}
			}
		}
	}

	return pItem;
}

//-----------------------------------------------------------------------------
// Purpose: Actually change a player's name.  
//-----------------------------------------------------------------------------
void CTFGameRules::ChangePlayerName( CTFPlayer *pPlayer, const char *pszNewName )
{
	const char *pszOldName = pPlayer->GetPlayerName();

	// Check if they can change their name
	// don't show when bots change their names in PvE mode
	if ( State_Get() != GR_STATE_STALEMATE && !( IsPVEModeActive() && pPlayer->IsBot() ) )
	{
		CReliableBroadcastRecipientFilter filter;
		UTIL_SayText2Filter( filter, pPlayer, false, "#TF_Name_Change", pszOldName, pszNewName );

		IGameEvent * event = gameeventmanager->CreateEvent( "player_changename" );
		if ( event )
		{
			event->SetInt( "userid", pPlayer->GetUserID() );
			event->SetString( "oldname", pszOldName );
			event->SetString( "newname", pszNewName );
			gameeventmanager->FireEvent( event );
		}
	}

	pPlayer->SetPlayerName( pszNewName );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::ClientSettingsChanged( CBasePlayer *pPlayer )
{
	const char *pszName = engine->GetClientConVarValue( pPlayer->entindex(), "name" );

	const char *pszOldName = pPlayer->GetPlayerName();

	CTFPlayer *pTFPlayer = (CTFPlayer*)pPlayer;

	// msg everyone if someone changes their name,  and it isn't the first time (changing no name to current name)
	// Note, not using FStrEq so that this is case sensitive
	if ( pszOldName[0] != 0 && Q_strncmp( pszOldName, pszName, MAX_PLAYER_NAME_LENGTH-1 ) )		
	{
		ChangePlayerName( pTFPlayer, pszName );
	}

	// keep track of their hud_classautokill value
	int nClassAutoKill = Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "hud_classautokill" ) );
	pTFPlayer->SetHudClassAutoKill( nClassAutoKill > 0 ? true : false );

	// keep track of their tf_medigun_autoheal value
	pTFPlayer->SetMedigunAutoHeal( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "tf_medigun_autoheal" ) ) > 0 );

	// keep track of their cl_autorezoom value
	pTFPlayer->SetAutoRezoom( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "cl_autorezoom" ) ) > 0 );
	pTFPlayer->SetAutoReload( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "cl_autoreload" ) ) > 0 );

	// keep track of their tf_remember_lastswitched value
	pTFPlayer->SetRememberActiveWeapon( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "tf_remember_activeweapon" ) ) > 0 );
	pTFPlayer->SetRememberLastWeapon( Q_atoi( engine->GetClientConVarValue( pPlayer->entindex(), "tf_remember_lastswitched" ) ) > 0 );

	const char *pszFov = engine->GetClientConVarValue( pPlayer->entindex(), "fov_desired" );
	int iFov = atoi(pszFov);
	iFov = clamp( iFov, 75, MAX_FOV );

	pTFPlayer->SetDefaultFOV( iFov );

	pTFPlayer->m_bFlipViewModels = Q_strcmp( engine->GetClientConVarValue( pPlayer->entindex(), "cl_flipviewmodels" ), "1" ) == 0;
}

//-----------------------------------------------------------------------------
// Purpose: Return true if the specified player can carry any more of the ammo type
//-----------------------------------------------------------------------------
bool CTFGameRules::CanHaveAmmo( CBaseCombatCharacter *pPlayer, int iAmmoIndex )
{
	if ( iAmmoIndex > -1 )
	{
		CTFPlayer *pTFPlayer = (CTFPlayer*)pPlayer;

		if ( pTFPlayer )
		{
			// Get the max carrying capacity for this ammo
			int iMaxCarry = pTFPlayer->GetMaxAmmo(iAmmoIndex);

			// Does the player have room for more of this type of ammo?
			if ( pTFPlayer->GetAmmoCount( iAmmoIndex ) < iMaxCarry )
				return true;
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool EconEntity_KillEaterEventPassesRestrictionCheck( const IEconItemInterface *pEconInterface, const CEconItemAttributeDefinition *pRestrictionAttribDef, const CEconItemAttributeDefinition *pRestrictionValueAttribDef, const CSteamID VictimSteamID )
{
	uint32 unRestrictionType = kStrangeEventRestriction_None;
	attrib_value_t unRestrictionValue;
	DbgVerify( pEconInterface->FindAttribute( pRestrictionAttribDef, &unRestrictionType ) ==
			   pEconInterface->FindAttribute( pRestrictionValueAttribDef, &unRestrictionValue ) );

	switch (unRestrictionType)
	{
	case kStrangeEventRestriction_None:
		return true;

	case kStrangeEventRestriction_Map:
	{
		const MapDef_t *pMap = GetItemSchema()->GetMasterMapDefByName(STRING(gpGlobals->mapname));
		return pMap && pMap->m_nDefIndex == unRestrictionValue;
	}
	case kStrangeEventRestriction_VictimSteamAccount:
		return VictimSteamID.GetAccountID() == unRestrictionValue;
	case kStrangeEventRestriction_Competitive:
	{
		if ( TFGameRules() && TFGameRules()->IsMatchTypeCompetitive() )
		{
			// Match Season unRestrictionValue == Season Number
			return true;
		}
		return false;
	}
	} // end Switch

	AssertMsg1( false, "Unhandled strange event restriction %u!", unRestrictionType );
	return false;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static CSteamID GetSteamIDForKillEaterScoring( CTFPlayer *pPlayer )
{
	if ( pPlayer->IsBot() )
		return k_steamIDNil;

	CSteamID ret;
	if ( !pPlayer->GetSteamID( &ret ) )
		return k_steamIDNil;

	return ret;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CStrangeEventValidator
{
public:
	CStrangeEventValidator( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType )
		: m_unItemID( INVALID_ITEM_ID )
		, m_eEventType( eEventType )
	{
		m_bIsValid = BInitEventParams( pEconEntity, pOwner, pVictim );
	}

	bool BIsValidEvent() const { return m_bIsValid; }
	CSteamID GetKillerSteamID() const { Assert( m_bIsValid ); return m_KillerSteamID; }
	CSteamID GetVictimSteamID() const { Assert( m_bIsValid ); return m_VictimSteamID; }
	itemid_t GetItemID() const { Assert( m_bIsValid ); return m_unItemID; }
	kill_eater_event_t GetEventType() const { Assert( m_bIsValid ); return m_eEventType; }

private:
	bool BInitEventParams( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim )
	{
		static CSchemaAttributeDefHandle pAttrDef_KillEater( "kill eater" );

		// Kill-eater weapons.
		if ( !pEconEntity )
			return false;

		if ( !pOwner )
			return false;

		if ( !pVictim )
			return false;

		// Ignore events where we're affecting ourself.
		if ( pOwner == pVictim )
			return false;

		// Store off our item ID for reference post-init.
		m_unItemID = pEconEntity->GetID();

		// Always require that we have at least the base kill eater attribute before sending any messages
		// to the GC.
		if ( !pEconEntity->FindAttribute( pAttrDef_KillEater ) )
			return false;

		// Don't bother sending a message to the GC if either party is a bot, unless we're tracking events against
		// bots specifically.
		if ( !pOwner->GetSteamID( &m_KillerSteamID ) )
			return false;
	
		m_VictimSteamID = GetSteamIDForKillEaterScoring( pVictim );
		if ( !m_VictimSteamID.IsValid() )
		{
			if ( !GetItemSchema()->GetKillEaterScoreTypeAllowsBotVictims( m_eEventType ) )
				return false;
		}

		// Also require that we have whatever event type we're looking for, unless we're looking for regular
		// player kills in which case we may or may not have a field to describe that.
		for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
		{
			const CEconItemAttributeDefinition *pScoreAttribDef = GetKillEaterAttr_Score(i);
			if ( !pScoreAttribDef )
				continue;

			// If we don't have this attribute, move on. It's possible to be missing this attribute but still
			// have the next one in the list if we have user-customized tracking types.
			if ( !pEconEntity->FindAttribute( pScoreAttribDef ) )
				continue;
		
			const CEconItemAttributeDefinition *pScoreTypeAttribDef = GetKillEaterAttr_Type(i);
			if ( !pScoreTypeAttribDef )
				continue;
		
			// If we're missing our type attribute, we interpret that as "track kills" -- none of the original
			// kill eaters have score type attributes.
			float fKillEaterEventType;
			kill_eater_event_t eMatchEvent = FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pEconEntity, pScoreTypeAttribDef, &fKillEaterEventType )
										   ? (kill_eater_event_t)(int)fKillEaterEventType
										   : kKillEaterEvent_PlayerKill;

			if ( m_eEventType == eMatchEvent )
			{
				// Does this attribute also specify a restriction (ie., "has to be on this specific map" or "has to be
				// against this specific account"? If so, only count this as a match if the restriction check passes.
				if ( EconEntity_KillEaterEventPassesRestrictionCheck( pEconEntity, GetKillEaterAttr_Restriction(i), GetKillEaterAttr_RestrictionValue(i), m_VictimSteamID ) )
					return true;
			}
		}

		return false;
	}

private:
	bool m_bIsValid;
	CSteamID m_KillerSteamID;
	CSteamID m_VictimSteamID;
	itemid_t m_unItemID;
	kill_eater_event_t m_eEventType;
};

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
template < typename tMsgType >
static void FillOutBaseKillEaterMessage( tMsgType *out_pMsg, const CStrangeEventValidator& Validator )
{
	Assert( out_pMsg );
	Assert( Validator.BIsValidEvent() );

	out_pMsg->set_killer_steam_id( Validator.GetKillerSteamID().ConvertToUint64() );
	out_pMsg->set_victim_steam_id( Validator.GetVictimSteamID().ConvertToUint64() );
	out_pMsg->set_item_id( Validator.GetItemID() );
	out_pMsg->set_event_type( Validator.GetEventType() );
}

//-----------------------------------------------------------------------------
// Purpose: Get the actual killeater weapon from a CTakeDamageInfo
//-----------------------------------------------------------------------------
CTFWeaponBase *GetKilleaterWeaponFromDamageInfo( const CTakeDamageInfo *pInfo )
{
	CTFWeaponBase *pTFWeapon = dynamic_cast<CTFWeaponBase *>( pInfo->GetWeapon() );
	CBaseEntity* pInflictor = pInfo->GetInflictor();

	// If there's no weapon specified, it might have been from a sentry
	if ( !pTFWeapon )
	{
		// If a sentry did the damage with bullets, it's the inflictor
		CObjectSentrygun *pSentrygun = dynamic_cast<CObjectSentrygun *>( pInflictor );
		if ( !pSentrygun )
		{
			// If a sentry's rocket did the damage, then the rocket is the inflictor, and the sentry is the rocket's owner
			pSentrygun = pInflictor ? dynamic_cast<CObjectSentrygun *>( pInflictor->GetOwnerEntity() ) : NULL;
		}

		if ( pSentrygun )
		{
			// Maybe they were using a Wrangler?  The builder is the player who owns the sentry
			CTFPlayer *pBuilder = pSentrygun->GetBuilder();
			if ( pBuilder )
			{
				// Check if they have a Wrangler and were aiming with it
				CTFLaserPointer* pLaserPointer = dynamic_cast< CTFLaserPointer * >( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_SECONDARY ) );
				if ( pLaserPointer && pLaserPointer->HasLaserDot() )
				{
					pTFWeapon =  pLaserPointer;
				}
			}
		}
	}

	// need to check for deflected projectiles so the weapon that did the most recent
	// deflection will get the killeater credit instead of the original launcher
	if ( pInflictor )
	{
		CTFWeaponBaseGrenadeProj *pBaseGrenade = dynamic_cast< CTFWeaponBaseGrenadeProj* >( pInflictor );
		if ( pBaseGrenade )
		{
			if ( pBaseGrenade->GetDeflected() && pBaseGrenade->GetLauncher() )
			{
				pTFWeapon = dynamic_cast< CTFWeaponBase* >( pBaseGrenade->GetLauncher() );
			}
		}
		else
		{
			CTFBaseRocket *pRocket = dynamic_cast< CTFBaseRocket* >( pInflictor );
			if ( pRocket )
			{
				if ( pRocket->GetDeflected() && pRocket->GetLauncher() )
				{
					pTFWeapon = dynamic_cast< CTFWeaponBase* >( pRocket->GetLauncher() );
				}
			}
		}
	}

	return pTFWeapon;
}

//-----------------------------------------------------------------------------
void EconEntity_ValidateAndSendStrangeMessageToGC( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
	CStrangeEventValidator Validator( pEconEntity, pOwner, pVictim, eEventType );

	if ( !Validator.BIsValidEvent() )
		return;

	GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute> msg( k_EMsgGC_IncrementKillCountAttribute );
	FillOutBaseKillEaterMessage( &msg.Body(), Validator );

	if ( nIncrementValue != 1 )
	{
		msg.Body().set_increment_value( nIncrementValue );
	}

	GCClientSystem()->BSendMessage( msg );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void EconEntity_OnOwnerKillEaterEvent( CEconEntity *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
	if ( !pEconEntity )
		return;

	EconItemInterface_OnOwnerKillEaterEvent( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue );
}
//-----------------------------------------------------------------------------
void EconItemInterface_OnOwnerKillEaterEvent( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
	bool bEconEntityHandled = false;

	// Fire the kill eater event on all wearables
	// Wearables can have all Strange parts
	for ( int i = 0; i < pOwner->GetNumWearables(); ++i )
	{
		CTFWearable *pWearableItem = dynamic_cast<CTFWearable *>( pOwner->GetWearable( i ) );
		if ( !pWearableItem )
			continue;

		if ( !pWearableItem->GetAttributeContainer() )
			continue;

		EconEntity_ValidateAndSendStrangeMessageToGC( pWearableItem->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue );

		if ( pWearableItem->GetAttributeContainer()->GetItem() == pEconEntity )
		{
			bEconEntityHandled = true;
		}
	}

	if ( !bEconEntityHandled )
	{
		EconEntity_ValidateAndSendStrangeMessageToGC( pEconEntity, pOwner, pVictim, eEventType, nIncrementValue );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void EconEntity_OnOwnerKillEaterEventNoPartner( CEconEntity *pEconEntity, CTFPlayer *pOwner, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
	if ( !pEconEntity )
		return;

	EconItemInterface_OnOwnerKillEaterEventNoPartner( pEconEntity->GetAttributeContainer()->GetItem(), pOwner,  eEventType, nIncrementValue );
}
//-----------------------------------------------------------------------------
void EconItemInterface_OnOwnerKillEaterEventNoPartner( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
	// Look for another player to pass in. We do two passes over the list of candidates.
	// First we look for anyone that we know is a real player. If we don't find any of
	// those then we pass in a known bot. This means that things that allow bots will
	// still find one and work, but event types that don't allow bots won't be dependent
	// on the order of players in the list.
	for( int iPass = 1; iPass <= 2; iPass++ )
	{
		for( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
		{
			CTFPlayer *pOtherPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
			if ( !pOtherPlayer )
				continue;

			// Ignore ourself.
			if ( pOtherPlayer == pOwner )
				continue;

		
			const bool bCandidatePasses = (iPass == 1 && GetSteamIDForKillEaterScoring( pOtherPlayer ).IsValid())	// if we have a real Steam ID we're golden
									   || (iPass == 2);																// or if we made it to the second pass, any valid player pointer is as good as any other
			if ( bCandidatePasses )
			{
				EconItemInterface_OnOwnerKillEaterEvent( pEconEntity, pOwner, pOtherPlayer, eEventType, nIncrementValue );
				return;
			}
		}
	}

	// We couldn't find anyone else at all. This is hard. Let's give up.
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute_Multiple> *s_pmsgIncrementKillCountMessageBatch = NULL;
//-----------------------------------------------------------------------------
void EconEntity_ValidateAndSendStrangeMessageToGC_Batched( IEconItemInterface *pEconInterface, class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
	CStrangeEventValidator Validator( pEconInterface, pOwner, pVictim, eEventType );

	if ( !Validator.BIsValidEvent() )
		return;

	// This has to be dynamically allocated because we can't static-init a protobuf message at startup type.
	if ( !s_pmsgIncrementKillCountMessageBatch )
	{
		s_pmsgIncrementKillCountMessageBatch = new GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute_Multiple>( k_EMsgGC_IncrementKillCountAttribute_Multiple );
	}

	// Look for an existing message that matches this user and this event.
	for ( int i = 0; i < s_pmsgIncrementKillCountMessageBatch->Body().msgs_size(); i++ )
	{
		CMsgIncrementKillCountAttribute *pMsg = s_pmsgIncrementKillCountMessageBatch->Body().mutable_msgs( i );
		Assert( pMsg );

		if ( pMsg->killer_steam_id() == Validator.GetKillerSteamID().ConvertToUint64() &&
			pMsg->victim_steam_id() == Validator.GetVictimSteamID().ConvertToUint64() &&
			pMsg->item_id() == Validator.GetItemID() &&
			(kill_eater_event_t)pMsg->event_type() == Validator.GetEventType() )
		{
			// We found an existing entry for this message. All we want to do is add to the stat we're tracking
			// but still send up this single message.
			Assert( pMsg->has_increment_value() );

			pMsg->set_increment_value( pMsg->increment_value() + nIncrementValue );
			return;
		}
	}

	// We don't have an existing entry, so make a new one.
	CMsgIncrementKillCountAttribute *pNewMsg = s_pmsgIncrementKillCountMessageBatch->Body().add_msgs();

	FillOutBaseKillEaterMessage( pNewMsg, Validator );
	pNewMsg->set_increment_value( nIncrementValue );
}
//-----------------------------------------------------------------------------
void EconEntity_OnOwnerKillEaterEvent_Batched( CEconEntity *pEconEntity, class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
	if ( !pEconEntity )
		return;

	EconItemInterface_OnOwnerKillEaterEvent_Batched( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue );
}
//-----------------------------------------------------------------------------
void EconItemInterface_OnOwnerKillEaterEvent_Batched( IEconItemInterface *pEconInterface, class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue /*= 1*/ )
{
	for ( int i = 0; i < pOwner->GetNumWearables(); ++i )
	{
		CTFWearable *pWearableItem = dynamic_cast<CTFWearable *>( pOwner->GetWearable( i ) );
		if ( !pWearableItem )
			continue;

		if ( !pWearableItem->GetAttributeContainer() )
			continue;

		CEconItemView *pEconItemView = pWearableItem->GetAttributeContainer()->GetItem();
		if ( !pEconItemView )
			continue;

		EconEntity_ValidateAndSendStrangeMessageToGC_Batched( pWearableItem->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType, nIncrementValue );
	}

	EconEntity_ValidateAndSendStrangeMessageToGC_Batched( pEconInterface, pOwner, pVictim, eEventType, nIncrementValue );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void KillEaterEvents_FlushBatches()
{
	if ( s_pmsgIncrementKillCountMessageBatch )
	{
		Assert( s_pmsgIncrementKillCountMessageBatch->Body().msgs_size() > 0 );

		GCClientSystem()->BSendMessage( *s_pmsgIncrementKillCountMessageBatch );

		delete s_pmsgIncrementKillCountMessageBatch;
		s_pmsgIncrementKillCountMessageBatch = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void HatAndMiscEconEntities_OnOwnerKillEaterEventNoParter( class CTFPlayer *pOwner, kill_eater_event_t eEventType, int nIncrementValue )
{
	EconItemInterface_OnOwnerKillEaterEventNoPartner( NULL, pOwner, eEventType, nIncrementValue );
}

//-----------------------------------------------------------------------------
void HatAndMiscEconEntities_OnOwnerKillEaterEvent( class CTFPlayer *pOwner, class CTFPlayer *pVictim, kill_eater_event_t eEventType, int nIncrementValue )
{
	EconItemInterface_OnOwnerKillEaterEvent( NULL, pOwner, pVictim, eEventType, nIncrementValue );
}

//-----------------------------------------------------------------------------
void EconEntity_OnOwnerUniqueEconEvent( IEconItemInterface *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType )
{
	CStrangeEventValidator Validator( pEconEntity, pOwner, pVictim, eEventType );

	if ( !Validator.BIsValidEvent() )
		return;

	GCSDK::CProtoBufMsg<CMsgTrackUniquePlayerPairEvent> msg( k_EMsgGC_TrackUniquePlayerPairEvent );
	FillOutBaseKillEaterMessage( &msg.Body(), Validator );

	GCClientSystem()->BSendMessage( msg );
}

//-----------------------------------------------------------------------------
void EconEntity_OnOwnerUniqueEconEvent( CEconEntity *pEconEntity, CTFPlayer *pOwner, CTFPlayer *pVictim, kill_eater_event_t eEventType )
{
	if ( !pEconEntity )
		return;
	EconEntity_OnOwnerUniqueEconEvent( pEconEntity->GetAttributeContainer()->GetItem(), pOwner, pVictim, eEventType );
}

//-----------------------------------------------------------------------------
void EconEntity_NonEquippedItemKillTracking( CTFPlayer *pOwner, CTFPlayer *pVictim, item_definition_index_t iDefIndex, kill_eater_event_t eEventType, int nIncrementValue = 1 )
{
	// Validate
	if ( !pOwner || !pVictim || pOwner == pVictim )
		return;

#ifndef STAGING_ONLY
	if ( pOwner->IsBot() || pVictim->IsBot() )
		return;
#endif

	CSteamID pOwnerSteamID;
	CSteamID pVictimSteamID;
	if ( !pOwner->GetSteamID( &pOwnerSteamID ) || !pVictim->GetSteamID( &pVictimSteamID ) )
		return;
	
	// Current date
	static CSchemaAttributeDefHandle pAttrDef_DeactiveDate( "deactive date" );
	uint32 unCurrentDate = CRTime::RTime32TimeCur();

	CEconItemView *pNonEquippedItem = pOwner->Inventory()->GetFirstItemOfItemDef( iDefIndex, pOwner->Inventory() );
	if ( pNonEquippedItem )
	{
		// Check the date
		uint32 unDeactiveDate = 0;
		if ( !pNonEquippedItem->FindAttribute( pAttrDef_DeactiveDate, &unDeactiveDate ) || unDeactiveDate > unCurrentDate )
		{
			GCSDK::CProtoBufMsg<CMsgIncrementKillCountAttribute> msg( k_EMsgGC_IncrementKillCountAttribute );
			msg.Body().set_killer_steam_id( pOwnerSteamID.ConvertToUint64() );
			msg.Body().set_victim_steam_id( pVictimSteamID.ConvertToUint64() );
			
			if ( nIncrementValue > 1 )
			{
				msg.Body().set_increment_value( nIncrementValue );
			}

			msg.Body().set_item_id( pNonEquippedItem->GetID() );
			msg.Body().set_event_type( eEventType );
			GCClientSystem()->BSendMessage( msg );
		}
	}

}

//-----------------------------------------------------------------------------
void EconEntity_NonEquippedItemKillTracking_NoPartner( CTFPlayer *pOwner, item_definition_index_t iDefIndex, kill_eater_event_t eEventType, int nIncrementValue )
{
	// Find a partner or give up
	for( int iPass = 1; iPass <= 2; iPass++ )
	{
		for( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
		{
			CTFPlayer *pOtherPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
			if ( !pOtherPlayer )
				continue;

			// Ignore ourself.
			if ( pOtherPlayer == pOwner )
				continue;


			const bool bCandidatePasses = (iPass == 1 && GetSteamIDForKillEaterScoring( pOtherPlayer ).IsValid())	// if we have a real Steam ID we're golden
				|| (iPass == 2);																// or if we made it to the second pass, any valid player pointer is as good as any other

			if ( bCandidatePasses )
			{
				EconEntity_NonEquippedItemKillTracking( pOwner, pOtherPlayer, iDefIndex, eEventType, nIncrementValue );
				return;
			}
		}
	}
}

void EconEntity_NonEquippedItemKillTracking_NoPartnerBatched( class CTFPlayer *pOwner, item_definition_index_t iDefIndex, kill_eater_event_t eEventType, int nIncrementValue )
{
	// Find a partner or give up
	for ( int iPass = 1; iPass <= 2; iPass++ )
	{
		for ( int playerIndex = 1; playerIndex <= MAX_PLAYERS; playerIndex++ )
		{
			CTFPlayer *pOtherPlayer = ToTFPlayer( UTIL_PlayerByIndex( playerIndex ) );
			if ( !pOtherPlayer )
				continue;

			// Ignore ourself.
			if ( pOtherPlayer == pOwner )
				continue;


			const bool bCandidatePasses = ( iPass == 1 && GetSteamIDForKillEaterScoring( pOtherPlayer ).IsValid() )	// if we have a real Steam ID we're golden
				|| ( iPass == 2 );																// or if we made it to the second pass, any valid player pointer is as good as any other

			if ( bCandidatePasses )
			{
				// find the item
				// Current date
				static CSchemaAttributeDefHandle pAttrDef_DeactiveDate( "deactive date" );
				uint32 unCurrentDate = CRTime::RTime32TimeCur();

				CEconItemView *pNonEquippedItem = pOwner->Inventory()->GetFirstItemOfItemDef( iDefIndex, pOwner->Inventory() );
				if ( pNonEquippedItem )
				{
					uint32 unDeactiveDate = 0;
					if ( !pNonEquippedItem->FindAttribute( pAttrDef_DeactiveDate, &unDeactiveDate ) || unDeactiveDate > unCurrentDate )
					{
						EconEntity_ValidateAndSendStrangeMessageToGC_Batched( pNonEquippedItem, pOwner, pOtherPlayer, eEventType, nIncrementValue );
					}
				}
				
				return;
			}
		}
	}
}

//-----------------------------------------------------------------------------
// TODO: Remove this call and only use the one above
//-----------------------------------------------------------------------------
void EconEntity_NonEquippedItemKillTracking( CTFPlayer *pOwner, CTFPlayer *pVictim, int nIncrementValue )
{
	// Validate
	if ( !pOwner || !pVictim || pOwner == pVictim )
		return;

	if ( pOwner->IsBot() || pVictim->IsBot() )
		return;

	CSteamID pOwnerSteamID;
	CSteamID pVictimSteamID;
	if ( ! pOwner->GetSteamID( &pOwnerSteamID ) || !pVictim->GetSteamID( &pVictimSteamID ) )
		return;

	// Find any active operation
	const auto& mapOperations = GetItemSchema()->GetOperationDefinitions();
	FOR_EACH_MAP_FAST( mapOperations, i )
	{
		CEconOperationDefinition* pOperation = mapOperations[i];
		if ( pOperation->IsActive() && pOperation->IsCampaign() )
		{
			EconEntity_NonEquippedItemKillTracking( pOwner, pVictim, pOperation->GetRequiredItemDefIndex(), kKillEaterEvent_CosmeticOperationKills, nIncrementValue );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Sends a soul with the specified value to every living member of the
//			specified team, originating from vecPosition.
//-----------------------------------------------------------------------------
void CTFGameRules::DropHalloweenSoulPackToTeam( int nAmount, const Vector& vecPosition, int nTeamNumber, int nSourceTeam )
{
	for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
	{
		CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
		if ( !pTFPlayer || !pTFPlayer->IsConnected() )
			continue;

		if ( pTFPlayer->GetTeamNumber() != nTeamNumber || !pTFPlayer->IsAlive() || pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
			continue;

		DropHalloweenSoulPack( nAmount, vecPosition, pTFPlayer, nSourceTeam );
	}
}




//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::DropHalloweenSoulPack( int nAmount, const Vector& vecSource, CBaseEntity *pTarget, int nSourceTeam )
{
	QAngle angles(0,0,0);
	CHalloweenSoulPack *pSoulsPack = assert_cast<CHalloweenSoulPack*>( CBaseEntity::CreateNoSpawn( "halloween_souls_pack", vecSource, angles, NULL ) );

	if ( pSoulsPack )
	{	
		pSoulsPack->SetTarget( pTarget );
		pSoulsPack->SetAmount( nAmount );
		pSoulsPack->ChangeTeam( nSourceTeam );

		DispatchSpawn( pSoulsPack );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldDropSpellPickup()
{
	if ( IsUsingSpells() )
	{
		return RandomFloat() <= tf_player_spell_drop_on_death_rate.GetFloat();
	}
	return false;
}
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::DropSpellPickup( const Vector& vPosition, int nTier /*= 0*/ ) const
{
	if ( !IsUsingSpells() )
		return;

	CSpellPickup *pSpellPickup = assert_cast<CSpellPickup*>( CBaseEntity::CreateNoSpawn( "tf_spell_pickup", vPosition + Vector( 0, 0, 50 ), vec3_angle, NULL ) );
	if ( pSpellPickup )
	{
		pSpellPickup->SetTier( nTier );

		DispatchSpawn( pSpellPickup );

		Vector vecImpulse = RandomVector( -0.5f, 0.5f );
		vecImpulse.z = 1.f;
		VectorNormalize( vecImpulse );

		Vector vecVelocity = vecImpulse * 500.f;
		pSpellPickup->DropSingleInstance( vecVelocity, NULL, 0 );
	}
}

//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldDropBonusDuck( void )
{
	if ( tf_player_drop_bonus_ducks.GetInt() < 0 )
	{
		return IsHolidayActive( kHoliday_EOTL );
	}
	else if ( tf_player_drop_bonus_ducks.GetInt() > 0 )
	{
		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldDropBonusDuckFromPlayer( CTFPlayer *pTFScorer, CTFPlayer *pTFVictim )
{
	if ( !pTFScorer || !pTFVictim )
		return false;

#ifndef STAGING_ONLY
	// Only drop if bot is not involved
	if ( pTFScorer->IsBot() || pTFVictim->IsBot() || pTFScorer == pTFVictim )
		return false;
#endif

	return ShouldDropBonusDuck();
}

//-----------------------------------------------------------------------------
int CTFGameRules::GetDuckSkinForClass( int nTeam, int nClass ) const
{
	int nSkin = 0;
	if ( nTeam >= FIRST_GAME_TEAM )
	{
		bool bRed = ( nTeam == TF_TEAM_RED );

		switch ( nClass )
		{
		case TF_CLASS_SCOUT:
			nSkin = bRed ? 3 : 12;
			break;
		case TF_CLASS_SNIPER:
			nSkin = bRed ? 4 : 13;
			break;
		case TF_CLASS_SOLDIER:
			nSkin = bRed ? 5 : 14;
			break;
		case TF_CLASS_DEMOMAN:
			nSkin = bRed ? 6 : 15;
			break;
		case TF_CLASS_MEDIC:
			nSkin = bRed ? 7 : 16;
			break;
		case TF_CLASS_HEAVYWEAPONS:
			nSkin = bRed ? 8 : 17;
			break;
		case TF_CLASS_PYRO:
			nSkin = bRed ? 9 : 18;
			break;
		case TF_CLASS_SPY:
			nSkin = bRed ? 10 : 19;
			break;
		case TF_CLASS_ENGINEER:
			nSkin = bRed ? 11 : 20;
			break;
		default:
			nSkin = bRed ? 1 : 2;
			break;
		}
	}

	return nSkin;
}

//-----------------------------------------------------------------------------
//
#ifdef STAGING_ONLY
ConVar tf_duck_droprate_min( "tf_duck_droprate_min", "-1", FCVAR_REPLICATED, "Set Minimum Number of Ducks to Spawn. No upgrade" );
ConVar tf_duck_droprate_bias( "tf_duck_droprate_bias", "0.2", FCVAR_REPLICATED, "Set Bias on Duck Spawns. No upgrade" );
ConVar tf_duck_power_override( "tf_duck_power_override", "0", FCVAR_REPLICATED, "Override everyone's duck power and use this value when > 0" );
ConVar tf_duck_random_extra( "tf_duck_random_extra", "3.0f", FCVAR_REPLICATED, "Random Count of Ducks to be added used by bias function" );
#endif
ConVar tf_duck_edict_limit( "tf_duck_edict_limit", "1900", FCVAR_REPLICATED, "Maximum number of edicts allowed before spawning a duck" );
ConVar tf_duck_edict_warning( "tf_duck_edict_warning", "1800", FCVAR_REPLICATED, "Maximum number of edicts allowed before slowing duck spawn rate" );
void CTFGameRules::DropBonusDuck( const Vector& vPosition, CTFPlayer *pTFCreator /*=NULL*/, CTFPlayer *pAssister /*=NULL*/, CTFPlayer *pTFVictim /*=NULL*/, bool bCrit /*=false*/, bool bObjective /*=false*/) const
{
	if ( gEntList.NumberOfEdicts() > tf_duck_edict_limit.GetInt() )
	{
		Warning( "Warning: High level of Edicts, Not spawning Ducks \n" );
		return;
	}

	static CSchemaAttributeDefHandle pAttr_DuckLevelBadge( "duck badge level" );

	// Find Badge and increase number of ducks based on badge level (1 duck per 5 levels)
	// Look through equipped items, if one is a duck badge use its level
	int iDuckFlags = 0;
 	if ( pTFCreator == NULL || bObjective )
	{
		iDuckFlags |= EDuckFlags::DUCK_FLAG_OBJECTIVE;
	}
	uint32 iDuckBadgeLevel = 0;

	if ( pTFCreator )
	{
		for ( int i = 0; i < pTFCreator->GetNumWearables(); ++i )
		{
			CTFWearable* pWearable = dynamic_cast<CTFWearable*>( pTFCreator->GetWearable( i ) );
			if ( !pWearable )
				continue;

			//if ( pWearable->GetAttributeContainer() && pWearable->GetAttributeContainer()->GetItem() )
			{
				//CEconItemView *pItem = pWearable->GetAttributeContainer()->GetItem();
				CALL_ATTRIB_HOOK_INT_ON_OTHER( pWearable, iDuckBadgeLevel, duck_badge_level );
				//if ( pItem && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttr_DuckLevelBadge, &iDuckBadgeLevel ) )
				{
					iDuckBadgeLevel++;
				}
			}			
		}
	}
	// Badges only go to max of 5 now instead of 10 so just doubling the output value
	int iDuckPower = Min( (int)iDuckBadgeLevel * 2, 11 );
	float flBias = RemapValClamped( (float)iDuckPower, 0.0f, 10.0f, 0.2f, 0.5f);
	float flBiasScale = 3.0f;
	int iMinimum = 0;
	bool bSpecial = false;

	// Drop a few bonus ducks, extra ducks for Crits!
#ifdef STAGING_ONLY
	flBias = RemapValClamped( (float)iDuckPower, 0.0f, 10.0f, tf_duck_droprate_bias.GetFloat(), 0.5f);
	iMinimum = tf_duck_droprate_min.GetInt();
	if ( tf_duck_power_override.GetInt() > 0 )
	{
		iDuckPower = tf_duck_power_override.GetInt();
	}
	flBiasScale = tf_duck_random_extra.GetFloat();
#endif
	//tf_duck_droprate_bias
	int iDuckCount = (int)( Bias( RandomFloat( 0, 1 ), flBias ) * ( flBiasScale + iDuckPower ) ) + iMinimum;
	iDuckCount = Max( iDuckCount, (int)iDuckBadgeLevel );	// min ducks for a badge

	if ( bCrit )
	{
		iDuckCount += RandomInt( 1, 2 );
	}

	if ( pTFCreator && ( iDuckBadgeLevel > 0 ) )
	{
		if ( RandomInt( 0, 600 ) <= iDuckPower )
		{
			// MEGA BONUS DUCKS
			iDuckCount += iDuckPower;
			bSpecial = true;
		}
	}

	if ( iDuckCount > 0 )
	{
		// Max of 50 ducks, which is a lot of ducks
		iDuckCount = Min( 50, iDuckCount );

		// High edict count, slow generation
		if ( gEntList.NumberOfEdicts() > tf_duck_edict_warning.GetInt() )
		{
			Warning( "Warning: High level of Edicts, Not spawning as many ducks\n" );
			iDuckCount /= 2;
		}

		int iCreatorId = pTFCreator ? pTFCreator->entindex() : -1;
		int iAssisterId = pAssister ? pAssister->entindex() : -1;

		int iVictimId = -1;
		int iDuckTeam = TEAM_UNASSIGNED;
		if ( pTFVictim )
		{
			iVictimId = pTFVictim->entindex();
			iDuckTeam = pTFVictim->GetTeamNumber();
		}

		for ( int i = 0; i < iDuckCount; ++i )
		{
			Vector vecOrigin = vPosition + Vector( 0, 0, 50 );
			CBonusDuckPickup *pDuckPickup = assert_cast<CBonusDuckPickup*>( CBaseEntity::CreateNoSpawn( "tf_bonus_duck_pickup", vecOrigin, vec3_angle, NULL ) );
			if ( pDuckPickup )
			{
				DispatchSpawn( pDuckPickup );

				Vector vecImpulse = RandomVector( -0.5f, 0.5f );
				vecImpulse.z = 1.f;
				VectorNormalize( vecImpulse );

				Vector vecVelocity = vecImpulse * RandomFloat( 350.0f, 450.0f );
				pDuckPickup->DropSingleInstance( vecVelocity, NULL, 1.0f );
				pDuckPickup->SetCreatorId( iCreatorId );
				pDuckPickup->SetVictimId( iVictimId );
				pDuckPickup->SetAssisterId( iAssisterId );
				pDuckPickup->ChangeTeam( iDuckTeam );
				pDuckPickup->SetDuckFlag( iDuckFlags );
				// random chance to have a special duck appear
				// Bonus duck implies atleast 1 Saxton
				if ( bSpecial || ( RandomInt( 1, 100 ) <= tf_test_special_ducks.GetInt() ) )
				{
					bSpecial = false;
					pDuckPickup->m_nSkin = 21; // Quackston Hale
					pDuckPickup->SetSpecial();

					CSingleUserRecipientFilter filter( pTFCreator );
					UserMessageBegin( filter, "BonusDucks" );
					WRITE_BYTE( iCreatorId );
					WRITE_BYTE( true );
					MessageEnd();
				}
				else
				{
					if ( iDuckPower > 0 )
					{
						pDuckPickup->m_nSkin = GetDuckSkinForClass( iDuckTeam, ( pTFVictim && pTFVictim->GetPlayerClass() ) ? pTFVictim->GetPlayerClass()->GetClassIndex() : -1 );
					}
					else
					{
						// Scorer without a badge only make normal ducks
						pDuckPickup->m_nSkin = iDuckTeam == TF_TEAM_RED ? 1 : 2;
					}
					pDuckPickup->SetModelScale( 0.7f );
				}
			}
		}

		// Update duckstreak count on player and assister if they have badges
		if ( pTFCreator && PlayerHasDuckStreaks( pTFCreator ) )
		{
			pTFCreator->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Ducks, iDuckCount );
		}
		if ( pAssister && PlayerHasDuckStreaks( pAssister ) )
		{
			pAssister->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Ducks, iDuckCount );
		}

		// Duck UserMessage
		if ( pTFCreator && pTFVictim && !TFGameRules()->HaveCheatsBeenEnabledDuringLevel() )
		{
			if ( IsHolidayActive( kHoliday_EOTL ) )
			{
				// Send a Message to Creator
				{
					// IsCreated, ID of Creator, ID of Victim, Count, IsGolden
					CSingleUserRecipientFilter userfilter( pTFCreator );
					UserMessageBegin( userfilter, "EOTLDuckEvent" );
					WRITE_BYTE( true );
					WRITE_BYTE( iCreatorId );
					WRITE_BYTE( iVictimId );
					WRITE_BYTE( 0 );
					WRITE_BYTE( iDuckTeam );
					WRITE_BYTE( iDuckCount );
					WRITE_BYTE( iDuckFlags );
					MessageEnd();
				}

				// To assister
				if ( pAssister )
				{
					// IsCreated, ID of Creator, ID of Victim, Count, IsGolden
					CSingleUserRecipientFilter userfilter( pAssister );
					UserMessageBegin( userfilter, "EOTLDuckEvent" );
					WRITE_BYTE( true );
					WRITE_BYTE( pAssister->entindex() );
					WRITE_BYTE( iVictimId );
					WRITE_BYTE( 0 );
					WRITE_BYTE( iDuckTeam );
					WRITE_BYTE( iDuckCount );
					WRITE_BYTE( iDuckFlags );
					MessageEnd();
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static kill_eater_event_t g_eClassKillEvents[] =
{
	kKillEaterEvent_ScoutKill,					// TF_CLASS_SCOUT
	kKillEaterEvent_SniperKill,					// TF_CLASS_SNIPER
	kKillEaterEvent_SoldierKill,				// TF_CLASS_SOLDIER
	kKillEaterEvent_DemomanKill,				// TF_CLASS_DEMOMAN
	kKillEaterEvent_MedicKill,					// TF_CLASS_MEDIC
	kKillEaterEvent_HeavyKill,					// TF_CLASS_HEAVYWEAPONS
	kKillEaterEvent_PyroKill,					// TF_CLASS_PYRO
	kKillEaterEvent_SpyKill,					// TF_CLASS_SPY
	kKillEaterEvent_EngineerKill,				// TF_CLASS_ENGINEER
};
COMPILE_TIME_ASSERT( ARRAYSIZE( g_eClassKillEvents ) == (TF_LAST_NORMAL_CLASS - TF_FIRST_NORMAL_CLASS) );

//-----------------------------------------------------------------------------
static kill_eater_event_t g_eRobotClassKillEvents[] =
{
	kKillEaterEvent_RobotScoutKill,					// TF_CLASS_SCOUT
	kKillEaterEvent_RobotSniperKill,				// TF_CLASS_SNIPER
	kKillEaterEvent_RobotSoldierKill,				// TF_CLASS_SOLDIER
	kKillEaterEvent_RobotDemomanKill,				// TF_CLASS_DEMOMAN
	kKillEaterEvent_RobotMedicKill,					// TF_CLASS_MEDIC
	kKillEaterEvent_RobotHeavyKill,					// TF_CLASS_HEAVYWEAPONS
	kKillEaterEvent_RobotPyroKill,					// TF_CLASS_PYRO
	kKillEaterEvent_RobotSpyKill,					// TF_CLASS_SPY
	kKillEaterEvent_RobotEngineerKill,				// TF_CLASS_ENGINEER
};
COMPILE_TIME_ASSERT( ARRAYSIZE( g_eRobotClassKillEvents ) == (TF_LAST_NORMAL_CLASS - TF_FIRST_NORMAL_CLASS) );

static bool BHasWearableOfSpecificQualityEquipped( /*const*/ CTFPlayer *pTFPlayer, EEconItemQuality eQuality )
{
	Assert( pTFPlayer );

	// Fire the kill eater event on all wearables
	for ( int i = 0; i < pTFPlayer->GetNumWearables(); ++i )
	{
		CTFWearable *pWearableItem = dynamic_cast<CTFWearable *>( pTFPlayer->GetWearable( i ) );
		if ( !pWearableItem )
			continue;

		if ( !pWearableItem->GetAttributeContainer() )
			continue;

		CEconItemView *pEconItemView = pWearableItem->GetAttributeContainer()->GetItem();
		if ( !pEconItemView )
			continue;

		if ( pEconItemView->GetQuality() == eQuality )
			return true;
	}

	return false;
}

void CTFGameRules::PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
	// Find the killer & the scorer
	CBaseEntity *pInflictor = info.GetInflictor();
	CBaseEntity *pKiller = info.GetAttacker();
	CBaseMultiplayerPlayer *pScorer = ToBaseMultiplayerPlayer( GetDeathScorer( pKiller, pInflictor, pVictim ) );
	CTFPlayer *pAssister = NULL;
	CBaseObject *pObject = NULL;

	// if inflictor or killer is a base object, tell them that they got a kill
	// ( depends if a sentry rocket got the kill, sentry may be inflictor or killer )
	if ( pInflictor )
	{
		if ( pInflictor->IsBaseObject() )
		{
			pObject = dynamic_cast<CBaseObject *>( pInflictor );
		}
		else 
		{
			CBaseEntity *pInflictorOwner = pInflictor->GetOwnerEntity();
			if ( pInflictorOwner && pInflictorOwner->IsBaseObject() )
			{
				pObject = dynamic_cast<CBaseObject *>( pInflictorOwner );
			}
		}
		
	}
	else if( pKiller && pKiller->IsBaseObject() )
	{
		pObject = dynamic_cast<CBaseObject *>( pKiller );
	}

	if ( pObject )
	{
		if ( pObject->GetBuilder() != pVictim )
		{
			pObject->IncrementKills();

			// minibosses count for 5 kills
			if ( IsMannVsMachineMode() && pVictim && pVictim->IsPlayer() )
			{
				CTFPlayer *playerVictim = ToTFPlayer( pVictim );
				if ( playerVictim->IsMiniBoss() )
				{
					pObject->IncrementKills();
					pObject->IncrementKills();
					pObject->IncrementKills();
					pObject->IncrementKills();
				}
			}
		}
		pInflictor = pObject;

		if ( pObject->ObjectType() == OBJ_SENTRYGUN )
		{
			// notify the sentry
			CObjectSentrygun *pSentrygun = dynamic_cast<CObjectSentrygun *>( pObject );
			if ( pSentrygun )
			{
				pSentrygun->OnKilledEnemy( pVictim );
			}

			CTFPlayer *pOwner = pObject->GetOwner();
			if ( pOwner )
			{
				int iKills = pObject->GetKills();

				// keep track of max kills per a single sentry gun in the player object
				if ( pOwner->GetMaxSentryKills() < iKills )
				{
					pOwner->SetMaxSentryKills( iKills );
				}

				// if we just got 10 kills with one sentry, tell the owner's client, which will award achievement if it doesn't have it already
				if ( iKills == 10 )
				{
					pOwner->AwardAchievement( ACHIEVEMENT_TF_GET_TURRETKILLS );
				}
			}
		}
	}

	// if not killed by suicide or killed by world, see if the scorer had an assister, and if so give the assister credit
	if ( ( pVictim != pScorer ) && pKiller )
	{
		pAssister = ToTFPlayer( GetAssister( pVictim, pScorer, pInflictor ) );

		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( pAssister && pTFVictim )
		{
			EntityHistory_t* entHist = pTFVictim->m_AchievementData.IsSentryDamagerInHistory( pAssister, 5.0 );
			if ( entHist )
			{
				CBaseObject *pObj = dynamic_cast<CBaseObject*>( entHist->hObject.Get() );
				if ( pObj )
				{
					pObj->IncrementAssists();
				}
			}

			// Rage On Assists
			// Sniper Kill Rage
			if ( pAssister->IsPlayerClass( TF_CLASS_SNIPER ) )
			{
				// Item attribute
				// Add Sniper Rage On Assists
				float flRageGain = 0;
				CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pAssister, flRageGain, rage_on_assists );
				if (flRageGain != 0)
				{
					pAssister->m_Shared.ModifyRage(flRageGain);
				}
			}
		}
	}

	if ( pVictim ) 
	{
		if ( ShouldDropSpellPickup() )
		{
			DropSpellPickup( pVictim->GetAbsOrigin() );
		}

		CTFPlayer *pTFScorer = ToTFPlayer( pScorer );
		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( pTFScorer && pTFVictim )
		{
			if ( ShouldDropBonusDuckFromPlayer( pTFScorer, pTFVictim ) )
			{
				DropBonusDuck( pTFVictim->GetAbsOrigin(), pTFScorer, pAssister, pTFVictim, ( info.GetDamageType() & DMG_CRITICAL ) != 0 );
			}
		}

		// Drop a halloween soul!
		if ( IsHolidayActive( kHoliday_Halloween ) )
		{
			CBaseCombatCharacter* pBaseCombatScorer = dynamic_cast< CBaseCombatCharacter*>( pScorer ? pScorer : pKiller );
			// No souls for a pure suicide
			if ( pTFVictim != pBaseCombatScorer )
			{
				// Only spawn a soul if the target is a base combat character. 
				if ( pTFVictim && pBaseCombatScorer )
				{
					DropHalloweenSoulPack( 1, pVictim->EyePosition(), pBaseCombatScorer, pTFVictim->GetTeamNumber() );
				}

				// Also spawn one for the assister
				if ( pAssister )
				{
					DropHalloweenSoulPack( 1, pVictim->EyePosition(), pAssister, pTFVictim->GetTeamNumber() );
				}
			}
		}
	}

	//find the area the player is in and see if his death causes a block
	CBaseMultiplayerPlayer *pMultiplayerPlayer = ToBaseMultiplayerPlayer(pVictim);
	for ( int i=0; i<ITriggerAreaCaptureAutoList::AutoList().Count(); ++i )
	{
		CTriggerAreaCapture *pArea = static_cast< CTriggerAreaCapture * >( ITriggerAreaCaptureAutoList::AutoList()[i] );
		if ( pArea->IsTouching( pMultiplayerPlayer ) )
		{
			// ACHIEVEMENT_TF_MEDIC_ASSIST_CAPTURER
			// kill 3 players 
			if ( pAssister && pAssister->IsPlayerClass( TF_CLASS_MEDIC ) )
			{
				// the victim is touching a cap point, see if they own it
				if ( pMultiplayerPlayer->GetTeamNumber() == pArea->GetOwningTeam() )
				{
					int iDefenderKills = pAssister->GetPerLifeCounterKV( "medic_defender_kills" );

					if ( ++iDefenderKills == 3 )
					{
						pAssister->AwardAchievement( ACHIEVEMENT_TF_MEDIC_ASSIST_CAPTURER );
					}

					pAssister->SetPerLifeCounterKV( "medic_defender_kills", iDefenderKills );
				}
			}

			if ( pArea->CheckIfDeathCausesBlock( pMultiplayerPlayer, pScorer ) )
				break;
		}
	}

	// determine if this kill affected a nemesis relationship
	int iDeathFlags = 0;
	CTFPlayer *pTFPlayerVictim = ToTFPlayer( pVictim );
	CTFPlayer *pTFPlayerScorer = ToTFPlayer( pScorer );
	if ( pScorer )
	{	
		CalcDominationAndRevenge( pTFPlayerScorer, info.GetWeapon(), pTFPlayerVictim, false, &iDeathFlags );
		if ( pAssister )
		{
			CalcDominationAndRevenge( pAssister, info.GetWeapon(), pTFPlayerVictim, true, &iDeathFlags );
		}
	}
	pTFPlayerVictim->SetDeathFlags( iDeathFlags );	

	CTFPlayer *pTFPlayerAssister = ToTFPlayer( pAssister );
	if ( pTFPlayerAssister )
	{
		CTF_GameStats.Event_AssistKill( pTFPlayerAssister, pVictim );
	}

	// check for achievements
	PlayerKilledCheckAchievements( pTFPlayerScorer, pTFPlayerVictim );

	if ( IsInTraining() && GetTrainingModeLogic() )
	{
		if ( pVictim->IsFakeClient() == false )
		{
			GetTrainingModeLogic()->OnPlayerDied( ToTFPlayer( pVictim ), pKiller );
		}
		else
		{
			GetTrainingModeLogic()->OnBotDied( ToTFPlayer( pVictim ), pKiller );
		}
	}

	// credit for dueling
	if ( pTFPlayerScorer != NULL && pTFPlayerScorer != pTFPlayerVictim )
	{
		DuelMiniGame_NotifyKill( pTFPlayerScorer, pTFPlayerVictim );
	}
	if ( pTFPlayerAssister && pTFPlayerAssister != pTFPlayerVictim )
	{
		DuelMiniGame_NotifyAssist( pTFPlayerAssister, pTFPlayerVictim );
	}

	// Count kills from powerup carriers to detect imbalances
	if ( IFuncPowerupVolumeAutoList::AutoList().Count() != 0 ) // If there are no func_powerupvolumes in the map, there's no point in checking for imbalances
	{
		if ( pTFPlayerScorer && pTFPlayerScorer != pTFPlayerVictim && pTFPlayerScorer->m_Shared.IsCarryingRune() && !pTFPlayerScorer->m_Shared.InCond( TF_COND_RUNE_IMBALANCE ) )
		{
			if ( !m_bPowerupImbalanceMeasuresRunning && !PowerupModeFlagStandoffActive() ) // Only count if imbalance measures aren't running and there is no flag standoff 
			{
				if ( pTFPlayerScorer->GetTeamNumber() == TF_TEAM_BLUE )
				{
					m_nPowerupKillsBlueTeam++;		// Blue team score increases if a powered up blue player makes a kill
				}
				else if ( pTFPlayerScorer->GetTeamNumber() == TF_TEAM_RED )
				{
					m_nPowerupKillsRedTeam++;
				}

				int nBlueAdvantage = m_nPowerupKillsBlueTeam - m_nPowerupKillsRedTeam;		// How far ahead is this team?
//				Msg( "\nnBlueAdvantage = %d\n", nBlueAdvantage );
				int nRedAdvantage = m_nPowerupKillsRedTeam - m_nPowerupKillsBlueTeam;
//				Msg( "nRedAdvantage = %d\n\n", nRedAdvantage );

				if ( nRedAdvantage >= tf_powerup_mode_imbalance_delta.GetInt() )
				{
					PowerupTeamImbalance( TF_TEAM_BLUE );		// Fire the output to map logic
				}
				else if ( nBlueAdvantage >= tf_powerup_mode_imbalance_delta.GetInt() )
				{
					PowerupTeamImbalance( TF_TEAM_RED );
				}
			}
		}
	}

	// credit for kill-eating weapons and anything else that might care
	if ( pTFPlayerScorer && pTFPlayerVictim && pTFPlayerScorer != pTFPlayerVictim )
	{
		// Increment the server-side kill count for this weapon -- this is used for honorbound
		// weapons and has nothing to do with strange weapons/stats.
		pTFPlayerScorer->IncrementKillCountSinceLastDeploy( info );

		CTFWeaponBase *pTFWeapon = GetKilleaterWeaponFromDamageInfo( &info );
		
		kill_eater_event_t eKillEaterEvent = pTFWeapon														// if we have a weapon...
											? pTFWeapon->GetKillEaterKillEventType()							// ...then ask it what type of event to report
											: info.GetDamageCustom() == TF_DMG_CUSTOM_BOOTS_STOMP			// if we don't have a weapon, and we're hacking for kill types from wearables (!)...
											? kKillEaterEvent_PlayerKillByBootStomp							// ...then use our hard-coded event
											: kKillEaterEvent_PlayerKill;									// otherwise default to a normal player kill
		
		CEconEntity *pAttackerEconWeapon = NULL;

		// Cosmetic Kill like manntreads or demo shield
		if ( !pTFWeapon )
		{
			pAttackerEconWeapon = dynamic_cast< CEconEntity * >( info.GetWeapon() );
		}
		else
		{
			pAttackerEconWeapon = dynamic_cast< CEconEntity * >( pTFWeapon );
		}
		

		if ( pAttackerEconWeapon )
		{
			if ( !( IsPVEModeActive() && pTFPlayerVictim->GetTeamNumber() == TF_TEAM_PVE_INVADERS ) )
			{
				// Any type of non-robot kill!
				EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, eKillEaterEvent );

				// Cosmetic any kill type tracking
				{
					HatAndMiscEconEntities_OnOwnerKillEaterEvent( pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_CosmeticKills );

					// Halloween silliness: overworld kills for Merasmus carnival.
					if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_DOOMSDAY ) && !pTFPlayerScorer->m_Shared.InCond( TF_COND_HALLOWEEN_IN_HELL ) )
					{
						HatAndMiscEconEntities_OnOwnerKillEaterEvent( pTFPlayerScorer,
																	  pTFPlayerVictim,
																	  kKillEaterEvent_Halloween_OverworldKills );
					}
				}

				// Operation Kills
				EconEntity_NonEquippedItemKillTracking( pTFPlayerScorer, pTFPlayerVictim, 1 );

				// Unique kill tracking?
				EconEntity_OnOwnerUniqueEconEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_UniqueEvent__KilledAccountWithItem );

				// Optional Taunt Kill tracking
				if ( IsTauntDmg( info.GetDamageCustom() ) )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_TauntKill );
				}
				// Scorch Shot Taunt is Different
				else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_PELLET )
				{
					CBaseEntity *pInflictor = info.GetInflictor();
					CTFProjectile_Flare *pFlare = dynamic_cast<CTFProjectile_Flare*>(pInflictor);
					if ( pFlare && pFlare->IsFromTaunt() )
					{
						EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_TauntKill );
					}
				}

				// Optional: also track "killed X players of this specific class".
				int iVictimClassIndex = pTFPlayerVictim->GetPlayerClass()->GetClassIndex();
				if ( iVictimClassIndex >= TF_FIRST_NORMAL_CLASS && iVictimClassIndex <= TF_LAST_NORMAL_CLASS )
				{
					const kill_eater_event_t eClassKillType = g_eClassKillEvents[ iVictimClassIndex - TF_FIRST_NORMAL_CLASS ];
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, eClassKillType );
				}

				// Optional : Kills while in Victory / Bonus time
				if ( State_Get() == GR_STATE_TEAM_WIN && GetWinningTeam() != pTFPlayerVictim->GetTeamNumber() )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_VictoryTimeKill );
				}

				// Optional: also track "killed X players while they were in the air".
				if ( !(pTFPlayerVictim->GetFlags() & FL_ONGROUND) && (pTFPlayerVictim->GetWaterLevel() == WL_NotInWater) )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_AirborneEnemyKill );
				}

				// Optional: also track "killed X players with headshots".
				if ( IsHeadshot( info.GetDamageCustom() ) )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_HeadshotKill );
				}

				// Optional: also track "gibbed X players".
				if ( pTFPlayerVictim->ShouldGib( info ) )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_GibKill );
				}

				// Optional: also track "killed X players during full moons". We intentionally don't call into the
				// game rules here because we don't want server variables to override this. Setting local time on the
				// server will still allow it to happen but it at least takes a little effort.
				if ( UTIL_IsHolidayActive( kHoliday_FullMoon ) )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillDuringFullMoon );
				}

				// Optional: also track kills we make while we're dead (afterburn, pre-death-fired rocket, etc.)
				if ( !pTFPlayerScorer->IsAlive() )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillPosthumous );
				}

				// Optional: also track kills that were specifically criticals.
				if ( (info.GetDamageType() & DMG_CRITICAL) != 0 )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillCritical );
				}
				else 
				{
					// Not special at all kill
					if ( pTFPlayerVictim->GetAttackBonusEffect() == kBonusEffect_None )
					{
						EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_NonCritKills );
					}
				}

				// Optional: also track kills that were made while we were launched into the air from an explosion (ie., rocket-jumping).
				if ( pTFPlayerScorer->InAirDueToExplosion() )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillWhileExplosiveJumping );
				}

				// Optional: also track kills where the victim was a spy who was invisible at the time of death.
				if ( iVictimClassIndex == TF_CLASS_SPY && pTFPlayerVictim->m_Shared.GetPercentInvisible() > 0 )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_InvisibleSpiesKilled );
				}

				// Optional: also track kills where the victim was a medic with 100% uber.
				if ( pTFPlayerVictim->MedicGetChargeLevel() >= 1.0f )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_MedicsWithFullUberKilled );
				}

				// Optional: also track kills where the killer was at low health when they dealt the final damage. Don't count
				// kills with 0 or fewer health -- those would be post-mortem kills instead.
				if ( ((float)pTFPlayerScorer->GetHealth() / (float)pTFPlayerScorer->GetMaxHealth()) <= 0.1f && pTFPlayerScorer->GetHealth() > 0 )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_KillWhileLowHealth );
				}

				// Optional: also track kills that take place during the Halloween holiday. We intentionally *do* check against
				// the game rules logic here -- if folks want to enable Halloween mode on a server and play around, I don't see any
				// reason why we benefit from stopping their fun.
				if ( TF_IsHolidayActive( kHoliday_Halloween ) )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_HalloweenKill );
				}

				// Optional: also track kills where the victim was completely underwater.
				if ( pTFPlayerVictim->GetWaterLevel() >= WL_Eyes )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_UnderwaterKill );
				}

				// Optional: also track kills where we're under the effects of a medic's ubercharge.
				if ( pTFPlayerScorer->m_Shared.InCond( TF_COND_INVULNERABLE ) || pTFPlayerScorer->m_Shared.InCond( TF_COND_INVULNERABLE_WEARINGOFF ) )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_KillWhileUbercharged );
				}

				// Optional: also track kills where the victim was in the process of carrying the intel, capturing a point, or pushing
				// the cart. The actual logic for "killed a flag carrier" is handled elsewhere because by this point we've forgotten
				// if we had a flag before we died.
				if ( pTFPlayerVictim->IsCapturingPoint() )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_DefenderKill );
				}

				// Optional: also track kills where the victim was at least N units from the person dealing the damage, where N is "however far
				// you have to be to get the crowd chear noise". This also specifically checks to make sure the damage dealer is alive to avoid
				// casing where you spectate far away, etc.
				if ( pTFPlayerScorer->IsAlive() && (pTFPlayerScorer->GetAbsOrigin() - pTFPlayerVictim->GetAbsOrigin()).Length() >= 2000.0f )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_LongDistanceKill );
				}

				// Optional: also track kills where the victim was wearing at least one unusual-quality item.
				if ( BHasWearableOfSpecificQualityEquipped( pTFPlayerVictim, AE_UNUSUAL ) )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PlayersWearingUnusualKill );
				}

				// Optional: also track kills where the victim was on fire at the time that they died. We can't check the condition flag
				// here because that may or may not be active after they die, but instead we test to see whether they still had a burn queued
				// up for the future as a proxy for "was on fire at this point".
				if ( pTFPlayerVictim->m_Shared.GetFlameBurnTime() >= gpGlobals->curtime )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_BurningEnemyKill );
				}

				// Optional: also track kills where this kill ended someone else's killstreak, where "killstreak" starts when the first
				// announcement happens. If Mike gets to hard-code constants, I do, too.
				enum { kFirstKillStreakAnnouncement = 5 };
				if ( pTFPlayerVictim->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills ) >= kFirstKillStreakAnnouncement )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_KillstreaksEnded );
				}

				// Optional: also track kills where the killer and the victim were basically right next to each other. This is hard-coded to
				// 1.5x default melee swing range.
				if ( pTFPlayerScorer->IsAlive() && (pTFPlayerScorer->GetAbsOrigin() - pTFPlayerVictim->GetAbsOrigin()).Length() <= 72.0f )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_PointBlankKills );
				}

				// Optional : Fullhealth kills
				if ( pTFPlayerScorer->GetHealth() >= pTFPlayerScorer->GetMaxHealth() )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_FullHealthKills );
				}

				// Optional : Taunting Player kills
				if ( pTFPlayerVictim->IsTaunting() )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_TauntingPlayerKills );
				}
			}
			else
			{
				Assert( pTFPlayerVictim->GetTeamNumber() == TF_TEAM_PVE_INVADERS );

				// Optional: also track kills where the victim was a robot in MvM
				EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_RobotsDestroyed );

				// Optional: also track "killed X Robots of this specific class".
				int iVictimClassIndex = pTFPlayerVictim->GetPlayerClass()->GetClassIndex();
				if ( iVictimClassIndex >= TF_FIRST_NORMAL_CLASS && iVictimClassIndex <= TF_LAST_NORMAL_CLASS )
				{
					const kill_eater_event_t eClassKillType = g_eRobotClassKillEvents[ iVictimClassIndex - TF_FIRST_NORMAL_CLASS ];
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, eClassKillType );
				}

				// Optional: specifically track miniboss kills separately from base robot kills.
				if ( pTFPlayerVictim->IsMiniBoss() )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_MinibossRobotsDestroyed );
				}

				// Optional: track whether this shot killed a robot *after* penetrating something else.
				if ( info.GetPlayerPenetrationCount() > 0 )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_RobotsDestroyedAfterPenetration );
				}

				// Optional: also track "killed X players with headshots", but for robots specifically.
				if ( IsHeadshot( info.GetDamageCustom() ) )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_RobotHeadshotKills );
				}

				// Optional: also track kills that take place during the Halloween holiday. See note for kKillEaterEvent_HalloweenKill
				// regarding calling into game rules here.
				if ( TF_IsHolidayActive( kHoliday_Halloween ) )
				{
					EconEntity_OnOwnerKillEaterEvent( pAttackerEconWeapon, pTFPlayerScorer, pTFPlayerVictim, kKillEaterEvent_HalloweenKillRobot );
				}
			}
		}
	}

	BaseClass::PlayerKilled( pVictim, info );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::PlayerKilledCheckAchievements( CTFPlayer *pAttacker, CTFPlayer *pVictim )
{
	if ( !pAttacker || !pVictim )
		return;

	// HEAVY WEAPONS GUY
	if ( pAttacker->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) )
	{
		if ( GetGameType() == TF_GAMETYPE_CP )
		{
			// ACHIEVEMENT_TF_HEAVY_DEFEND_CONTROL_POINT
			CTriggerAreaCapture *pAreaTrigger = pAttacker->GetControlPointStandingOn();
			if ( pAreaTrigger )
			{
				CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint();
				if ( pCP )
				{
					if ( pCP->GetOwner() == pAttacker->GetTeamNumber() )
					{
						// no suicides!
						if ( pAttacker != pVictim )
						{
							pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_DEFEND_CONTROL_POINT );
						}
					}
				}
			}

			// ACHIEVEMENT_TF_HEAVY_KILL_CAPPING_ENEMIES
			pAreaTrigger = pVictim->GetControlPointStandingOn();
			if ( pAreaTrigger )
			{
				CTeamControlPoint *pCP = pAreaTrigger->GetControlPoint();
				if ( pCP )
				{
					if ( pCP->GetOwner() == pAttacker->GetTeamNumber() && 
						 TeamMayCapturePoint( pVictim->GetTeamNumber(), pCP->GetPointIndex() ) &&
						 PlayerMayCapturePoint( pVictim, pCP->GetPointIndex() ) )
					{
						pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_KILL_CAPPING_ENEMIES );
					}
				}
			}
		}

		// ACHIEVEMENT_TF_HEAVY_CLEAR_STICKYBOMBS
		if ( pVictim->IsPlayerClass( TF_CLASS_DEMOMAN ) )
		{
			int iPipes = pVictim->GetNumActivePipebombs();

			for (int i = 0; i < iPipes; i++)
			{
				pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_CLEAR_STICKYBOMBS );
			}
		}

		// ACHIEVEMENT_TF_HEAVY_DEFEND_MEDIC
		int i;
		int iNumHealers = pAttacker->m_Shared.GetNumHealers();
		for ( i = 0 ; i < iNumHealers ; i++ )
		{
			CTFPlayer *pMedic = ToTFPlayer( pAttacker->m_Shared.GetHealerByIndex( i ) );
			if ( pMedic && pMedic->m_AchievementData.IsDamagerInHistory( pVictim, 3.0 ) )
			{
				pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_DEFEND_MEDIC );
				break; // just award it once for each kill...even if the victim attacked more than one medic attached to the killer
			}
		}

		// ACHIEVEMENT_TF_HEAVY_STAND_NEAR_DISPENSER
		for ( i = 0 ; i < iNumHealers ; i++ )
		{
			if ( pAttacker->m_Shared.HealerIsDispenser( i ) )
			{
				pAttacker->AwardAchievement( ACHIEVEMENT_TF_HEAVY_STAND_NEAR_DISPENSER );
				break; // just award it once for each kill...even if the attacker is being healed by more than one dispenser
			}
		}
	}

	int i;
	int iNumHealers = pAttacker->m_Shared.GetNumHealers();
	for ( i = 0 ; i < iNumHealers ; i++ )
	{
		CTFPlayer *pMedic = ToTFPlayer( pAttacker->m_Shared.GetHealerByIndex( i ) );
		if ( pMedic && pMedic->m_AchievementData.IsDamagerInHistory( pVictim, 10.0 ) )
		{
			IGameEvent * event = gameeventmanager->CreateEvent( "medic_defended" );
			if ( event )
			{
				event->SetInt( "userid", pAttacker->GetUserID() );
				event->SetInt( "medic", pMedic->GetUserID() );
				gameeventmanager->FireEvent( event );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Determines if attacker and victim have gotten domination or revenge
//-----------------------------------------------------------------------------
void CTFGameRules::CalcDominationAndRevenge( CTFPlayer *pAttacker, CBaseEntity *pWeapon, CTFPlayer *pVictim, bool bIsAssist, int *piDeathFlags )
{
//=============================================================================
// HPE_BEGIN:
// [msmith]	If we're in training, we want to disable this domination stuff.
//=============================================================================
	if ( IsInTraining() )
		return;
//=============================================================================
// HPE_END
//=============================================================================

	// don't do domination stuff in powerup mode
	if ( IsPowerupMode() )
		return;

	// no dominations/revenge in competitive mode
	if ( IsMatchTypeCompetitive() )
		return;

	PlayerStats_t *pStatsVictim = CTF_GameStats.FindPlayerStats( pVictim );

	// no dominations/revenge in PvE mode
	if ( IsPVEModeActive() )
		return;

	CEconEntity *pEconWeapon = dynamic_cast<CEconEntity *>( pWeapon );

	// calculate # of unanswered kills between killer & victim - add 1 to include current kill
	int iKillsUnanswered = pStatsVictim->statsKills.iNumKilledByUnanswered[pAttacker->entindex()] + 1;		
	if ( TF_KILLS_DOMINATION == iKillsUnanswered )
	{			
		// this is the Nth unanswered kill between killer and victim, killer is now dominating victim
		*piDeathFlags |= ( bIsAssist ? TF_DEATH_ASSISTER_DOMINATION : TF_DEATH_DOMINATION );
		// set victim to be dominated by killer
		pAttacker->m_Shared.SetPlayerDominated( pVictim, true );

		int iCurrentlyDominated = pAttacker->GetNumberofDominations() + 1;
		pAttacker->SetNumberofDominations( iCurrentlyDominated );

		// record stats
		CTF_GameStats.Event_PlayerDominatedOther( pAttacker );

		// strange weapon stat tracking?
		EconEntity_OnOwnerKillEaterEvent( pEconWeapon, pAttacker, pVictim, kKillEaterEvent_PlayerKillStartDomination );
	}
	else if ( pVictim->m_Shared.IsPlayerDominated( pAttacker->entindex() ) )
	{
		// the killer killed someone who was dominating him, gains revenge
		*piDeathFlags |= ( bIsAssist ? TF_DEATH_ASSISTER_REVENGE : TF_DEATH_REVENGE );
		// set victim to no longer be dominating the killer
		pVictim->m_Shared.SetPlayerDominated( pAttacker, false );

		int iCurrentlyDominated = pVictim->GetNumberofDominations() - 1;
		if (iCurrentlyDominated < 0)
		{
			iCurrentlyDominated = 0;
		}
		pVictim->SetNumberofDominations( iCurrentlyDominated );

		// record stats
		CTF_GameStats.Event_PlayerRevenge( pAttacker );

		// strange weapon stat tracking?
		EconEntity_OnOwnerKillEaterEvent( pEconWeapon, pAttacker, pVictim, kKillEaterEvent_PlayerKillRevenge );
	}
	else if ( pAttacker->m_Shared.IsPlayerDominated( pVictim->entindex() ) )
	{
		// the killer killed someone who they were already dominating

		// strange weapon stat tracking?
		EconEntity_OnOwnerKillEaterEvent( pEconWeapon, pAttacker, pVictim, kKillEaterEvent_PlayerKillAlreadyDominated );
	}
}

//-----------------------------------------------------------------------------
// Purpose: create some proxy entities that we use for transmitting data */
//-----------------------------------------------------------------------------
void CTFGameRules::CreateStandardEntities()
{
	// Create the player resource
	g_pPlayerResource = (CPlayerResource*)CBaseEntity::Create( "tf_player_manager", vec3_origin, vec3_angle );

	// Create the objective resource
	g_pObjectiveResource = (CTFObjectiveResource *)CBaseEntity::Create( "tf_objective_resource", vec3_origin, vec3_angle );

	Assert( g_pObjectiveResource );

	// Create the monster resource for PvE battles
	g_pMonsterResource = (CMonsterResource *)CBaseEntity::Create( "monster_resource", vec3_origin, vec3_angle );

	MannVsMachineStats_Init();

	// Create the entity that will send our data to the client.
	m_hGamerulesProxy = assert_cast<CTFGameRulesProxy*>(CBaseEntity::Create( "tf_gamerules", vec3_origin, vec3_angle ));
	Assert( m_hGamerulesProxy.Get() );
	m_hGamerulesProxy->SetName( AllocPooledString("tf_gamerules" ) );
	
	CBaseEntity::Create("vote_controller", vec3_origin, vec3_angle);
	// Vote Issue classes are handled/cleaned-up by g_voteController
	new CKickIssue;
	new CRestartGameIssue;
	new CChangeLevelIssue;
	new CNextLevelIssue;
	new CExtendLevelIssue;
	new CScrambleTeams;
	new CMannVsMachineChangeChallengeIssue;
	new CEnableTemporaryHalloweenIssue;
	new CTeamAutoBalanceIssue;
	new CClassLimitsIssue;
	new CPauseGameIssue;
}

//-----------------------------------------------------------------------------
// Purpose: determine the class name of the weapon that got a kill
//-----------------------------------------------------------------------------
const char *CTFGameRules::GetKillingWeaponName( const CTakeDamageInfo &info, CTFPlayer *pVictim, int *iWeaponID )
{
 	CBaseEntity *pInflictor = info.GetInflictor();
	CBaseEntity *pKiller = info.GetAttacker();
	CBasePlayer *pScorer = GetDeathScorer( pKiller, pInflictor, pVictim );

	const char *killer_weapon_name = "world";
	*iWeaponID = TF_WEAPON_NONE;

	if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING )
	{
		// special-case burning damage, since persistent burning damage may happen after attacker has switched weapons
		killer_weapon_name = "tf_weapon_flamethrower";
		*iWeaponID = TF_WEAPON_FLAMETHROWER;

		CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( info.GetWeapon() );
		if ( pWeapon )
		{
			CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
			if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() )
			{
				killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
				*iWeaponID = TF_WEAPON_NONE;
			}
		}
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BURNING_FLARE )
	{
		// special-case burning damage, since persistent burning damage may happen after attacker has switched weapons
		killer_weapon_name = "tf_weapon_flaregun";
		*iWeaponID = TF_WEAPON_FLAREGUN;

		if ( pInflictor && pInflictor->IsPlayer() == false )
		{
			CTFBaseRocket *pBaseRocket = dynamic_cast<CTFBaseRocket*>( pInflictor );

			if ( pBaseRocket )
			{
				if ( pBaseRocket->GetDeflected() )
				{
					killer_weapon_name = "deflect_flare";
				}
			}
		}

		CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( info.GetWeapon() );
		if ( pWeapon && pWeapon->GetWeaponID() == TF_WEAPON_FLAREGUN_REVENGE )
		{
			CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
			if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() )
			{
				killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
				*iWeaponID = pWeapon->GetWeaponID();
			}
		}
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_FLARE_EXPLOSION )
	{
		killer_weapon_name = "tf_weapon_detonator";
		*iWeaponID = TF_WEAPON_FLAREGUN;

		if ( pInflictor && pInflictor->IsPlayer() == false )
		{
			CTFBaseRocket *pBaseRocket = dynamic_cast<CTFBaseRocket*>( pInflictor );
			if ( pBaseRocket )
			{
				if ( pBaseRocket->GetDeflected() )
				{
					killer_weapon_name = "deflect_flare_detonator";
				}
			}
		}
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CHARGE_IMPACT )
	{
		CTFWearable *pWearable = dynamic_cast< CTFWearable * >( info.GetWeapon() );
		if ( pWearable )
		{
			CEconItemView *pItem = pWearable->GetAttributeContainer()->GetItem();
			if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() )
			{
				killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
				*iWeaponID = TF_WEAPON_NONE;
			}
		}
	}
	else if ( info.GetPlayerPenetrationCount() > 0 )
	{
		// This may be stomped later if the kill was a headshot.
		killer_weapon_name = "player_penetration";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_PICKAXE )
	{
		killer_weapon_name = "pickaxe";
		*iWeaponID = TF_WEAPON_SHOVEL;
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CARRIED_BUILDING )
	{
		killer_weapon_name = "tf_weapon_building_carried_destroyed";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_HADOUKEN )
	{
		killer_weapon_name = "tf_weapon_taunt_pyro";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_HIGH_NOON )
	{
		killer_weapon_name = "tf_weapon_taunt_heavy";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_GRAND_SLAM )
	{
		killer_weapon_name = "tf_weapon_taunt_scout";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_BARBARIAN_SWING )
	{
		killer_weapon_name = "tf_weapon_taunt_demoman";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_UBERSLICE )
	{
		killer_weapon_name = "tf_weapon_taunt_medic";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_FENCING )
	{
		killer_weapon_name = "tf_weapon_taunt_spy";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ARROW_STAB )
	{
		killer_weapon_name = "tf_weapon_taunt_sniper";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_GRENADE )
	{
		CTFPlayer *pTFKiller = ToTFPlayer( pKiller );
		if ( pTFKiller && pTFKiller->IsWormsGearEquipped() )
		{
			killer_weapon_name = "tf_weapon_taunt_soldier_lumbricus";
		}
		else
		{
			killer_weapon_name = "tf_weapon_taunt_soldier";
		}
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ENGINEER_GUITAR_SMASH )
	{
		killer_weapon_name = "tf_weapon_taunt_guitar_kill";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ALLCLASS_GUITAR_RIFF )
	{
		killer_weapon_name = "tf_weapon_taunt_guitar_riff_kill";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ENGINEER_ARM_KILL )
	{
		killer_weapon_name = "robot_arm_blender_kill";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TELEFRAG )
	{
		killer_weapon_name = "telefrag";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BOOTS_STOMP )
	{
		killer_weapon_name = "mantreads";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BASEBALL )
	{
		killer_weapon_name = "ball";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_COMBO_PUNCH )
	{
		killer_weapon_name = "robot_arm_combo_kill";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_BLEEDING )
	{
		killer_weapon_name = "tf_weapon_bleed_kill";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_PLAYER_SENTRY )
	{
		int nGigerCounter = 0; 
		if ( pScorer )
		{
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pScorer, nGigerCounter, is_giger_counter );
		}
			
		if ( nGigerCounter > 0 )
		{
			killer_weapon_name = "giger_counter";
		}
		else
		{
			killer_weapon_name = "wrangler_kill";
		}
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_DECAPITATION_BOSS )
	{
		killer_weapon_name = "headtaker";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_EYEBALL_ROCKET )
	{
		killer_weapon_name = "eyeball_rocket";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_STICKBOMB_EXPLOSION )
	{
		killer_weapon_name = "ullapool_caber_explosion";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_TAUNTATK_ARMAGEDDON )
	{
		killer_weapon_name = "armageddon";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SAPPER_RECORDER_DEATH )
	{
		killer_weapon_name = "recorder";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_DECAPITATION )
	{
		killer_weapon_name = "merasmus_decap";
	}	
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_ZAP )
	{
		killer_weapon_name = "merasmus_zap";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_GRENADE )
	{
		killer_weapon_name = "merasmus_grenade";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_MERASMUS_PLAYER_BOMB )
	{
		killer_weapon_name = "merasmus_player_bomb";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_CANNONBALL_PUSH )
	{
		killer_weapon_name = "loose_cannon_impact";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_TELEPORT )
	{
		killer_weapon_name = "spellbook_teleport";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_SKELETON )
	{
		killer_weapon_name = "spellbook_skeleton";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_MIRV )
	{
		killer_weapon_name = "spellbook_mirv";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_METEOR )
	{
		killer_weapon_name = "spellbook_meteor";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_LIGHTNING )
	{
		killer_weapon_name = "spellbook_lightning";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_FIREBALL )
	{
		killer_weapon_name = "spellbook_fireball";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_MONOCULUS )
	{
		killer_weapon_name = "spellbook_boss";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_BLASTJUMP )
	{
		killer_weapon_name = "spellbook_blastjump";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_BATS )
	{
		killer_weapon_name = "spellbook_bats";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_SPELL_TINY )
	{
		killer_weapon_name = "spellbook_athletic";
	}
	else if ( info.GetDamageCustom() == TF_DMG_CUSTOM_THROWABLE ||
			  info.GetDamageCustom() == TF_DMG_CUSTOM_THROWABLE_KILL )			// Throwables
	{
		if ( pVictim && pVictim->GetHealth() <= 0 )
		{
			killer_weapon_name = "water_balloon_kill";	
		}
		else
		{
			killer_weapon_name = "water_balloon_hit";
		}
		*iWeaponID = TF_WEAPON_THROWABLE;
	}
	else if ( pScorer && pInflictor && ( pInflictor == pScorer ) )
	{
		// If this is not a suicide
		if ( pVictim != pScorer )
		{
			// If the inflictor is the killer, then it must be their current weapon doing the damage
			if ( pScorer->GetActiveWeapon() )
			{
				killer_weapon_name = pScorer->GetActiveWeapon()->GetClassname(); 
				if ( pScorer->IsPlayer() )
				{
					*iWeaponID = ToTFPlayer(pScorer)->GetActiveTFWeapon()->GetWeaponID();
				}
			}
		}
	}
	else if ( pInflictor )
	{
		killer_weapon_name = STRING( pInflictor->m_iClassname );

		CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pInflictor );
		if ( pWeapon )
		{
			*iWeaponID = pWeapon->GetWeaponID();
		}
		else
		{
			CTFBaseRocket *pBaseRocket = dynamic_cast<CTFBaseRocket*>( pInflictor );
			if ( pBaseRocket )
			{
				*iWeaponID = pBaseRocket->GetWeaponID();

				if ( pBaseRocket->GetDeflected() )
				{
					if ( *iWeaponID == TF_WEAPON_ROCKETLAUNCHER || *iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT )
					{
						killer_weapon_name = "deflect_rocket";
					}
					else if ( *iWeaponID == TF_WEAPON_COMPOUND_BOW )
					{
						CTFProjectile_Arrow* pArrow = dynamic_cast<CTFProjectile_Arrow*>( pBaseRocket );
						if ( pArrow && pArrow->IsAlight() )
						{
							killer_weapon_name = "deflect_huntsman_flyingburn";
						}
						else
						{
							killer_weapon_name = "deflect_arrow";
						}
					}
					else if ( *iWeaponID == TF_WEAPON_SHOTGUN_BUILDING_RESCUE )
					{
						killer_weapon_name = "rescue_ranger_reflect";
					}
				}
				else if ( *iWeaponID == TF_WEAPON_ROCKETLAUNCHER_DIRECTHIT )
				{
					killer_weapon_name = "rocketlauncher_directhit";
				}
			}
			else
			{
				CTFWeaponBaseGrenadeProj *pBaseGrenade = dynamic_cast<CTFWeaponBaseGrenadeProj*>( pInflictor );
				if ( pBaseGrenade )
				{
					*iWeaponID = pBaseGrenade->GetWeaponID();

					if ( pBaseGrenade->GetDeflected() )
					{
						if ( *iWeaponID == TF_WEAPON_GRENADE_PIPEBOMB )
						{
							killer_weapon_name = "deflect_sticky";
						}
						else if ( *iWeaponID == TF_WEAPON_GRENADE_DEMOMAN )
						{
							killer_weapon_name = "deflect_promode";
						}
						else if ( *iWeaponID == TF_WEAPON_BAT_WOOD )
						{
							killer_weapon_name = "deflect_ball";
						}
						else if ( *iWeaponID == TF_WEAPON_CANNON )
						{
							killer_weapon_name = "loose_cannon_reflect";
						}
					}
				}
			}
		}
	}

	if ( info.GetDamageCustom() == TF_DMG_CUSTOM_DEFENSIVE_STICKY )
	{
		killer_weapon_name = "sticky_resistance";
	}

	// strip certain prefixes from inflictor's classname
	const char *prefix[] = { "tf_weapon_grenade_", "tf_weapon_", "NPC_", "func_" };
	for ( int i = 0; i< ARRAYSIZE( prefix ); i++ )
	{
		// if prefix matches, advance the string pointer past the prefix
		int len = Q_strlen( prefix[i] );
		if ( strncmp( killer_weapon_name, prefix[i], len ) == 0 )
		{
			killer_weapon_name += len;
			break;
		}
	}

	// look out for sentry rocket as weapon and map it to sentry gun, so we get the sentry death icon based off level

	if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_sentryrocket" ) )
	{
		killer_weapon_name = "obj_sentrygun3";
	}
	else if ( 0 == Q_strcmp( killer_weapon_name, "obj_sentrygun" ) )
	{
		CObjectSentrygun *pSentrygun = assert_cast<CObjectSentrygun*>( pInflictor );
		if ( pSentrygun )
		{
			if ( pSentrygun->IsMiniBuilding() )
			{
				killer_weapon_name = "obj_minisentry";
			}
			else
			{
				int iSentryLevel = pSentrygun->GetUpgradeLevel();
				switch( iSentryLevel)
				{
				case 1:
					killer_weapon_name = "obj_sentrygun";
					break;
				case 2:
					killer_weapon_name = "obj_sentrygun2";
					break;
				case 3:
					killer_weapon_name = "obj_sentrygun3";
					break;
				default:
					killer_weapon_name = "obj_sentrygun";
					break;
				}
			}
		}
	}
	else if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_healing_bolt" ) )
	{
		killer_weapon_name = "crusaders_crossbow";
	}
	else if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_pipe" ) )
	{
		// let's look-up the primary weapon to see what type of grenade launcher it is
		if ( pScorer )
		{
			CTFPlayer *pTFScorer = ToTFPlayer( pScorer );
			if ( pTFScorer )
			{
				CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pTFScorer->Weapon_GetWeaponByType( TF_WPN_TYPE_PRIMARY ) );
				if ( pWeapon && ( pWeapon->GetWeaponID() == TF_WEAPON_GRENADELAUNCHER ) && pWeapon->GetAttributeContainer() )
				{
					CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
					if ( pItem && pItem->GetStaticData() )
					{
						if ( pItem->GetStaticData()->GetIconClassname() )
						{
							killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
							*iWeaponID = TF_WEAPON_NONE;
						}
					}
				}
			}
		}
	}
	else if ( 0 == Q_strcmp( killer_weapon_name, "tf_projectile_energy_ring" ) )
	{
		CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>( info.GetWeapon() );
		if ( pWeapon )
		{
			CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
			if ( pItem && pItem->GetStaticData() && pItem->GetStaticData()->GetIconClassname() )
			{
				killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
				*iWeaponID = TF_WEAPON_NONE;
			}
		}
	}	
	else if ( 0 == Q_strcmp( killer_weapon_name, "obj_attachment_sapper" ) )
	{
		// let's look-up the sapper weapon to see what type it is
		if ( pScorer )
		{
			CTFPlayer *pTFScorer = ToTFPlayer( pScorer );
			if ( pTFScorer )
			{
				CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase *>( pTFScorer->GetEntityForLoadoutSlot( LOADOUT_POSITION_BUILDING ) );

				if ( pWeapon && ( pWeapon->GetWeaponID() == TF_WEAPON_BUILDER ) && pWeapon->GetAttributeContainer() )
				{
					CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
					if ( pItem && pItem->GetStaticData() )
					{
						if ( pItem->GetStaticData()->GetIconClassname() )
						{
							killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
							*iWeaponID = TF_WEAPON_NONE;
						}
					}
				}
			}
		}
	}
	else if ( ( info.GetDamageCustom() == TF_DMG_CUSTOM_STANDARD_STICKY ) || ( info.GetDamageCustom() == TF_DMG_CUSTOM_AIR_STICKY_BURST ) )
	{
		// let's look-up the secondary weapon to see what type of sticky launcher it is
		if ( pScorer )
		{
			CTFPlayer *pTFScorer = ToTFPlayer( pScorer );
			if ( pTFScorer )
			{
				CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase * >( pTFScorer->Weapon_GetWeaponByType( TF_WPN_TYPE_SECONDARY ) );
				if ( pWeapon && ( pWeapon->GetWeaponID() == TF_WEAPON_PIPEBOMBLAUNCHER ) && pWeapon->GetAttributeContainer() )
				{
					CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
					if ( pItem && pItem->GetStaticData() )
					{
						if ( pItem->GetStaticData()->GetIconClassname() )
						{
							killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
							*iWeaponID = TF_WEAPON_NONE;
						}
					}
				}
			}
		}
	}

	return killer_weapon_name;
}

//-----------------------------------------------------------------------------
// Purpose: returns the player who assisted in the kill, or NULL if no assister
//-----------------------------------------------------------------------------
CBasePlayer *CTFGameRules::GetAssister( CBasePlayer *pVictim, CBasePlayer *pScorer, CBaseEntity *pInflictor )
{
	CTFPlayer *pTFScorer = ToTFPlayer( pScorer );
	CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
	if ( pTFScorer && pTFVictim )
	{
		// if victim killed himself, don't award an assist to anyone else, even if there was a recent damager
		if ( pTFScorer == pTFVictim )
			return NULL;

		// If an assist has been specified already, use it.
		if ( pTFVictim->m_Shared.GetAssist() )
		{
			return pTFVictim->m_Shared.GetAssist();
		}

		// If a player is healing the scorer, give that player credit for the assist
		CTFPlayer *pHealer = ToTFPlayer( pTFScorer->m_Shared.GetFirstHealer() );
		// Must be a medic to receive a healing assist, otherwise engineers get credit for assists from dispensers doing healing.
		// Also don't give an assist for healing if the inflictor was a sentry gun, otherwise medics healing engineers get assists for the engineer's sentry kills.
		if ( pHealer && ( TF_CLASS_MEDIC == pHealer->GetPlayerClass()->GetClassIndex() ) && ( NULL == dynamic_cast<CObjectSentrygun *>( pInflictor ) ) )
		{
			return pHealer;
		}

		// If we're under the effect of a condition that grants assists, give one to the player that buffed us
		CTFPlayer *pCondAssister = ToTFPlayer( pTFScorer->m_Shared.GetConditionAssistFromAttacker() );
		if ( pCondAssister )
			return pCondAssister;

		// See who has damaged the victim 2nd most recently (most recent is the killer), and if that is within a certain time window.
		// If so, give that player an assist.  (Only 1 assist granted, to single other most recent damager.)
		CTFPlayer *pRecentDamager = GetRecentDamager( pTFVictim, 1, TF_TIME_ASSIST_KILL );
		if ( pRecentDamager && ( pRecentDamager != pScorer ) )
			return pRecentDamager;

		// if a teammate has recently helped this sentry (ie: wrench hit), they assisted in the kill
		CObjectSentrygun *sentry = dynamic_cast< CObjectSentrygun * >( pInflictor );
		if ( sentry )
		{
			CTFPlayer *pAssister = sentry->GetAssistingTeammate( TF_TIME_ASSIST_KILL );
			if ( pAssister )
				return pAssister;
		}
	}
	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Returns specified recent damager, if there is one who has done damage
//			within the specified time period.  iDamager=0 returns the most recent
//			damager, iDamager=1 returns the next most recent damager.
//-----------------------------------------------------------------------------
CTFPlayer *CTFGameRules::GetRecentDamager( CTFPlayer *pVictim, int iDamager, float flMaxElapsed )
{
	EntityHistory_t *damagerHistory = pVictim->m_AchievementData.GetDamagerHistory( iDamager );
	if ( !damagerHistory )
		return NULL;

	if ( damagerHistory->hEntity && ( gpGlobals->curtime - damagerHistory->flTimeDamage <= flMaxElapsed ) )
	{
		CTFPlayer *pRecentDamager = ToTFPlayer( damagerHistory->hEntity );
		if ( pRecentDamager )
			return pRecentDamager;
	}
	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Returns who should be awarded the kill
//-----------------------------------------------------------------------------
CBasePlayer *CTFGameRules::GetDeathScorer( CBaseEntity *pKiller, CBaseEntity *pInflictor, CBaseEntity *pVictim )
{
	if ( ( pKiller == pVictim ) && ( pKiller == pInflictor ) )
	{
		// If this was an explicit suicide, see if there was a damager within a certain time window.  If so, award this as a kill to the damager.
		CTFPlayer *pTFVictim = ToTFPlayer( pVictim );
		if ( pTFVictim )
		{
			CTFPlayer *pRecentDamager = GetRecentDamager( pTFVictim, 0, TF_TIME_SUICIDE_KILL_CREDIT );
			if ( pRecentDamager )
				return pRecentDamager;
		}
	}

	//Handle Pyro's Deflection credit.
	CTFWeaponBaseGrenadeProj *pBaseGrenade = dynamic_cast<CTFWeaponBaseGrenadeProj*>( pInflictor );

	if ( pBaseGrenade )
	{
		if ( pBaseGrenade->GetDeflected() )
		{
			if ( pBaseGrenade->GetWeaponID() == TF_WEAPON_GRENADE_PIPEBOMB )
			{
				CTFPlayer *pDeflectOwner = ToTFPlayer( pBaseGrenade->GetDeflectOwner() );

				if ( pDeflectOwner )
				{
					if ( pDeflectOwner->InSameTeam( pVictim ) == false )
						 return pDeflectOwner;
					else
					{
						pBaseGrenade->ResetDeflected();
						pBaseGrenade->SetDeflectOwner( NULL );
					}
				}
			}
		}
	}

	return BaseClass::GetDeathScorer( pKiller, pInflictor, pVictim );
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : *pVictim - 
//			*pKiller - 
//			*pInflictor - 
//-----------------------------------------------------------------------------
void CTFGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info )
{
	DeathNotice( pVictim, info, "player_death" );
}

void CTFGameRules::DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info, const char* eventName )
{
	int killer_ID = 0;

	// Find the killer & the scorer
	CTFPlayer *pTFPlayerVictim = ToTFPlayer( pVictim );
	CBaseEntity *pInflictor = info.GetInflictor();
	CBaseEntity *pKiller = info.GetAttacker();
	CTFPlayer *pScorer = ToTFPlayer( GetDeathScorer( pKiller, pInflictor, pVictim ) );
	CTFPlayer *pAssister = ToTFPlayer( GetAssister( pVictim, pScorer, pInflictor ) );
	
	// You can't assist yourself!
	Assert( pScorer != pAssister || !pScorer );
	if ( pScorer == pAssister && pScorer )
	{
		pAssister = NULL;
	}

	// Silent killers cause no death notices.
	bool bSilentKill = false;
	CTFPlayer *pAttacker = (CTFPlayer*)ToTFPlayer( info.GetAttacker() );
	if ( pAttacker )
	{
		CTFWeaponBase *pWpn = pAttacker->GetActiveTFWeapon();
		if ( pWpn && pWpn->IsSilentKiller() && ( info.GetDamageCustom() == TF_DMG_CUSTOM_BACKSTAB ) )
			bSilentKill = true;
	}

	// Determine whether it's a feign death fake death notice
	bool bFeignDeath = pTFPlayerVictim->IsGoingFeignDeath();
	if ( bFeignDeath )
	{
		CTFPlayer *pDisguiseTarget = ToTFPlayer( pTFPlayerVictim->m_Shared.GetDisguiseTarget() );
		if ( pDisguiseTarget && (pTFPlayerVictim->GetTeamNumber() == pDisguiseTarget->GetTeamNumber()) )
		{
			// We're disguised as a team mate. Pretend to die as that player instead of us.
			pVictim = pTFPlayerVictim = pDisguiseTarget;
		}
	}

	// Work out what killed the player, and send a message to all clients about it
	int iWeaponID;
	const char *killer_weapon_name = GetKillingWeaponName( info, pTFPlayerVictim, &iWeaponID );
	const char *killer_weapon_log_name = killer_weapon_name;

	// Kill eater events.
	{
		// Was this a sentry kill? If the sentry did the kill itself with bullets then it'll be the inflictor.
		// If it got the kill by firing a rocket, the rocket will be the inflictor and the sentry will be the
		// owner of the rocket.
		//
		// Holy crap dynamic_cast quagmire of sadness below.
		CObjectSentrygun *pSentrygun = dynamic_cast<CObjectSentrygun *>( pInflictor );
		if ( !pSentrygun )
		{
			pSentrygun = pInflictor ? dynamic_cast<CObjectSentrygun *>( pInflictor->GetOwnerEntity() ) : NULL;
		}

		if ( pSentrygun )
		{
			// Try to grab the wrench that the engineer has equipped right now. We destroy sentries when wrenches
			// get changed so whatever they have equipped right now counts for the wrench that built this sentry.
			CTFPlayer *pBuilder = pSentrygun->GetBuilder();
			if ( pBuilder )
			{
				EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_MELEE ) ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsBySentry );
				// PDA's Also count Sentry kills
				EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_PDA ) ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsBySentry );

				// Check if the engineer is using a Wrangler on this sentry
				CTFLaserPointer* pLaserPointer = dynamic_cast< CTFLaserPointer * >( pBuilder->GetEntityForLoadoutSlot( LOADOUT_POSITION_SECONDARY ) );
				if ( pLaserPointer && pLaserPointer->HasLaserDot() )
				{
					EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pLaserPointer ), pScorer, pTFPlayerVictim, kKillEaterEvent_PlayerKillsByManualControlOfSentry );
				}
			}
		}

		// Should we award an assist kill to someone?
		if ( pAssister )
		{
			EconEntity_OnOwnerKillEaterEvent( dynamic_cast<CEconEntity *>( pAssister->GetActiveWeapon() ), pAssister, pTFPlayerVictim, kKillEaterEvent_PlayerKillAssist );
			HatAndMiscEconEntities_OnOwnerKillEaterEvent( pAssister, pTFPlayerVictim, kKillEaterEvent_CosmeticAssists );
		}
	}

	if ( pScorer )	// Is the killer a client?
	{
		killer_ID = pScorer->GetUserID();
	}

	CTFWeaponBase *pScorerWeapon = NULL;
	if ( pScorer )
	{
		pScorerWeapon = dynamic_cast< CTFWeaponBase * >( pScorer->Weapon_OwnsThisID( iWeaponID ) );
		if ( pScorerWeapon )
		{
			CEconItemView *pItem = pScorerWeapon->GetAttributeContainer()->GetItem();

			if ( pItem )
			{
				if ( pItem->GetStaticData()->GetIconClassname() )
				{
					killer_weapon_name = pItem->GetStaticData()->GetIconClassname();
				}
			
				if ( pItem->GetStaticData()->GetLogClassname() )
				{
					killer_weapon_log_name = pItem->GetStaticData()->GetLogClassname();
				}
			}
		}
	}

	// In Arena mode award first blood to the first player that kills an enemy.
	bool bKillWasFirstBlood = false;
	if ( IsFirstBloodAllowed() )
	{
		if ( pScorer && pVictim && pScorer != pVictim )
		{
			if ( !FStrEq( eventName, "fish_notice" ) && !FStrEq( eventName, "fish_notice__arm" ) && !FStrEq( eventName, "throwable_hit" ) )
			{
#ifndef _DEBUG
				if ( GetGlobalTeam( pVictim->GetTeamNumber() ) && GetGlobalTeam( pVictim->GetTeamNumber() )->GetNumPlayers() > 1 )
#endif // !DEBUG
				{
					float flFastTime = IsCompetitiveMode() ? 120.f : TF_ARENA_MODE_FAST_FIRST_BLOOD_TIME;
					float flSlowTime = IsCompetitiveMode() ? 300.f : TF_ARENA_MODE_SLOW_FIRST_BLOOD_TIME;

					if ( ( gpGlobals->curtime - m_flRoundStartTime ) <= flFastTime )
					{
						BroadcastSound( 255, "Announcer.AM_FirstBloodFast" );
					}
					else if ( ( gpGlobals->curtime - m_flRoundStartTime ) >= flSlowTime )
					{
						BroadcastSound( 255, "Announcer.AM_FirstBloodFinally" );
					}
					else
					{
						BroadcastSound( 255, "Announcer.AM_FirstBloodRandom" );
					}

					m_bArenaFirstBlood = true;
					bKillWasFirstBlood = true;

					if ( IsCompetitiveMode() )
					{
// 						CTF_GameStats.Event_PlayerAwardBonusPoints( pScorer, pVictim, 10 );
// 						
// 						CUtlVector< CTFPlayer* > vecPlayers;
// 						CollectPlayers( &vecPlayers, pScorer->GetTeamNumber(), false );
// 						FOR_EACH_VEC( vecPlayers, i )
// 						{
// 							if ( !vecPlayers[i] )
// 								continue;
// 
// 							if ( vecPlayers[i] == pScorer )
// 								continue;
// 
// 							CTF_GameStats.Event_PlayerAwardBonusPoints( vecPlayers[i], pVictim, 5 );
// 						}
					}
					else
					{
						pScorer->m_Shared.AddCond( TF_COND_CRITBOOSTED_FIRST_BLOOD, TF_ARENA_MODE_FIRST_BLOOD_CRIT_TIME );
					}
				}
			}
		}
	}
	else
	{
		// so you can't turn on the ConVar in the middle of a round and get the first blood reward
		m_bArenaFirstBlood = true;
	}

	// Awesome hack for pyroland silliness: if there was no other assister, and the person that got
	// the kill has some sort of "pet" item (balloonicorn, brainslug, etc.), we send the name of
	// that item down as the assister. We'll use a custom name if available and fall back to the
	// localization token (localized on the client) if not.
	CUtlConstString sAssisterOverrideDesc;

	if ( pScorer && !pAssister )
	{
		// Find out whether the killer has at least one item that will ask for kill assist credit.
		int iKillerHasPetItem = 0;
		CUtlVector<CBaseEntity *> vecItems;
		CALL_ATTRIB_HOOK_FLOAT_ON_OTHER_WITH_ITEMS( pScorer, iKillerHasPetItem, &vecItems, counts_as_assister );

		FOR_EACH_VEC( vecItems, i )
		{
			CEconEntity *pEconEntity = dynamic_cast<CEconEntity *>( vecItems[i] );
			if ( !pEconEntity )
				continue;

			CEconItemView *pEconItemView = pEconEntity->GetAttributeContainer()->GetItem();
			if ( !pEconItemView )
				continue;

			if ( pEconItemView->GetCustomName() )
			{
				sAssisterOverrideDesc = CFmtStr( "%c%s", iKillerHasPetItem == 2 ? kHorriblePyroVisionHack_KillAssisterType_CustomName_First : kHorriblePyroVisionHack_KillAssisterType_CustomName, pEconItemView->GetCustomName() );
			}
			else
			{
				sAssisterOverrideDesc = CFmtStr( "%c%s", iKillerHasPetItem == 2 ? kHorriblePyroVisionHack_KillAssisterType_LocalizationString_First : kHorriblePyroVisionHack_KillAssisterType_LocalizationString, pEconItemView->GetItemDefinition()->GetItemBaseName() ).Get();
			}
			break;
		}
	}

	IGameEvent * event = gameeventmanager->CreateEvent( eventName /* "player_death" */ );

	//if ( event && FStrEq( eventName, "throwable_hit" ) )
	//{
	//	int iHitCount = 1;
	//	PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pScorer );
	//	if ( pStats )
	//	{
	//		iHitCount = pStats->statsAccumulated.Get( TFSTAT_THROWABLEHIT );
	//	}

	//	event->SetInt( "totalhits", iHitCount );
	//}

	if ( event )
	{
		event->SetInt( "userid", pVictim->GetUserID() );
		event->SetInt( "victim_entindex", pVictim->entindex() );
		event->SetInt( "attacker", killer_ID );
		event->SetInt( "assister", pAssister ? pAssister->GetUserID() : -1 );
		event->SetString( "weapon", killer_weapon_name );
		event->SetString( "weapon_logclassname", killer_weapon_log_name );
		event->SetInt( "weaponid", iWeaponID );
		event->SetInt( "damagebits", info.GetDamageType() );
		event->SetInt( "customkill", info.GetDamageCustom() );
		event->SetInt( "inflictor_entindex", pInflictor ? pInflictor->entindex() : -1 );
		event->SetInt( "priority", 7 );	// HLTV event priority, not transmitted

		if ( info.GetPlayerPenetrationCount() > 0 )
		{
			event->SetInt( "playerpenetratecount", info.GetPlayerPenetrationCount() );
		}

		if ( !sAssisterOverrideDesc.IsEmpty() )
		{
			event->SetString( "assister_fallback", sAssisterOverrideDesc.Get() );
		}

		event->SetBool( "silent_kill", bSilentKill );

		int iDeathFlags = pTFPlayerVictim->GetDeathFlags();

		if ( bKillWasFirstBlood )
		{
			iDeathFlags |= TF_DEATH_FIRST_BLOOD;
		}

		if ( bFeignDeath )
		{
			iDeathFlags |= TF_DEATH_FEIGN_DEATH;
		}

		if ( pTFPlayerVictim->WasGibbedOnLastDeath() )
		{
			iDeathFlags |= TF_DEATH_GIBBED;
		}

		if ( pTFPlayerVictim->IsInPurgatory() )
		{
			iDeathFlags |= TF_DEATH_PURGATORY;
		}

		if ( pTFPlayerVictim->IsMiniBoss() )
		{
			iDeathFlags |= TF_DEATH_MINIBOSS;
		}

		// Australium Guns get a Gold Background
		IHasAttributes *pAttribInterface = GetAttribInterface( info.GetWeapon() );
		if ( pAttribInterface )
		{
			int iIsAustralium = 0;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( info.GetWeapon(), iIsAustralium, is_australium_item );
			if ( iIsAustralium )
			{
				iDeathFlags |= TF_DEATH_AUSTRALIUM;
			}
		}

		// We call this directly since we need more information than provided in the event alone.
		if ( FStrEq( eventName, "player_death" ) )
		{
			CTF_GameStats.Event_KillDetail( pScorer, pTFPlayerVictim, pAssister, event, info );
			event->SetInt( "kill_streak_victim", pTFPlayerVictim->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Kills ) );
			event->SetBool( "rocket_jump", ( pTFPlayerVictim->RocketJumped() == 1 ) );
			event->SetInt( "crit_type", info.GetCritType() );

			// Kill streak updating
			if ( pTFPlayerVictim && pScorer && pTFPlayerVictim != pScorer )
			{
				// Propagate duckstreaks
				event->SetInt( "duck_streak_victim", pTFPlayerVictim->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Ducks ) );
				event->SetInt( "duck_streak_total", pScorer->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Ducks ) );
				event->SetInt( "ducks_streaked", pScorer->m_Shared.GetLastDuckStreakIncrement() );

				// Check if they have the appropriate attribute.
				int iKillStreak = 0;
				int iKills = 0;
				CBaseEntity *pKillStreakTarget = NULL;
				if ( !pAttribInterface )
				{
					// Check if you are a sentry and if so, use the wrench
					// For Sentries Inflictor can be the sentry (bullets) or the Sentry Rocket

					CObjectSentrygun *pSentry = dynamic_cast<CObjectSentrygun*>( pInflictor );
					if ( !pSentry && pInflictor )
					{
						pSentry = dynamic_cast<CObjectSentrygun*>( pInflictor->GetOwnerEntity() );
					}

					if ( pSentry )
					{
						pKillStreakTarget = dynamic_cast<CTFWeaponBase*>( pScorer->GetEntityForLoadoutSlot( LOADOUT_POSITION_MELEE ) );
					}
				}
				else
				{
					pKillStreakTarget = info.GetWeapon();
				}

				if ( pKillStreakTarget )
				{
					CALL_ATTRIB_HOOK_INT_ON_OTHER( pKillStreakTarget, iKillStreak, killstreak_tier );
#ifdef STAGING_ONLY
					if ( tf_killstreak_alwayson.GetBool() )
					{
						iKillStreak = 1;
					}
#endif
					// Always track killstreak regardless of the attribute for data collection purposes
					pScorer->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_KillsAll, 1 );
					if ( iKillStreak )
					{
						iKills = pScorer->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Kills, 1 );
						event->SetInt( "kill_streak_total", iKills );

						int iWepKills = 0;
						CTFWeaponBase *pWeapon = dynamic_cast<CTFWeaponBase*>( pKillStreakTarget );
						if ( pWeapon )
						{
							iWepKills = pWeapon->GetKillStreak() + 1;
							pWeapon->SetKillStreak( iWepKills );
						}
						else
						{
							CTFWearable *pWearable = dynamic_cast<CTFWearable*>( pKillStreakTarget );
							if ( pWearable )
							{
								iWepKills = pWearable->GetKillStreak() + 1;
								pWearable->SetKillStreak( iWepKills );
							}
						}

						event->SetInt( "kill_streak_wep", iWepKills );

						// Track each player's max streak per-round
						CTF_GameStats.Event_PlayerEarnedKillStreak( pScorer );
					}
				}

				if ( pAssister )
				{
					event->SetInt( "duck_streak_assist", pAssister->m_Shared.GetStreak( CTFPlayerShared::kTFStreak_Ducks ) );

					// Only allow assists for Mediguns
					CTFWeaponBase *pAssisterWpn = pAssister->GetActiveTFWeapon();
					if ( pAssisterWpn && pAssister->IsPlayerClass( TF_CLASS_MEDIC ) )
					{
						CWeaponMedigun *pMedigun = dynamic_cast<CWeaponMedigun*>( pAssisterWpn );
						if ( pMedigun )
						{
							iKillStreak = 0;
							CALL_ATTRIB_HOOK_INT_ON_OTHER( pAssisterWpn, iKillStreak, killstreak_tier );
#ifdef STAGING_ONLY
							if ( tf_killstreak_alwayson.GetBool() )
							{
								iKillStreak = 1;
							}
#endif
							if ( iKillStreak )
							{
								iKills = pAssister->m_Shared.IncrementStreak( CTFPlayerShared::kTFStreak_Kills, 1 );
								event->SetInt( "kill_streak_assist", iKills );

								int iWepKills = pAssisterWpn->GetKillStreak() + 1;
								pAssisterWpn->SetKillStreak( iWepKills );

								// Track each player's max streak per-round
								CTF_GameStats.Event_PlayerEarnedKillStreak( pAssister );
							}
						}
					}
				}
			}
		}

		event->SetInt( "death_flags", iDeathFlags );	
		event->SetInt( "stun_flags", pTFPlayerVictim->m_iOldStunFlags );

		item_definition_index_t weaponDefIndex = INVALID_ITEM_DEF_INDEX;
		if ( pScorerWeapon )
		{
			CEconItemView *pItem = pScorerWeapon->GetAttributeContainer()->GetItem();
			if ( pItem )
			{
				weaponDefIndex = pItem->GetItemDefIndex();
			}
		}
		else if ( pScorer && pScorer->GetActiveTFWeapon() )
		{
			// get from active weapon instead
			CEconItemView *pItem = pScorer->GetActiveTFWeapon()->GetAttributeContainer()->GetItem();
			if ( pItem )
			{
				weaponDefIndex = pItem->GetItemDefIndex();
			}
		}
		event->SetInt( "weapon_def_index", weaponDefIndex );

		pTFPlayerVictim->m_iOldStunFlags = 0;

		gameeventmanager->FireEvent( event );
	}	
}

void CTFGameRules::ClientDisconnected( edict_t *pClient )
{
	CTFPlayer *pPlayer = ToTFPlayer( GetContainingEntity( pClient ) );
	if ( pPlayer )
	{
		// ACHIEVEMENT_TF_PYRO_DOMINATE_LEAVESVR - Pyro causes a dominated player to leave the server
		for ( int i = 1; i <= gpGlobals->maxClients ; i++ )
		{
			if ( pPlayer->m_Shared.IsPlayerDominatingMe(i) )
			{
				CTFPlayer *pDominatingPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
				if ( pDominatingPlayer && pDominatingPlayer != pPlayer )
				{
					if ( pDominatingPlayer->IsPlayerClass(TF_CLASS_PYRO) )
					{
						pDominatingPlayer->AwardAchievement( ACHIEVEMENT_TF_PYRO_DOMINATE_LEAVESVR );
					}
				}
			}
		}

		CTFPlayerResource *pTFResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource );		
		if ( pTFResource )
		{
			if ( pPlayer->entindex() == pTFResource->GetPartyLeaderIndex( pPlayer->GetTeamNumber() ) )
			{
				// the leader is leaving so reset the player resource index
				pTFResource->SetPartyLeaderIndex( pPlayer->GetTeamNumber(), 0 ); 
			}
		}

		// Notify gamestats that the player left.
		CTF_GameStats.Event_PlayerDisconnectedTF( pPlayer );

		// Check Ready status for the player
		if ( UsePlayerReadyStatusMode() )
		{
			if ( !pPlayer->IsBot() && State_Get() != GR_STATE_RND_RUNNING )
			{
				const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
				if ( !pMatchDesc || !pMatchDesc->m_params.m_bAutoReady )
				{
					// Always reset when a player leaves this type of match
					PlayerReadyStatus_ResetState();
				}
				else if ( !IsTeamReady( pPlayer->GetTeamNumber() ) )
				{
					if ( IsPlayerReady( pPlayer->entindex() ) )
					{
						// Clear the ready status so it doesn't block the rest of the team
						PlayerReadyStatus_UpdatePlayerState( pPlayer, false );
					}
					else
					{
						// Disconnecting player wasn't ready, but is the rest of the team?
						// If so, we want to cancel the ready_state so it doesn't start right away when this player disconnects
						bool bEveryoneReady = true;
						CUtlVector<CTFPlayer *> playerVector;
						CollectPlayers( &playerVector, pPlayer->GetTeamNumber() );
						FOR_EACH_VEC( playerVector, i )
						{
							if ( !playerVector[i] )
								continue;

							if ( playerVector[i]->IsBot() )
								continue;

							if ( playerVector[i] == pPlayer )
								continue;

							if ( !IsPlayerReady( playerVector[i]->entindex() ) )
							{
								bEveryoneReady = false;
							}
						}

						if ( bEveryoneReady )
						{
							PlayerReadyStatus_ResetState();
						}
					}
				}
				else
				{
					// If we're currently in a countdown we should cancel it
					if ( ( m_flRestartRoundTime > 0 ) || ( mp_restartgame.GetInt() > 0 ) )
					{
						PlayerReadyStatus_ResetState();
					}
				}
			}
		}

		// clean up anything they left behind
		pPlayer->TeamFortress_ClientDisconnected();
		Arena_ClientDisconnect( pPlayer->GetPlayerName() );
	}

	BaseClass::ClientDisconnected( pClient );

	// are any of the spies disguising as this player?
	for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
	{
		CTFPlayer *pTemp = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pTemp && pTemp != pPlayer )
		{
			if ( pTemp->m_Shared.GetDisguiseTarget() == pPlayer )
			{
				// choose someone else...
				pTemp->m_Shared.FindDisguiseTarget();
			}
		}
	}
}

// Falling damage stuff.
#define TF_PLAYER_MAX_SAFE_FALL_SPEED	650		

float CTFGameRules::FlPlayerFallDamage( CBasePlayer *pPlayer )
{
	CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
	if ( !pTFPlayer )
		return 0;

	// Karts don't take fall damage
	if ( pTFPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_KART ) )
	{
		return 0;
	}

	// grappling hook don't take fall damage
	if ( pTFPlayer->GetGrapplingHookTarget() )
	{
		return 0;
	}

	if ( pTFPlayer->m_Shared.GetCarryingRuneType() == RUNE_AGILITY )
	{
		return 0;
	}

	if ( pPlayer->m_Local.m_flFallVelocity > TF_PLAYER_MAX_SAFE_FALL_SPEED )
	{
		// Old TFC damage formula
		float flFallDamage = 5 * (pPlayer->m_Local.m_flFallVelocity / 300);

		// Fall damage needs to scale according to the player's max health, or
		// it's always going to be much more dangerous to weaker classes than larger.
		float flRatio = (float)pPlayer->GetMaxHealth() / 100.0;
		flFallDamage *= flRatio;

		flFallDamage *= random->RandomFloat( 0.8, 1.2 );

		int iCancelFallingDamage = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iCancelFallingDamage, cancel_falling_damage );
		if ( iCancelFallingDamage > 0 )
			flFallDamage = 0;

		return flFallDamage;
	}

	// Fall caused no damage
	return 0;
}

void CTFGameRules::SendArenaWinPanelInfo( void )
{
	IGameEvent *winEvent = gameeventmanager->CreateEvent( "arena_win_panel" );

	if ( winEvent )
	{
		int iBlueScore = GetGlobalTeam( TF_TEAM_BLUE )->GetScore();
		int iRedScore = GetGlobalTeam( TF_TEAM_RED )->GetScore();
		int iBlueScorePrev = iBlueScore;
		int iRedScorePrev = iRedScore;

		// if this is a complete round, calc team scores prior to this win
		switch ( m_iWinningTeam )
		{
		case TF_TEAM_BLUE:
			{
				iBlueScorePrev = ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0;

				if ( IsInTournamentMode() == false )
				{
					iRedScore = 0;
				}
			}
			break;

		case TF_TEAM_RED:
			{
				iRedScorePrev = ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0;

				if ( IsInTournamentMode() == false )
				{
					iBlueScore = 0;
				}

				break;
			}
		case TEAM_UNASSIGNED:
			break;	// stalemate; nothing to do
		}

		winEvent->SetInt( "panel_style", WINPANEL_BASIC );
		winEvent->SetInt( "winning_team", m_iWinningTeam );
		winEvent->SetInt( "winreason", m_iWinReason );
		winEvent->SetString( "cappers",  ( m_iWinReason == WINREASON_ALL_POINTS_CAPTURED || m_iWinReason == WINREASON_FLAG_CAPTURE_LIMIT ) ? m_szMostRecentCappers : "" );
		winEvent->SetInt( "blue_score", iBlueScore );
		winEvent->SetInt( "red_score", iRedScore );
		winEvent->SetInt( "blue_score_prev", iBlueScorePrev );
		winEvent->SetInt( "red_score_prev", iRedScorePrev );
		
		CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource * >( g_pPlayerResource );
		if ( !pResource )
			return;

		// build a vector of players & round scores
		CUtlVector<PlayerArenaRoundScore_t> vecPlayerScore;
		int iPlayerIndex;
		for( iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
		{
			CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
			if ( !pTFPlayer || !pTFPlayer->IsConnected() )
				continue;
			// filter out spectators and, if not stalemate, all players not on winning team
			int iPlayerTeam = pTFPlayer->GetTeamNumber();
			if ( ( iPlayerTeam < FIRST_GAME_TEAM ) )
				continue;

			PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pTFPlayer );
			PlayerArenaRoundScore_t &playerRoundScore = vecPlayerScore[vecPlayerScore.AddToTail()];

			playerRoundScore.iPlayerIndex = iPlayerIndex;

			if ( pStats )
			{
				playerRoundScore.iTotalDamage = pStats->statsCurrentRound.m_iStat[TFSTAT_DAMAGE];
				playerRoundScore.iTotalHealing = pStats->statsCurrentRound.m_iStat[TFSTAT_HEALING];

				if ( pTFPlayer->IsAlive() == true )
				{
					playerRoundScore.iTimeAlive = (int)gpGlobals->curtime - pTFPlayer->GetSpawnTime();
				}
				else
				{
					playerRoundScore.iTimeAlive = (int)pTFPlayer->GetDeathTime() - pTFPlayer->GetSpawnTime();
				}
					
				playerRoundScore.iKillingBlows = pStats->statsCurrentRound.m_iStat[TFSTAT_KILLS];
				playerRoundScore.iScore = CalcPlayerScore( &pStats->statsCurrentRound, pTFPlayer );
			}
		}

		// sort the players by round score
		vecPlayerScore.Sort( PlayerArenaRoundScoreSortFunc );

		// set the top (up to) 6 players by round score in the event data
		int numPlayers = 6;
		int iPlayersAdded = 0;

		// Add winners first
		for ( int i = 0; i < vecPlayerScore.Count(); i++ )
		{
			if (  GetWinningTeam() == TEAM_UNASSIGNED )
			{
				if ( iPlayersAdded >= 6 )
					break;
			}
			else
			{
				if ( iPlayersAdded >= 3 )
					break;
			}

			int iPlayerIndex = vecPlayerScore[i].iPlayerIndex;

			CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );

			if ( pTFPlayer && pTFPlayer->GetTeamNumber() != GetWinningTeam() && GetWinningTeam() != TEAM_UNASSIGNED )
				continue;

			winEvent->SetInt( UTIL_VarArgs( "player_%d", iPlayersAdded + 1 ), vecPlayerScore[i].iPlayerIndex );
			winEvent->SetInt( UTIL_VarArgs( "player_%d_damage", iPlayersAdded + 1 ), vecPlayerScore[i].iTotalDamage );				
			winEvent->SetInt( UTIL_VarArgs( "player_%d_healing", iPlayersAdded + 1 ), vecPlayerScore[i].iTotalHealing );
			winEvent->SetInt( UTIL_VarArgs( "player_%d_lifetime", iPlayersAdded + 1 ), vecPlayerScore[i].iTimeAlive );
			winEvent->SetInt( UTIL_VarArgs( "player_%d_kills", iPlayersAdded + 1 ), vecPlayerScore[i].iKillingBlows );

			iPlayersAdded++;
		}

		if ( GetWinningTeam() != TEAM_UNASSIGNED )
		{
			//Now add the rest
			iPlayersAdded = 3;

			for ( int i = 0; i < vecPlayerScore.Count(); i++ )
			{
				if ( iPlayersAdded >= numPlayers )
					break;

				int iIndex = iPlayersAdded + 1;

				int iPlayerIndex = vecPlayerScore[i].iPlayerIndex;

				CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );

				if ( pTFPlayer && pTFPlayer->GetTeamNumber() == GetWinningTeam() )
					continue;

				winEvent->SetInt( UTIL_VarArgs( "player_%d", iIndex ), vecPlayerScore[i].iPlayerIndex );
				winEvent->SetInt( UTIL_VarArgs( "player_%d_damage", iIndex ), vecPlayerScore[i].iTotalDamage );				
				winEvent->SetInt( UTIL_VarArgs( "player_%d_healing", iIndex ), vecPlayerScore[i].iTotalHealing );
				winEvent->SetInt( UTIL_VarArgs( "player_%d_lifetime", iIndex ), vecPlayerScore[i].iTimeAlive );
				winEvent->SetInt( UTIL_VarArgs( "player_%d_kills", iIndex ), vecPlayerScore[i].iKillingBlows );

				iPlayersAdded++;
			}
		}

		// Send the event
		gameeventmanager->FireEvent( winEvent );
	}
}

void CTFGameRules::SendPVEWinPanelInfo( void )
{
	IGameEvent *winEvent = gameeventmanager->CreateEvent( "pve_win_panel" );

	if ( winEvent )
	{
		winEvent->SetInt( "panel_style", WINPANEL_BASIC );
		winEvent->SetInt( "winning_team", m_iWinningTeam );
		winEvent->SetInt( "winreason", 0 );

		// Send the event
		gameeventmanager->FireEvent( winEvent );
	}

	/*CBroadcastRecipientFilter filter;
	filter.MakeReliable();
	UserMessageBegin( filter, "MVMAnnouncement" );
		WRITE_CHAR( TF_MVM_ANNOUNCEMENT_WAVE_FAILED );
		WRITE_CHAR( -1 );
	MessageEnd();*/
}

void CTFGameRules::SendWinPanelInfo( bool bGameOver )
{
	if ( IsInArenaMode() == true )
	{
		SendArenaWinPanelInfo();
		return;
	}

	if ( IsPVEModeActive() )
	{
		SendPVEWinPanelInfo();
		return;
	}

	IGameEvent *winEvent = gameeventmanager->CreateEvent( "teamplay_win_panel" );

	if ( winEvent )
	{
		int iBlueScore = GetGlobalTeam( TF_TEAM_BLUE )->GetScore();
		int iRedScore = GetGlobalTeam( TF_TEAM_RED )->GetScore();
		int iBlueScorePrev = iBlueScore;
		int iRedScorePrev = iRedScore;

		bool bRoundComplete = m_bForceMapReset || ( IsGameUnderTimeLimit() && ( GetTimeLeft() <= 0 ) );

		CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
		bool bScoringPerCapture = ( pMaster ) ? ( pMaster->ShouldScorePerCapture() ) : false;

		if ( m_nGameType == TF_GAMETYPE_CTF )
		{
			if ( tf_flag_caps_per_round.GetInt() == 0 )
			{
				bScoringPerCapture = true;
			}
		}

		if ( bRoundComplete && !bScoringPerCapture && m_bUseAddScoreAnim )
		{
			// if this is a complete round, calc team scores prior to this win
			switch ( m_iWinningTeam )
			{
			case TF_TEAM_BLUE:
				iBlueScorePrev = ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iBlueScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0;
				break;
			case TF_TEAM_RED:
				iRedScorePrev = ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE >= 0 ) ? ( iRedScore - TEAMPLAY_ROUND_WIN_SCORE ) : 0;
				break;
			case TEAM_UNASSIGNED:
				break;	// stalemate; nothing to do
			}
		}
				
		winEvent->SetInt( "panel_style", WINPANEL_BASIC );
		winEvent->SetInt( "winning_team", m_iWinningTeam );
		winEvent->SetInt( "winreason", m_iWinReason );
		winEvent->SetString( "cappers",  ( m_iWinReason == WINREASON_ALL_POINTS_CAPTURED || m_iWinReason == WINREASON_FLAG_CAPTURE_LIMIT ) ?
							 m_szMostRecentCappers : "" );
		winEvent->SetInt( "flagcaplimit", IsPasstimeMode() ? tf_passtime_scores_per_round.GetInt() : tf_flag_caps_per_round.GetInt() );
		winEvent->SetInt( "blue_score", iBlueScore );
		winEvent->SetInt( "red_score", iRedScore );
		winEvent->SetInt( "blue_score_prev", iBlueScorePrev );
		winEvent->SetInt( "red_score_prev", iRedScorePrev );
		winEvent->SetInt( "round_complete", bRoundComplete );

		CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource * >( g_pPlayerResource );
		if ( !pResource )
			return;

		// Highest killstreak
		int nMaxStreakPlayerIndex = 0;
		int nMaxStreakCount = 0;
	 
		// determine the 3 players on winning team who scored the most points this round

		// build a vector of players & round scores
		CUtlVector<PlayerRoundScore_t> vecPlayerScore;
		int iPlayerIndex;
		for( iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
		{
			CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
			if ( !pTFPlayer || !pTFPlayer->IsConnected() )
				continue;
			// filter out spectators and, if not stalemate, all players not on winning team
			int iPlayerTeam = pTFPlayer->GetTeamNumber();
			if ( ( iPlayerTeam < FIRST_GAME_TEAM ) || ( m_iWinningTeam != TEAM_UNASSIGNED && ( m_iWinningTeam != iPlayerTeam ) ) )
				continue;

			int iRoundScore = 0, iTotalScore = 0;
			PlayerStats_t *pStats = CTF_GameStats.FindPlayerStats( pTFPlayer );
			if ( pStats )
			{
				iRoundScore = CalcPlayerScore( &pStats->statsCurrentRound, pTFPlayer );
				iTotalScore = CalcPlayerScore( &pStats->statsAccumulated, pTFPlayer );
			}

			PlayerRoundScore_t &playerRoundScore = vecPlayerScore[vecPlayerScore.AddToTail()];

			playerRoundScore.iRoundScore = iRoundScore;
			playerRoundScore.iPlayerIndex = iPlayerIndex;
			playerRoundScore.iTotalScore = iTotalScore;

			// Highest killstreak?
			PlayerStats_t *pPlayerStats = CTF_GameStats.FindPlayerStats( pTFPlayer );
			if ( pPlayerStats ) 
			{
				int nMax = pPlayerStats->statsCurrentRound.m_iStat[TFSTAT_KILLSTREAK_MAX];
				if ( nMax > nMaxStreakCount )
				{
					nMaxStreakCount = nMax;
					nMaxStreakPlayerIndex = iPlayerIndex;
				}
			}
		}

		// sort the players by round score
		vecPlayerScore.Sort( PlayerRoundScoreSortFunc );

		// set the top (up to) 6 players by round score in the event data
		int numPlayers = MIN( 6, vecPlayerScore.Count() );
		for ( int i = 0; i < numPlayers; i++ )
		{
			// only include players who have non-zero points this round; if we get to a player with 0 round points, stop
			if ( 0 == vecPlayerScore[i].iRoundScore )
				break;

			// set the player index and their round score in the event
			char szPlayerIndexVal[64]="", szPlayerScoreVal[64]="";
			Q_snprintf( szPlayerIndexVal, ARRAYSIZE( szPlayerIndexVal ), "player_%d", i+ 1 );
			Q_snprintf( szPlayerScoreVal, ARRAYSIZE( szPlayerScoreVal ), "player_%d_points", i+ 1 );
			winEvent->SetInt( szPlayerIndexVal, vecPlayerScore[i].iPlayerIndex );
			winEvent->SetInt( szPlayerScoreVal, vecPlayerScore[i].iRoundScore );				
		}

		winEvent->SetInt( "killstreak_player_1", nMaxStreakPlayerIndex );
		winEvent->SetInt( "killstreak_player_1_count", nMaxStreakCount );

#ifdef TF_RAID_MODE
		if ( !bRoundComplete && ( TEAM_UNASSIGNED != m_iWinningTeam ) && !IsRaidMode() )
#else
		if ( !bRoundComplete && ( TEAM_UNASSIGNED != m_iWinningTeam ) )
#endif // TF_RAID_MODE
		{
			// is this our new payload race game mode?
			if ( ( m_nGameType == TF_GAMETYPE_ESCORT ) && ( m_bMultipleTrains == true ) )
			{
				if ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] && g_hControlPointMasters[0]->PlayingMiniRounds() )
				{
					int nRoundsRemaining = g_hControlPointMasters[0]->NumPlayableControlPointRounds();
					if ( nRoundsRemaining > 0 )
					{
						winEvent->SetInt( "rounds_remaining", nRoundsRemaining );
					}
				}
			}
			else
			{
				// if this was not a full round ending, include how many mini-rounds remain for winning team to win
				if ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] )
				{
					winEvent->SetInt( "rounds_remaining", g_hControlPointMasters[0]->CalcNumRoundsRemaining( m_iWinningTeam ) );
				}
			}
		}

		winEvent->SetBool( "game_over", bGameOver );

		// Send the event
		gameeventmanager->FireEvent( winEvent );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Sorts players by round score
//-----------------------------------------------------------------------------
int CTFGameRules::PlayerRoundScoreSortFunc( const PlayerRoundScore_t *pRoundScore1, const PlayerRoundScore_t *pRoundScore2 )
{
	// sort first by round score	
	if ( pRoundScore1->iRoundScore != pRoundScore2->iRoundScore )
		return pRoundScore2->iRoundScore - pRoundScore1->iRoundScore;

	// if round scores are the same, sort next by total score
	if ( pRoundScore1->iTotalScore != pRoundScore2->iTotalScore )
		return pRoundScore2->iTotalScore - pRoundScore1->iTotalScore;

	// if scores are the same, sort next by player index so we get deterministic sorting
	return ( pRoundScore2->iPlayerIndex - pRoundScore1->iPlayerIndex );
}

//-----------------------------------------------------------------------------
// Purpose: Sorts players by arena stats
//-----------------------------------------------------------------------------
int CTFGameRules::PlayerArenaRoundScoreSortFunc( const PlayerArenaRoundScore_t *pRoundScore1, const PlayerArenaRoundScore_t *pRoundScore2 )
{
	//Compare Total points first
	//This gives us a rough estimate of performance
	if ( pRoundScore1->iScore != pRoundScore2->iScore )
		return pRoundScore2->iScore - pRoundScore1->iScore;

	//Compare healing
	if ( pRoundScore1->iTotalHealing != pRoundScore2->iTotalHealing )
		return pRoundScore2->iTotalHealing - pRoundScore1->iTotalHealing;

	//Compare damage
	if ( pRoundScore1->iTotalDamage != pRoundScore2->iTotalDamage )
		return pRoundScore2->iTotalDamage - pRoundScore1->iTotalDamage;

	//Compare time alive
	if ( pRoundScore1->iTimeAlive != pRoundScore2->iTimeAlive )
		return pRoundScore2->iTimeAlive - pRoundScore1->iTimeAlive;

	//Compare killing blows
	if ( pRoundScore1->iKillingBlows != pRoundScore2->iKillingBlows )
		return pRoundScore2->iKillingBlows - pRoundScore1->iKillingBlows;

	// if scores are the same, sort next by player index so we get deterministic sorting
	return ( pRoundScore2->iPlayerIndex - pRoundScore1->iPlayerIndex );
}

//-----------------------------------------------------------------------------
// Purpose: Called when the teamplay_round_win event is about to be sent, gives
//			this method a chance to add more data to it
//-----------------------------------------------------------------------------
void CTFGameRules::FillOutTeamplayRoundWinEvent( IGameEvent *event )
{
	event->SetInt( "flagcaplimit", IsPasstimeMode() ? tf_passtime_scores_per_round.GetInt() : tf_flag_caps_per_round.GetInt() );

	// determine the losing team
	int iLosingTeam;

	switch( event->GetInt( "team" ) )
	{
	case TF_TEAM_RED:
		iLosingTeam = TF_TEAM_BLUE;
		break;
	case TF_TEAM_BLUE:
		iLosingTeam = TF_TEAM_RED;
		break;
	case TEAM_UNASSIGNED:
	default:
		iLosingTeam = TEAM_UNASSIGNED;
		break;
	}

	// set the number of caps that team got any time during the round
	event->SetInt( "losing_team_num_caps", m_iNumCaps[iLosingTeam] );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetupSpawnPointsForRound( void )
{
	if ( !g_hControlPointMasters.Count() || !g_hControlPointMasters[0] || !g_hControlPointMasters[0]->PlayingMiniRounds() )
		return;

	CTeamControlPointRound *pCurrentRound = g_hControlPointMasters[0]->GetCurrentRound();
	if ( !pCurrentRound )
	{
		return;
	}

	// loop through the spawn points in the map and find which ones are associated with this round or the control points in this round
	for ( int i=0; i<ITFTeamSpawnAutoList::AutoList().Count(); ++i )
	{
		CTFTeamSpawn *pTFSpawn = static_cast< CTFTeamSpawn* >( ITFTeamSpawnAutoList::AutoList()[i] );

		CHandle<CTeamControlPoint> hControlPoint = pTFSpawn->GetControlPoint();
		CHandle<CTeamControlPointRound> hRoundBlue = pTFSpawn->GetRoundBlueSpawn();
		CHandle<CTeamControlPointRound> hRoundRed = pTFSpawn->GetRoundRedSpawn();

		if ( hControlPoint && pCurrentRound->IsControlPointInRound( hControlPoint ) )
		{
			// this spawn is associated with one of our control points
			pTFSpawn->SetDisabled( false );
			pTFSpawn->ChangeTeam( hControlPoint->GetOwner() );
		}
		else if ( hRoundBlue && ( hRoundBlue == pCurrentRound ) )
		{
			pTFSpawn->SetDisabled( false );
			pTFSpawn->ChangeTeam( TF_TEAM_BLUE );
		}
		else if ( hRoundRed && ( hRoundRed == pCurrentRound ) )
		{
			pTFSpawn->SetDisabled( false );
			pTFSpawn->ChangeTeam( TF_TEAM_RED );
		}
		else
		{
			// this spawn isn't associated with this round or the control points in this round
			pTFSpawn->SetDisabled( true );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFGameRules::SetCurrentRoundStateBitString( void )
{
	m_iPrevRoundState = m_iCurrentRoundState;

	CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;

	if ( !pMaster )
	{
		return 0;
	}

	int iState = 0;

	for ( int i=0; i<pMaster->GetNumPoints(); i++ )
	{
		CTeamControlPoint *pPoint = pMaster->GetControlPoint( i );

		if ( pPoint->GetOwner() == TF_TEAM_BLUE )
		{
			// Set index to 1 for the point being owned by blue
			iState |= ( 1<<i );
		}
	}

	m_iCurrentRoundState = iState;

	return iState;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetMiniRoundBitMask( int iMask )
{
	m_iCurrentMiniRoundMask = iMask;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::IsFirstBloodAllowed( void )
{
	// Already granted
	if ( m_bArenaFirstBlood )
		return false;

	if ( IsInArenaMode() && tf_arena_first_blood.GetBool() )
		return true;

	if ( IsCompetitiveMode() && ( State_Get() == GR_STATE_RND_RUNNING ) )
	{
		if ( IsMatchTypeCompetitive() )
			return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: NULL pPlayer means show the panel to everyone
//-----------------------------------------------------------------------------
void CTFGameRules::ShowRoundInfoPanel( CTFPlayer *pPlayer /* = NULL */ )
{
	KeyValues *data = new KeyValues( "data" );

	if ( m_iCurrentRoundState < 0 )
	{
		// Haven't set up the round state yet
		return;
	}

	// if prev and cur are equal, we are starting from a fresh round
	if ( m_iPrevRoundState >= 0 && pPlayer == NULL )	// we have data about a previous state
	{
		data->SetInt( "prev", m_iPrevRoundState );
	}
	else
	{
		// don't send a delta if this is just to one player, they are joining mid-round
		data->SetInt( "prev", m_iCurrentRoundState );	
	}

	data->SetInt( "cur", m_iCurrentRoundState );

	// get bitmask representing the current miniround
	data->SetInt( "round", m_iCurrentMiniRoundMask );

	if ( pPlayer )
	{
		pPlayer->ShowViewPortPanel( PANEL_ROUNDINFO, true, data );
	}
	else
	{
		for ( int i = 1;  i <= MAX_PLAYERS; i++ )
		{
			CTFPlayer *pTFPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );

			if ( pTFPlayer && pTFPlayer->IsReadyToPlay() )
			{
				pTFPlayer->ShowViewPortPanel( PANEL_ROUNDINFO, true, data );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::TimerMayExpire( void )
{
	// Prevent timers expiring while control points are contested
	int iNumControlPoints = ObjectiveResource()->GetNumControlPoints();
	for ( int iPoint = 0; iPoint < iNumControlPoints; iPoint ++ )
	{
		if ( ObjectiveResource()->GetCappingTeam(iPoint) )
		{
			m_flCapInProgressBuffer = gpGlobals->curtime + 0.1f;
			return false;
		}
	}

	// This delay prevents an order-of-operations issue with caps that
	// fire an AddTime output, and round timers' OnFinished output
	if ( m_flCapInProgressBuffer >= gpGlobals->curtime )
		return false;

	if ( GetOvertimeAllowedForCTF() )
	{
		// Prevent timers expiring while flags are stolen/dropped
		for ( int i=0; i<ICaptureFlagAutoList::AutoList().Count(); ++i )
		{
			CCaptureFlag *pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[i] );
			if ( !pFlag->IsDisabled() && !pFlag->IsHome() )
				return false;
		}
	}

	for ( int i = 0 ; i < m_CPTimerEnts.Count() ; i++ )
	{
		CCPTimerLogic *pTimer = m_CPTimerEnts[i];
		if ( pTimer )
		{
			if ( pTimer->TimerMayExpire() == false )
				return false;
		}
	}

#ifdef TF_RAID_MODE
	if ( IsRaidMode() && IsBossBattleMode() && tf_raid_allow_overtime.GetBool() )
	{
		CUtlVector< CTFPlayer * > alivePlayerVector;
		CollectPlayers( &alivePlayerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS );

		// if anyone is alive, go into overtime
		if ( alivePlayerVector.Count() > 0 )
		{
			return false;
		}
	}
#endif

	return BaseClass::TimerMayExpire();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::BHavePlayers( void )
{
	CMatchInfo *pInfo = GTFGCClientSystem()->GetMatch();
	if ( pInfo )
	{
		// When we have a match, we start reporting we're active as soon as the first person loads, and never stop.
		return pInfo->m_bFirstPersonActive;
	}

	if ( IsInArenaMode() )
	{
		// At least two in queue, we're always able to play
		if ( m_hArenaPlayerQueue.Count() >= 2 )
			return true;

		// Otherwise, return false if nobody is actually on a team, regardless of players ready-to-play state.
		if ( GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers() == 0 || GetGlobalTFTeam( TF_TEAM_RED )->GetNumPlayers() == 0 )
			return false;

		// Otherwise, fall through to base logic (e.g. 1v0 but already running)
	}

	return BaseClass::BHavePlayers();
}

int SortPlayerSpectatorQueue( CTFPlayer* const *p1, CTFPlayer* const *p2 )
{
	float flTime1 = (*p1)->GetTeamJoinTime();
	float flTime2 = (*p2)->GetTeamJoinTime();

	if ( flTime1 == flTime2 )
	{
		flTime1 = (*p1)->GetConnectionTime();
		flTime2 = (*p2)->GetConnectionTime();

		if ( flTime1 < flTime2 )
			return -1;
	}
	else
	{
		if ( flTime1 > flTime2 )
			return -1;
	}
		
	if ( flTime1 == flTime2 )
		return 0;

	return 1;
}

int SortPlayersScoreBased( CTFPlayer* const *p1, CTFPlayer* const *p2 )
{
	CTFPlayerResource *pResource = dynamic_cast<CTFPlayerResource *>( g_pPlayerResource );

	if ( pResource )
	{
		int nScore2 = pResource->GetTotalScore( ( *p2 )->entindex() );
		int nScore1 = pResource->GetTotalScore( ( *p1 )->entindex() );

		// check the priority
		if ( nScore2 > nScore1 )
		{
			return 1;
		}
	}

	return -1;
}

// sort function for the list of players that we're going to use to scramble the teams
int ScramblePlayersSort( CTFPlayer* const *p1, CTFPlayer* const *p2 )
{
	CTFPlayerResource *pResource = dynamic_cast< CTFPlayerResource * >( g_pPlayerResource );

	if ( pResource )
	{
		int nScore2 = pResource->GetTotalScore( (*p2)->entindex() );
		int nScore1 = pResource->GetTotalScore( (*p1)->entindex() );

		// check the priority
		if ( nScore2 > nScore1 )
		{
			return 1;
		}
	}

	return -1;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_ClientDisconnect( const char *playername )
{
	if ( IsInArenaMode() == false )
		return;

	if ( IsInWaitingForPlayers() == true )
		return;

	if ( m_iRoundState != GR_STATE_PREROUND )
		return;

	if ( IsInTournamentMode() == true )
		return;

	int iLight, iHeavy;

	if ( AreTeamsUnbalanced( iHeavy, iLight ) == true )
	{
		CTeam *pTeamHeavy = GetGlobalTeam( iHeavy );
		CTeam *pTeamLight = GetGlobalTeam( iLight );

		if ( pTeamHeavy == NULL || pTeamLight == NULL )
			return;

		int iPlayersNeeded = pTeamHeavy->GetNumPlayers() - pTeamLight->GetNumPlayers();

		if ( m_hArenaPlayerQueue.Count() == 0 )
			return;

		for ( int iPlayers = 0; iPlayers < iPlayersNeeded; iPlayers++ )
		{
			CTFPlayer *pPlayer = m_hArenaPlayerQueue[iPlayers];

			if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false )
			{
				pPlayer->ForceChangeTeam( TF_TEAM_AUTOASSIGN );

				UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_Arena_ClientDisconnect", pPlayer->GetPlayerName(), GetGlobalTeam( pPlayer->GetTeamNumber() )->GetName(), playername  );

				if ( pPlayer->DidPlayerJustPlay() == false )
				{
					pPlayer->MarkTeamJoinTime();
				}

				m_hArenaPlayerQueue.FindAndRemove( pPlayer );
				pPlayer->PlayerJustPlayed( false );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_ResetLosersScore( bool bResetAll )
{
	//Winner gets to keep their score
	for ( int i = 0; i < GetNumberOfTeams(); i++ )
	{
		if ( ( i != GetWinningTeam() && GetWinningTeam() > LAST_SHARED_TEAM ) || bResetAll == true )
		{
			GetGlobalTeam( i )->ResetScores();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_PrepareNewPlayerQueue( bool bResetAll )
{
	CUtlVector<CTFPlayer*> pTempPlayerQueue;

	for ( int i = 1;  i <= MAX_PLAYERS; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );

		if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false )
		{
			if ( ( GetWinningTeam() > LAST_SHARED_TEAM && pPlayer->GetTeamNumber() != GetWinningTeam() && pPlayer->IsReadyToPlay() ) || bResetAll == true  )
			{
				pTempPlayerQueue.AddToTail( pPlayer );
			}
		}
	}

	//Sort the players going into spectator
	//Players that have been longer on the server should go in front of newer players
	//We have to do this since player slots are reused for new clients, so looping through players
	//using their entindex doesn't work.

	if ( bResetAll == true )
	{
		pTempPlayerQueue.Sort( ScramblePlayersSort );
	}
	else
	{
		pTempPlayerQueue.Sort( SortPlayerSpectatorQueue );
	}

	for ( int i = 0; i < pTempPlayerQueue.Count(); i++ )
	{
		CTFPlayer *pPlayer = pTempPlayerQueue[i];

		if ( pPlayer && pPlayer->IsReadyToPlay() )
		{
			//Changing into Spectator Team puts the player at the end of the queue
			//Use ForceChangeTeam if you want to move them to the FRONT of the queue
			pPlayer->ChangeTeam( TEAM_SPECTATOR );
			pPlayer->PlayerJustPlayed( true );
		}
	}
}

#define TF_ARENA_TEAM_COUNT 3

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int	CTFGameRules::Arena_PlayersNeededForMatch( void )
{
	int iMaxPlayers = gpGlobals->maxClients;

	if ( HLTVDirector()->IsActive() )
	{
		iMaxPlayers -= 1;
	}

	int iTeamSize;
	if ( tf_arena_override_team_size.GetInt() > 0 )
		iTeamSize = tf_arena_override_team_size.GetInt();
	else
		iTeamSize = floor( ( (float)iMaxPlayers / TF_ARENA_TEAM_COUNT ) + 0.5f );

	int iPlayersNeeded = iTeamSize * 2;
	int iDesiredTeamSize = iTeamSize;
	int iPlayersInWinningTeam = 0;
	bool bRebalanceWinners = false;

	int iPlayerNumber = 0;

	for ( int i = 1;  i <= MAX_PLAYERS; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );

		if ( pPlayer && pPlayer->IsReadyToPlay() )
		{
			iPlayerNumber++;
		}
	}

	int iBalancedTeamSize = floor( ((m_hArenaPlayerQueue.Count() + iPlayerNumber ) * 0.5f ) );

	iPlayersNeeded = (iBalancedTeamSize - iPlayerNumber) + iBalancedTeamSize;

	if ( (iPlayersNeeded + iPlayerNumber) > iDesiredTeamSize*2 )
	{
		iPlayersNeeded = (iDesiredTeamSize*2) - iPlayerNumber;

		if ( iPlayersNeeded < 0 )
		{
			iPlayersNeeded = 0;
		}
	}

	// If the last round was won by a team, then let's figure out how many players we need.
	// Also, if the winning team has more players than are available, then let's have one of them switch teams.
	if ( GetWinningTeam() > LAST_SHARED_TEAM )
	{
		iPlayersInWinningTeam = GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers();
		
		if ( iPlayersInWinningTeam > iTeamSize ) 
		{
			bRebalanceWinners = true;
			iDesiredTeamSize = iTeamSize;
		}
		else if ( iPlayersInWinningTeam > iBalancedTeamSize )
		{
			bRebalanceWinners = true;
			iDesiredTeamSize = iBalancedTeamSize;
		}
	}

//	Msg( "iPlayerNumber: %d - InQueue: %d - iPlayersInWinningTeam: %d - iDesiredTeamSize: %d - iBalancedTeamSize: %d - iPlayersNeeded: %d - bRebalanceWinners %d\n", iPlayerNumber, m_hArenaPlayerQueue.Count(), iPlayersInWinningTeam, iDesiredTeamSize, iBalancedTeamSize, iPlayersNeeded, bRebalanceWinners );


	if ( bRebalanceWinners == true )
	{
		while ( iPlayersInWinningTeam > iDesiredTeamSize )
		{
			CTFPlayer *pBalancedWinner = NULL;
			float flShortestTeamJoinTime = 9999.9f;

			for ( int i = 1;  i <= MAX_PLAYERS; i++ )
			{
				CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );

				if ( pPlayer && pPlayer->GetTeamNumber() == GetWinningTeam() && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false )
				{
					if ( bRebalanceWinners == true )
					{
						//Find the newest guy that joined this team and flag him.
						if ( (gpGlobals->curtime - pPlayer->GetTeamJoinTime()) < flShortestTeamJoinTime )
						{
							flShortestTeamJoinTime = (gpGlobals->curtime - pPlayer->GetTeamJoinTime());
							pBalancedWinner = pPlayer;
						}
					}
				}
			}

			if ( pBalancedWinner )
			{
				pBalancedWinner->ForceChangeTeam( TEAM_SPECTATOR );
				pBalancedWinner->MarkTeamJoinTime();

				if ( iPlayersNeeded < iDesiredTeamSize )
				{
					iPlayersNeeded++;
				}

				IGameEvent *event = gameeventmanager->CreateEvent( "teamplay_teambalanced_player" );
				if ( event )
				{
					event->SetInt( "player", pBalancedWinner->entindex() );
					event->SetInt( "team", GetWinningTeam() == TF_TEAM_BLUE ? TF_TEAM_RED : TF_TEAM_BLUE );
					gameeventmanager->FireEvent( event );
				}

				// tell people that we've switched this player
				UTIL_ClientPrintAll( HUD_PRINTTALK, "#game_player_was_team_balanced", pBalancedWinner->GetPlayerName() );
			}

			iPlayersInWinningTeam = GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers();
		}
	}
	
	return iPlayersNeeded;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_CleanupPlayerQueue( void )
{
	//One more loop to remove players that are currently playing from the queue 
	//And to mark everyone as not having just played.
	for ( int i = 1;  i <= MAX_PLAYERS; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );

		if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false )
		{
			if ( pPlayer->GetTeamNumber() != TEAM_SPECTATOR )
			{
				m_hArenaPlayerQueue.FindAndRemove( pPlayer );
			}

			pPlayer->PlayerJustPlayed( false );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_RunTeamLogic( void )
{
	if ( IsInArenaMode() == false )
		return;

	if ( IsInWaitingForPlayers() == true )
		return;

	bool bGameNotReady = !BHavePlayers();
	bool bStreaksReached = false;

	if ( tf_arena_use_queue.GetBool() == false )
	{
		if ( bGameNotReady == true || GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers() == 0 || GetGlobalTFTeam( TF_TEAM_RED )->GetNumPlayers() == 0 )
		{
			State_Transition( GR_STATE_PREGAME );
		}

		return;
	}

	if ( tf_arena_max_streak.GetInt() > 0 )
	{
		if ( GetWinningTeam() != TEAM_UNASSIGNED )
		{
			if ( GetGlobalTFTeam( GetWinningTeam() )->GetScore() >= tf_arena_max_streak.GetInt() )
			{
				bStreaksReached = true;

				IGameEvent *event = gameeventmanager->CreateEvent( "arena_match_maxstreak" );
				if ( event )
				{
					event->SetInt( "team", GetWinningTeam() );
					event->SetInt( "streak", tf_arena_max_streak.GetInt() );
					gameeventmanager->FireEvent( event );
				}	

				BroadcastSound( 255, "Announcer.AM_TeamScrambleRandom" );

				m_iWinningTeam = TEAM_UNASSIGNED;
			}
		}
	}

	if ( IsInTournamentMode() == false )
	{
		Arena_ResetLosersScore( bGameNotReady || bStreaksReached );
	}

	Arena_PrepareNewPlayerQueue(  bGameNotReady || bStreaksReached );
	
	if ( bGameNotReady == true )
	{
		State_Transition( GR_STATE_PREGAME );
		return;
	}

	int iPlayersNeeded = Arena_PlayersNeededForMatch();
	
	//Let's add people to teams
	//But only do this if there's people in the actual game and teams are unbalanced 
	//(which they should be since winners are in and everyone else is spectating)
	int iLight, iHeavy;

	if ( AreTeamsUnbalanced( iHeavy, iLight ) == true && iPlayersNeeded > 0 )
	{
		if ( iPlayersNeeded > m_hArenaPlayerQueue.Count() )
		{
			iPlayersNeeded = m_hArenaPlayerQueue.Count();
		}
	
//		Msg( "iTeamSize: %d\n", iTeamSize );

		int iTeam = GetWinningTeam();

		int iSwitch = floor( ((GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers() + iPlayersNeeded) * 0.5f ) - GetGlobalTFTeam( GetWinningTeam() )->GetNumPlayers() );

		if ( GetWinningTeam() == TEAM_UNASSIGNED )
		{
			iTeam = TF_TEAM_AUTOASSIGN;
		}

		//Move people in the queue into a team.
		for ( int iPlayers = 0; iPlayers < iPlayersNeeded; iPlayers++ )
		{
			CTFPlayer *pPlayer = m_hArenaPlayerQueue[iPlayers];

			if ( iPlayers >= iSwitch )
			{
				iTeam = TF_TEAM_AUTOASSIGN;
			}

			if ( pPlayer )
			{
				pPlayer->ForceChangeTeam( iTeam );

//				Msg( "Moving Player to game: %s - team: %d\n", pPlayer->GetPlayerName(), pPlayer->GetTeamNumber() );

				if ( pPlayer->DidPlayerJustPlay() == false )
				{
					pPlayer->MarkTeamJoinTime();
				}
			}
		}
	}

	

	// show the class composition panel

	m_flSendNotificationTime = gpGlobals->curtime + 1.0f;

	Arena_CleanupPlayerQueue();
	Arena_NotifyTeamSizeChange();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_NotifyTeamSizeChange( void )
{
	int iTeamSize = GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers();

	if ( iTeamSize == m_iPreviousTeamSize )
		return;

	if ( m_iPreviousTeamSize == 0 )
	{
		m_iPreviousTeamSize = iTeamSize;
		return;
	}

	if ( m_iPreviousTeamSize > iTeamSize )
	{
		UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_Arena_TeamSizeDecreased", UTIL_VarArgs( "%d", iTeamSize  ) );
	}
	else
	{
		UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_Arena_TeamSizeIncreased", UTIL_VarArgs( "%d", iTeamSize  ) );
	}

	m_iPreviousTeamSize = iTeamSize;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::Arena_SendPlayerNotifications( void )
{
	int iTeamPlayers = GetGlobalTFTeam( TF_TEAM_RED )->GetNumPlayers() + GetGlobalTFTeam( TF_TEAM_BLUE )->GetNumPlayers();
	int iNumPlayers = 0;

	m_flSendNotificationTime = 0.0f;

	for ( int i = 1;  i <= MAX_PLAYERS; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );

		if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false && pPlayer->GetDesiredPlayerClassIndex() > TF_CLASS_UNDEFINED )
		{
			iNumPlayers++;
			
			if ( pPlayer->GetTeamNumber() == TEAM_SPECTATOR && pPlayer->GetPreviousTeam() != TEAM_UNASSIGNED )
			{
				CSingleUserRecipientFilter filter( pPlayer );

				UserMessageBegin( filter, "HudArenaNotify" );
					WRITE_BYTE( pPlayer->entindex() );
					WRITE_BYTE( TF_ARENA_NOTIFICATION_SITOUT );
				MessageEnd();
			}
		}
	}

	if ( iTeamPlayers == iNumPlayers ) 
		return;

	int iExtras = iNumPlayers - iTeamPlayers;

	for ( int iTeam = TF_TEAM_RED; iTeam < TF_TEAM_COUNT; iTeam++ )
	{
		CUtlVector<CTFPlayer*> pTempPlayerQueue;
		
		CTFTeam *pTeam = GetGlobalTFTeam( iTeam );

		if ( pTeam )
		{
			for ( int iPlayer = 0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
			{
				CTFPlayer *pPlayer = ToTFPlayer( pTeam->GetPlayer( iPlayer ) );

				if ( pPlayer && pPlayer->IsHLTV() == false && pPlayer->IsReplay() == false )
				{
					pTempPlayerQueue.AddToTail( pPlayer );
				}
			}
		}
	
		pTempPlayerQueue.Sort( SortPlayerSpectatorQueue );

		for ( int i = pTempPlayerQueue.Count(); --i >= 0; )
		{
			if ( pTempPlayerQueue.Count() - i > iExtras )
				continue;

			CTFPlayer *pPlayer = pTempPlayerQueue[i];

			CSingleUserRecipientFilter filter( pPlayer );
			UserMessageBegin( filter, "HudArenaNotify" );
				WRITE_BYTE( pPlayer->entindex() );
				WRITE_BYTE( TF_ARENA_NOTIFICATION_CAREFUL );
			MessageEnd();
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Handle maps that may be in our map cycle/etc changing name or availability
//-----------------------------------------------------------------------------
#ifdef GAME_DLL
void CTFGameRules::OnWorkshopMapUpdated( PublishedFileId_t nUpdatedWorkshopID )
{
	// Check if this map is in the mapcycle under a different name, reload mapcycle if so. We want the up-to-date names
	// in the map cycle as it is used for user-facing things such as votes.
	CTFMapsWorkshop *pWorkshop = TFMapsWorkshop();
	if ( pWorkshop )
	{
		FOR_EACH_VEC( m_MapList, i )
		{
			// Check if this represents a workshop map
			PublishedFileId_t nWorkshopID = pWorkshop->MapIDFromName( m_MapList[ i ] );
			if ( nWorkshopID == nUpdatedWorkshopID )
			{
				CUtlString newName;
				if ( pWorkshop->GetMapName( nWorkshopID, newName ) == CTFMapsWorkshop::eName_Canon &&
				     newName != m_MapList[ i ] )
				{
					// We can't just fixup the name here, as the primary mapcycle is also mirrored to a string
					// table. This queues a reload, which will check for workshop names at that point.
					m_bMapCycleNeedsUpdate = true;
					break;
				}
			}
		}
	}
}
#endif

//-----------------------------------------------------------------------------
// Purpose: Hook new map cycle file loads
//-----------------------------------------------------------------------------
void CTFGameRules::LoadMapCycleFile( void )
{
	BaseClass::LoadMapCycleFile();
#ifdef GAME_DLL
	// The underlying LoadMapCycleFileIntoVector fixes up workshop names, but for loading the primary map cycle file, we
	// also want to tell the workshop to track them. See also: TFGameRules::OnWorkshopMapChanged
	TrackWorkshopMapsInMapCycle();
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Hook new map cycle file loads
//-----------------------------------------------------------------------------
void CTFGameRules::TrackWorkshopMapsInMapCycle( void )
{
	CTFMapsWorkshop *pWorkshop = TFMapsWorkshop();
	if ( pWorkshop )
	{
		unsigned int nAddedMaps = 0;
		unsigned int nWorkshopMaps = 0;
		FOR_EACH_VEC( m_MapList, i )
		{
			// Check if this represents a workshop map
			PublishedFileId_t nWorkshopID = pWorkshop->MapIDFromName( m_MapList[ i ] );
			if ( nWorkshopID != k_PublishedFileIdInvalid )
			{
				nWorkshopMaps++;
				// Track it if we're not
				if ( pWorkshop->AddMap( nWorkshopID ) )
				{
					nAddedMaps++;
				}
			}
		}

		if ( nAddedMaps )
		{
			Msg( "Tracking %u new workshop maps from map cycle (%u already tracked)\n", nAddedMaps, nWorkshopMaps - nAddedMaps );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Hook new map cycle file loads
//-----------------------------------------------------------------------------
void CTFGameRules::LoadMapCycleFileIntoVector( const char *pszMapCycleFile, CUtlVector<char *> &mapList )
{
	BaseClass::LoadMapCycleFileIntoVector( pszMapCycleFile, mapList );

#ifdef GAME_DLL
	// Fixup workshop map names if known. E.g. workshop/12345 -> workshop/cp_foo.ugc12345
	CTFMapsWorkshop *pWorkshop = TFMapsWorkshop();
	if ( pWorkshop )
	{
		FOR_EACH_VEC( mapList, i )
		{
			// Check if this represents a workshop map
			PublishedFileId_t nWorkshopID = pWorkshop->MapIDFromName( mapList[ i ] );
			if ( nWorkshopID != k_PublishedFileIdInvalid )
			{
				// Workshop map, update name
				CUtlString newName;
				pWorkshop->GetMapName( nWorkshopID, newName );
				if ( newName.Length() )
				{
					// Alloc replacement
					size_t nNewSize = newName.Length() + 1;
					char *pNew = new char[ nNewSize ];
					V_strncpy( pNew, newName.Get(), nNewSize );

					// Replace
					delete [] mapList[ i ];
					mapList[ i ] = pNew;
				}
			}
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose:  Server-side vote creation
//-----------------------------------------------------------------------------
void CTFGameRules::ManageServerSideVoteCreation( void )
{
	if ( gpGlobals->curtime < m_flVoteCheckThrottle )
		return;

	if ( IsInTournamentMode() )
		return;

	if ( IsInArenaMode() )
		return;

	if ( IsInWaitingForPlayers() )
		return;

	if ( m_bInSetup )
		return;

	if ( IsInTraining() )
		return;

	if ( IsInItemTestingMode() )
		return;

	if ( m_MapList.Count() < 2 )
		return;
	
	// Ask players which map they would prefer to play next, based
	// on "n" lowest playtime from server stats

	ConVarRef sv_vote_issue_nextlevel_allowed( "sv_vote_issue_nextlevel_allowed" );
	ConVarRef sv_vote_issue_nextlevel_choicesmode( "sv_vote_issue_nextlevel_choicesmode" );

	if ( sv_vote_issue_nextlevel_allowed.GetBool() && sv_vote_issue_nextlevel_choicesmode.GetBool() )
	{
		// Don't do this if we already have a nextlevel set
		if ( nextlevel.GetString() && *nextlevel.GetString() )
			return;

		if ( !m_bServerVoteOnReset && !m_bVoteCalled )
		{
			// If we have any round or win limit, ignore time
			if ( mp_winlimit.GetInt() || mp_maxrounds.GetInt() )
			{
				int nBlueScore = TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetScore();
				int nRedScore = TFTeamMgr()->GetTeam( TF_TEAM_RED)->GetScore();
				int nWinLimit = mp_winlimit.GetInt();
				if ( ( nWinLimit - nBlueScore ) == 1 || ( nWinLimit - nRedScore ) == 1 )
				{
					m_bServerVoteOnReset = true;
				}

				int nRoundsPlayed = GetRoundsPlayed();
				if ( ( mp_maxrounds.GetInt() - nRoundsPlayed ) == 1 )
				{
					m_bServerVoteOnReset = true;
				}
			}
			else if ( mp_timelimit.GetInt() > 0 )
			{
				int nTimeLeft = GetTimeLeft();
				if ( nTimeLeft <= 120 && !m_bServerVoteOnReset )
				{
					if ( g_voteController )
					{
						g_voteController->CreateVote( DEDICATED_SERVER, "nextlevel", "" );
					}
					m_bVoteCalled = true;
				}
			}
		}
	}

	m_flVoteCheckThrottle = gpGlobals->curtime + 0.5f;
}


//-----------------------------------------------------------------------------
// Purpose: Figures out how much money to put in a custom currency pack drop
//-----------------------------------------------------------------------------
int CTFGameRules::CalculateCurrencyAmount_CustomPack( int nAmount )
{
	// Entities and events that specify a custom currency value should pass in the amount
	// they're worth, and we figure out if there's enough currency to generate a pack.
	// If the amount passed in isn't enough to generate a pack, we store it in an accumulator.
	
	int nMinDrop = kMVM_CurrencyPackMinSize;
	if ( nMinDrop > 1 )
	{
		// If we're on the last spawn, drop everything
		if ( TFObjectiveResource()->GetMannVsMachineWaveEnemyCount() == 1 )
		{
			nMinDrop = m_nCurrencyAccumulator + nAmount;
			m_nCurrencyAccumulator = 0;
			return nMinDrop;
		}

		// If we're passing in a value above mindrop, just drop it
		if ( nAmount >= nMinDrop )
			return nAmount;

		// Accumulate currency if we're getting values below nMinDrop
		m_nCurrencyAccumulator += nAmount;
		if ( m_nCurrencyAccumulator >= nMinDrop )
		{
			m_nCurrencyAccumulator -= nMinDrop;
			//DevMsg( "*MIN REACHED* -- %d left\n", m_nCurrencyAccumulator );
			return nMinDrop;
		}
		else
		{
			// We don't have enough yet, drop nothing
			//DevMsg( "*STORE* -- %d stored\n", m_nCurrencyAccumulator );
			return 0;
		}
	}
	else
	{
		// We don't have a PopManager - return the amount passed in
		return nAmount;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Figures out how much to give for pre-definied events or types
//-----------------------------------------------------------------------------
int CTFGameRules::CalculateCurrencyAmount_ByType( CurrencyRewards_t nType )
{
	// CUSTOM values are usually determined by CalculateCurrencyAmount_CustomPack() and set via CCurrencyPack::SetValue()
	Assert ( nType != TF_CURRENCY_PACK_CUSTOM );

	int nAmount = 0;

	switch ( nType )
	{
	case TF_CURRENCY_KILLED_PLAYER:
		nAmount = 40;
		break;

	case TF_CURRENCY_KILLED_OBJECT:
		nAmount = 40;
		break;

	case TF_CURRENCY_ASSISTED_PLAYER:
		nAmount = 20;
		break;

	case TF_CURRENCY_BONUS_POINTS:
		nAmount = 1;
		break;

	case TF_CURRENCY_CAPTURED_OBJECTIVE:
		nAmount = 100;
		break;

	case TF_CURRENCY_ESCORT_REWARD:
		nAmount = 10;
		break;

	case TF_CURRENCY_PACK_SMALL:
		nAmount = 5;
		break;

	case TF_CURRENCY_PACK_MEDIUM:
		nAmount = 10;
		break;

	case TF_CURRENCY_PACK_LARGE:
		nAmount = 25;
		break;

	case TF_CURRENCY_TIME_REWARD:
		nAmount = 5;
		break;

	case TF_CURRENCY_WAVE_COLLECTION_BONUS:
		nAmount = 100;
		break;

	default:
		Assert( 0 );	// Unknown type
	};

	return nAmount;
}

//-----------------------------------------------------------------------------
// Purpose: Gives money directly to a team or specific player
//-----------------------------------------------------------------------------
int CTFGameRules::DistributeCurrencyAmount( int nAmount, CTFPlayer *pTFPlayer /* = NULL */, bool bShared /* = true */, bool bCountAsDropped /*= false */, bool bIsBonus /*= false */ )
{
	// Group distribution (default)
	if ( bShared )
	{
		CUtlVector<CTFPlayer *> playerVector;

		if ( IsMannVsMachineMode() )
		{
			CollectPlayers( &playerVector, TF_TEAM_PVE_DEFENDERS );
		}
#ifdef STAGING_ONLY
		else if ( IsBountyMode() )
		{
			// We require a player in order to award the proper team
			if ( pTFPlayer )
			{
				CollectPlayers( &playerVector, pTFPlayer->GetTeamNumber() );
			}
		}
#endif // STAGING_ONLY

		// Money
		FOR_EACH_VEC( playerVector, i )
		{
			if ( playerVector[i] )
			{
#ifdef STAGING_ONLY
				if ( IsBountyMode() )
				{
					// Check for a cap
					int nLimit = tf_bountymode_currency_limit.GetInt();
					if ( nLimit > 0 )
					{
						int nNewCurrency = nAmount + pTFPlayer->GetCurrency();
						if ( nNewCurrency > nLimit )
						{
							int nDelta = nNewCurrency - nLimit;
							if ( nDelta )
							{
								nAmount -= nDelta;
							}
						}
					}
				}
#endif // STAGING_ONLY

				playerVector[i]->AddCurrency( nAmount );
			}
		}
	}
	// Individual distribution
	else if ( pTFPlayer )
	{
#ifdef STAGING_ONLY
		if ( IsBountyMode() )
		{
			// Check for a cap
			int nLimit = tf_bountymode_currency_limit.GetInt();
			if ( nLimit > 0 )
			{
				int nNewCurrency = nAmount + pTFPlayer->GetCurrency();
				if ( nNewCurrency > nLimit )
				{
					int nDelta = nNewCurrency - nLimit;
					if ( nDelta )
					{
						nAmount -= nDelta;
					}
				}
			}
		}
#endif // STAGING_ONLY

		pTFPlayer->AddCurrency( nAmount );
	}

	// Accounting
	if ( IsMannVsMachineMode() && g_pPopulationManager )
	{
		g_pPopulationManager->OnCurrencyCollected( nAmount, bCountAsDropped, bIsBonus );
	}

	return nAmount;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::RoundRespawn( void )
{
#ifdef GAME_DLL
	m_hasSpawnedToy = false;
	for ( int i = 0; i < TF_TEAM_COUNT; i++ )
	{
		m_bHasSpawnedSoccerBall[i] = false;
	}
#endif // GAME_DLL

	// remove any buildings, grenades, rockets, etc. the player put into the world
	RemoveAllProjectilesAndBuildings();

	// re-enable any sentry guns the losing team has built (and not hidden!)
	for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
	{
		CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
		if ( pObj->ObjectType() == OBJ_SENTRYGUN && pObj->IsEffectActive( EF_NODRAW ) == false && pObj->GetTeamNumber() != m_iWinningTeam )
		{
			pObj->SetDisabled( false );
		}
	}

#ifdef TF_RAID_MODE
	// Raid mode: clean up any Red buildings that might be left behind from the previous round
	if ( IsRaidMode() )
	{
		CTFTeam *pTeam = TFTeamMgr()->GetTeam( TF_TEAM_RED );
		if ( pTeam )
		{
			int nTeamObjectCount = pTeam->GetNumObjects();

			for ( int iObject = 0; iObject < nTeamObjectCount; ++iObject )
			{
				CBaseObject *pObj = pTeam->GetObject( iObject );

				if ( pObj )
				{
					pObj->SetThink( &CBaseEntity::SUB_Remove );
					pObj->SetNextThink( gpGlobals->curtime );
					pObj->SetTouch( NULL );
					pObj->AddEffects( EF_NODRAW );
				}
			}
		}
	}
	else if ( IsBossBattleMode() )
	{
		// unspawn entire red team
		CTeam *defendingTeam = GetGlobalTeam( TF_TEAM_RED );
		int i;
		for( i=0; i<defendingTeam->GetNumPlayers(); ++i )
		{
			engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", defendingTeam->GetPlayer(i)->GetUserID() ) );
		}
	}
#endif // TF_RAID_MODE

	if ( IsInTournamentMode() == false )
	{
		Arena_RunTeamLogic();
	}
	
	m_bArenaFirstBlood = false;
	
	// reset the flag captures
	int nTeamCount = TFTeamMgr()->GetTeamCount();
	for ( int iTeam = FIRST_GAME_TEAM; iTeam < nTeamCount; ++iTeam )
	{
		CTFTeam *pTeam = GetGlobalTFTeam( iTeam );
		if ( !pTeam )
			continue;

		pTeam->SetFlagCaptures( 0 );
	}

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

	// reset player per-round stats
	CTF_GameStats.ResetRoundStats();

	BaseClass::RoundRespawn();

	// ** AFTER WE'VE BEEN THROUGH THE ROUND RESPAWN, SHOW THE ROUNDINFO PANEL
	if ( !IsInWaitingForPlayers() )
	{
		ShowRoundInfoPanel();
	}

	// We've hit some condition where a server-side vote should be called on respawn
	if ( m_bServerVoteOnReset )
	{
		if ( g_voteController )
		{
			g_voteController->CreateVote( DEDICATED_SERVER, "nextlevel", "" );
		}
		m_bVoteCalled = true;
		m_bServerVoteOnReset = false;
	}
}

#ifdef GAME_DLL

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldSwitchTeams( void )
{
	if ( IsPVEModeActive() )
		return false;

	return BaseClass::ShouldSwitchTeams();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldScrambleTeams( void )
{
	if ( IsPVEModeActive() )
		return false;

	if ( IsCompetitiveMode() )
		return false;

	return BaseClass::ShouldScrambleTeams();
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::ClientCommandKeyValues( edict_t *pEntity, KeyValues *pKeyValues )
{
	CTFPlayer *pTFPlayer = ToTFPlayer( CBaseEntity::Instance( pEntity ) );

	if ( !pTFPlayer )
		return;

	char const *pszCommand = pKeyValues->GetName();
	if ( pszCommand && pszCommand[0] )
	{
		if ( FStrEq( pszCommand, "FreezeCamTaunt" ) )
		{
			CTFPlayer *pAchiever = ToTFPlayer( UTIL_PlayerByUserId( pKeyValues->GetInt( "achiever" ) ) );
			if ( pAchiever )
			{
				const char *pszCommand = pKeyValues->GetString( "command" );
				if ( pszCommand && pszCommand[0] )
				{
					int nGibs = pKeyValues->GetInt( "gibs" );

					if ( FStrEq( pszCommand, "freezecam_taunt" ) )
					{	
						CheckTauntAchievement( pAchiever, nGibs, g_TauntCamAchievements );
						CheckTauntAchievement( pAchiever, nGibs, g_TauntCamAchievements2 );
						HatAndMiscEconEntities_OnOwnerKillEaterEventNoParter( pAchiever, kKillEaterEvent_KillcamTaunts );
					}
					else if ( FStrEq( pszCommand, "freezecam_tauntrag" ) )
					{	
						CheckTauntAchievement( pAchiever, nGibs, g_TauntCamRagdollAchievements );
					}
					else if ( FStrEq( pszCommand, "freezecam_tauntgibs" ) )
					{	
						CheckTauntAchievement( pAchiever, nGibs, g_TauntCamAchievements );
					}
					else if ( FStrEq( pszCommand, "freezecam_tauntsentry" ) )
					{
						// Maybe should also require a taunt? Currently too easy to get?
						pAchiever->AwardAchievement( ACHIEVEMENT_TF_ENGINEER_FREEZECAM_SENTRY );
					}
				}
			}
		}
		else if ( FStrEq( pszCommand, "UsingVRHeadset" ) )
		{
			pTFPlayer->SetUsingVRHeadset( true );
		}
		else if ( FStrEq( pszCommand, "TestItems" ) )
		{
			pTFPlayer->ItemTesting_Start( pKeyValues );
		}
		else if ( FStrEq( pszCommand, "TestItemsBotUpdate" ) )
		{
			ItemTesting_SetupFromKV( pKeyValues );
		}
		else if ( FStrEq( pszCommand, "MVM_Upgrade" ) )
		{
			if ( GameModeUsesUpgrades() )
			{
#ifndef STAGING_ONLY
				if ( IsMannVsMachineMode() )
				{
					if ( sv_cheats && !sv_cheats->GetBool() && !pTFPlayer->m_Shared.IsInUpgradeZone() )
						return;
				}
#endif //!STAGING_ONLY

				if ( g_hUpgradeEntity )
				{
					// First sell everything we want to sell
					KeyValues *pSubKey = pKeyValues->GetFirstTrueSubKey();
					while ( pSubKey )
					{
						int iCount = pSubKey->GetInt("count");
						if ( iCount < 0 )
						{
							int iItemSlot = pSubKey->GetInt("itemslot");
							int iUpgrade = pSubKey->GetInt("upgrade");
							bool bFree = pSubKey->GetBool( "free", false );

							while ( iCount < 0 )
							{
								g_hUpgradeEntity->PlayerPurchasingUpgrade( pTFPlayer, iItemSlot, iUpgrade, true, bFree );
								++iCount;
							}
						}

						pSubKey = pSubKey->GetNextTrueSubKey();
					}

					// Now buy everything we want to buy
					pSubKey = pKeyValues->GetFirstTrueSubKey();
					while ( pSubKey )
					{
						int iCount = pSubKey->GetInt("count");
						if ( iCount > 0 )
						{
							int iItemSlot = pSubKey->GetInt("itemslot");
							int iUpgrade = pSubKey->GetInt("upgrade");
							bool bFree = ( sv_cheats && sv_cheats->GetBool() ) ? pSubKey->GetBool( "free", false ) : false;	// Never let a client set "free" without sv_cheats 1

							while ( iCount > 0 )
							{
								g_hUpgradeEntity->PlayerPurchasingUpgrade( pTFPlayer, iItemSlot, iUpgrade, false, bFree );
								--iCount;
							}
						}

						pSubKey = pSubKey->GetNextTrueSubKey();
					}
				}
			}
		}
		else if ( FStrEq( pszCommand, "MvM_UpgradesBegin" ) )
		{
			pTFPlayer->BeginPurchasableUpgrades();
		}
		else if ( FStrEq( pszCommand, "MvM_UpgradesDone" ) )
		{
			pTFPlayer->EndPurchasableUpgrades();

			if ( IsMannVsMachineMode() && pKeyValues->GetInt( "num_upgrades", 0 ) > 0 )
			{
				pTFPlayer->SpeakConceptIfAllowed( MP_CONCEPT_MVM_UPGRADE_COMPLETE );
			}
		}
		else if ( FStrEq( pszCommand, "MVM_Revive_Response" ) )
		{
			CTFReviveMarker *pReviveMarker = pTFPlayer->GetReviveMarker();
			if ( pReviveMarker )
			{
				if ( pKeyValues->GetBool( "accepted", 0 ) )
				{
					pReviveMarker->ReviveOwner();
				}
				else
				{
					// They hit cancel after their spawn timer was up
					if ( HasPassedMinRespawnTime( pTFPlayer ) )
					{
						pTFPlayer->ForceRespawn();
					}
	
					UTIL_Remove( pReviveMarker );
				}
			}
		}
		else if ( FStrEq( pszCommand, "MVM_Respec" ) )
		{
			if ( GameModeUsesUpgrades() && IsMannVsMachineRespecEnabled() && CanPlayerUseRespec( pTFPlayer ) )
			{
#ifndef STAGING_ONLY
				if ( IsMannVsMachineMode() )
				{
					if ( sv_cheats && !sv_cheats->GetBool() && !pTFPlayer->m_Shared.IsInUpgradeZone() )
						return;
				}
#endif //!STAGING_ONLY

				if ( g_hUpgradeEntity && g_pPopulationManager )
				{
					// Consume a respec credit
					g_pPopulationManager->RemoveRespecFromPlayer( pTFPlayer );

					// Remove the appropriate upgrade info from upgrade histories
					g_pPopulationManager->RemovePlayerAndItemUpgradesFromHistory( pTFPlayer );

					// Remove upgrade attributes from the player and their items
					g_hUpgradeEntity->GrantOrRemoveAllUpgrades( pTFPlayer, true );

					pTFPlayer->ForceRespawn();
				}
			}
		}
		else if ( FStrEq( pszCommand, "use_action_slot_item_server" ) )
		{
			if ( pTFPlayer->ShouldRunRateLimitedCommand( "use_action_slot_item_server" ) )
			{
				pTFPlayer->UseActionSlotItemPressed();
				pTFPlayer->UseActionSlotItemReleased();
			}
		}
		else if ( FStrEq( pszCommand, "+use_action_slot_item_server" ) )
		{
			if ( !pTFPlayer->IsUsingActionSlot() )
			{
				pTFPlayer->UseActionSlotItemPressed();
			}
		}
		else if ( FStrEq( pszCommand, "-use_action_slot_item_server" ) )
		{
			if ( pTFPlayer->IsUsingActionSlot() )
			{
				pTFPlayer->UseActionSlotItemReleased();
			}
		}
		else if ( FStrEq( pszCommand, "+inspect_server" ) )
		{
			pTFPlayer->InspectButtonPressed();
		}
		else if ( FStrEq( pszCommand, "-inspect_server" ) )
		{
			pTFPlayer->InspectButtonReleased();
		}
		else if ( FStrEq( pszCommand, "cl_drawline" ) )
		{
			BroadcastDrawLine( pTFPlayer, pKeyValues );
		}
		else if ( FStrEq( pszCommand, "AutoBalanceVolunteerReply" ) )
		{
			if ( TFAutoBalance() )
			{
				TFAutoBalance()->ReplyReceived( pTFPlayer, pKeyValues->GetBool( "response", false ) );   
			}
		}
		else
		{
			BaseClass::ClientCommandKeyValues( pEntity, pKeyValues );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::BroadcastDrawLine( CTFPlayer *pTFPlayer, KeyValues *pKeyValues )
{
	int paneltype = clamp( pKeyValues->GetInt( "panel", DRAWING_PANEL_TYPE_NONE ), DRAWING_PANEL_TYPE_NONE, DRAWING_PANEL_TYPE_MAX - 1 );

	if ( paneltype >= DRAWING_PANEL_TYPE_MATCH_SUMMARY )
	{
		int linetype = clamp( pKeyValues->GetInt( "line", 0 ), 0, 1 );
		float x = pKeyValues->GetFloat( "x", 0.f );
		float y = pKeyValues->GetFloat( "y", 0.f );

		IGameEvent *event = gameeventmanager->CreateEvent( "cl_drawline" );
		if ( event )
		{
			event->SetInt( "player", pTFPlayer->entindex() );
			event->SetInt( "panel",paneltype );
			event->SetInt( "line", linetype );
			event->SetFloat( "x", x );
			event->SetFloat( "y", y );

			gameeventmanager->FireEvent( event );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::RespawnTeam( int iTeam )
{
	BaseClass::RespawnTeam( iTeam );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SpawnPlayerInHell( CTFPlayer *pPlayer, const char *pszSpawnPointName )
{
	Vector vTeleportPosition;
	QAngle qTeleportAngles;

	int iCachedLocations = m_mapTeleportLocations.Find( MAKE_STRING( pszSpawnPointName ) );
	if ( m_mapTeleportLocations.IsValidIndex( iCachedLocations ) )
	{
		CUtlVector< TeleportLocation_t > *pLocations = m_mapTeleportLocations[iCachedLocations];
		Assert( pLocations );
		if ( !pLocations )
			return;
		
		const TeleportLocation_t& location = pLocations->Element( RandomInt( 0, pLocations->Count() - 1 ) );
		vTeleportPosition = location.m_vecPosition;
		qTeleportAngles = location.m_qAngles;
	}
	else
	{
		CUtlVector< CBaseEntity* > m_vecPossibleSpawns;
		CBaseEntity* pSpawn = NULL;
		while( (pSpawn = gEntList.FindEntityByName( pSpawn, pszSpawnPointName ) ) != NULL )
		{
			m_vecPossibleSpawns.AddToTail( pSpawn );
		}

		// There had better be a spawnpoint in this map!
		Assert( m_vecPossibleSpawns.Count() );
		if ( m_vecPossibleSpawns.Count() == 0 )
			return;

		// Randomly choose one
		pSpawn = m_vecPossibleSpawns[ RandomInt( 0, m_vecPossibleSpawns.Count() - 1 ) ];
		vTeleportPosition = pSpawn->GetAbsOrigin();
		qTeleportAngles = pSpawn->GetAbsAngles();
	}

	// Teleport them to hell
	pPlayer->Teleport( &vTeleportPosition, &qTeleportAngles, &vec3_origin );
	pPlayer->pl.v_angle = qTeleportAngles;

	// Send us to hell as a ghost!
	pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_GHOST_MODE );
	pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_IN_HELL );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
extern ISoundEmitterSystemBase *soundemitterbase;
void CTFGameRules::PlayHelltowerAnnouncerVO( int iRedLine, int iBlueLine )
{
	static float flRedAnnouncerTalkingUntil = 0.00f, flBlueAnnouncerTalkingUntil = 0.00f;
	
	// 01 is the first line for the VO
	int iRandomVORed = RandomInt( 1, g_pszHelltowerAnnouncerLines[iRedLine].m_nCount );	
	int iRandomVOBlue = RandomInt( 1, g_pszHelltowerAnnouncerLines[iBlueLine].m_nCount );

	// the misc lines should match up so we'll play the same lines to both teams
	if ( ( iRedLine <= HELLTOWER_VO_BLUE_MISC_RARE ) && ( iBlueLine <= HELLTOWER_VO_BLUE_MISC_RARE ) )
	{
		// can we safely set blue to the same value?
		if ( iRandomVORed <= g_pszHelltowerAnnouncerLines[iBlueLine].m_nCount )
		{
			iRandomVOBlue = iRandomVORed;
		}
	}

	char szRedAudio[128];
	char szBlueAudio[128];
	V_sprintf_safe( szRedAudio, g_pszHelltowerAnnouncerLines[iRedLine].m_pszFormatString, iRandomVORed );
	V_sprintf_safe( szBlueAudio, g_pszHelltowerAnnouncerLines[iBlueLine].m_pszFormatString, iRandomVOBlue );

	bool bForceVO = false;
	switch (iRedLine)
	{
		case HELLTOWER_VO_RED_WIN:
		case HELLTOWER_VO_RED_WIN_RARE:
		case HELLTOWER_VO_RED_LOSE:
		case HELLTOWER_VO_RED_LOSE_RARE:
			bForceVO = true;
	}
	switch (iBlueLine)
	{
		case HELLTOWER_VO_BLUE_WIN:
		case HELLTOWER_VO_BLUE_WIN_RARE:
		case HELLTOWER_VO_BLUE_LOSE:
		case HELLTOWER_VO_BLUE_LOSE_RARE:
			bForceVO = true;
	}	
	
	CSoundParameters params;
	float flSoundDuration = 0;

	if ( gpGlobals->curtime > flRedAnnouncerTalkingUntil || bForceVO )
	{
		BroadcastSound( TF_TEAM_RED, szRedAudio );
		if ( soundemitterbase->GetParametersForSound( szRedAudio, params, GENDER_NONE ) )
		{
			//flSoundDuration = enginesound->GetSoundDuration( params.soundname );
			flRedAnnouncerTalkingUntil = gpGlobals->curtime + flSoundDuration;
		}
		else
		{
			flRedAnnouncerTalkingUntil = 0.00;
		}	
	}
	if ( gpGlobals->curtime > flBlueAnnouncerTalkingUntil || bForceVO )
	{
		BroadcastSound( TF_TEAM_BLUE, szBlueAudio );
		if ( soundemitterbase->GetParametersForSound( szBlueAudio, params, GENDER_NONE ) )
		{
			//flSoundDuration = enginesound->GetSoundDuration( params.soundname );
			flBlueAnnouncerTalkingUntil = gpGlobals->curtime + flSoundDuration;
		}
		else
		{
			flBlueAnnouncerTalkingUntil = 0.00;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Based on connected match players, chooses the 3 maps players can
//			vote on as their next map
//-----------------------------------------------------------------------------
void CTFGameRules::ChooseNextMapVoteOptions()
{
	// Copy chosen maps into the actual fields we're networking to clients
	for( int i=0; i < NEXT_MAP_VOTE_OPTIONS; ++i )
	{
		m_nNextMapVoteOptions.Set( i, GTFGCClientSystem()->GetNextMapVoteByIndex( i )->m_nDefIndex );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::CheckHelltowerCartAchievement( int iTeam )
{
	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		CUtlVector< CTFPlayer * > playerVector;
		CollectPlayers( &playerVector, iTeam );

		FOR_EACH_VEC( playerVector, i )
		{
			CTFPlayer *pPlayer = playerVector[i];
			if ( pPlayer && ( pPlayer->GetObserverMode() <= OBS_MODE_DEATHCAM ) ) // they might be killed by the explosion, so check if they are OBS_MODE_NONE OR OBS_MODE_DEATHCAM
			{
				CTriggerAreaCapture *pAreaTrigger = pPlayer->GetControlPointStandingOn();
				if ( pAreaTrigger && pAreaTrigger->TeamCanCap( iTeam ) )
				{
					pPlayer->AwardAchievement( ACHIEVEMENT_TF_HALLOWEEN_HELLTOWER_KILL_BROTHERS );
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::HandleMapEvent( inputdata_t &inputdata )
{
	if ( FStrEq( "sd_doomsday", STRING( gpGlobals->mapname ) ) )
	{
		// find the flag in the map
		CCaptureFlag *pFlag = NULL;
		for ( int i=0; i<ICaptureFlagAutoList::AutoList().Count(); ++i )
		{
			pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[i] );
			if ( !pFlag->IsDisabled() )
			{
				break;
			}
		}

		// make sure it's being carried by one of the teams
		if ( pFlag && pFlag->IsStolen() )
		{
			CTFPlayer *pFlagCarrier = ToTFPlayer( pFlag->GetOwnerEntity() );
			if ( pFlagCarrier )
			{
				// let everyone know which team has opened the rocket
				IGameEvent *event = gameeventmanager->CreateEvent( "doomsday_rocket_open" );
				if ( event )
				{
					event->SetInt( "team", pFlagCarrier->GetTeamNumber() );
					gameeventmanager->FireEvent( event );
				}
			}
		}
	}
	else if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		const char *pszEvent = inputdata.value.String();
		if ( FStrEq( pszEvent, "midnight" ) )
		{
			HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_HELLTOWER_MIDNIGHT );
		}
		else if ( FStrEq( pszEvent, "horde" ) )
		{
			HaveAllPlayersSpeakConceptIfAllowed( MP_CONCEPT_PLAYER_SKELETON_KING_APPEAR );
			PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_SKELETON_KING, HELLTOWER_VO_BLUE_SKELETON_KING );
		}
		else if ( FStrEq( pszEvent, "red_capture" ) )
		{
			CheckHelltowerCartAchievement( TF_TEAM_RED );
			if ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE )
			{
				PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_WIN_RARE, HELLTOWER_VO_BLUE_LOSE_RARE );
			}
			else
			{
				PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_WIN, HELLTOWER_VO_BLUE_LOSE );
			}
		}
		else if ( FStrEq( pszEvent, "blue_capture" ) )
		{
			CheckHelltowerCartAchievement( TF_TEAM_BLUE );
			if ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE )
			{
				PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_LOSE_RARE, HELLTOWER_VO_BLUE_WIN_RARE );
			}
			else
			{
				PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_LOSE, HELLTOWER_VO_BLUE_WIN );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetCustomUpgradesFile( inputdata_t &inputdata )
{
	const char *pszPath = inputdata.value.String();

	// Reload
	g_MannVsMachineUpgrades.LoadUpgradesFileFromPath( pszPath );

	// Tell future clients to load from this path
	V_strncpy( m_pszCustomUpgradesFile.GetForModify(), pszPath, MAX_PATH );

	// Tell connected clients to reload
	IGameEvent *pEvent = gameeventmanager->CreateEvent( "upgrades_file_changed" );
	if ( pEvent )
	{
		pEvent->SetString( "path", pszPath );
		gameeventmanager->FireEvent( pEvent );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldWaitToStartRecording( void )
{
	if ( IsMannVsMachineMode() )
	{
		// Don't wait for the WaitingForPlayers period to end if we're MvM
		return false;
	}
	
	return BaseClass::ShouldWaitToStartRecording(); 
}

//-----------------------------------------------------------------------------
// Purpose: return true if this flag is currently allowed to be captured
//-----------------------------------------------------------------------------
bool CTFGameRules::CanFlagBeCaptured( CBaseEntity *pOther )
{
	if ( pOther && ( tf_flag_return_on_touch.GetBool() || IsPowerupMode() ) )
	{
		for ( int i = 0; i < ICaptureFlagAutoList::AutoList().Count(); ++i )
		{
			CCaptureFlag *pListFlag = static_cast<CCaptureFlag*>( ICaptureFlagAutoList::AutoList()[i] );
			if ( ( pListFlag->GetType() == TF_FLAGTYPE_CTF ) && !pListFlag->IsDisabled() && ( pOther->GetTeamNumber() == pListFlag->GetTeamNumber() ) && !pListFlag->IsHome() )
				return false;
		}
	}
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: return true if the game is in a state where both flags are stolen and poisonous
//-----------------------------------------------------------------------------
bool CTFGameRules::PowerupModeFlagStandoffActive( void )
{
	if ( IsPowerupMode() )
	{
		int nQualifyingFlags = 0; // All flags need to be stolen and poisonous (poisonous time delay gives the flag carriers a chance to get out of the enemy base)
		int nEnabledFlags = 0; // Some flags might be in the autolist but be out of play. We don't want them included in the count
		for ( int i = 0; i < ICaptureFlagAutoList::AutoList().Count(); ++i )
		{
			CCaptureFlag *pFlag = static_cast<CCaptureFlag*>( ICaptureFlagAutoList::AutoList()[i] );
			if ( !pFlag->IsDisabled() )
				nEnabledFlags++;
			if ( pFlag->IsPoisonous() && pFlag->IsStolen() )
				nQualifyingFlags++;
		}
		if ( nQualifyingFlags == nEnabledFlags )
		{
			return true;
		}
	}
	return false;
}

void CTFGameRules::TeleportPlayersToTargetEntities( int iTeam, const char *pszEntTargetName, CUtlVector< CTFPlayer * > *pTeleportedPlayers )
{
	CUtlVector< CTFPlayer * > vecPlayers;
	CUtlVector< CTFPlayer * > vecRandomOrderPlayers;

	CollectPlayers( &vecPlayers, iTeam );

	FOR_EACH_VEC( vecPlayers, i )
	{
		CTFPlayer *pPlayer = vecPlayers[i];

		// Skip players not on a team or who have not chosen a class
		if ( ( pPlayer->GetTeamNumber() != TF_TEAM_RED && pPlayer->GetTeamNumber() != TF_TEAM_BLUE )
			|| pPlayer->IsPlayerClass( TF_CLASS_UNDEFINED ) )
			continue;

		vecRandomOrderPlayers.AddToTail( pPlayer );
	}

	// Randomize the order so players dont go to the same spot every time
	vecRandomOrderPlayers.Shuffle();

	string_t sName = MAKE_STRING( pszEntTargetName );
	int iCachedLocationIndex = m_mapTeleportLocations.Find( sName );
	CUtlVector< TeleportLocation_t > *pCachedLocations = NULL;
	// is there any cached entities to teleport to
	if ( m_mapTeleportLocations.IsValidIndex( iCachedLocationIndex ) )
	{
		pCachedLocations = m_mapTeleportLocations[iCachedLocationIndex];
	}

	
	int iCurrentTeleportLocation = 0;
	CBaseEntity *pSpawnPoint = NULL;
	FOR_EACH_VEC_BACK( vecRandomOrderPlayers, i )
	{
		// don't do anything if we run out of spawn point
		Vector vTeleportPosition;
		QAngle qTeleportAngles;

		// if we have cached locations, use them
		if ( pCachedLocations )
		{
			Assert( iCurrentTeleportLocation < pCachedLocations->Count() );
			if ( iCurrentTeleportLocation < pCachedLocations->Count() )
			{
				const TeleportLocation_t& location = pCachedLocations->Element( iCurrentTeleportLocation );
				vTeleportPosition = location.m_vecPosition;
				qTeleportAngles = location.m_qAngles;
				iCurrentTeleportLocation++;
			}
			else
			{
				// we need to add more teleport location in the map for players to teleport to
				continue;
			}
		}
		else // use old search for entities by name
		{
			pSpawnPoint = gEntList.FindEntityByName( pSpawnPoint, pszEntTargetName );

			Assert( pSpawnPoint );
			if ( pSpawnPoint )
			{
				vTeleportPosition = pSpawnPoint->GetAbsOrigin();
				qTeleportAngles = pSpawnPoint->GetAbsAngles();
			}
			else
			{
				// we need to add more teleport location in the map for players to teleport to
				continue;
			}
		}

		CTFPlayer *pPlayer = vecRandomOrderPlayers[ i ];
		pPlayer->m_Shared.RemoveAllCond();
		
		// Respawn dead players
		if ( !pPlayer->IsAlive() )
		{
			pPlayer->ForceRespawn();
		}

		// Unzoom if we are a sniper zoomed!
		pPlayer->m_Shared.InstantlySniperUnzoom();

		// Teleport
		pPlayer->Teleport( &vTeleportPosition, &qTeleportAngles, &vec3_origin );
		pPlayer->SnapEyeAngles( qTeleportAngles );

		// Force client to update all view angles (including kart and taunt yaw)
		pPlayer->ForcePlayerViewAngles( qTeleportAngles );

		// fill in the teleported player vector
		if ( pTeleportedPlayers )
		{
			pTeleportedPlayers->AddToTail( pPlayer );
		}
	}
}

#endif // GAME_DLL

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::InternalHandleTeamWin( int iWinningTeam )
{
	// remove any spies' disguises and make them visible (for the losing team only)
	// and set the speed for both teams (winners get a boost and losers have reduced speed)
	for ( int i = 1;  i <= MAX_PLAYERS; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );

		if ( pPlayer )
		{
			if ( pPlayer->GetTeamNumber() > LAST_SHARED_TEAM )
			{
				if ( pPlayer->GetTeamNumber() != iWinningTeam )
				{
					pPlayer->RemoveInvisibility();
//					pPlayer->RemoveDisguise();

					if ( pPlayer->HasTheFlag() )
					{
						pPlayer->DropFlag();
					}
				}

				pPlayer->TeamFortress_SetSpeed();
			}
		}
	}

	for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
	{
		CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
		if ( pObj->GetTeamNumber() != iWinningTeam )
		{
			// Stop placing any carried objects or else they will float around
			// at our feet at the end of the round
			if( pObj->IsPlacing() )
			{
				pObj->StopPlacement();
			}

			// Disable sentry guns that the losing team has built
			if( pObj->GetType() == OBJ_SENTRYGUN )
			{
				pObj->SetDisabled( true );
			}
		}
	}

	if ( m_bForceMapReset )
	{
		m_iPrevRoundState = -1;
		m_iCurrentRoundState = -1;
		m_iCurrentMiniRoundMask = 0;
	}

	if ( IsInStopWatch() == true && GetStopWatchTimer() )
	{
		variant_t sVariant;
		GetStopWatchTimer()->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );

		if ( m_bForceMapReset )
		{
			if ( GetStopWatchTimer()->IsWatchingTimeStamps() == true )
			{
				m_flStopWatchTotalTime = GetStopWatchTimer()->GetStopWatchTotalTime();
			}
			else
			{
				ShouldResetScores( true, false );
				UTIL_Remove( m_hStopWatchTimer	);
				m_hStopWatchTimer = NULL;
				m_flStopWatchTotalTime = -1.0f;
				m_bStopWatch = false;
				m_nStopWatchState.Set( STOPWATCH_CAPTURE_TIME_NOT_SET );
			}
		}
	}

#ifdef GAME_DLL
	if ( GetHalloweenScenario() == HALLOWEEN_SCENARIO_VIADUCT )
	{
		// send everyone to the underworld!
		BroadcastSound( 255, "Halloween.PlayerEscapedUnderworld" );

		CUtlVector< CTFPlayer * > playerVector;
		CollectPlayers( &playerVector, TF_TEAM_RED, COLLECT_ONLY_LIVING_PLAYERS );
		CollectPlayers( &playerVector, TF_TEAM_BLUE, COLLECT_ONLY_LIVING_PLAYERS, APPEND_PLAYERS );

		CUtlVector< CBaseEntity * > spawnVector;

		CBaseEntity *spawnPoint = NULL;
		while( ( spawnPoint = gEntList.FindEntityByClassname( spawnPoint, "info_target" ) ) != NULL )
		{
			if ( FStrEq( STRING( spawnPoint->GetEntityName() ), "spawn_warcrimes" ) )
			{
				spawnVector.AddToTail( spawnPoint );
			}
		}

		if ( spawnVector.Count() > 0 )
		{
			// shuffle the order of the spawns
			int n = spawnVector.Count();
			while( n > 1 )
			{
				int k = RandomInt( 0, n-1 );
				n--;

				CBaseEntity *tmp = spawnVector[n];
				spawnVector[n] = spawnVector[k];
				spawnVector[k] = tmp;
			}

			color32 fadeColor = { 255, 255, 255, 100 };

			// send players to the underworld
			for( int i=0; i<playerVector.Count(); ++i )
			{
				CTFPlayer *player = playerVector[i];

				player->SetLocalOrigin( spawnVector[n]->GetAbsOrigin() + Vector( 0, 0, 20.0f ) );
				player->SetAbsVelocity( vec3_origin );
				player->SetLocalAngles( spawnVector[n]->GetAbsAngles() );
				player->m_Local.m_vecPunchAngle = vec3_angle;
				player->m_Local.m_vecPunchAngleVel = vec3_angle;
				player->SnapEyeAngles( spawnVector[n]->GetAbsAngles() );

				// give them full health since purgatory damages them over time
				player->SetHealth( player->GetMaxHealth() );

				UTIL_ScreenFade( player, fadeColor, 0.25, 0.4, FFADE_IN );

				n = ( n + 1 ) % spawnVector.Count();
			}
		}
	}
#endif
}

//-----------------------------------------------------------------------------
// Purpose: Helper function for scramble teams
//-----------------------------------------------------------------------------
int FindScoreDifferenceBetweenTeams( CUtlVector< CTFPlayer* > &vecSource, CTFPlayerResource *pPR, int &nRedScore, int &nBlueScore )
{
	if ( !pPR )
		return false;

	nRedScore = 0;
	nBlueScore = 0;

	FOR_EACH_VEC( vecSource, i )
	{
		if ( !vecSource[i] )
			continue;

		if ( vecSource[i]->GetTeamNumber() == TF_TEAM_RED )
		{
			nRedScore += pPR->GetTotalScore( vecSource[i]->entindex() );
		}
		else
		{
			nBlueScore += pPR->GetTotalScore( vecSource[i]->entindex() );
		}
	}

	return abs( nRedScore - nBlueScore );
}

//-----------------------------------------------------------------------------
// Purpose: Helper function for scramble teams
//-----------------------------------------------------------------------------
bool FindAndSwapPlayersToBalanceTeams( CUtlVector< CTFPlayer* > &vecSource, int &nDelta, CTFPlayerResource *pPR )
{
	if ( !pPR )
		return false;

	int nTeamScoreRed = 0;
	int nTeamScoreBlue = 0;
	FindScoreDifferenceBetweenTeams( vecSource, pPR, nTeamScoreRed, nTeamScoreBlue );

	FOR_EACH_VEC( vecSource, i )
	{
		if ( !vecSource[i] )
			continue;

		if ( vecSource[i]->GetTeamNumber() != TF_TEAM_RED )
			continue;

		// Check against players on the other team
		FOR_EACH_VEC( vecSource, j )
		{
			if ( !vecSource[j] )
				continue;

			if ( vecSource[j]->GetTeamNumber() != TF_TEAM_BLUE )
				continue;

			if ( vecSource[i] == vecSource[j] )
				continue;

			int nRedPlayerScore = pPR->GetTotalScore( vecSource[i]->entindex() );
			int nBluePlayerScore = pPR->GetTotalScore( vecSource[j]->entindex() );

			int nPlayerDiff = abs( nRedPlayerScore - nBluePlayerScore );
			if ( nPlayerDiff )
			{
				int nNewRedScore = nTeamScoreRed;
				int nNewBlueScore = nTeamScoreBlue;

				if ( nRedPlayerScore > nBluePlayerScore )
				{
					nNewRedScore -= nPlayerDiff;
					nNewBlueScore += nPlayerDiff;
				}
				else
				{
					nNewRedScore += nPlayerDiff;
					nNewBlueScore -= nPlayerDiff;
				}

				int nNewDelta = abs( nNewRedScore - nNewBlueScore );
				if ( nNewDelta < nDelta )
				{
					// Swap and recheck
					vecSource[i]->ForceChangeTeam( TF_TEAM_BLUE );
					vecSource[j]->ForceChangeTeam( TF_TEAM_RED );

					nDelta = FindScoreDifferenceBetweenTeams( vecSource, pPR, nTeamScoreRed, nTeamScoreBlue );
					return true;
				}
			}
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::HandleScrambleTeams( void )
{
	static CUtlVector< CTFPlayer* > playerVector;
	playerVector.RemoveAll();

	CollectPlayers( &playerVector, TF_TEAM_RED );
	CollectPlayers( &playerVector, TF_TEAM_BLUE, false, APPEND_PLAYERS );

	// Sort by player score.
	playerVector.Sort( ScramblePlayersSort );

	// Put everyone on Spectator to clear the teams (or the autoteam step won't work correctly)
	FOR_EACH_VEC_BACK( playerVector, i )
	{
		if ( !playerVector[i] )
		{
			playerVector.Remove( i );
			continue;
		}
		else if ( DuelMiniGame_IsInDuel( playerVector[i] ) ) // don't include them if they're in a duel
		{
			playerVector.Remove( i );
			continue;
		}

		playerVector[i]->ForceChangeTeam( TEAM_SPECTATOR );
	}

	// Assign players using the original, quick method.
	FOR_EACH_VEC( playerVector, i )
	{
		if ( !playerVector[i] )
			continue;

		if ( playerVector[i]->GetTeamNumber() >= FIRST_GAME_TEAM ) // are they already on a game team?
			continue;

		playerVector[i]->ForceChangeTeam( TF_TEAM_AUTOASSIGN );
	}

	// New method
	if ( playerVector.Count() > 2 )
	{
		CTFPlayerResource *pPR = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource );
		if ( pPR )
		{
			int nTeamScoreRed = 0;
			int nTeamScoreBlue = 0;
			int nDelta = FindScoreDifferenceBetweenTeams( playerVector, pPR, nTeamScoreRed, nTeamScoreBlue );

#ifdef _DEBUG
			if ( mp_scrambleteams_debug.GetBool() )
			{
				DevMsg( "FIRST PASS -- Team1: %i || Team2: %i || Diff: %i\n", 
						nTeamScoreRed, 
						nTeamScoreBlue, 
						nDelta );
			}
#endif // _DEBUG

			// Try swapping players to bring scores closer
			if ( nDelta > 1 )
			{
				int nOrigValue = mp_teams_unbalance_limit.GetInt();
				mp_teams_unbalance_limit.SetValue( 0 );

				static const int nPassLimit = 8;
				for ( int i = 0; i < nPassLimit && FindAndSwapPlayersToBalanceTeams( playerVector, nDelta, pPR ); ++i )
				{
#ifdef _DEBUG
					if ( mp_scrambleteams_debug.GetBool() )
					{
						nTeamScoreRed = 0;
						nTeamScoreBlue = 0;
						DevMsg( "EXTRA PASS -- Team1: %i || Team2: %i || Diff: %i\n", 
								nTeamScoreRed, 
								nTeamScoreBlue, 
								FindScoreDifferenceBetweenTeams( playerVector, pPR, nTeamScoreRed, nTeamScoreBlue ) );
					}
#endif // _DEBUG
				}
			
				mp_teams_unbalance_limit.SetValue( nOrigValue );
			}
		}
	}

	// scrambleteams_auto tracking
	ResetTeamsRoundWinTracking();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::TeamPlayerCountChanged( CTFTeam *pTeam )
{
	if ( m_hGamerulesProxy )
	{
		m_hGamerulesProxy->TeamPlayerCountChanged( pTeam );
	}
}


#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: Should we attempt to roll into a new match for the current match
//-----------------------------------------------------------------------------
bool CTFGameRules::BAttemptMapVoteRollingMatch()
{
	if ( IsManagedMatchEnded() )
		{ return false; }

	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
	return pMatchDesc && GTFGCClientSystem()->CanRequestNewMatchForLobby() && pMatchDesc->BUsesMapVoteAfterMatchEnds();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::BIsManagedMatchEndImminent( void )
{
/*
	if ( IsCompetitiveMode() )
	{
		if ( State_Get() == GR_STATE_RND_RUNNING )
		{
			bool bPotentiallyTheFinalRound = ( CheckWinLimit( false, 1 ) || CheckMaxRounds( false, 1 ) );
			if ( bPotentiallyTheFinalRound )
			{
				bool bPlayingMiniRounds = ( g_hControlPointMasters.Count() && g_hControlPointMasters[0] && g_hControlPointMasters[0]->PlayingMiniRounds() );

				switch( m_nGameType )
				{
				case TF_GAMETYPE_ESCORT:
				{
					if ( HasMultipleTrains() )
					{


					}
					else
					{



					}
				}
					break;
				case TF_GAMETYPE_CP:

					break;
				case TF_GAMETYPE_CTF:
					if ( tf_flag_caps_per_round.GetInt() > 0 )
					{
						for ( int iTeam = TF_TEAM_RED; iTeam < TF_TEAM_COUNT; iTeam++ )
						{
							C_TFTeam *pTeam = GetGlobalTFTeam( iTeam );
							if ( pTeam )
							{
								if ( ( tf_flag_caps_per_round.GetInt() - pTeam->GetFlagCaptures() ) <= 1 )
								{
									CCaptureFlag *pFlag = NULL;
									for ( int iFlag = 0; iFlag < ICaptureFlagAutoList::AutoList().Count(); ++iFlag )
									{
										pFlag = static_cast< CCaptureFlag* >( ICaptureFlagAutoList::AutoList()[iFlag] );
										if ( !pFlag->IsDisabled() && ( pFlag->GetTeamNumber() == iTeam ) && !pFlag->IsHome() )
											return true;
									}
								}
							}
						}
					}
					break;
				default:
					break;
				}
			}
		}
	}*/

	return false;
}
#endif // GAME_DLL


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::PowerupTeamImbalance( int nTeam )
{
	if ( m_hGamerulesProxy )
	{
		m_hGamerulesProxy->PowerupTeamImbalance( nTeam );

		if ( nTeam == TEAM_UNASSIGNED )
		{
			m_bPowerupImbalanceMeasuresRunning = false;
		}
		else
		{
			m_bPowerupImbalanceMeasuresRunning = true;
			m_flTimeToStopImbalanceMeasures = gpGlobals->curtime + m_flTimeToRunImbalanceMeasures;
			
			BroadcastSound( nTeam, "Announcer.Powerup.Volume.Starting" );
 			CTeamRecipientFilter filter( nTeam, true );
			UTIL_ClientPrintFilter( filter, HUD_PRINTCENTER, "#TF_Powerupvolume_Available" );
		}
		
		m_nPowerupKillsBlueTeam = 0;		// Reset both scores
		m_nPowerupKillsRedTeam = 0;
	}
}

//-----------------------------------------------------------------------------
// Purpose: Restrict team human players can join
//-----------------------------------------------------------------------------
int CTFGameRules::GetAssignedHumanTeam( void )
{
	if ( FStrEq( "blue", mp_humans_must_join_team.GetString() ) )
	{
		return TF_TEAM_BLUE;
	}
	else if ( FStrEq( "red", mp_humans_must_join_team.GetString() ) )
	{
		return TF_TEAM_RED;
	}
	else if ( FStrEq( "spectator", mp_humans_must_join_team.GetString() ) )
	{
		return TEAM_SPECTATOR;
	}
	else
	{
		return TEAM_ANY;
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::HandleSwitchTeams( void )
{
	if ( IsPVEModeActive() )
		return;

	m_bTeamsSwitched.Set( !m_bTeamsSwitched );

	// switch this as well
	if ( FStrEq( mp_humans_must_join_team.GetString(), "blue" ) )
	{
		mp_humans_must_join_team.SetValue( "red" );
	}
	else if ( FStrEq( mp_humans_must_join_team.GetString(), "red" ) )
	{
		mp_humans_must_join_team.SetValue( "blue" );
	}

	int i = 0;

	// remove everyone's projectiles and objects
	RemoveAllProjectilesAndBuildings();

	// respawn the players
	for ( i = 1 ; i <= gpGlobals->maxClients ; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pPlayer )
		{
			if ( pPlayer->GetTeamNumber() == TF_TEAM_RED )
			{
				pPlayer->ForceChangeTeam( TF_TEAM_BLUE, true );
			}
			else if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
			{
				pPlayer->ForceChangeTeam( TF_TEAM_RED, true );
			}
		}
	}

	// switch the team scores
	CTFTeam *pRedTeam = GetGlobalTFTeam( TF_TEAM_RED );
	CTFTeam *pBlueTeam = GetGlobalTFTeam( TF_TEAM_BLUE );
	if ( pRedTeam && pBlueTeam )
	{
		int nRed = pRedTeam->GetScore();
		int nBlue = pBlueTeam->GetScore();

		pRedTeam->SetScore( nBlue );
		pBlueTeam->SetScore( nRed );

		if ( IsInTournamentMode() == true )
		{
			char szBlueName[16];
			char szRedName[16];

			Q_strncpy( szBlueName, mp_tournament_blueteamname.GetString(), sizeof ( szBlueName ) );
			Q_strncpy( szRedName, mp_tournament_redteamname.GetString(), sizeof ( szRedName ) );

			mp_tournament_redteamname.SetValue( szBlueName );
			mp_tournament_blueteamname.SetValue( szRedName );
		}
	}

	UTIL_ClientPrintAll( HUD_PRINTTALK, "#TF_TeamsSwitched" );

	CMatchInfo *pMatchInfo = GTFGCClientSystem()->GetMatch();
	if ( pMatchInfo )
	{
		CTFPlayerResource *pTFResource = dynamic_cast< CTFPlayerResource* >( g_pPlayerResource );
		if ( pTFResource )
		{
			uint32 unEventTeamStatus = pTFResource->GetEventTeamStatus();

			if ( unEventTeamStatus && m_bTeamsSwitched )
			{
				const uint32 unInvadersArePyro = 1u;
				const uint32 unInvadersAreHeavy = 2u;
				unEventTeamStatus = ( unEventTeamStatus == unInvadersArePyro ) ? unInvadersAreHeavy : unInvadersArePyro;
			}

			pMatchInfo->m_unEventTeamStatus = unEventTeamStatus;
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::CanChangeClassInStalemate( void ) 
{ 
	return (gpGlobals->curtime < (m_flStalemateStartTime + tf_stalematechangeclasstime.GetFloat())); 
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::CanChangeTeam( int iCurrentTeam ) const
{
	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		if ( ( iCurrentTeam == TF_TEAM_RED ) || ( iCurrentTeam == TF_TEAM_BLUE ) )
		{
			return !ArePlayersInHell();
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetRoundOverlayDetails( void )
{
	CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;

	if ( pMaster && pMaster->PlayingMiniRounds() )
	{
		CTeamControlPointRound *pRound = pMaster->GetCurrentRound();

		if ( pRound )
		{
			CHandle<CTeamControlPoint> pRedPoint = pRound->GetPointOwnedBy( TF_TEAM_RED );
			CHandle<CTeamControlPoint> pBluePoint = pRound->GetPointOwnedBy( TF_TEAM_BLUE );

			// do we have opposing points in this round?
			if ( pRedPoint && pBluePoint )
			{
				int iMiniRoundMask = ( 1<<pBluePoint->GetPointIndex() ) | ( 1<<pRedPoint->GetPointIndex() );
				SetMiniRoundBitMask( iMiniRoundMask );
			}
			else
			{
				SetMiniRoundBitMask( 0 );
			}

			SetCurrentRoundStateBitString();
		}
	}

	BaseClass::SetRoundOverlayDetails();
}

//-----------------------------------------------------------------------------
// Purpose: Returns whether a team should score for each captured point
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldScorePerRound( void )
{ 
	bool bRetVal = true;

	CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
	if ( pMaster && pMaster->ShouldScorePerCapture() )
	{
		bRetVal = false;
	}

	return bRetVal;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::IsValveMap( void )
{ 
	char szCurrentMap[MAX_MAP_NAME];
	Q_strncpy( szCurrentMap, STRING( gpGlobals->mapname ), sizeof( szCurrentMap ) );

	if ( ::IsValveMap( szCurrentMap ) )
	{
		return true;
	}

	return BaseClass::IsValveMap();
}

void CTFGameRules::PlayTrainCaptureAlert( CTeamControlPoint *pPoint, bool bFinalPointInMap )
{
	if ( !pPoint )
		return;
	
	if ( State_Get() != GR_STATE_RND_RUNNING )
		return;

	const char *pszAlert = TEAM_TRAIN_ALERT;

	// is this the final control point in the map?
	if ( bFinalPointInMap )
	{
		pszAlert = TEAM_TRAIN_FINAL_ALERT;
	}

	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		if ( bFinalPointInMap )
		{
			int iWinningTeam = TEAM_UNASSIGNED;
			float flRedProgress = 0.0f, flBlueProgress = 0.0f;
			for ( int i = 0 ; i < ITFTeamTrainWatcher::AutoList().Count() ; ++i )
			{
				CTeamTrainWatcher *pTrainWatcher = static_cast< CTeamTrainWatcher* >( ITFTeamTrainWatcher::AutoList()[i] );
				if ( !pTrainWatcher->IsDisabled() )
				{
					if ( pTrainWatcher->GetTeamNumber() == TF_TEAM_RED )
					{
						flRedProgress = pTrainWatcher->GetTrainDistanceAlongTrack();
					}
					else
					{
						flBlueProgress = pTrainWatcher->GetTrainDistanceAlongTrack();
					}
				}
			}

			if ( flRedProgress > flBlueProgress )
			{
				iWinningTeam = TF_TEAM_RED;
			}
			else if ( flBlueProgress > flRedProgress )
			{
				iWinningTeam = TF_TEAM_BLUE;
			}

			if (  iWinningTeam != TEAM_UNASSIGNED ) 
			{
				int iRedLine, iBlueLine;
				iRedLine = ( iWinningTeam == TF_TEAM_RED ) ? HELLTOWER_VO_RED_NEAR_WIN : HELLTOWER_VO_RED_NEAR_LOSE;
				iBlueLine = ( iWinningTeam == TF_TEAM_BLUE ) ? HELLTOWER_VO_BLUE_NEAR_WIN : HELLTOWER_VO_BLUE_NEAR_LOSE;
				PlayHelltowerAnnouncerVO( iRedLine, iBlueLine );
			}
		}
		return;
	}

	CBroadcastRecipientFilter filter;
	pPoint->EmitSound( filter, pPoint->entindex(), pszAlert );
}

#endif  // GAME_DLL

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFGameRules::GetFarthestOwnedControlPoint( int iTeam, bool bWithSpawnpoints )
{
	int iOwnedEnd = ObjectiveResource()->GetBaseControlPointForTeam( iTeam );
	if ( iOwnedEnd == -1 )
		return -1;

	int iNumControlPoints = ObjectiveResource()->GetNumControlPoints();
	int iWalk = 1;
	int iEnemyEnd = iNumControlPoints-1;
	if ( iOwnedEnd != 0 )
	{
		iWalk = -1;
		iEnemyEnd = 0;
	}

	// Walk towards the other side, and find the farthest owned point that has spawn points
	int iFarthestPoint = iOwnedEnd;
	for ( int iPoint = iOwnedEnd; iPoint != iEnemyEnd; iPoint += iWalk )
	{
		// If we've hit a point we don't own, we're done
		if ( ObjectiveResource()->GetOwningTeam( iPoint ) != iTeam )
			break;

		if ( bWithSpawnpoints && !m_bControlSpawnsPerTeam[iTeam][iPoint] )
			continue;

		iFarthestPoint = iPoint;
	}

	return iFarthestPoint;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::TeamMayCapturePoint( int iTeam, int iPointIndex ) 
{ 
	if ( !tf_caplinear.GetBool() )
		return true; 

	// Any previous points necessary?
	int iPointNeeded = ObjectiveResource()->GetPreviousPointForPoint( iPointIndex, iTeam, 0 );

	// Points set to require themselves are always cappable 
	if ( iPointNeeded == iPointIndex )
		return true;

	if ( IsInKothMode() && IsInWaitingForPlayers() )
		return false;

	// Is the point locked?
	if ( ObjectiveResource()->GetCPLocked( iPointIndex ) )
		return false;

	// No required points specified? Require all previous points.
	if ( iPointNeeded == -1 )
	{
		if ( IsInArenaMode() == true )
		{

#ifdef CLIENT_DLL

			if ( m_flCapturePointEnableTime - 5.0f <= gpGlobals->curtime && State_Get() == GR_STATE_STALEMATE )
				return true;
#endif

			if ( m_flCapturePointEnableTime <= gpGlobals->curtime && State_Get() == GR_STATE_STALEMATE )
				return true;

			return false;
		}

		if ( !ObjectiveResource()->PlayingMiniRounds() )
		{
			// No custom previous point, team must own all previous points
			int iFarthestPoint = GetFarthestOwnedControlPoint( iTeam, false );
			return (abs(iFarthestPoint - iPointIndex) <= 1);
		}
		else
		{
			// No custom previous point, team must own all previous points in the current mini-round
			//tagES TFTODO: need to figure out a good algorithm for this
			return true;
		}
	}

	// Loop through each previous point and see if the team owns it
	for ( int iPrevPoint = 0; iPrevPoint < MAX_PREVIOUS_POINTS; iPrevPoint++ )
	{
		iPointNeeded = ObjectiveResource()->GetPreviousPointForPoint( iPointIndex, iTeam, iPrevPoint );
		if ( iPointNeeded != -1 )
		{
			if ( ObjectiveResource()->GetOwningTeam( iPointNeeded ) != iTeam )
				return false;
		}
	}
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::PlayerMayCapturePoint( CBasePlayer *pPlayer, int iPointIndex, char *pszReason /* = NULL */, int iMaxReasonLength /* = 0 */ )
{
	CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );

	if ( !pTFPlayer )
	{
		return false;
	}

	// Disguised and invisible spies cannot capture points
	if ( pTFPlayer->m_Shared.IsStealthed() )
	{
		if ( pszReason )
		{
			Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_stealthed" );
		}
		return false;
	}

	if ( ( pTFPlayer->m_Shared.IsInvulnerable() || pTFPlayer->m_Shared.InCond( TF_COND_MEGAHEAL ) ) && !pTFPlayer->m_bInPowerPlay && !IsMannVsMachineMode() )
	{
		if ( pszReason )
		{
			Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_invuln" );
		}
		return false;
	}

	if ( pTFPlayer->m_Shared.InCond( TF_COND_PHASE ) )
	{
		if ( pszReason )
		{
			Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_invuln" );
		}

		return false;
	}

	if ( pTFPlayer->m_Shared.IsControlStunned() )
	{
		if ( pszReason )
		{
			Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_stunned" );
		}

		return false;
	}

	// spies disguised as the enemy team cannot capture points
 	if ( pTFPlayer->m_Shared.InCond( TF_COND_DISGUISED ) && pTFPlayer->m_Shared.GetDisguiseTeam() != pTFPlayer->GetTeamNumber() )
	{
		if ( pszReason )
		{
			Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_disguised" );
		}
		return false;
	}

#ifdef GAME_DLL
	if ( IsInTraining() && pTFPlayer->IsBotOfType( TF_BOT_TYPE ) )
	{
		switch( GetGameType() )
		{
		case TF_GAMETYPE_CP:
			{
				// in training mode, bots cannot initiate a capture
				float flCapPerc = ObjectiveResource()->GetCPCapPercentage( iPointIndex );
				if ( flCapPerc <= 0.0f )
				{
					return false;
				}
				break;
			}

		case TF_GAMETYPE_ESCORT:
			{
				// in training mode, the player must push the cart for the first time
				// after that, bots can start it moving again

				// assume only one cart in the map
				CTeamTrainWatcher *watcher = NULL;
				while( ( watcher = dynamic_cast< CTeamTrainWatcher * >( gEntList.FindEntityByClassname( watcher, "team_train_watcher" ) ) ) != NULL )
				{
					if ( !watcher->IsDisabled() )
					{
						break;
					}
				}

				if ( watcher && !watcher->IsDisabled() )
				{
					return !watcher->IsTrainAtStart();
				}
				break;
			}
		}
	}

#ifdef TF_CREEP_MODE
	if ( IsCreepWaveMode() )
	{
		CTFBot *bot = ToTFBot( pTFPlayer );

		if ( !bot || !bot->HasAttribute( CTFBot::IS_NPC ) )
		{
			// only creeps can capture points
			return false;
		}
	}
#endif

#endif

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::PlayerMayBlockPoint( CBasePlayer *pPlayer, int iPointIndex, char *pszReason, int iMaxReasonLength )
{
	CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
	if ( !pTFPlayer )
		return false;

#ifdef GAME_DLL
#ifdef TF_CREEP_MODE
	if ( IsCreepWaveMode() )
	{
		CTFBot *bot = ToTFBot( pTFPlayer );

		if ( !bot || !bot->HasAttribute( CTFBot::IS_NPC ) )
		{
			// only creeps can block points
			return false;
		}
	}
#endif
#endif

	// Invuln players can block points
	if ( pTFPlayer->m_Shared.IsInvulnerable() )
	{
		if ( pszReason )
		{
			Q_snprintf( pszReason, iMaxReasonLength, "#Cant_cap_invuln" );
		}
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Calculates score for player
//-----------------------------------------------------------------------------
int CTFGameRules::CalcPlayerScore( RoundStats_t *pRoundStats, CTFPlayer *pPlayer )
{
	Assert( pRoundStats );
	if ( !pRoundStats )
		return 0;

	// defensive fix for the moment for bug where healing value becomes bogus sometimes: if bogus, slam it to 0
	int iHealing = pRoundStats->m_iStat[TFSTAT_HEALING];
	Assert( iHealing >= 0 );
	Assert( iHealing <= 10000000 );
	if ( iHealing < 0 || iHealing > 10000000 )
	{
		iHealing = 0;
	}

	bool bMvM = TFGameRules() && TFGameRules()->IsMannVsMachineMode();
	bool bPowerupMode = TFGameRules() && TFGameRules()->IsPowerupMode();

	int iScore =	( pRoundStats->m_iStat[TFSTAT_KILLS] * TF_SCORE_KILL ) + 
					( pRoundStats->m_iStat[TFSTAT_KILLS_RUNECARRIER] * TF_SCORE_KILL_RUNECARRIER ) + // Kill someone who is carrying a rune
					( pRoundStats->m_iStat[TFSTAT_CAPTURES] * ( ( bPowerupMode ) ? TF_SCORE_CAPTURE_POWERUPMODE : TF_SCORE_CAPTURE ) ) +
					( pRoundStats->m_iStat[TFSTAT_FLAGRETURNS] * TF_SCORE_FLAG_RETURN ) +
					( pRoundStats->m_iStat[TFSTAT_DEFENSES] * TF_SCORE_DEFEND ) + 
					( pRoundStats->m_iStat[TFSTAT_BUILDINGSDESTROYED] * TF_SCORE_DESTROY_BUILDING ) + 
					( pRoundStats->m_iStat[TFSTAT_HEADSHOTS] / TF_SCORE_HEADSHOT_DIVISOR ) + 
					( pRoundStats->m_iStat[TFSTAT_BACKSTABS] * TF_SCORE_BACKSTAB ) + 
					( iHealing / ( ( bMvM ) ? TF_SCORE_DAMAGE : TF_SCORE_HEAL_HEALTHUNITS_PER_POINT ) ) +  // MvM values healing more than PvP
					( pRoundStats->m_iStat[TFSTAT_KILLASSISTS] / TF_SCORE_KILL_ASSISTS_PER_POINT ) + 
					( pRoundStats->m_iStat[TFSTAT_TELEPORTS] / TF_SCORE_TELEPORTS_PER_POINT ) +
					( pRoundStats->m_iStat[TFSTAT_INVULNS] / TF_SCORE_INVULN ) +
					( pRoundStats->m_iStat[TFSTAT_REVENGE] / TF_SCORE_REVENGE ) +
					( pRoundStats->m_iStat[TFSTAT_BONUS_POINTS] / TF_SCORE_BONUS_POINT_DIVISOR );
					( pRoundStats->m_iStat[TFSTAT_CURRENCY_COLLECTED] / TF_SCORE_CURRENCY_COLLECTED );

	if ( pPlayer )
	{
		int nScoreboardMinigame = 0;
		CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, nScoreboardMinigame, scoreboard_minigame );
		if ( nScoreboardMinigame > 0 )
		{
			// Increment Score
			iScore +=
				( pRoundStats->m_iStat[TFSTAT_KILLS] ) + 
				( pRoundStats->m_iStat[TFSTAT_CAPTURES] ) + 
				( pRoundStats->m_iStat[TFSTAT_DEFENSES] ) + 
				( pRoundStats->m_iStat[TFSTAT_BUILDINGSDESTROYED] );

			// Subtract Deaths
			iScore -= pRoundStats->m_iStat[TFSTAT_DEATHS] * 3;
		}
	}

	// Previously MvM-only
	const int nDivisor = ( bMvM ) ? TF_SCORE_DAMAGE : TF_SCORE_HEAL_HEALTHUNITS_PER_POINT;
	iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE] / nDivisor );
	iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE_ASSIST] / nDivisor );
	iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE_BOSS] / nDivisor );
	iScore += ( pRoundStats->m_iStat[TFSTAT_HEALING_ASSIST] / nDivisor );
	iScore += ( pRoundStats->m_iStat[TFSTAT_DAMAGE_BLOCKED] / nDivisor );

	return Max( iScore, 0 );
}

//-----------------------------------------------------------------------------
// Purpose: Calculates score for player
//-----------------------------------------------------------------------------
int	CTFGameRules::CalcPlayerSupportScore( RoundStats_t *pRoundStats, int iPlayerIdx )
{
#ifdef GAME_DLL
	Assert( pRoundStats );
	if ( !pRoundStats )
		return 0;

	return ( pRoundStats->m_iStat[TFSTAT_DAMAGE_ASSIST] +
		   pRoundStats->m_iStat[TFSTAT_HEALING_ASSIST] +
		   pRoundStats->m_iStat[TFSTAT_DAMAGE_BLOCKED] +
		   ( pRoundStats->m_iStat[TFSTAT_BONUS_POINTS] * 25 ) );
#else
	Assert( g_TF_PR );
	if ( !g_TF_PR )
		return 0;

	return	g_TF_PR->GetDamageAssist( iPlayerIdx ) +
			g_TF_PR->GetHealingAssist( iPlayerIdx ) +
			g_TF_PR->GetDamageBlocked( iPlayerIdx ) +
			( g_TF_PR->GetBonusPoints( iPlayerIdx ) * 25 );
#endif
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::IsBirthday( void ) const
{
	if ( IsX360() )
		return false;

	return tf_birthday.GetBool() || IsHolidayActive( kHoliday_TFBirthday );
}

bool CTFGameRules::IsBirthdayOrPyroVision( void ) const
{
	if ( IsBirthday() )
		return true;

#ifdef CLIENT_DLL
	// Use birthday fun if the local player has an item that allows them to see it (Pyro Goggles)
	if ( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_PYRO ) )
	{
		return true;
	}
#endif

	return false;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::IsHolidayActive( /*EHoliday*/ int eHoliday ) const
{
	//if ( IsPVEModeActive() )
	//	return false;

	return TF_IsHolidayActive( eHoliday );
}

#ifndef GAME_DLL
void CTFGameRules::SetUpVisionFilterKeyValues( void )
{
	m_pkvVisionFilterShadersMapWhitelist = new KeyValues( "VisionFilterShadersMapWhitelist" );
	m_pkvVisionFilterShadersMapWhitelist->LoadFromFile( g_pFullFileSystem, "cfg/mtp.cfg", "MOD" );

	m_pkvVisionFilterTranslations = new KeyValues( "VisionFilterTranslations" );

	// **************************************************************************************************
	// PARTICLES
	KeyValues *pKVBlock = new KeyValues( "particles" );
	m_pkvVisionFilterTranslations->AddSubKey( pKVBlock );

	// No special vision
	KeyValues *pKVFlag = new KeyValues( "0" );
	pKVFlag->SetString( "flamethrower_rainbow", "flamethrower" );
	pKVFlag->SetString( "flamethrower_rainbow_FP", "flamethrower" );
	pKVBlock->AddSubKey( pKVFlag );

	// Pyrovision
	pKVFlag = new KeyValues( "1" );		//TF_VISION_FILTER_PYRO
	pKVFlag->SetString( "flamethrower_rainbow", "flamethrower_rainbow" );			// Rainblower defaults to rainbows and we want to ensure that we use it
	pKVFlag->SetString( "flamethrower_rainbow_FP", "flamethrower_rainbow_FP" );		
	pKVFlag->SetString( "burningplayer_blue", "burningplayer_rainbow_blue" );
	pKVFlag->SetString( "burningplayer_red", "burningplayer_rainbow_red" );
	pKVFlag->SetString( "burningplayer_corpse", "burningplayer_corpse_rainbow" );
	pKVFlag->SetString( "water_blood_impact_red_01", "pyrovision_blood" );
	pKVFlag->SetString( "blood_impact_red_01", "pyrovision_blood" );
	pKVFlag->SetString( "blood_spray_red_01", "pyrovision_blood" );
	pKVFlag->SetString( "blood_spray_red_01_far", "pyrovision_blood" );
	pKVFlag->SetString( "ExplosionCore_wall", "pyrovision_explosion" );
	pKVFlag->SetString( "ExplosionCore_buildings", "pyrovision_explosion" );
	pKVFlag->SetString( "ExplosionCore_MidAir", "pyrovision_explosion" );
	pKVFlag->SetString( "rockettrail", "pyrovision_rockettrail" );
	pKVFlag->SetString( "rockettrail_!", "pyrovision_rockettrail" );
	pKVFlag->SetString( "sentry_rocket", "pyrovision_rockettrail" );
	pKVFlag->SetString( "flaregun_trail_blue", "pyrovision_flaregun_trail_blue" );
	pKVFlag->SetString( "flaregun_trail_red", "pyrovision_flaregun_trail_red" );
	pKVFlag->SetString( "flaregun_trail_crit_blue", "pyrovision_flaregun_trail_crit_blue" );
	pKVFlag->SetString( "flaregun_trail_crit_red", "pyrovision_flaregun_trail_crit_red" );
	pKVFlag->SetString( "flaregun_destroyed", "pyrovision_flaregun_destroyed" );
	pKVFlag->SetString( "scorchshot_trail_blue", "pyrovision_scorchshot_trail_blue" );
	pKVFlag->SetString( "scorchshot_trail_red", "pyrovision_scorchshot_trail_red" );
	pKVFlag->SetString( "scorchshot_trail_crit_blue", "pyrovision_scorchshot_trail_crit_blue" );
	pKVFlag->SetString( "scorchshot_trail_crit_red", "pyrovision_scorchshot_trail_crit_red" );
	pKVFlag->SetString( "ExplosionCore_MidAir_Flare", "pyrovision_flaregun_destroyed" );
	pKVFlag->SetString( "pyrotaunt_rainbow_norainbow", "pyrotaunt_rainbow" );
	pKVFlag->SetString( "pyrotaunt_rainbow_bubbles_flame", "pyrotaunt_rainbow_bubbles" );
	pKVFlag->SetString( "v_flaming_arrow", "pyrovision_v_flaming_arrow" );
	pKVFlag->SetString( "flaming_arrow", "pyrovision_flaming_arrow" );
	pKVFlag->SetString( "flying_flaming_arrow", "pyrovision_flying_flaming_arrow" );
	pKVFlag->SetString( "taunt_pyro_balloon", "taunt_pyro_balloon_vision" );
	pKVFlag->SetString( "taunt_pyro_balloon_explosion", "taunt_pyro_balloon_explosion_vision" );

	pKVBlock->AddSubKey( pKVFlag );

	//// Spooky Vision
	//pKVFlag = new KeyValues( "2" );	//TF_VISION_FILTER_HALLOWEEN
	//pKVBlock->AddSubKey( pKVFlag );

	// **************************************************************************************************
	// SOUNDS
	pKVBlock = new KeyValues( "sounds" );
	m_pkvVisionFilterTranslations->AddSubKey( pKVBlock );

	// No special vision
	pKVFlag = new KeyValues( "0" );
	pKVFlag->SetString( "weapons/rainblower/rainblower_start.wav", "weapons/flame_thrower_start.wav" );
	pKVFlag->SetString( "weapons/rainblower/rainblower_loop.wav", "weapons/flame_thrower_loop.wav" );
	pKVFlag->SetString( "weapons/rainblower/rainblower_end.wav", "weapons/flame_thrower_end.wav" );
	pKVFlag->SetString( "weapons/rainblower/rainblower_hit.wav", "weapons/flame_thrower_fire_hit.wav" );
	pKVFlag->SetString( "weapons/rainblower/rainblower_pilot.wav", "weapons/flame_thrower_pilot.wav" );
	pKVFlag->SetString( ")weapons/rainblower/rainblower_start.wav", ")weapons/flame_thrower_start.wav" );
	pKVFlag->SetString( ")weapons/rainblower/rainblower_loop.wav", ")weapons/flame_thrower_loop.wav" );
	pKVFlag->SetString( ")weapons/rainblower/rainblower_end.wav", ")weapons/flame_thrower_end.wav" );
	pKVFlag->SetString( ")weapons/rainblower/rainblower_hit.wav", ")weapons/flame_thrower_fire_hit.wav" );
	pKVFlag->SetString( ")weapons/rainblower/rainblower_pilot.wav", "weapons/flame_thrower_pilot.wav" );
	pKVFlag->SetString( "Weapon_Rainblower.Fire", "Weapon_FlameThrower.Fire" );
	pKVFlag->SetString( "Weapon_Rainblower.FireLoop", "Weapon_FlameThrower.FireLoop" );
	pKVFlag->SetString( "Weapon_Rainblower.WindDown", "Weapon_FlameThrower.WindDown" );
	pKVFlag->SetString( "Weapon_Rainblower.FireHit", "Weapon_FlameThrower.FireHit" );
	pKVFlag->SetString( "Weapon_Rainblower.PilotLoop", "Weapon_FlameThrower.PilotLoop" );
	pKVFlag->SetString( "Taunt.PyroBalloonicorn", "Taunt.PyroHellicorn" );
	pKVFlag->SetString( ")items/pyro_music_tube.wav", "common/null.wav" );
	pKVBlock->AddSubKey( pKVFlag );

	// Pyrovision
	pKVFlag = new KeyValues( "1" ); //TF_VISION_FILTER_PYRO
	pKVFlag->SetString( "weapons/rainblower/rainblower_start.wav", "weapons/rainblower/rainblower_start.wav" );		// If we're in PyroVision, explicitly set to ensure this is saved
	pKVFlag->SetString( "weapons/rainblower/rainblower_loop.wav", "weapons/rainblower/rainblower_loop.wav" );
	pKVFlag->SetString( "weapons/rainblower/rainblower_end.wav", "weapons/rainblower/rainblower_end.wav" );
	pKVFlag->SetString( "weapons/rainblower/rainblower_hit.wav", "weapons/rainblower/rainblower_hit.wav" );
	pKVFlag->SetString( "weapons/rainblower/rainblower_pilot.wav", "weapons/rainblower/rainblower_pilot.wav" );
	pKVFlag->SetString( ")weapons/rainblower/rainblower_start.wav", ")weapons/rainblower/rainblower_start.wav" );
	pKVFlag->SetString( ")weapons/rainblower/rainblower_loop.wav", ")weapons/rainblower/rainblower_loop.wav" );
	pKVFlag->SetString( ")weapons/rainblower/rainblower_end.wav", ")weapons/rainblower/rainblower_end.wav" );
	pKVFlag->SetString( ")weapons/rainblower/rainblower_hit.wav", ")weapons/rainblower/rainblower_hit.wav" );
	pKVFlag->SetString( ")weapons/rainblower/rainblower_pilot.wav", ")weapons/rainblower/rainblower_pilot.wav" );
	pKVFlag->SetString( "Weapon_Rainblower.Fire", "Weapon_Rainblower.Fire" );
	pKVFlag->SetString( "Weapon_Rainblower.FireLoop", "Weapon_Rainblower.FireLoop" );
	pKVFlag->SetString( "Weapon_Rainblower.WindDown", "Weapon_Rainblower.WindDown" );
	pKVFlag->SetString( "Weapon_Rainblower.FireHit", "Weapon_Rainblower.FireHit" );
	pKVFlag->SetString( "Weapon_Rainblower.PilotLoop", "Weapon_Rainblower.PilotLoop" );
	pKVFlag->SetString( "Taunt.PyroBalloonicorn", "Taunt.PyroBalloonicorn" );
	pKVFlag->SetString( ")items/pyro_music_tube.wav", ")items/pyro_music_tube.wav" );

	pKVFlag->SetString( "vo/demoman_PainCrticialDeath01.mp3", "vo/demoman_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/demoman_PainCrticialDeath02.mp3", "vo/demoman_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/demoman_PainCrticialDeath03.mp3", "vo/demoman_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/demoman_PainCrticialDeath04.mp3", "vo/demoman_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/demoman_PainCrticialDeath05.mp3", "vo/demoman_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSevere01.mp3", "vo/demoman_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSevere02.mp3", "vo/demoman_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSevere03.mp3", "vo/demoman_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSevere04.mp3", "vo/demoman_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSharp01.mp3", "vo/demoman_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSharp02.mp3", "vo/demoman_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSharp03.mp3", "vo/demoman_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSharp04.mp3", "vo/demoman_LaughShort04.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSharp05.mp3", "vo/demoman_LaughShort05.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSharp06.mp3", "vo/demoman_LaughShort06.mp3" );
	pKVFlag->SetString( "vo/demoman_PainSharp07.mp3", "vo/demoman_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/demoman_AutoOnFire01.mp3", "vo/demoman_PositiveVocalization02.mp3" );
	pKVFlag->SetString( "vo/demoman_AutoOnFire02.mp3", "vo/demoman_PositiveVocalization03.mp3" );
	pKVFlag->SetString( "vo/demoman_AutoOnFire03.mp3", "vo/demoman_PositiveVocalization04.mp3" );

	pKVFlag->SetString( "vo/engineer_PainCrticialDeath01.mp3", "vo/engineer_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/engineer_PainCrticialDeath02.mp3", "vo/engineer_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/engineer_PainCrticialDeath03.mp3", "vo/engineer_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/engineer_PainCrticialDeath04.mp3", "vo/engineer_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/engineer_PainCrticialDeath05.mp3", "vo/engineer_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/engineer_PainCrticialDeath06.mp3", "vo/engineer_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSevere01.mp3", "vo/engineer_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSevere02.mp3", "vo/engineer_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSevere03.mp3", "vo/engineer_LaughHappy03.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSevere04.mp3", "vo/engineer_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSevere05.mp3", "vo/engineer_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSevere06.mp3", "vo/engineer_LaughHappy03.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSevere07.mp3", "vo/engineer_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSharp01.mp3", "vo/engineer_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSharp02.mp3", "vo/engineer_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSharp03.mp3", "vo/engineer_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSharp04.mp3", "vo/engineer_LaughShort04.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSharp05.mp3", "vo/engineer_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSharp06.mp3", "vo/engineer_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSharp07.mp3", "vo/engineer_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/engineer_PainSharp08.mp3", "vo/engineer_LaughShort04.mp3" );
	pKVFlag->SetString( "vo/engineer_AutoOnFire01.mp3", "vo/engineer_PositiveVocalization01.mp3" );
	pKVFlag->SetString( "vo/engineer_AutoOnFire02.mp3", "vo/engineer_Cheers01.mp3" );
	pKVFlag->SetString( "vo/engineer_AutoOnFire03.mp3", "vo/engineer_Cheers02.mp3" );

	pKVFlag->SetString( "vo/heavy_PainCrticialDeath01.mp3", "vo/heavy_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/heavy_PainCrticialDeath02.mp3", "vo/heavy_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/heavy_PainCrticialDeath03.mp3", "vo/heavy_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/heavy_PainSevere01.mp3", "vo/heavy_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/heavy_PainSevere02.mp3", "vo/heavy_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/heavy_PainSevere03.mp3", "vo/heavy_LaughHappy03.mp3" );
	pKVFlag->SetString( "vo/heavy_PainSharp01.mp3", "vo/heavy_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/heavy_PainSharp02.mp3", "vo/heavy_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/heavy_PainSharp03.mp3", "vo/heavy_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/heavy_PainSharp04.mp3", "vo/heavy_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/heavy_PainSharp05.mp3", "vo/heavy_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/heavy_AutoOnFire01.mp3", "vo/heavy_PositiveVocalization01.mp3" );
	pKVFlag->SetString( "vo/heavy_AutoOnFire02.mp3", "vo/heavy_PositiveVocalization02.mp3" );
	pKVFlag->SetString( "vo/heavy_AutoOnFire03.mp3", "vo/heavy_PositiveVocalization03.mp3" );
	pKVFlag->SetString( "vo/heavy_AutoOnFire04.mp3", "vo/heavy_PositiveVocalization04.mp3" );
	pKVFlag->SetString( "vo/heavy_AutoOnFire05.mp3", "vo/heavy_PositiveVocalization05.mp3" );

	pKVFlag->SetString( "vo/medic_PainCrticialDeath01.mp3", "vo/medic_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/medic_PainCrticialDeath02.mp3", "vo/medic_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/medic_PainCrticialDeath03.mp3", "vo/medic_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/medic_PainCrticialDeath04.mp3", "vo/medic_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/medic_PainSevere01.mp3", "vo/medic_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/medic_PainSevere02.mp3", "vo/medic_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/medic_PainSevere03.mp3", "vo/medic_LaughHappy03.mp3" );
	pKVFlag->SetString( "vo/medic_PainSevere04.mp3", "vo/medic_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/medic_PainSharp01.mp3", "vo/medic_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/medic_PainSharp02.mp3", "vo/medic_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/medic_PainSharp03.mp3", "vo/medic_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/medic_PainSharp04.mp3", "vo/medic_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/medic_PainSharp05.mp3", "vo/medic_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/medic_PainSharp06.mp3", "vo/medic_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/medic_PainSharp07.mp3", "vo/medic_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/medic_PainSharp08.mp3", "vo/medic_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/medic_AutoOnFire01.mp3", "vo/medic_PositiveVocalization01.mp3" );
	pKVFlag->SetString( "vo/medic_AutoOnFire02.mp3", "vo/medic_PositiveVocalization02.mp3" );
	pKVFlag->SetString( "vo/medic_AutoOnFire03.mp3", "vo/medic_PositiveVocalization03.mp3" );
	pKVFlag->SetString( "vo/medic_AutoOnFire04.mp3", "vo/medic_PositiveVocalization04.mp3" );
	pKVFlag->SetString( "vo/medic_AutoOnFire05.mp3", "vo/medic_PositiveVocalization05.mp3" );

	pKVFlag->SetString( "vo/pyro_PainCrticialDeath01.mp3", "vo/pyro_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/pyro_PainCrticialDeath02.mp3", "vo/pyro_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/pyro_PainCrticialDeath03.mp3", "vo/pyro_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/pyro_PainSevere01.mp3", "vo/pyro_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/pyro_PainSevere02.mp3", "vo/pyro_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/pyro_PainSevere03.mp3", "vo/pyro_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/pyro_PainSevere04.mp3", "vo/pyro_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/pyro_PainSevere05.mp3", "vo/pyro_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/pyro_PainSevere06.mp3", "vo/pyro_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/pyro_AutoOnFire01.mp3", "vo/pyro_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/pyro_AutoOnFire02.mp3", "vo/pyro_LaughHappy01.mp3" );

	pKVFlag->SetString( "vo/scout_PainCrticialDeath01.mp3", "vo/scout_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/scout_PainCrticialDeath02.mp3", "vo/scout_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/scout_PainCrticialDeath03.mp3", "vo/scout_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/scout_PainSevere01.mp3", "vo/scout_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/scout_PainSevere02.mp3", "vo/scout_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/scout_PainSevere03.mp3", "vo/scout_LaughHappy03.mp3" );
	pKVFlag->SetString( "vo/scout_PainSevere04.mp3", "vo/scout_LaughHappy04.mp3" );
	pKVFlag->SetString( "vo/scout_PainSevere05.mp3", "vo/scout_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/scout_PainSevere06.mp3", "vo/scout_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/scout_PainSharp01.mp3", "vo/scout_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/scout_PainSharp02.mp3", "vo/scout_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/scout_PainSharp03.mp3", "vo/scout_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/scout_PainSharp04.mp3", "vo/scout_LaughShort04.mp3" );
	pKVFlag->SetString( "vo/scout_PainSharp05.mp3", "vo/scout_LaughShort05.mp3" );
	pKVFlag->SetString( "vo/scout_PainSharp06.mp3", "vo/scout_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/scout_PainSharp07.mp3", "vo/scout_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/scout_PainSharp08.mp3", "vo/scout_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/scout_AutoOnFire01.mp3", "vo/scout_PositiveVocalization02.mp3" );
	pKVFlag->SetString( "vo/scout_AutoOnFire02.mp3", "vo/scout_PositiveVocalization03.mp3" );

	pKVFlag->SetString( "vo/sniper_PainCrticialDeath01.mp3", "vo/sniper_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/sniper_PainCrticialDeath02.mp3", "vo/sniper_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/sniper_PainCrticialDeath03.mp3", "vo/sniper_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/sniper_PainCrticialDeath04.mp3", "vo/sniper_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/sniper_PainSevere01.mp3", "vo/sniper_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/sniper_PainSevere02.mp3", "vo/sniper_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/sniper_PainSevere03.mp3", "vo/sniper_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/sniper_PainSevere04.mp3", "vo/sniper_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/sniper_PainSharp01.mp3", "vo/sniper_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/sniper_PainSharp02.mp3", "vo/sniper_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/sniper_PainSharp03.mp3", "vo/sniper_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/sniper_PainSharp04.mp3", "vo/sniper_LaughShort04.mp3" );
	pKVFlag->SetString( "vo/sniper_AutoOnFire01.mp3", "vo/sniper_PositiveVocalization02.mp3" );
	pKVFlag->SetString( "vo/sniper_AutoOnFire02.mp3", "vo/sniper_PositiveVocalization03.mp3" );
	pKVFlag->SetString( "vo/sniper_AutoOnFire03.mp3", "vo/sniper_PositiveVocalization05.mp3" );

	pKVFlag->SetString( "vo/soldier_PainCrticialDeath01.mp3", "vo/soldier_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/soldier_PainCrticialDeath02.mp3", "vo/soldier_LaughLong02.mp3" );
	pKVFlag->SetString( "vo/soldier_PainCrticialDeath03.mp3", "vo/soldier_LaughLong03.mp3" );
	pKVFlag->SetString( "vo/soldier_PainCrticialDeath04.mp3", "vo/soldier_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSevere01.mp3", "vo/soldier_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSevere02.mp3", "vo/soldier_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSevere03.mp3", "vo/soldier_LaughHappy03.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSevere04.mp3", "vo/soldier_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSevere05.mp3", "vo/soldier_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSevere06.mp3", "vo/soldier_LaughHappy03.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSharp01.mp3", "vo/soldier_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSharp02.mp3", "vo/soldier_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSharp03.mp3", "vo/soldier_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSharp04.mp3", "vo/soldier_LaughShort04.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSharp05.mp3", "vo/soldier_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSharp06.mp3", "vo/soldier_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSharp07.mp3", "vo/soldier_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/soldier_PainSharp08.mp3", "vo/soldier_LaughShort04.mp3" );
	pKVFlag->SetString( "vo/soldier_AutoOnFire01.mp3", "vo/soldier_PositiveVocalization01.mp3" );
	pKVFlag->SetString( "vo/soldier_AutoOnFire02.mp3", "vo/soldier_PositiveVocalization02.mp3" );
	pKVFlag->SetString( "vo/soldier_AutoOnFire03.mp3", "vo/soldier_PositiveVocalization03.mp3" );

	pKVFlag->SetString( "vo/spy_PainCrticialDeath01.mp3", "vo/spy_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/spy_PainCrticialDeath02.mp3", "vo/spy_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/spy_PainCrticialDeath03.mp3", "vo/spy_LaughLong01.mp3" );
	pKVFlag->SetString( "vo/spy_PainSevere01.mp3", "vo/spy_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/spy_PainSevere02.mp3", "vo/spy_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/spy_PainSevere03.mp3", "vo/spy_LaughHappy03.mp3" );
	pKVFlag->SetString( "vo/spy_PainSevere04.mp3", "vo/spy_LaughHappy01.mp3" );
	pKVFlag->SetString( "vo/spy_PainSevere05.mp3", "vo/spy_LaughHappy02.mp3" );
	pKVFlag->SetString( "vo/spy_PainSharp01.mp3", "vo/spy_LaughShort01.mp3" );
	pKVFlag->SetString( "vo/spy_PainSharp02.mp3", "vo/spy_LaughShort02.mp3" );
	pKVFlag->SetString( "vo/spy_PainSharp03.mp3", "vo/spy_LaughShort03.mp3" );
	pKVFlag->SetString( "vo/spy_PainSharp04.mp3", "vo/spy_LaughShort04.mp3" );
	pKVFlag->SetString( "vo/spy_AutoOnFire01.mp3", "vo/spy_PositiveVocalization02.mp3" );
	pKVFlag->SetString( "vo/spy_AutoOnFire02.mp3", "vo/spy_PositiveVocalization04.mp3" );
	pKVFlag->SetString( "vo/spy_AutoOnFire03.mp3", "vo/spy_PositiveVocalization05.mp3" );

	pKVBlock->AddSubKey( pKVFlag );

	// Spooky Vision
	//pKVFlag = new KeyValues( "2" ); // TF_VISION_FILTER_HALLOWEEN
	//pKVBlock->AddSubKey( pKVFlag );

	// **************************************************************************************************
	// WEAPONS
	pKVBlock = new KeyValues( "weapons" );
	m_pkvVisionFilterTranslations->AddSubKey( pKVBlock );

	// No special vision
	pKVFlag = new KeyValues( "0" );
	pKVFlag->SetString( "models/weapons/c_models/c_rainblower/c_rainblower.mdl", "models/weapons/c_models/c_flamethrower/c_flamethrower.mdl" );
	pKVFlag->SetString( "models/weapons/c_models/c_lollichop/c_lollichop.mdl", "models/weapons/w_models/w_fireaxe.mdl" );
	pKVBlock->AddSubKey( pKVFlag );

	// Pyrovision
	pKVFlag = new KeyValues( "1" );
	pKVFlag->SetString( "models/weapons/c_models/c_rainblower/c_rainblower.mdl", "models/weapons/c_models/c_rainblower/c_rainblower.mdl" );		//explicit set for pyrovision
	pKVFlag->SetString( "models/weapons/c_models/c_lollichop/c_lollichop.mdl", "models/weapons/c_models/c_lollichop/c_lollichop.mdl" );

	pKVFlag->SetString( "models/player/items/demo/demo_bombs.mdl", "models/player/items/all_class/mtp_bottle_demo.mdl" );
	pKVFlag->SetString( "models/player/items/pyro/xms_pyro_bells.mdl", "models/player/items/all_class/mtp_bottle_pyro.mdl" );
	pKVFlag->SetString( "models/player/items/soldier/ds_can_grenades.mdl", "models/player/items/all_class/mtp_bottle_soldier.mdl" );
	pKVBlock->AddSubKey( pKVFlag );

	// Spooky Vision
	//pKVFlag = new KeyValues( "2" );
	//pKVBlock->AddSubKey( pKVFlag );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::UseSillyGibs( void )
{
	// Use silly gibs if the local player has an item that allows them to see it (Pyro Goggles)
	if ( IsLocalPlayerUsingVisionFilterFlags( TF_VISION_FILTER_PYRO ) )
		return true;
	if ( UTIL_IsLowViolence() )
		return true;

	return m_bSillyGibs;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::AllowWeatherParticles( void )
{
	return ( tf_particles_disable_weather.GetBool() == false );
}

bool CTFGameRules::AllowMapVisionFilterShaders( void )
{
	if ( !m_pkvVisionFilterShadersMapWhitelist )
		return false;

	const char *pMapName = engine->GetLevelName();
	while ( pMapName && pMapName[ 0 ] != '\\' && pMapName[ 0 ] != '/' )
	{
		pMapName++;
	}

	if ( !pMapName )
		return false;

	pMapName++;

	return  m_pkvVisionFilterShadersMapWhitelist->GetInt( pMapName, 0 ) != 0;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char* CTFGameRules::TranslateEffectForVisionFilter( const char *pchEffectType, const char *pchEffectName )
{
	if ( !pchEffectType || !pchEffectName )
	{
		return pchEffectName;
	}

	CUtlVector<const char *> vecNames;
	vecNames.AddToTail( pchEffectName );

	// Swap the effect if the local player has an item that allows them to see it (Pyro Goggles)
	bool bWeaponsOnly = FStrEq( pchEffectType, "weapons" );
	int nVisionOptInFlags = GetLocalPlayerVisionFilterFlags( bWeaponsOnly );

	KeyValues *pkvParticles = m_pkvVisionFilterTranslations->FindKey( pchEffectType );
	if ( pkvParticles )
	{
		for ( KeyValues *pkvFlag = pkvParticles->GetFirstTrueSubKey(); pkvFlag != NULL; pkvFlag = pkvFlag->GetNextTrueSubKey() )
		{
			int nFlag = atoi( pkvFlag->GetName() );

			// Grab any potential translations for this item
			// Always grab default (No vision) names if they exist
			if ( ( nVisionOptInFlags & nFlag ) != 0 || nFlag == 0 )
			{
				// We either have this vision flag or we have no flags and this is the no flag block
				const char *pchTranslatedString = pkvFlag->GetString( pchEffectName, NULL );

				if ( pchTranslatedString )
				{
					vecNames.AddToHead( pchTranslatedString );
				}
			}
		}
	}

	// Return the top item in the list.  Currently Halloween replacements would out prioritize Pyrovision if there is any overlap
	return vecNames.Head();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::ModifySentChat( char *pBuf, int iBufSize )
{
	if ( IsInMedievalMode() && tf_medieval_autorp.GetBool() && english.GetBool() )
	{
		AutoRP()->ApplyRPTo( pBuf, iBufSize );
	}

	// replace all " with ' to prevent exploits related to chat text
	// example:   ";exit
	for ( char *ch = pBuf; *ch != 0; ch++ )
	{
		if ( *ch == '"' )
		{
			*ch = '\'';
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::AllowMapParticleEffect( const char *pszParticleEffect )
{
	static const char *s_WeatherEffects[] =
	{
		"tf_gamerules",
		"env_rain_001",
		"env_rain_002_256",
		"env_rain_ripples",
		"env_snow_light_001",
		"env_rain_gutterdrip",
		"env_rain_guttersplash",
		"", // END Marker
	};

	if ( !AllowWeatherParticles() )
	{
		if ( FindInList( s_WeatherEffects, pszParticleEffect ) )
			return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::GetTeamGlowColor( int nTeam, float &r, float &g, float &b )
{
	if ( nTeam == TF_TEAM_RED )
	{
		r = 0.74f;
		g = 0.23f;
		b = 0.23f;
	}
	else if ( nTeam == TF_TEAM_BLUE )
	{
		r = 0.49f;
		g = 0.66f;
		b = 0.77f;
	}
	else
	{
		r = 0.76f;
		g = 0.76f;
		b = 0.76f;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldConfirmOnDisconnect()
{
	// Add any game mode which uses matchmaking here. Note that the disconnect dialog checks if it should be showing abandons and such.
	return ( IsMannVsMachineMode() && GTFGCClientSystem()->GetSearchPlayForBraggingRights() ) ||
		   ( IsCompetitiveMode() && GTFGCClientSystem()->GetLobby() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldShowPreRoundDoors() const
{
	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
	if ( pMatchDesc )
	{
		return pMatchDesc->m_params.m_bShowPreRoundDoors;
	}

	return false;
}

#endif


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFGameRules::GetClassLimit( int iClass )
{
	if ( IsInTournamentMode() || IsPasstimeMode() )
	{
		switch ( iClass )
		{
		case TF_CLASS_SCOUT: return tf_tournament_classlimit_scout.GetInt(); break;
		case TF_CLASS_SNIPER: return tf_tournament_classlimit_sniper.GetInt(); break;
		case TF_CLASS_SOLDIER: return tf_tournament_classlimit_soldier.GetInt(); break;
		case TF_CLASS_DEMOMAN: return tf_tournament_classlimit_demoman.GetInt(); break;
		case TF_CLASS_MEDIC: return tf_tournament_classlimit_medic.GetInt(); break;
		case TF_CLASS_HEAVYWEAPONS: return tf_tournament_classlimit_heavy.GetInt(); break;
		case TF_CLASS_PYRO: return tf_tournament_classlimit_pyro.GetInt(); break;
		case TF_CLASS_SPY: return tf_tournament_classlimit_spy.GetInt(); break;
		case TF_CLASS_ENGINEER: return tf_tournament_classlimit_engineer.GetInt(); break;
		default:
			break;
		}
	}
	else if ( IsInHighlanderMode() )
	{
		return 1;
	}
	else if ( tf_classlimit.GetInt() )
	{
		return tf_classlimit.GetInt();
	}

	return NO_CLASS_LIMIT;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::CanPlayerChooseClass( CBasePlayer *pPlayer, int iClass )
{
	int iClassLimit = GetClassLimit( iClass );

#ifdef TF_RAID_MODE
	if ( IsRaidMode() && !pPlayer->IsBot() )
	{
		// bots are exempt from class limits, to allow for additional support bot "friends"
		if ( pPlayer->GetTeamNumber() == TF_TEAM_BLUE )
		{
			if ( tf_raid_allow_all_classes.GetBool() == false )
			{
				if ( iClass == TF_CLASS_SCOUT )
					return false;

				if ( iClass == TF_CLASS_SPY )
					return false;
			}

			if ( tf_raid_enforce_unique_classes.GetBool() )
			{
				// only one of each class on the raiding team
				iClassLimit = 1;
			}
		}
	}
	else if ( IsBossBattleMode() )
	{
		return true;
	}
	else
#endif // TF_RAID_MODE

	if ( iClassLimit == NO_CLASS_LIMIT )
		return true;

	if ( pPlayer->GetTeamNumber() != TF_TEAM_BLUE && pPlayer->GetTeamNumber() != TF_TEAM_RED )
		return true;
#ifdef GAME_DLL
	CTFTeam *pTeam = assert_cast<CTFTeam*>(pPlayer->GetTeam());
#else
	C_TFTeam *pTeam = assert_cast<C_TFTeam*>(pPlayer->GetTeam());
#endif
	if ( !pTeam )
		return true;

	int iTeamClassCount = 0;
	for ( int iPlayer = 0; iPlayer < pTeam->GetNumPlayers(); iPlayer++ )
	{
		CTFPlayer *pTFPlayer = ToTFPlayer( pTeam->GetPlayer( iPlayer ) );
		if ( pTFPlayer && pTFPlayer != pPlayer && pTFPlayer->GetPlayerClass()->GetClassIndex() == iClass )
		{
			iTeamClassCount++;
		}
	}

	return ( iTeamClassCount < iClassLimit );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldBalanceTeams( void )
{
	// never autobalance the teams for managed matches using the old system
	if ( GetMatchGroupDescription( GetCurrentMatchGroup() ) )
		return false;

	bool bDisableBalancing = false;
#ifdef STAGING_ONLY
	bDisableBalancing = IsBountyMode();
#endif // STAGING_ONLY

	if ( IsPVEModeActive() || bDisableBalancing )
		return false;

	// don't balance the teams while players are in hell
	if ( ArePlayersInHell() )
		return false;

	return BaseClass::ShouldBalanceTeams();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFGameRules::GetBonusRoundTime( bool bGameOver /* = false*/ )
{
	if ( IsMannVsMachineMode() )
	{
		return 5;
	}
	else if ( IsCompetitiveMode() && bGameOver )
	{
		if ( IsMatchTypeCompetitive() )
		{
			return 5;
		}
	}

	return BaseClass::GetBonusRoundTime( bGameOver );
}


#ifdef GAME_DLL

bool CTFGameRules::CanBotChangeClass( CBasePlayer* pPlayer )
{
	// if there's a roster for this bot's team, check to see if the level designer has allowed the bot to change class
	// used when the bot dies and wants to see if it can change class
	CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
	if ( pTFPlayer && pTFPlayer->GetPlayerClass() && pTFPlayer->GetPlayerClass()->GetClassIndex() != TF_CLASS_UNDEFINED )
	{
		switch ( pPlayer->GetTeamNumber() )
		{					  
		case TF_TEAM_RED:  return m_hRedBotRoster ? m_hRedBotRoster->IsClassChangeAllowed() : true; break;
		case TF_TEAM_BLUE: return m_hBlueBotRoster ? m_hBlueBotRoster->IsClassChangeAllowed() : true; break;
		}
	}
	return true;
}

bool CTFGameRules::CanBotChooseClass( CBasePlayer *pPlayer, int iClass )
{
	// if there's a roster for this bot's team, then check to see if the class the bot has requested is allowed by the roster
	bool bCanChooseClass = CanPlayerChooseClass( pPlayer, iClass );
	if ( bCanChooseClass )
	{
		// now check rosters...
		switch ( pPlayer->GetTeamNumber() )
		{					  
		case TF_TEAM_RED:  
			bCanChooseClass = m_hRedBotRoster ? m_hRedBotRoster->IsClassAllowed( iClass ) : true; 
			break;
		case TF_TEAM_BLUE: 
			bCanChooseClass = m_hBlueBotRoster ? m_hBlueBotRoster->IsClassAllowed( iClass ) : true; 
			break;
		default: 
			// no roster - spectator team
			bCanChooseClass = true; 
			break;
		}
	}
	return bCanChooseClass;
}

//-----------------------------------------------------------------------------
// Populate vector with set of control points the player needs to capture
void CTFGameRules::CollectCapturePoints( CBasePlayer *player, CUtlVector< CTeamControlPoint * > *captureVector ) const
{
	if ( !captureVector )
		return;

	captureVector->RemoveAll();

	CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
	if ( pMaster )
	{
		// special case hack for KotH mode to use control points that are locked at the start of the round
		if ( IsInKothMode() && pMaster->GetNumPoints() == 1 )
		{
			captureVector->AddToTail( pMaster->GetControlPoint( 0 ) );
			return;
		}

		for( int i=0; i<pMaster->GetNumPoints(); ++i )
		{
			CTeamControlPoint *point = pMaster->GetControlPoint( i );
			if ( point && pMaster->IsInRound( point ) )
			{
				if ( ObjectiveResource()->GetOwningTeam( point->GetPointIndex() ) == player->GetTeamNumber() )
					continue;

				if ( player && player->IsBot() && point->ShouldBotsIgnore() )
					continue;

				if ( ObjectiveResource()->TeamCanCapPoint( point->GetPointIndex(), player->GetTeamNumber() ) )
				{
					if ( TeamplayGameRules()->TeamMayCapturePoint( player->GetTeamNumber(), point->GetPointIndex() ) )
					{
						// unlocked point not on our team available to capture
						captureVector->AddToTail( point );
					}
				}
			}
		}
	}
}


//-----------------------------------------------------------------------------
// Populate vector with set of control points the player needs to defend from capture
void CTFGameRules::CollectDefendPoints( CBasePlayer *player, CUtlVector< CTeamControlPoint * > *defendVector ) const
{
	if ( !defendVector )
		return;

	defendVector->RemoveAll();

	CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
	if ( pMaster )
	{
		for( int i=0; i<pMaster->GetNumPoints(); ++i )
		{
			CTeamControlPoint *point = pMaster->GetControlPoint( i );
			if ( point && pMaster->IsInRound( point ) )
			{
				if ( ObjectiveResource()->GetOwningTeam( point->GetPointIndex() ) != player->GetTeamNumber() )
					continue;
					
				if ( player && player->IsBot() && point->ShouldBotsIgnore() )
					continue;

				if ( ObjectiveResource()->TeamCanCapPoint( point->GetPointIndex(), GetEnemyTeam( player->GetTeamNumber() ) ) )
				{
					if ( TeamplayGameRules()->TeamMayCapturePoint( GetEnemyTeam( player->GetTeamNumber() ), point->GetPointIndex() ) )
					{
						// unlocked point on our team vulnerable to capture
						defendVector->AddToTail( point );
					}
				}
			}
		}
	}
}


//-----------------------------------------------------------------------------
CObjectSentrygun *CTFGameRules::FindSentryGunWithMostKills( int team ) const
{
	CObjectSentrygun *dangerousSentry = NULL;
	int dangerousSentryKills = -1;

	for ( int i=0; i<IBaseObjectAutoList::AutoList().Count(); ++i )
	{
		CBaseObject *pObj = static_cast< CBaseObject* >( IBaseObjectAutoList::AutoList()[i] );
		if ( pObj->ObjectType() == OBJ_SENTRYGUN && pObj->GetTeamNumber() == team && pObj->GetKills() >= dangerousSentryKills )
		{
			dangerousSentryKills = pObj->GetKills();
			dangerousSentry = static_cast<CObjectSentrygun *>( pObj );
		}
	}

	return dangerousSentry;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen )
{
	if ( IsMannVsMachineMode() )
	{
		int nCount = 0;
		CTFPlayer *pPlayer;

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

			if ( !pPlayer || pPlayer->IsFakeClient() )
				continue;

			nCount++;
		}

		if ( nCount >= kMVM_MaxConnectedPlayers )
			return false;
	}

	bool bRet = BaseClass::ClientConnected( pEntity, pszName, pszAddress, reject, maxrejectlen );
	if ( bRet )
	{
		const CSteamID *steamID = engine->GetClientSteamID( pEntity );
		if ( steamID && steamID->IsValid() )
		{
			// Invalid steamIDs wont be known to the GC system, but it has a SteamIDAllowedToConnect() hook that would
			// allow it to reject the connect in the first place in a matchmaking scenario where cares.
			GTFGCClientSystem()->ClientConnected( *steamID, pEntity );
		}
	}
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldMakeChristmasAmmoPack( void )
{
	if ( IsInTournamentMode() && !IsMatchTypeCasual() )
		return false;

	if ( IsMannVsMachineMode() )
		return false;

	if ( mp_holiday_nogifts.GetBool() == true )
		return false;

	if ( IsHolidayActive( kHoliday_Christmas ) == false )
		return false;
 
	return ( RandomInt( 0, 100 ) < 10 );
}

//-----------------------------------------------------------------------------
// Purpose: **** DO NOT SHIP THIS IN REL/HL2 ****
//-----------------------------------------------------------------------------
void CTFGameRules::UpdatePeriodicEvent( CTFPlayer *pPlayer, eEconPeriodicScoreEvents eEvent, uint32 nCount )
{
	CSteamID steamID;
	if ( !pPlayer || !pPlayer->GetSteamID( &steamID ) || !steamID.IsValid() )
		return;

	GCSDK::CProtoBufMsg<CMsgUpdatePeriodicEvent> msg( k_EMsgGC_UpdatePeriodicEvent );
	msg.Body().set_account_id( steamID.GetAccountID() );
	msg.Body().set_event_type( eEvent );
	msg.Body().set_amount( nCount );
	GCClientSystem()->BSendMessage( msg );
}

#endif // GAME_DLL

#ifndef CLIENT_DLL

void CTFGameRules::Status( void (*print) (const char *fmt, ...) )
{
	// print( "Total Time: %d seconds\n", CTF_GameStats.m_currentMap.m_Header.m_iTotalTime );
	// priprint( "Blue Team Wins: %d\n", CTF_GameStats.m_currentMap.m_Header.m_iBlueWins );
	// priprint( "Red Team Wins: %d\n", CTF_GameStats.m_currentMap.m_Header.m_iRedWins );
	// priprint( "Stalemates: %d\n", CTF_GameStats.m_currentMap.m_Header.m_iStalemates );

	print( "         Spawns Points Kills Deaths Assists\n" );
	for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; iClass++ )
	{
		TF_Gamestats_ClassStats_t &Stats = CTF_GameStats.m_currentMap.m_aClassStats[ iClass ];

		print( "%-8s %6d %6d %5d %6d %7d\n",
			g_aPlayerClassNames_NonLocalized[ iClass ],
			Stats.iSpawns, Stats.iScore, Stats.iKills, Stats.iDeaths, Stats.iAssists );
	}
	print( "\n" );
}

#endif // !CLIENT_DLL

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldCollide( int collisionGroup0, int collisionGroup1 )
{
	if ( collisionGroup0 > collisionGroup1 )
	{
		// swap so that lowest is always first
		::V_swap( collisionGroup0, collisionGroup1 );
	}
	
	//Don't stand on COLLISION_GROUP_WEAPONs
	if( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT &&
		collisionGroup1 == COLLISION_GROUP_WEAPON )
	{
		return false;
	}

	// Don't stand on projectiles
	if( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT &&
		collisionGroup1 == COLLISION_GROUP_PROJECTILE )
	{
		return false;
	}

	// Rockets need to collide with players when they hit, but
	// be ignored by player movement checks
	if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER ) && 
		( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
		return true;

	if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT ) && 
		( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
		return false;

	if ( ( collisionGroup0 == COLLISION_GROUP_WEAPON ) && 
		( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
		return false;

	if ( ( collisionGroup0 == TF_COLLISIONGROUP_GRENADES ) && 
		( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
		return false;

	if ( ( collisionGroup0 == COLLISION_GROUP_PROJECTILE ) && 
		( collisionGroup1 == TFCOLLISION_GROUP_ROCKETS || collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
		return false;

	if ( ( collisionGroup0 == TFCOLLISION_GROUP_ROCKETS ) &&
		( collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
		return false;

	if ( ( collisionGroup0 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) &&
		( collisionGroup1 == TFCOLLISION_GROUP_ROCKET_BUT_NOT_WITH_OTHER_ROCKETS ) )
		return false;

	// Grenades don't collide with players. They handle collision while flying around manually.
	if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER ) && 
		( collisionGroup1 == TF_COLLISIONGROUP_GRENADES ) )
		return false;

	if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT ) && 
		( collisionGroup1 == TF_COLLISIONGROUP_GRENADES ) )
		return false;

	// Respawn rooms only collide with players
	if ( collisionGroup1 == TFCOLLISION_GROUP_RESPAWNROOMS )
		return ( collisionGroup0 == COLLISION_GROUP_PLAYER ) || ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT );
	
/*	if ( collisionGroup0 == COLLISION_GROUP_PLAYER )
	{
		// Players don't collide with objects or other players
		if ( collisionGroup1 == COLLISION_GROUP_PLAYER  )
			 return false;
 	}

	if ( collisionGroup1 == COLLISION_GROUP_PLAYER_MOVEMENT )
	{
		// This is only for probing, so it better not be on both sides!!!
		Assert( collisionGroup0 != COLLISION_GROUP_PLAYER_MOVEMENT );

		// No collide with players any more
		// Nor with objects or grenades
		switch ( collisionGroup0 )
		{
		default:
			break;
		case COLLISION_GROUP_PLAYER:
			return false;
		}
	}
*/
	// don't want caltrops and other grenades colliding with each other
	// caltops getting stuck on other caltrops, etc.)
	if ( ( collisionGroup0 == TF_COLLISIONGROUP_GRENADES ) && 
		 ( collisionGroup1 == TF_COLLISIONGROUP_GRENADES ) )
	{
		return false;
	}


	if ( collisionGroup0 == COLLISION_GROUP_PLAYER_MOVEMENT &&
		collisionGroup1 == TFCOLLISION_GROUP_COMBATOBJECT )
	{
		return false;
	}

	if ( collisionGroup0 == COLLISION_GROUP_PLAYER &&
		collisionGroup1 == TFCOLLISION_GROUP_COMBATOBJECT )
	{
		return false;
	}

	if ( ( collisionGroup0 == COLLISION_GROUP_PLAYER || collisionGroup0 ==  COLLISION_GROUP_PLAYER_MOVEMENT ) &&
		 collisionGroup1 == TFCOLLISION_GROUP_TANK )
	{
		return false;
	}

	return BaseClass::ShouldCollide( collisionGroup0, collisionGroup1 ); 
}

//-----------------------------------------------------------------------------
// Purpose: Return the value of this player towards capturing a point
//-----------------------------------------------------------------------------
int	CTFGameRules::GetCaptureValueForPlayer( CBasePlayer *pPlayer )
{
#ifdef GAME_DLL
#ifdef TF_CREEP_MODE
	if ( IsCreepWaveMode() )
	{
		CTFBot *bot = ToTFBot( pPlayer );

		if ( !bot || !bot->HasAttribute( CTFBot::IS_NPC ) )
		{
			// only creeps can influence points
			return 0;
		}
	}
#endif
#endif

	int nValue = BaseClass::GetCaptureValueForPlayer( pPlayer );


	CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
	if ( pTFPlayer->IsPlayerClass( TF_CLASS_SCOUT ) )
	{
		if ( mp_capstyle.GetInt() == 1 )
		{
			// Scouts count for 2 people in timebased capping.
			nValue = 2;
		}
		else
		{
			// Scouts can cap all points on their own.
			nValue = 10;
		}
	}

	CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, nValue, add_player_capturevalue );

	return nValue;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFGameRules::GetTimeLeft( void )
{
	float flTimeLimit = mp_timelimit.GetInt() * 60;

	Assert( flTimeLimit > 0 && "Should not call this function when !IsGameUnderTimeLimit" );

	float flMapChangeTime = m_flMapResetTime + flTimeLimit;

	int iTime = (int)(flMapChangeTime - gpGlobals->curtime);
	if ( iTime < 0 )
	{
		iTime = 0;
	}

	return ( iTime );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::FireGameEvent( IGameEvent *event )
{
	const char *eventName = event->GetName();

#ifdef GAME_DLL
	if ( !Q_strcmp( eventName, "teamplay_point_captured" ) )
	{
		if ( IsMannVsMachineMode() )
			return;

		// keep track of how many times each team caps
		int iTeam = event->GetInt( "team" );
		Assert( iTeam >= FIRST_GAME_TEAM && iTeam < TF_TEAM_COUNT );
		m_iNumCaps[iTeam]++;

		// award a capture to all capping players
		const char *cappers = event->GetString( "cappers" );

		Q_strncpy( m_szMostRecentCappers, cappers, ARRAYSIZE( m_szMostRecentCappers ) );	
		for ( int i =0; i < Q_strlen( cappers ); i++ )
		{
			int iPlayerIndex = (int) cappers[i];
			CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
			if ( pPlayer )
			{
				CTF_GameStats.Event_PlayerCapturedPoint( pPlayer );	

				if ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && GetGameType() == TF_GAMETYPE_ESCORT )
				{
					pPlayer->AwardAchievement( ACHIEVEMENT_TF_HEAVY_PAYLOAD_CAP_GRIND );
				}

				// Give money and experience
				int nAmount = CalculateCurrencyAmount_ByType( TF_CURRENCY_CAPTURED_OBJECTIVE );
#ifdef STAGING_ONLY
				if ( GameModeUsesExperience() )
				{
					pPlayer->AddExperiencePoints( nAmount );	
				}
#endif // STAGING_ONLY
				DistributeCurrencyAmount( nAmount, pPlayer, false );
			}
		}

		// Halloween 2012 doesn't want ghosts to spawn when the point is captured
		if( !IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) )
		{
			// for 2011 Halloween map
			BeginHaunting( 4, 25.f, 35.f );
		}
	}
	else if ( !Q_strcmp( eventName, "teamplay_capture_blocked" ) )
	{
		int iPlayerIndex = event->GetInt( "blocker" );
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
		CTF_GameStats.Event_PlayerDefendedPoint( pPlayer );

		pPlayer->m_Shared.CheckForAchievement( ACHIEVEMENT_TF_MEDIC_CHARGE_BLOCKER );
	}	
	else if ( !Q_strcmp( eventName, "teamplay_round_win" ) )
	{
		int iWinningTeam = event->GetInt( "team" );
		bool bFullRound = event->GetBool( "full_round" );
		float flRoundTime = event->GetFloat( "round_time" );
		bool bWasSuddenDeath = event->GetBool( "was_sudden_death" );
		CTF_GameStats.Event_RoundEnd( iWinningTeam, bFullRound, flRoundTime, bWasSuddenDeath );
	}
	else if ( !Q_strcmp( eventName, "teamplay_setup_finished" ) )
	{
		if ( IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_DOOMSDAY ) )
		{
			m_doomsdaySetupTimer.Start( 1 );
		}
	}
	else if ( !Q_strcmp( eventName, "teamplay_flag_event" ) )
	{
		// if this is a capture event, remember the player who made the capture		
		int iEventType = event->GetInt( "eventtype" );
		if ( TF_FLAGEVENT_CAPTURE == iEventType )
		{
			int iPlayerIndex = event->GetInt( "player" );
			m_szMostRecentCappers[0] = iPlayerIndex;
			m_szMostRecentCappers[1] = 0;
		}
	}
	else if ( !Q_strcmp( eventName, "player_escort_score" ) )
	{
		int iPlayer = event->GetInt( "player", 0 );
		int iPoints = event->GetInt( "points", 0 );

		if ( iPlayer > 0 && iPlayer <= MAX_PLAYERS )
		{
			CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex(iPlayer) );
			if ( pPlayer )
			{
				CTF_GameStats.Event_PlayerScoresEscortPoints( pPlayer, iPoints );

				int nAmount = CalculateCurrencyAmount_ByType( TF_CURRENCY_ESCORT_REWARD );
#ifdef STAGING_ONLY
				if ( GameModeUsesExperience() )
				{
					pPlayer->AddExperiencePoints( nAmount * iPoints );	
				}
#endif // STAGING_ONLY
				DistributeCurrencyAmount( ( nAmount * iPoints ), pPlayer, false );

				if ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && GetGameType() == TF_GAMETYPE_ESCORT )
				{
					for ( int i = 0 ; i < iPoints ; i++ )
					{
						pPlayer->AwardAchievement( ACHIEVEMENT_TF_HEAVY_PAYLOAD_CAP_GRIND );
					}
				}
			}
		}
	}
	else if ( !Q_strcmp( eventName, "player_disconnect" ) )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByUserId( event->GetInt("userid") ) );

		// @note Tom Bui: this really sucks, but we don't know the reason other than the string...
		const char *pReason = event->GetString( "reason" );
		if ( !Q_strncmp( pReason, "Kicked", ARRAYSIZE( "Kicked" ) - 1 ) )
		{
			if ( pPlayer )
			{
				DuelMiniGame_NotifyPlayerDisconnect( pPlayer, true );
			}
		}
	}
	else if ( !Q_strcmp( eventName, "teamplay_round_start" ) )
	{
		if ( IsMannVsMachineMode() )
		{
			if ( g_pPopulationManager )
			{
				g_pPopulationManager->RestorePlayerCurrency();
				
				// make sure all invaders are removed
				CUtlVector< CTFPlayer * > playerVector;
				CollectPlayers( &playerVector, TF_TEAM_PVE_INVADERS );

				for( int i=0; i<playerVector.Count(); ++i )
				{
					playerVector[i]->ChangeTeam( TEAM_SPECTATOR, false, true );
				}
			}
		}
	}
	else if ( !Q_strcmp( eventName, "recalculate_truce" ) )
	{
		RecalculateTruce();
	}
#else	// CLIENT_DLL
	if ( !Q_strcmp( eventName, "overtime_nag" ) )
	{
		HandleOvertimeBegin();
	}
	else if ( !Q_strcmp( eventName, "recalculate_holidays" ) )
	{
		UTIL_CalculateHolidays();
	}
#endif

	BaseClass::FireGameEvent( event );
}


const char *CTFGameRules::GetGameTypeName( void )
{
	return ::GetGameTypeName( m_nGameType.Get() );
}


void CTFGameRules::ClientSpawned( edict_t * pPlayer )
{
}

void CTFGameRules::OnFileReceived( const char * fileName, unsigned int transferID )
{
}

//-----------------------------------------------------------------------------
// Purpose: Init ammo definitions
//-----------------------------------------------------------------------------

// shared ammo definition
// JAY: Trying to make a more physical bullet response
#define BULLET_MASS_GRAINS_TO_LB(grains)	(0.002285*(grains)/16.0f)
#define BULLET_MASS_GRAINS_TO_KG(grains)	lbs2kg(BULLET_MASS_GRAINS_TO_LB(grains))

// exaggerate all of the forces, but use real numbers to keep them consistent
#define BULLET_IMPULSE_EXAGGERATION			1	

// convert a velocity in ft/sec and a mass in grains to an impulse in kg in/s
#define BULLET_IMPULSE(grains, ftpersec)	((ftpersec)*12*BULLET_MASS_GRAINS_TO_KG(grains)*BULLET_IMPULSE_EXAGGERATION)


CAmmoDef* GetAmmoDef()
{
	static CAmmoDef def;
	static bool bInitted = false;

	if ( !bInitted )
	{
		bInitted = true;
		
		// Start at 1 here and skip the dummy ammo type to make CAmmoDef use the same indices
		// as our #defines.
		for ( int i=1; i < TF_AMMO_COUNT; i++ )
		{
			const char *pszAmmoName = GetAmmoName( i );
			def.AddAmmoType( pszAmmoName, DMG_BULLET | DMG_USEDISTANCEMOD | DMG_NOCLOSEDISTANCEMOD, TRACER_LINE, 0, 0, "ammo_max", 2400, 10, 14 );
			Assert( def.Index( pszAmmoName ) == i );
		}
	}

	return &def;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CTFGameRules::GetTeamGoalString( int iTeam )
{
	if ( iTeam == TF_TEAM_RED )
		return m_pszTeamGoalStringRed.Get();
	if ( iTeam == TF_TEAM_BLUE )
		return m_pszTeamGoalStringBlue.Get();
	return NULL;
}

#ifdef GAME_DLL

	Vector MaybeDropToGround( 
							CBaseEntity *pMainEnt, 
							bool bDropToGround, 
							const Vector &vPos, 
							const Vector &vMins, 
							const Vector &vMaxs )
	{
		if ( bDropToGround )
		{
			trace_t trace;
			UTIL_TraceHull( vPos, vPos + Vector( 0, 0, -500 ), vMins, vMaxs, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace );
			return trace.endpos;
		}
		else
		{
			return vPos;
		}
	}

	//-----------------------------------------------------------------------------
	// Purpose: This function can be used to find a valid placement location for an entity.
	//			Given an origin to start looking from and a minimum radius to place the entity at,
	//			it will sweep out a circle around vOrigin and try to find a valid spot (on the ground)
	//			where mins and maxs will fit.
	// Input  : *pMainEnt - Entity to place
	//			&vOrigin - Point to search around
	//			fRadius - Radius to search within
	//			nTries - Number of tries to attempt
	//			&mins - mins of the Entity
	//			&maxs - maxs of the Entity
	//			&outPos - Return point
	// Output : Returns true and fills in outPos if it found a spot.
	//-----------------------------------------------------------------------------
	bool EntityPlacementTest( CBaseEntity *pMainEnt, const Vector &vOrigin, Vector &outPos, bool bDropToGround )
	{
		// This function moves the box out in each dimension in each step trying to find empty space like this:
		//
		//											  X  
		//							   X			  X  
		// Step 1:   X     Step 2:    XXX   Step 3: XXXXX
		//							   X 			  X  
		//											  X  
		//

		Vector mins, maxs;
		pMainEnt->CollisionProp()->WorldSpaceAABB( &mins, &maxs );
		mins -= pMainEnt->GetAbsOrigin();
		maxs -= pMainEnt->GetAbsOrigin();

		// Put some padding on their bbox.
		float flPadSize = 5;
		Vector vTestMins = mins - Vector( flPadSize, flPadSize, flPadSize );
		Vector vTestMaxs = maxs + Vector( flPadSize, flPadSize, flPadSize );

		// First test the starting origin.
		if ( UTIL_IsSpaceEmpty( pMainEnt, vOrigin + vTestMins, vOrigin + vTestMaxs ) )
		{
			outPos = MaybeDropToGround( pMainEnt, bDropToGround, vOrigin, vTestMins, vTestMaxs );
			return true;
		}

		Vector vDims = vTestMaxs - vTestMins;


		// Keep branching out until we get too far.
		int iCurIteration = 0;
		int nMaxIterations = 15;

		int offset = 0;
		do
		{
			for ( int iDim=0; iDim < 3; iDim++ )
			{
				float flCurOffset = offset * vDims[iDim];

				for ( int iSign=0; iSign < 2; iSign++ )
				{
					Vector vBase = vOrigin;
					vBase[iDim] += (iSign*2-1) * flCurOffset;

					if ( UTIL_IsSpaceEmpty( pMainEnt, vBase + vTestMins, vBase + vTestMaxs ) )
					{
						// Ensure that there is a clear line of sight from the spawnpoint entity to the actual spawn point.
						// (Useful for keeping things from spawning behind walls near a spawn point)
						trace_t tr;
						UTIL_TraceLine( vOrigin, vBase, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &tr );

						if ( tr.fraction != 1.0 )
						{
							continue;
						}

						outPos = MaybeDropToGround( pMainEnt, bDropToGround, vBase, vTestMins, vTestMaxs );
						return true;
					}
				}
			}

			++offset;
		} while ( iCurIteration++ < nMaxIterations );

		//	Warning( "EntityPlacementTest for ent %d:%s failed!\n", pMainEnt->entindex(), pMainEnt->GetClassname() );
		return false;
	}

#else // GAME_DLL

CTFGameRules::~CTFGameRules()
{
	if ( m_pkvVisionFilterTranslations )
	{
		m_pkvVisionFilterTranslations->deleteThis();
		m_pkvVisionFilterTranslations = NULL;
	}

	if ( m_pkvVisionFilterShadersMapWhitelist )
	{
		m_pkvVisionFilterShadersMapWhitelist->deleteThis();
		m_pkvVisionFilterShadersMapWhitelist = NULL;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::OnDataChanged( DataUpdateType_t updateType )
{
	BaseClass::OnDataChanged( updateType );

	m_bRecievedBaseline |= updateType == DATA_UPDATE_CREATED;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::HandleOvertimeBegin()
{
	C_TFPlayer *pTFPlayer = C_TFPlayer::GetLocalTFPlayer();
	if ( pTFPlayer )
	{
		pTFPlayer->EmitSound( "Game.Overtime" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldShowTeamGoal( void )
{

//=============================================================================
// HPE_BEGIN
// [msmith] We always show the team goal when in training.
//=============================================================================	
	bool showDuringSetup = InSetup();

	if ( IsInTraining() || IsInItemTestingMode() )
	{
		showDuringSetup = false;
	}

	if ( State_Get() == GR_STATE_PREROUND || State_Get() == GR_STATE_RND_RUNNING || showDuringSetup )
		return true;

//=============================================================================
// HPE_END
//=============================================================================
	return false;
}

#endif

#ifdef GAME_DLL

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::ShutdownCustomResponseRulesDicts()
{
	DestroyCustomResponseSystems();

	if ( m_ResponseRules.Count() != 0 )
	{
		int nRuleCount = m_ResponseRules.Count();
		for ( int iRule = 0; iRule < nRuleCount; ++iRule )
		{
			m_ResponseRules[iRule].m_ResponseSystems.Purge();
		}
		m_ResponseRules.Purge();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::InitCustomResponseRulesDicts()
{
	MEM_ALLOC_CREDIT();

	// Clear if necessary.
	ShutdownCustomResponseRulesDicts();

	// Initialize the response rules for TF.
	m_ResponseRules.AddMultipleToTail( TF_CLASS_COUNT_ALL );

	char szName[512];
	for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_CLASS_COUNT_ALL; ++iClass )
	{
		m_ResponseRules[iClass].m_ResponseSystems.AddMultipleToTail( MP_TF_CONCEPT_COUNT );

		for ( int iConcept = 0; iConcept < MP_TF_CONCEPT_COUNT; ++iConcept )
		{
			AI_CriteriaSet criteriaSet;
			criteriaSet.AppendCriteria( "playerclass", g_aPlayerClassNames_NonLocalized[iClass] );
			criteriaSet.AppendCriteria( "Concept", g_pszMPConcepts[iConcept] );

			// 1 point for player class and 1 point for concept.
			float flCriteriaScore = 2.0f;

			// Name.
			V_sprintf_safe( szName, "%s_%s\n", g_aPlayerClassNames_NonLocalized[iClass], g_pszMPConcepts[iConcept] );
			m_ResponseRules[iClass].m_ResponseSystems[iConcept] = BuildCustomResponseSystemGivenCriteria( "scripts/talker/response_rules.txt", szName, criteriaSet, flCriteriaScore );
		}		
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
#ifdef _DEBUG
CON_COMMAND( hud_notify, "Show a hud notification." )
{
	if ( args.ArgC() < 2 )
	{
		Warning( "Requires one argument, HudNotification_t, between 0 and %i\n", NUM_STOCK_NOTIFICATIONS );
		return;
	}

	if ( !TFGameRules() )
	{
		Warning( "Can't do that right now\n" );
		return;
	}

	CRecipientFilter filter;
	filter.AddAllPlayers();	
	TFGameRules()->SendHudNotification( filter, (HudNotification_t) V_atoi(args.Arg(1)) );
}
#endif

void CTFGameRules::SendHudNotification( IRecipientFilter &filter, HudNotification_t iType, bool bForceShow /*= false*/ )
{
	if ( !bForceShow && IsInWaitingForPlayers() )
		return;

	UserMessageBegin( filter, "HudNotify" );
		WRITE_BYTE( iType );
		WRITE_BOOL( bForceShow );	// Display in cl_hud_minmode
	MessageEnd();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SendHudNotification( IRecipientFilter &filter, const char *pszText, const char *pszIcon, int iTeam /*= TEAM_UNASSIGNED*/ )
{
	if ( IsInWaitingForPlayers() )
		return;

	UserMessageBegin( filter, "HudNotifyCustom" );
		WRITE_STRING( pszText );
		WRITE_STRING( pszIcon );
		WRITE_BYTE( iTeam );
	MessageEnd();
}

//-----------------------------------------------------------------------------
// Purpose: Is the player past the required delays for spawning
//-----------------------------------------------------------------------------
bool CTFGameRules::HasPassedMinRespawnTime( CBasePlayer *pPlayer )
{
	CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );

	if ( pTFPlayer && pTFPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_UNDEFINED )
		return true;

	float flMinSpawnTime = GetMinTimeWhenPlayerMaySpawn( pPlayer ); 

	return ( gpGlobals->curtime > flMinSpawnTime );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldRespawnQuickly( CBasePlayer *pPlayer )
{
	CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
	if ( IsPVEModeActive() && pTFPlayer && pTFPlayer->GetTeamNumber() == TF_TEAM_PVE_DEFENDERS && pTFPlayer->GetPlayerClass()->GetClassIndex() == TF_CLASS_SCOUT )
	{
		return true;
	}

#if defined( _DEBUG ) || defined( STAGING_ONLY )
	if ( mp_developer.GetBool() )
		return true;
#endif // _DEBUG || STAGING_ONLY

	if ( IsCompetitiveMode() && State_Get() == GR_STATE_BETWEEN_RNDS )
		return true;

	return BaseClass::ShouldRespawnQuickly( pPlayer );
}

typedef bool (*BIgnoreConvarChangeFunc)(void);

struct convar_tags_t
{
	const char *pszConVar;
	const char *pszTag;
	BIgnoreConvarChangeFunc ignoreConvarFunc;
};

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static bool BIgnoreConvarChangeInPVEMode(void)
{
	return TFGameRules() && TFGameRules()->IsPVEModeActive();
}

// The list of convars that automatically turn on tags when they're changed.
// Convars in this list need to have the FCVAR_NOTIFY flag set on them, so the
// tags are recalculated and uploaded to the master server when the convar is changed.
convar_tags_t convars_to_check_for_tags[] =
{
	{ "mp_friendlyfire", "friendlyfire", NULL },
	{ "tf_birthday", "birthday", NULL },
	{ "mp_respawnwavetime", "respawntimes", NULL },
	{ "mp_fadetoblack", "fadetoblack", NULL },
	{ "tf_weapon_criticals", "nocrits", NULL },
	{ "mp_disable_respawn_times", "norespawntime", NULL },
	{ "tf_gamemode_arena", "arena", NULL },
	{ "tf_gamemode_cp", "cp", NULL },
	{ "tf_gamemode_ctf", "ctf", NULL },
	{ "tf_gamemode_sd", "sd", NULL },
	{ "tf_gamemode_mvm", "mvm", NULL },
	{ "tf_gamemode_payload", "payload", NULL },
	{ "tf_gamemode_rd",	"rd", NULL },
	{ "tf_gamemode_pd",	"pd", NULL },
	{ "tf_gamemode_tc",	"tc", NULL },
	{ "tf_beta_content", "beta", NULL },
	{ "tf_damage_disablespread", "dmgspread", NULL },
	{ "mp_highlander", "highlander", NULL },
	{ "tf_bot_count", "bots", &BIgnoreConvarChangeInPVEMode },
	{ "tf_pve_mode", "pve" },
	{ "sv_registration_successful", "_registered", NULL },
	{ "tf_server_identity_disable_quickplay", "noquickplay", NULL },
	{ "tf_mm_strict", "hidden", NULL },
	{ "tf_medieval", "medieval", NULL },
	{ "mp_holiday_nogifts", "nogifts" },
	{ "tf_powerup_mode", "powerup", NULL },
	{ "tf_gamemode_passtime", "passtime", NULL },
	{ "tf_gamemode_misc", "misc", NULL }, // catch-all for matchmaking to identify sd, tc, and pd servers via sv_tags
};

//-----------------------------------------------------------------------------
// Purpose: Engine asks for the list of convars that should tag the server
//-----------------------------------------------------------------------------
void CTFGameRules::GetTaggedConVarList( KeyValues *pCvarTagList )
{
	BaseClass::GetTaggedConVarList( pCvarTagList );

	for ( int i = 0; i < ARRAYSIZE(convars_to_check_for_tags); i++ )
	{
		if ( convars_to_check_for_tags[i].ignoreConvarFunc && convars_to_check_for_tags[i].ignoreConvarFunc() )
			continue;

		KeyValues *pKV = new KeyValues( "tag" );
		pKV->SetString( "convar", convars_to_check_for_tags[i].pszConVar );
		pKV->SetString( "tag", convars_to_check_for_tags[i].pszTag );

		pCvarTagList->AddSubKey( pKV );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::PlaySpecialCapSounds( int iCappingTeam, CTeamControlPoint *pPoint )
{
	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_LAKESIDE ) )
	{
		return;
	}

	if ( GetGameType() == TF_GAMETYPE_CP )
	{
		bool bPlayControlPointCappedSound = IsInKothMode();
		if ( !bPlayControlPointCappedSound )
		{
			if ( pPoint && ShouldScorePerRound() )
			{
				CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
				if ( pMaster && !pMaster->WouldNewCPOwnerWinGame( pPoint, iCappingTeam ) )
				{
					bPlayControlPointCappedSound = true;
				}
			}
		}

		if ( bPlayControlPointCappedSound )
		{
			for ( int i = FIRST_GAME_TEAM; i < GetNumberOfTeams(); i++ )
			{
				if ( IsInKothMode() )
				{
					BroadcastSound( i, "Hud.PointCaptured" );
				}

				if ( i == iCappingTeam )
				{
					BroadcastSound( i, "Announcer.Success" );
				}
				else
				{
					BroadcastSound( i, "Announcer.Failure" );
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Factory to create TF-specific mission manager singleton
//-----------------------------------------------------------------------------
CTacticalMissionManager *CTFGameRules::TacticalMissionManagerFactory( void )
{
	return new CTFTacticalMissionManager;
}

#endif


//-----------------------------------------------------------------------------
// Purpose: Get the video file name for the current map.
//-----------------------------------------------------------------------------
#ifdef CLIENT_DLL
const char *CTFGameRules::GetVideoFileForMap( bool bWithExtension /*= true*/ )
{
	char mapname[MAX_MAP_NAME];
	mapname[0] = 0;

	Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname ) );
	if ( mapname[0] == 0 )
	{
		return NULL;
	}
	
	Q_strlower( mapname );
	return FormatVideoName( (const char *)mapname, bWithExtension );
}

//=============================================================================
// HPE_BEGIN
// [msmith] Used for the client to tell the server that we're watching a movie or not.
//			Also contains the name of a movie if it's an in game video.
//=============================================================================
//-----------------------------------------------------------------------------
// Purpose: Format a video file name from the name passed in.
//-----------------------------------------------------------------------------
const char *CTFGameRules::FormatVideoName( const char *videoName, bool bWithExtension /*= true*/ )
{

	static char strFullpath[MAX_PATH];		// this buffer is returned to the caller
	
#ifdef _X360
	// Should we be modifying a const buffer?
	// need to remove the .360 extension on the end of the map name
	char *pExt = Q_stristr( videoName, ".360" );
	if ( pExt )
	{
		*pExt = '\0';
	}
#endif

	Q_strncpy( strFullpath, "media/", MAX_PATH );	// Assume we must play out of the media directory

	if ( Q_strstr( videoName, "arena_" ) )
	{
		char strTempPath[MAX_PATH];
		Q_strncpy( strTempPath, "media/", MAX_PATH );
		Q_strncat( strTempPath, videoName, MAX_PATH );
		Q_strncat( strTempPath, FILE_EXTENSION_ANY_MATCHING_VIDEO, MAX_PATH );	

		VideoSystem_t vSystem = VideoSystem::NONE;

		// default to arena_intro video if we can't find the specified video
		if ( !g_pVideo || g_pVideo->LocatePlayableVideoFile( strTempPath, "GAME", &vSystem, strFullpath, sizeof(strFullpath), VideoSystemFeature::PLAY_VIDEO_FILE_IN_MATERIAL ) != VideoResult::SUCCESS )
		{
			V_strncpy( strFullpath, "media/" "arena_intro", MAX_PATH );
		}
	}
	else if ( Q_strstr( videoName, "mvm_" ) )
	{
		char strTempPath[MAX_PATH];
		Q_strncpy( strTempPath, "media/", MAX_PATH );
		Q_strncat( strTempPath, videoName, MAX_PATH );
		Q_strncat( strTempPath, FILE_EXTENSION_ANY_MATCHING_VIDEO, MAX_PATH );	

		VideoSystem_t vSystem = VideoSystem::NONE;

		// default to mvm_intro video if we can't find the specified video
		if ( !g_pVideo || g_pVideo->LocatePlayableVideoFile( strTempPath, "GAME", &vSystem, strFullpath, sizeof(strFullpath), VideoSystemFeature::PLAY_VIDEO_FILE_IN_MATERIAL ) != VideoResult::SUCCESS )
		{
			V_strncpy( strFullpath, "media/" "mvm_intro", MAX_PATH );
		}
	}
	else
	{
		Q_strncat( strFullpath, videoName, MAX_PATH );
	}

	if ( bWithExtension )
	{
		Q_strncat( strFullpath, FILE_EXTENSION_ANY_MATCHING_VIDEO, MAX_PATH );		// Don't assume any specific video type, let the video services find it
	}

	return strFullpath;
}
#endif
//=============================================================================
// HPE_END
//=============================================================================

#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *GetMapDisplayName( const char *mapName )
{
	static char szDisplayName[256];
	char szTempName[256];
	const char *pszSrc = NULL;

	szDisplayName[0] = '\0';

	if ( !mapName )
		return szDisplayName;

	// check our lookup table
	Q_strncpy( szTempName, mapName, sizeof( szTempName ) );
	Q_strlower( szTempName );
	pszSrc = szTempName;

	for ( int i = 0; i < ARRAYSIZE( s_ValveMaps ); ++i )
	{
		if ( !Q_stricmp( s_ValveMaps[i].pDiskName, pszSrc ) )
		{
			return s_ValveMaps[i].pDisplayName;
		}
	}

	// check the community maps that we've featured
	for ( int i = 0; i < ARRAYSIZE( s_CommunityMaps ); ++i )
	{
		if ( !Q_stricmp( s_CommunityMaps[i].pDiskName, pszSrc ) )
		{
			return s_CommunityMaps[i].pDisplayName;
		}
	}

	char *pszFinal = Q_strstr( pszSrc, "_final" );
	if ( pszFinal )
	{
		// truncate the _final (or _final1) part of the filename if it's at the end of the name
		char *pszNextChar = pszFinal + Q_strlen( "_final" );
		if ( pszNextChar )
		{
			if ( ( *pszNextChar == '\0' ) ||
				 ( ( *pszNextChar == '1' ) && ( *(pszNextChar+1) == '\0' ) ) )
			{
				*pszFinal = '\0';
			}
		}
	}

	// Our workshop maps will be of the format workshop/cp_somemap.ugc12345
	const char szWorkshop[] = "workshop/";
	if ( V_strncmp( pszSrc, szWorkshop, sizeof( szWorkshop ) - 1 ) == 0 )
	{
		pszSrc += sizeof( szWorkshop ) - 1;
		char *pszUGC = V_strstr( pszSrc, ".ugc" );
		int nUGCLen = pszUGC ? strlen( pszUGC ) : 0;
		if ( pszUGC && nUGCLen > 4 )
		{
			int i;
			for ( i = 4; i < nUGCLen; i ++ )
			{
				if ( pszUGC[i] < '0' || pszUGC[i] > '9' )
				{
					break;
				}
			}

			if ( i == nUGCLen )
			{
				*pszUGC = '\0';
			}
		}
	}

	// we haven't found a "friendly" map name, so let's just clean up what we have
	if ( !Q_strncmp( pszSrc, "cp_", 3 ) ||
		 !Q_strncmp( pszSrc, "tc_", 3 ) ||
		 !Q_strncmp( pszSrc, "pl_", 3 ) ||
		 !Q_strncmp( pszSrc, "ad_", 3 ) ||
		 !Q_strncmp( pszSrc, "sd_", 3 ) || 
		 !Q_strncmp( pszSrc, "rd_", 3 ) ||
		 !Q_strncmp( pszSrc, "pd_", 3 ) )
	{
		pszSrc +=  3;
	}
	else if ( !Q_strncmp( pszSrc, "ctf_", 4 ) ||
		      !Q_strncmp( pszSrc, "plr_", 4 ) )
	{
		pszSrc +=  4;
	}
	else if ( !Q_strncmp( szTempName, "koth_", 5 ) ||
			  !Q_strncmp( szTempName, "pass_", 5 ) )
	{
		pszSrc +=  5;
	}
#ifdef TF_RAID_MODE
	else if ( !Q_strncmp( pszSrc, "raid_", 5 ) )
	{
		pszSrc +=  5;
	}
#endif // TF_RAID_MODE
	else if ( !Q_strncmp( pszSrc, "mvm_", 4 ) )
	{
		pszSrc +=  4;
	}
	else if ( !Q_strncmp( pszSrc, "arena_", 6 ) )
	{
		pszSrc +=  6;
	}

	Q_strncpy( szDisplayName, pszSrc, sizeof( szDisplayName ) );
	Q_strupr( szDisplayName );

	// replace underscores with spaces
	for ( char *pszUnderscore = szDisplayName ; pszUnderscore != NULL && *pszUnderscore != 0 ; pszUnderscore++ )
	{
		// Replace it with a space
		if ( *pszUnderscore == '_' )
		{
			*pszUnderscore = ' ';
		}
	}

	return szDisplayName;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *GetMapType( const char *mapName )
{
	int i;

	if ( mapName )
	{
		for ( i = 0; i < ARRAYSIZE( s_ValveMaps ); ++i )
		{
			if ( !Q_stricmp( s_ValveMaps[i].pDiskName, mapName ) )
			{
				return s_ValveMaps[i].pGameType;
			}
		}

		// check the community maps that we've featured
		for ( i = 0; i < ARRAYSIZE( s_CommunityMaps ); ++i )
		{
			if ( !Q_stricmp( s_CommunityMaps[i].pDiskName, mapName ) )
			{
				return s_CommunityMaps[i].pGameType;
			}
		}
	}

	if ( !IsX360() )
	{
		// we haven't found a "friendly" map name, so let's just clean up what we have
		if ( !Q_strnicmp( mapName, "cp_", 3 ) )
		{
			return "#Gametype_CP";
		}
		else if ( !Q_strnicmp( mapName, "tc_", 3 ) )
		{
			return "#TF_TerritoryControl";
		}
		else if ( !Q_strnicmp( mapName, "pl_", 3 ) ) 
		{
			return "#Gametype_Escort";
		}
		else if ( !Q_strnicmp( mapName, "plr_", 4 ) ) 
		{
			return "#Gametype_EscortRace";
		}
		else if ( !Q_strnicmp( mapName, "ad_", 3 ) )
		{
			return "#TF_AttackDefend";
		}
		else if ( !Q_strnicmp( mapName, "ctf_", 4 ) )
		{
			return "#Gametype_CTF";
		}
		else if ( !Q_strnicmp( mapName, "koth_", 5 ) )
		{
			return "#Gametype_Koth";
		}
		else if ( !Q_strnicmp( mapName, "arena_", 6 ) )
		{
			return "#Gametype_Arena";
		}
		else if ( !Q_strnicmp( mapName, "sd_", 3 ) )
		{
			return "#Gametype_SD";
		}
#ifdef TF_RAID_MODE
		else if ( !Q_strnicmp( mapName, "raid_", 5 ) )
		{
			return "#Gametype_Raid";
		}
#endif // TF_RAID_MODE
		else if ( !Q_strnicmp( mapName, "mvm_", 4 ) )
		{
			return "#Gametype_MVM";
		}
		else if ( !Q_strnicmp( mapName, "pass_", 5 ) )
		{
			return "#GameType_Passtime";
		}
		else if ( !Q_strnicmp( mapName, "rd_", 3 ) )
		{
			return "#Gametype_RobotDestruction";
		}
		else if ( !Q_strnicmp( mapName, "pd_", 3 ) )
		{
			return "#Gametype_PlayerDestruction";
		}
		else
		{
			if ( TFGameRules() )
			{
				return TFGameRules()->GetGameTypeName();
			}
		}
	}

	return "";
}
#endif

//Arena Mode
bool CTFGameRules::IsInArenaMode( void ) const
{
	return m_nGameType == TF_GAMETYPE_ARENA;
}

#ifdef GAME_DLL

//==================================================================================================================
// ARENA LOGIC
BEGIN_DATADESC( CArenaLogic )
	DEFINE_OUTPUT( m_OnArenaRoundStart, "OnArenaRoundStart" ),
	DEFINE_OUTPUT( m_OnCapEnabled, "OnCapEnabled" ),
	DEFINE_KEYFIELD( m_flTimeToEnableCapPoint, FIELD_FLOAT, "CapEnableDelay" ),
	DEFINE_FUNCTION( ArenaLogicThink ),
END_DATADESC()

LINK_ENTITY_TO_CLASS( tf_logic_arena, CArenaLogic );


void CArenaLogic::Spawn( void )
{
	BaseClass::Spawn();

	SetThink( &CArenaLogic::ArenaLogicThink );
	SetNextThink( gpGlobals->curtime );
}

void CArenaLogic::ArenaLogicThink( void )
{
	SetNextThink( gpGlobals->curtime + 0.1f );

	if ( TFGameRules()->State_Get() != GR_STATE_STALEMATE )
		return;

	if ( TFGameRules() && TFGameRules()->GetCapturePointTime() <= gpGlobals->curtime )
	{
		if ( m_bFiredOutput == false )
		{
			m_bFiredOutput = true;
			m_OnCapEnabled.FireOutput( this, this );
		}
	}
	else if ( TFGameRules() && TFGameRules()->GetCapturePointTime() > gpGlobals->curtime )
	{
		m_bFiredOutput = false;
	}
}


//-----------------------------------------------------------------------------
// Purpose: COMPETITIVE LOGIC (why are we shouting?)
//-----------------------------------------------------------------------------
BEGIN_DATADESC( CCompetitiveLogic )
DEFINE_OUTPUT( m_OnSpawnRoomDoorsShouldLock, "OnSpawnRoomDoorsShouldLock" ),
DEFINE_OUTPUT( m_OnSpawnRoomDoorsShouldUnlock, "OnSpawnRoomDoorsShouldUnlock" ),
END_DATADESC()
LINK_ENTITY_TO_CLASS( tf_logic_competitive, CCompetitiveLogic );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CCompetitiveLogic::OnSpawnRoomDoorsShouldLock( void )
{
	if ( !TFGameRules() || !TFGameRules()->IsCompetitiveMode() )
		return; 

	m_OnSpawnRoomDoorsShouldLock.FireOutput( this, this );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CCompetitiveLogic::OnSpawnRoomDoorsShouldUnlock( void )
{
	if ( !TFGameRules() || !TFGameRules()->IsCompetitiveMode() )
		return; 

	m_OnSpawnRoomDoorsShouldUnlock.FireOutput( this, this );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
BEGIN_DATADESC( CLogicMannPower )
END_DATADESC()
LINK_ENTITY_TO_CLASS( tf_logic_mannpower, CLogicMannPower );

//=============================================================================
// Training Mode
CON_COMMAND( training_continue, "Tells training that it should continue." )
{
	if ( TFGameRules() == NULL || TFGameRules()->IsInTraining() == false || TFGameRules()->GetTrainingModeLogic() == NULL )
	{
		return;
	}
	TFGameRules()->GetTrainingModeLogic()->OnPlayerWantsToContinue();
}

#define SF_TF_DYNAMICPROP_GRENADE_COLLISION			512
class CTFTrainingDynamicProp : public CDynamicProp
{
	DECLARE_CLASS( CTFTrainingDynamicProp, CDynamicProp );
public:
};
LINK_ENTITY_TO_CLASS( training_prop_dynamic, CTFTrainingDynamicProp );

bool PropDynamic_CollidesWithGrenades( CBaseEntity *pBaseEntity )
{
	CTFTrainingDynamicProp *pTrainingDynamicProp = dynamic_cast< CTFTrainingDynamicProp* >( pBaseEntity );
	return ( pTrainingDynamicProp && pTrainingDynamicProp->HasSpawnFlags( SF_TF_DYNAMICPROP_GRENADE_COLLISION) );
}

BEGIN_DATADESC( CTrainingModeLogic )
	DEFINE_KEYFIELD( m_nextMapName, FIELD_STRING, "nextMap" ),
	DEFINE_INPUTFUNC( FIELD_STRING, "ShowTrainingMsg", InputShowTrainingMsg ),
	DEFINE_INPUTFUNC( FIELD_STRING, "ShowTrainingObjective", InputShowTrainingObjective ),
	DEFINE_INPUTFUNC( FIELD_VOID, "ForcePlayerSpawnAsClassOutput", InputForcePlayerSpawnAsClassOutput ),
	DEFINE_INPUTFUNC( FIELD_VOID, "KickBots", InputKickAllBots ),
	DEFINE_INPUTFUNC( FIELD_VOID, "ShowTrainingHUD", InputShowTrainingHUD ),
	DEFINE_INPUTFUNC( FIELD_VOID, "HideTrainingHUD", InputHideTrainingHUD ),
	DEFINE_INPUTFUNC( FIELD_STRING, "EndTraining", InputEndTraining ),
	DEFINE_INPUTFUNC( FIELD_STRING, "PlaySoundOnPlayer", InputPlaySoundOnPlayer ),
	DEFINE_INPUTFUNC( FIELD_STRING, "WaitForTimerOrKeypress", InputWaitForTimerOrKeypress ),
	DEFINE_INPUTFUNC( FIELD_STRING, "SetNextMap", InputSetNextMap ),
	DEFINE_INPUTFUNC( FIELD_STRING, "ForcePlayerSwapToWeapon", InputForcePlayerSwapToWeapon ),
	DEFINE_OUTPUT( m_outputOnPlayerSpawnAsScout, "OnPlayerSpawnAsScout" ),
	DEFINE_OUTPUT( m_outputOnPlayerSpawnAsSniper, "OnPlayerSpawnAsSniper" ),
	DEFINE_OUTPUT( m_outputOnPlayerSpawnAsSoldier, "OnPlayerSpawnAsSoldier" ),
	DEFINE_OUTPUT( m_outputOnPlayerSpawnAsDemoman, "OnPlayerSpawnAsDemoman" ),
	DEFINE_OUTPUT( m_outputOnPlayerSpawnAsMedic, "OnPlayerSpawnAsMedic" ),
	DEFINE_OUTPUT( m_outputOnPlayerSpawnAsHeavy, "OnPlayerSpawnAsHeavy" ),
	DEFINE_OUTPUT( m_outputOnPlayerSpawnAsPyro, "OnPlayerSpawnAsPyro" ),
	DEFINE_OUTPUT( m_outputOnPlayerSpawnAsSpy, "OnPlayerSpawnAsSpy" ),
	DEFINE_OUTPUT( m_outputOnPlayerSpawnAsEngineer, "OnPlayerSpawnAsEngineer" ),
	DEFINE_OUTPUT( m_outputOnPlayerDied, "OnPlayerDied" ),
	DEFINE_OUTPUT( m_outputOnBotDied, "OnBotDied" ),
	DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotPrimary, "OnPlayerSwappedToPrimary" ),
	DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotSecondary, "OnPlayerSwappedToSecondary" ),
	DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotMelee, "OnPlayerSwappedToMelee" ),
	DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotBuilding, "OnPlayerSwappedToBuilding" ),
	DEFINE_OUTPUT( m_outputOnPlayerSwappedToWeaponSlotPDA, "OnPlayerSwappedToPDA" ),
	DEFINE_OUTPUT( m_outputOnPlayerBuiltOutsideSuggestedArea, "OnBuildOutsideArea" ),
	DEFINE_OUTPUT( m_outputOnPlayerDetonateBuilding, "OnPlayerDetonateBuilding" ),
END_DATADESC()

LINK_ENTITY_TO_CLASS( tf_logic_training_mode, CTrainingModeLogic );

void CTrainingModeLogic::SetupOnRoundStart()
{
	m_objText[0] = 0;
	SetTrainingMsg( "" );
}

void CTrainingModeLogic::SetTrainingMsg(const char *msg)
{
	CBroadcastRecipientFilter allusers;
	allusers.MakeReliable();
	UserMessageBegin( allusers, "TrainingMsg" );
	WRITE_STRING( msg );
	MessageEnd();
}

void CTrainingModeLogic::SetTrainingObjective(const char *text)
{
	CBroadcastRecipientFilter allusers;
	allusers.MakeReliable();
	UserMessageBegin( allusers, "TrainingObjective" );
	WRITE_STRING( text );
	MessageEnd();
}

void CTrainingModeLogic::OnPlayerSpawned( CTFPlayer* pPlayer )
{
	if ( pPlayer->GetDesiredPlayerClassIndex() == TF_CLASS_UNDEFINED )
	{
		return;
	}
	if ( pPlayer->IsFakeClient() )
	{
		return;
	}
	int iClass = pPlayer->GetPlayerClass()->GetClassIndex();
	switch ( iClass )
	{
	case TF_CLASS_SCOUT:		m_outputOnPlayerSpawnAsScout.FireOutput( this, this ); break;
	case TF_CLASS_SNIPER:		m_outputOnPlayerSpawnAsSniper.FireOutput( this, this ); break;
	case TF_CLASS_SOLDIER:		m_outputOnPlayerSpawnAsSoldier.FireOutput( this, this ); break;
	case TF_CLASS_DEMOMAN:		m_outputOnPlayerSpawnAsDemoman.FireOutput( this, this ); break;
	case TF_CLASS_MEDIC:		m_outputOnPlayerSpawnAsMedic.FireOutput( this, this ); break;
	case TF_CLASS_HEAVYWEAPONS:	m_outputOnPlayerSpawnAsHeavy.FireOutput( this, this ); break;
	case TF_CLASS_PYRO:			m_outputOnPlayerSpawnAsPyro.FireOutput( this, this ); break;
	case TF_CLASS_SPY:			m_outputOnPlayerSpawnAsSpy.FireOutput( this, this ); break;
	case TF_CLASS_ENGINEER:		m_outputOnPlayerSpawnAsEngineer.FireOutput( this, this ); break;
	}
}

void CTrainingModeLogic::OnPlayerDied( CTFPlayer *pPlayer, CBaseEntity *pKiller )
{
	m_outputOnPlayerDied.FireOutput( pKiller, this );
}

void CTrainingModeLogic::OnBotDied( CTFPlayer *pPlayer, CBaseEntity *pKiller )
{
	m_outputOnBotDied.FireOutput( pKiller, this );
}

void CTrainingModeLogic::OnPlayerSwitchedWeapons( CTFPlayer *pPlayer )
{
	CTFWeaponBase *pWeapon = (CTFWeaponBase*)pPlayer->GetActiveWeapon();
	if ( pWeapon == NULL )
	{
		return;
	}
	switch ( pWeapon->GetTFWpnData().m_iWeaponType )
	{
	case TF_WPN_TYPE_PRIMARY:	m_outputOnPlayerSwappedToWeaponSlotPrimary.FireOutput( this, this ); break;
	case TF_WPN_TYPE_SECONDARY:	m_outputOnPlayerSwappedToWeaponSlotSecondary.FireOutput( this, this ); break;
	case TF_WPN_TYPE_MELEE:		m_outputOnPlayerSwappedToWeaponSlotMelee.FireOutput( this, this ); break;
	case TF_WPN_TYPE_BUILDING:	m_outputOnPlayerSwappedToWeaponSlotBuilding.FireOutput( this, this ); break;
	case TF_WPN_TYPE_PDA:		m_outputOnPlayerSwappedToWeaponSlotPDA.FireOutput( this, this ); break;
	}
}

void CTrainingModeLogic::OnPlayerWantsToContinue()
{
	if ( m_waitingForKeypressTimer.Get() != NULL )
	{
		m_waitingForKeypressTimer->FireNamedOutput( "OnTimer", variant_t(), this, this );
		m_waitingForKeypressTimer = NULL;
		TFGameRules()->SetIsWaitingForTrainingContinue( false );
	}
}

void CTrainingModeLogic::OnPlayerBuiltBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject )
{
	if ( pBaseObject && NotifyObjectBuiltInSuggestedArea( *pBaseObject ) == false )
	{
		m_outputOnPlayerBuiltOutsideSuggestedArea.FireOutput( pBaseObject, this );
	}
}

void CTrainingModeLogic::OnPlayerUpgradedBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject )
{
	if ( pBaseObject )
	{
		NotifyObjectUpgradedInSuggestedArea( *pBaseObject );
	}
}

void CTrainingModeLogic::OnPlayerDetonateBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject )
{
	m_outputOnPlayerDetonateBuilding.FireOutput( pPlayer, pBaseObject );
}

void CTrainingModeLogic::UpdateHUDObjective()
{
	if ( m_objText[0] != 0 )
	{
		SetTrainingObjective( m_objText );
	}
	else
	{
		SetTrainingObjective("");
	}
}

const char* CTrainingModeLogic::GetNextMap()
{
	return m_nextMapName.ToCStr();
}

const char* CTrainingModeLogic::GetTrainingEndText()
{
	return m_endTrainingText.ToCStr();
}

int CTrainingModeLogic::GetDesiredClass() const
{
	return training_class.GetInt();
}

void CTrainingModeLogic::InputForcePlayerSpawnAsClassOutput( inputdata_t &inputdata )
{
	// This is a bit weird, but we will call this for every player--bots should be ignored
	CTFPlayer *pPlayer;
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );

		if ( !pPlayer )
			continue;
		OnPlayerSpawned( pPlayer );
	}
}

void CTrainingModeLogic::InputKickAllBots( inputdata_t &inputdata )
{
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pPlayer && pPlayer->IsFakeClient() )
		{
			engine->ServerCommand( UTIL_VarArgs( "kickid %d\n", pPlayer->GetUserID() ) );
		}
	}
}

void CTrainingModeLogic::InputShowTrainingMsg( inputdata_t &inputdata )
{
	if ( TFGameRules()->IsInTraining() )
	{
		SetTrainingMsg( inputdata.value.String() );
	}
}

void CTrainingModeLogic::InputShowTrainingObjective( inputdata_t &inputdata )
{
	if ( !TFGameRules()->IsInTraining() )
		return;
  
	//First try to find the unicode string to send over.
	wchar_t *strPtr = NULL;
	strPtr = g_pVGuiLocalize->Find( inputdata.value.String() );

	if (NULL == strPtr)
	{
		V_strcpy_safe(m_objText, inputdata.value.String());
	}
	else
	{
		g_pVGuiLocalize->ConvertUnicodeToANSI(strPtr, m_objText, kMaxLengthObjectiveText);
	}
	
	UpdateHUDObjective();
}

void CTrainingModeLogic::InputShowTrainingHUD( inputdata_t &inputdata )
{
	if ( !TFGameRules()->IsInTraining() )
		return;
	TFGameRules()->SetTrainingHUDVisible( true );
}

void CTrainingModeLogic::InputHideTrainingHUD( inputdata_t &inputdata )
{
	if ( !TFGameRules()->IsInTraining() )
		return;
	TFGameRules()->SetTrainingHUDVisible( false );
}

void CTrainingModeLogic::InputEndTraining( inputdata_t &inputdata )
{
	if ( !TFGameRules()->IsInTraining() )
		return;

	TFGameRules()->SetAllowTrainingAchievements( true );

	m_endTrainingText = inputdata.value.StringID();

	CTFPlayer* pHumanPlayer = ToTFPlayer( UTIL_GetListenServerHost() );
	    
	if (NULL == pHumanPlayer) return;
	
	int iTeam = pHumanPlayer->GetTeamNumber();
	
	bool force_map_reset = true;
	CTeamplayRoundBasedRules *pGameRules = dynamic_cast<CTeamplayRoundBasedRules *>( GameRules() );
	pGameRules->SetWinningTeam( iTeam, pGameRules->GetWinReason(), force_map_reset );

	// Show a training win screen so send that event instead.
	IGameEvent *winEvent = gameeventmanager->CreateEvent( "training_complete" );
	if ( winEvent )
	{
		winEvent->SetString( "map", STRING( gpGlobals->mapname ) );
		winEvent->SetString( "next_map", GetNextMap() );
		winEvent->SetString( "text", GetTrainingEndText() );
		
		gameeventmanager->FireEvent( winEvent );
	}
}

void CTrainingModeLogic::InputPlaySoundOnPlayer( inputdata_t &inputdata )
{
	if ( !TFGameRules()->IsInTraining() )
		return;
	CTFPlayer* pHumanPlayer = ToTFPlayer( UTIL_GetListenServerHost() );

	if (NULL == pHumanPlayer) 
		return;

	pHumanPlayer->EmitSound( inputdata.value.String() );
}

void CTrainingModeLogic::InputWaitForTimerOrKeypress( inputdata_t &inputdata )
{
	if ( !TFGameRules()->IsInTraining() )
		return;

	m_waitingForKeypressTimer = gEntList.FindEntityByName( NULL, inputdata.value.String() );
	TFGameRules()->SetIsWaitingForTrainingContinue( m_waitingForKeypressTimer.Get() != NULL );
}

void CTrainingModeLogic::InputSetNextMap( inputdata_t &inputdata )
{
	m_nextMapName = AllocPooledString( inputdata.value.String() );
}

void CTrainingModeLogic::InputForcePlayerSwapToWeapon( inputdata_t &inputdata )
{
	CTFPlayer* pHumanPlayer = ToTFPlayer( UTIL_GetListenServerHost() );

	if (NULL == pHumanPlayer) 
		return;

	CBaseCombatWeapon *pWeapon = NULL;

	if ( FStrEq( inputdata.value.String(), "primary" ) )
	{
		pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_PRIMARY );
	}
	else if ( FStrEq( inputdata.value.String(), "secondary" ) )
	{
		pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_SECONDARY );
	}
	else if ( FStrEq( inputdata.value.String(), "melee" ) )
	{
		pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_MELEE );
	}
	else if ( FStrEq( inputdata.value.String(), "grenade" ) )
	{
		pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_GRENADE );
	}
	else if ( FStrEq( inputdata.value.String(), "building" ) )
	{
		pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_BUILDING );
	}
	else if ( FStrEq( inputdata.value.String(), "pda" ) )
	{
		pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_PDA );
	}
	else if ( FStrEq( inputdata.value.String(), "item1" ) )
	{
		pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_ITEM1 );
	}
	else if ( FStrEq( inputdata.value.String(), "item2" ) )
	{
		pWeapon = pHumanPlayer->Weapon_GetSlot( TF_WPN_TYPE_ITEM2 );
	}

	if ( pWeapon )
	{
		pHumanPlayer->Weapon_Switch( pWeapon );
	}

}

LINK_ENTITY_TO_CLASS( tf_logic_multiple_escort, CMultipleEscort );
LINK_ENTITY_TO_CLASS( tf_logic_hybrid_ctf_cp, CHybridMap_CTF_CP );
LINK_ENTITY_TO_CLASS( tf_logic_medieval, CMedievalLogic );


BEGIN_DATADESC(CTFHolidayEntity)
	DEFINE_KEYFIELD( m_nHolidayType, FIELD_INTEGER,	"holiday_type" ),
	DEFINE_KEYFIELD( m_nTauntInHell, FIELD_INTEGER,	"tauntInHell" ),
	DEFINE_KEYFIELD( m_nAllowHaunting, FIELD_INTEGER, "allowHaunting" ),
	
	DEFINE_INPUTFUNC( FIELD_INTEGER, "HalloweenSetUsingSpells", InputHalloweenSetUsingSpells ),
	DEFINE_INPUTFUNC( FIELD_STRING,	"Halloween2013TeleportToHell", InputHalloweenTeleportToHell ),
END_DATADESC();

LINK_ENTITY_TO_CLASS( tf_logic_holiday, CTFHolidayEntity );


void CTFHolidayEntity::InputHalloweenSetUsingSpells( inputdata_t &inputdata )
{
	if ( !TFGameRules() )
		return;

	TFGameRules()->SetUsingSpells( ( inputdata.value.Int() == 0 ) ? false : true );
}

void CTFHolidayEntity::InputHalloweenTeleportToHell( inputdata_t &inputdata )
{
	m_nWinningTeam = FStrEq( "red", inputdata.value.String() ) ? TF_TEAM_RED : TF_TEAM_BLUE;

	CUtlVector< CTFPlayer * > vecPlayers;
	CollectPlayers( &vecPlayers, TEAM_ANY, false );

	FOR_EACH_VEC( vecPlayers, i )
	{
		CTFPlayer *pPlayer = vecPlayers[i];
		// Only do these effects if the player is alive
		if ( !pPlayer->IsAlive() )
			continue;

		// Fade to white
		color32 fadeColor = {255,255,255,255};
		UTIL_ScreenFade( pPlayer, fadeColor, 2.f, 0.5, FFADE_OUT | FFADE_PURGE );

		// Do a zoom in effect
		pPlayer->SetFOV( pPlayer, 10.f, 2.5f, 0.f );
		// Rumble like something important happened
		UTIL_ScreenShake(pPlayer->GetAbsOrigin(), 100.f, 150, 4.f, 0.f, SHAKE_START, true );
	}

	// Play a sound for all players
	TFGameRules()->BroadcastSound( 255, "Halloween.hellride" );

	SetContextThink( &CTFHolidayEntity::Teleport, gpGlobals->curtime + 2.5f, "TeleportToHell" );
}

void CTFHolidayEntity::Teleport() 
{
	RemoveAll2013HalloweenTeleportSpellsInMidFlight();

	const char *pszRedString	= ( m_nWinningTeam == TF_TEAM_RED ) ? "winner" : "loser";
	const char *pszBlueString	= ( m_nWinningTeam == TF_TEAM_BLUE ) ? "winner" : "loser";

	CUtlVector< CTFPlayer* > vecTeleportedPlayers;
	TFGameRules()->TeleportPlayersToTargetEntities( TF_TEAM_RED, CFmtStr( "spawn_loot_%s" , pszRedString ), &vecTeleportedPlayers );
	TFGameRules()->TeleportPlayersToTargetEntities( TF_TEAM_BLUE, CFmtStr( "spawn_loot_%s" , pszBlueString ), &vecTeleportedPlayers );

	// clear dancer
	m_vecDancers.RemoveAll();

	// remove players' projectiles and buildings from world
	TFGameRules()->RemoveAllProjectilesAndBuildings();

	FOR_EACH_VEC( vecTeleportedPlayers, i )
	{
		CTFPlayer *pPlayer = vecTeleportedPlayers[i];

		// Roll a new, low-tier spell
		CTFSpellBook *pSpellBook = dynamic_cast< CTFSpellBook* >( pPlayer->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
		if ( pSpellBook )
		{
			pSpellBook->ClearSpell();
			if ( TFGameRules()->IsHalloweenScenario( CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
			{
				pSpellBook->RollNewSpell( 0, true );
			}
		}

		// Do a zoom effect
		pPlayer->SetFOV( pPlayer, tf_teleporter_fov_start.GetInt() );
		pPlayer->SetFOV( pPlayer, 0, 1.f, tf_teleporter_fov_start.GetInt() );

		// Screen flash
		color32 fadeColor = {255,255,255,100};
		UTIL_ScreenFade( pPlayer, fadeColor, 0.25, 0.4, FFADE_IN );

		const float flDanceTime = 6.f;

		if ( ShouldTauntInHell() || ( TFGameRules()->GetHalloweenScenario() == CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
		{
			pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_THRILLER, flDanceTime );
		}

		pPlayer->m_Shared.AddCond( TF_COND_HALLOWEEN_IN_HELL );

		// Losers get their health set to max.  Winners get overhealed
		bool bIsWinner = ( pPlayer->GetTeamNumber() == m_nWinningTeam );
		float flMax = bIsWinner ? ( pPlayer->GetMaxHealth() * 1.6f ) : ( pPlayer->GetMaxHealth() * 1.1 );
		float flToHeal = flMax - pPlayer->GetHealth();
		// Overheal the winning team, and just restore the losing team to full health
		pPlayer->m_Shared.Heal( pPlayer, flToHeal / flDanceTime, bIsWinner ? 1.5f : 1.f, 1.0f );

		// Give them full ammo
		pPlayer->GiveAmmo( 1000, TF_AMMO_PRIMARY );
		pPlayer->GiveAmmo( 1000, TF_AMMO_SECONDARY );
		pPlayer->GiveAmmo( 1000, TF_AMMO_METAL );
		pPlayer->GiveAmmo( 1000, TF_AMMO_GRENADES1 );
		pPlayer->GiveAmmo( 1000, TF_AMMO_GRENADES2 );
		pPlayer->GiveAmmo( 1000, TF_AMMO_GRENADES3 );

		// Refills weapon clips, too
		for ( int i = 0; i < MAX_WEAPONS; i++ )
		{
			CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase* >( pPlayer->GetWeapon( i ) );
			if ( !pWeapon )
				continue;

			pWeapon->GiveDefaultAmmo();

			if ( pWeapon->IsEnergyWeapon() )
			{
				pWeapon->WeaponRegenerate();
			}
		}

		m_vecDancers.AddToTail( pPlayer );
	}

	// Set this flag.  Lets us check elsewhere if it's hell time
	if ( TFGameRules() )
	{
		TFGameRules()->SetPlayersInHell( true );
	}

	if ( ShouldTauntInHell() || ( TFGameRules()->GetHalloweenScenario() == CTFGameRules::HALLOWEEN_SCENARIO_HIGHTOWER ) )
	{
		const float flDanceTime = 0.5f;
		const float flDanceDuration = 2.75f;

		SetContextThink( &CTFHolidayEntity::HalloweenTeleportToHellDanceThink, gpGlobals->curtime + flDanceTime, "DanceThink1" );
		SetContextThink( &CTFHolidayEntity::HalloweenTeleportToHellDanceThink, gpGlobals->curtime + flDanceTime + flDanceDuration, "DanceThink2" );
	}
}


void CTFHolidayEntity::HalloweenTeleportToHellDanceThink( void )
{
	FOR_EACH_VEC( m_vecDancers, i )
	{
		CTFPlayer* pPlayer = m_vecDancers[i];
		if ( !pPlayer )
			continue;

		// Dance
		pPlayer->Taunt();
	}
}

void CTFHolidayEntity::FireGameEvent( IGameEvent *event )
{
	const char *eventName = event->GetName();

#ifdef GAME_DLL
	if ( !Q_strcmp( eventName, "player_turned_to_ghost" ) 
		|| !Q_strcmp( eventName, "player_disconnect" )
		|| !Q_strcmp( eventName, "player_team" ))
	{
		if ( TFGameRules()->ArePlayersInHell() )
		{
			CUtlVector< CTFPlayer * > vecPlayers;
			CollectPlayers( &vecPlayers, TF_TEAM_RED, true );
			CollectPlayers( &vecPlayers, TF_TEAM_BLUE, true, true );

			FOR_EACH_VEC( vecPlayers, i )
			{
				// If everyone is a ghost
				if ( !vecPlayers[i]->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
					return;
			}

			// Everyone is a ghost.  Stalemate!
			TFGameRules()->SetWinningTeam( TEAM_UNASSIGNED, WINREASON_STALEMATE, true, false );
		}
	}
#endif
}

BEGIN_DATADESC(CKothLogic)
	DEFINE_KEYFIELD( m_nTimerInitialLength,		FIELD_INTEGER,	"timer_length" ),
	DEFINE_KEYFIELD( m_nTimeToUnlockPoint,		FIELD_INTEGER,	"unlock_point" ),

	DEFINE_INPUTFUNC( FIELD_VOID,		"RoundSpawn",		InputRoundSpawn ),
	DEFINE_INPUTFUNC( FIELD_VOID,		"RoundActivate",	InputRoundActivate ),
	DEFINE_INPUTFUNC( FIELD_INTEGER,	"SetRedTimer",		InputSetRedTimer ),
	DEFINE_INPUTFUNC( FIELD_INTEGER,	"SetBlueTimer",		InputSetBlueTimer ),
	DEFINE_INPUTFUNC( FIELD_INTEGER,	"AddRedTimer",		InputAddRedTimer ),
	DEFINE_INPUTFUNC( FIELD_INTEGER,	"AddBlueTimer",		InputAddBlueTimer ),
END_DATADESC();

LINK_ENTITY_TO_CLASS( tf_logic_koth, CKothLogic );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKothLogic::InputRoundSpawn( inputdata_t &input )
{
	if ( TFGameRules() && TFGameRules()->IsInKothMode() )
	{
		// create the koth team_round_timer entities
		variant_t sVariant;
		sVariant.SetInt( m_nTimerInitialLength );

		CTeamRoundTimer *pTimer = NULL;

		pTimer = (CTeamRoundTimer*)CBaseEntity::Create( "team_round_timer", vec3_origin, vec3_angle );
		if ( pTimer )
		{
			TFGameRules()->SetKothTeamTimer( TF_TEAM_BLUE, pTimer );
			pTimer->SetName( MAKE_STRING( "zz_blue_koth_timer" ) );
			pTimer->SetShowInHud( true );
			pTimer->AcceptInput( "SetTime", NULL, NULL, sVariant, 0 );
			pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );

			m_hBlueTimer = pTimer;
		}

		pTimer = (CTeamRoundTimer*)CBaseEntity::Create( "team_round_timer", vec3_origin, vec3_angle );
		if ( pTimer )
		{
			TFGameRules()->SetKothTeamTimer( TF_TEAM_RED, pTimer );
			pTimer->SetName( MAKE_STRING( "zz_red_koth_timer" ) );
			pTimer->SetShowInHud( true );
			pTimer->AcceptInput( "SetTime", NULL, NULL, sVariant, 0 );
			pTimer->AcceptInput( "Pause", NULL, NULL, sVariant, 0 );

			m_hRedTimer = pTimer;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKothLogic::InputRoundActivate( inputdata_t &inputdata )
{
	if ( TFGameRules() && TFGameRules()->IsInKothMode() )
	{
		CTeamControlPointMaster *pMaster = g_hControlPointMasters.Count() ? g_hControlPointMasters[0] : NULL;
		if ( pMaster )
		{
			variant_t sVariant;
			sVariant.SetInt( m_nTimeToUnlockPoint );

			for ( int i = 0 ; i < pMaster->GetNumPoints() ; i++ )
			{
				CTeamControlPoint *pPoint = pMaster->GetControlPoint( i );
				if ( pPoint )
				{
					pPoint->AcceptInput( "SetLocked", NULL, NULL, sVariant, 0 );

					if ( m_nTimeToUnlockPoint > 0 )
					{
						pPoint->AcceptInput( "SetUnlockTime", NULL, NULL, sVariant, 0 );
					}
				}
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKothLogic::InputSetRedTimer( inputdata_t &inputdata )
{
	if ( TFGameRules() && TFGameRules()->IsInKothMode() )
	{
		if ( m_hRedTimer )
		{
			m_hRedTimer->SetTimeRemaining( inputdata.value.Int() );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKothLogic::InputSetBlueTimer( inputdata_t &inputdata )
{
	if ( TFGameRules() && TFGameRules()->IsInKothMode() )
	{
		if ( m_hBlueTimer )
		{
			m_hBlueTimer->SetTimeRemaining( inputdata.value.Int() );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKothLogic::InputAddRedTimer( inputdata_t &inputdata )
{
	if ( TFGameRules() && TFGameRules()->IsInKothMode() )
	{
		if ( m_hRedTimer )
		{
			m_hRedTimer->AddTimerSeconds( inputdata.value.Int() );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKothLogic::InputAddBlueTimer( inputdata_t &inputdata )
{
	if ( TFGameRules() && TFGameRules()->IsInKothMode() )
	{
		if ( m_hBlueTimer )
		{
			m_hBlueTimer->AddTimerSeconds( inputdata.value.Int() );
		}
	}
}

BEGIN_DATADESC(CCPTimerLogic)
	DEFINE_KEYFIELD( m_iszControlPointName, FIELD_STRING, "controlpoint" ),
	DEFINE_KEYFIELD( m_nTimerLength, FIELD_INTEGER,	"timer_length" ),

	DEFINE_INPUTFUNC( FIELD_VOID, "RoundSpawn", InputRoundSpawn ),

	DEFINE_OUTPUT( m_onCountdownStart, "OnCountdownStart" ),
	DEFINE_OUTPUT( m_onCountdown15SecRemain, "OnCountdown15SecRemain" ),
	DEFINE_OUTPUT( m_onCountdown10SecRemain, "OnCountdown10SecRemain" ),
	DEFINE_OUTPUT( m_onCountdown5SecRemain, "OnCountdown5SecRemain" ),
	DEFINE_OUTPUT( m_onCountdownEnd, "OnCountdownEnd" ),
END_DATADESC();

LINK_ENTITY_TO_CLASS( tf_logic_cp_timer, CCPTimerLogic );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CCPTimerLogic::InputRoundSpawn( inputdata_t &input )
{
	if ( m_iszControlPointName != NULL_STRING )
	{
		// We need to re-find our control point, because they're recreated over round restarts
		m_hControlPoint = dynamic_cast<CTeamControlPoint*>( gEntList.FindEntityByName( NULL, m_iszControlPointName ) );
		if ( !m_hControlPoint )
		{
			Warning( "%s failed to find control point named '%s'\n", GetClassname(), STRING(m_iszControlPointName) );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CCPTimerLogic::TimerMayExpire( void )
{
	if ( m_hControlPoint )
	{
		if ( TeamplayGameRules()->TeamMayCapturePoint( TF_TEAM_BLUE, m_hControlPoint->GetPointIndex() ) )
			return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CCPTimerLogic::Think( void )
{
	if ( !TFGameRules() || !ObjectiveResource() )
		return;
	
	if ( TFGameRules()->State_Get() == GR_STATE_TEAM_WIN )
	{
		// game has already been won, our job is done
		m_pointTimer.Invalidate();
		SetContextThink( &CCPTimerLogic::Think, gpGlobals->curtime + 0.15, CP_TIMER_THINK );
	}

	if ( m_hControlPoint )
	{
		if ( TeamplayGameRules()->TeamMayCapturePoint( TF_TEAM_BLUE, m_hControlPoint->GetPointIndex() ) )
		{
			if ( !m_pointTimer.HasStarted() )
			{
				m_pointTimer.Start( m_nTimerLength );
				m_onCountdownStart.FireOutput( this, this );

				ObjectiveResource()->SetCPTimerTime( m_hControlPoint->GetPointIndex(), gpGlobals->curtime + m_nTimerLength );
			}
			else
			{
				if ( m_pointTimer.IsElapsed() )
				{
					// the point must be fully owned by the owner before we reset
					if ( ObjectiveResource()->GetCappingTeam( m_hControlPoint->GetPointIndex() ) == TEAM_UNASSIGNED )
					{
						m_pointTimer.Invalidate();
						m_onCountdownEnd.FireOutput( this, this );
						m_bFire15SecRemain = m_bFire10SecRemain = m_bFire5SecRemain = true;

						ObjectiveResource()->SetCPTimerTime( m_hControlPoint->GetPointIndex(), -1.0f );
					}
				}
				else 
				{
					float flRemainingTime = m_pointTimer.GetRemainingTime();

					if ( flRemainingTime <= 15.0f && m_bFire15SecRemain )
					{
						m_bFire15SecRemain = false;
					}
					else if ( flRemainingTime <= 10.0f && m_bFire10SecRemain )
					{
						m_bFire10SecRemain = false;
					}
					else if ( flRemainingTime <= 5.0f && m_bFire5SecRemain )
					{
						m_bFire5SecRemain = false;
					}
				}
			}
		}
		else
		{
			m_pointTimer.Invalidate();
		}
	}

	SetContextThink( &CCPTimerLogic::Think, gpGlobals->curtime + 0.15, CP_TIMER_THINK );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::AddPlayerToQueue( CTFPlayer *pPlayer )
{
	//Already in Queue
	if ( m_hArenaPlayerQueue.Find( pPlayer ) != m_hArenaPlayerQueue.InvalidIndex() )
		return;

	if ( pPlayer->IsArenaSpectator() == true )
		return;

//	Msg( "AddPlayerToQueue:: Adding to queue: %s\n", pPlayer->GetPlayerName() );

	m_hArenaPlayerQueue.AddToTail( pPlayer );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::AddPlayerToQueueHead( CTFPlayer *pPlayer )
{
	//Already in Queue
	if ( m_hArenaPlayerQueue.Find( pPlayer ) != m_hArenaPlayerQueue.InvalidIndex() )
		return;

	m_hArenaPlayerQueue.AddToHead( pPlayer );

//	Msg( "AddPlayerToQueueHead:: Adding to queue: %s\n", pPlayer->GetPlayerName() );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::RemovePlayerFromQueue( CTFPlayer *pPlayer )
{
	//Not in list?
	if ( m_hArenaPlayerQueue.Find( pPlayer ) == m_hArenaPlayerQueue.InvalidIndex() )
		return;

	m_hArenaPlayerQueue.FindAndRemove( pPlayer );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::OnNavMeshLoad( void )
{
	TheNavMesh->SetPlayerSpawnName( "info_player_teamspawn" );
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::OnDispenserBuilt( CBaseEntity *dispenser )
{
	if ( !m_healthVector.HasElement( dispenser ) )
	{
		m_healthVector.AddToTail( dispenser );
	}

	if ( !m_ammoVector.HasElement( dispenser ) )
	{
		m_ammoVector.AddToTail( dispenser );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::OnDispenserDestroyed( CBaseEntity *dispenser )
{
	m_healthVector.FindAndFastRemove( dispenser );
	m_ammoVector.FindAndFastRemove( dispenser );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CPhysicsProp *CreateBeachBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles );
CPhysicsProp *CreateSoccerBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles );

#ifdef STAGING_ONLY
//------------------------------------------------------------------------------
// Purpose: 
//------------------------------------------------------------------------------
void CC_Spawn_SoccerBall( const CCommand& args )
{
	CBasePlayer *pPlayer = UTIL_GetCommandClient();
	if ( pPlayer )
	{
		trace_t tr;
		Vector forward;
		pPlayer->EyeVectors( &forward );
		UTIL_TraceLine( pPlayer->EyePosition(),
						pPlayer->EyePosition() + forward * MAX_TRACE_LENGTH,MASK_NPCSOLID, 
						pPlayer, COLLISION_GROUP_NONE, &tr );
		if ( tr.fraction != 1.0 )
		{
			CreateSoccerBall( tr.endpos, vec3_angle );
		}
	}
}

ConCommand tf_spawn_soccerball( "tf_spawn_soccerball", CC_Spawn_SoccerBall, "", FCVAR_CHEAT );
#endif // STAGING_ONLY

static bool CanFindBallSpawnLocation( const Vector& vSearchOrigin, Vector *out_pvDropSpot )
{
	// find clear space to drop the ball
	for( float angle = 0.0f; angle < 2.0f * M_PI; angle += 0.2f )
	{
		Vector forward;
		FastSinCos( angle, &forward.y, &forward.x );
		forward.z = 0.0f;					

		const float ballRadius = 16.0f;
		const float playerRadius = 20.0f;

		Vector hullMins( -ballRadius, -ballRadius, -ballRadius );
		Vector hullMaxs( ballRadius, ballRadius, ballRadius );

		Vector dropSpot = vSearchOrigin + 1.2f * ( playerRadius + ballRadius ) * forward;

		trace_t result;
		UTIL_TraceHull( dropSpot, dropSpot, hullMins, hullMaxs, MASK_PLAYERSOLID, NULL, &result );

		if ( !result.DidHit() )
		{
			*out_pvDropSpot = dropSpot;
			return true;
		}
	}

	return false;
}

void CTFGameRules::OnPlayerSpawned( CTFPlayer *pPlayer )
{
	// coach?
	CSteamID steamIDForPlayer;
	if ( pPlayer->GetSteamID( &steamIDForPlayer ) )
	{
		// find out if we are supposed to coach
		int idx = m_mapCoachToStudentMap.Find( steamIDForPlayer.GetAccountID() );
		if ( m_mapCoachToStudentMap.IsValidIndex( idx ) )
		{
			// find student
			uint32 studentAccountID = m_mapCoachToStudentMap[idx];
			CSteamID steamIDForStudent;
			for ( int i = 1; i <= gpGlobals->maxClients; i++ )
			{
				CTFPlayer *pPotentialStudent = ToTFPlayer( UTIL_PlayerByIndex( i ) );
				if ( NULL == pPotentialStudent )
				{
					continue;
				}
				// is this the student?
				if ( pPotentialStudent->GetSteamID( &steamIDForStudent ) && steamIDForStudent.GetAccountID() == studentAccountID )
				{
					Coaching_Start( pPlayer, pPotentialStudent );
					// @todo (Tom Bui): Not sure this is required--nothing seems to use it
					// engine->ClientCommand( pPlayer->edict(), "cl_spec_mode %d", OBS_MODE_IN_EYE );
					// finally, notify the GC
					GCSDK::CProtoBufMsg< CMsgTFCoaching_CoachJoined > msg( k_EMsgGCCoaching_CoachJoined );
					msg.Body().set_account_id_coach( steamIDForPlayer.GetAccountID() );
					GCClientSystem()->BSendMessage( msg );
					break;
				}
			}
			// remove from the map now so the coach can join later as a normal player if they DC
			m_mapCoachToStudentMap.RemoveAt( idx );
		}
	}
	// warp coach to student?
	if ( pPlayer->GetCoach() )
	{
		// warp the coach to student
		pPlayer->GetCoach()->SetObserverTarget( pPlayer );
		pPlayer->GetCoach()->StartObserverMode( OBS_MODE_CHASE );
	}

	// notify training
	if ( m_hTrainingModeLogic )
	{
		m_hTrainingModeLogic->OnPlayerSpawned( pPlayer );
	}

#ifdef GAME_DLL
	if ( !IsInTraining() )
	{
		// Birthday beachball ball spawning.
		if ( IsBirthday() &&
			 !m_hasSpawnedToy &&
			 pPlayer->GetTeamNumber() == TF_TEAM_BLUE &&				// always give ball to first blue player, since they are often trapped during setup
			 RandomInt( 0, 100 ) < tf_birthday_ball_chance.GetInt() )
		{
			Vector vDropSpot;
			if ( CanFindBallSpawnLocation( pPlayer->WorldSpaceCenter(), &vDropSpot ) )
			{
				CPhysicsProp *ball = CreateBeachBall( vDropSpot, pPlayer->GetAbsAngles() );
				if ( ball )
				{
					m_hasSpawnedToy = true;

					// turn on the birthday skin
					ball->m_nSkin = 1;
				}
			}
		}

		// Soccer ball spawning if wearing soccer cleats.
		if ( !m_bHasSpawnedSoccerBall[ pPlayer->GetTeamNumber() ] )
		{
			enum
			{
				kSpawnWith_Nothing = 0,
				kSpawnWith_SoccerBall = 1,
			};

			int iSpawnWithPhysicsToy = kSpawnWith_Nothing;
			CALL_ATTRIB_HOOK_INT_ON_OTHER( pPlayer, iSpawnWithPhysicsToy, spawn_with_physics_toy );
			if ( iSpawnWithPhysicsToy == kSpawnWith_SoccerBall )
			{
				Vector vDropSpot;
				if ( CanFindBallSpawnLocation( pPlayer->WorldSpaceCenter(), &vDropSpot ) )
				{
					CPhysicsProp *ball = CreateSoccerBall( vDropSpot, pPlayer->GetAbsAngles() );
					if ( ball )
					{
						m_bHasSpawnedSoccerBall[ pPlayer->GetTeamNumber() ] = true;

						// turn on the birthday skin
						ball->m_nSkin = pPlayer->GetTeamNumber() == TF_TEAM_BLUE ? 1 : 0;
					}
				}
			}
		}
	}
#endif
}


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

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		GCSDK::CProtoBufMsg< CMsgTFCoaching_CoachJoining > msg( pNetPacket );
		if ( TFGameRules() )
		{
			TFGameRules()->OnCoachJoining( msg.Body().account_id_coach(), msg.Body().account_id_student() );
		}
		return true;
	}
};
GC_REG_JOB( GCSDK::CGCClient, CGCCoaching_CoachJoining, "CGCCoaching_CoachJoining", k_EMsgGCCoaching_CoachJoining, GCSDK::k_EServerTypeGCClient );

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

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		GCSDK::CProtoBufMsg< CMsgTFCoaching_RemoveCurrentCoach > msg( pNetPacket );
		if ( TFGameRules() )
		{
			TFGameRules()->OnRemoveCoach( msg.Body().account_id_coach() );
		}
		return true;
	}
};
GC_REG_JOB( GCSDK::CGCClient, CGCCoaching_RemoveCurrentCoach, "CGCCoaching_RemoveCurrentCoach", k_EMsgGCCoaching_RemoveCurrentCoach, GCSDK::k_EServerTypeGCClient );

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

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		GCSDK::CProtoBufMsg<CMsgGC_GameServer_UseServerModificationItem> msg( pNetPacket );

		// If this server doesn't have the capability to call a vote right now for whatever reason, we
		// give up and return immediate failure to the GC. If the vote gets called, we'll send up pass/fail
		// when it finishes.
		if ( !g_voteController || !g_voteController->CreateVote( DEDICATED_SERVER, "eternaween", "" ) )
		{
			GCSDK::CProtoBufMsg<CMsgGC_GameServer_UseServerModificationItem_Response> msgResponse( k_EMsgGC_GameServer_UseServerModificationItem_Response );
			msgResponse.Body().set_server_response_code( CMsgGC_GameServer_UseServerModificationItem_Response::kServerModificationItemServerResponse_NoVoteCalled );
			m_pGCClient->BSendMessage( msgResponse );
		}

		return true;
	}
};
GC_REG_JOB( GCSDK::CGCClient, CGCUseServerModificationItemJob, "CGCUseServerModificationItemJob", k_EMsgGC_GameServer_UseServerModificationItem, GCSDK::k_EServerTypeGCClient );

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

	virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
	{
		GCSDK::CProtoBufMsg<CMsgGC_GameServer_ServerModificationItem> msg( pNetPacket );

		switch ( msg.Body().modification_type() )
		{
		case kGameServerModificationItem_Halloween:
			tf_item_based_forced_holiday.SetValue( msg.Body().active() ? kHoliday_Halloween : kHoliday_None );
			g_fEternaweenAutodisableTime = engine->Time() + (SERVER_MODIFICATION_ITEM_DURATION_IN_MINUTES * 60.0f);
			if ( TFGameRules() )
			{
				TFGameRules()->FlushAllAttributeCaches();
			}
			break;
		default:
			Warning( "%s: unknown modification type %u for server item.\n", __FUNCTION__, msg.Body().modification_type() );
			break;
		}
		
		return true;
	}
};
GC_REG_JOB( GCSDK::CGCClient, CGCUpdateServerModificationItemStateJob, "CGCUpdateServerModificationItemStateJob", k_EMsgGC_GameServer_ModificationItemState, GCSDK::k_EServerTypeGCClient );

#ifdef _DEBUG
CON_COMMAND( coaching_stop, "Stop coaching" )
{
	CTFPlayer* pCoach = ToTFPlayer( UTIL_GetListenServerHost() );
	Coaching_Stop( pCoach );
}

CON_COMMAND( coaching_remove_coach, "Remove current coach" )
{
	CTFPlayer* pStudent = ToTFPlayer( UTIL_GetListenServerHost() );
	CTFPlayer *pCoach = pStudent->GetCoach();
	if ( pCoach )
	{
		Coaching_Stop( pCoach );
	}
}

CON_COMMAND( coaching_force_coach, "Force self as coach" )
{
	CTFPlayer* pCoachPlayer = ToTFPlayer( UTIL_GetListenServerHost() );
	if ( pCoachPlayer && TFGameRules() )
	{
		for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
		{
			CTFPlayer *pStudentPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
			if ( pStudentPlayer != pCoachPlayer )
			{
				Coaching_Start( pCoachPlayer, pStudentPlayer );
				break;
			}
		}
	}
}

CON_COMMAND( coaching_force_student, "Force self as student" )
{
	CTFPlayer* pStudentPlayer = ToTFPlayer( UTIL_GetListenServerHost() );
	if ( pStudentPlayer && TFGameRules() )
	{
		for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
		{
			CTFPlayer *pCoachPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
			if ( pCoachPlayer != pStudentPlayer )
			{
				Coaching_Start( pCoachPlayer, pStudentPlayer );
				break;
			}
		}
	}
}
#endif


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::OnCoachJoining( uint32 unCoachAccountID, uint32 unStudentAccountID )
{
	m_mapCoachToStudentMap.Insert( unCoachAccountID, unStudentAccountID );
	// see if the coach is on the server already
	CSteamID steamIDForCoach;
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CTFPlayer *pPotentialCoach = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( NULL == pPotentialCoach )
		{
			continue;
		}
		// coach is here, force them to respawn, which will set them up as a coach
		if ( pPotentialCoach->GetSteamID( &steamIDForCoach ) && steamIDForCoach.GetAccountID() == unCoachAccountID )
		{
			pPotentialCoach->ForceRespawn();
			return;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::OnRemoveCoach( uint32 unCoachAccountID )
{
	m_mapCoachToStudentMap.Remove( unCoachAccountID );
	for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		CSteamID steamID;
		if ( pPlayer && pPlayer->GetSteamID( &steamID ) && steamID.GetAccountID() == unCoachAccountID )
		{
			Coaching_Stop( pPlayer );
			return;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Activates 100% crits for an entire team for a short period of time
//-----------------------------------------------------------------------------
void CTFGameRules::HandleCTFCaptureBonus( int nTeam )
{
	float flBonusTime = GetCTFCaptureBonusTime();
	
	if ( flBonusTime <= 0 )
		return;

	for ( int i = 1 ; i <= gpGlobals->maxClients ; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( pPlayer && pPlayer->IsAlive() && pPlayer->GetTeamNumber() == nTeam )
		{
			pPlayer->m_Shared.AddCond( TF_COND_CRITBOOSTED_CTF_CAPTURE, flBonusTime );
		}
	}
}
#endif

int CTFGameRules::GetStatsMinimumPlayers( void )
{
	if ( IsInArenaMode() == true )
	{
		return 1;
	}

	return 3;
}

int CTFGameRules::GetStatsMinimumPlayedTime( void )
{
	if ( IsInArenaMode() == true )
	{
		return tf_arena_preround_time.GetFloat();
	}

	return 4 * 60; //Default of 4 minutes
}

bool CTFGameRules::IsConnectedUserInfoChangeAllowed( CBasePlayer *pPlayer )
{
	CTFPlayer* pTFPlayer = NULL;
#ifdef GAME_DLL
	pTFPlayer = ToTFPlayer( pPlayer );
#else
	pTFPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
#endif

	if( pTFPlayer )
	{
		// We can change if we're not alive
		if( pTFPlayer->m_lifeState != LIFE_ALIVE )
			return true;
		
		// We can change if we're not on team red or blue
		int iPlayerTeam = pTFPlayer->GetTeamNumber();
		if( ( iPlayerTeam != TF_TEAM_RED ) && ( iPlayerTeam != TF_TEAM_BLUE ) )
			return true;
		
		// We can change if we've respawned/changed classes within the last 2 seconds.
		// This allows for <classname>.cfg files to change these types of convars
		float flRespawnTime = 0.f;
#ifdef GAME_DLL
		flRespawnTime = pTFPlayer->GetSpawnTime();	// Called everytime the player respawns
#else
		flRespawnTime = pTFPlayer->GetClassChangeTime(); // Called when the player changes class and respawns
#endif
		if( ( gpGlobals->curtime - flRespawnTime ) < 2.f )
			return true;
	}

	return false;
}

//========================================================================================================================
// BONUS ROUND HANDLING
//========================================================================================================================
#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::ShouldGoToBonusRound( void )
{
	// Only do this on a Valve official server. Use the presence of our DLL as a key.
	return false;

	if ( IsInTournamentMode() )
		return false;

	// Don't do this on empty servers
	if ( !BHavePlayers() )
		return false;
	if ( TFTeamMgr()->GetTeam( TF_TEAM_RED )->GetNumPlayers() <= 0 )
		return false;
	if ( TFTeamMgr()->GetTeam( TF_TEAM_BLUE )->GetNumPlayers() <= 0 )
		return false;

	// Random chance per round, based on time.
	float flRoundTime = gpGlobals->curtime - m_flRoundStartTime;
	float flChance = RemapValClamped( flRoundTime, (3 * 60), (30 * 60), 0.0, 0.75 );	// 75% chance for > 30 min rounds, down to 0% at 3 min rounds
	float flRoll = RandomFloat( 0, 1 );
	return ( flRoll < flChance );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnBonusStart( void )
{
	m_hBonusLogic.Set( dynamic_cast<CBonusRoundLogic*>(CreateEntityByName( "tf_logic_bonusround" )) );
	if ( !m_hBonusLogic.Get()->InitBonusRound() )
	{
		State_Transition( GR_STATE_PREROUND );
		return;
	}

	// Bring up the giveaway panel on all the players
	for ( int i = 1; i <= MAX_PLAYERS; i++ )
	{
		CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
		if ( !pPlayer )
			continue;

		pPlayer->ShowViewPortPanel( PANEL_GIVEAWAY_ITEM );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetupOnBonusEnd( void )
{
	if ( m_hBonusLogic.Get() )
	{
		UTIL_Remove( m_hBonusLogic.Get() );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::BonusStateThink( void )
{
}

//-----------------------------------------------------------------------------
// Purpose: We need to abort the bonus state because our item generation failed.
//			Steam is probably down. 
//-----------------------------------------------------------------------------
void CTFGameRules::BonusStateAbort( void )
{
	if ( m_hBonusLogic.Get() )
	{
		m_hBonusLogic.Get()->SetBonusStateAborted( true );
	}

	State_Transition( GR_STATE_PREROUND );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::BetweenRounds_Start( void )
{
	SetSetup( true );

	if ( IsMannVsMachineMode() )
	{
		mp_tournament.SetValue( true );
		RestartTournament();
		SetInStopWatch( false );

		char szName[16];
		Q_strncpy( szName, "ROBOTS", MAX_TEAMNAME_STRING + 1 );
		mp_tournament_blueteamname.SetValue( szName );
		Q_strncpy( szName, "MANNCO", MAX_TEAMNAME_STRING + 1 );
		mp_tournament_redteamname.SetValue( szName );
		SetTeamReadyState( true, TF_TEAM_PVE_INVADERS );
	}

	for ( int i = 0; i < IBaseObjectAutoList::AutoList().Count(); ++i )
	{
		CBaseObject *pObj = static_cast<CBaseObject*>( IBaseObjectAutoList::AutoList()[i] );
		if ( pObj->IsDisposableBuilding() || pObj->GetTeamNumber() == TF_TEAM_PVE_INVADERS )
		{
			pObj->DetonateObject();
		}
	}

	if ( m_hGamerulesProxy )
	{
		m_hGamerulesProxy->StateEnterBetweenRounds();
	}

	if ( m_hCompetitiveLogicEntity )
	{
		m_hCompetitiveLogicEntity->OnSpawnRoomDoorsShouldUnlock();
	}

	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
	if ( pMatchDesc && pMatchDesc->m_params.m_bAutoReady )
	{
		for ( int i = 1; i <= MAX_PLAYERS; i++ )
		{
			CTFPlayer *pPlayer = static_cast<CTFPlayer*>( UTIL_PlayerByIndex( i ) );
			if ( !pPlayer )
				continue;

			if ( IsValidTFTeam( pPlayer->GetTeamNumber() ) && pPlayer->GetPlayerClass() && IsValidTFPlayerClass( pPlayer->GetPlayerClass()->GetClassIndex() ) )
			{
				PlayerReadyStatus_UpdatePlayerState( pPlayer, true );
			}
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::BetweenRounds_End( void )
{
	SetInWaitingForPlayers( false );
	SetSetup( false );

	if ( IsMannVsMachineMode() )
	{
		SetInStopWatch( false );
		mp_tournament_stopwatch.SetValue( false );
	}

	for ( int i = 1; i <= MAX_PLAYERS; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( !pPlayer )
			continue;

		// We don't consider inactivity during BetweenRounds as idle
		pPlayer->ResetIdleCheck();
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::BetweenRounds_Think( void )
{
	if ( UsePlayerReadyStatusMode() )
	{
		// Everyone is ready, or the drop-dead timer naturally ticked down to mp_tournament_readymode_countdown
		bool bStartFinalCountdown = ( PlayerReadyStatus_ShouldStartCountdown() || ( m_flRestartRoundTime > 0 && (int)( m_flRestartRoundTime - gpGlobals->curtime ) == mp_tournament_readymode_countdown.GetInt() ) );

		// It's the FINAL COUNTDOOOWWWNNnnnnnnnnn
		float flDropDeadTime = gpGlobals->curtime + mp_tournament_readymode_countdown.GetFloat() + 0.1f;
		if ( bStartFinalCountdown && ( m_flRestartRoundTime < 0 || m_flRestartRoundTime >= flDropDeadTime ) )
		{
			float flDelay = IsMannVsMachineMode() ? 10.f : mp_tournament_readymode_countdown.GetFloat();
			m_flRestartRoundTime.Set( gpGlobals->curtime + flDelay );
			ShouldResetScores( true, true );
			ShouldResetRoundsPlayed( true );

			if ( IsCompetitiveMode() )
			{
				m_flCompModeRespawnPlayersAtMatchStart = gpGlobals->curtime + 2.0;
			}
		}

		// Required for UI state
		if ( PlayerReadyStatus_HaveMinPlayersToEnable() )
		{
			CheckReadyRestart();
		}
	}
	
	CheckRespawnWaves();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::PreRound_Start( void )
{
	if ( m_hGamerulesProxy )
	{
		m_hGamerulesProxy->StateEnterPreRound();
	}

	if ( m_hCompetitiveLogicEntity )
	{
		m_hCompetitiveLogicEntity->OnSpawnRoomDoorsShouldLock();
	}

	BaseClass::PreRound_Start();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::PreRound_End( void )
{
	if ( IsHalloweenScenario( HALLOWEEN_SCENARIO_HIGHTOWER ) && !IsInWaitingForPlayers() )
	{
		if ( RandomFloat( 0, 1 ) < HELLTOWER_RARE_LINE_CHANCE )
		{
			PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_ROUNDSTART_RARE, HELLTOWER_VO_BLUE_ROUNDSTART_RARE );
		}
		else
		{
			PlayHelltowerAnnouncerVO( HELLTOWER_VO_RED_ROUNDSTART, HELLTOWER_VO_BLUE_ROUNDSTART );
		}
	}

	if ( m_hGamerulesProxy )
	{
		m_hGamerulesProxy->StateExitPreRound();
	}

	if ( m_hCompetitiveLogicEntity )
	{
		m_hCompetitiveLogicEntity->OnSpawnRoomDoorsShouldUnlock();
	}

	BaseClass::PreRound_End();
}

//-----------------------------------------------------------------------------
// Purpose: Compute internal vectors of health and ammo locations
//-----------------------------------------------------------------------------
void CTFGameRules::ComputeHealthAndAmmoVectors( void )
{
	m_ammoVector.RemoveAll();
	m_healthVector.RemoveAll();

	CBaseEntity *pEnt = gEntList.FirstEnt();
	while( pEnt )
	{
		if ( pEnt->ClassMatches( "func_regenerate" ) || pEnt->ClassMatches( "item_healthkit*" ) )
		{
			m_healthVector.AddToTail( pEnt );
		}

		if ( pEnt->ClassMatches( "func_regenerate" ) || pEnt->ClassMatches( "item_ammopack*" ) )
		{
			m_ammoVector.AddToTail( pEnt );
		}

		pEnt = gEntList.NextEnt( pEnt );
	}

	m_areHealthAndAmmoVectorsReady = true;
}


//-----------------------------------------------------------------------------
// Purpose: Return vector of health entities
//-----------------------------------------------------------------------------
const CUtlVector< CHandle< CBaseEntity > > &CTFGameRules::GetHealthEntityVector( void )
{
	// lazy-populate health and ammo vector since some maps (Dario!) move these entities around between stages
	if ( !m_areHealthAndAmmoVectorsReady )
	{
		ComputeHealthAndAmmoVectors();
	}

	return m_healthVector;
}


//-----------------------------------------------------------------------------
// Purpose: Return vector of ammo entities
//-----------------------------------------------------------------------------
const CUtlVector< CHandle< CBaseEntity > > &CTFGameRules::GetAmmoEntityVector( void )
{
	// lazy-populate health and ammo vector since some maps (Dario!) move these entities around between stages
	if ( !m_areHealthAndAmmoVectorsReady )
	{
		ComputeHealthAndAmmoVectors();
	}

	return m_ammoVector;
}


//-----------------------------------------------------------------------------
// Purpose: Return the Payload cart the given team needs to push to win, or NULL if none currently exists
//-----------------------------------------------------------------------------
CHandle< CTeamTrainWatcher > CTFGameRules::GetPayloadToPush( int pushingTeam ) const
{
	if ( TFGameRules()->GetGameType() != TF_GAMETYPE_ESCORT )
		return NULL;

	if ( pushingTeam == TF_TEAM_RED )
	{
		if ( m_redPayloadToPush == NULL )
		{
			// find our cart!
			if ( TFGameRules()->HasMultipleTrains() )
			{
				// find the red cart
			}
			else
			{
				// normal Escort scenario, red always blocks
				return NULL;
			}
		}

		return m_redPayloadToPush;
	}

	if ( pushingTeam == TF_TEAM_BLUE )
	{
		if ( m_bluePayloadToPush == NULL )
		{
			if ( TFGameRules()->HasMultipleTrains() )
			{
				// find the blue cart
			}
			else
			{
				// only one cart in the map, and we need to push it
				CTeamTrainWatcher *watcher = NULL;
				while( ( watcher = dynamic_cast< CTeamTrainWatcher * >( gEntList.FindEntityByClassname( watcher, "team_train_watcher" ) ) ) != NULL )
				{
					if ( !watcher->IsDisabled() )
					{
						m_bluePayloadToPush = watcher;
						break;
					}
				}
			}
		}

		return m_bluePayloadToPush;
	}

	return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Return the Payload cart the given player needs to block from advancing, or NULL if none currently exists
//-----------------------------------------------------------------------------
CHandle< CTeamTrainWatcher > CTFGameRules::GetPayloadToBlock( int blockingTeam ) const
{
	if ( TFGameRules()->GetGameType() != TF_GAMETYPE_ESCORT )
		return NULL;

	if ( blockingTeam == TF_TEAM_RED )
	{
		if ( m_redPayloadToBlock == NULL )
		{
			// find our cart!
			if ( TFGameRules()->HasMultipleTrains() )
			{
				// find the red cart
			}
			else
			{
				// normal Escort scenario, red always blocks
				CTeamTrainWatcher *watcher = NULL;
				while( ( watcher = dynamic_cast< CTeamTrainWatcher * >( gEntList.FindEntityByClassname( watcher, "team_train_watcher" ) ) ) != NULL )
				{
					if ( !watcher->IsDisabled() )
					{
						m_redPayloadToBlock = watcher;
						break;
					}
				}
			}
		}

		return m_redPayloadToBlock;
	}

	if ( blockingTeam == TF_TEAM_BLUE )
	{
		if ( m_bluePayloadToBlock == NULL )
		{
			if ( TFGameRules()->HasMultipleTrains() )
			{
				// find the blue cart
			}
			else
			{
				// normal Payload, blue never blocks
				return NULL;
			}
		}

		return m_bluePayloadToBlock;
	}

	return NULL;
}


#endif // GAME_DLL

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::BuildBonusPlayerList( void ) 
{ 
	if ( m_hBonusLogic.Get() )
	{
		m_hBonusLogic.Get()->BuildBonusPlayerList();
	}
}

//-----------------------------------------------------------------------------
// Purpose: Item testing bot controls
//-----------------------------------------------------------------------------
void CTFGameRules::ItemTesting_SetupFromKV( KeyValues *pKV )
{
	m_iItemTesting_BotAnim = pKV->GetInt( "bot_anim", TI_BOTANIM_IDLE );

	int iAnimSpeed = pKV->GetInt( "bot_animspeed", 100 );
	m_flItemTesting_BotAnimSpeed = ( (float)iAnimSpeed / 100.0f );

	m_bItemTesting_BotForceFire = pKV->GetBool( "bot_force_fire" );
	m_bItemTesting_BotTurntable = pKV->GetBool( "bot_turntable" );
	m_bItemTesting_BotViewScan = pKV->GetBool( "bot_view_scan" );
}

//==================================================================================================================
// BONUS ROUND LOGIC
#ifndef CLIENT_DLL
EXTERN_SEND_TABLE( DT_ScriptCreatedItem );
#else
EXTERN_RECV_TABLE( DT_ScriptCreatedItem );
#endif

BEGIN_NETWORK_TABLE_NOBASE( CBonusRoundLogic, DT_BonusRoundLogic )
#ifdef CLIENT_DLL
	RecvPropUtlVector( RECVINFO_UTLVECTOR( m_aBonusPlayerRoll ), MAX_PLAYERS, RecvPropInt( NULL, 0, 4 ) ),
	RecvPropEHandle( RECVINFO( m_hBonusWinner ) ),
	RecvPropDataTable(RECVINFO_DT(m_Item), 0, &REFERENCE_RECV_TABLE(DT_ScriptCreatedItem)),
#else
	SendPropUtlVector( SENDINFO_UTLVECTOR( m_aBonusPlayerRoll ), MAX_PLAYERS, SendPropInt( NULL, 0, 4, 12, SPROP_UNSIGNED ) ),
	SendPropEHandle( SENDINFO( m_hBonusWinner ) ),
	SendPropDataTable(SENDINFO_DT(m_Item), &REFERENCE_SEND_TABLE(DT_ScriptCreatedItem)),
#endif
END_NETWORK_TABLE()

LINK_ENTITY_TO_CLASS( tf_logic_bonusround, CBonusRoundLogic );
IMPLEMENT_NETWORKCLASS_ALIASED( BonusRoundLogic, DT_BonusRoundLogic )

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBonusRoundLogic::BuildBonusPlayerList( void )
{
	m_aBonusPlayerList.Purge();

	for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
		if ( !pPlayer )
			continue;

		m_aBonusPlayerList.InsertNoSort( pPlayer );
	}

	m_aBonusPlayerList.RedoSort( true );
}

#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CBonusRoundLogic::InitBonusRound( void )
{
	m_bAbortedBonusRound = false;
	SetBonusItem( 0 );
	m_hBonusWinner = NULL;

	BuildBonusPlayerList();

	// We actually precalculate the whole shebang.
	m_aBonusPlayerRoll.SetSize( m_aBonusPlayerList.Count() );
	for ( int i = 0; i < m_aBonusPlayerRoll.Count(); i++ )
	{
		m_aBonusPlayerRoll[i] = RandomInt( PLAYER_ROLL_MIN, PLAYER_ROLL_MAX );
	}

	// Sum up the bonus chances 
	int iTotal = 0;
	CUtlVector<int>	aBonusPlayerTotals;
	aBonusPlayerTotals.SetSize( m_aBonusPlayerList.Count() );
	for ( int i = 0; i < aBonusPlayerTotals.Count(); i++ )
	{
		aBonusPlayerTotals[i] = iTotal + m_aBonusPlayerRoll[i] + m_aBonusPlayerList[i]->m_Shared.GetItemFindBonus();
		iTotal = aBonusPlayerTotals[i];
	}

	// Roll for who gets the item.
	int iRoll = RandomInt( 0, iTotal );
	for ( int i = 0; i < aBonusPlayerTotals.Count(); i++ )
	{
		if ( iRoll < aBonusPlayerTotals[i] )
		{
			m_hBonusWinner = m_aBonusPlayerList[i];
			break;
		}
	}

	if ( !m_hBonusWinner.Get() )
		return false;

	// Generate the item on the server for now
	//CSteamID steamID;
	//if ( !m_hBonusWinner.Get()->GetSteamID( &steamID ) )
	const CSteamID *steamID = engine->GetGameServerSteamID();
	if ( !steamID || !steamID->IsValid() )
		return false;

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CBonusRoundLogic::SetBonusItem( itemid_t iItemID ) 
{
	m_iBonusItemID = iItemID;
	if ( !m_iBonusItemID )
	{
		m_Item.Invalidate();
		return;
	}

}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::SetBonusItem( itemid_t iItemID ) 
{ 
	if ( m_hBonusLogic.Get() )
	{
		m_hBonusLogic.Get()->SetBonusItem( iItemID );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::ProcessVerboseLogOutput( void )
{
	for ( int i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );

		if ( pPlayer && ( pPlayer->GetTeamNumber() > TEAM_UNASSIGNED ) )
		{
			UTIL_LogPrintf( "\"%s<%i><%s><%s>\" position_report (position \"%d %d %d\")\n",   
				pPlayer->GetPlayerName(),
				pPlayer->GetUserID(),
				pPlayer->GetNetworkIDString(),
				pPlayer->GetTeam()->GetName(),
				(int)pPlayer->GetAbsOrigin().x, 
				(int)pPlayer->GetAbsOrigin().y,
				(int)pPlayer->GetAbsOrigin().z );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::MatchSummaryTeleport()
{
	bool bUseMatchSummaryStage = false;
#ifdef STAGING_ONLY
	bUseMatchSummaryStage = tf_test_match_summary.GetBool();
#endif

	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( GetCurrentMatchGroup() );
	if ( pMatchDesc && pMatchDesc->m_params.m_bUseMatchSummaryStage )
	{
		bUseMatchSummaryStage = true;
	}

	if ( bUseMatchSummaryStage && m_bMapHasMatchSummaryStage )
	{
		RespawnPlayers( true );

		// find the observer target for the stage
		CObserverPoint *pObserverPoint = dynamic_cast<CObserverPoint*>( gEntList.FindEntityByClassname( NULL, "info_observer_point" ) );
		while( pObserverPoint )
		{
			if ( pObserverPoint->IsMatchSummary() )
			{
				pObserverPoint->SetDisabled( false );
				SetRequiredObserverTarget( pObserverPoint );
				break;
			}

			pObserverPoint = dynamic_cast<CObserverPoint*>( gEntList.FindEntityByClassname( pObserverPoint, "info_observer_point" ) );
		}

		// need to do this AFTER we respawn the players above or the conditions will be cleared
		for ( int i = 1; i <= MAX_PLAYERS; i++ )
		{
			CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
			if ( !pPlayer )
				continue;

			pPlayer->AddFlag( FL_FROZEN );

			if ( pPlayer->GetTeamNumber() >= FIRST_GAME_TEAM )  // spectators automatically get the RequiredObserverTarget that was set above
			{
				CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
				if ( pTFPlayer )
				{
					pTFPlayer->m_Shared.AddCond( ( pTFPlayer->GetTeamNumber() == GetWinningTeam() ) ? TF_COND_COMPETITIVE_WINNER : TF_COND_COMPETITIVE_LOSER );

					if ( pObserverPoint )
					{
						pTFPlayer->SetViewEntity( pObserverPoint );
						pTFPlayer->SetViewOffset( vec3_origin );
						pTFPlayer->SetFOV( pObserverPoint, pObserverPoint->m_flFOV );
					}

					// use this to force the client player anim to face the right direction
					pTFPlayer->SetTauntYaw( pTFPlayer->GetAbsAngles()[YAW] );
				}
			}
		}

		m_bPlayersAreOnMatchSummaryStage.Set( true );
	}
}

#ifdef STAGING_ONLY
//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::MatchSummaryTest( void )
{
	mp_waitingforplayers_cancel.SetValue( 1 );
	tf_test_match_summary.SetValue( 1 );
	g_fGameOver = true;
	TFGameRules()->State_Transition( GR_STATE_GAME_OVER );
	m_flStateTransitionTime = gpGlobals->curtime + 99999.f;
	TFGameRules()->MatchSummaryStart();
}

CON_COMMAND ( show_match_summary, "Show the match summary" )
{
	if ( !UTIL_IsCommandIssuedByServerAdmin() )
		return;

	if ( args.ArgC() < 2 )
		return;

	if ( FStrEq( args[1], "start" ) )
	{
		TFGameRules()->MatchSummaryTest();
	}
	else if ( FStrEq( args[1], "end" ) )
	{
		TFGameRules()->MatchSummaryEnd();
	}
}

#endif // STAGING_ONLY

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::MatchSummaryStart( void )
{
	if ( BAttemptMapVoteRollingMatch() )
	{
		// Grab the final list of maps for users to vote on
		UpdateNextMapVoteOptionsFromLobby();
		m_eRematchState = NEXT_MAP_VOTE_STATE_WAITING_FOR_USERS_TO_VOTE;
	}

	for ( int i = 1; i <= MAX_PLAYERS; i++ )
	{
		CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
		if ( pPlayer )
		{
			pPlayer->AddFlag( FL_FROZEN );
		}
	}

	m_bShowMatchSummary.Set( true );
	m_flMatchSummaryTeleportTime = gpGlobals->curtime + 2.f;

	if ( m_hGamerulesProxy )
	{
		m_hGamerulesProxy->MatchSummaryStart();
	}

	CBaseEntity *pLogicCase = NULL;
	while ( ( pLogicCase = gEntList.FindEntityByName( pLogicCase, "competitive_stage_logic_case" ) ) != NULL )
	{
		if ( pLogicCase )
		{
			variant_t sVariant;
			sVariant.SetInt( GetWinningTeam() );
			pLogicCase->AcceptInput( "InValue", NULL, NULL, sVariant, 0 );
			break;
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::MatchSummaryEnd( void )
{
	m_bShowMatchSummary.Set( false );
	m_bPlayersAreOnMatchSummaryStage.Set( false );

	SetRequiredObserverTarget( NULL );

	for ( int i = 1; i <= MAX_PLAYERS; i++ )
	{
		CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
		if ( !pPlayer )
			continue;

		pPlayer->RemoveFlag( FL_FROZEN );
		pPlayer->SetViewEntity( NULL );
		pPlayer->SetFOV( pPlayer, 0 );
	}

	// reset bot convars here
	static ConVarRef tf_bot_quota( "tf_bot_quota" );
	tf_bot_quota.SetValue( tf_bot_quota.GetDefault() );
	static ConVarRef tf_bot_quota_mode( "tf_bot_quota_mode" );
	tf_bot_quota_mode.SetValue( tf_bot_quota_mode.GetDefault() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CTFGameRules::GetTeamAssignmentOverride( CTFPlayer *pTFPlayer, int iDesiredTeam, bool bAutoBalance /*= false*/ )
{
	int iTeam = iDesiredTeam;

	// Look up GC managed match info
	CSteamID steamID;
	pTFPlayer->GetSteamID( &steamID );
	CMatchInfo *pMatch = GTFGCClientSystem()->GetLiveMatch();
	int nMatchPlayers = pMatch ? pMatch->GetNumActiveMatchPlayers() : 0;
	CMatchInfo::PlayerMatchData_t *pMatchPlayer = ( pMatch && steamID.IsValid() ) ? pMatch->GetMatchDataForPlayer( steamID ) : NULL;

	if ( IsMannVsMachineMode() )
	{
		if ( !pTFPlayer->IsBot() && iTeam != TEAM_SPECTATOR )
		{
			if ( pMatchPlayer && !pMatchPlayer->bDropped )
			{
				// Part of the lobby match
				Log( "MVM assigned %s to defending team (player is in lobby)\n", pTFPlayer->GetPlayerName() );
				return TF_TEAM_PVE_DEFENDERS;
			}

			// Count ad-hoc players on defenders team
			int nAdHocDefenders = 0;
			for ( int i = 1; i <= gpGlobals->maxClients; i++ )
			{
				CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );

				if ( !pPlayer || ( pPlayer->GetTeamNumber() != TF_TEAM_PVE_DEFENDERS ) )
					{ continue; }

				CSteamID steamID;
				if ( pPlayer->GetSteamID( &steamID ) && GTFGCClientSystem()->GetLiveMatchPlayer( steamID ) )
					{ continue; }

				// Player on defenders that doesn't have a live match entry
				nAdHocDefenders++;
			}

			// Bootcamp mode can mix a lobby with ad-hoc joins
			int nSlotsLeft = kMVM_DefendersTeamSize - nMatchPlayers - nAdHocDefenders;
			if ( nSlotsLeft >= 1 )
			{
				Log( "MVM assigned %s to defending team (%d more slots remaining after us)\n", pTFPlayer->GetPlayerName(), nSlotsLeft-1 );

				// Set Their Currency
				int nRoundCurrency = MannVsMachineStats_GetAcquiredCredits();
				nRoundCurrency += g_pPopulationManager->GetStartingCurrency();

				// deduct any cash that has already been spent
				int spentCurrency = g_pPopulationManager->GetPlayerCurrencySpent( pTFPlayer );
				pTFPlayer->SetCurrency( nRoundCurrency - spentCurrency );

				iTeam = TF_TEAM_PVE_DEFENDERS;
			}
			else
			{
				// no room
				Log( "MVM assigned %s to spectator, all slots for defending team are in use, or reserved for lobby members\n",
				     pTFPlayer->GetPlayerName() );
				iTeam = TEAM_SPECTATOR;
			}
		}
	}
	else if ( pMatch )
	{
		if ( !bAutoBalance )
		{
			CSteamID steamID;
			if ( pMatchPlayer )
			{
				iTeam = GetGameTeamForGCTeam( pMatchPlayer->eGCTeam );
				if ( iTeam < FIRST_GAME_TEAM )
				{
					// We should always have a team assigned by the GC
					Warning( "Competitive mode: Lobby player with invalid GC team %i in MatchGroup %i\n", iTeam, (int)pMatch->m_eMatchGroup );
				}
				CheckAndSetPartyLeader( pTFPlayer, iTeam );
			}
		}
	}

	return iTeam;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static CPhysicsProp *CreatePhysicsToy( const char* pszModelName, const Vector &vSpawnPos, const QAngle &qSpawnAngles )
{
	if ( pszModelName == NULL )
		return NULL;

	CPhysicsProp *pProp = NULL;

	MDLCACHE_CRITICAL_SECTION();

	MDLHandle_t h = mdlcache->FindMDL( pszModelName );
	if ( h != MDLHANDLE_INVALID )
	{
		// Must have vphysics to place as a physics prop
		studiohdr_t *pStudioHdr = mdlcache->GetStudioHdr( h );
		if ( pStudioHdr && mdlcache->GetVCollide( h ) )
		{
			bool bAllowPrecache = CBaseEntity::IsPrecacheAllowed();
			CBaseEntity::SetAllowPrecache( true );
			
			// Try to create entity
			pProp = dynamic_cast< CPhysicsProp * >( CreateEntityByName( "prop_physics_override" ) );
			if ( pProp )
			{
				pProp->SetCollisionGroup( COLLISION_GROUP_PUSHAWAY );
				// so it can be pushed by airblast
				pProp->AddFlag( FL_GRENADE );
				// so that it will always be interactable with the player
				//pProp->SetPhysicsMode( PHYSICS_MULTIPLAYER_SOLID );//PHYSICS_MULTIPLAYER_NON_SOLID );
				char buf[512];
				// Pass in standard key values
				Q_snprintf( buf, sizeof(buf), "%.10f %.10f %.10f", vSpawnPos.x, vSpawnPos.y, vSpawnPos.z );
				pProp->KeyValue( "origin", buf );
				Q_snprintf( buf, sizeof(buf), "%.10f %.10f %.10f", qSpawnAngles.x, qSpawnAngles.y, qSpawnAngles.z );
				pProp->KeyValue( "angles", buf );
				pProp->KeyValue( "model", pszModelName );
				pProp->KeyValue( "fademindist", "-1" );
				pProp->KeyValue( "fademaxdist", "0" );
				pProp->KeyValue( "fadescale", "1" );
				pProp->KeyValue( "inertiaScale", "1.0" );
				pProp->KeyValue( "physdamagescale", "0.1" );
				pProp->Precache();
				DispatchSpawn( pProp );
				pProp->m_takedamage = DAMAGE_YES;	// Take damage, otherwise this can block trains
				pProp->SetHealth( 5000 );
				pProp->Activate();
			}

			CBaseEntity::SetAllowPrecache( bAllowPrecache );
		}

		mdlcache->Release( h ); // counterbalance addref from within FindMDL
	}
	return pProp;
}

CPhysicsProp *CreateBeachBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles )
{
	return CreatePhysicsToy( "models/props_gameplay/ball001.mdl", vSpawnPos, qSpawnAngles );
}

CPhysicsProp *CreateSoccerBall( const Vector &vSpawnPos, const QAngle &qSpawnAngles )
{
	return CreatePhysicsToy( "models/player/items/scout/soccer_ball.mdl", vSpawnPos, qSpawnAngles );
}


void CTFGameRules::PushAllPlayersAway( const Vector& vFromThisPoint, float flRange, float flForce, int nTeam, CUtlVector< CTFPlayer* > *pPushedPlayers /*= NULL*/ )
{
	CUtlVector< CTFPlayer * > playerVector;
	CollectPlayers( &playerVector, nTeam, COLLECT_ONLY_LIVING_PLAYERS );

	for( int i=0; i<playerVector.Count(); ++i )
	{
		CTFPlayer *pPlayer = playerVector[i];

		Vector toPlayer = pPlayer->EyePosition() - vFromThisPoint;

		if ( toPlayer.LengthSqr() < flRange * flRange )
		{
			// send the player flying
			// make sure we push players up and away
			toPlayer.z = 0.0f;
			toPlayer.NormalizeInPlace();
			toPlayer.z = 1.0f;

			Vector vPush = flForce * toPlayer;

			pPlayer->ApplyAbsVelocityImpulse( vPush );

			if ( pPushedPlayers )
			{
				pPushedPlayers->AddToTail( pPlayer );
			}
		}
	}
}

#endif // GAME_DLL

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTFGameRules::CanUpgradeWithAttrib( CTFPlayer *pPlayer, int iWeaponSlot, attrib_definition_index_t iAttribIndex, CMannVsMachineUpgrades *pUpgrade )
{
	if ( !pPlayer )
		return false;

	Assert ( pUpgrade );

	// Upgrades on players are considered active at all times
	if ( pUpgrade->nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_PLAYER )
	{
		switch ( iAttribIndex )
		{
		case 113:	// "metal regen"
			{
				return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) );
			}
			break;
		}

		return true;
	}

	// Get the item entity. We use the entity, not the item in the loadout, because we want
	// the dynamic attributes that have already been purchases and attached.
	CEconEntity *pEntity;
	CEconItemView *pCurItemData = CTFPlayerSharedUtils::GetEconItemViewByLoadoutSlot( pPlayer, iWeaponSlot, &pEntity );
	if ( !pCurItemData || !pEntity )
		return false;

	// bottles can only hold things in the appropriate ui group
	if ( dynamic_cast< CTFPowerupBottle *>( pEntity ) )
	{
		if ( pUpgrade->nUIGroup == UIGROUP_POWERUPBOTTLE )
		{
			switch ( iAttribIndex )
			{
			case 327:	// "building instant upgrade"
				{
					return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) );
				}
#ifndef _DEBUG
			case 480:	// "radius stealth"
				{
					return ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) );
				}
#endif // !_DEBUG
		}
			return true;
		}

		return false;
	}
	else if ( pUpgrade->nUIGroup == UIGROUP_POWERUPBOTTLE )
	{
		return false;
	}

	CTFWeaponBase *pWeapon = dynamic_cast< CTFWeaponBase* > ( pEntity );
	CTFWeaponBaseGun *pWeaponGun = dynamic_cast< CTFWeaponBaseGun* > ( pEntity );
	int iWeaponID = ( pWeapon ) ? pWeapon->GetWeaponID() : TF_WEAPON_NONE;
	CTFWearableDemoShield *pShield = dynamic_cast< CTFWearableDemoShield* >( pEntity );
	bool bShield = ( pShield ) ? true : false;

	if ( iWeaponID == TF_WEAPON_PARACHUTE )
		return false;

	// Hack to simplify excluding non-weapons from damage upgrades
	bool bHideDmgUpgrades = iWeaponID == TF_WEAPON_NONE || 
							iWeaponID == TF_WEAPON_LASER_POINTER || 
							iWeaponID == TF_WEAPON_MEDIGUN || 
							iWeaponID == TF_WEAPON_BUFF_ITEM ||
							iWeaponID == TF_WEAPON_BUILDER ||
							iWeaponID == TF_WEAPON_PDA_ENGINEER_BUILD ||
							iWeaponID == TF_WEAPON_INVIS ||
							iWeaponID == TF_WEAPON_SPELLBOOK;

	// What tier upgrade is it?
	int nQuality = pUpgrade->nQuality;

	// This is crappy, but it's hopefully more maintainable than the allowed attributes block for all current & future items
	switch ( iAttribIndex )
	{
	case 2:		// "damage bonus"
		{
			if ( bHideDmgUpgrades )
				return false;

			// Some classes get a weaker dmg upgrade
			if ( nQuality == MVM_UPGRADE_QUALITY_LOW )
			{
				if ( pPlayer->IsPlayerClass( TF_CLASS_DEMOMAN ) && !bShield )
				{
					return ( iWeaponSlot == TF_WPN_TYPE_PRIMARY || iWeaponSlot == TF_WPN_TYPE_SECONDARY );
				}
				else
				{
					return false;
				}
			}

			bool bShieldEquipped = false;
			if ( pPlayer->IsPlayerClass( TF_CLASS_DEMOMAN ) )
			{
				for ( int i = 0; i < pPlayer->GetNumWearables(); ++i )
				{
					CTFWearableDemoShield *pWearableShield = dynamic_cast< CTFWearableDemoShield* >( pPlayer->GetWearable( i ) );
					if ( pWearableShield )
					{
						bShieldEquipped = true;
					}
				}
			}

			return ( ( iWeaponSlot == TF_WPN_TYPE_PRIMARY && 
					( pPlayer->IsPlayerClass( TF_CLASS_SCOUT ) || 
					pPlayer->IsPlayerClass( TF_CLASS_SNIPER ) || 
					pPlayer->IsPlayerClass( TF_CLASS_SOLDIER ) || 
					pPlayer->IsPlayerClass( TF_CLASS_PYRO ) ) ) || 
					( iWeaponID == TF_WEAPON_SWORD && bShieldEquipped ) );
		}
		break;
	case 6:		// "fire rate bonus"
		{
			// Heavy's version of firing speed costs more
			bool bMinigun = iWeaponID == TF_WEAPON_MINIGUN;
			if ( nQuality == MVM_UPGRADE_QUALITY_LOW )
			{
				return bMinigun;
			}
			else if ( iWeaponID == TF_WEAPON_GRENADELAUNCHER && pWeapon && pWeapon->AutoFiresFullClipAllAtOnce() )
			{
				return false;
			}

			// Non-melee version
			return ( dynamic_cast< CTFWeaponBaseMelee* >( pEntity ) == NULL && 
				iWeaponID != TF_WEAPON_NONE && !bHideDmgUpgrades && 
				iWeaponID != TF_WEAPON_FLAMETHROWER && 
				!WeaponID_IsSniperRifleOrBow( iWeaponID ) && 
				!( pWeapon && pWeapon->HasEffectBarRegeneration() ) &&
				!bMinigun );
		}
		break;
	// case 8:		// "heal rate bonus"
	case 10:	// "ubercharge rate bonus"
	case 314:	// "uber duration bonus"
	case 481:	// "canteen specialist"
	case 482:	// "overheal expert"
	case 483:	// "medic machinery beam"
	case 493:	// "healing mastery"
		{
			return ( iWeaponID == TF_WEAPON_MEDIGUN );
		}
		break;
	case 31:	// "critboost on kill"
		{
			CTFWeaponBaseMelee *pMelee = dynamic_cast<CTFWeaponBaseMelee *> ( pEntity );
			return ( pMelee && (
				pPlayer->IsPlayerClass( TF_CLASS_DEMOMAN ) || 
				pPlayer->IsPlayerClass( TF_CLASS_SPY ) ) );
		}
	case 71:	// weapon burn dmg increased
	case 73:	// weapon burn time increased
		{
			return ( iWeaponID == TF_WEAPON_FLAMETHROWER || iWeaponID == TF_WEAPON_FLAREGUN );
		}
		break;
	case 76:	// "maxammo primary increased"
		{
			return ( pWeapon && pWeapon->GetPrimaryAmmoType() == TF_AMMO_PRIMARY && !pWeapon->IsEnergyWeapon() );
		}
		break;
	case 78:	// "maxammo secondary increased"
		{
			return ( pWeapon && pWeapon->GetPrimaryAmmoType() == TF_AMMO_SECONDARY && !pWeapon->IsEnergyWeapon() );
		}
		break;
	case 90:	// "SRifle Charge rate increased"
		{
			return WeaponID_IsSniperRifle( iWeaponID );
		}
		break;
	case 103:	// "Projectile speed increased"
		{
			if ( pWeaponGun )
			{
				return ( pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_PIPEBOMB );
			}

			return false;
		}
		break;
	case 149:	// "bleed duration"
	case 523:	// "arrow mastery"
		{
			return ( iWeaponID == TF_WEAPON_COMPOUND_BOW );
		}
		break;
	case 218:	// "mark for death"
		{
			return ( iWeaponID == TF_WEAPON_BAT_WOOD );
		}
		break;
	case 249:	// "charge recharge rate increased"
	case 252:   // "damage force reduction"
		{
			return bShield;
		}
		break;
	case 255:	// "airblast pushback scale"
		{
			return ( iWeaponID == TF_WEAPON_FLAMETHROWER && 
				pWeaponGun && assert_cast< CTFFlameThrower* >( pWeaponGun )->SupportsAirBlastFunction( TF_FUNCTION_AIRBLAST_PUSHBACK) );
		}
		break;
	case 266:	// "projectile penetration"
		{
			if ( pWeaponGun && !bHideDmgUpgrades )
			{
				if ( !( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY ) )
				{
					int iProjectile = pWeaponGun->GetWeaponProjectileType();
					return ( iProjectile == TF_PROJECTILE_ARROW || iProjectile == TF_PROJECTILE_BULLET || iProjectile == TF_PROJECTILE_HEALING_BOLT || iProjectile == TF_PROJECTILE_FESTIVE_ARROW || iProjectile == TF_PROJECTILE_FESTIVE_HEALING_BOLT );
				}
			}

			return false;
		}
		break;
	case 80:	// "maxammo metal increased"
	case 276:	// "bidirectional teleport"
	case 286:	// "engy building health bonus"
	case 343:	// "engy sentry fire rate increased"
	case 345:	// "engy dispenser radius increased"
	case 351:	// "engy disposable sentries"
		{
			return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) && iWeaponID == TF_WEAPON_PDA_ENGINEER_BUILD );
		}
		break;
	case 278:	// "effect bar recharge rate increased"
		{
			return ( pWeapon && pWeapon->HasEffectBarRegeneration() && iWeaponID != TF_WEAPON_BUILDER && iWeaponID != TF_WEAPON_SPELLBOOK );
		}
		break;
	case 279:	// "maxammo grenades1 increased"
		{
			return ( iWeaponID == TF_WEAPON_BAT_WOOD || iWeaponID == TF_WEAPON_BAT_GIFTWRAP );
		}
		break;
	case 313:	// "applies snare effect"
		{
			return ( iWeaponID == TF_WEAPON_JAR || iWeaponID == TF_WEAPON_JAR_MILK );
		}
		break;
	case 318:	// "faster reload rate"
		{
			return ( ( pWeapon && pWeapon->ReloadsSingly() ) || 
				WeaponID_IsSniperRifleOrBow( iWeaponID ) || 
				iWeaponID == TF_WEAPON_FLAREGUN );
		}
		break;
	case 319:	// "increase buff duration"
		{
			return ( iWeaponID == TF_WEAPON_BUFF_ITEM );
		}
		break;
	case 320:	// "robo sapper"
#ifdef STAGING_ONLY
	case 601:	//	"ability spy traps"
	case 603:	//  "phase cloak"
#endif // STAGING_ONLY
		{
			return ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) && iWeaponID == TF_WEAPON_BUILDER );
		}
		break;
	case 323:	// "attack projectiles"
		{
			return ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
		}
		break;
	case 335:		// "clip size bonus upgrade"
		{
			return ( pWeapon && !pWeapon->IsBlastImpactWeapon() && pWeapon->UsesClipsForAmmo1() && pWeapon->GetMaxClip1() > 1 
					 && iWeaponID != TF_WEAPON_FLAREGUN_REVENGE && iWeaponID != TF_WEAPON_SPELLBOOK );
		}
		break;
	case 375:		// "generate rage on damage"
		{
			return ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
		}
		break;
	case 395:		// "explosive sniper shot"
		{
			return ( pPlayer->IsPlayerClass( TF_CLASS_SNIPER ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY && 
					 pWeaponGun && pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_BULLET );
		}
		break;
	case 396:		// "melee attack rate bonus"
		{
			// Melee version
			return ( dynamic_cast< CTFWeaponBaseMelee* >( pEntity ) != NULL && iWeaponID != TF_WEAPON_BUFF_ITEM && 
				!( pWeapon && pWeapon->HasEffectBarRegeneration() && iWeaponID != TF_WEAPON_BAT_WOOD ) );
		}
		break;
	case 397:	// "projectile penetration heavy"
		{
			if ( !bHideDmgUpgrades )
			{
				return ( pPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
			}
		}
		break;
	case 399:	// "armor piercing"
		{
			return ( pPlayer->IsPlayerClass( TF_CLASS_SPY ) && iWeaponID == TF_WEAPON_KNIFE );
		}
		break;
	case 440:	// "clip size upgrade atomic"
		{
			return pWeapon && pWeapon->IsBlastImpactWeapon();
		}
		break;
	case 484:	// "mad milk syringes"
		{
			return ( iWeaponID == TF_WEAPON_SYRINGEGUN_MEDIC );
		}
	case 488:	// "rocket specialist"
		if ( pWeaponGun )
		{
			return ( pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_ROCKET || pWeaponGun->GetWeaponProjectileType() == TF_PROJECTILE_ENERGY_BALL );
		}
	case 499:	// generate rage on heal (shield)
	case 554:	// revive
	case 555:	// medigun specialist
		{
			return ( iWeaponID == TF_WEAPON_MEDIGUN );
		}
#ifdef STAGING_ONLY
	case 553:	// rocket pack
	case 558:	// mod flamethrower napalm
		{
			return ( iWeaponID == TF_WEAPON_FLAMETHROWER );
		}
	case 604:	// sniper cloak
	case 605:	// master sniper
		{
			return ( pPlayer->IsPlayerClass( TF_CLASS_SNIPER ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
		}
	case 611:	// airborne infantry
		{
			return ( pPlayer->IsPlayerClass( TF_CLASS_SOLDIER ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
		}
	case 624:	// construction expert
	case 626:	// support engineer
		{
			return ( pPlayer->IsPlayerClass( TF_CLASS_ENGINEER ) && iWeaponSlot == TF_WPN_TYPE_MELEE );
		}
	case 631:	// ability doubletap teleport
		{
			return ( pPlayer->IsPlayerClass( TF_CLASS_SCOUT ) && iWeaponSlot == TF_WPN_TYPE_PRIMARY );
		}
#endif // STAGING_ONLY
	}

	// All weapon related attributes require an item that does damage
	if ( pUpgrade->nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_ITEM )
	{
		// All guns
		if ( pWeaponGun )
			return ( iWeaponID != TF_WEAPON_NONE && !bHideDmgUpgrades && 
			!( pWeapon && pWeapon->HasEffectBarRegeneration() ) );

		CTFWeaponBaseMelee *pMelee = dynamic_cast< CTFWeaponBaseMelee* >( pEntity );
		if ( pMelee )
		{
			// All melee weapons except buff banners
			return ( iWeaponID != TF_WEAPON_BUFF_ITEM && !bHideDmgUpgrades );
		}

		return false;
	}

	return false;
}

//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
int CTFGameRules::GetUpgradeTier( int iUpgrade )
{
	if ( !GameModeUsesUpgrades() || iUpgrade < 0 || iUpgrade >= g_MannVsMachineUpgrades.m_Upgrades.Count() )
		return 0;
	
	return g_MannVsMachineUpgrades.m_Upgrades[iUpgrade].nTier;
}

//-----------------------------------------------------------------------------
//  Given an upgrade and slot, see if its' tier is enabled/available
//-----------------------------------------------------------------------------
bool CTFGameRules::IsUpgradeTierEnabled( CTFPlayer *pTFPlayer, int iItemSlot, int iUpgrade )
{
	if ( !pTFPlayer )
		return false;

	// If the upgrade has a tier, it's mutually exclusive with upgrades of the same tier for the same slot
	int nTier = GetUpgradeTier( iUpgrade );
	if ( !nTier )
		return false;

	bool bIsAvailable = true;
	CEconItemView *pItem = NULL;
	float flValue = 0.f;

	// Go through the upgrades and see if it could apply, and if we already have it
	for ( int i = 0; i < g_MannVsMachineUpgrades.m_Upgrades.Count(); i++ )
	{
		CMannVsMachineUpgrades upgrade = g_MannVsMachineUpgrades.m_Upgrades[i];

		// Same upgrade
// 		if ( !V_strcmp( upgrade.szAttrib, g_MannVsMachineUpgrades.m_Upgrades[iUpgrade].szAttrib ) )
// 			continue;

		// Different tier
		if ( upgrade.nTier != nTier )
			continue;

		// Wrong type
		if ( upgrade.nUIGroup != g_MannVsMachineUpgrades.m_Upgrades[iUpgrade].nUIGroup )
			continue;

		CEconItemAttributeDefinition *pAttribDef = ItemSystem()->GetStaticDataForAttributeByName( upgrade.szAttrib );
		if ( !pAttribDef )
			continue;
			
		// Can't use
		if ( !CanUpgradeWithAttrib( pTFPlayer, iItemSlot, pAttribDef->GetDefinitionIndex(), &upgrade ) )
			continue;

		if ( upgrade.nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_ITEM )
		{
			pItem = CTFPlayerSharedUtils::GetEconItemViewByLoadoutSlot( pTFPlayer, iItemSlot );
			if ( pItem )
			{
				::FindAttribute_UnsafeBitwiseCast< attrib_value_t >( pItem->GetAttributeList(), pAttribDef, &flValue );
			}
		}
		else if ( upgrade.nUIGroup == UIGROUP_UPGRADE_ATTACHED_TO_PLAYER )
		{
			::FindAttribute_UnsafeBitwiseCast< attrib_value_t >( pTFPlayer->GetAttributeList(), pAttribDef, &flValue );
		}

		if ( flValue > 0.f )
		{
			bIsAvailable = false;
			break;
		}
	}
	
	return bIsAvailable;
}

#ifdef GAME_DLL
//-----------------------------------------------------------------------------
// Helper Functions
//-----------------------------------------------------------------------------
void CTFGameRules::SetNextMvMPopfile ( const char * next )
{
	s_strNextMvMPopFile = next;
}

//-----------------------------------------------------------------------------
const char * CTFGameRules::GetNextMvMPopfile ( )
{
	return s_strNextMvMPopFile.Get();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTFGameRules::BalanceTeams( bool bRequireSwitcheesToBeDead )
{
	// are we playing a managed match via matchmaking?
	if ( GetMatchGroupDescription( GetCurrentMatchGroup() ) )
		return;
		
	if ( mp_autoteambalance.GetInt() == 2 )
		return;

	BaseClass::BalanceTeams( bRequireSwitcheesToBeDead );
}
#endif