d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
114 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 0fb75b41fd
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '0fb75b41fd'
${ noResults }
source-engine/game/shared/tf/tf_match_description.cpp

1783 lines
66 KiB
Raw Blame History

//========= 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 ) );