path: root/game/shared/tf/tf_match_description.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================

#include "cbase.h"
#include "tf_match_description.h"
#include "tf_ladder_data.h"
#include "tf_rating_data.h"

#ifdef GC_DLL
#include "tf_lobby.h"
#include "tf_partymanager.h"
#endif

#if defined CLIENT_DLL || defined GAME_DLL
#include "tf_gamerules.h"
#endif

#ifdef CLIENT_DLL
#include "tf_gc_client.h"
#include "animation.h"
#include "vgui/ISurface.h"
#include "vgui_controls/Controls.h"
#include "tf_lobby_server.h"
#endif

#ifdef GAME_DLL
#include "tf_lobby_server.h"
#include "tf_gc_server.h"
#include "tf_objective_resource.h"
#include "team_control_point_master.h"
#endif

#ifdef GC_DLL
GCConVar tf_mm_ladder_force_map_by_name( "tf_mm_ladder_force_map_by_name", "", "If specified, force any matches that form for 6v6, 9v9, 12v12 to use the specified map (e.g. cp_sunshine)." );
GCConVar tf_mm_casual_rejoin_cooldown_secs( "tf_mm_casual_rejoin_cooldown_secs", "180",
                                            "How many seconds must pass before anyone can re-match into a casual or MvM lobby they have left. "
                                            "Setting this too low may allow someone to rejoin a lobby while a vote-kick for them is still occuring, but before it has passed." );
GCConVar tf_mm_casual_rejoin_cooldown_votekick_secs( "tf_mm_casual_rejoin_cooldown_votekick_secs", "10800", // 3 hours
                                                     "How many seconds must pass before a vote-kicked player can re-match into a casual or MvM lobby. "
                                                     "This is not infinite as casual lobbies may persist for days." );
// These are in matchmaking shared
extern GCConVar tf_mm_match_size_mvm;
extern GCConVar tf_mm_match_size_ladder_6v6;
extern GCConVar tf_mm_match_size_ladder_9v9;
extern GCConVar tf_mm_match_size_ladder_12v12;
extern GCConVar tf_mm_match_size_ladder_12v12_minimum;
#else
extern ConVar tf_mm_match_size_mvm;
extern ConVar tf_mm_match_size_ladder_6v6;
extern ConVar tf_mm_match_size_ladder_9v9;
extern ConVar tf_mm_match_size_ladder_12v12;
extern ConVar tf_mm_match_size_ladder_12v12_minimum;
extern ConVar servercfgfile;
extern ConVar lservercfgfile;
extern ConVar mp_tournament_stopwatch;
extern ConVar tf_gamemode_payload;
extern ConVar tf_gamemode_ctf;
#endif

#ifdef GAME_DLL
extern ConVar tf_mvm_allow_abandon_after_seconds;
extern ConVar tf_mvm_allow_abandon_below_players;
#endif

#ifdef GC_DLL
	#define MVM_REQUIRED_SCORE &tf_mm_required_score_mvm
	#define LADDER_REQUIRED_SCORE &tf_mm_required_score_ladder
	#define CASUAL_REQUIRED_SCORE &tf_mm_required_score_ladder
#else
	#define MVM_REQUIRED_SCORE (ConVar*)NULL
	#define LADDER_REQUIRED_SCORE (ConVar*)NULL
	#define CASUAL_REQUIRED_SCORE (ConVar*)NULL
#endif

#ifdef GC_DLL
#include "tf_matchmaker.h"
#include "tf_party.h"

using namespace GCSDK;
extern GCConVar tf_mm_scoring_ladder_skillrating_delta_max_high;
extern GCConVar tf_mm_scoring_ladder_skillrating_delta_max;
extern GCConVar tf_mm_required_score_mvm;
extern GCConVar tf_mm_required_score_ladder;
extern GCConVar tf_mm_required_score_pvp;

// Predicate for below filters
typedef std::function< bool(const CTFMemcachedLobbyFormerMember &) > FilterLeftMember_t;

// Helper that finds any party members that appear in the given match's m_mapFormerMembersByAccountID as having left the
// match, and calls the given predicate on them.
//
// Returns true if no party members are in the former member list with a match-leave flag, or they all pass the
// predicate.
//
// Returns false and stops iterating if predicate fails.
static bool BCheckLeftMatchMembersAgainstParty( const MatchDescription_t *pMatch,
                                                const MatchParty_t *pParty,
                                                const FilterLeftMember_t &predicate )
{
	FOR_EACH_VEC( pParty->m_vecMembers, idxMember )
	{
		const MatchParty_t::Member_t &member = pParty->m_vecMembers[ idxMember ];
		UtlHashHandle_t idx = pMatch->m_mapFormerMembersByAccountID.Find( member.m_steamID.GetAccountID() );
		if ( pMatch->m_mapFormerMembersByAccountID.IsValidHandle( idx ) )
		{
			const CTFMemcachedLobbyFormerMember &formerMember = pMatch->m_mapFormerMembersByAccountID[ idx ];
			// Only care about former members that left a match this lobby was visiting
			if ( !formerMember.has_left_match_time() )
				{ continue; }

			if ( !predicate( formerMember ) )
			{
				return false;
			}
		}
	}

	return true;
}

// Helper that finds any newly-added (not existing incomplete-match-party) members of the given match description that
// appear in  m_mapFormerMembersByAccountID as having left the match previously, and calls the given predicate on them.
//
// Returns true if no new match members appear in the former member list with a match-leave flag, or they all pass the
// predicate.
//
// Returns false and stops iterating if predicate fails.
static bool BCheckLeftMatchMembersAgainstNewlyAddedMembers( const MatchDescription_t *pMatch,
                                                            const FilterLeftMember_t &predicate )
{
	FOR_EACH_VEC( pMatch->m_vecParties, idx )
	{
		auto *pParty = pMatch->m_vecParties[ idx ];
		// If this party is not an incomplete match party (and thus already in the match), run the check
		if ( !pParty->m_bIncompleteMatchParty && !BCheckLeftMatchMembersAgainstParty( pMatch, pParty, predicate ) )
		{
			return false;
		}
	}

	return true;
}

// Shared helper for the casual modes to have a consistent rejoin policy
static bool BThreadedFormerMemberMayRejoinJoinCasualOrMvMMatch( const CTFMemcachedLobbyFormerMember& member )
{
	RTime32 rtNow = CRTime::RTime32TimeCur();
	RTime32 rtLeftLobby = member.left_lobby_time();
	uint32_t unRejoinTimeout = (uint32_t)Max( tf_mm_casual_rejoin_cooldown_secs.GetInt(), 0 );

	if ( unRejoinTimeout && rtLeftLobby != 0 &&
	     rtLeftLobby + unRejoinTimeout > rtNow )
	{
		// Rejoin too soon after leaving lobby
		return false;
	}

	uint32_t unVoteKickTimeout = (uint32_t)Max( tf_mm_casual_rejoin_cooldown_votekick_secs.GetInt(), 0 );
	RTime32 rtLeftMatch = member.left_match_time();
	TFMatchLeaveReason eLeftMatchReason = member.left_match_reason();
	if ( unVoteKickTimeout &&
	     rtLeftMatch != 0 &&
	     ( eLeftMatchReason == TFMatchLeaveReason_VOTE_KICK ||
	       eLeftMatchReason == TFMatchLeaveReason_ADMIN_KICK ) &&
	     rtLeftMatch + unVoteKickTimeout > rtNow )
	{
		// Too soon after votekick
		return false;
	}

	return true;
}

int IMatchGroupDescription::GetServerPoolIndex( EMatchGroup eGroup, EMMServerMode eMode ) const
{
	int nResult = (int)eGroup;
	switch ( eMode )
	{
	case eMMServerMode_Idle:
	{
		nResult = k_nGameServerPool_Idle;
	}
	break;

	case eMMServerMode_Full:
	{
		COMPILE_TIME_ASSERT( (int)k_nMatchGroup_MvM_Practice + (int)k_nGameServerPool_Full_First == (int)k_nGameServerPool_MvM_Practice_Full );
		nResult += k_nGameServerPool_MvM_Practice_Full;
		Assert( nResult >= k_nGameServerPool_Full_First );
		Assert( nResult <= k_nGameServerPool_Full_Last );
		return nResult;
	}
	break;

	case eMMServerMode_Incomplete_Match:
	{
		COMPILE_TIME_ASSERT( (int)k_nMatchGroup_MvM_Practice + (int)k_nGameServerPool_Incomplete_Match_First == (int)k_nGameServerPool_MvM_Practice_Incomplete_Match );
		nResult += k_nGameServerPool_Incomplete_Match_First;
		Assert( nResult >= k_nGameServerPool_Incomplete_Match_First );
		Assert( nResult <= k_nGameServerPool_Incomplete_Match_Last );
	}
	break;

	default:
		Assert( false );
	}

	return nResult;
}
#endif

#ifdef GAME_DLL

bool IMatchGroupDescription::InitServerSettingsForMatch( const CTFGSLobby* pLobby ) const
{
	// Setting servercfgfile to our mode-specific config causes the server to exec it once it finishes
	// loading the map from the changelevel below
	servercfgfile.SetValue( m_params.m_pszExecFileName );
	lservercfgfile.SetValue( m_params.m_pszExecFileName );

	return TFGameRules()->StartManagedMatch();
}
#endif

#ifdef CLIENT_DLL

#ifdef STAGING_ONLY
void cc_tf_test_pvp_rank_xp_change( IConVar *pConVar, const char *pOldString, float flOldValue )
{
	IGameEvent *pEvent = gameeventmanager->CreateEvent( "experience_changed" );
	if ( pEvent )
	{
		gameeventmanager->FireEventClientSide( pEvent );
	}
}
ConVar tf_test_pvp_rank_xp_change( "tf_test_pvp_rank_xp_change", "-1", 0, "Force your experience to a specific value", cc_tf_test_pvp_rank_xp_change );


CON_COMMAND_F( tf_progression_set_xp_to_level, "Overrides your XP to be within the range the level specified", FCVAR_CHEAT )
{
	if ( args.ArgC() != 3 )
	{
		Msg( "Usage tf_progression_set_xp_to_level <matchgroup> <level>\n" );
		return;
	}

	const IMatchGroupDescription* pMatch = GetMatchGroupDescription( (EMatchGroup)atoi( args[1] ) );
	if ( !pMatch || !pMatch->m_pProgressionDesc )
		return;

	const LevelInfo_t& level = pMatch->m_pProgressionDesc->GetLevelByNumber( atoi( args[2] ) );
	tf_test_pvp_rank_xp_change.SetValue( RandomInt( level.m_nStartXP, level.m_nEndXP ) );

	IGameEvent *pEvent = gameeventmanager->CreateEvent( "experience_changed" );
	if ( pEvent )
	{
		gameeventmanager->FireEventClientSide( pEvent );
	}

	pEvent = gameeventmanager->CreateEvent( "begin_xp_lerp" );
	if ( pEvent )
	{
		gameeventmanager->FireEventClientSide( pEvent );
	}
}

