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

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:  TF-specific things to vote on
//
//=============================================================================

#include "cbase.h"
#include "tf_voteissues.h"
#include "tf_player.h"

#include "vote_controller.h"
#include "fmtstr.h"
#include "eiface.h"
#include "tf_gamerules.h"
#include "inetchannelinfo.h"
#include "tf_gamestats.h"

#include "tf_gcmessages.h"
#include "player_vs_environment/tf_population_manager.h"
#include "tf_mann_vs_machine_stats.h"
#include "tf_objective_resource.h"
#include "gc_clientsystem.h"
#include "tf_gc_server.h"
#include "player_resource.h"
#include "tf_player_resource.h"

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

extern ConVar tf_mm_trusted;
extern ConVar mp_autoteambalance;
extern ConVar tf_classlimit;
extern ConVar sv_vote_quorum_ratio;
extern ConVar tf_mm_strict;

static bool VotableMap( const char *pszMapName )
{
	char szCanonName[64] = { 0 };
	V_strncpy( szCanonName, pszMapName, sizeof( szCanonName ) );
	IVEngineServer::eFindMapResult eResult = engine->FindMap( szCanonName, sizeof( szCanonName ) );

	switch ( eResult )
	{
	case IVEngineServer::eFindMap_Found:
	case IVEngineServer::eFindMap_NonCanonical:
	case IVEngineServer::eFindMap_PossiblyAvailable:
	case IVEngineServer::eFindMap_FuzzyMatch:
		return true;
	case IVEngineServer::eFindMap_NotFound:
		return false;
	}

	AssertMsg( false, "Unhandled engine->FindMap return value\n" );
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Base TF Issue
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Purpose: Restart Round Issue
//-----------------------------------------------------------------------------
ConVar sv_vote_issue_restart_game_allowed( "sv_vote_issue_restart_game_allowed", "0", FCVAR_NONE, "Can players call votes to restart the game?" );
ConVar sv_vote_issue_restart_game_allowed_mvm( "sv_vote_issue_restart_game_allowed_mvm", "1", FCVAR_NONE, "Can players call votes to restart the game in Mann-Vs-Machine?" );
ConVar sv_vote_issue_restart_game_cooldown( "sv_vote_issue_restart_game_cooldown", "300", FCVAR_NONE, "Minimum time before another restart vote can occur (in seconds)." );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CRestartGameIssue::ExecuteCommand( void )
{
	if ( sv_vote_issue_restart_game_cooldown.GetInt() )
	{
		SetIssueCooldownDuration( sv_vote_issue_restart_game_cooldown.GetFloat() );
	}

	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
	{
		g_pPopulationManager->ResetMap();
		return;
	}

	engine->ServerCommand( "mp_restartgame 1;" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CRestartGameIssue::IsEnabled( void )
{
	if ( TFGameRules() )
	{
		if ( TFGameRules()->IsMannVsMachineMode() )
			return sv_vote_issue_restart_game_allowed_mvm.GetBool();
	}

	return sv_vote_issue_restart_game_allowed.GetBool();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CRestartGameIssue::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

	if( !IsEnabled() )
	{
		nFailCode = VOTE_FAILED_ISSUE_DISABLED;
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CRestartGameIssue::GetDisplayString( void )
{
	return "#TF_vote_restart_game";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CRestartGameIssue::GetVotePassedString( void )
{
	return "#TF_vote_passed_restart_game";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CRestartGameIssue::ListIssueDetails( CBasePlayer *pForWhom )
{
	if( !sv_vote_issue_restart_game_allowed.GetBool() )
		return;

	ListStandardNoArgCommand( pForWhom, GetTypeString() );
}


//-----------------------------------------------------------------------------
// Purpose: Kick Player Issue
//-----------------------------------------------------------------------------
ConVar sv_vote_issue_kick_allowed( "sv_vote_issue_kick_allowed", "0", FCVAR_NONE, "Can players call votes to kick players from the server?" );
ConVar sv_vote_issue_kick_allowed_mvm( "sv_vote_issue_kick_allowed_mvm", "1", FCVAR_NONE, "Can players call votes to kick players from the server in MvM?" );
ConVar sv_vote_kick_ban_duration( "sv_vote_kick_ban_duration", "20", FCVAR_NONE, "The number of minutes a vote ban should last. (0 = Disabled)" );
ConVar sv_vote_issue_kick_min_connect_time_mvm( "sv_vote_issue_kick_min_connect_time_mvm", "300", FCVAR_NONE, "How long a player must be connected before they can be kicked (in seconds)." );
ConVar sv_vote_issue_kick_spectators_mvm( "sv_vote_issue_kick_spectators_mvm", "1", FCVAR_NONE, "Allow players to kick spectators in MvM." );
ConVar sv_vote_issue_kick_namelock_duration( "sv_vote_issue_kick_namelock_duration", "120", FCVAR_NONE, "How long to prevent kick targets from changing their name (in seconds)." );
ConVar sv_vote_issue_kick_limit_mvm( "sv_vote_issue_kick_limit_mvm", "0", FCVAR_HIDDEN, "The maximum number of kick votes a player can call during an MvM mission started by matchmaking. (0 = disabled)" );
ConVar sv_vote_issue_kick_limit_gc( "sv_vote_issue_kick_limit_gc", "0", FCVAR_HIDDEN, "Ask the GC if a kick vote can be called by this player.  Official servers only." );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKickIssue::Init( void )
{
	m_szTargetPlayerName[0] = 0;
	m_hPlayerTarget = NULL;
	m_unKickReason = kVoteKickBanPlayerReason_Other;
	m_steamIDVoteCaller.Clear();
	m_steamIDVoteTarget.Clear();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKickIssue::ExecuteCommand( void )
{
	PrintLogData();

	engine->ServerCommand( CFmtStr( "kickid \"%s\" %s\n", m_steamIDVoteTarget.Render(), g_pszVoteKickString ) );

	GTFGCClientSystem()->MatchPlayerVoteKicked( m_steamIDVoteTarget );

	if ( tf_mm_strict.GetInt() == 1 )
	{
		// If we're in strict match mode, we're done.
		//
		// If the GC does send them back here, banning them would put them in a broken rejoin state. The matchmaker
		// should just not re-match you to somewhere you got kicked from.
		return;
	}

	// If we're not in strict mode they might be here as or be able to rejoin as an adhoc player -- ban.
	// Technically the GC might send them back here for *new* match if they get kicked as ad-hoc, the current match ends, etc.
	engine->ServerCommand( CFmtStr( "banid %d \"%s\"\n", sv_vote_kick_ban_duration.GetInt(), m_steamIDVoteTarget.Render() ) );

	// Band-aid: Hacks are able to avoid kick+ban, and we're not yet sure how they're doing it.  This code checks to see
	//           if they come back.
	//
	// XXX(JohnS): We think the original cause behind this was fixed (connecting-but-not-active race condition)
	g_voteController->AddPlayerToKickWatchList( m_steamIDVoteTarget, ( sv_vote_kick_ban_duration.GetFloat() * 60.f ) );

	NotifyGCAdHocKick( true );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CKickIssue::IsEnabled( void )
{
	if ( TFGameRules() )
	{
		if ( TFGameRules()->IsMannVsMachineMode() )
			return sv_vote_issue_kick_allowed_mvm.GetBool();
	}

	return sv_vote_issue_kick_allowed.GetBool();
}

//-----------------------------------------------------------------------------
// Purpose: This gets calle first.  If true, moves on to OnVoteStarted()
//-----------------------------------------------------------------------------
bool CKickIssue::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if ( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

	// We were waiting for an answer.  Return it.
	if ( m_bGCNotified && m_bGCResponded )
	{
		if ( !m_bGCApproved )
		{
			nFailCode = VOTE_FAILED_KICK_DENIED_BY_GC;
		}

		bool bReturn = m_bGCApproved;

		m_bGCApproved = false;
		m_bGCNotified = false;
		m_bGCResponded = false;

		return bReturn;
	}

	Init();

	if ( !IsEnabled() )
	{
		nFailCode = VOTE_FAILED_ISSUE_DISABLED;
		return false;
	}

	if ( !CreateVoteDataFromDetails( pszDetails ) )
	{
		nFailCode = VOTE_FAILED_PLAYERNOTFOUND;
		return false;
	}

	// Don't kick proxies
	if ( m_hPlayerTarget->IsReplay() || m_hPlayerTarget->IsHLTV() )
	{
		nFailCode = VOTE_FAILED_PLAYERNOTFOUND;
		return false;
	}

	// Don't kick the host or an admin
	if ( ( !engine->IsDedicatedServer() && m_hPlayerTarget->entindex() == 1 ) ||
		 m_hPlayerTarget->IsAutoKickDisabled() )
	{
		nFailCode = VOTE_FAILED_CANNOT_KICK_ADMIN;
		return false;
	}

	// Store caller steamID
	CTFPlayer *pTFVoteCaller = ToTFPlayer( UTIL_EntityByIndex( iEntIndex ) );
	if ( !pTFVoteCaller )
		return false;

	pTFVoteCaller->GetSteamID( &m_steamIDVoteCaller );
	if ( !m_steamIDVoteCaller.IsValid() || !m_steamIDVoteCaller.BIndividualAccount() )
		return false;

	// Store target steamID - if they're not a bot
	bool bFakeClient = m_hPlayerTarget->IsFakeClient() || m_hPlayerTarget->IsBot();
	if ( !bFakeClient )
	{
		m_hPlayerTarget->GetSteamID( &m_steamIDVoteTarget );
		if ( !m_steamIDVoteTarget.IsValid() || !m_steamIDVoteTarget.BIndividualAccount() )
			return false;
	}

	// MvM
	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
	{
		// Don't allow kicking unless we're between rounds
		if ( TFGameRules() && TFGameRules()->State_Get() != GR_STATE_BETWEEN_RNDS )
		{
			nFailCode = VOTE_FAILED_CANNOT_KICK_DURING_ROUND;
			return false;
		}

		// Allow kicking team unassigned
		if ( m_hPlayerTarget->IsConnected() && m_hPlayerTarget->GetTeamNumber() == TEAM_UNASSIGNED )
			return true;

		// Don't allow kicking of players connected less than sv_vote_kick_min_connect_time_mvm
		CTFPlayer *pTFVoteTarget = ToTFPlayer( m_hPlayerTarget );
		if ( pTFVoteTarget )
		{
			float flTimeConnected = gpGlobals->curtime - pTFVoteTarget->GetConnectionTime();

			// See if we have a lobby...
			if ( !bFakeClient )
			{
				CMatchInfo::PlayerMatchData_t *pMatchPlayerTarget = GTFGCClientSystem()->GetLiveMatchPlayer( m_steamIDVoteTarget );
				CMatchInfo::PlayerMatchData_t *pMatchPlayerCaller = GTFGCClientSystem()->GetLiveMatchPlayer( m_steamIDVoteCaller );
				if ( pMatchPlayerTarget )
				{
					// Use this time instead (prevents disconnect avoidance)
					flTimeConnected = CRTime::RTime32TimeCur() - pMatchPlayerTarget->rtJoinedMatch;

					if ( sv_vote_issue_kick_limit_mvm.GetInt() )
					{
						if ( pMatchPlayerCaller && pMatchPlayerCaller->nVoteKickAttempts > (uint32)sv_vote_issue_kick_limit_mvm.GetInt() )
						{
							nFailCode = VOTE_FAILED_KICK_LIMIT_REACHED;
							return false;
						}
					}
				}
			}

			if ( flTimeConnected < sv_vote_issue_kick_min_connect_time_mvm.GetFloat() )
			{
				nFailCode = VOTE_FAILED_CANNOT_KICK_FOR_TIME;
				nTime = sv_vote_issue_kick_min_connect_time_mvm.GetFloat() - flTimeConnected;
				return false;
			}
		}

		// Allow kicking of spectators when this is set, except when it's a bot (invader bots are spectators between rounds)
		if ( sv_vote_issue_kick_spectators_mvm.GetBool() && !m_hPlayerTarget->IsBot() && m_hPlayerTarget->GetTeamNumber() == TEAM_SPECTATOR )
				return true;
	}
	
	// Don't kick players on other teams
	if ( pTFVoteCaller->GetTeamNumber() != m_hPlayerTarget->GetTeamNumber() )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKickIssue::OnVoteFailed( int iEntityHoldingVote )
{
	CBaseTFIssue::OnVoteFailed( iEntityHoldingVote );
	m_bGCNotified = false;
	m_bGCApproved = false;
	m_bGCResponded = false;

	PrintLogData();
	NotifyGCAdHocKick( false );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
 void CKickIssue::OnVoteStarted( void )
 {
	 m_bGCNotified = false;
	 m_bGCApproved = false;
	 m_bGCResponded = false;

	// CanCallVote() should have initialized this
	if ( !m_hPlayerTarget )
	{
		m_hPlayerTarget = UTIL_PlayerBySteamID( m_steamIDVoteTarget );
	}

	if ( !m_hPlayerTarget )
		return;

	// Capture some data about the kick target now, so they can't avoid the 
	// result by doing things like drop, retry, stop sending commands, etc.
	if ( m_steamIDVoteTarget.IsValid() && m_steamIDVoteTarget.BIndividualAccount() )
	{
		Q_strncpy( m_szTargetPlayerName, m_hPlayerTarget->GetPlayerName(), sizeof( m_szTargetPlayerName ) );

		// Configured to block name changing when targeted for a kick?
		if ( sv_vote_issue_kick_namelock_duration.GetFloat() > 0 )
		{
			g_voteController->AddPlayerToNameLockedList( m_steamIDVoteTarget, sv_vote_issue_kick_namelock_duration.GetFloat(), m_hPlayerTarget->GetUserID() );
		}

		if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
		{
			CMatchInfo::PlayerMatchData_t *pMatchPlayerCaller = GTFGCClientSystem()->GetLiveMatchPlayer( m_steamIDVoteCaller );
			if ( pMatchPlayerCaller )
			{
				pMatchPlayerCaller->nVoteKickAttempts++;
			}
		}
	}

	// Auto vote 'No' for the person being kicked unless they are idle
	CTFPlayer *pTFVoteTarget = ToTFPlayer( m_hPlayerTarget );
	if ( pTFVoteTarget && !pTFVoteTarget->IsAwayFromKeyboard() && ( pTFVoteTarget->GetTeamNumber() != TEAM_SPECTATOR ) )
	{
		g_voteController->TryCastVote( pTFVoteTarget->entindex(), "Option2" );
	}
 }

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CKickIssue::GetDisplayString( void )
{
	switch ( m_unKickReason )
	{
	case kVoteKickBanPlayerReason_Other:	return "#TF_vote_kick_player_other";
	case kVoteKickBanPlayerReason_Cheating:	return "#TF_vote_kick_player_cheating";
	case kVoteKickBanPlayerReason_Idle:		return "#TF_vote_kick_player_idle";
	case kVoteKickBanPlayerReason_Scamming:	return "#TF_vote_kick_player_scamming";
	}
	return "#TF_vote_kick_player_other";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CKickIssue::GetVotePassedString( void )
{
	// Player left before we could finish, but still got banned
	if ( !m_hPlayerTarget && sv_vote_kick_ban_duration.GetInt() > 0 )
		return "#TF_vote_passed_ban_player";

	// Player is still here
	return "#TF_vote_passed_kick_player";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CKickIssue::GetDetailsString( void )
{
	if ( m_hPlayerTarget )
		return m_hPlayerTarget->GetPlayerName();

	// If they left, use name stored at creation
	if ( V_strlen( m_szTargetPlayerName ) )
		return m_szTargetPlayerName;
	
	return "Unnamed";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CKickIssue::NeedsPermissionFromGC( void )
{
	if ( sv_vote_issue_kick_limit_gc.GetBool() )
	{
		// Ask the GC if this is allowed (unless we've already asked, or the player is AFK - which makes it "free")
		if ( GTFGCClientSystem()->GetLiveMatch() && !m_bGCNotified )
		{
			CTFPlayer *pTFVoteTarget = ToTFPlayer( m_hPlayerTarget );
			if ( !pTFVoteTarget || pTFVoteTarget->IsAwayFromKeyboard() )
				return false;

			GCSDK::CProtoBufMsg< CMsgGC_TFVoteKickPlayerRequest > msgRequestVote( k_EMsgGCVoteKickPlayerRequest );
			msgRequestVote.Body().set_account_id( m_steamIDVoteCaller.GetAccountID() );
			msgRequestVote.Body().set_target_id( pTFVoteTarget->GetSteamIDAsUInt64() );
			GCClientSystem()->BSendMessage( msgRequestVote );

			m_bGCNotified = true;
			return true;
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKickIssue::NotifyGCAdHocKick( bool bKickedSuccessfully )
{
	if ( m_steamIDVoteCaller.IsValid() && m_steamIDVoteTarget.IsValid() && m_steamIDVoteTarget.BIndividualAccount() )
	{
		GCSDK::CProtoBufMsg<CMsgTFVoteKickBanPlayerResult> msg( k_EMsgGCVoteKickBanPlayerResult );
		msg.Body().set_account_id_initiator( m_steamIDVoteCaller.GetAccountID() );
		msg.Body().set_account_id_subject( m_steamIDVoteTarget.GetAccountID() );
		msg.Body().set_kick_successful( bKickedSuccessfully );
		msg.Body().set_kick_reason( m_unKickReason );
		msg.Body().set_num_yes_votes( m_iNumYesVotes );
		msg.Body().set_num_no_votes( m_iNumNoVotes );
		msg.Body().set_num_possible_votes( m_iNumPotentialVotes );
		GCClientSystem()->BSendMessage( msg );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKickIssue::PrintLogData( void )
{
	bool bFakeClient = m_hPlayerTarget && ( m_hPlayerTarget->IsFakeClient() || m_hPlayerTarget->IsHLTV() || m_hPlayerTarget->IsReplay() );

	UTIL_LogPrintf( "Kick Vote details:  VoteInitiatorSteamID: %s  VoteTargetSteamID: %s  Valid: %i  BIndividual: %i  Name: %s  Proxy: %i\n",
					m_steamIDVoteCaller.IsValid() ? m_steamIDVoteCaller.Render() : "[unknown]",
					m_steamIDVoteTarget.Render(),
					m_steamIDVoteTarget.IsValid(),
					m_steamIDVoteTarget.BIndividualAccount(),
					m_hPlayerTarget ? m_szTargetPlayerName : "Disconnected",
					bFakeClient );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CKickIssue::CreateVoteDataFromDetails( const char *pszDetails )
{
	int iUserID = 0;
	const char *pReasonString = strstr( pszDetails, " " );
	if ( pReasonString != NULL )
	{
		pReasonString += 1;
		CUtlString userID;
		userID.SetDirect( pszDetails, pReasonString - pszDetails );
		iUserID = atoi( userID );
		m_unKickReason = GetKickBanPlayerReason( pReasonString );
	}
	else
	{
		iUserID = atoi( pszDetails );
	}

	// Try to use the steamID we stored in OnVoteStarted() (will fail for bots)
	for ( int i = 0; i < MAX_PLAYERS; i++ )
	{
		CTFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( i ) );
		if ( !pPlayer )
			continue;

		CSteamID steamID;
		if ( pPlayer->GetSteamID( &steamID ) && steamID == m_steamIDVoteTarget )
		{
			m_hPlayerTarget = pPlayer;
			return true;
		}
	}
	
	// Otherwise rely on userID
	if ( iUserID )
	{
		m_hPlayerTarget = ToBasePlayer( UTIL_PlayerByUserId( iUserID ) );
	}

	return ( m_hPlayerTarget ) ? true : false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CKickIssue::ListIssueDetails( CBasePlayer *pForWhom )
{
	if( !sv_vote_issue_kick_allowed.GetBool() )
		return;

	char szBuffer[MAX_COMMAND_LENGTH];
	Q_snprintf( szBuffer, MAX_COMMAND_LENGTH, "callvote %s <userID>\n", GetTypeString() );
	ClientPrint( pForWhom, HUD_PRINTCONSOLE, szBuffer );
}


//-----------------------------------------------------------------------------
// Purpose: Changelevel
//-----------------------------------------------------------------------------
ConVar sv_vote_issue_changelevel_allowed( "sv_vote_issue_changelevel_allowed", "0", FCVAR_NONE, "Can players call votes to change levels?" );
ConVar sv_vote_issue_changelevel_allowed_mvm( "sv_vote_issue_changelevel_allowed_mvm", "0", FCVAR_NONE, "Can players call votes to change levels in MvM?" );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CChangeLevelIssue::ExecuteCommand( void )
{
	engine->ChangeLevel( m_szDetailsString, NULL );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CChangeLevelIssue::CanTeamCallVote( int iTeam ) const
{
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CChangeLevelIssue::IsEnabled( void )
{
	if ( TFGameRules() )
	{
		if ( TFGameRules()->IsMannVsMachineMode() )
			return sv_vote_issue_changelevel_allowed_mvm.GetBool();
	}

	return sv_vote_issue_changelevel_allowed.GetBool();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CChangeLevelIssue::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

	if( !IsEnabled() )
	{
		nFailCode = VOTE_FAILED_ISSUE_DISABLED;
		return false;
	}

	if ( !Q_strcmp( pszDetails, "" ) )
	{
		nFailCode = VOTE_FAILED_MAP_NAME_REQUIRED;
		return false;
	}
	else
	{
		if ( !VotableMap( pszDetails ) )
		{
			nFailCode = VOTE_FAILED_MAP_NOT_FOUND;
			return false;
		}

		if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
		{
			// We can't test if it's valid - deny
			if ( !g_pPopulationManager )
			{
				nFailCode = VOTE_FAILED_GENERIC;
				return false;
			}

			if ( !g_pPopulationManager->IsValidMvMMap( pszDetails ) )
			{
				nFailCode = VOTE_FAILED_MAP_NOT_VALID;
				return false;
			}
		}
		else
		{
			if ( MultiplayRules() && !MultiplayRules()->IsMapInMapCycle( pszDetails ) )
			{
				nFailCode = VOTE_FAILED_MAP_NOT_VALID;
				return false;
			}
		}
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CChangeLevelIssue::GetDisplayString( void )
{
	return "#TF_vote_changelevel";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CChangeLevelIssue::GetVotePassedString( void )
{
	return "#TF_vote_passed_changelevel";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CChangeLevelIssue::GetDetailsString( void )
{
	return m_szDetailsString;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CChangeLevelIssue::ListIssueDetails( CBasePlayer *pForWhom )
{
	if( !sv_vote_issue_changelevel_allowed.GetBool() )
		return;

	char szBuffer[MAX_COMMAND_LENGTH];
	Q_snprintf( szBuffer, MAX_COMMAND_LENGTH, "callvote %s <mapname>\n", GetTypeString() );
	ClientPrint( pForWhom, HUD_PRINTCONSOLE, szBuffer );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CChangeLevelIssue::IsYesNoVote( void )
{
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Nextlevel
//-----------------------------------------------------------------------------
ConVar sv_vote_issue_nextlevel_allowed( "sv_vote_issue_nextlevel_allowed", "1", FCVAR_NONE, "Can players call votes to set the next level?" );
ConVar sv_vote_issue_nextlevel_choicesmode( "sv_vote_issue_nextlevel_choicesmode", "0", FCVAR_NONE, "Present players with a list of lowest playtime maps to choose from?" );
ConVar sv_vote_issue_nextlevel_allowextend( "sv_vote_issue_nextlevel_allowextend", "1", FCVAR_NONE, "Allow players to extend the current map?" );
ConVar sv_vote_issue_nextlevel_prevent_change( "sv_vote_issue_nextlevel_prevent_change", "1", FCVAR_NONE, "Not allowed to vote for a nextlevel if one has already been set." );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CNextLevelIssue::GetVoteOptions( CUtlVector <const char*> &vecNames )
{
	m_IssueOptions.RemoveAll();

	// Reserve the last option for "Extend current Map?"
	int nNumOptions = sv_vote_issue_nextlevel_allowextend.GetBool() ? GetNumberVoteOptions() - 1 : GetNumberVoteOptions();

	// Ask the stats system for playtime data
	if ( CTF_GameStats.GetVoteData( "NextLevel", nNumOptions, m_IssueOptions ) )
	{
		FOR_EACH_VEC( m_IssueOptions, iIndex )
		{
			vecNames.AddToTail( m_IssueOptions[iIndex] );
		}

		if ( sv_vote_issue_nextlevel_allowextend.GetBool() || m_IssueOptions.Count() == 1 )
		{
			vecNames.AddToTail( "Extend current Map" );
		}
	
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CNextLevelIssue::ExecuteCommand( void )
{
	if ( Q_strcmp( m_szDetailsString, "Extend current Map" ) == 0 )
	{
		// Players want to extend the current map, so extend any existing limits
		if ( mp_timelimit.GetInt() > 0 )
		{
			engine->ServerCommand( CFmtStr( "mp_timelimit %d;", mp_timelimit.GetInt() + 20 ) );
		}

		if ( mp_maxrounds.GetInt() > 0 )
		{
			engine->ServerCommand( CFmtStr( "mp_maxrounds %d;", mp_maxrounds.GetInt() + 2 ) );
		}

		if ( mp_winlimit.GetInt() > 0 )
		{
			engine->ServerCommand( CFmtStr( "mp_winlimit %d;", mp_winlimit.GetInt() + 2 ) );
		}
	}
	else
	{
		nextlevel.SetValue( m_szDetailsString );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CNextLevelIssue::CanTeamCallVote( int iTeam ) const
{
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CNextLevelIssue::IsEnabled( void )
{
	if ( TFGameRules() )
	{
		if ( TFGameRules()->IsMannVsMachineMode() )
			return false;
	}

	return sv_vote_issue_nextlevel_allowed.GetBool();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CNextLevelIssue::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

	// TFGameRules created vote
	if ( sv_vote_issue_nextlevel_choicesmode.GetBool() && iEntIndex == 99 )
	{
		// Invokes a UI down stream
		if ( Q_strcmp( pszDetails, "" ) == 0 )
		{
			return true;
		}

		return false;
	}
	
	if( !IsEnabled() )
	{
		nFailCode = VOTE_FAILED_ISSUE_DISABLED;
		return false;
	}

	if ( Q_strcmp( pszDetails, "" ) == 0 )
	{
		nFailCode = VOTE_FAILED_MAP_NAME_REQUIRED;
		return false;
	}
	else
	{
		if ( !VotableMap( pszDetails ) )
		{
			nFailCode = VOTE_FAILED_MAP_NOT_FOUND;
			return false;
		}

		if ( MultiplayRules() && !MultiplayRules()->IsMapInMapCycle( pszDetails ) )
		{
			nFailCode = VOTE_FAILED_MAP_NOT_VALID;
			return false;
		}
	}

	if ( sv_vote_issue_nextlevel_prevent_change.GetBool() )
	{
		if ( nextlevel.GetString() && *nextlevel.GetString() )
		{
			nFailCode = VOTE_FAILED_NEXTLEVEL_SET;
			return false;
		}
	}
	
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CNextLevelIssue::GetDisplayString( void )
{
	// If we don't have a map passed in already...
	if ( Q_strcmp( m_szDetailsString, "" ) == 0 )
	{
		if ( sv_vote_issue_nextlevel_choicesmode.GetBool() )
		{
			return "#TF_vote_nextlevel_choices";
		}
	}

	return "#TF_vote_nextlevel";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CNextLevelIssue::GetVotePassedString( void )
{
	if ( sv_vote_issue_nextlevel_allowextend.GetBool() )
	{
		if ( Q_strcmp( m_szDetailsString, "Extend current Map" ) == 0 )
		{
			return "#TF_vote_passed_nextlevel_extend";
		}
	}
	
	return "#TF_vote_passed_nextlevel";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CNextLevelIssue::GetDetailsString( void )
{
	return m_szDetailsString;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CNextLevelIssue::ListIssueDetails( CBasePlayer *pForWhom )
{
	if( !sv_vote_issue_nextlevel_allowed.GetBool() )
		return;

	if ( !sv_vote_issue_nextlevel_choicesmode.GetBool() )
	{
		char szBuffer[MAX_COMMAND_LENGTH];
		Q_snprintf( szBuffer, MAX_COMMAND_LENGTH, "callvote %s <mapname>\n", GetTypeString() );
		ClientPrint( pForWhom, HUD_PRINTCONSOLE, szBuffer );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CNextLevelIssue::IsYesNoVote( void )
{
	// If we don't have a map name already, this will trigger a list of choices
	if ( Q_strcmp( m_szDetailsString, "" ) == 0 )
	{
		if ( sv_vote_issue_nextlevel_choicesmode.GetBool() )
			return false;
	}
	
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CNextLevelIssue::GetNumberVoteOptions( void )
{
	// If we don't have a map name already, this will trigger a list of choices
	if ( Q_strcmp( m_szDetailsString, "" ) == 0 )
	{
		if ( sv_vote_issue_nextlevel_choicesmode.GetBool() )
			return MAX_VOTE_OPTIONS;
	}

	// Vote on a specific map - Yes, No
	return 2;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CNextLevelIssue::GetQuorumRatio( void )
{
	// We don't really care about a quorum in this case.  If a few
	// people have a preference on the next level, and no one else
	// bothers to vote, just let their choice pass.
	if ( sv_vote_issue_nextlevel_choicesmode.GetBool() )
		return 0.1f;

	// Default
	return sv_vote_quorum_ratio.GetFloat();
}

//-----------------------------------------------------------------------------
// Purpose: Extend the current level
//-----------------------------------------------------------------------------
ConVar sv_vote_issue_extendlevel_allowed( "sv_vote_issue_extendlevel_allowed", "1", FCVAR_NONE, "Can players call votes to set the next level?" );
ConVar sv_vote_issue_extendlevel_quorum( "sv_vote_issue_extendlevel_quorum", "0.6", FCVAR_NONE, "What is the ratio of voters needed to reach quorum?" );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExtendLevelIssue::ExecuteCommand( void )
{
	// Players want to extend the current map, so extend any existing limits
	if ( mp_timelimit.GetInt() > 0 )
	{
		engine->ServerCommand( CFmtStr( "mp_timelimit %d;", mp_timelimit.GetInt() + 20 ) );
	}

	if ( mp_maxrounds.GetInt() > 0 )
	{
		engine->ServerCommand( CFmtStr( "mp_maxrounds %d;", mp_maxrounds.GetInt() + 2 ) );
	}

	if ( mp_winlimit.GetInt() > 0 )
	{
		engine->ServerCommand( CFmtStr( "mp_winlimit %d;", mp_winlimit.GetInt() + 2 ) );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CExtendLevelIssue::IsEnabled( void )
{
	if ( TFGameRules() )
	{
		if ( TFGameRules()->IsMannVsMachineMode() )
			return false;
	}

	return sv_vote_issue_extendlevel_allowed.GetBool();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CExtendLevelIssue::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if ( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

	if ( !IsEnabled() )
	{
		nFailCode = VOTE_FAILED_ISSUE_DISABLED;
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CExtendLevelIssue::GetDisplayString( void )
{
	return "#TF_vote_extendlevel";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CExtendLevelIssue::ListIssueDetails( CBasePlayer *pForWhom )
{
	if ( !sv_vote_issue_extendlevel_allowed.GetBool() ) 
		return;

	ListStandardNoArgCommand( pForWhom, GetTypeString() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CExtendLevelIssue::GetVotePassedString( void )
{
	// We already had a localized string for this, even though we never use it.
	return "#TF_vote_passed_nextlevel_extend";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CExtendLevelIssue::GetQuorumRatio( void )
{
	// Our own quorom 
	return sv_vote_issue_extendlevel_quorum.GetFloat();
}

//-----------------------------------------------------------------------------
// Purpose: Scramble Teams Issue
//-----------------------------------------------------------------------------
ConVar sv_vote_issue_scramble_teams_allowed( "sv_vote_issue_scramble_teams_allowed", "1", FCVAR_NONE, "Can players call votes to scramble the teams?" );
ConVar sv_vote_issue_scramble_teams_cooldown( "sv_vote_issue_scramble_teams_cooldown", "1200", FCVAR_NONE, "Minimum time before another scramble vote can occur (in seconds)." );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScrambleTeams::ExecuteCommand( void )
{
	if ( sv_vote_issue_scramble_teams_cooldown.GetInt() )
	{
		SetIssueCooldownDuration( sv_vote_issue_scramble_teams_cooldown.GetFloat() );
	}

	engine->ServerCommand( "mp_scrambleteams 2;" );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CScrambleTeams::IsEnabled( void )
{
	if ( TFGameRules() )
	{
		if ( TFGameRules()->IsMannVsMachineMode() )
			return false;
	}

	return sv_vote_issue_scramble_teams_allowed.GetBool();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CScrambleTeams::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

	if( !IsEnabled() )
	{
		nFailCode = VOTE_FAILED_ISSUE_DISABLED;
		return false;
	}

	if ( TFGameRules() && TFGameRules()->ShouldScrambleTeams() )
	{
		nFailCode = VOTE_FAILED_SCRAMBLE_IN_PROGRESS;
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CScrambleTeams::GetDisplayString( void )
{
	return "#TF_vote_scramble_teams";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CScrambleTeams::GetVotePassedString( void )
{
	return "#TF_vote_passed_scramble_teams";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CScrambleTeams::ListIssueDetails( CBasePlayer *pForWhom )
{
	if( !sv_vote_issue_scramble_teams_allowed.GetBool() )
		return;

	ListStandardNoArgCommand( pForWhom, GetTypeString() );
}

//-----------------------------------------------------------------------------
// Purpose: MvM Challenge Issue
//-----------------------------------------------------------------------------
ConVar sv_vote_issue_mvm_challenge_allowed( "sv_vote_issue_mvm_challenge_allowed", "1", FCVAR_NONE, "Can players call votes to set the challenge level?" );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMannVsMachineChangeChallengeIssue::ExecuteCommand( void )
{
	if ( Q_stricmp( m_szDetailsString, "normal" ) == 0 )
	{
		engine->ServerCommand( CFmtStr( "tf_mvm_popfile \"%s\";", STRING(gpGlobals->mapname) ) );
	}
	else
	{
		engine->ServerCommand( CFmtStr( "tf_mvm_popfile \"%s\";", m_szDetailsString ) );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CMannVsMachineChangeChallengeIssue::CanTeamCallVote( int iTeam ) const
{
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: MvM-specific issue
//-----------------------------------------------------------------------------
bool CMannVsMachineChangeChallengeIssue::IsEnabled( void )
{
	// Only allow in MvM
	if ( TFGameRules() && !TFGameRules()->IsMannVsMachineMode() )
		return false;

	// But prevent on MannUp (Valve) servers
	CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();
	if ( pMatch && pMatch->m_eMatchGroup == k_nMatchGroup_MvM_MannUp )
	{
		return false;
	}

	return sv_vote_issue_mvm_challenge_allowed.GetBool();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CMannVsMachineChangeChallengeIssue::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

	if( !IsEnabled() )
	{
		nFailCode = VOTE_FAILED_ISSUE_DISABLED;
		return false;
	}

	if ( Q_strcmp( pszDetails, "" ) == 0 )
	{
		nFailCode = VOTE_FAILED_MAP_NAME_REQUIRED;
		return false;
	}
	else
	{
		// Make sure it's a valid pop
		/*if ( !HaveExactMap( pszDetails ) )
		{
			nFailCode = VOTE_FAILED_MAP_NOT_FOUND;
			return false;
		}*/
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CMannVsMachineChangeChallengeIssue::GetDisplayString( void )
{
	return "#TF_vote_changechallenge";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CMannVsMachineChangeChallengeIssue::GetVotePassedString( void )
{
	return "#TF_vote_passed_changechallenge";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CMannVsMachineChangeChallengeIssue::GetDetailsString( void )
{
	return m_szDetailsString;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CMannVsMachineChangeChallengeIssue::ListIssueDetails( CBasePlayer *pForWhom )
{
	if( !sv_vote_issue_mvm_challenge_allowed.GetBool() )
		return;

	char szBuffer[MAX_COMMAND_LENGTH];
	Q_snprintf( szBuffer, MAX_COMMAND_LENGTH, "callvote %s <popfile>\n", GetTypeString() );
	ClientPrint( pForWhom, HUD_PRINTCONSOLE, szBuffer );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CMannVsMachineChangeChallengeIssue::IsYesNoVote( void )
{
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
int CMannVsMachineChangeChallengeIssue::GetNumberVoteOptions( void )
{
	// Vote on a specific map - Yes, No
	return 2;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CEnableTemporaryHalloweenIssue::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

#ifndef STAGING_ONLY
	// Prevent concommand calling of this vote
	if ( iEntIndex != DEDICATED_SERVER )
		return false;
#endif // !STAGING_ONLY

	if( TFGameRules()->IsHolidayActive( kHoliday_HalloweenOrFullMoon ) )
	{
		nFailCode = VOTE_FAILED_MODIFICATION_ALREADY_ACTIVE;
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEnableTemporaryHalloweenIssue::ListIssueDetails( CBasePlayer *pForWhom )
{
	ListStandardNoArgCommand( pForWhom, GetTypeString() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
static void SendVoteResponseToGC( bool bVoteResponse )
{
	if ( GTFGCClientSystem() )
	{
		// Tell the GC.
		GCSDK::CProtoBufMsg<CMsgGC_GameServer_UseServerModificationItem_Response> msgResponse( k_EMsgGC_GameServer_UseServerModificationItem_Response );
		msgResponse.Body().set_server_response_code( bVoteResponse ? CMsgGC_GameServer_UseServerModificationItem_Response::kServerModificationItemServerResponse_Accepted : CMsgGC_GameServer_UseServerModificationItem_Response::kServerModificationItemServerResponse_VoteFailed );
		GTFGCClientSystem()->BSendMessage( msgResponse );

		// Tell the players on the server.
		if ( bVoteResponse )
		{
			TFGameRules()->BroadcastSound( 255, RandomInt( 0, 100 ) <= 10 ? "Halloween.MerasmusHalloweenModeRare" : "Halloween.MerasmusHalloweenModeCommon" );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEnableTemporaryHalloweenIssue::ExecuteCommand( void )
{
	SendVoteResponseToGC( true );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CEnableTemporaryHalloweenIssue::OnVoteFailed( int iEntityHoldingVote )
{
	CBaseTFIssue::OnVoteFailed( iEntityHoldingVote );

	SendVoteResponseToGC( false );
}

//-----------------------------------------------------------------------------
// Purpose: Enable/Disable mp_autoteambalance
//-----------------------------------------------------------------------------
ConVar sv_vote_issue_autobalance_allowed( "sv_vote_issue_autobalance_allowed", "0", FCVAR_NONE, "Can players call votes to enable or disable auto team balance?" );
ConVar sv_vote_issue_autobalance_cooldown( "sv_vote_issue_autobalance_cooldown", "300", FCVAR_NONE, "Minimum time before another auto team balance vote can occur (in seconds)." );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CTeamAutoBalanceIssue::GetTypeStringLocalized( void )
{
	// Disabled
	if ( !mp_autoteambalance.GetInt() )
	{
		return "#Vote_TeamAutoBalance_Enable";
	}

	return "#Vote_TeamAutoBalance_Disable";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTeamAutoBalanceIssue::ExecuteCommand( void )
{
	if ( sv_vote_issue_autobalance_cooldown.GetInt() )
	{
		SetIssueCooldownDuration( sv_vote_issue_autobalance_cooldown.GetFloat() );
	}

	// Disable
	if ( mp_autoteambalance.GetInt() )
	{
		engine->ServerCommand( "mp_autoteambalance 0;" );
	}
	// Enable
	else
	{
		engine->ServerCommand( "mp_autoteambalance 1;" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTeamAutoBalanceIssue::IsEnabled( void )
{
	if ( !TFGameRules() || !TFGameRules()->IsDefaultGameMode() )
		return false;

	return sv_vote_issue_autobalance_allowed.GetBool();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CTeamAutoBalanceIssue::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if ( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

	if ( !IsEnabled() )
	{
		nFailCode = VOTE_FAILED_ISSUE_DISABLED;
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CTeamAutoBalanceIssue::GetDisplayString( void )
{
	// Disable
	if ( mp_autoteambalance.GetInt() )
		return "#TF_vote_autobalance_disable";

	// Enable
	return "#TF_vote_autobalance_enable";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CTeamAutoBalanceIssue::GetVotePassedString( void )
{
	// Disable
	if ( mp_autoteambalance.GetInt() )
		return "#TF_vote_passed_autobalance_disable";

	// Enable
	return "#TF_vote_passed_autobalance_enable";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CTeamAutoBalanceIssue::ListIssueDetails( CBasePlayer *pForWhom )
{
	if ( !sv_vote_issue_autobalance_allowed.GetBool() )
		return;

	ListStandardNoArgCommand( pForWhom, GetTypeString() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
float CTeamAutoBalanceIssue::GetQuorumRatio( void )
{
	float flRatio = sv_vote_quorum_ratio.GetFloat();

	// Disable
	if ( mp_autoteambalance.GetInt() )
		return flRatio;

	// Enable
	return Max( 0.1f, flRatio * 0.7f );
}

//-----------------------------------------------------------------------------
// Purpose: Enable/Disable tf_classlimit
//-----------------------------------------------------------------------------
#ifdef STAGING_ONLY
ConVar sv_vote_issue_classlimits_allowed( "sv_vote_issue_classlimits_allowed", "1", FCVAR_NONE, "Can players call votes to enable or disable per-class limits?" );
#else
ConVar sv_vote_issue_classlimits_allowed( "sv_vote_issue_classlimits_allowed", "0", FCVAR_NONE, "Can players call votes to enable or disable per-class limits?" );
#endif
ConVar sv_vote_issue_classlimits_allowed_mvm( "sv_vote_issue_classlimits_allowed_mvm", "0", FCVAR_NONE, "Can players call votes in Mann-Vs-Machine to enable or disable per-class limits?" );
ConVar sv_vote_issue_classlimits_max( "sv_vote_issue_classlimits_max", "4", FCVAR_NONE, "Maximum number of players (per-team) that can be any one class.", true, 1.f, false, 16.f );
ConVar sv_vote_issue_classlimits_max_mvm( "sv_vote_issue_classlimits_max_mvm", "2", FCVAR_NONE, "Maximum number of players (per-team) that can be any one class.", true, 1.f, false, 16.f );
ConVar sv_vote_issue_classlimits_cooldown( "sv_vote_issue_classlimits_cooldown", "300", FCVAR_NONE, "Minimum time before another classlimits vote can occur (in seconds)." );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CClassLimitsIssue::GetTypeStringLocalized( void )
{
	// Disabled
	if ( !tf_classlimit.GetInt() )
	{
		return "#Vote_ClassLimit_Enable";
	}

	return "#Vote_ClassLimit_Disable";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLimitsIssue::ExecuteCommand( void )
{
	if ( sv_vote_issue_classlimits_cooldown.GetInt() )
	{
		SetIssueCooldownDuration( sv_vote_issue_classlimits_cooldown.GetFloat() );
	}

	// Disable
	if ( tf_classlimit.GetInt() )
	{
		engine->ServerCommand( "tf_classlimit 0;" );
	}
	// Enable
	else
	{
		int nLimit = ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() ) ? sv_vote_issue_classlimits_max_mvm.GetInt() : sv_vote_issue_classlimits_max.GetInt();
		engine->ServerCommand( CFmtStr( "tf_classlimit %i;", nLimit ) );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CClassLimitsIssue::IsEnabled( void )
{
	if ( TFGameRules() )
	{
		// Manages class limits already
		if ( TFGameRules()->IsInTournamentMode() )
			return false;

		// Manages class limits already
		if ( TFGameRules()->IsInHighlanderMode() )
			return false;

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

	return sv_vote_issue_classlimits_allowed.GetBool();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CClassLimitsIssue::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if ( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

	if ( !IsEnabled() )
	{
		nFailCode = VOTE_FAILED_ISSUE_DISABLED;
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CClassLimitsIssue::GetDisplayString( void )
{
	// Disable
	if ( tf_classlimit.GetInt() )
		return "#TF_vote_classlimits_disable";

	// Enable
	return "#TF_vote_classlimits_enable";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CClassLimitsIssue::GetVotePassedString( void )
{
	// Disable
	if ( tf_classlimit.GetInt() )
		return "#TF_vote_passed_classlimits_disable";

	// Enable
	return "#TF_vote_passed_classlimits_enable";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CClassLimitsIssue::ListIssueDetails( CBasePlayer *pForWhom )
{
	if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && !sv_vote_issue_classlimits_allowed_mvm.GetBool() )
		return;

	if ( !sv_vote_issue_classlimits_allowed.GetBool() )
		return;

	ListStandardNoArgCommand( pForWhom, GetTypeString() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CClassLimitsIssue::GetDetailsString( void )
{
	int nLimit = ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() ) ? sv_vote_issue_classlimits_max_mvm.GetInt() : sv_vote_issue_classlimits_max.GetInt();
	m_sRetString = CFmtStr( "%i", nLimit );
	return m_sRetString.String();
}


//-----------------------------------------------------------------------------
// Purpose: Pause Game
//-----------------------------------------------------------------------------
ConVar sv_vote_issue_pause_game_allowed( "sv_vote_issue_pause_game_allowed", "0", FCVAR_HIDDEN, "Can players call votes to pause the game?" );
ConVar sv_vote_issue_pause_game_timer( "sv_vote_issue_pause_game_timer", "120", FCVAR_HIDDEN, "How long to pause the game for when this vote passes (in seconds)." );
ConVar sv_vote_issue_pause_game_cooldown( "sv_vote_issue_pause_game_cooldown", "1200", FCVAR_HIDDEN, "Minimum time before another pause vote can occur (in seconds)." );

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPauseGameIssue::ExecuteCommand( void )
{
	if ( sv_vote_issue_pause_game_cooldown.GetInt() )
	{
		SetIssueCooldownDuration( sv_vote_issue_pause_game_cooldown.GetFloat() );
	}

	engine->SetPausedForced( true, sv_vote_issue_pause_game_timer.GetFloat() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CPauseGameIssue::IsEnabled( void )
{
	if ( engine->IsPaused() )
		return false;

	return sv_vote_issue_pause_game_allowed.GetBool();
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CPauseGameIssue::CanCallVote( int iEntIndex, const char *pszDetails, vote_create_failed_t &nFailCode, int &nTime )
{
	if ( !CBaseTFIssue::CanCallVote( iEntIndex, pszDetails, nFailCode, nTime ) )
		return false;

	if ( !IsEnabled() )
	{
		nFailCode = VOTE_FAILED_ISSUE_DISABLED;
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CPauseGameIssue::GetDisplayString( void )
{
	return "#TF_vote_pause_game";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CPauseGameIssue::GetVotePassedString( void )
{
	return "#TF_vote_passed_pause_game";
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CPauseGameIssue::ListIssueDetails( CBasePlayer *pForWhom )
{
	if ( !sv_vote_issue_pause_game_allowed.GetBool() )
		return;

	ListStandardNoArgCommand( pForWhom, GetTypeString() );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
const char *CPauseGameIssue::GetDetailsString( void )
{
	m_sRetString = CFmtStr( "%i", sv_vote_issue_pause_game_timer.GetInt() );
	return (m_sRetString.String());
}