1HEADmaster

1 files changed, 1783 insertions, 0 deletions

diff --git a/game/shared/tf/tf_match_description.cpp b/game/shared/tf/tf_match_description.cpp
new file mode 100644
index 0000000..a9b50a6
--- /dev/null
+++ b/game/shared/tf/tf_match_description.cpp
@@ -0,0 +1,1783 @@
+//========= 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 ) );