CON_COMMAND_F( tf_progression_set_xp_to_value, "Overrides your XP to be a specific value", FCVAR_CHEAT )
{
	if ( args.ArgC() != 3 )
	{
		Msg( "Usage tf_progression_set_xp_to_level <matchgroup> <value>\n" );
		return;
	}

	const IMatchGroupDescription* pMatch = GetMatchGroupDescription( (EMatchGroup)atoi( args[1] ) );
	if ( !pMatch || !pMatch->m_pProgressionDesc )
		return;

	tf_test_pvp_rank_xp_change.SetValue( atoi( args[2] ) );

	IGameEvent *pEvent = gameeventmanager->CreateEvent( "experience_changed" );
	if ( pEvent )
	{
		gameeventmanager->FireEventClientSide( pEvent );
	}

	pEvent = gameeventmanager->CreateEvent( "begin_xp_lerp" );
	if ( pEvent )
	{
		gameeventmanager->FireEventClientSide( pEvent );
	}
}
#endif // STAGING_ONLY
#endif // CLIENT_DLL

// Casual XP constants
const float flAverageXPPerGame = 500.f;
const float flAverageMinutesPerGame = 30;

// The target XP per minute
const float flTargetXPPM = (float)flAverageXPPerGame / (float)flAverageMinutesPerGame;

// The target breakdown at the end of a match
const float flScoreXPScale				= 0.4485f;
const float flObjectiveXPScale			= 0.15f;
const float flMatchCompletionXPScale	= 0.3f;

// These come from the first 4 weeks of MyM match data
const float flAvgPPMPM = 27.f;	// Points per minute per match
const float flAvgPPMPP = 1.15f;	// Points per minute per player (above / 24)

const XPSourceDef_t g_XPSourceDefs[] = { { "MatchMaking.XPChime", "TF_XPSource_PositiveFormat", "#TF_XPSource_Score", flTargetXPPM * flScoreXPScale / flAvgPPMPP					/* 6.5  */ }	// SOURCE_SCORE = 0;
									   , { "MatchMaking.XPChime", "TF_XPSource_PositiveFormat", "#TF_XPSource_ObjectiveBonus", flTargetXPPM * flObjectiveXPScale / flAvgPPMPM		/* 0.0926  */ }	// SOURCE_OBJECTIVE_BONUS = 1;
									   , { "MatchMaking.XPChime", "TF_XPSource_PositiveFormat", "#TF_XPSource_CompletedMatch", flTargetXPPM * flMatchCompletionXPScale / flAvgPPMPM /* 0.185 */ }	// SOURCE_COMPLETED_MATCH = 2;
									   , { "MVM.PlayerDied", "TF_XPSource_NoValueFormat", "#TF_XPSource_Comp_Abandon", 1.f }																// SOURCE_COMPETITIVE_ABANDON = 3;
									   , { "MatchMaking.XPChime", "TF_XPSource_NoValueFormat", "#TF_XPSource_Comp_Win", 1.f }																// SOURCE_COMPETITIVE_WIN = 4;
									   , { NULL, "TF_XPSource_NoValueFormat", "#TF_XPSource_Comp_Loss", 1.f }																			// SOURCE_COMPETITIVE_LOSS = 5;
									   , { "MatchMaking.XPChime", "TF_XPSource_PositiveFormat", "#TF_XPSource_Autobalance_Bonus", 1.f } };														// SOURCE_AUTOBALANCE_BONUS = 6;

IProgressionDesc::IProgressionDesc( EMatchGroup eMatchGroup
								  , const char* pszBadgeName
								  , const char* pszProgressionResFile 
								  , const char* pszLevelToken )
	: m_eMatchGroup( eMatchGroup )
	, m_strBadgeName( pszBadgeName )
	, m_pszProgressionResFile( pszProgressionResFile )
	, m_pszLevelToken( pszLevelToken )
{}


#ifdef CLIENT_DLL
void IProgressionDesc::EnsureBadgePanelModel( CBaseModelPanel *pModelPanel ) const
{
	studiohdr_t* pHDR = pModelPanel->GetStudioHdr();
	if ( !pHDR || !(CUtlString( pHDR->name ).UnqualifiedFilename() == m_strBadgeName.UnqualifiedFilename()) )
	{
		pModelPanel->SetMDL( m_strBadgeName );
	}
}

const LevelInfo_t& IProgressionDesc::YieldingGetLevelForSteamID( const CSteamID& steamID ) const
{
	return GetLevelForExperience( GetPlayerExperienceBySteamID( steamID ) );
}
#endif // CLIENT_DLL

const LevelInfo_t& IProgressionDesc::GetLevelByNumber( uint32 nNumber ) const
{
	int nIndex = nNumber;
	nIndex = Clamp( nIndex - 1, 0, m_vecLevels.Count() - 1 );
	Assert( nIndex >= 0 && nIndex < m_vecLevels.Count() );
	return m_vecLevels[ nIndex ];
};

const LevelInfo_t& IProgressionDesc::GetLevelForExperience( uint32 nExperience ) const
{
	uint32 nNumLevels = (uint32)m_vecLevels.Count();
	// Walk the levels to find where the passed in experience value falls
	for( uint32 i=0; i<nNumLevels; ++i )
	{
		if ( nExperience >= m_vecLevels[ i ].m_nStartXP && ( nExperience < m_vecLevels[ i ].m_nEndXP || (i + 1) == nNumLevels ) )
		{
			return m_vecLevels[ i ];
		}
	}

	Assert( false );
	return m_vecLevels[ 0 ];
}

class CMvMMatchGroupDescription : public IMatchGroupDescription
{
	public:
		CMvMMatchGroupDescription( EMatchGroup eMatchGroup, const char* pszConfig, bool bTrustedOnly )
			: IMatchGroupDescription( eMatchGroup
									  , { eMatchMode_MatchMaker_LateJoinDropIn // m_eLateJoinMode;
									  , eMMPenaltyPool_Casual // m_ePenaltyPool
									  , false				  // m_bUsesSkillRatings;
									  , false				  // m_bSupportsLowPriorityQueue;
									  , false				  // m_bRequiresMatchID;
									  , MVM_REQUIRED_SCORE	  // m_pmm_required_score;
									  , false				  // m_bUseMatchHud;
									  , pszConfig			  // m_pszExecFileName;
									  , &tf_mm_match_size_mvm // m_pmm_match_group_size;
									  , NULL				  // m_pmm_match_group_size_minimum;
									  , MATCH_TYPE_MVM		  // m_eMatchType;
									  , false				  // m_bShowPreRoundDoors;
									  , false				  // m_bShowPostRoundDoors;
									  , NULL				  // m_pszMatchEndKickWarning;
									  , NULL				  // m_pszMatchStartSound;
									  , false				  // m_bAutoReady;
									  , false				  // m_bShowRankIcons;
									  , false				  // m_bUseMatchSummaryStage;
									  , false				  // m_bDistributePerformanceMedals;
									  , false				  // m_bIsCompetitiveMode;
									  , false				  // m_bUseFirstBlood;
									  , false				  // m_bUseReducedBonusTime;
									  , false				  // m_bUseAutoBalance;
									  , false				  // m_bAllowTeamChange;
									  , true				  // m_bRandomWeaponCrits;
									  , false				  // m_bFixedWeaponSpread;
									  , false				  // m_bRequireCompleteMatch;
									  , bTrustedOnly		  // m_bTrustedServersOnly;
									  , false				  // m_bForceClientSettings;
									  , false				  // m_bAllowDrawingAtMatchSummary
									  , true				  // m_bAllowSpecModeChange
									  , false				  // m_bAutomaticallyRequeueAfterMatchEnds
									  , false				  // m_bUsesMapVoteOnRoundEnd
									  , false				  // m_bUsesXP
									  , false				  // m_bUsesDashboardOnRoundEnd
									  , false				  // m_bUsesSurveys
									  , false } )			  // m_bStrictMatchmakerScoring
		{}

#ifdef GC_DLL
	virtual EMMRating PrimaryMMRatingBackend() const OVERRIDE { return k_nMMRating_Invalid; }
	virtual const std::vector< EMMRating > &MatchResultRatingBackends() const OVERRIDE
	{
		static std::vector< EMMRating > mvmRatings = { /* crickets */ };
		return mvmRatings;
	}

	// Copy the party's search challenges
	bool InitMatchFromParty( MatchDescription_t* pMatch, const MatchParty_t* pParty ) const OVERRIDE
	{
		pMatch->m_setAcceptableChallenges = pParty->m_setSearchChallenges;

#ifdef USE_MVM_TOUR
		if ( pMatch->m_eMatchGroup == k_nMatchGroup_MvM_MannUp )
		{
			Assert( pParty->m_iMannUpTourOfDuty >= 0 );
			pMatch->m_iMannUpTourOfDuty = pParty->m_iMannUpTourOfDuty;
		}
		else
		{
			Assert( pParty->m_iMannUpTourOfDuty == k_iMvmTourIndex_NotMannedUp );
			pMatch->m_iMannUpTourOfDuty = k_iMvmTourIndex_NotMannedUp;
		}
#endif // USE_MVM_TOUR
		return true;
	}

	virtual bool InitMatchFromLobby( MatchDescription_t* pMatch, CTFLobby* pLobby ) const OVERRIDE 
	{ 
		pMatch->m_setAcceptableChallenges.Clear();
		pMatch->m_setAcceptableChallenges.SetMissionBySchemaIndex( pLobby->GetMissionIndex(), true );

#ifdef USE_MVM_TOUR
		if ( pLobby->GetMatchGroup() == k_nMatchGroup_MvM_MannUp )
		{
			pMatch->m_iMannUpTourOfDuty = pLobby->GetMannUpTourIndex();
		}
		else
		{
			Assert( pLobby->GetMannUpTourIndex() == k_iMvmTourIndex_NotMannedUp );
		}
#endif // USE_MVM_TOUR

		return true;
	}

