540 lines
20 KiB
C++
540 lines
20 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
#ifndef TF_GC_SERVER_H
|
|
#define TF_GC_SERVER_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#if !defined( _X360 ) && !defined( NO_STEAM )
|
|
#include "steam/steam_api.h"
|
|
#include "steam/steam_gameserver.h"
|
|
#endif
|
|
|
|
//#include "tf_gc_common.h"
|
|
#include "gcsdk/gcclientsdk.h"
|
|
#include "playergroup.h"
|
|
//#include "dota_gamerules.h"
|
|
#include "gc_clientsystem.h"
|
|
#include "tf_gcmessages.h"
|
|
#include "GameEventListener.h"
|
|
#include "rtime.h"
|
|
#include "tf_shareddefs.h"
|
|
|
|
class CTFGSLobby;
|
|
class CTFParty;
|
|
|
|
//enum EDOTA_Uploading_Match_Stats
|
|
//{
|
|
// EDOTA_MATCH_STATS_IDLE,
|
|
// EDOTA_MATCH_STATS_UPLOADING,
|
|
// EDOTA_MATCH_STATS_UPLOAD_COMPLETE
|
|
//};
|
|
|
|
#ifdef ENABLE_GC_MATCHMAKING
|
|
|
|
class CMvMVictoryInfo
|
|
{
|
|
public:
|
|
int m_nLobbyId;
|
|
CUtlString m_sChallengeName;
|
|
#ifdef USE_MVM_TOUR
|
|
CUtlString m_sMannUpTourOfDuty;
|
|
#endif // USE_MVM_TOUR
|
|
CUtlVector<uint64> m_vPlayerIds;
|
|
CUtlVector<bool> m_vSquadSurplus;
|
|
RTime32 m_tEventTime;
|
|
|
|
void Init ( CTFGSLobby *pLobby );
|
|
};
|
|
|
|
class CMatchInfo
|
|
{
|
|
friend class CTFGCServerSystem;
|
|
public:
|
|
CMatchInfo( const CTFGSLobby *pLobby );
|
|
~CMatchInfo();
|
|
|
|
uint64 m_nMatchID;
|
|
uint64 m_nLobbyID;
|
|
EMatchGroup m_eMatchGroup;
|
|
uint32 m_uLobbyFlags;
|
|
uint32 m_uAverageRank;
|
|
RTime32 m_rtMatchCreated;
|
|
uint32 m_unEventTeamStatus;
|
|
bool m_bFirstPersonActive;
|
|
int m_nBotsAdded;
|
|
bool m_bServerCreated;
|
|
|
|
struct DailyStatsRankBucket_t
|
|
{
|
|
uint32 nRank;
|
|
uint32 nRecords;
|
|
uint32 nAvgScore;
|
|
uint32 nStDevScore;
|
|
uint32 nAvgKills;
|
|
uint32 nStDevKills;
|
|
uint32 nAvgDamage;
|
|
uint32 nStDevDamage;
|
|
uint32 nAvgHealing;
|
|
uint32 nStDevHealing;
|
|
uint32 nAvgSupport;
|
|
uint32 nStDevSupport;
|
|
};
|
|
|
|
struct PlayerMatchData_t
|
|
{
|
|
friend class CTFGCServerSystem;
|
|
friend class CMatchInfo;
|
|
PlayerMatchData_t( CSteamID steamID, const CTFLobbyMember *pMemberData )
|
|
: steamID( steamID )
|
|
, uPartyID( pMemberData->party_id() )
|
|
, eGCTeam( pMemberData->team() )
|
|
, bDropped( false )
|
|
, bConnected( false )
|
|
, rtJoinedMatch( CRTime::RTime32TimeCur() )
|
|
, nVoteKickAttempts( 0 )
|
|
, nDisconnectedSeconds( 0 )
|
|
, nScoreMedal( 0 )
|
|
, nKillsMedal( 0 )
|
|
, nDamageMedal( 0 )
|
|
, nHealingMedal( 0 )
|
|
, nSupportMedal( 0 )
|
|
, bLateJoin( false )
|
|
, nScore( 0 )
|
|
, bPlayed( false )
|
|
, unMMSkillRating( 0u )
|
|
, nDrilloRatingDelta( 0 )
|
|
, unClassesPlayed( 0u )
|
|
, rtLastActiveEvent( CRTime::RTime32TimeCur() )
|
|
, bAlwaysSafeToLeave( false )
|
|
, bEverConnected( false )
|
|
, bDropWasAbandon( false )
|
|
, eDropReason( TFMatchLeaveReason_UNSPECIFIED )
|
|
, nConnectingButNotActiveIndex( 0 )
|
|
, m_mapXPAccumulation( DefLessFunc( CMsgTFXPSource::XPSourceType ) )
|
|
{}
|
|
|
|
PlayerMatchData_t( const PlayerMatchData_t& rhs );
|
|
|
|
CSteamID steamID;
|
|
uint64 uPartyID;
|
|
TF_GC_TEAM eGCTeam;
|
|
|
|
// If true, this player was dropped from the match and is not part of the active lobby. This is important for
|
|
// cases where the GC connection is lost and the lobby state is stale.
|
|
bool bDropped;
|
|
bool bConnected;
|
|
// Timestamp player joined the match at. Not guaranteed to be the same instant the match was created, depending
|
|
// on how the GC does things.
|
|
RTime32 rtJoinedMatch;
|
|
|
|
uint32 nVoteKickAttempts;
|
|
|
|
// Number of cumulative seconds the player has been absent, *not* including the initial connect timeout. Used
|
|
// to determine when to award an abandon. We may do odd things like "comp" you some seconds on a second, later,
|
|
// disconnect, so this shouldn't be used for stats purposes.
|
|
int nDisconnectedSeconds;
|
|
|
|
int nScoreMedal;
|
|
int nKillsMedal;
|
|
int nDamageMedal;
|
|
int nHealingMedal;
|
|
int nSupportMedal;
|
|
|
|
bool bLateJoin;
|
|
int nScore;
|
|
bool bPlayed;
|
|
// This is a single-value skill rating given to each player by the GC
|
|
uint32 unMMSkillRating;
|
|
// This is the older drillo rating system that was done on the server. It is still sent up to the GC as the
|
|
// input to the drillo backend there. If we want to keep this long-term it should be moved to be a fully-gc
|
|
// backend like glicko
|
|
int nDrilloRatingDelta;
|
|
uint32 unClassesPlayed;
|
|
|
|
const CMsgTFXPSourceBreakdown& GetXPSources() const { return m_XPBreakdown; }
|
|
|
|
// Override releasing this player from obligation to this match beyond the normal abandon rules. Used by MvM mode
|
|
// for marking everyone who completes a wave as allowed to drop without penalty, for instance.
|
|
void MarkAlwaysSafeToLeave() { bAlwaysSafeToLeave = true; }
|
|
|
|
bool BDropWasAbandon() { return bDropped && bDropWasAbandon; }
|
|
TFMatchLeaveReason GetDropReason() { return bDropped ? eDropReason : TFMatchLeaveReason_UNSPECIFIED; }
|
|
RTime32 GetLastActiveEventTime( void ) { return rtLastActiveEvent; }
|
|
|
|
MM_PlayerConnectionState_t GetConnectionState() const;
|
|
void UpdateClassesPlayed( int nClass );
|
|
|
|
struct XPBonusPool_t
|
|
{
|
|
XPBonusPool_t()
|
|
: m_flMultiplier( 1.f )
|
|
, m_nBonusPoolRemaining( 0 )
|
|
{}
|
|
|
|
CMsgTFXPSource_XPSourceType m_eType;
|
|
|
|
// Only give up to this amount
|
|
int m_nBonusPoolRemaining;
|
|
// Give at this rate
|
|
float m_flMultiplier;
|
|
};
|
|
|
|
private:
|
|
|
|
void OnConnected( int nEntindex );
|
|
void OnActive();
|
|
|
|
// Last time the player changed between active (fully loaded in) and not-active. A player is active if
|
|
// ( bConnected && !nConnectingButNotActiveIndex )
|
|
RTime32 rtLastActiveEvent;
|
|
bool bAlwaysSafeToLeave;
|
|
bool bEverConnected;
|
|
// If dropped - was it an abandon and what was the reason.
|
|
bool bDropWasAbandon;
|
|
TFMatchLeaveReason eDropReason;
|
|
|
|
// Track the janky source-engine state between ClientConnect (when we allow them in) and ClientActive
|
|
int nConnectingButNotActiveIndex;
|
|
|
|
// XP accumulation for a player
|
|
CMsgTFXPSourceBreakdown m_XPBreakdown;
|
|
// The breakdown stores ints, but we need float precision or else we're going to round off a
|
|
// significant amount of XP as the match plays on.
|
|
CUtlMap< CMsgTFXPSource::XPSourceType, float > m_mapXPAccumulation;
|
|
|
|
CUtlVector< XPBonusPool_t > m_vecXPBonusPools;
|
|
};
|
|
|
|
enum RankStatType_t
|
|
{
|
|
RankStat_Invalid = -1,
|
|
RankStat_Score = 0,
|
|
RankStat_Kills,
|
|
RankStat_Damage,
|
|
RankStat_Healing,
|
|
RankStat_Support,
|
|
};
|
|
|
|
void SetDailyRankData( DailyStatsRankBucket_t vecRankData );
|
|
bool RequestGCRankData( void );
|
|
bool CalculatePlayerMatchRankData( void );
|
|
bool CalculateMatchSkillRatingAdjustments( int iWinningTeam );
|
|
const CMatchInfo::PlayerMatchData_t* GetMatchDataForPlayer( CSteamID steamID ) const;
|
|
CMatchInfo::PlayerMatchData_t* GetMatchDataForPlayer( CSteamID steamID );
|
|
|
|
// For iterating over all players. Index is relative to GetNumTotalMatchPlayers
|
|
CMatchInfo::PlayerMatchData_t* GetMatchDataForPlayer( int nPlayer );
|
|
|
|
// This is the total number of players we have match data for -- it may include dropped players not part of the
|
|
// match any longer.
|
|
int GetNumTotalMatchPlayers() const;
|
|
|
|
// Number of players still active in the match.
|
|
int GetNumActiveMatchPlayers() const;
|
|
|
|
// Number of players still active in the match for a specific team
|
|
int GetNumActiveMatchPlayersForTeam( int nTeam ) const;
|
|
|
|
// Total skill rating for a team
|
|
int GetTotalSkillRatingForTeam( int nTeam ) const;
|
|
|
|
// Subset of active match players who are currently connected
|
|
int GetNumConnectedMatchPlayers() const;
|
|
|
|
// Indicates that this is a stale match that is ending. In cases such as rolling matches, we never "end" a match,
|
|
// just roll into the next one, since "ended" matches indicate that we've terminated our relationship with the
|
|
// players/GC.
|
|
bool BMatchTerminated() const { return m_bMatchEnded; }
|
|
|
|
// Indicates we've sent a result for this match. The match may still be active if we're intending to use it to start
|
|
// a rolling match or other post-game activities.
|
|
bool BSentResult() const { return m_bSentResult; }
|
|
|
|
// The canonical size of this type of match. Can be passed from the GC and override the match description size.
|
|
uint32 GetCanonicalMatchSize() const;
|
|
|
|
const char *GetMatchMap() const { return m_strMapName.Length() ? m_strMapName.Get() : NULL; }
|
|
|
|
// Rewards the player with XP based on the count scaled by the XP per unit of that type.
|
|
// nCount here is the raw occurances of the action (ie. Points scored, Gold Medals Scored)
|
|
void GiveXPRewardToPlayerForAction( CSteamID steamID, CMsgTFXPSource::XPSourceType eType, int nCount );
|
|
// Directly assign the value
|
|
void GiveXPDirectly( CSteamID steamID, CMsgTFXPSource::XPSourceType eType, int nAmount, bool bCanAwardBonusXP = true );
|
|
// Give an XP bonus that increases
|
|
void GiveXPBonus( CSteamID steamID,
|
|
CMsgTFXPSource_XPSourceType eType,
|
|
float flMultipler,
|
|
int nBonusPool );
|
|
|
|
// Is this player allowed to leave the match without incurring an abandon right now
|
|
|
|
// TODO(JohnS): This should not go from true to false due to race conditions (players clicks DC, sees no warning,
|
|
// races with server deciding its unsafe again), but does for MvM late join. The GS-initiated late
|
|
// join rework would make it possible to fix that (once it enters too-low-to-latejoin state it stays
|
|
// there)
|
|
bool BPlayerSafeToLeaveMatch( CSteamID steamID );
|
|
|
|
protected:
|
|
int GetRankForStat( RankStatType_t statType, int nRankIndex, uint32 nValue );
|
|
float NormalDistributionCDF( float flValue, float flMu, float flSigma );
|
|
|
|
private:
|
|
CMatchInfo();
|
|
CMatchInfo( const CMatchInfo &otherinfo );
|
|
|
|
// Track a new player participating in our match
|
|
void AddPlayer( CSteamID steamID, const CTFLobbyMember *pMemberData, bool bIsLateJoin, int nEntindex, bool bActive );
|
|
// Or with an existing player to copy from (e.g. old match)
|
|
void AddPlayer( const PlayerMatchData_t &oldPlayer, int nEntIndex, bool bActive );
|
|
|
|
// Mark a player as dropped from the match
|
|
void DropPlayer( CSteamID steamID, TFMatchLeaveReason eReason, bool bWasAbandon );
|
|
void SetEnded() { m_bMatchEnded = true; }
|
|
|
|
CUtlVector < DailyStatsRankBucket_t > m_vDailyStatsRankData;
|
|
CUtlVector < PlayerMatchData_t* > m_vMatchRankData;
|
|
|
|
CUtlString m_strMapName;
|
|
bool m_bMatchEnded;
|
|
bool m_bSentResult;
|
|
// Canonical size for this match type, override passed from GC.
|
|
uint32 m_nGCMatchSize;
|
|
|
|
float m_flBronzePercentile;
|
|
float m_flSilverPercentile;
|
|
float m_flGoldPercentile;
|
|
};
|
|
|
|
class CTFGCServerSystem : public CGCClientSystem, public GCSDK::ISharedObjectListener, public IServerGCLobby, public CGameEventListener
|
|
{
|
|
DECLARE_CLASS_GAMEROOT( CTFGCServerSystem, CGCClientSystem );
|
|
|
|
// Messages that need to do callbacks
|
|
friend class ReliableMsgNewMatchForLobby;
|
|
friend class ReliableMsgChangeMatchPlayerTeams;
|
|
public:
|
|
CTFGCServerSystem( void );
|
|
~CTFGCServerSystem( void );
|
|
|
|
// CAutoGameSystemPerFrame
|
|
virtual bool Init() OVERRIDE;
|
|
virtual void LevelInitPreEntity() OVERRIDE;
|
|
virtual void LevelShutdownPostEntity() OVERRIDE;
|
|
virtual void Shutdown() OVERRIDE;
|
|
virtual void PreClientUpdate() OVERRIDE;
|
|
|
|
// uint8 FindItemID( CTF_Item *pItem );
|
|
void MatchSignOut();
|
|
// const char *GetMatchStartTimeString();
|
|
|
|
// void GameRules_State_Enter( DOTA_GameState newState );
|
|
|
|
void SetHibernation( bool bHibernating );
|
|
bool ShouldHideServer();
|
|
|
|
// ISharedObjectListener
|
|
virtual void SOCreated( const CSteamID & steamIDOwner, const GCSDK::CSharedObject *pObject, GCSDK::ESOCacheEvent eEvent ) OVERRIDE;
|
|
virtual void PreSOUpdate( const CSteamID & steamIDOwner, GCSDK::ESOCacheEvent eEvent ) OVERRIDE { /* do nothing */ }
|
|
virtual void SOUpdated( const CSteamID & steamIDOwner, const GCSDK::CSharedObject *pObject, GCSDK::ESOCacheEvent eEvent ) OVERRIDE;
|
|
virtual void PostSOUpdate( const CSteamID & steamIDOwner, GCSDK::ESOCacheEvent eEvent ) OVERRIDE { /* do nothing */ }
|
|
virtual void SODestroyed( const CSteamID & steamIDOwner, const GCSDK::CSharedObject *pObject, GCSDK::ESOCacheEvent eEvent ) OVERRIDE;
|
|
virtual void SOCacheSubscribed( const CSteamID & steamIDOwner, GCSDK::ESOCacheEvent eEvent ) OVERRIDE { }
|
|
virtual void SOCacheUnsubscribed( const CSteamID & steamIDOwner, GCSDK::ESOCacheEvent eEvent ) OVERRIDE { }
|
|
|
|
void DumpLobby();
|
|
|
|
// IServerGCLobby methods
|
|
virtual bool HasLobby() const;
|
|
virtual bool SteamIDAllowedToConnect(const CSteamID &steamId) const;
|
|
virtual void UpdateServerDetails(void);
|
|
virtual bool ShouldHibernate();
|
|
|
|
// IGameEventListener2
|
|
virtual void FireGameEvent( IGameEvent *event ) OVERRIDE;
|
|
|
|
CTFParty* GetPartyForPlayer( CSteamID steamID ) const;
|
|
|
|
CMatchInfo *GetMatch() { return m_pMatchInfo; }
|
|
const CMatchInfo *GetMatch() const { return m_pMatchInfo; }
|
|
|
|
// Verbose accessor helpers
|
|
//
|
|
// Get match only if it is live
|
|
CMatchInfo *GetLiveMatch() { return ( m_pMatchInfo && !m_pMatchInfo->m_bMatchEnded ) ? m_pMatchInfo : NULL; }
|
|
const CMatchInfo *GetLiveMatch() const { return const_cast<CTFGCServerSystem*>(this)->GetLiveMatch(); }
|
|
// Get a player only if there is a live match and they are still in the match (not dropped)
|
|
CMatchInfo::PlayerMatchData_t *GetLiveMatchPlayer( CSteamID steamID );
|
|
const CMatchInfo::PlayerMatchData_t *GetLiveMatchPlayer( CSteamID steamID ) const ;
|
|
|
|
int GetTeamForLobbyMember( const CSteamID &steamId ) const;
|
|
// bool IsLobbyMemberBroadcaster( const CSteamID &steamId ) const;
|
|
// ELanguage GetBroadcasterLanguage( const CSteamID &steamId ) const;
|
|
float GetFirstConnectTimeForLobbyMember( const CSteamID &steamId ) const;
|
|
int GetVoteKickAttemptsByLobbyMember( const CSteamID &steamID ) const;
|
|
void IncrementVoteKickAttemptsByLobbyMember( const CSteamID &steamID );
|
|
//
|
|
// EDOTA_Uploading_Match_Stats UploadingMatchStats() { return m_nUploadingMatchStats; }
|
|
// void OnStatsSubmitted( uint32 unMatchID, int32 nReplaySalt );
|
|
// uint32 GetLastMatchID() { return m_unLastMatchID; }
|
|
// int32 GetLastReplaySalt() { return m_nLastReplaySalt; }
|
|
|
|
void ClientActive( CSteamID steamIDClient );
|
|
void ClientConnected( CSteamID steamIDPlayer, edict_t *pEntity );
|
|
void ClientDisconnected( CSteamID steamIDClient );
|
|
|
|
inline bool IsMMServerModeActive() const { return m_bMMServerMode; }
|
|
|
|
void MMServerModeChanged();
|
|
|
|
// void SetRelayedGameServerSteamID( const CSteamID &steamID ) { m_relayedGameServerSteamID = steamID; }
|
|
// void SetParentRelayCount( int nParentRelayCount ) { m_nParentRelayCount = nParentRelayCount; }
|
|
|
|
float GetTimeLastConnectedToGC( void ) { return m_timeLastConnectedToGC; }
|
|
|
|
void EndManagedMatch( bool bKickPlayersToParties = false );
|
|
|
|
// Sends match results. Expects the managed match be ended.
|
|
|
|
/// MvM game rules processing lets us the players have won
|
|
void SendMvMVictoryResult();
|
|
|
|
// Takes ownership of matchResultMsg
|
|
void SendCompetitiveMatchResult( GCSDK::CProtoBufMsg< CMsgGC_Match_Result > *matchResultMsg );
|
|
|
|
// If the GC has confirmed we are in the pool for late joins. GetTimeRequestedLateJoin() can be compared with
|
|
// BLateJoinEligible() to reason about delays in the GC making us available for late join.
|
|
bool BLateJoinEligible();
|
|
|
|
double GetTimeRequestedLateJoin() { return m_flTimeRequestedLateJoin; }
|
|
|
|
// Eject a player from the match, kicking them if they are still present, with given reason.
|
|
bool EjectMatchPlayer( CSteamID steamID, TFMatchLeaveReason eReason );
|
|
|
|
void MatchPlayerVoteKicked( CSteamID steamID );
|
|
|
|
const MapDef_t* GetNextMapVoteByIndex( int nIndex ) const;
|
|
|
|
// Changing Match Player Teams
|
|
//
|
|
// Is game logic allowed to perform team reassignments for this match mode?
|
|
bool CanChangeMatchPlayerTeams();
|
|
// When game logic changes the team of a match player, this should be called immediately. It is invalid to call this
|
|
// if CanChangeMatchPlayerTeams is false.
|
|
void ChangeMatchPlayerTeam( CSteamID steamID, TF_GC_TEAM eTeam );
|
|
// Multi-player version of the above, less GC traffic when multiple reassignments occur at once.
|
|
struct PlayerTeamPair_t { CSteamID steamID; TF_GC_TEAM eTeam; };
|
|
template< typename ANY_ALLOCATOR >
|
|
void ChangeMatchPlayerTeams( const CUtlVector< PlayerTeamPair_t, ANY_ALLOCATOR > &vecNewTeams );
|
|
|
|
// Rolling Matches
|
|
//
|
|
// Some match types let us keep a lobby and roll into a new match. This may not always be allowed depending on GC
|
|
// state.
|
|
//
|
|
// Upon calling RequestNewMatchForLobby, a timer starts, after which the new match is launched in
|
|
// LaunchNewMatchForLobby. During this period our match object is the old match, but the lobby may have been updated
|
|
// to reflect the new match.
|
|
//
|
|
// !! Currently if the GC is out of contact, we will speculatively continue with a new match. There are rare cases
|
|
// where the GC will return and decline this request, in which case the resulting match will be unofficial and
|
|
// not recorded. It should be trivial to add a bool to prevent such speculative matches should it be necessary.
|
|
bool CanRequestNewMatchForLobby();
|
|
void RequestNewMatchForLobby( const MapDef_t* pNewMap );
|
|
|
|
// If the match is in a bogus state and has no useful resolution, terminate it and submit a minidump. This usually
|
|
// just means reboot the match server.
|
|
void AbortInvalidMatchState();
|
|
|
|
protected:
|
|
|
|
// CGCClientSystem
|
|
virtual void PreInitGC() OVERRIDE;
|
|
virtual void PostInitGC() OVERRIDE;
|
|
|
|
private:
|
|
void SendPlayerLeftMatch( CSteamID steamID, TFMatchLeaveReason eReason, bool bAbandoned );
|
|
|
|
// Send a kick-lobby message for a stale or unexpected lobby
|
|
void SendRejectLobby();
|
|
|
|
// Kick a player that is no longer present in the match and should not be here.
|
|
// Returns true if they were present
|
|
bool KickRemovedMatchPlayer( CSteamID steamIDClient );
|
|
|
|
// The lobby object should only be looked at by this class and may be out of date when the GC reboots and similar --
|
|
// most users should use the canonical match state in GetMatch()
|
|
const CTFGSLobby *GetLobby() const;
|
|
CTFGSLobby *GetLobby();
|
|
|
|
// Accepts a reservation request from the GC, adding this player to our reserved list, and, for MM mode, to the
|
|
// match.
|
|
void AcceptGCReservation( CSteamID steamID, const CTFLobbyMember *pMemberData, bool bIsLateJoin, int nEntindex, bool bActive );
|
|
|
|
// Rolling Matches (private)
|
|
//
|
|
// If we requested a new match for our existing lobby. We don't actually launch the new match for this timer, but
|
|
// the GC may get back to us before (or after!) that period, so this tracks that we're not currently in sync with
|
|
// our lobby object. See RequestNewMatchForLobby / LaunchNewMatchForLobby and the "Team Assignments" section of the
|
|
// big comment at the top of tf_gc_server.cpp
|
|
bool BPendingNewMatch() const { return m_flWaitingForNewMatchTime != 0.f; }
|
|
// Called at the end of the m_flWaitingForNewMatchTime period to actually create the new match. We could let the
|
|
// caller finish the launch process by changing this timer to a bool and making this public.
|
|
void LaunchNewMatchForLobby();
|
|
|
|
// Callbacks from the GC
|
|
void ChangeMatchPlayerTeamsResponse( bool bSuccess );
|
|
void NewMatchForLobbyResponse( bool bSuccess );
|
|
// Static callbacks that are just forwarding to us
|
|
static void ChangeMatchPlayerTeamsResponseCallback( GCSDK::CProtoBufMsg<CMsgGCChangeMatchPlayerTeamsResponse>& msg );
|
|
static void NewMatchForLobbyResponseCallback( GCSDK::CProtoBufMsg<CMsgGCNewMatchForLobbyResponse>& msg );
|
|
|
|
bool m_bSetupSchema;
|
|
|
|
RTime32 m_unGameStartTime;
|
|
float m_timeLastSendGameServerInfoAndConnectedPlayers;
|
|
ServerMatchmakingState m_eLastGameServerUpdateState;
|
|
TF_MatchmakingMode m_eLastGameServerUpdateMatchmakingMode;
|
|
CUtlString m_sLastGameServerUpdateMap;
|
|
CUtlString m_sLastGameServerUpdateTags;
|
|
int m_nLastGameServerUpdateBotCount;
|
|
int m_nLastGameServerUpdateMaxHumans;
|
|
int m_nLastGameServerUpdateSlotsFree;
|
|
uint32 m_nLastGameServerUpdateLobbyMMVersion;
|
|
|
|
// EDOTA_Uploading_Match_Stats m_nUploadingMatchStats;
|
|
// uint32 m_unLastMatchID;
|
|
// int32 m_nLastReplaySalt;
|
|
CSteamID m_ourSteamID;
|
|
CSteamID m_relayedGameServerSteamID;
|
|
int m_nParentRelayCount;
|
|
bool m_bMMServerMode;
|
|
double m_flTimeBecameEmptyWithLobby;
|
|
double m_flTimeRequestedLateJoin;
|
|
bool m_bLateJoinEligible;
|
|
int m_iSavedVisibleMaxPlayers;
|
|
bool m_bOverridingVisibleMaxPlayers;
|
|
bool m_bWaitingForNewMatchID;
|
|
float m_flWaitingForNewMatchTime;
|
|
|
|
CMvMVictoryInfo m_mvmVictoryInfo;
|
|
|
|
// Check for match players who have been disconnected for long enough to warrant an abandon and do so.
|
|
void MatchPlayerAbandonThink();
|
|
|
|
void SetMatchPlayerDropped( CSteamID steamID, TFMatchLeaveReason eReason );
|
|
|
|
void UpdateConnectedPlayersAndServerInfo( CMsgGameServerMatchmakingStatus_Event event, bool bForceSendServerInfo );
|
|
|
|
CMatchInfo *m_pMatchInfo;
|
|
float m_timeLastConnectedToGC;
|
|
|
|
// DOTAGameVersion m_GameVersion;
|
|
};
|
|
|
|
CTFGCServerSystem *GTFGCClientSystem();
|
|
|
|
#endif // #ifdef ENABLE_GC_MATCHMAKING
|
|
|
|
#endif // TF_GC_SERVER_H
|