1HEADmaster

1 files changed, 1841 insertions, 0 deletions

diff --git a/game/shared/tf/tf_gamerules.h b/game/shared/tf/tf_gamerules.h
new file mode 100644
index 0000000..4a9678e
--- /dev/null
+++ b/game/shared/tf/tf_gamerules.h
@@ -0,0 +1,1841 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// The copyright to the contents herein is the property of Valve, L.L.C.
+// The contents may be used and/or copied only with the written permission of
+// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
+// the agreement/contract under which the contents have been supplied.
+//
+// Purpose: The TF Game rules object
+//
+// $Workfile:     $
+// $Date:         $
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef TF_GAMERULES_H
+#define TF_GAMERULES_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include "teamplayroundbased_gamerules.h"
+#include "convar.h"
+#include "gamevars_shared.h"
+#include "GameEventListener.h"
+#include "tf_gamestats_shared.h"
+#include "tf_match_description.h"
+
+#ifdef CLIENT_DLL
+#include "c_tf_player.h"
+#else
+#include "tf_player.h"
+#endif
+
+#ifdef CLIENT_DLL
+	
+	#define CTFGameRules C_TFGameRules
+	#define CTFGameRulesProxy C_TFGameRulesProxy
+	#define CBonusRoundLogic C_BonusRoundLogic
+#else
+	extern CUtlString s_strNextMvMPopFile;
+
+	extern BOOL no_cease_fire_text;
+	extern BOOL cease_fire;
+
+	class CHealthKit;
+	class CTrainingModeLogic;
+	class CTFHolidayEntity;
+	class CTFNavArea;
+	class CTFBot;
+	class CTFBotRoster;
+	class CMedievalLogic;
+	class CCPTimerLogic;
+	class CPopulationManager;
+	class CCompetitiveLogic;
+#endif
+
+class CBonusRoundLogic;
+class CTeamTrainWatcher;
+class CPhysicsProp;
+class CObjectSentrygun;
+class CGhost;
+class CUpgrades;
+
+extern ConVar	tf_spec_xray;
+extern ConVar	tf_avoidteammates;
+extern ConVar	tf_avoidteammates_pushaway;
+extern ConVar	mp_tournament_blueteamname;
+extern ConVar	mp_tournament_redteamname;
+extern ConVar	tf_arena_force_class;
+extern ConVar	tf_arena_change_limit;
+extern ConVar	tf_ctf_bonus_time;
+extern ConVar	tf_mvm_respec_enabled;
+extern ConVar	tf_spawn_glows_duration;
+#ifdef TF_RAID_MODE
+
+class CRaidLogic;
+class CBossBattleLogic;
+
+extern ConVar tf_gamemode_raid;
+extern ConVar tf_gamemode_creep_wave;
+extern ConVar tf_gamemode_boss_battle;
+
+#endif // TF_RAID_MODE
+
+class CMannVsMachineLogic;
+class CMannVsMachineUpgrades;
+
+//extern ConVar tf_populator_health_multiplier;
+//extern ConVar tf_populator_damage_multiplier;
+
+const int kMVM_DefendersTeamSize = 6;
+const int kLadder_TeamSize_6v6 = 6;
+const int kLadder_TeamSize_9v9 = 9;
+const int kLadder_TeamSize_12v12 = 12;
+
+//#define TF_MVM_FCVAR_CHEAT 0 /* Cheats enabled */
+#define TF_MVM_FCVAR_CHEAT FCVAR_CHEAT /* Cheats disabled */
+
+extern bool TF_IsHolidayActive( /*EHoliday*/ int eHoliday );
+
+//=============================================================================
+// HPE_BEGIN
+// [msmith] Used for the client to tell the server that we're whatching a movie or not
+//			and weather or not we're ready to transition to the next map.
+//=============================================================================
+// Training mode cvars
+extern ConVar	tf_training_client_message;
+enum {
+	TRAINING_CLIENT_MESSAGE_NONE = 0,
+	TRAINING_CLIENT_MESSAGE_WATCHING_INTRO_MOVIE,
+	TRAINING_CLIENT_MESSAGE_IN_SUMMARY_SCREEN,
+	TRAINING_CLIENT_MESSAGE_NEXT_MAP,
+	TRAINING_CLIENT_MESSAGE_REPLAY,
+	TRAINING_CLIENT_MESSAGE_MAX,
+};
+
+// How many achievements we show in the summary screen.
+#define MAX_SHOWN_ACHIEVEMENTS 6
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+extern Vector g_TFClassViewVectors[];
+
+#define NO_CLASS_LIMIT -1
+
+enum {
+	STOPWATCH_CAPTURE_TIME_NOT_SET = 0,
+	STOPWATCH_RUNNING,
+	STOPWATCH_OVERTIME,
+};
+
+class CTFGameRulesProxy : public CTeamplayRoundBasedRulesProxy, public CGameEventListener
+{
+public:
+	DECLARE_CLASS( CTFGameRulesProxy, CTeamplayRoundBasedRulesProxy );
+	DECLARE_NETWORKCLASS();
+
+#ifdef GAME_DLL
+	DECLARE_DATADESC();
+
+	CTFGameRulesProxy();
+
+	void	InputSetRedTeamRespawnWaveTime( inputdata_t &inputdata );
+	void	InputSetBlueTeamRespawnWaveTime( inputdata_t &inputdata );
+	void	InputAddRedTeamRespawnWaveTime( inputdata_t &inputdata );
+	void	InputAddBlueTeamRespawnWaveTime( inputdata_t &inputdata );
+	void	InputSetRedTeamGoalString( inputdata_t &inputdata );
+	void	InputSetBlueTeamGoalString( inputdata_t &inputdata );
+	void	InputSetRedTeamRole( inputdata_t &inputdata );
+	void	InputSetBlueTeamRole( inputdata_t &inputdata );
+	void	InputSetRequiredObserverTarget( inputdata_t &inputdata );
+	void	InputAddRedTeamScore( inputdata_t &inputdata );
+	void	InputAddBlueTeamScore( inputdata_t &inputdata );
+	void	InputSetRedKothClockActive( inputdata_t &inputdata );
+	void	InputSetBlueKothClockActive( inputdata_t &inputdata );
+	void	InputSetCTFCaptureBonusTime( inputdata_t &inputdata );
+	void	InputPlayVORed( inputdata_t &inputdata );
+	void	InputPlayVOBlue( inputdata_t &inputdata );
+	void	InputPlayVO( inputdata_t &inputdata );
+	void	InputHandleMapEvent( inputdata_t &inputdata );
+	void	InputSetCustomUpgradesFile( inputdata_t &inputdata );
+	void	InputSetRoundRespawnFreezeEnabled( inputdata_t &inputdata );
+	void	InputSetMapForcedTruceDuringBossFight( inputdata_t &inputdata );
+
+	void	TeamPlayerCountChanged( CTFTeam *pTeam );
+	void	PowerupTeamImbalance( int nTeam );
+	void	StateEnterRoundRunning( void );
+	void	StateEnterBetweenRounds( void );
+	void	StateEnterPreRound( void );
+	void	StateExitPreRound( void );
+	void	MatchSummaryStart( void );
+	void	TruceStart( void );
+	void	TruceEnd( void );
+
+	COutputEvent m_OnWonByTeam1;
+	COutputEvent m_OnWonByTeam2;
+	COutputInt m_Team1PlayersChanged;
+	COutputInt m_Team2PlayersChanged;
+	COutputEvent m_OnPowerupImbalanceTeam1;
+	COutputEvent m_OnPowerupImbalanceTeam2;
+	COutputEvent m_OnPowerupImbalanceMeasuresOver;
+	COutputEvent m_OnStateEnterRoundRunning;
+	COutputEvent m_OnStateEnterBetweenRounds;
+	COutputEvent m_OnStateEnterPreRound;
+	COutputEvent m_OnStateExitPreRound;
+	COutputEvent m_OnMatchSummaryStart;
+	COutputEvent m_OnTruceStart;
+	COutputEvent m_OnTruceEnd;
+
+	virtual void Activate();
+
+private:
+
+//=============================================================================
+// HPE_BEGIN:
+// [msmith]	hud type so the game type and hud type can be separate.  Used for
+//			training missions.
+//=============================================================================
+	int		m_nHudType;
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+
+	bool	m_bOvertimeAllowedForCTF;
+#endif
+
+public: // IGameEventListener Interface
+	virtual void FireGameEvent( IGameEvent * event );
+};
+
+class CTFRadiusDamageInfo
+{
+	DECLARE_CLASS_NOBASE( CTFRadiusDamageInfo );
+public:
+	CTFRadiusDamageInfo( CTakeDamageInfo *pInfo, const Vector &vecSrcIn, float flRadiusIn, CBaseEntity *pIgnore = NULL, float flRJRadiusIn = 0, float flForceScaleIn = 1.0f )
+	{
+		dmgInfo = pInfo;
+		vecSrc = vecSrcIn;
+		flRadius = flRadiusIn;
+		pEntityIgnore = pIgnore;
+		flRJRadius = flRJRadiusIn;
+		flFalloff = 0;
+		m_flForceScale = flForceScaleIn;
+		m_pEntityTarget = NULL;
+
+		CalculateFalloff();
+	}
+
+	void CalculateFalloff( void );
+	int ApplyToEntity( CBaseEntity *pEntity );
+
+public:
+	// Fill these in & call RadiusDamage()
+	CTakeDamageInfo	*dmgInfo;
+	Vector			vecSrc;
+	float			flRadius;
+	CBaseEntity		*pEntityIgnore;
+	float			flRJRadius;	// Radius to use to calculate RJ, to maintain RJs when damage/radius changes on a RL
+	float			m_flForceScale;
+	CBaseEntity		*m_pEntityTarget;		// Target being direct hit if any
+private:
+	// These are used during the application of the RadiusDamage 
+	float			flFalloff;
+};
+
+struct PlayerRoundScore_t
+{
+	int iPlayerIndex;	// player index
+	int iRoundScore;	// how many points scored this round
+	int	iTotalScore;	// total points scored across all rounds
+};
+
+struct PlayerArenaRoundScore_t
+{
+	int iPlayerIndex;	// player index
+	int	iTotalDamage;	// damage done this round
+	int iTotalHealing;	// healing done this round
+	int iTimeAlive;		// time alive (in seconds)
+	int iKillingBlows;	// killing blows this round
+	int iScore;
+};
+
+#ifdef CLIENT_DLL
+const char *GetMapType( const char *mapName );
+const char *GetMapDisplayName( const char *mapName );
+#else
+
+class CKothLogic;
+
+#endif
+
+// Used to sort the players in the list by their bonus score
+typedef CTFPlayer *BONUSPLAYERPTR;
+class CBonusPlayerListLess
+{
+public:
+	bool Less( const BONUSPLAYERPTR &src1, const BONUSPLAYERPTR &src2, void *pCtx )
+	{
+		if ( src1->m_Shared.GetItemFindBonus() > src2->m_Shared.GetItemFindBonus() )
+			return true;
+		return false;
+	}
+};
+
+#define MAX_TEAMGOAL_STRING		256
+#define MAX_TEAMNAME_STRING		6
+
+class CTFGameRules : public CTeamplayRoundBasedRules
+{
+public:
+	DECLARE_CLASS( CTFGameRules, CTeamplayRoundBasedRules );
+
+	CTFGameRules();
+
+	virtual void	LevelInitPostEntity( void );
+	virtual float	GetRespawnTimeScalar( int iTeam );
+	virtual float	GetRespawnWaveMaxLength( int iTeam, bool bScaleWithNumPlayers = true );
+
+	// Damage Queries.
+	virtual bool	Damage_IsTimeBased( int iDmgType );			// Damage types that are time-based.
+	virtual bool	Damage_ShowOnHUD( int iDmgType );				// Damage types that have client HUD art.
+	virtual bool	Damage_ShouldNotBleed( int iDmgType );			// Damage types that don't make the player bleed.
+	// TEMP:
+	virtual int		Damage_GetTimeBased( void );		
+	virtual int		Damage_GetShowOnHud( void );
+	virtual int		Damage_GetShouldNotBleed( void );
+
+	int				GetFarthestOwnedControlPoint( int iTeam, bool bWithSpawnpoints );
+	virtual bool	TeamMayCapturePoint( int iTeam, int iPointIndex );
+	virtual bool	PlayerMayCapturePoint( CBasePlayer *pPlayer, int iPointIndex, char *pszReason = NULL, int iMaxReasonLength = 0 );
+	virtual bool	PlayerMayBlockPoint( CBasePlayer *pPlayer, int iPointIndex, char *pszReason = NULL, int iMaxReasonLength = 0 );
+
+	static int		CalcPlayerScore( RoundStats_t *pRoundStats, CTFPlayer *pPlayer );
+	static int		CalcPlayerSupportScore( RoundStats_t *pRoundStats, int iPlayerIdx );
+
+	bool			IsBirthday( void ) const;
+	bool			IsBirthdayOrPyroVision( void ) const;
+	virtual bool	IsHolidayActive( /*EHoliday*/ int eHoliday ) const;
+
+	virtual const unsigned char *GetEncryptionKey( void ) { return GetTFEncryptionKey(); }
+
+	int				GetClassLimit( int iClass );
+	bool			CanPlayerChooseClass( CBasePlayer *pPlayer, int iClass );
+
+	virtual bool	ShouldBalanceTeams( void );
+
+	virtual int		GetBonusRoundTime( bool bGameOver = false ) OVERRIDE;
+
+#ifdef GAME_DLL
+public:
+	virtual void	Precache( void );
+
+	// Override this to prevent removal of game specific entities that need to persist
+	virtual bool	RoundCleanupShouldIgnore( CBaseEntity *pEnt );
+	virtual bool	ShouldCreateEntity( const char *pszClassName );
+	virtual void	CleanUpMap( void );
+
+	virtual void	FrameUpdatePostEntityThink();
+
+	virtual void	RespawnPlayers( bool bForceRespawn, bool bTeam = false, int iTeam = TEAM_UNASSIGNED ) OVERRIDE;
+
+	// Called when a new round is being initialized
+	virtual void	SetupOnRoundStart( void );
+
+	// Called when a new round is off and running
+	virtual void	SetupOnRoundRunning( void );
+
+	// Called before a new round is started (so the previous round can end)
+	virtual void	PreviousRoundEnd( void );
+
+	// Send the team scores down to the client
+	virtual void	SendTeamScoresEvent( void ) { return; }
+
+	// Send the end of round info displayed in the win panel
+	virtual void	SendWinPanelInfo( bool bGameOver ) OVERRIDE;
+	void			SendArenaWinPanelInfo( void );
+	void			SendPVEWinPanelInfo( void );
+
+	// Setup spawn points for the current round before it starts
+	virtual void	SetupSpawnPointsForRound( void );
+
+	// Called when a round has entered stalemate mode (timer has run out)
+	virtual void	SetupOnStalemateStart( void );
+	virtual void	SetupOnStalemateEnd( void );
+
+	virtual void	RecalculateControlPointState( void );
+
+	void			TeamPlayerCountChanged( CTFTeam *pTeam );
+	void			PowerupTeamImbalance( int nTeam );
+	int				GetAssignedHumanTeam( void );
+	virtual void	HandleSwitchTeams( void );
+	virtual void	HandleScrambleTeams( void );
+	bool			CanChangeClassInStalemate( void );
+	bool			CanChangeTeam( int iCurrentTeam ) const;
+
+	virtual void	SetRoundOverlayDetails( void );	
+	virtual void	ShowRoundInfoPanel( CTFPlayer *pPlayer = NULL ); // NULL pPlayer means show the panel to everyone
+
+	virtual bool	TimerMayExpire( void );
+
+	virtual void	Activate();
+
+	virtual bool	AllowDamage( CBaseEntity *pVictim, const CTakeDamageInfo &info );
+
+	void			SetTeamGoalString( int iTeam, const char *pszGoal );
+//=============================================================================
+// HPE_BEGIN:
+// [msmith]	Added a HUD type separate from the game mode so we can do different
+//			HUDs for the same mode.  This is used in training maps.
+//=============================================================================
+	void			SetHUDType( int nHudType );
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+	// Speaking, vcds, voice commands.
+	virtual void	InitCustomResponseRulesDicts();
+	virtual void	ShutdownCustomResponseRulesDicts();
+
+	virtual bool	HasPassedMinRespawnTime( CBasePlayer *pPlayer );
+	virtual bool	ShouldRespawnQuickly( CBasePlayer *pPlayer );
+
+	bool			ShouldScorePerRound( void );
+
+	virtual bool	IsValveMap( void );
+
+	virtual void	PlayTrainCaptureAlert( CTeamControlPoint *pPoint, bool bFinalPointInMap );
+
+	void			SetRequiredObserverTarget( CBaseEntity *pEnt ){ m_hRequiredObserverTarget = pEnt; }
+	void			SetObjectiveObserverTarget( CBaseEntity *pEnt ) { m_hObjectiveObserverTarget = pEnt; }
+	EHANDLE			GetRequiredObserverTarget( void ){ return m_hRequiredObserverTarget.Get(); }
+	EHANDLE			GetObjectiveObserverTarget( void ){ return m_hObjectiveObserverTarget.Get(); }
+
+	virtual void	GetTaggedConVarList( KeyValues *pCvarTagList );
+
+	virtual bool	PointsMayBeCaptured( void );
+	virtual bool	PointsMayAlwaysBeBlocked(){ return ( GetGameType() == TF_GAMETYPE_ESCORT ); }
+
+	virtual void	PlaySpecialCapSounds( int iCappingTeam, CTeamControlPoint *pPoint );
+
+	virtual CTacticalMissionManager *TacticalMissionManagerFactory( void );
+
+	virtual bool	ShouldSwitchTeams( void );
+	virtual bool	ShouldScrambleTeams( void );
+
+	virtual void	ClientCommandKeyValues( edict_t *pEntity, KeyValues *pKeyValues );
+
+	bool            CanBotChangeClass( CBasePlayer* pPlayer );
+	bool            CanBotChooseClass( CBasePlayer *pPlayer, int iClass );
+
+	void SetCTFCaptureBonusTime( float flTime ){ m_flCTFCaptureBonusTime = flTime; }
+	float GetCTFCaptureBonusTime( void )
+	{ 
+		float flRetVal = tf_ctf_bonus_time.GetFloat();
+		if ( m_flCTFCaptureBonusTime >= 0.0f )
+		{
+			flRetVal = m_flCTFCaptureBonusTime;
+		}
+
+		return flRetVal; 
+	}
+
+	// populate vector with set of control points the player needs to capture
+	virtual void CollectCapturePoints( CBasePlayer *player, CUtlVector< CTeamControlPoint * > *captureVector ) const;
+
+	// populate vector with set of control points the player needs to defend from capture
+	virtual void CollectDefendPoints( CBasePlayer *player, CUtlVector< CTeamControlPoint * > *defendVector ) const;
+
+	CObjectSentrygun *FindSentryGunWithMostKills( int team = TEAM_ANY ) const;
+
+	// Client connection/disconnection
+	virtual bool ClientConnected( edict_t *pEntity, const char *pszName, const char *pszAddress, char *reject, int maxrejectlen );
+
+	virtual bool ShouldSkipAutoScramble( void )
+	{ 
+		return IsPVEModeActive();
+	}
+
+	bool			ShouldMakeChristmasAmmoPack( void );
+
+	void			UpdatePeriodicEvent( CTFPlayer *pPlayer, eEconPeriodicScoreEvents eEvent, uint32 nCount );
+
+	void			HandleMapEvent( inputdata_t &inputdata );
+
+	void			SetCustomUpgradesFile( inputdata_t &inputdata );
+
+	virtual bool	ShouldWaitToStartRecording( void );
+
+	void			SetGravityMultiplier( float flValue ){ m_flGravityMultiplier.Set( flValue ); }
+
+	bool			CanFlagBeCaptured( CBaseEntity *pOther );
+	bool			PowerupModeFlagStandoffActive( void );
+
+	void			TeleportPlayersToTargetEntities( int iTeam, const char *pszEntTargetName, CUtlVector< CTFPlayer * > *pTeleportedPlayers );
+
+	virtual void LoadMapCycleFileIntoVector ( const char *pszMapCycleFile, CUtlVector<char *> &mapList ) OVERRIDE;
+
+	void			OnWorkshopMapUpdated( PublishedFileId_t nWorkshopID );
+
+	void			RecalculateTruce( void );
+
+	void			SetMapForcedTruceDuringBossFight( bool bState ){ m_bMapForcedTruceDuringBossFight = bState; }
+	bool			IsMapForcedTruceDuringBossFight( void ){ return m_bMapForcedTruceDuringBossFight; }
+
+protected:
+	virtual void LoadMapCycleFile( void ) OVERRIDE;
+	void TrackWorkshopMapsInMapCycle( void );
+
+	virtual const char* GetStalemateSong( int nTeam ) OVERRIDE;
+	virtual const char* WinSongName( int nTeam ) OVERRIDE;
+	virtual const char* LoseSongName( int nTeam ) OVERRIDE;
+
+	virtual void	InitTeams( void );
+
+	virtual void	RoundRespawn( void );
+	virtual void	RespawnTeam( int iTeam );
+
+	virtual void	InternalHandleTeamWin( int iWinningTeam );
+	
+	static int		PlayerRoundScoreSortFunc( const PlayerRoundScore_t *pRoundScore1, const PlayerRoundScore_t *pRoundScore2 );
+	static int		PlayerArenaRoundScoreSortFunc( const PlayerArenaRoundScore_t *pRoundScore1, const PlayerArenaRoundScore_t *pRoundScore2 );
+
+	virtual void FillOutTeamplayRoundWinEvent( IGameEvent *event );
+
+	virtual bool CanChangelevelBecauseOfTimeLimit( void );
+	virtual bool CanGoToStalemate( void );
+
+	virtual void RestoreActiveTimer( void );
+
+	void BroadcastDrawLine( CTFPlayer *pTFPlayer, KeyValues *pKeyValues );
+
+#endif // GAME_DLL
+
+public:
+	// Bonus round handling
+#ifdef GAME_DLL
+	virtual bool	ShouldGoToBonusRound( void );
+	virtual void	SetupOnBonusStart( void );
+	virtual void	SetupOnBonusEnd( void );
+	virtual void	BonusStateThink( void );
+	void			BonusStateAbort( void );
+	void			SetBonusItem( itemid_t iItemID );
+
+	// Between rounds handling
+	virtual void	BetweenRounds_Start( void );
+	virtual void	BetweenRounds_End( void );
+	virtual void	BetweenRounds_Think( void );
+	virtual void	PreRound_Start( void ) OVERRIDE;
+	virtual void	PreRound_End( void ) OVERRIDE;
+#endif
+
+public:
+	// Return the value of this player towards capturing a point
+	virtual int		GetCaptureValueForPlayer( CBasePlayer *pPlayer );
+
+	// Collision and Damage rules.
+	virtual bool	ShouldCollide( int collisionGroup0, int collisionGroup1 );
+	
+	int GetTimeLeft( void );
+
+	// Get the view vectors for this mod.
+	virtual const CViewVectors *GetViewVectors() const;
+
+	virtual void FireGameEvent( IGameEvent *event );
+
+	virtual const char *GetGameTypeName( void );
+	virtual int GetGameType( void ){ return m_nGameType; }
+
+	virtual void ClientSpawned( edict_t * pPlayer );
+
+	virtual void OnFileReceived( const char * fileName, unsigned int transferID );
+
+	virtual bool FlagsMayBeCapped( void );
+
+	void	RunPlayerConditionThink ( void );
+
+	const char *GetTeamGoalString( int iTeam );
+
+	int		GetStopWatchState( void ) { return m_nStopWatchState; }
+	
+	// Game Modes
+	virtual bool IsInArenaMode( void ) const OVERRIDE;
+	virtual bool IsInKothMode( void ) const OVERRIDE { return m_bPlayingKoth; }
+	bool IsInMedievalMode( void ) const { return m_bPlayingMedieval; }
+	bool IsHolidayMap( int nHoliday ) const { return m_nMapHolidayType == nHoliday; }
+	
+#ifdef TF_RAID_MODE
+	bool IsRaidMode( void ) const;
+	bool IsBossBattleMode( void ) const;
+#endif // TF_RAID_MODE
+
+#ifdef TF_CREEP_MODE
+bool IsCreepWaveMode( void ) const;
+#endif
+
+	bool IsMannVsMachineMode( void ) const { return m_bPlayingMannVsMachine; }
+
+	void SetMannVsMachineAlarmStatus( bool bStatus ){ m_bMannVsMachineAlarmStatus.Set( bStatus ); }
+	bool GetMannVsMachineAlarmStatus( void ){ return m_bMannVsMachineAlarmStatus; }
+	
+	bool IsQuickBuildTime( void );
+
+	bool GameModeUsesUpgrades( void );
+	bool GameModeUsesCurrency( void ) { return IsMannVsMachineMode() || IsBountyMode(); }
+	bool GameModeUsesMiniBosses( void ) { return IsMannVsMachineMode() || IsBountyMode(); }
+
+	bool IsPasstimeMode() const { return m_nGameType == TF_GAMETYPE_PASSTIME; }
+
+#ifdef STAGING_ONLY
+	bool GameModeUsesExperience( void ) { return IsBountyMode(); }
+#endif // STAGING_ONLY
+	bool IsMannVsMachineRespecEnabled( void ) { return IsMannVsMachineMode() && tf_mvm_respec_enabled.GetBool(); }
+	bool CanPlayerUseRespec( CTFPlayer *pTFPlayer );
+	bool IsPowerupMode( void ) { return m_bPowerupMode; }
+	void SetPowerupMode( bool bValue );
+
+#ifdef GAME_DLL
+	// Managed competitive matches should go through the End/StopCompetitiveMatch path
+	void EndManagedMvMMatch( bool bKickPlayersToParties );
+#endif
+
+	// Competitive games
+	bool IsCompetitiveMode( void ) const;			// means we're using competitive/casual matchmaking
+	bool IsMatchTypeCasual( void ) const;
+	bool IsMatchTypeCompetitive( void ) const;
+	// Are we showing the match-start-countdown doors right now
+	bool BInMatchStartCountdown() const;
+#ifdef GAME_DLL
+	void SyncMatchSettings();
+	// ! Check return
+	bool StartManagedMatch();
+	void SetCompetitiveMode( bool bValue );
+#endif
+	void StartCompetitiveMatch( void );
+	void StopCompetitiveMatch( CMsgGC_Match_Result_Status nCode );
+	void EndCompetitiveMatch( void );
+	void ManageCompetitiveMode( void );
+	bool ReportMatchResultsToGC( CMsgGC_Match_Result_Status nCode );
+	bool MatchmakingShouldUseStopwatchMode();
+
+	EMatchGroup GetCurrentMatchGroup() const;
+	bool IsManagedMatchEnded() const;
+
+	bool UsePlayerReadyStatusMode( void );
+	bool PlayerReadyStatus_HaveMinPlayersToEnable( void );
+#ifdef GAME_DLL
+	bool PlayerReadyStatus_ArePlayersOnTeamReady( int iTeam );
+	bool PlayerReadyStatus_ShouldStartCountdown( void );
+	void PlayerReadyStatus_ResetState( void );
+	void PlayerReadyStatus_UpdatePlayerState( CTFPlayer *pTFPlayer, bool bState );
+#endif // GAME_DLL
+
+	bool IsDefaultGameMode( void );		// The absence of arena, mvm, tournament mode, etc
+
+	// Upgrades
+	int	GetCostForUpgrade( CMannVsMachineUpgrades *pUpgrade, int iItemSlot, int nClass, CTFPlayer *pPurchaser = NULL );
+	bool CanUpgradeWithAttrib( CTFPlayer *pPlayer, int iWeaponSlot, attrib_definition_index_t iAttribIndex, CMannVsMachineUpgrades *pUpgrade );
+	int GetUpgradeTier( int iUpgrade );
+	bool IsUpgradeTierEnabled( CTFPlayer *pTFPlayer, int iItemSlot, int iUpgrade );
+	bool IsPVEModeActive( void ) const;						// return true if we are playing a PvE mode
+	bool IsPVEModeControlled( CBaseEntity *who ) const;		// return true for PvE opponents (ie: enemy bot team)
+	const char*		GetCustomUpgradesFile() { return m_pszCustomUpgradesFile.Get(); }
+
+//=============================================================================
+// HPE_BEGIN:
+// [msmith]	Training Status. And HUD type.
+//=============================================================================
+	bool IsInTraining( void ){ return m_bIsInTraining; }
+	bool AllowTrainingAchievements() { return m_bAllowTrainingAchievements; }
+	void SetAllowTrainingAchievements( bool bAllow) { m_bAllowTrainingAchievements = bAllow; }
+	bool IsWaitingForTrainingContinue() { return m_bIsWaitingForTrainingContinue; }
+	void SetIsWaitingForTrainingContinue( bool bWaiting ) { m_bIsWaitingForTrainingContinue = bWaiting; }
+	int GetHUDType( void ){ return m_nHudType; }
+//=============================================================================
+// HPE_END
+//=============================================================================
+	bool IsTrainingHUDVisible( void ) { return IsInTraining() && m_bIsTrainingHUDVisible; }
+	void SetTrainingHUDVisible( bool bVisible ) { m_bIsTrainingHUDVisible.Set( bVisible ); }
+
+	virtual bool	IsInItemTestingMode( void ) { return m_bIsInItemTestingMode; }
+	void			SetInItemTestingMode( bool bInTesting ) { m_bIsInItemTestingMode.Set( bInTesting ); }
+	int				ItemTesting_GetBotAnim( void ) { return m_iItemTesting_BotAnim; }
+	float			ItemTesting_GetBotAnimSpeed( void );
+	bool			ItemTesting_GetBotForceFire( void ) { return m_bItemTesting_BotForceFire; }
+	bool			ItemTesting_GetBotTurntable( void ) { return m_bItemTesting_BotTurntable; }
+	bool			ItemTesting_GetBotViewScan( void ) { return m_bItemTesting_BotViewScan; }
+	void			ItemTesting_SetupFromKV( KeyValues *pKV );
+	
+	bool IsPlayingHybrid_CTF_CP( void ) const { return m_bPlayingHybrid_CTF_CP; }
+	bool IsPlayingSpecialDeliveryMode( void ) const { return m_bPlayingSpecialDeliveryMode; }
+	bool IsPlayingRobotDestructionMode( void ) const { return m_bPlayingRobotDestructionMode; }
+
+	virtual bool AllowThirdPersonCamera( void ) { return ( IsInMedievalMode() || ShowMatchSummary() ); }
+
+	// Bonus rounds
+	CBonusRoundLogic *GetBonusLogic( void ) { return m_hBonusLogic.Get(); }
+	void		BuildBonusPlayerList( void );
+
+	CTeamRoundTimer *GetRedKothRoundTimer( void ) { return m_hRedKothTimer.Get(); }
+	CTeamRoundTimer *GetBlueKothRoundTimer( void ) { return m_hBlueKothTimer.Get(); }
+
+	int		GetStatsMinimumPlayers( void );
+	int		GetStatsMinimumPlayedTime( void );
+
+	// BountyMode
+#ifdef STAGING_ONLY
+	bool IsBountyMode( void ) { return m_bBountyModeEnabled && !IsMannVsMachineMode() && !IsInTraining(); }
+#else
+	bool IsBountyMode( void ) { return false; }
+#endif
+
+	float GetGravityMultiplier(  void ){ return m_flGravityMultiplier; }
+
+	virtual bool IsConnectedUserInfoChangeAllowed( CBasePlayer *pPlayer );
+
+	void SetPlayersInHell( bool bState ){ m_bHelltowerPlayersInHell.Set( bState ); } // used for Halloween 2013 state of the game (players in the underworld fighting)
+	bool ArePlayersInHell( void ) const { return m_bHelltowerPlayersInHell; }
+	void SpawnPlayerInHell( CTFPlayer *pPlayer, const char *pszSpawnPointName );
+	
+	// Halloween 2013 
+	void PlayHelltowerAnnouncerVO( int iRedLine, int iBlueLine );
+
+	void SetUsingSpells( bool bState )
+	{ 
+		m_bIsUsingSpells.Set( bState ); 
+	}
+
+	bool IsUsingSpells( void ) const;
+	bool IsUsingGrapplingHook( void ) const;
+
+	bool IsTruceActive( void ) const; 
+
+	bool MapHasMatchSummaryStage( void ){ return m_bMapHasMatchSummaryStage; }
+	bool PlayersAreOnMatchSummaryStage( void ){ return m_bPlayersAreOnMatchSummaryStage; }
+
+	bool ShowMatchSummary( void ){ return m_bShowMatchSummary; }
+
+	bool HaveStopWatchWinner( void ) { return m_bStopWatchWinner; }
+
+	int GetGameTeamForGCTeam( TF_GC_TEAM nGCTeam );
+	TF_GC_TEAM GetGCTeamForGameTeam( int nGameTeam );
+
+	enum ENextMapVotingState
+	{
+		NEXT_MAP_VOTE_STATE_NONE,
+		NEXT_MAP_VOTE_STATE_WAITING_FOR_USERS_TO_VOTE,
+		NEXT_MAP_VOTE_STATE_MAP_CHOSEN_PAUSE,
+	};
+
+	enum EUserNextMapVote
+	{
+		USER_NEXT_MAP_VOTE_MAP_0 = 0,
+		USER_NEXT_MAP_VOTE_MAP_1,
+		USER_NEXT_MAP_VOTE_MAP_2,
+		USER_NEXT_MAP_VOTE_UNDECIDED,
+
+		NUM_VOTE_STATES
+	};
+
+	EUserNextMapVote GetWinningVote( int (&nVotes)[ EUserNextMapVote::NUM_VOTE_STATES ] ) const;
+	EUserNextMapVote PlayerNextMapVoteState( int nIndex ) const { return m_ePlayerWantsRematch.Get( nIndex ); }
+	ENextMapVotingState GetCurrentNextMapVotingState() const { return m_eRematchState; }
+	MapDefIndex_t GetNextMapVoteOption( int nIndex ) const { return m_nNextMapVoteOptions.Get( nIndex ); }
+	
+#ifdef GAME_DLL
+	void UpdateNextMapVoteOptionsFromLobby();
+	void KickPlayersNewMatchIDRequestFailed();
+
+	void CheckAndSetPartyLeader( CTFPlayer *pTFPlayer, int iTeam );
+#endif // GAME_DLL
+
+#ifdef STAGING_ONLY
+#ifdef GAME_DLL
+	void SetBountyMode( bool bValue );
+#endif // GAME_DLL
+
+#endif // STAGING_ONLY
+
+#ifdef CLIENT_DLL
+
+	DECLARE_CLIENTCLASS_NOBASE(); // This makes data tables able to access our private vars.
+
+	virtual ~CTFGameRules();
+
+	virtual void	OnDataChanged( DataUpdateType_t updateType );
+	virtual void	HandleOvertimeBegin();
+
+	bool			ShouldShowTeamGoal( void );
+
+	const char *GetVideoFileForMap( bool bWithExtension = true );
+
+	const char *FormatVideoName( const char *videoName, bool bWithExtension = true );
+
+	void			SetUpVisionFilterKeyValues( void );
+
+	bool			UseSillyGibs( void );
+
+	virtual bool	AllowMapParticleEffect( const char *pszParticleEffect );
+
+	virtual bool	AllowWeatherParticles( void );
+
+	virtual bool AllowMapVisionFilterShaders( void );
+	virtual const char* TranslateEffectForVisionFilter( const char *pchEffectType, const char *pchEffectName );
+
+	virtual void	ModifySentChat( char *pBuf, int iBufSize );
+
+	virtual void	GetTeamGlowColor( int nTeam, float &r, float &g, float &b );
+
+	virtual bool ShouldConfirmOnDisconnect();
+
+	bool ShouldShowPreRoundDoors() const;
+	bool RecievedBaseline() const { return m_bRecievedBaseline; }
+
+#else
+
+	DECLARE_SERVERCLASS_NOBASE(); // This makes data tables able to access our private vars.
+	
+	virtual ~CTFGameRules();
+
+	virtual void LevelShutdown();
+	virtual bool ClientCommand( CBaseEntity *pEdict, const CCommand &args );
+	virtual void Think();
+
+	void PeriodicHalloweenUpdate();
+
+	virtual bool SwitchToNextBestWeapon( CBaseCombatCharacter *pPlayer, CBaseCombatWeapon *pCurrentWeapon );
+
+	bool CheckWinLimit( bool bAllowEnd = true, int nAddValueWhenChecking = 0 ) OVERRIDE;
+	bool SetCtfWinningTeam();
+	bool SetPasstimeWinningTeam();
+	bool CheckCapsPerRound();
+	virtual void CheckRespawnWaves();
+	virtual void PlayWinSong( int team ) OVERRIDE;
+
+//=============================================================================
+// HPE_BEGIN:
+// [msmith]	Used in training to load the next training map in sequence.
+//=============================================================================
+	void LoadNextTrainingMap();
+//=============================================================================
+// HPE_END
+//=============================================================================
+
+	virtual void SetWinningTeam( int team, int iWinReason, bool bForceMapReset = true, bool bSwitchTeams = false, bool bDontAddScore = false, bool bFinal = false ) OVERRIDE;
+	virtual void SetStalemate( int iReason, bool bForceMapReset = true, bool bSwitchTeams = false );
+
+	void CheckTauntAchievement( CTFPlayer *pAchiever, int nGibs, int *pTauntCamAchievements );
+
+	virtual bool FPlayerCanTakeDamage( CBasePlayer *pPlayer, CBaseEntity *pAttacker, const CTakeDamageInfo &info );
+
+	// Spawing rules.
+	CBaseEntity *GetPlayerSpawnSpot( CBasePlayer *pPlayer );
+	bool IsSpawnPointValid( CBaseEntity *pSpot, CBasePlayer *pPlayer, bool bIgnorePlayers, PlayerTeamSpawnMode_t nSpawndMode = PlayerTeamSpawnMode_Normal );
+
+	virtual int ItemShouldRespawn( CItem *pItem );
+	virtual float FlItemRespawnTime( CItem *pItem );
+	virtual Vector VecItemRespawnSpot( CItem *pItem );
+	virtual QAngle VecItemRespawnAngles( CItem *pItem );
+
+	virtual const char *GetChatFormat( bool bTeamOnly, CBasePlayer *pPlayer );
+	void ClientSettingsChanged( CBasePlayer *pPlayer );
+	void ChangePlayerName( CTFPlayer *pPlayer, const char *pszNewName );
+
+	virtual VoiceCommandMenuItem_t *VoiceCommand( CBaseMultiplayerPlayer *pPlayer, int iMenu, int iItem ); 
+
+	float GetPreMatchEndTime() const;	// Returns the time at which the prematch will be over.
+	void GoToIntermission( void );
+
+	virtual int GetAutoAimMode()	{ return AUTOAIM_NONE; }
+	void SetSetup( bool bSetup );
+	void ManageStopwatchTimer( bool bInSetup );
+	virtual void HandleTeamScoreModify( int iTeam, int iScore);
+
+	bool CanHaveAmmo( CBaseCombatCharacter *pPlayer, int iAmmoIndex );
+
+	virtual const char *GetGameDescription( void ){ return "Team Fortress"; }
+
+	virtual void Status( void (*print) (PRINTF_FORMAT_STRING const char *fmt, ...) );
+
+	// Sets up g_pPlayerResource.
+	virtual void CreateStandardEntities();
+
+	virtual void PlayerKilled( CBasePlayer *pVictim, const CTakeDamageInfo &info );
+	virtual void PlayerKilledCheckAchievements( CTFPlayer *pAttacker, CTFPlayer *pVictim );
+	virtual void DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info );
+	virtual void DeathNotice( CBasePlayer *pVictim, const CTakeDamageInfo &info, const char* eventName );
+	virtual CBasePlayer *GetDeathScorer( CBaseEntity *pKiller, CBaseEntity *pInflictor, CBaseEntity *pVictim );
+
+	void CalcDominationAndRevenge( CTFPlayer *pAttacker, CBaseEntity *pWeapon, CTFPlayer *pVictim, bool bIsAssist, int *piDeathFlags );
+
+	const char *GetKillingWeaponName( const CTakeDamageInfo &info, CTFPlayer *pVictim, int *iWeaponID );
+	CBasePlayer *GetAssister( CBasePlayer *pVictim, CBasePlayer *pScorer, CBaseEntity *pInflictor );
+	CTFPlayer *GetRecentDamager( CTFPlayer *pVictim, int iDamager, float flMaxElapsed );
+
+	virtual void ClientDisconnected( edict_t *pClient );
+
+	virtual void  RadiusDamage( const CTakeDamageInfo &info, const Vector &vecSrc, float flRadius, int iClassIgnore, CBaseEntity *pEntityIgnore );
+	void	RadiusDamage( CTFRadiusDamageInfo &info );
+
+	bool ApplyOnDamageModifyRules( CTakeDamageInfo &info, CBaseEntity *pVictimBaseEntity, bool bAllowDamage );
+
+	struct DamageModifyExtras_t
+	{
+		bool bIgniting;
+		bool bSelfBlastDmg;
+		bool bSendPreFeignDamage;
+		bool bPlayDamageReductionSound;
+	};
+	float ApplyOnDamageAliveModifyRules( const CTakeDamageInfo &info, CBaseEntity *pVictimBaseEntity, DamageModifyExtras_t& outParams );
+
+	virtual float FlPlayerFallDamage( CBasePlayer *pPlayer );
+
+	virtual bool  FlPlayerFallDeathDoesScreenFade( CBasePlayer *pl ) { return false; }
+
+	virtual bool UseSuicidePenalty() { return false; }
+
+	int		GetPreviousRoundWinners( void ) { return m_iPreviousRoundWinners; }
+
+	void	SendHudNotification( IRecipientFilter &filter, HudNotification_t iType, bool bForceShow = false  );
+	void	SendHudNotification( IRecipientFilter &filter, const char *pszText, const char *pszIcon, int iTeam = TEAM_UNASSIGNED );
+	void	StopWatchModeThink( void );
+
+	virtual		void RestartTournament( void );
+
+	bool	TFVoiceManager( CBasePlayer *pListener, CBasePlayer *pTalker );
+
+	void	OnNavMeshLoad( void );
+	void	OnDispenserBuilt( CBaseEntity *dispenser );
+	void	OnDispenserDestroyed( CBaseEntity *dispenser );
+	void	OnPlayerSpawned( CTFPlayer *pPlayer );
+	void	OnCoachJoining( uint32 unCoachAccountID, uint32 unStudentAccountID );
+	void 	OnRemoveCoach( uint32 unCoachAccountID );
+
+	//Arena
+	void		AddPlayerToQueue( CTFPlayer *pPlayer );
+	void		AddPlayerToQueueHead( CTFPlayer *pPlayer );
+	void		RemovePlayerFromQueue( CTFPlayer *pPlayer );
+	virtual bool BHavePlayers( void ) OVERRIDE;
+
+	void		Arena_RunTeamLogic( void );
+	void		Arena_ResetLosersScore( bool bResetAll );
+	void		Arena_PrepareNewPlayerQueue( bool bResetAll );
+	int			Arena_PlayersNeededForMatch( void );
+	void		Arena_CleanupPlayerQueue( void );
+	void		Arena_ClientDisconnect( const char *playername );
+	void		Arena_SendPlayerNotifications( void );
+	void		Arena_NotifyTeamSizeChange( void );
+	float		GetRoundStart( void ) { return m_flRoundStartTime; }
+
+	// Voting
+	void		ManageServerSideVoteCreation( void );
+
+#ifdef TF_RAID_MODE
+	// Raid game mode
+	CRaidLogic	*GetRaidLogic( void ) const		{ return m_hRaidLogic.Get(); }
+#endif // TF_RAID_MODE
+
+	// Currency awarding
+	int		CalculateCurrencyAmount_CustomPack( int nAmount );											// If we should drop a custom currency pack, and how much money to put in - 0 means don't drop
+	int		CalculateCurrencyAmount_ByType( CurrencyRewards_t nType );									// How much to give players for specific items and events, i.e. cash collection bonus, small packs
+	int		DistributeCurrencyAmount( int nAmount, CTFPlayer *pTFPlayer = NULL, bool bShared = true, bool bCountAsDropped = false, bool bIsBonus = false );	// Distributes nAmount to a specific player or team
+
+	virtual bool StopWatchShouldBeTimedWin( void ) OVERRIDE;
+
+public:
+	void SetPlayerNextMapVote( int nIndex, EUserNextMapVote eState ) { m_ePlayerWantsRematch.Set( nIndex, eState ); }
+
+	CTrainingModeLogic *GetTrainingModeLogic() { return m_hTrainingModeLogic; }
+	CTFHolidayEntity *GetHolidayLogic() const { return m_hHolidayLogic; }
+
+	void	HandleCTFCaptureBonus( int nTeam );
+	bool	TournamentModeCanEndWithTimelimit( void ){ return ( GetStopWatchTimer() == NULL ); }
+
+	CTeamRoundTimer *GetKothTeamTimer( int iTeam )
+	{
+		if ( IsInKothMode() == false )
+			return NULL;
+
+		if ( iTeam == TF_TEAM_RED )
+		{
+			return m_hRedKothTimer.Get();
+		}
+		else if ( iTeam == TF_TEAM_BLUE )
+		{
+			return m_hBlueKothTimer.Get();
+		}
+
+		return NULL;
+	}
+
+	void SetKothTeamTimer( int iTeam, CTeamRoundTimer *pTimer )
+	{
+		if ( iTeam == TF_TEAM_RED )
+		{
+			m_hRedKothTimer.Set( pTimer );
+		}
+		else if ( iTeam == TF_TEAM_BLUE )
+		{
+			m_hBlueKothTimer.Set( pTimer );
+		}
+	}
+
+	void SetOvertimeAllowedForCTF( bool bAllowed ){ m_bOvertimeAllowedForCTF = bAllowed; }
+	bool GetOvertimeAllowedForCTF( void ){ return m_bOvertimeAllowedForCTF; }
+
+	const CUtlVector< CHandle< CBaseEntity > > &GetHealthEntityVector( void );		// return vector of health entities 
+	const CUtlVector< CHandle< CBaseEntity > > &GetAmmoEntityVector( void );		// return vector of ammo entities 
+
+	CHandle< CTeamTrainWatcher > GetPayloadToPush( int pushingTeam ) const;			// return the train watcher for the Payload cart the given team needs to push to win, or NULL if none currently exists
+	CHandle< CTeamTrainWatcher > GetPayloadToBlock( int blockingTeam ) const;		// return the train watcher for the Payload cart the given team needs to block from advancing, or NULL if none currently exists
+
+	virtual void ProcessVerboseLogOutput( void );
+
+	void PushAllPlayersAway( const Vector& vFromThisPoint, float flRange, float flForce, int nTeam, CUtlVector< CTFPlayer* > *pPushedPlayers = NULL );
+
+	bool ShouldDropSpellPickup();
+	void DropSpellPickup( const Vector& vPosition, int nTier = 0 ) const;
+	
+	bool ShouldDropBonusDuck( void );
+	bool ShouldDropBonusDuckFromPlayer( CTFPlayer *pScorer, CTFPlayer *pVictim );
+	void DropBonusDuck( const Vector& vPosition, CTFPlayer *pScorer = NULL, CTFPlayer *pAssistor = NULL, CTFPlayer *pVictim = NULL, bool bCrit = false, bool bObjective = false ) const;
+
+	void DropHalloweenSoulPackToTeam( int nAmount, const Vector& vecPosition, int nTeamNumber, int nSourceTeam );
+	void DropHalloweenSoulPack( int nAmount, const Vector& vecSource, CBaseEntity *pTarget, int nSourceTeam );
+
+#ifdef STAGING_ONLY
+	void MatchSummaryTest( void );
+#endif // STAGING_ONLY
+	void MatchSummaryStart( void );
+	void MatchSummaryEnd( void );
+
+	int GetTeamAssignmentOverride( CTFPlayer *pTFPlayer, int iDesiredTeam, bool bAutoBalance = false );
+private:
+
+	void ChooseNextMapVoteOptions();
+
+	int DefaultFOV( void ) { return 75; }
+	int GetDuckSkinForClass( int nTeam, int nClass ) const;
+	void MatchSummaryTeleport();
+
+	void StopWatchShouldBeTimedWin_Calculate( void );
+	
+#endif // GAME_DLL
+
+private:
+
+	void ComputeHealthAndAmmoVectors( void );		// compute internal vectors of health and ammo locations
+	bool m_areHealthAndAmmoVectorsReady;
+
+
+#ifdef GAME_DLL
+
+	
+	void CheckHelltowerCartAchievement( int iTeam );
+
+	Vector2D	m_vecPlayerPositions[MAX_PLAYERS];
+
+	CUtlVector<CHandle<CHealthKit> > m_hDisabledHealthKits;	
+
+
+	char	m_szMostRecentCappers[MAX_PLAYERS+1];	// list of players who made most recent capture.  Stored as string so it can be passed in events.
+	int		m_iNumCaps[TF_TEAM_COUNT];				// # of captures ever by each team during a round
+
+	int SetCurrentRoundStateBitString();
+	void SetMiniRoundBitMask( int iMask );
+	int m_iPrevRoundState;	// bit string representing the state of the points at the start of the previous miniround
+	int m_iCurrentRoundState;
+	int m_iCurrentMiniRoundMask;
+
+	CHandle<CTeamRoundTimer>	m_hStopWatchTimer;
+	
+
+	CTeamRoundTimer* GetStopWatchTimer( void ) { return (CTeamRoundTimer*)m_hStopWatchTimer.Get(); }
+
+	EHANDLE m_hRequiredObserverTarget;
+	EHANDLE m_hObjectiveObserverTarget;
+
+	CHandle<CTFGameRulesProxy> m_hGamerulesProxy;
+
+	//Arena
+	bool IsFirstBloodAllowed( void );
+	EHANDLE m_hArenaEntity;
+	CUtlVector<CHandle<CTFPlayer> > m_hArenaPlayerQueue;	
+	int		m_iPreviousTeamSize;
+	bool	m_bArenaFirstBlood;
+
+	float	m_flSendNotificationTime;
+
+	// Tournament
+	CHandle< CCompetitiveLogic > m_hCompetitiveLogicEntity;
+	
+	CHandle<CTrainingModeLogic> m_hTrainingModeLogic;
+	CHandle<CTFHolidayEntity> m_hHolidayLogic;
+
+	bool	m_bOvertimeAllowedForCTF;
+
+	// for bot rosters
+	CHandle<CTFBotRoster> m_hBlueBotRoster;
+	CHandle<CTFBotRoster> m_hRedBotRoster;
+
+	// coaching
+	typedef CUtlMap<uint32, uint32> tCoachToStudentMap;
+	tCoachToStudentMap m_mapCoachToStudentMap;
+
+	// Automatic vote called near the end of a map
+	bool	m_bVoteCalled;
+	bool	m_bServerVoteOnReset;
+	float	m_flVoteCheckThrottle;
+
+	CUtlVector< CHandle< CCPTimerLogic > > m_CPTimerEnts;
+	float	m_flCapInProgressBuffer;
+
+	float	m_flMatchSummaryTeleportTime;
+
+#ifdef TF_RAID_MODE
+	CHandle< CRaidLogic >		m_hRaidLogic;
+	CHandle< CBossBattleLogic > m_hBossBattleLogic;
+#endif // TF_RAID_MODE
+	
+	int		m_nCurrencyAccumulator;
+	int		m_iCurrencyPool;
+
+	float	m_flCheckPlayersConnectingTime;
+
+	CountdownTimer m_helltowerTimer;		// used for Halloween 2013 Announcer VO in plr_hightower_event
+	CountdownTimer m_doomsdaySetupTimer;	// used for Halloween 2014 Announcer Setup VO in sd_doomsday_event
+	CountdownTimer m_doomsdayTicketsTimer;	// Used on sd_doomsday_event to nag players about picking up the tickets
+
+	float m_flNextStrangeEventProcessTime;
+
+	bool m_bMapForcedTruceDuringBossFight;
+	float m_flNextHalloweenGiftUpdateTime;
+#else
+
+	KeyValues *m_pkvVisionFilterTranslations;
+	KeyValues *m_pkvVisionFilterShadersMapWhitelist;
+
+	bool	m_bSillyGibs;
+
+#endif
+
+	CNetworkVar( ETFGameType, m_nGameType ); // Type of game this map is (CTF, CP)
+	CNetworkVar( int, m_nStopWatchState );
+	CNetworkString( m_pszTeamGoalStringRed, MAX_TEAMGOAL_STRING );
+	CNetworkString( m_pszTeamGoalStringBlue, MAX_TEAMGOAL_STRING );
+	CNetworkVar( float, m_flCapturePointEnableTime );
+	CNetworkVar( int, m_iGlobalAttributeCacheVersion );
+
+//=============================================================================
+// HPE_BEGIN:
+// [msmith]	Training and HUD status.
+//=============================================================================
+	CNetworkVar( int, m_nHudType ); // Used by map authors to override the default HUD clients are showing
+	CNetworkVar( bool, m_bIsInTraining );
+	CNetworkVar( bool, m_bAllowTrainingAchievements );
+	CNetworkVar( bool, m_bIsWaitingForTrainingContinue );
+//=============================================================================
+// HPE_END
+//=============================================================================
+	CNetworkVar( bool, m_bIsTrainingHUDVisible );
+
+	CNetworkVar( bool, m_bIsInItemTestingMode );
+	int		m_iItemTesting_BotAnim;
+	float	m_flItemTesting_BotAnimSpeed;
+	bool	m_bItemTesting_BotForceFire;
+	bool	m_bItemTesting_BotTurntable;
+	bool	m_bItemTesting_BotViewScan;
+
+	CNetworkVar( CHandle<CBonusRoundLogic>, m_hBonusLogic );
+
+	CNetworkVar( bool, m_bPlayingKoth );
+	CNetworkVar( bool, m_bPowerupMode );
+	CNetworkVar( bool, m_bPlayingRobotDestructionMode );
+	CNetworkVar( bool, m_bPlayingMedieval );
+	CNetworkVar( bool, m_bPlayingHybrid_CTF_CP );
+	CNetworkVar( bool, m_bPlayingSpecialDeliveryMode );
+
+	CNetworkVar( bool, m_bPlayingMannVsMachine );
+	CNetworkVar( bool, m_bMannVsMachineAlarmStatus );
+	CNetworkVar( bool, m_bHaveMinPlayersToEnableReady );
+
+	CNetworkVar( bool, m_bBountyModeEnabled );
+	CNetworkVar( bool, m_bCompetitiveMode );
+	CNetworkVar( float, m_flGravityMultiplier );
+	CNetworkVar( int, m_nMatchGroupType );
+	CNetworkVar( bool, m_bMatchEnded );
+
+	// This is used to check if players are in hell. The name doesn't make sense because we thought this would only be used for Halloween 2013
+	// cannot change the name because it's network var which will break demo
+	CNetworkVar( bool, 	m_bHelltowerPlayersInHell );
+
+	CNetworkVar( bool, m_bIsUsingSpells );
+
+	CNetworkVar( bool, m_bTruceActive );
+	CNetworkVar( bool, m_bTeamsSwitched );
+
+#ifdef GAME_DLL
+	float	m_flNextFlagAlarm;
+	float	m_flNextFlagAlert;
+
+	float	m_flSafeToLeaveTimer;
+
+	CBaseEntity *m_pUpgrades;
+#endif
+
+	CNetworkVar( CHandle<CTeamRoundTimer>, m_hRedKothTimer );
+	CNetworkVar( CHandle<CTeamRoundTimer>, m_hBlueKothTimer );
+
+	CNetworkVar( int, m_nMapHolidayType ); // Used by map authors to indicate this is a holiday map
+
+	CNetworkString( m_pszCustomUpgradesFile, MAX_PATH );
+
+	CNetworkVar( bool, m_bShowMatchSummary );
+	CNetworkVar( bool, m_bMapHasMatchSummaryStage );
+	CNetworkVar( bool, m_bPlayersAreOnMatchSummaryStage );
+	CNetworkVar( bool, m_bStopWatchWinner );
+	// This is called m_ePlayerWantsRematch because we initially had rematches, but now we
+	// let players vote on the next map instead.  Can't rename this variable, so we're just
+	// going to use with the wrong name
+	CNetworkArray( EUserNextMapVote, m_ePlayerWantsRematch, MAX_PLAYERS + 1 );
+	CNetworkVar( ENextMapVotingState, m_eRematchState );
+	CNetworkArray( MapDefIndex_t, m_nNextMapVoteOptions, 3 );
+
+	float		m_flCTFCaptureBonusTime;
+public:
+
+	bool m_bControlSpawnsPerTeam[ MAX_TEAMS ][ MAX_CONTROL_POINTS ];
+	int	 m_iPreviousRoundWinners;
+
+	float	GetCapturePointTime( void ) { return m_flCapturePointEnableTime; }
+
+	virtual bool ShouldDrawHeadLabels()
+	{ 
+		if ( IsInTournamentMode() )
+			return false;
+
+		return BaseClass::ShouldDrawHeadLabels();
+	}
+
+	enum HalloweenScenarioType
+	{
+		HALLOWEEN_SCENARIO_NONE = 0,
+		HALLOWEEN_SCENARIO_MANN_MANOR,
+		HALLOWEEN_SCENARIO_VIADUCT,
+		HALLOWEEN_SCENARIO_LAKESIDE,
+		HALLOWEEN_SCENARIO_HIGHTOWER,
+		HALLOWEEN_SCENARIO_DOOMSDAY,
+	};
+	HalloweenScenarioType GetHalloweenScenario( void ) const;
+	bool IsHalloweenScenario( HalloweenScenarioType scenario ) const;
+
+	bool CanInitiateDuels( void );
+
+#ifdef GAME_DLL
+
+	// Used on sd_doomsday_event to nag players about picking up the tickets
+	void StartDoomsdayTicketsTimer( void ) { m_doomsdayTicketsTimer.Start( RandomInt( 30, 60 ) ); }
+	void StopDoomsdayTicketsTimer( void ) { m_doomsdayTicketsTimer.Invalidate(); }
+	bool DoomsdayTicketTimerElapsed( void ) const { return m_doomsdayTicketsTimer.HasStarted() && m_doomsdayTicketsTimer.IsElapsed(); }
+
+	int GetBossCount() const { return m_activeBosses.Count(); }
+
+	CBaseCombatCharacter *GetActiveBoss( int iBoss = 0 )
+	{
+		if ( iBoss < 0 || iBoss >= m_activeBosses.Count() )
+			return NULL;
+
+		return m_activeBosses[iBoss];
+	}
+
+	void AddActiveBoss( CBaseCombatCharacter *boss )
+	{
+		// don't add the same boss
+		if ( m_activeBosses.Find( boss ) != m_activeBosses.InvalidIndex() )
+			return;
+
+		m_activeBosses.AddToTail( boss );
+	}
+
+	void RemoveActiveBoss( CBaseCombatCharacter *boss )
+	{
+		m_activeBosses.FindAndRemove( boss );
+	}
+
+	CBaseEntity *GetIT( void ) const			// who is the boss chasing
+	{
+		return m_itHandle;
+	}
+
+	void SetIT( CBaseEntity *who );
+	void SetBirthdayPlayer( CBaseEntity *pEntity );
+
+	void SetHalloweenEffectStatus( int effect, float duration )		// Update the current Halloween effect on the HUD
+	{
+		m_nHalloweenEffect = effect;
+		m_fHalloweenEffectStartTime = gpGlobals->curtime;
+		m_fHalloweenEffectDuration = duration;
+	}
+
+
+	// remove all projectiles in the world
+	void RemoveAllProjectiles();
+
+	// remove all buildings in the world
+	void RemoveAllBuildings( bool bExplodeBuildings = false );
+
+	// remove all sentry's ammo
+	void RemoveAllSentriesAmmo();
+
+	// remove all projectiles and objects
+	void RemoveAllProjectilesAndBuildings( bool bExplodeBuildings = false );
+
+#endif // GAME_DLL
+
+	void ClearHalloweenEffectStatus( void )							// Clear the current Halloween effect and hide the HUD display
+	{
+		m_nHalloweenEffect = -1;
+		m_fHalloweenEffectStartTime = -1.0f;
+		m_fHalloweenEffectDuration = -1.0f;
+	}
+
+	bool IsIT( CBaseEntity *who ) const
+	{
+		return ( who && who == m_itHandle.Get() );
+	}
+
+	CBaseEntity *GetBirthdayPlayer( void ) const
+	{
+		return m_hBirthdayPlayer.Get();
+	}
+
+	bool IsHalloweenEffectStatusActive( void ) const
+	{
+		return m_nHalloweenEffect >= 0;
+	}
+
+	int GetHalloweenEffectStatus( void ) const
+	{
+		return m_nHalloweenEffect;
+	}
+
+	float GetHalloweenEffectTimeLeft( void ) const
+	{
+		float expireTime = m_fHalloweenEffectStartTime + m_fHalloweenEffectDuration;
+
+		return expireTime - gpGlobals->curtime;
+	}
+
+	float GetHalloweenEffectDuration( void ) const
+	{
+		return m_fHalloweenEffectDuration;
+	}
+
+	int GetGlobalAttributeCacheVersion( void ) const
+	{
+		return m_iGlobalAttributeCacheVersion;
+	}
+
+	void FlushAllAttributeCaches( void )
+	{
+		m_iGlobalAttributeCacheVersion++;
+	}
+
+private:	
+#ifdef CLIENT_DLL
+	bool m_bRecievedBaseline;
+#endif
+
+
+	CountdownTimer m_botCountTimer;
+
+	CUtlVector< CHandle< CBaseEntity > > m_ammoVector;			// vector of active ammo entities
+	bool m_isAmmoVectorReady;									// for lazy evaluation
+
+	CUtlVector< CHandle< CBaseEntity > > m_healthVector;		// vector of active health entities
+	bool m_isHealthVectorReady;									// for lazy evaluation
+
+	bool m_bUseMatchHUD;
+	bool m_bUsePreRoundDoors;
+#ifdef GAME_DLL
+	mutable CHandle< CTeamTrainWatcher > m_redPayloadToPush;
+	mutable CHandle< CTeamTrainWatcher > m_bluePayloadToPush;
+	mutable CHandle< CTeamTrainWatcher > m_redPayloadToBlock;
+	mutable CHandle< CTeamTrainWatcher > m_bluePayloadToBlock;
+
+	bool m_hasSpawnedToy;
+	void SpawnHalloweenBoss( void );
+	CountdownTimer m_halloweenBossTimer;
+	CUtlVector< CHandle< CBaseCombatCharacter > > m_activeBosses;
+	bool m_bHasSpawnedSoccerBall[TF_TEAM_COUNT];
+
+	CountdownTimer m_ghostTimer;
+
+	void SpawnZombieMob( void );
+	CountdownTimer m_zombieMobTimer;
+	int m_zombiesLeftToSpawn;
+	Vector m_zombieSpawnSpot;
+
+public:
+	void BeginHaunting( int nDesiredCount, float flMinDuration, float flMaxDuration );
+
+	void StartHalloweenBossTimer( float flTime, float flVariation = 0.f )
+	{
+		m_halloweenBossTimer.Start( RandomFloat( flTime - flVariation, flTime + flVariation ) );
+	}
+
+	// Recent player stuff
+	void PlayerHistory_AddPlayer( CTFPlayer *pTFPlayer );
+	PlayerHistoryInfo_t *PlayerHistory_GetPlayerInfo( CTFPlayer *pTFPlayer );
+	int PlayerHistory_GetTimeSinceLastSeen( CTFPlayer *pTFPlayer );
+
+	CUtlVector< Vector > *GetHalloweenSpawnLocations() { return &m_halloweenGiftSpawnLocations; }
+
+	bool BAttemptMapVoteRollingMatch();
+
+	bool BIsManagedMatchEndImminent( void );
+
+private:
+	CUtlVector< CHandle< CGhost > > m_ghostVector;
+	CUtlVector< PlayerHistoryInfo_t > m_vecPlayerHistory;
+
+	struct TeleportLocation_t
+	{
+		Vector m_vecPosition;
+		QAngle m_qAngles;
+	};
+	CUtlMap< string_t, CUtlVector< TeleportLocation_t >* > m_mapTeleportLocations;
+
+	// Keep track of kills made with powerups
+	int		m_nPowerupKillsRedTeam;
+	int		m_nPowerupKillsBlueTeam;
+	float	m_flTimeToRunImbalanceMeasures;
+	float	m_flTimeToStopImbalanceMeasures;
+	bool	m_bPowerupImbalanceMeasuresRunning;
+
+	bool	m_bMapCycleNeedsUpdate;
+
+	CUtlVector< Vector > m_halloweenGiftSpawnLocations;		// vector of valid gift spawn locations from the map
+	float	m_flCompModeRespawnPlayersAtMatchStart;
+
+#endif // GAME_DLL
+
+	// LEGACY BOSS CODE. Keeping this to not break demo
+	CNetworkVar( int, m_nBossHealth );
+	CNetworkVar( int, m_nMaxBossHealth );
+	CNetworkVar( float, m_fBossNormalizedTravelDistance );
+
+	CNetworkHandle( CBaseEntity, m_itHandle );	// entindex of current IT entity (0 = no it)
+	CNetworkHandle( CBaseEntity, m_hBirthdayPlayer );	// entindex of current birthday player (0 = none)
+
+	CNetworkVar( int, m_nHalloweenEffect );
+	CNetworkVar( float, m_fHalloweenEffectStartTime );
+	CNetworkVar( float, m_fHalloweenEffectDuration );
+	CNetworkVar( HalloweenScenarioType, m_halloweenScenario );
+
+// MvM Helpers
+#ifdef GAME_DLL
+public:
+	void SetNextMvMPopfile ( const char * next );
+	const char * GetNextMvMPopfile ();
+
+	virtual void BalanceTeams( bool bRequireSwitcheesToBeDead );
+#endif
+};
+
+//-----------------------------------------------------------------------------
+// Gets us at the team fortress game rules
+//-----------------------------------------------------------------------------
+
+inline CTFGameRules* TFGameRules()
+{
+	return static_cast<CTFGameRules*>(g_pGameRules);
+}
+
+inline float CTFGameRules::ItemTesting_GetBotAnimSpeed( void ) 
+{ 
+	static const ConVar *pHostTimescale = NULL;
+
+	if ( !pHostTimescale )
+	{
+		pHostTimescale = cvar->FindVar( "host_timescale" );
+	}
+
+	if ( pHostTimescale )
+		return (m_flItemTesting_BotAnimSpeed * pHostTimescale->GetFloat());
+	return m_flItemTesting_BotAnimSpeed;
+}
+
+#ifdef TF_RAID_MODE
+
+inline bool CTFGameRules::IsRaidMode( void ) const
+{
+#ifdef GAME_DLL
+	return m_hRaidLogic != NULL; 
+#else
+	return tf_gamemode_raid.GetBool();
+#endif
+}
+
+
+
+inline bool CTFGameRules::IsBossBattleMode( void ) const
+{
+	return tf_gamemode_boss_battle.GetBool();
+}
+
+#endif // TF_RAID_MODE
+
+#ifdef TF_CREEP_MODE
+
+inline bool CTFGameRules::IsCreepWaveMode( void ) const
+{
+	return tf_gamemode_creep_wave.GetBool();
+}
+
+#endif
+
+
+inline bool CTFGameRules::IsHalloweenScenario( HalloweenScenarioType scenario ) const
+{
+	return m_halloweenScenario == scenario;
+}
+
+
+#ifdef GAME_DLL
+bool EntityPlacementTest( CBaseEntity *pMainEnt, const Vector &vOrigin, Vector &outPos, bool bDropToGround );
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CArenaLogic : public CPointEntity
+{
+	DECLARE_CLASS( CArenaLogic, CPointEntity );
+public:
+	DECLARE_DATADESC();
+
+	virtual int UpdateTransmitState()
+	{
+		return SetTransmitState( FL_EDICT_ALWAYS );
+	}
+
+	virtual void ArenaLogicThink( void );
+	virtual void Spawn( void );
+
+	COutputEvent	m_OnArenaRoundStart;
+	float			m_flTimeToEnableCapPoint;
+	COutputEvent	m_OnCapEnabled;
+	bool			m_bFiredOutput;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CCompetitiveLogic : public CPointEntity
+{
+	DECLARE_CLASS( CCompetitiveLogic, CPointEntity );
+public:
+	DECLARE_DATADESC();
+
+	void OnSpawnRoomDoorsShouldLock( void );
+	void OnSpawnRoomDoorsShouldUnlock( void );
+
+	COutputEvent	m_OnSpawnRoomDoorsShouldLock;
+	COutputEvent	m_OnSpawnRoomDoorsShouldUnlock;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class CLogicMannPower : public CPointEntity
+{
+	DECLARE_CLASS( CLogicMannPower, CPointEntity );
+public:
+	DECLARE_DATADESC();
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: New training stuff
+//-----------------------------------------------------------------------------
+class CTrainingModeLogic : public CPointEntity
+{
+	DECLARE_CLASS( CTrainingModeLogic, CPointEntity );
+public:
+	DECLARE_DATADESC();
+
+	void SetupOnRoundStart( void );
+	void SetTrainingMsg( const char *msg );
+	void SetTrainingObjective( const char *msg );
+	void OnPlayerSpawned( CTFPlayer *pPlayer );
+	void OnPlayerDied( CTFPlayer *pPlayer, CBaseEntity *pKiller );
+	void OnBotDied( CTFPlayer *pPlayer, CBaseEntity *pKiller );
+	void OnPlayerSwitchedWeapons( CTFPlayer *pPlayer );
+	void OnPlayerWantsToContinue();
+	void OnPlayerBuiltBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject );
+	void OnPlayerUpgradedBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject );
+	void OnPlayerDetonateBuilding( CTFPlayer *pPlayer, CBaseObject *pBaseObject );
+	void UpdateHUDObjective();
+	const char* GetNextMap();
+	const char* GetTrainingEndText();
+	int GetDesiredClass() const;
+
+	// Inputs
+	void InputForcePlayerSpawnAsClassOutput( inputdata_t &inputdata );
+	void InputKickAllBots( inputdata_t &inputdata );
+	void InputShowTrainingMsg( inputdata_t &inputdata );
+	void InputShowTrainingObjective( inputdata_t &inputdata );
+	void InputShowTrainingHUD( inputdata_t &inputdata );
+	void InputHideTrainingHUD( inputdata_t &inputdata );
+	void InputEndTraining( inputdata_t &inputdata );
+	void InputPlaySoundOnPlayer( inputdata_t &inputdata );
+	void InputWaitForTimerOrKeypress( inputdata_t &inputdata );
+	void InputSetNextMap( inputdata_t &inputdata );
+	void InputForcePlayerSwapToWeapon( inputdata_t &inputdata );
+
+protected:
+	enum
+	{
+		kMaxLengthObjectiveText = 128,
+	};
+
+	// outputs based on the class the player spawned as
+	COutputEvent m_outputOnPlayerSpawnAsScout;
+	COutputEvent m_outputOnPlayerSpawnAsSniper;
+	COutputEvent m_outputOnPlayerSpawnAsSoldier;
+	COutputEvent m_outputOnPlayerSpawnAsDemoman;
+	COutputEvent m_outputOnPlayerSpawnAsMedic;
+	COutputEvent m_outputOnPlayerSpawnAsHeavy;
+	COutputEvent m_outputOnPlayerSpawnAsPyro;
+	COutputEvent m_outputOnPlayerSpawnAsSpy;
+	COutputEvent m_outputOnPlayerSpawnAsEngineer;
+	// outputs based on the weapon the player swapped to
+	COutputEvent m_outputOnPlayerSwappedToWeaponSlotPrimary;
+	COutputEvent m_outputOnPlayerSwappedToWeaponSlotSecondary;
+	COutputEvent m_outputOnPlayerSwappedToWeaponSlotMelee;
+	COutputEvent m_outputOnPlayerSwappedToWeaponSlotBuilding;
+	COutputEvent m_outputOnPlayerSwappedToWeaponSlotPDA;
+	// outputs based on if the player built inside a suggested area
+	COutputEvent m_outputOnPlayerBuiltOutsideSuggestedArea;
+	// player detonated their own building
+	COutputEvent m_outputOnPlayerDetonateBuilding;
+	// other outputs
+	COutputEvent m_outputOnPlayerDied;
+	COutputEvent m_outputOnBotDied;
+
+	CHandle<CBaseEntity> m_waitingForKeypressTimer;
+	string_t m_nextMapName;
+	char m_objText[kMaxLengthObjectiveText];
+	string_t m_endTrainingText;
+};
+
+class CMultipleEscort : public CPointEntity
+{
+	DECLARE_CLASS( CMultipleEscort, CPointEntity );
+public:
+
+	virtual int UpdateTransmitState()
+	{
+		return SetTransmitState( FL_EDICT_ALWAYS );
+	}
+};
+
+class CMedievalLogic : public CPointEntity
+{
+	DECLARE_CLASS( CMedievalLogic, CPointEntity );
+public:
+
+	virtual int UpdateTransmitState()
+	{
+		return SetTransmitState( FL_EDICT_ALWAYS );
+	}
+};
+
+class CHybridMap_CTF_CP : public CPointEntity
+{
+	DECLARE_CLASS( CHybridMap_CTF_CP, CPointEntity );
+public:
+
+	virtual int UpdateTransmitState()
+	{
+		return SetTransmitState( FL_EDICT_ALWAYS );
+	}
+};
+
+class CTFHolidayEntity : public CPointEntity, public CGameEventListener
+{
+	DECLARE_CLASS( CTFHolidayEntity, CPointEntity );
+public:
+	DECLARE_DATADESC();
+
+	CTFHolidayEntity()
+	{ 
+		m_nHolidayType = kHoliday_None;
+		m_nTauntInHell = 0;
+		m_nAllowHaunting = 0;
+		ListenForGameEvent( "player_turned_to_ghost" );
+		ListenForGameEvent( "player_disconnect" );
+		ListenForGameEvent( "player_team" );
+	}
+	~CTFHolidayEntity()
+	{
+	}
+
+	virtual int UpdateTransmitState()
+	{
+		return SetTransmitState( FL_EDICT_ALWAYS );
+	}
+	int GetHolidayType( void ){ return m_nHolidayType; }
+	bool ShouldTauntInHell( void ){ return ( m_nTauntInHell > 0 ); }
+	bool ShouldAllowHaunting( void ){ return ( m_nAllowHaunting > 0 ); }
+
+	void InputHalloweenSetUsingSpells( inputdata_t &inputdata );
+	void InputHalloweenTeleportToHell( inputdata_t &inputdata );
+
+	virtual void FireGameEvent( IGameEvent *event );
+
+	void ResetWinner() { m_nWinningTeam = TF_TEAM_COUNT; }
+	int GetWinningTeam() const { return m_nWinningTeam; }
+private:
+
+	void HalloweenTeleportToHellDanceThink( void );
+	void Teleport();
+
+	CUtlVector< CHandle<CTFPlayer> > m_vecDancers;
+	int m_nWinningTeam;
+
+	int m_nHolidayType;
+	int m_nTauntInHell;
+	int m_nAllowHaunting;
+};
+
+class CKothLogic : public CPointEntity
+{
+	DECLARE_CLASS( CKothLogic, CPointEntity );
+public:
+	DECLARE_DATADESC();
+
+	CKothLogic()
+	{ 
+		m_nTimerInitialLength = 180; // seconds
+		m_nTimeToUnlockPoint = 30; // seconds
+
+		m_hRedTimer = NULL;
+		m_hBlueTimer = NULL;
+	}
+	virtual int UpdateTransmitState()
+	{
+		return SetTransmitState( FL_EDICT_ALWAYS );
+	}
+
+	int GetInitialTimerLength( void ){ return m_nTimerInitialLength; }
+	int GetTimerToUnlockPoint( void ){ return m_nTimeToUnlockPoint; }
+
+	void InputRoundSpawn( inputdata_t &inputdata );
+	void InputRoundActivate( inputdata_t &inputdata );
+	void InputSetRedTimer( inputdata_t &inputdata );
+	void InputSetBlueTimer( inputdata_t &inputdata );
+	void InputAddRedTimer( inputdata_t &inputdata );
+	void InputAddBlueTimer( inputdata_t &inputdata );
+
+private:
+	int m_nTimerInitialLength;
+	int m_nTimeToUnlockPoint;
+
+	CHandle< CTeamRoundTimer > m_hRedTimer;
+	CHandle< CTeamRoundTimer > m_hBlueTimer;
+};
+
+#define CP_TIMER_THINK "CCPTimerLogicThink"
+class CCPTimerLogic : public CPointEntity
+{
+	DECLARE_CLASS( CCPTimerLogic, CPointEntity );
+public:
+	DECLARE_DATADESC();
+
+	CCPTimerLogic()
+	{ 
+		m_nTimerLength = 60; // seconds
+		m_iszControlPointName = NULL_STRING;
+		m_hControlPoint = NULL;
+		m_bFire15SecRemain = m_bFire10SecRemain = m_bFire5SecRemain = true;
+	
+		SetContextThink( &CCPTimerLogic::Think, gpGlobals->curtime + 0.15, CP_TIMER_THINK );
+	}
+	virtual int UpdateTransmitState()
+	{
+		return SetTransmitState( FL_EDICT_ALWAYS );
+	}
+
+	void InputRoundSpawn( inputdata_t &inputdata );
+	void Think( void );
+	bool TimerMayExpire( void );
+
+private:
+	int m_nTimerLength;
+	string_t m_iszControlPointName;
+	CHandle<CTeamControlPoint> m_hControlPoint;
+	CountdownTimer m_pointTimer;
+
+	bool m_bFire15SecRemain;
+	bool m_bFire10SecRemain;
+	bool m_bFire5SecRemain;
+
+	COutputEvent m_onCountdownStart;
+	COutputEvent m_onCountdown15SecRemain;
+	COutputEvent m_onCountdown10SecRemain;
+	COutputEvent m_onCountdown5SecRemain;
+	COutputEvent m_onCountdownEnd;
+};
+#endif
+
+class CBonusRoundLogic : public CBaseEntity
+{
+	DECLARE_CLASS( CBonusRoundLogic, CBaseEntity );
+public:
+	DECLARE_NETWORKCLASS();
+
+#ifdef GAME_DLL
+	bool		InitBonusRound( void );
+	void		SetBonusItem( itemid_t iItemID );
+	virtual int UpdateTransmitState()
+	{
+		return SetTransmitState( FL_EDICT_ALWAYS );
+	}
+#endif
+
+	void		BuildBonusPlayerList( void );
+	int			GetNumBonusPlayers( void ) { return m_aBonusPlayerList.Count(); }
+	CTFPlayer	*GetBonusPlayer( int i ) { Assert ( i < m_aBonusPlayerList.Count() ); return m_aBonusPlayerList[i]; }
+	CTFPlayer	*GetBonusWinner( void ) { return m_hBonusWinner.Get(); }
+	void		SetBonusStateAborted( bool bAborted ) { m_bAbortedBonusRound = bAborted; }
+	bool		BonusStateAborted( void ) { return m_bAbortedBonusRound; }
+	int			GetPlayerBonusRoll( int iPlayer ) { return (iPlayer < m_aBonusPlayerRoll.Count()) ? m_aBonusPlayerRoll[iPlayer] : 0; }
+	CEconItemView	*GetBonusItem( void ) { return &m_Item; }
+
+private:
+	CUtlSortVector< BONUSPLAYERPTR, CBonusPlayerListLess >	m_aBonusPlayerList;
+	CUtlVector<int>			m_aBonusPlayerRoll;
+	CNetworkVar( CHandle<CTFPlayer>, m_hBonusWinner );
+	CNetworkVar( bool,		m_bAbortedBonusRound );
+	itemid_t			m_iBonusItemID;
+	CNetworkVarEmbedded( CEconItemView,	m_Item );
+};
+
+#ifdef GAME_DLL
+class CSingleUserReliableRecipientFilter : public CRecipientFilter
+{
+public:
+	CSingleUserReliableRecipientFilter( CBasePlayer *player )
+	{
+		AddRecipient( player );
+		MakeReliable();
+	}
+};
+#endif
+
+#endif // TF_GAMERULES_H