	// Sync selected MvM challenges
	virtual void SyncMatchParty( const CTFParty *pParty, MatchParty_t *pMatchParty ) const OVERRIDE
	{
		pParty->GetSearchChallenges( pMatchParty->m_setSearchChallenges );
	}

	// Go through our selected challenges and pick a random challenge then a random popfile from the chosen challenge
	virtual void SelectModeSpecificParameters( const MatchDescription_t* pMatch, CTFLobby* pLobby ) const OVERRIDE
	{
		if ( !pMatch )
			return;

		int nCountPops = GetItemSchema()->GetMvmMissions().Count();
		int nSelectedChallenge = -1;
		nSelectedChallenge = -1;

		int n = 0;
		for ( int i = 0 ; i < nCountPops ; ++i )
		{
			if ( pMatch->m_setAcceptableChallenges.GetMissionBySchemaIndex( i ) )
			{
				int r = RandomInt( 0, n );
				if ( r == 0 )
				{
					nSelectedChallenge = i;
				}
				++n;
			}
		}

		// We *should* have chosen one by now, unless the schema is hosed.
		// But if we haven't, force it to be selected now
		if ( nSelectedChallenge < 0 )
		{
			Assert( nSelectedChallenge >= 0 );
			nSelectedChallenge = RandomInt( 0, nCountPops-1 );
		}

		Assert( nSelectedChallenge >= 0 );
		pLobby->SetMapName( GetItemSchema()->GetMvmMissions()[ nSelectedChallenge ].m_sMapNameActual.Get() );
		pLobby->SetMissionName( GetItemSchema()->GetMvmMissions()[ nSelectedChallenge ].m_sPop.Get() );
#ifdef USE_MVM_TOUR
		if ( pMatch->m_eMatchGroup == k_nMatchGroup_MvM_MannUp )
		{
			Assert( pMatch->m_iMannUpTourOfDuty >= 0 );
			pLobby->SetMannUpTourName( GetItemSchema()->GetMvmTours()[pMatch->m_iMannUpTourOfDuty].m_sTourInternalName.Get() );
		}
		else
		{
			Assert( pMatch->m_iMannUpTourOfDuty == k_iMvmTourIndex_NotMannedUp );
		}
#endif // USE_MVM_TOUR
	}

	// Check MvM challenges have an intersection between the current and searching parties
	virtual bool BThreadedPartyCompatibleWithMatch( const MatchDescription_t* pMatch, const MatchParty_t *pCandidateParty ) const OVERRIDE
	{
		// Check for blacklisted former members that tank compatibility
		if ( !BCheckLeftMatchMembersAgainstParty( pMatch, pCandidateParty, &BThreadedFormerMemberMayRejoinJoinCasualOrMvMMatch) )
			{ return false; }

#ifdef USE_MVM_TOUR
		return pCandidateParty->m_iMannUpTourOfDuty == pMatch->m_iMannUpTourOfDuty;
#endif // USE_MVM_TOUR

		return pMatch->m_setAcceptableChallenges.HasIntersection( pCandidateParty->m_setSearchChallenges );
	}

	virtual bool BThreadedPartiesCompatible( const MatchParty_t *pLeftParty, const MatchParty_t *pRightParty ) const OVERRIDE
	{
#ifdef USE_MVM_TOUR
		if ( pLeftParty->m_iMannUpTourOfDuty != pRightParty->m_iMannUpTourOfDuty )
			return false;
#endif // USE_MVM_TOUR

		return !pLeftParty->m_setSearchChallenges.HasIntersection( pRightParty->m_setSearchChallenges );
	}

	// Intersect MvM challenges
	bool BThreadedIntersectMatchWithParty( MatchDescription_t* pMatch, const MatchParty_t* pParty ) const OVERRIDE
	{
		// Check for blacklisted former members that tank compatibility
		if ( !BCheckLeftMatchMembersAgainstParty( pMatch, pParty, &BThreadedFormerMemberMayRejoinJoinCasualOrMvMMatch) )
			{ return false; }

		pMatch->m_setAcceptableChallenges.Intersect( pParty->m_setSearchChallenges );
		if ( pMatch->m_setAcceptableChallenges.IsEmpty() )
			return false;

#ifdef USE_MVM_TOUR
		if ( pMatch->m_eMatchGroup == k_nMatchGroup_MvM_MannUp )
		{
			Assert( pParty->m_iMannUpTourOfDuty >= 0 );
			if ( pMatch->m_iMannUpTourOfDuty != pParty->m_iMannUpTourOfDuty )
				return false;
		}
		else
		{
			Assert( pParty->m_iMannUpTourOfDuty == k_iMvmTourIndex_NotMannedUp );
		}
#endif // USE_MVM_TOUR

		return true;
	}

	virtual void GetServerDetails( const CMsgGameServerMatchmakingStatus& msg, int& nChallengeIndex, const char* pszMap ) const OVERRIDE
	{
		if ( msg.matchmaking_state() == ServerMatchmakingState_EMPTY ) // if we're empty, we can switch the challenge, so the current value doesn't matter
		{
			pszMap = "";
		}
		else
		{
			nChallengeIndex = GetItemSchema()->FindMvmMissionByName( pszMap );
		}
	}

	virtual const char* GetUnauthorizedPartyReason( CTFParty* pParty ) const OVERRIDE
	{
		pParty->CheckRemoveInvalidSearchChallenges();
		CMvMMissionSet searchChallenges;
		pParty->GetSearchChallenges( searchChallenges );
		if ( searchChallenges.IsEmpty() )
		{
			return "They want to play MvM, but set of search challenges is empty.";
		}

		if ( pParty->GetMatchGroup() == k_nMatchGroup_MvM_MannUp )
		{
			TFPartyManager()->YldUpdatePartyMemberData( pParty );
			if ( pParty->BAnyMemberWithoutTicket() )
			{
				return "They want to play MannUp, but somebody doesn't have a ticket.";
			}

#ifdef USE_MVM_TOUR
			// Make sure we know what tour of duty the want to play
			if ( pParty->GetSearchMannUpTourIndex() < 0 )
			{
				return "They want to play MannUp, but no tour of duty specified.";
			}
#endif // USE_MVM_TOUR
		}
		
		return NULL;
	}

	virtual void Dump( const char *pszLeader, int nSpewLevel, int nLogLevel, const MatchParty_t* pMatch ) const OVERRIDE
	{
		CUtlString sSelectedPops;
		int n = 0;
		for ( int i = 0 ; i < GetItemSchema()->GetMvmMissions().Count() ; ++i )
		{
			if ( pMatch->m_setSearchChallenges.GetMissionBySchemaIndex( i ) )
			{
				if ( n > 0 )
					sSelectedPops += ", ";
				if ( n >= 5  )
				{
					sSelectedPops += "...";
					break;
				}
				sSelectedPops += GetItemSchema()->GetMvmMissionName( i );
				++n;
			}
		}
		EmitInfo( SPEW_GC, nSpewLevel, nLogLevel, "%s  MvM Type: %s    Search Pop: %s\n", pszLeader,
		          ( m_eMatchGroup == k_nMatchGroup_MvM_MannUp ? "Mann Up" : ( m_eMatchGroup == k_nMatchGroup_MvM_Practice ? "Bootcamp" : "UNKNOWN" ) ),
		          sSelectedPops.String() );
		EmitInfo( SPEW_GC, nSpewLevel, nLogLevel, "%s  Best valve data center ping: %.0fms\n", pszLeader, pMatch->m_flPingClosestServer );
	}
#endif

#ifdef CLIENT_DLL
	virtual bool BGetRoundStartBannerParameters( int& nSkin, int& nBodyGroup ) const OVERRIDE
	{
		// Dont show in MvM...for now
		return false;
	}

	virtual bool BGetRoundDoorParameters( int& nSkin, int& nLogoBodyGroup ) const OVERRIDE
	{
		// Don't show in MvM...for now
		return false;
	}

	virtual const char *GetMapLoadBackgroundOverride( bool bWidescreen ) const OVERRIDE
	{
		if ( bWidescreen )
		{
			return NULL;
		}

		return "mvm_background_map";
	}
#endif

#ifdef GAME_DLL
	virtual bool InitServerSettingsForMatch( const CTFGSLobby* pLobby ) const OVERRIDE
	{
		bool bRet = IMatchGroupDescription::InitServerSettingsForMatch( pLobby );

		if ( *pLobby->GetMissionName() != '\0' )
		{
			TFGameRules()->SetNextMvMPopfile( pLobby->GetMissionName() );
		}

		return bRet;
	}

	virtual void PostMatchClearServerSettings() const OVERRIDE
	{

	}

	virtual void InitGameRulesSettings() const OVERRIDE
	{
	}

	virtual void InitGameRulesSettingsPostEntity() const OVERRIDE
	{
	}

	bool ShouldRequestLateJoin() const OVERRIDE
	{
		if ( !TFGameRules() || !TFGameRules()->IsMannVsMachineMode() )
			return false;

		// Check game state
		switch ( TFGameRules()->State_Get() )
		{
		case GR_STATE_INIT:
		case GR_STATE_PREGAME:
		case GR_STATE_STARTGAME:
		case GR_STATE_PREROUND:
		case GR_STATE_TEAM_WIN:
		case GR_STATE_RESTART:
		case GR_STATE_STALEMATE:
		case GR_STATE_BONUS:
		case GR_STATE_BETWEEN_RNDS:
			return true;

		case GR_STATE_RND_RUNNING:
			if ( TFObjectiveResource() &&
			     !TFObjectiveResource()->GetMannVsMachineIsBetweenWaves() &&
			     TFObjectiveResource()->GetMannVsMachineWaveCount() == TFObjectiveResource()->GetMannVsMachineMaxWaveCount() )
			{
				int nMaxEnemyCountNoSupport = TFObjectiveResource()->GetMannVsMachineWaveEnemyCount();
				if ( nMaxEnemyCountNoSupport <= 0 )
				{
					Assert( false ); // no enemies in wave?!
					return false;
				}

				// calculate number of remaining enemies
				int nNumEnemyRemaining = 0;

				for ( int i = 0; i < MVM_CLASS_TYPES_PER_WAVE_MAX_NEW; ++i )
				{
					int nClassCount = TFObjectiveResource()->GetMannVsMachineWaveClassCount( i );
					unsigned int iFlags = TFObjectiveResource()->GetMannVsMachineWaveClassFlags( i );

					if ( iFlags & MVM_CLASS_FLAG_MINIBOSS )
					{
						nNumEnemyRemaining += nClassCount;
					}

					if ( iFlags & MVM_CLASS_FLAG_NORMAL )
					{
						nNumEnemyRemaining += nClassCount;
					}
				}

				// if less then 40% of the last wave remains, lock people out from MM
				if ( (float)nNumEnemyRemaining / (float)nMaxEnemyCountNoSupport < 0.4f )
					return false;
			}
			return true;

		case GR_STATE_GAME_OVER:
			return false;
		}

		Assert( false );
		return false;
	}

