//========= 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 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 \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 \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 &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 \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 \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 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()); }