	bool BMatchIsSafeToLeaveForPlayer( const CMatchInfo* pMatchInfo, const CMatchInfo::PlayerMatchData_t *pMatchPlayer ) const
	{
		bool bSafe = false;
		// Allow safe leaving after you have played for N seconds or if the match drops below N players, even if it is
		// still active.
		int nAllowAfterSeconds = tf_mvm_allow_abandon_after_seconds.GetInt();
		int nAllowBelowPlayers = tf_mvm_allow_abandon_below_players.GetInt();
		RTime32 now = CRTime::RTime32TimeCur();
		bSafe = bSafe || ( nAllowAfterSeconds > 0 && (uint32)nAllowAfterSeconds < ( now - pMatchPlayer->rtJoinedMatch ) );
		bSafe = bSafe || ( nAllowBelowPlayers > 0 && pMatchInfo->GetNumActiveMatchPlayers() < nAllowBelowPlayers );

		// Bootcamp is a magical nevar-abandon land
		bSafe = bSafe || ( m_eMatchGroup == k_nMatchGroup_MvM_Practice );

		return bSafe;
	}

	virtual bool BPlayWinMusic( int nWinningTeam, bool bGameOver ) const OVERRIDE 
	{
		// Not handled
		return false; 
	} 
#endif
};

class CLadderMatchGroupDescription : public IMatchGroupDescription
{
public:

	class CLadderProgressionDesc : public IProgressionDesc
	{
	public:
		CLadderProgressionDesc( EMatchGroup eMatchGroup )
			: IProgressionDesc( eMatchGroup
							  , "models/vgui/competitive_badge.mdl"
							  , "resource/ui/PvPCompRankPanel.res"
							  , "TF_Competitive_Rank" )
		{
			// Bucket 1
			m_vecLevels.AddToTail( { 1,		k_unDrilloRating_Ladder_Min,		11500, "competitive/competitive_badge_rank001", "#TF_Competitive_Rank_1",  "MatchMaking.RankOneAchieved",	"competitive/comp_background_tier001a" } );
			m_vecLevels.AddToTail( { 2,		m_vecLevels.Tail().m_nEndXP,		13000, "competitive/competitive_badge_rank002", "#TF_Competitive_Rank_2",  "MatchMaking.RankOneAchieved",	"competitive/comp_background_tier001a" } );
			m_vecLevels.AddToTail( { 3,		m_vecLevels.Tail().m_nEndXP,		14500, "competitive/competitive_badge_rank003", "#TF_Competitive_Rank_3",  "MatchMaking.RankOneAchieved",	"competitive/comp_background_tier001a" } );
			m_vecLevels.AddToTail( { 4,		m_vecLevels.Tail().m_nEndXP,		16000, "competitive/competitive_badge_rank004", "#TF_Competitive_Rank_4",  "MatchMaking.RankOneAchieved",	"competitive/comp_background_tier002a" } );
			m_vecLevels.AddToTail( { 5,		m_vecLevels.Tail().m_nEndXP,		17500, "competitive/competitive_badge_rank005", "#TF_Competitive_Rank_5",  "MatchMaking.RankOneAchieved",	"competitive/comp_background_tier002a" } );
			m_vecLevels.AddToTail( { 6,		m_vecLevels.Tail().m_nEndXP,		19500, "competitive/competitive_badge_rank006", "#TF_Competitive_Rank_6",  "MatchMaking.RankOneAchieved",	"competitive/comp_background_tier002a" } );
			// Bucket 2
			m_vecLevels.AddToTail( { 7,		m_vecLevels.Tail().m_nEndXP,		21500, "competitive/competitive_badge_rank007", "#TF_Competitive_Rank_7",  "MatchMaking.RankTwoAchieved",	"competitive/comp_background_tier003a" } );
			m_vecLevels.AddToTail( { 8,		m_vecLevels.Tail().m_nEndXP,		23500, "competitive/competitive_badge_rank008", "#TF_Competitive_Rank_8",  "MatchMaking.RankTwoAchieved",	"competitive/comp_background_tier003a" } );
			m_vecLevels.AddToTail( { 9,		m_vecLevels.Tail().m_nEndXP,		25500, "competitive/competitive_badge_rank009", "#TF_Competitive_Rank_9",  "MatchMaking.RankTwoAchieved",	"competitive/comp_background_tier003a" } );
			m_vecLevels.AddToTail( { 10,	m_vecLevels.Tail().m_nEndXP,		28000, "competitive/competitive_badge_rank010", "#TF_Competitive_Rank_10", "MatchMaking.RankTwoAchieved",	"competitive/comp_background_tier004a" } );
			m_vecLevels.AddToTail( { 11,	m_vecLevels.Tail().m_nEndXP,		30500, "competitive/competitive_badge_rank011", "#TF_Competitive_Rank_11", "MatchMaking.RankTwoAchieved",	"competitive/comp_background_tier004a" } );
			m_vecLevels.AddToTail( { 12,	m_vecLevels.Tail().m_nEndXP,		33000, "competitive/competitive_badge_rank012", "#TF_Competitive_Rank_12", "MatchMaking.RankTwoAchieved",	"competitive/comp_background_tier004a" } );
			// Bucket 3
			m_vecLevels.AddToTail( { 13,	m_vecLevels.Tail().m_nEndXP,		35500, "competitive/competitive_badge_rank013", "#TF_Competitive_Rank_13", "MatchMaking.RankThreeAchieved",	"competitive/comp_background_tier005a" } );
			m_vecLevels.AddToTail( { 14,	m_vecLevels.Tail().m_nEndXP,		38000, "competitive/competitive_badge_rank014", "#TF_Competitive_Rank_14", "MatchMaking.RankThreeAchieved",	"competitive/comp_background_tier005a" } );
			m_vecLevels.AddToTail( { 15,	m_vecLevels.Tail().m_nEndXP,		40500, "competitive/competitive_badge_rank015", "#TF_Competitive_Rank_15", "MatchMaking.RankThreeAchieved",	"competitive/comp_background_tier005a" } );
			m_vecLevels.AddToTail( { 16,	m_vecLevels.Tail().m_nEndXP,		43500, "competitive/competitive_badge_rank016", "#TF_Competitive_Rank_16", "MatchMaking.RankThreeAchieved",	"competitive/comp_background_tier006a" } );
			m_vecLevels.AddToTail( { 17,	m_vecLevels.Tail().m_nEndXP,		46500, "competitive/competitive_badge_rank017", "#TF_Competitive_Rank_17", "MatchMaking.RankThreeAchieved",	"competitive/comp_background_tier006a" } );
			// Bucket 4
			m_vecLevels.AddToTail( { 18,	m_vecLevels.Tail().m_nEndXP,		50000, "competitive/competitive_badge_rank018", "#TF_Competitive_Rank_18", "MatchMaking.RankFourAchieved",	"competitive/comp_background_tier006a" } );
		}

		const LevelInfo_t& GetLevelForExperience( uint32 nExperience ) const OVERRIDE
		{
			FixmeMMRatingBackendSwapping(); // Hard-coded drillo

			// The client may not have a rating yet, in which case they see 0 until they've been in a match. For level
			// purposes, return minimum.
			return IProgressionDesc::GetLevelForExperience( nExperience == 0 ? k_unDrilloRating_Ladder_Min : nExperience );
		}

#ifdef CLIENT_DLL
		virtual void SetupBadgePanel( CBaseModelPanel *pModelPanel, const LevelInfo_t& level ) const OVERRIDE
		{
			if ( !pModelPanel )
				return;

			int nLevelIndex = level.m_nLevelNum - 1;
			int nSkin = nLevelIndex;
			int nSkullsBodygroup	= ( nLevelIndex % 6 );
			int nSparkleBodygroup	= 0;
			if ( level.m_nLevelNum == 18 ) nSparkleBodygroup = 1;
			EnsureBadgePanelModel( pModelPanel );

			int nBody = 0;
			CStudioHdr studioHDR( pModelPanel->GetStudioHdr(), g_pMDLCache );

			::SetBodygroup( &studioHDR, nBody, ::FindBodygroupByName( &studioHDR, "skulls" ), nSkullsBodygroup );
			::SetBodygroup( &studioHDR, nBody, ::FindBodygroupByName( &studioHDR, "sparkle" ), nSparkleBodygroup );

			pModelPanel->SetBody( nBody );
			pModelPanel->SetSkin( nSkin );
		}

		virtual const uint32 GetLocalPlayerLastAckdExperience() const OVERRIDE
		{
			// This is bad and hard-coding a match group. We should just make XP a rating type and these functions
			// should just say "use this rating for XP"/"use this rating for acked XP"
			FixmeMMRatingBackendSwapping();
#if defined STAGING_ONLY
			if ( tf_test_pvp_rank_xp_change.GetInt() != -1 )
			{
				return tf_test_pvp_rank_xp_change.GetInt();
			}
#endif
			if ( !steamapicontext || !steamapicontext->SteamUser() )
			{
				return 0u;
			}

#ifndef CLIENT_DLL
			#error Make this call a yielding call if you are removing it from client ifdefs
#endif
			CTFRatingData *pRating = CTFRatingData::YieldingGetPlayerRatingDataBySteamID( steamapicontext->SteamUser()->GetSteamID(),
			                                                                              k_nMMRating_6v6_DRILLO_PlayerAcknowledged );
			return pRating ? pRating->GetRatingData().unRatingPrimary : 0u;
		}

		virtual const uint32 GetPlayerExperienceBySteamID( CSteamID steamid ) const OVERRIDE
		{
			// This is bad and hard-coding a match group. We should just make XP a rating type and these functions
			// should just say "use this rating for XP"/"use this rating for acked XP"
			FixmeMMRatingBackendSwapping();
#if defined CLIENT_DLL && defined STAGING_ONLY
			if ( tf_test_pvp_rank_xp_change.GetInt() != -1 )
			{
				return tf_test_pvp_rank_xp_change.GetInt();
			}
#endif

#ifndef CLIENT_DLL
			#error Make this call a yielding call if you are removing it from client ifdefs
#endif
			CTFRatingData *pRating = CTFRatingData::YieldingGetPlayerRatingDataBySteamID( steamapicontext->SteamUser()->GetSteamID(),
			                                                                              k_nMMRating_6v6_DRILLO );

			return pRating ? pRating->GetRatingData().unRatingPrimary : 0u;
		}
#endif // CLIENT_DLL

#if defined GC
		virtual bool BYldAcknowledgePlayerXPOnTransaction( CSQLAccess &transaction,
		                                                   CTFSharedObjectCache *pLockedSOCache ) const OVERRIDE
		{
			// This is bad and a result of XP being just a rating in some places but a magic field elsewhere.
			FixmeMMRatingBackendSwapping();

			MMRatingData_t ratingData = pLockedSOCache->GetPlayerRatingData( k_nMMRating_6v6_DRILLO );
			MMRatingData_t ackedRatingData = pLockedSOCache->GetPlayerRatingData( k_nMMRating_6v6_DRILLO_PlayerAcknowledged );
			if ( ratingData == ackedRatingData )
				{ return true; }

			// Feed it to acknowledged rating
			return pLockedSOCache->BYieldingUpdatePlayerRating( transaction,
			                                                    k_nMMRating_6v6_DRILLO_PlayerAcknowledged,
			                                                    k_nMMRatingSource_PlayerAcknowledge,
			                                                    0,
			                                                    ratingData );
		}

		virtual const bool BRankXPIsActuallyPrimaryMMRating() const OVERRIDE
		{
			// Gross hack due to XP being magically used differently in 6v6 right now.
			FixmeMMRatingBackendSwapping();
			return true;
		}
#endif // defined GC

#if defined GC_DLL || ( defined STAGING_ONLY && defined CLIENT_DLL )
		virtual void DebugSpewLevels() const OVERRIDE
		{
			Msg( "Spewing comp levels:\n" );
	
			// Walk the levels to find where the passed in experience value falls
			for( int i=0; i< m_vecLevels.Count(); ++i )
			{
				Msg( "Level %d:\t%d - %d. (+%d)\n", m_vecLevels[i].m_nLevelNum, m_vecLevels[i].m_nStartXP, m_vecLevels[i].m_nEndXP, ( m_vecLevels[i].m_nEndXP - m_vecLevels[i].m_nStartXP ) );
			}
		}
#endif
	};

	CLadderMatchGroupDescription( EMatchGroup eMatchGroup, ConVar* pmm_match_group_size )
		:	IMatchGroupDescription( eMatchGroup
								  , { eMatchMode_MatchMaker_LateJoinMatchBased // m_eLateJoinMode;
								  , eMMPenaltyPool_Ranked	   // m_ePenaltyPool
								  , true					   // m_bUsesSkillRatings;
								  , true					   // m_bSupportsLowPriorityQueue;
								  , true					   // m_bRequiresMatchID;
								  , LADDER_REQUIRED_SCORE	   // m_pmm_required_score;
								  , true					   // m_bUseMatchHud;
								  , "server_competitive.cfg"   // m_pszExecFileName;
								  , pmm_match_group_size	   // m_pmm_match_group_size;
								  , NULL					   // m_pmm_match_group_size_minimum;
								  , MATCH_TYPE_COMPETITIVE	   // m_eMatchType;
								  , true					   // m_bShowPreRoundDoors;
								  , true					   // m_bShowPostRoundDoors;
								  , "#TF_Competitive_GameOver" // m_pszMatchEndKickWarning;
								  , "MatchMaking.RoundStart"   // m_pszMatchStartSound;
								  , false					   // m_bAutoReady;
								  , true					   // m_bShowRankIcons;
								  , true					   // m_bUseMatchSummaryStage;
								  , true					   // m_bDistributePerformanceMedals;
								  , true					   // m_bIsCompetitiveMode;
								  , true					   // m_bUseFirstBlood;
								  , true					   // m_bUseReducedBonusTime;
								  , false					   // m_bUseAutoBalance;
								  , false					   // m_bAllowTeamChange;
								  , false					   // m_bRandomWeaponCrits;
								  , true					   // m_bFixedWeaponSpread;
								  , true					   // m_bRequireCompleteMatch;
								  , true					   // m_bTrustedServersOnly;
								  , true					   // m_bForceClientSettings;
								  , true					   // m_bAllowDrawingAtMatchSummary
								  , false					   // m_bAllowSpecModeChange
								  , false					   // m_bAutomaticallyRequeueAfterMatchEnds
								  , false					   // m_bUsesMapVoteOnRoundEnd
								  , false					   // m_bUsesXP
								  , true					   // m_bUsesDashboardOnRoundEnd
								  , true					   // m_bUsesSurveys
								  , true } )				   // m_bStrictMatchmakerScoring
	{
		m_pProgressionDesc = new CLadderProgressionDesc( eMatchGroup );
	}

#ifdef GC_DLL
	virtual EMMRating PrimaryMMRatingBackend() const OVERRIDE
	{
		// Right now all ladders have this hard-coded. Live-swapping won't work either, since lobbies don't know what
		// they were formed with in Match_Result
		FixmeMMRatingBackendSwapping();
		return k_nMMRating_6v6_DRILLO;
	}

	virtual const std::vector< EMMRating > &MatchResultRatingBackends() const OVERRIDE
	{
		FixmeMMRatingBackendSwapping(); // Shouldn't be hard-coded for 6v6, param
		static std::vector< EMMRating > ladderRatings = { k_nMMRating_6v6_DRILLO, k_nMMRating_6v6_GLICKO };
		return ladderRatings;
	}

	virtual bool InitMatchFromParty( MatchDescription_t* pMatch, const MatchParty_t* pParty ) const OVERRIDE { return true; }
	virtual bool InitMatchFromLobby( MatchDescription_t* pMatch, CTFLobby* pLobby ) const OVERRIDE { return true; }
	virtual void SyncMatchParty( const CTFParty *pParty, MatchParty_t *pMatchParty ) const OVERRIDE {};
	virtual void SelectModeSpecificParameters( const MatchDescription_t* pMatch, CTFLobby* pLobby ) const OVERRIDE
	{
		// Forced to use the competitive category
		const SchemaGameCategory_t* pCategory = GetItemSchema()->GetGameCategory( kGameCategory_Competitive_6v6 );
		const char *pszMap = ( *tf_mm_ladder_force_map_by_name.GetString() ) ? tf_mm_ladder_force_map_by_name.GetString() : pCategory->GetRandomMap()->pszMapName;
		pLobby->SetMapName( pszMap );
	}

	virtual void GetServerDetails( const CMsgGameServerMatchmakingStatus& msg, int& nChallengeIndex, const char* pszMap ) const OVERRIDE
	{}

	virtual bool BThreadedPartiesCompatible( const MatchParty_t *pLeftParty, const MatchParty_t *pRightParty ) const OVERRIDE
	{
		return true;
	}

	virtual bool BThreadedPartyCompatibleWithMatch( const MatchDescription_t* pMatch, const MatchParty_t *pCurrentParty ) const OVERRIDE
	{
		// Right now there's no criteria on ladder matches, but leavers are never allowed to rejoin
		return BCheckLeftMatchMembersAgainstParty( pMatch, pCurrentParty,
		                                           [](const CTFMemcachedLobbyFormerMember& member) { return false; } );
	}

	virtual bool BThreadedIntersectMatchWithParty( MatchDescription_t* pMatch, const MatchParty_t* pParty ) const OVERRIDE
	{
		// No action on match, just check that they're compatible
		return BThreadedPartyCompatibleWithMatch( pMatch, pParty );
	}

	virtual const char* GetUnauthorizedPartyReason( CTFParty* pParty ) const OVERRIDE
	{
		TFPartyManager()->YldUpdatePartyMemberData( pParty );
		if ( pParty->BAnyMemberWithoutCompetitiveAccess() )
		{
			return "They want to play a competitive game, but somebody doesn't have competitive access";
		}

		return NULL;
	}

	virtual void Dump( const char *pszLeader, int nSpewLevel, int nLogLevel, const MatchParty_t* pMatch ) const OVERRIDE
	{
		EmitInfo( SPEW_GC, nSpewLevel, nLogLevel, "%s  Best Ladder ping: %.0fms\n", pszLeader, pMatch->m_flPingClosestServer );
	}
#endif

#ifdef CLIENT_DLL
	virtual bool BGetRoundStartBannerParameters( int& nSkin, int& nBodyGroup ) const OVERRIDE
	{
		// The comp skins start at skin 8
		nSkin = 8 + TFGameRules()->GetRoundsPlayed();
		nBodyGroup = 1;
		return true;
	}

	virtual bool BGetRoundDoorParameters( int& nSkin, int& nLogoBodyGroup ) const OVERRIDE
	{
		nLogoBodyGroup = 0;
		nSkin = 0;
		if( GTFGCClientSystem()->GetLobby() &&
			GTFGCClientSystem()->GetLobby()->Obj().average_rank() >= k_unDrilloRating_Ladder_HighSkill )
		{
			// High skill has a different skin
			nSkin = 1;
		}

		return true;
	}
	virtual const char *GetMapLoadBackgroundOverride( bool bWidescreen ) const OVERRIDE
	{
		return ( bWidescreen ? "ranked_background_widescreen" : "ranked_background" );
	}
#endif

#ifdef GAME_DLL

	virtual void PostMatchClearServerSettings() const OVERRIDE
	{
		Assert( TFGameRules() );
		TFGameRules()->EndCompetitiveMatch();
	}

	virtual void InitGameRulesSettings() const OVERRIDE
	{
		TFGameRules()->SetCompetitiveMode( true );
		TFGameRules()->SetAllowBetweenRounds( true );
	}

	virtual void InitGameRulesSettingsPostEntity() const OVERRIDE
	{
		CTeamControlPointMaster *pMaster = ( g_hControlPointMasters.Count() ) ? g_hControlPointMasters[0] : NULL;
		bool bMultiStagePLR = ( tf_gamemode_payload.GetBool() && pMaster && pMaster->PlayingMiniRounds() && TFGameRules()->HasMultipleTrains() );
		bool bUseStopWatch = TFGameRules()->MatchmakingShouldUseStopwatchMode();
		bool bCTF = tf_gamemode_ctf.GetBool();
		bool bHighSkill = GTFGCClientSystem()->GetMatch() && GTFGCClientSystem()->GetMatch()->m_uAverageRank >= k_unDrilloRating_Ladder_HighSkill;

		// Exec our match settings
		const char *pszExecFile = ( bHighSkill ) ? "server_competitive_rounds_win_conditions_high_skill.cfg" : "server_competitive_rounds_win_conditions.cfg";
		
		if ( bUseStopWatch )
		{
			pszExecFile = ( bHighSkill ) ? "server_competitive_stopwatch_win_conditions_high_skill.cfg" : "server_competitive_stopwatch_win_conditions.cfg";
		}
		else if ( bMultiStagePLR || bCTF )
		{
			pszExecFile = ( bHighSkill ) ? "server_competitive_max_rounds_win_conditions_high_skill.cfg" : "server_competitive_max_rounds_win_conditions.cfg";
		}

		engine->ServerCommand( CFmtStr( "exec %s\n", pszExecFile ) );

		TFGameRules()->SetInStopWatch( bUseStopWatch );
		mp_tournament_stopwatch.SetValue( bUseStopWatch );
	}

	bool ShouldRequestLateJoin() const OVERRIDE
	{
		auto pTFGameRules = TFGameRules();
		if ( !pTFGameRules || !pTFGameRules->IsCompetitiveMode() || pTFGameRules->IsManagedMatchEnded() )
		{
			return false;
		}

		const CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();

		int nPlayers = pMatch->GetNumActiveMatchPlayers();
		int nMissingPlayers = pMatch->GetCanonicalMatchSize() - nPlayers;

		// Allow late-join if we're not started yet, have missing players, and have not lost everyone.
		return nMissingPlayers && nPlayers &&
				(	pTFGameRules->State_Get() == GR_STATE_BETWEEN_RNDS ||
					pTFGameRules->State_Get() == GR_STATE_PREGAME ||
					pTFGameRules->State_Get() == GR_STATE_STARTGAME );
	}

	bool BMatchIsSafeToLeaveForPlayer( const CMatchInfo* pMatchInfo, const CMatchInfo::PlayerMatchData_t *pMatchPlayer ) const OVERRIDE
	{
		// It's only safe if the match is over
		return pMatchInfo->BMatchTerminated();
	}

	virtual bool BPlayWinMusic( int nWinningTeam, bool bGameOver ) const OVERRIDE
	{
		if ( bGameOver )
		{
			TFGameRules()->BroadcastSound( 255, ( nWinningTeam == TF_TEAM_RED ) ? "Announcer.CompMatchWinRed" : "Announcer.CompMatchWinBlu"  );
			TFGameRules()->BroadcastSound( 255, ( nWinningTeam == TF_TEAM_RED ) ? "MatchMaking.MatchEndRedWinMusic" : "MatchMaking.MatchEndBlueWinMusic"  );
		}
		else
		{
			if ( nWinningTeam == TF_TEAM_RED )
			{
				TFGameRules()->BroadcastSound( 255, "Announcer.CompRoundWinRed" );
				TFGameRules()->BroadcastSound( 255, "MatchMaking.RoundEndRedWinMusic" );
			}
			else if ( nWinningTeam == TF_TEAM_BLUE )
			{
				TFGameRules()->BroadcastSound( 255, "Announcer.CompRoundWinBlu" );
				TFGameRules()->BroadcastSound( 255, "MatchMaking.RoundEndBlueWinMusic" );
			}
			else
			{
				TFGameRules()->BroadcastSound( 255, "Announcer.CompRoundStalemate" );
				TFGameRules()->BroadcastSound( 255, "MatchMaking.RoundEndStalemateMusic" );
			}
		}

		return true;
	}
#endif

};

class CCasualMatchGroupDescription : public IMatchGroupDescription
{
public:

	class CCasualProgressionDesc : public IProgressionDesc
	{
	public:

		CCasualProgressionDesc( EMatchGroup eMatchGroup )
			: IProgressionDesc( eMatchGroup
			                    , "models/vgui/12v12_badge.mdl"
			                    , "resource/ui/PvPCasualRankPanel.res"
			                    , "TF_Competitive_Level" )
			, m_nLevelsPerStep( 25 )
			, m_nSteps( 6 )
			, m_nAverageXPPerGame( 500 )
			, m_nAverageMinutesPerGame( 30 )
		{
			struct StepInfo_t
			{
				float m_flAvgGamerPerLevel;
				const char* m_pszLevelUpSound;
			};

			const StepInfo_t stepInfo[] = { { 1.5f, "MatchMaking.LevelOneAchieved" }
										  , { 2.5f, "MatchMaking.LevelTwoAchieved" }
										  , { 4.f, "MatchMaking.LevelThreeAchieved" }
										  , { 6.f, "MatchMaking.LevelFourAchieved" }
										  , { 9.f, "MatchMaking.LevelFiveAchieved" }
										  , { 14.f, "MatchMaking.LevelSixAchieved" } };

			uint32 nNumLevels = m_nLevelsPerStep * m_nSteps;

			uint32 nEndXPForLevel = 0;
			for( uint32 i=0; i<nNumLevels; ++i )
			{
				const uint32 nStep = i / m_nLevelsPerStep;
				LevelInfo_t& level = m_vecLevels[ m_vecLevels.AddToTail() ];
				level.m_nLevelNum = i + 1;	// This loop is 0-based, but users will start at level 1
				level.m_nStartXP = nEndXPForLevel; // Use the previous level's end as our start

				// We want the last level to have the same starting and ending XP value so the progress bar looks filled
				// as soon as you hit max level.
				if ( level.m_nLevelNum != nNumLevels )
				{
					nEndXPForLevel += stepInfo[ nStep ].m_flAvgGamerPerLevel * m_nAverageXPPerGame;
				}

				level.m_nEndXP = nEndXPForLevel;
				level.m_pszLevelTitle = NULL; // Casual levels dont have titles
				level.m_pszLevelUpSound = stepInfo[ nStep ].m_pszLevelUpSound;
				level.m_pszLobbyBackgroundImage = "competitive/12v12_background001"; // All the same in casual
			}
		}

#ifdef CLIENT_DLL
		virtual void SetupBadgePanel( CBaseModelPanel *pModelPanel, const LevelInfo_t& level ) const OVERRIDE
		{
			if ( !pModelPanel )
				return;

			int nLevelIndex = level.m_nLevelNum - 1;
			int nSkin = nLevelIndex / m_nLevelsPerStep;
			int nStarsBodyGroup	= ( ( nLevelIndex ) % 5 ) + 1;
			int nBulletsBodyGroup = 0;
			int nPlatesBodyGroup = 0;
			int nBannerBodyGroup = 0;

			switch( ( ( nLevelIndex ) / 5 ) % 5 )
			{
				case 0:
					nBulletsBodyGroup	= 0;
					nPlatesBodyGroup	= 0;
					nBannerBodyGroup	= 0;
					break;
				case 1:
					nBulletsBodyGroup	= 1;
					nPlatesBodyGroup	= 0;
					nBannerBodyGroup	= 0;
					break;
				case 2:
					nBulletsBodyGroup	= 2;
					nPlatesBodyGroup	= 1;
					nBannerBodyGroup	= 0;
					break;
				case 3:
					nBulletsBodyGroup	= 3;
					nPlatesBodyGroup	= 2;
					nBannerBodyGroup	= 1;
					break;
				case 4:
					nBulletsBodyGroup	= 4;
					nPlatesBodyGroup	= 3;
					nBannerBodyGroup	= 1;
					break;
			}

			EnsureBadgePanelModel( pModelPanel );

			int nBody = 0;
			CStudioHdr studioHDR( pModelPanel->GetStudioHdr(), g_pMDLCache );

			::SetBodygroup( &studioHDR, nBody, ::FindBodygroupByName( &studioHDR, "bullets" ), nBulletsBodyGroup );
			::SetBodygroup( &studioHDR, nBody, ::FindBodygroupByName( &studioHDR, "plates" ), nPlatesBodyGroup );
			::SetBodygroup( &studioHDR, nBody, ::FindBodygroupByName( &studioHDR, "banner" ), nBannerBodyGroup );
			::SetBodygroup( &studioHDR, nBody, ::FindBodygroupByName( &studioHDR, "stars" ), nStarsBodyGroup );

			pModelPanel->SetBody( nBody );
			pModelPanel->SetSkin( nSkin );
		}

		virtual const uint32 GetLocalPlayerLastAckdExperience() const OVERRIDE
		{
			// This is bad and hard-coding a match group. We should just make XP a rating type and these functions
			// should just say "use this rating for XP"/"use this rating for acked XP"
			FixmeMMRatingBackendSwapping();
#if defined CLIENT_DLL && defined STAGING_ONLY
			if ( tf_test_pvp_rank_xp_change.GetInt() != -1 )
			{
				return tf_test_pvp_rank_xp_change.GetInt();
			}
#endif

			CSOTFLadderData *pLadderData = GetLocalPlayerLadderData( k_nMatchGroup_Casual_12v12 );
			if ( pLadderData )
			{
				return pLadderData->Obj().last_ackd_experience();
			}

			return 0u;
		}

		virtual const uint32 GetPlayerExperienceBySteamID( CSteamID steamid ) const OVERRIDE
		{
			// This is bad and hard-coding a match group. We should just make XP a rating type and these functions
			// should just say "use this rating for XP"/"use this rating for acked XP"
			FixmeMMRatingBackendSwapping();
#if defined CLIENT_DLL && defined STAGING_ONLY
			if ( tf_test_pvp_rank_xp_change.GetInt() != -1 )
			{
				return tf_test_pvp_rank_xp_change.GetInt();
			}
#endif

#ifndef CLIENT_DLL
#error This function is only okay on the client due to calling yielding stuff
#endif
			CSOTFLadderData *pLadderData = YieldingGetPlayerLadderDataBySteamID( steamid, k_nMatchGroup_Casual_12v12 );
			if ( pLadderData )
			{
				return pLadderData->Obj().experience();
			}

			return 0u;
		}
#endif // CLIENT_DLL

#if defined GC
		virtual bool BYldAcknowledgePlayerXPOnTransaction( CSQLAccess &transaction,
		                                                   CTFSharedObjectCache *pLockedSOCache ) const OVERRIDE
		{
			// This is bad and a result of XP being just a rating in some places but a magic field elsewhere.
			FixmeMMRatingBackendSwapping();
			Assert( GGCTF()->IsSteamIDLockedByCurJob( pLockedSOCache->GetOwner() ) );

			CSOTFLadderData *pLadderData = NULL;

			// Find their ladder data
			CSharedObjectTypeCache *pItemTypeCache = pLockedSOCache->FindTypeCache( CSOTFLadderData::k_nTypeID );
			if ( pItemTypeCache )
			{
				CSOTFLadderData queryItem( pLockedSOCache->GetOwner().GetAccountID(), k_nMatchGroup_Casual_12v12 );
				pLadderData = pLockedSOCache->FindTypedSharedObject< CSOTFLadderData >( queryItem );
			}

			if ( !pLadderData )
			{
				return false;
			}

			// Update the last ack'd to the current
			//
			// XXX(JohnS): This function needs to be destroyed, but if kept, we would probably want to fix
			//             CSharedObjectTransactionEx to work properly with multiple SOCaches, such that
			//             BYieldingUpdatePlayerRating could work with it, such that this function could just require a
			//             sharedobject transaction...
			CSOTFLadderData dataCopy;
			dataCopy.Copy( *pLadderData );
			uint32_t nAck = pLadderData->Obj().experience();
			dataCopy.Obj().set_last_ackd_experience( nAck );
			CUtlVector<int> dirtyFields( 0, 1 );
			dirtyFields.AddToTail( CSOTFLadderPlayerStats::kLastAckdExperienceFieldNumber );
			bool bRet = dataCopy.BYieldingAddWriteToTransaction( transaction, dirtyFields );
			if ( bRet )
			{
				transaction.AddCommitListener( [pLockedSOCache, nAck, pLadderData]() {
					Assert( GGCTF()->IsSteamIDLockedByCurJob( pLockedSOCache->GetOwner() ) );
					pLadderData->Obj().set_last_ackd_experience( nAck );
					pLockedSOCache->DirtyNetworkObject( pLadderData );
				});
			}
			return bRet;
		}

		virtual const bool BRankXPIsActuallyPrimaryMMRating() const OVERRIDE { return false; }
#endif // defined GC

#if defined GC_DLL || ( defined STAGING_ONLY && defined CLIENT_DLL )
		virtual void DebugSpewLevels() const OVERRIDE
		{
			Msg( "Spewing casual levels:\n" );
			Msg( "Assuming average %d XP per game and average %d minutes per game\n", m_nAverageXPPerGame, m_nAverageMinutesPerGame );
	
			uint32 nNumGamesToAchieve = 0;
			// Walk the levels to find where the passed in experience value falls
			for( int i=0; i< m_vecLevels.Count(); ++i )
			{
				nNumGamesToAchieve += ( m_vecLevels[ i ].m_nEndXP - m_vecLevels[ i ].m_nStartXP ) / m_nAverageXPPerGame;
				uint32 nExpectedMinutesToAchieve = nNumGamesToAchieve * m_nAverageMinutesPerGame;
#ifdef CLIENT_DLL
				int nStep = i / m_nLevelsPerStep;
				const CEconItemRarityDefinition* pRarity = GetItemSchema()->GetRarityDefinition( nStep + 1 );
				vgui::HScheme scheme = vgui::scheme()->GetScheme( "ClientScheme" );
				vgui::IScheme *pScheme = vgui::scheme()->GetIScheme( scheme );
				Color color = pScheme->GetColor( GetColorNameForAttribColor( pRarity->GetAttribColor() ), Color( 255, 255, 255, 255 ) );

				ConColorMsg( color, "Level %d:\t%d - %d.  Expected games required: %d  Expected hours required: %.2f\n", m_vecLevels[ i ].m_nLevelNum, m_vecLevels[ i ].m_nStartXP, m_vecLevels[ i ].m_nEndXP, nNumGamesToAchieve, ( nExpectedMinutesToAchieve / 60.f ) );
#else
				DevMsg( "Level %d:\t%d - %d.  Expected games required: %d  Expected hours required: %.2f\n", m_vecLevels[ i ].m_nLevelNum, m_vecLevels[ i ].m_nStartXP, m_vecLevels[ i ].m_nEndXP, nNumGamesToAchieve, ( nExpectedMinutesToAchieve / 60.f ) );
#endif
			}
		}
#endif

	private:
		const uint32 m_nLevelsPerStep;
		const uint32 m_nSteps;
		const uint32 m_nAverageXPPerGame;
		const uint32 m_nAverageMinutesPerGame;
	};

	CCasualMatchGroupDescription( EMatchGroup eMatchGroup, ConVar* pmm_match_group_size, ConVar* pmm_match_group_size_minimum )
		: IMatchGroupDescription( eMatchGroup
								  , { eMatchMode_MatchMaker_LateJoinMatchBased	   // m_eLateJoinMode;
								  , eMMPenaltyPool_Casual		   // m_ePenaltyPool
								  , true						   // m_bUsesSkillRatings;
								  , true						   // m_bSupportsLowPriorityQueue;
								  , true						   // m_bRequiresMatchID;
								  , CASUAL_REQUIRED_SCORE		   // m_pmm_required_score;
								  , true						   // m_bUseMatchHud;
								  , "server_casual.cfg"			   // m_pszExecFileName;
								  , pmm_match_group_size		   // m_pmm_match_group_size;
								  , pmm_match_group_size_minimum   // m_pmm_match_group_size_minimum;
								  , MATCH_TYPE_CASUAL			   // m_eMatchType;
								  , true						   // m_bShowPreRoundDoors;
								  , true						   // m_bShowPostRoundDoors;
								  , "#TF_Competitive_GameOver"	   // m_pszMatchEndKickWarning;
								  , "MatchMaking.RoundStartCasual" // m_pszMatchStartSound;
								  , true						   // m_bAutoReady;
								  , false						   // m_bShowRankIcons;
								  , false						   // m_bUseMatchSummaryStage;
								  , false						   // m_bDistributePerformanceMedals;
								  , true						   // m_bIsCompetitiveMode;
								  , false						   // m_bUseFirstBlood;
								  , false						   // m_bUseReducedBonusTime;
								  , true						   // m_bUseAutoBalance;
								  , false						   // m_bAllowTeamChange;
								  , true						   // m_bRandomWeaponCrits;
								  , false						   // m_bFixedWeaponSpread;
								  , false						   // m_bRequireCompleteMatch;
								  , true						   // m_bTrustedServersOnly;
								  , false						   // m_bForceClientSettings;
								  , false						   // m_bAllowDrawingAtMatchSummary
								  , true						   // m_bAllowSpecModeChange
								  , true						   // m_bAutomaticallyRequeueAfterMatchEnds
								  , true						   // m_bUsesMapVoteOnRoundEnd
								  , true						   // m_bUsesXP
								  , true						   // m_bUsesDashboardOnRoundEnd
								  , true						   // m_bUsesSurveys
								  , false } )					   // m_bStrictMatchmakerScoring
	{
		m_pProgressionDesc = new CCasualProgressionDesc( eMatchGroup );
	}

#ifdef GC_DLL
	virtual EMMRating PrimaryMMRatingBackend() const OVERRIDE
	{
		// Hard-coded for casual at the moment. Live-swapping won't work either, since lobbies don't know what they were
		// formed with in Match_Result
		FixmeMMRatingBackendSwapping();
		return k_nMMRating_12v12_DRILLO;
	}

	virtual const std::vector< EMMRating > &MatchResultRatingBackends() const OVERRIDE
	{
		FixmeMMRatingBackendSwapping(); // Shouldn't be hard-coded for 12v12, param
		static std::vector< EMMRating > casualRatings = { k_nMMRating_12v12_DRILLO, k_nMMRating_12v12_GLICKO };
		return casualRatings;
	}

	// Copy party's casual criteria
	virtual bool InitMatchFromParty( MatchDescription_t* pMatch, const MatchParty_t* pParty ) const OVERRIDE
	{
		pMatch->m_acceptableCasualCriteria.Clear();
		pMatch->m_acceptableCasualCriteria.CopyFrom( pParty->m_casualCriteria );

		CCasualCriteriaHelper helper( pMatch->m_acceptableCasualCriteria );
		return helper.AnySelected();
	}

	virtual bool InitMatchFromLobby( MatchDescription_t* pMatch, CTFLobby* pLobby ) const OVERRIDE
	{
		pMatch->m_acceptableCasualCriteria.Clear();
		CCasualCriteriaHelper helper( pMatch->m_acceptableCasualCriteria );

		const MapDef_t* pMap = GetItemSchema()->GetMasterMapDefByName( pLobby->GetMapName() );
		if ( pMap )
		{
			helper.SetMapSelected( pMap->m_nDefIndex, true );
		}

		pMatch->m_acceptableCasualCriteria = helper.GetCasualCriteria();

		return helper.AnySelected();
	}

	// Set the match party's criteria to the TFParty's criteria
	virtual void SyncMatchParty( const CTFParty *pParty, MatchParty_t *pMatchParty ) const OVERRIDE
	{
		pMatchParty->m_casualCriteria.CopyFrom( pParty->Obj().search_casual() );
	}

	// Get all the valid categories and randomly choose a category to play
	virtual void SelectModeSpecificParameters( const MatchDescription_t* pMatch, CTFLobby* pLobby  ) const OVERRIDE
	{
		if ( *tf_mm_ladder_force_map_by_name.GetString() )
		{
			pLobby->SetMapName( tf_mm_ladder_force_map_by_name.GetString() );
			return;
		}

		CUtlVector< const MapDef_t* > vecValidMaps;
		int nNumMaps = GetItemSchema()->GetMasterMapsList().Count();
		CCasualCriteriaHelper helper( pMatch->m_acceptableCasualCriteria );
		for( int i=0; i < nNumMaps; ++ i )
		{
			const MapDef_t* pMapDef = GetItemSchema()->GetMasterMapsList()[ i ];

			if ( helper.IsMapSelected( pMapDef ) )
			{
				vecValidMaps.AddToTail( pMapDef );
			}
		}

		if ( vecValidMaps.Count() == 0 )
		{
			// We should have SOMETHING valid.
			Assert( vecValidMaps.Count() > 0 );
			pLobby->SetMapName( "ctf_2fort" ); // Everybody loves 2fort
			return; 
		}

		const char *pszMap = vecValidMaps[ RandomInt( 0, vecValidMaps.Count() - 1 ) ]->pszMapName;
		pLobby->SetMapName( pszMap );
	}

	// Private helper to check an entire party's join permissions and criteria, for both PartyCompatible and Intersect
	// below, since they do the same computation, one just keeps it.
	bool BThreadedCheckPartyAllowedToJoinMatchAndIntersectCriteria( const MatchDescription_t* pMatch,
	                                                                const MatchParty_t *pParty,
	                                                                CCasualCriteriaHelper &criteria ) const
	{
		if ( *tf_mm_ladder_force_map_by_name.GetString() )
		{
			// If a map is forced, we don't care about compatibility.  We're obviously testing something.
			return true;
		}

		// Check for blacklisted former members that tank compatibility
		if ( !BCheckLeftMatchMembersAgainstParty( pMatch, pParty, &BThreadedFormerMemberMayRejoinJoinCasualOrMvMMatch) )
			{ return false; }

		// Intersect criteria with new party
		criteria = CCasualCriteriaHelper( pMatch->m_acceptableCasualCriteria );
		criteria.Intersect( pParty->m_casualCriteria );

		return criteria.AnySelected();
	}

	virtual bool BThreadedPartyCompatibleWithMatch( const MatchDescription_t* pMatch, const MatchParty_t *pCandidateParty ) const OVERRIDE
	{
		CCasualCriteriaHelper helper( pMatch->m_acceptableCasualCriteria );
		return BThreadedCheckPartyAllowedToJoinMatchAndIntersectCriteria( pMatch, pCandidateParty, helper );
	}

	virtual bool BThreadedIntersectMatchWithParty( MatchDescription_t* pMatch, const MatchParty_t* pParty ) const OVERRIDE
	{
		CCasualCriteriaHelper helper( pMatch->m_acceptableCasualCriteria );
		bool bRet = BThreadedCheckPartyAllowedToJoinMatchAndIntersectCriteria( pMatch, pParty, helper );

		// Update the match
		if ( bRet )
		{
			pMatch->m_acceptableCasualCriteria = helper.GetCasualCriteria();
			return true;
		}

		return false;

	}

	virtual bool BThreadedPartiesCompatible( const MatchParty_t *pLeftParty, const MatchParty_t *pRightParty ) const OVERRIDE
	{
		CCasualCriteriaHelper helper( pLeftParty->m_casualCriteria );
		helper.Intersect( pRightParty->m_casualCriteria );
		return helper.AnySelected();
	}

	virtual void GetServerDetails( const CMsgGameServerMatchmakingStatus& msg, int& nChallengeIndex, const char* pszMap ) const OVERRIDE
	{}

	virtual const char* GetUnauthorizedPartyReason( CTFParty* pParty ) const OVERRIDE
	{
		// Don't need no credit card to ride this train
		return NULL;
	}

	virtual void Dump( const char *pszLeader, int nSpewLevel, int nLogLevel, const MatchParty_t* pMatch ) const OVERRIDE
	{
		CUtlString strSelectedMaps;
		
		CUtlVector< const MapDef_t* > vecValidMaps;
		int nCount = 0;
		int nNumMaps = GetItemSchema()->GetMasterMapsList().Count();
		CCasualCriteriaHelper helper( pMatch->m_casualCriteria );
		for( int i=0; i < nNumMaps; ++ i )
		{
			const MapDef_t* pMapDef = GetItemSchema()->GetMasterMapsList()[ i ];
			if ( helper.IsMapSelected( pMapDef ) )
			{
				if ( nCount > 0 )
				{
					strSelectedMaps += ", ";
				}

				strSelectedMaps += pMapDef->pszMapName;
				++nCount;
			}
		}

		EmitInfo( SPEW_GC, nSpewLevel, nLogLevel, "%s  Search casual maps: %s\n", pszLeader, strSelectedMaps.String() );
		EmitInfo( SPEW_GC, nSpewLevel, nLogLevel, "%s  Best casual server ping: %.0fms\n", pszLeader, pMatch->m_flPingClosestServer );
	}
#endif

#ifdef CLIENT_DLL
	virtual bool BGetRoundStartBannerParameters( int& nSkin, int& nBodyGroup ) const OVERRIDE
	{
		nBodyGroup = 0;
		nSkin = TFGameRules()->GetRoundsPlayed();
		return true;
	}

	virtual bool BGetRoundDoorParameters( int& nSkin, int& nLogoBodyGroup ) const OVERRIDE
	{
		nLogoBodyGroup = 1;
		nSkin = 3;
		return true;
	}

	virtual const char *GetMapLoadBackgroundOverride( bool bWidescreen ) const OVERRIDE
	{
		return NULL;
	}
#endif

#ifdef GAME_DLL
	virtual void PostMatchClearServerSettings() const OVERRIDE
	{
		Assert( TFGameRules() );
		TFGameRules()->MatchSummaryEnd();
	}

	virtual void InitGameRulesSettings() const OVERRIDE
	{
		TFGameRules()->SetAllowBetweenRounds( true );
	}

	virtual void InitGameRulesSettingsPostEntity() const OVERRIDE
	{
		CTeamControlPointMaster *pMaster = ( g_hControlPointMasters.Count() ) ? g_hControlPointMasters[0] : NULL;
		bool bMultiStagePLR = ( tf_gamemode_payload.GetBool() && pMaster && pMaster->PlayingMiniRounds() && 
								pMaster->GetNumRounds() > 1 && TFGameRules()->HasMultipleTrains() );
		bool bCTF = tf_gamemode_ctf.GetBool();
		bool bUseStopWatch = TFGameRules()->MatchmakingShouldUseStopwatchMode();

		// Exec our match settings
		const char *pszExecFile = bUseStopWatch ? "server_casual_stopwatch_win_conditions.cfg" : 
								  ( ( bMultiStagePLR || bCTF ) ? "server_casual_max_rounds_win_conditions.cfg" : "server_casual_rounds_win_conditions.cfg" );

		if ( TFGameRules()->IsPowerupMode() )
		{
			pszExecFile = "server_casual_max_rounds_win_conditions_mannpower.cfg";
		}

		engine->ServerCommand( CFmtStr( "exec %s\n", pszExecFile ) );

		// leave stopwatch off for now
		TFGameRules()->SetInStopWatch( false );//bUseStopWatch );
		mp_tournament_stopwatch.SetValue( false );//bUseStopWatch );
	}

	bool ShouldRequestLateJoin() const OVERRIDE
	{
		auto pTFGameRules = TFGameRules();
		if ( !pTFGameRules || !pTFGameRules->IsCompetitiveMode() || pTFGameRules->IsManagedMatchEnded() )
		{
			Assert( false );
			return false;
		}

		if ( pTFGameRules->BIsManagedMatchEndImminent() )
			return false;

		const CMatchInfo *pMatch = GTFGCClientSystem()->GetMatch();

		int nPlayers = pMatch->GetNumActiveMatchPlayers();
		int nMissingPlayers = pMatch->GetCanonicalMatchSize() - nPlayers;

		// Allow late-join if we have missing players, have not lost everyone
		return nMissingPlayers && nPlayers;
	}

	bool BMatchIsSafeToLeaveForPlayer( const CMatchInfo* pMatchInfo, const CMatchInfo::PlayerMatchData_t *pMatchPlayer ) const
	{
		return true;
	}

	virtual bool BPlayWinMusic( int nWinningTeam, bool bGameOver ) const OVERRIDE
	{
		// Custom for game over
		if ( bGameOver )
		{
			TFGameRules()->BroadcastSound( TF_TEAM_RED, nWinningTeam == TF_TEAM_RED ? "MatchMaking.MatchEndWinMusicCasual" : "MatchMaking.MatchEndLoseMusicCasual" );
			TFGameRules()->BroadcastSound( TF_TEAM_BLUE, nWinningTeam == TF_TEAM_BLUE ? "MatchMaking.MatchEndWinMusicCasual" : "MatchMaking.MatchEndLoseMusicCasual" );
			return true;
		}
		else
		{
			// Let non-match logic handle round wins
			return false;
		}
	}
#endif
};

#if defined STAGING_ONLY && defined CLIENT_DLL
CON_COMMAND( spew_match_group_levels, "Spew all casual levels" )
{
	if ( args.ArgC() < 2 )
		return;

	const IMatchGroupDescription* pMatchDesc = GetMatchGroupDescription( (EMatchGroup)atoi( args[1] ) );
	if ( !pMatchDesc || !pMatchDesc->m_pProgressionDesc )
		return;

	pMatchDesc->m_pProgressionDesc->DebugSpewLevels();
}
#endif

const IMatchGroupDescription* GetMatchGroupDescription( const EMatchGroup& eGroup )
{
	static CMvMMatchGroupDescription descBootcamp		( k_nMatchGroup_MvM_Practice, "server_bootcamp.cfg", /* bTrustedOnly */ false );
	static CMvMMatchGroupDescription descMannup			( k_nMatchGroup_MvM_MannUp,   "server_mannup.cfg", /* bTrustedOnly */ true );
	static CLadderMatchGroupDescription descLadder6v6	( k_nMatchGroup_Ladder_6v6,   &tf_mm_match_size_ladder_6v6 );
	static CLadderMatchGroupDescription descLadder9v9	( k_nMatchGroup_Ladder_9v9,   &tf_mm_match_size_ladder_9v9 );
	static CLadderMatchGroupDescription descLadder12v12	( k_nMatchGroup_Ladder_12v12, &tf_mm_match_size_ladder_12v12 );
	static CCasualMatchGroupDescription descCasual6v6	( k_nMatchGroup_Casual_6v6,   &tf_mm_match_size_ladder_6v6, NULL );
	static CCasualMatchGroupDescription descCasual9v9	( k_nMatchGroup_Casual_9v9,   &tf_mm_match_size_ladder_9v9, NULL );
	static CCasualMatchGroupDescription descCasual12v12	( k_nMatchGroup_Casual_12v12, &tf_mm_match_size_ladder_12v12, \
	                                                                                  &tf_mm_match_size_ladder_12v12_minimum );

	switch( eGroup )
	{
	case k_nMatchGroup_MvM_Practice:
		return &descBootcamp;
	case k_nMatchGroup_MvM_MannUp:
		return &descMannup;

	case k_nMatchGroup_Ladder_6v6:
		return &descLadder6v6;
	case k_nMatchGroup_Ladder_9v9:
		return &descLadder9v9;
	case k_nMatchGroup_Ladder_12v12:
		return &descLadder12v12;

	case k_nMatchGroup_Casual_6v6:
		return &descCasual6v6;
	case k_nMatchGroup_Casual_9v9:
		return &descCasual9v9;
	case k_nMatchGroup_Casual_12v12:
		return &descCasual12v12;

	default:
#ifdef GC_DLL
		// We're going to expectedly hit this many times on the client/server.
		// Only complain on the GC
		Assert( false );
#endif
		break;
	}

	return NULL;
}
// If you add a matchmaking group, handle it in the above switch
COMPILE_TIME_ASSERT( k_nMatchGroup_Casual_12v12 == ( k_nMatchGroup_Count - 1 ) );