id/doom3-bfg
0
0
Fork 0
mirror of https://github.com/id-Software/DOOM-3-BFG.git synced 2024-11-25 13:31:12 +00:00
Code Issues Projects Releases Packages Wiki Activity
doom3-bfg/neo/sys/sys_lobby.h

915 lines
39 KiB
C
Raw Normal View History

Initial commit
2012-11-26 18:58:24 +00:00
/*
===========================================================================
Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#include "sys_lobby_backend.h"
#define INVALID_LOBBY_USER_NAME " " // Used to be "INVALID" but Sony might not like that.
class idSessionCallbacks;
class idDebugGraph;
/*
========================
idLobby
========================
*/
class idLobby : public idLobbyBase {
public:
idLobby();
enum lobbyType_t {
TYPE_PARTY = 0,
TYPE_GAME = 1,
TYPE_GAME_STATE = 2,
TYPE_INVALID = 0xff
};
enum lobbyState_t {
STATE_IDLE,
STATE_CREATE_LOBBY_BACKEND,
STATE_SEARCHING,
STATE_OBTAINING_ADDRESS,
STATE_CONNECT_HELLO_WAIT,
STATE_FINALIZE_CONNECT,
STATE_FAILED,
NUM_STATES
};
enum failedReason_t {
FAILED_UNKNOWN,
FAILED_CONNECT_FAILED,
FAILED_MIGRATION_CONNECT_FAILED,
};
void Initialize( lobbyType_t sessionType_, class idSessionCallbacks * callbacks );
void StartHosting( const idMatchParameters & parms );
void StartFinding( const idMatchParameters & parms_ );
void Pump();
void ProcessSnapAckQueue();
void Shutdown( bool retainMigrationInfo = false, bool skipGoodbye = false ); // Goto idle state
void HandlePacket( lobbyAddress_t & remoteAddress, idBitMsg fragMsg, idPacketProcessor::sessionId_t sessionID );
lobbyState_t GetState() { return state; }
virtual bool HasActivePeers() const;
virtual bool IsLobbyFull() const { return NumFreeSlots() == 0; }
int NumFreeSlots() const;
public:
enum reliablePlayerToPlayer_t {
//RELIABLE_PLAYER_TO_PLAYER_VOICE_EVENT,
RELIABLE_PLAYER_TO_PLAYER_GAME_DATA,
// Game messages would be reserved here in the same way that RELIABLE_GAME_DATA is.
// I'm worried about using up the 0xff values we have for reliable type, so I'm not
// going to reserve anything here just yet.
NUM_RELIABLE_PLAYER_TO_PLAYER,
};
enum reliableType_t {
RELIABLE_HELLO, // host to peer : connection established
RELIABLE_USER_CONNECTED, // host to peer : a new session user connected
RELIABLE_USER_DISCONNECTED, // host to peer : a session user disconnected
RELIABLE_START_LOADING, // host to peer : peer should begin loading the map
RELIABLE_LOADING_DONE, // peer to host : finished loading map
RELIABLE_IN_GAME, // peer to host : first full snap received, in game now
RELIABLE_SNAPSHOT_ACK, // peer to host : got a snapshot
RELIABLE_RESOURCE_ACK, // peer to host : got some new resources
RELIABLE_CONNECT_AND_MOVE_TO_LOBBY, // host to peer : connect to this server
RELIABLE_PARTY_CONNECT_OK, // host to peer
RELIABLE_PARTY_LEAVE_GAME_LOBBY, // host to peer : leave game lobby
RELIABLE_MATCH_PARMS, // host to peer : update in match parms
RELIABLE_UPDATE_MATCH_PARMS, // peer to host : peer updating match parms
// User join in progress msg's (join in progress for the party/game lobby, not inside a match)
RELIABLE_USER_CONNECT_REQUEST, // peer to host: local user wants to join session in progress
RELIABLE_USER_CONNECT_DENIED, // host to peer: user join session in progress denied (not enough slots)
// User leave in progress msg's (leave in progress for the party/game lobby, not inside a match)
RELIABLE_USER_DISCONNECT_REQUEST, // peer to host: request host to remove user from session
RELIABLE_KICK_PLAYER, // host to peer : kick a player
RELIABLE_MATCHFINISHED, // host to peer - Match is in post looking at score board
RELIABLE_ENDMATCH, // host to peer - End match, and go to game lobby
RELIABLE_ENDMATCH_PREMATURE, // host to peer - End match prematurely, and go to game lobby (onl possible in unrated/custom games)
RELIABLE_SESSION_USER_MODIFIED, // peer to host : user changed something (emblem, name, etc)
RELIABLE_UPDATE_SESSION_USER, // host to peers : inform all peers of the change
RELIABLE_HEADSET_STATE, // * to * : headset state change for user
RELIABLE_VOICE_STATE, // * to * : voice state changed for user pair (mute, unmute, etc)
RELIABLE_PING, // * to * : send host->peer, then reflected
RELIABLE_PING_VALUES, // host to peers : ping data from lobbyUser_t for everyone
RELIABLE_BANDWIDTH_VALUES, // peer to host: data back about bandwidth test
RELIABLE_ARBITRATE, // host to peer : start arbitration
RELIABLE_ARBITRATE_OK, // peer to host : ack arbitration request
RELIABLE_POST_STATS, // host to peer : here, write these stats now (hacky)
RELIABLE_MIGRATION_GAME_DATA, // host to peers: game data to use incase of a migration
RELIABLE_START_MATCH_GAME_LOBBY_HOST, // game lobby host to game state lobby host: start the match, since all players are in
RELIABLE_DUMMY_MSG, // used as a placeholder for old removed msg's
RELIABLE_PLAYER_TO_PLAYER_BEGIN,
// use reliablePlayerToPlayer_t
RELIABLE_PLAYER_TO_PLAYER_END = RELIABLE_PLAYER_TO_PLAYER_BEGIN + NUM_RELIABLE_PLAYER_TO_PLAYER,
// * to * : misc reliable game data above this
RELIABLE_GAME_DATA = RELIABLE_PLAYER_TO_PLAYER_END
};
// JGM: Reliable type in packet is a byte and there are a lot of reliable game messages.
// Feel free to bump this up since it's arbitrary anyway, but take a look at gameReliable_t.
// At the moment, both Doom and Rage have around 32 gameReliable_t values.
compile_time_assert( RELIABLE_GAME_DATA < 64 );
static const char * stateToString[ NUM_STATES ];
// Consts
static const int PEER_HEARTBEAT_IN_SECONDS = 5; // Make sure something was sent every 5 seconds, so we don't time out
static const int CONNECT_REQUEST_FREQUENCY_IN_SECONDS = 5; // Frequency at which we resend a request to connect to a server (will increase in frequency over time down to MIN_CONNECT_FREQUENCY_IN_SECONDS)
static const int MIN_CONNECT_FREQUENCY_IN_SECONDS = 1; // Min frequency of connection attempts
static const int MAX_CONNECT_ATTEMPTS = 5;
static const int BANDWIDTH_REPORTING_MAX = 10240; // make bps to report receiving (clamp if higher). For quantizing
static const int BANDWIDTH_REPORTING_BITS = 16; // number of bits to use for bandwidth reporting
static const int MAX_BPS_HISTORY = 32; // size of outgoing bps history to maintain for each client
static const int MAX_SNAP_SIZE = idPacketProcessor::MAX_MSG_SIZE;
static const int MAX_SNAPSHOT_QUEUE = 64;
static const int OOB_HELLO = 0;
static const int OOB_GOODBYE = 1;
static const int OOB_GOODBYE_W_PARTY = 2;
static const int OOB_GOODBYE_FULL = 3;
static const int OOB_RESOURCE_LIST = 4;
static const int OOB_VOICE_AUDIO = 5;
static const int OOB_MATCH_QUERY = 6;
static const int OOB_MATCH_QUERY_ACK = 7;
static const int OOB_SYSTEMLINK_QUERY = 8;
static const int OOB_MIGRATE_INVITE = 9;
static const int OOB_BANDWIDTH_TEST = 10;
enum connectionState_t {
CONNECTION_FREE = 0, // Free peer slot
CONNECTION_CONNECTING = 1, // Waiting for response from host for initial connection
CONNECTION_ESTABLISHED = 2, // Connection is established and active
};
struct peer_t {
peer_t() {
loaded = false;
inGame = false;
networkChecksum = 0;
lastSnapTime = 0;
snapHz = 0.0f;
numResources = 0;
lastHeartBeat = 0;
connectionState = CONNECTION_FREE;
packetProc = NULL;
snapProc = NULL;
nextPing = 0; // do it asap
lastPingRtt = 0;
sessionID = idPacketProcessor::SESSION_ID_INVALID;
startResourceLoadTime = 0;
nextThrottleCheck = 0;
maxSnapQueueSize = 0;
throttledSnapRate = 0;
pauseSnapshots = false;
receivedBps = -1.0f;
maxSnapBps = -1.0f;
receivedThrottle = 0;
receivedThrottleTime = 0;
throttleSnapsForXSeconds = 0;
recoverPing = 0;
failedPingRecoveries = 0;
rightBeforeSnapsPing = 0;
bandwidthTestLastSendTime = 0;
bandwidthSequenceNum = 0;
bandwidthTestBytes = 0;
bandwidthChallengeStartSendTime = 0;
bandwidthChallengeResults = false;
bandwidthChallengeSendComplete = false;
numSnapsSent = 0;
ResetConnectState();
};
void ResetConnectState() {
lastResourceTime = 0;
lastSnapTime = 0;
snapHz =
lastProcTime = 0;
lastInBandProcTime = 0;
lastFragmentSendTime = 0;
needToSubmitPendingSnap = false;
lastSnapJobTime = true;
startResourceLoadTime = 0;
receivedBps = -1.0;
maxSnapBps = -1.0f;
receivedThrottle = 0;
receivedThrottleTime = 0;
throttleSnapsForXSeconds = 0;
recoverPing = 0;
failedPingRecoveries = 0;
rightBeforeSnapsPing = 0;
bandwidthTestLastSendTime = 0;
bandwidthSequenceNum = 0;
bandwidthTestBytes = 0;
bandwidthChallengeStartSendTime = 0;
bandwidthChallengeResults = false;
bandwidthChallengeSendComplete = false;
memset( sentBpsHistory, 0, sizeof( sentBpsHistory ) );
receivedBpsIndex = 0;
debugGraphs.Clear();
}
void ResetAllData() {
ResetConnectState();
ResetMatchData();
}
void ResetMatchData() {
loaded = false;
networkChecksum = 0;
inGame = false;
numResources = 0;
needToSubmitPendingSnap = false;
throttledSnapRate = 0;
maxSnapQueueSize = 0;
receivedBpsIndex = -1;
numSnapsSent = 0;
pauseSnapshots = false;
// Reset the snapshot processor
if ( snapProc != NULL ) {
snapProc->Reset( false );
}
}
void Print() {
idLib::Printf(" lastResourceTime: %d\n", lastResourceTime );
idLib::Printf(" lastSnapTime: %d\n", lastSnapTime );
idLib::Printf(" lastProcTime: %d\n", lastProcTime );
idLib::Printf(" lastInBandProcTime: %d\n", lastInBandProcTime );
idLib::Printf(" lastFragmentSendTime: %d\n", lastFragmentSendTime );
idLib::Printf(" needToSubmitPendingSnap: %d\n", needToSubmitPendingSnap );
idLib::Printf(" lastSnapJobTime: %d\n", lastSnapJobTime );
}
bool IsActive() const { return connectionState != CONNECTION_FREE; }
bool IsConnected() const { return connectionState == CONNECTION_ESTABLISHED; }
connectionState_t GetConnectionState() const;
connectionState_t connectionState;
bool loaded; // true if this peer has finished loading the map
bool inGame; // true if this peer received the first snapshot, and is in-game
int lastSnapTime; // Last time a snapshot was sent on the network to this peer
float snapHz;
int lastProcTime; // Used to determine when a packet was processed for sending to this peer
int lastInBandProcTime; // Last time a in-band packet was processed for sending
int lastFragmentSendTime; // Last time a fragment was sent out (fragments are processed msg's, waiting to be fully sent)
unsigned long networkChecksum; // Checksum used to determine if a peer loaded the network resources the EXACT same as the server did
int pauseSnapshots;
lobbyAddress_t address;
int numResources; // number of network resources we know the peer has
idPacketProcessor * packetProc; // Processes packets for this peer
idSnapshotProcessor * snapProc; // Processes snapshots for this peer
idStaticList< idDebugGraph *, 4 > debugGraphs;//
int lastResourceTime; // Used to throttle the sending of resources
int lastHeartBeat;
int nextPing; // next Sys_Milliseconds when I'll send this peer a RELIABLE_PING
int lastPingRtt;
bool needToSubmitPendingSnap;
int lastSnapJobTime; // Last time a snapshot was sent to the joblist for this peer
int startResourceLoadTime; // Used to determine how long a peer has been loading resources
int maxSnapQueueSize; // how big has the snap queue gotten?
int throttledSnapRate; // effective snap rate for this peer
int nextThrottleCheck;
int numSnapsSent;
float sentBpsHistory[ MAX_BPS_HISTORY ];
int receivedBpsIndex;
float receivedBps; // peer's reported bps (they tell us their effective downstream)
float maxSnapBps;
float receivedThrottle; // amount of accumlated time this client has been lagging behind
int receivedThrottleTime; // last time we did received based throttle calculations
int throttleSnapsForXSeconds;
int recoverPing;
int failedPingRecoveries;
int rightBeforeSnapsPing;
int bandwidthChallengeStartSendTime; // time we sent first packet of bw challenge to this peer
int bandwidthTestLastSendTime; // last time in MS we sent them a bw challenge packet
int bandwidthTestBytes; // used to measure number of bytes we sent them
int bandwidthSequenceNum; // number of challenge sequences we sent them
bool bandwidthChallengeResults; // we got results back
bool bandwidthChallengeSendComplete; // we finished sending everything
idPacketProcessor::sessionId_t sessionID;
};
const char * GetLobbyName() {
switch ( lobbyType ) {
case TYPE_PARTY: return "TYPE_PARTY";
case TYPE_GAME: return "TYPE_GAME";
case TYPE_GAME_STATE: return "TYPE_GAME_STATE";
}
return "LOBBY_INVALID";
}
virtual lobbyUserID_t AllocLobbyUserSlotForBot( const char * botName ); // find a open user slot for the bot, and return the userID.
virtual void RemoveBotFromLobbyUserList( lobbyUserID_t lobbyUserID ); // release the session user slot, so that it can be claimed by a player, etc.
virtual bool GetLobbyUserIsBot( lobbyUserID_t lobbyUserID ) const; // check to see if the lobby user is a bot or not
virtual int GetNumLobbyUsers() const { return userList.Num(); }
virtual int GetNumActiveLobbyUsers() const;
virtual bool AllPeersInGame() const;
lobbyUser_t * GetLobbyUser( int index ) { return ( index >= 0 && index < GetNumLobbyUsers() ) ? userList[index] : NULL; }
const lobbyUser_t * GetLobbyUser( int index ) const { return ( index >= 0 && index < GetNumLobbyUsers() ) ? userList[index] : NULL; }
virtual bool IsLobbyUserConnected( int index ) const { return !IsLobbyUserDisconnected( index ); }
virtual int PeerIndexFromLobbyUser( lobbyUserID_t lobbyUserID ) const;
virtual int GetPeerTimeSinceLastPacket( int peerIndex ) const;
virtual int PeerIndexForHost() const { return host; }
virtual int PeerIndexOnHost() const { return peerIndexOnHost; } // Returns -1 if we are the host
virtual const idMatchParameters & GetMatchParms() const { return parms; }
lobbyType_t GetActingGameStateLobbyType() const;
// If IsHost is true, we are a host accepting connections from peers
bool IsHost() const { return isHost; }
// If IsPeer is true, we are a peer, with an active connection to a host
bool IsPeer() const {
if ( host == -1 ) {
return false; // Can't possibly be a peer if we haven't setup a host
}
assert( !IsHost() );
return peers[host].IsConnected();
}
bool IsConnectingPeer() const {
if ( host == -1 ) {
return false; // Can't possibly be a peer if we haven't setup a host
}
assert( !IsHost() );
return peers[host].connectionState == CONNECTION_CONNECTING;
}
// IsRunningAsHostOrPeer means we are either an active host, and can accept connections from peers, or we are a peer with an active connection to a host
bool IsRunningAsHostOrPeer() const { return IsHost() || IsPeer(); }
bool IsLobbyActive() const { return IsRunningAsHostOrPeer(); }
struct reliablePlayerToPlayerHeader_t {
int fromSessionUserIndex;
int toSessionUserIndex;
reliablePlayerToPlayerHeader_t();
// Both read and write return false if the data is invalid.
// The state of the msg and object are undefined if false is returned.
// The network packets contain userIds, and Read/Write will translate from userId to a
// sessionUserIndex. The sessionUserIndex should be the same on all peers, but the
// userId has to be used in case the target player quits while the message is on the
// wire from the originating peer to the server.
bool Read( idLobby * lobby, idBitMsg & msg );
bool Write( idLobby * lobby, idBitMsg & msg );
};
int GetTotalOutgoingRate(); // returns total instant outgoing bandwidth in B/s
//private:
public: // Turning this on for now, for the sake of getting this up and running to see where things are
// State functions
void State_Idle();
void State_Create_Lobby_Backend();
void State_Searching();
void State_Obtaining_Address();
void State_Finalize_Connect();
void State_Connect_Hello_Wait();
void SetState( lobbyState_t newState );
void StartCreating();
int FindPeer( const lobbyAddress_t & remoteAddress, idPacketProcessor::sessionId_t sessionID, bool ignoreSessionID = false );
int FindAnyPeer( const lobbyAddress_t & remoteAddress ) const;
int FindFreePeer() const;
int AddPeer( const lobbyAddress_t & remoteAddress, idPacketProcessor::sessionId_t sessionID );
void DisconnectPeerFromSession( int p );
void SetPeerConnectionState( int p, connectionState_t newState, bool skipGoodbye = false );
void DisconnectAllPeers();
virtual void SendReliable( int type, idBitMsg & msg, bool callReceiveReliable = true, peerMask_t sessionUserMask = MAX_UNSIGNED_TYPE( peerMask_t ) );
virtual void SendReliableToLobbyUser( lobbyUserID_t lobbyUserID, int type, idBitMsg & msg );
virtual void SendReliableToHost( int type, idBitMsg & msg );
void SendGoodbye( const lobbyAddress_t & remoteAddress, bool wasFull = false );
void QueueReliableMessage( int peerNum, byte type ) { QueueReliableMessage( peerNum, type, NULL, 0 ); }
void QueueReliableMessage( int p, byte type, const byte * data, int dataLen );
virtual int GetNumConnectedPeers() const;
virtual int GetNumConnectedPeersInGame() const;
void SendMatchParmsToPeers();
static bool IsReliablePlayerToPlayerType( byte type );
void HandleReliablePlayerToPlayerMsg( int peerNum, idBitMsg & msg, int type );
void HandleReliablePlayerToPlayerMsg( const reliablePlayerToPlayerHeader_t & info, idBitMsg & msg, int reliableType );
void SendConnectionLess( const lobbyAddress_t & remoteAddress, byte type ) { SendConnectionLess( remoteAddress, type, NULL, 0 ); }
void SendConnectionLess( const lobbyAddress_t & remoteAddress, byte type, const byte * data, int dataLen );
void SendConnectionRequest();
void ConnectTo( const lobbyConnectInfo_t & connectInfo, bool fromInvite );
void HandleGoodbyeFromPeer( int peerNum, lobbyAddress_t & remoteAddress, int msgType );
void HandleConnectionAttemptFailed();
bool ConnectToNextSearchResult();
bool CheckVersion( idBitMsg & msg, lobbyAddress_t peerAddress );
bool VerifyNumConnectingUsers( idBitMsg & msg );
bool VerifyLobbyUserIDs( idBitMsg & msg );
int HandleInitialPeerConnection( idBitMsg & msg, const lobbyAddress_t & peerAddress, int peerNum );
void InitStateLobbyHost();
void SendMembersToLobby( lobbyType_t destLobbyType, const lobbyConnectInfo_t & connectInfo, bool waitForOtherMembers );
void SendMembersToLobby( idLobby & destLobby, bool waitForOtherMembers );
void SendPeerMembersToLobby( int peerIndex, lobbyType_t destLobbyType, const lobbyConnectInfo_t & connectInfo, bool waitForOtherMembers );
void SendPeerMembersToLobby( int peerIndex, lobbyType_t destLobbyType, bool waitForOtherMembers );
void NotifyPartyOfLeavingGameLobby();
uint32 GetPartyTokenAsHost();
virtual void DrawDebugNetworkHUD() const;
virtual void DrawDebugNetworkHUD2() const;
virtual void DrawDebugNetworkHUD_ServerSnapshotMetrics( bool draw );
void CheckHeartBeats();
bool IsLosingConnectionToHost() const;
bool IsMigratedStatsGame() const;
bool ShouldRelaunchMigrationGame() const;
bool ShouldShowMigratingDialog() const;
bool IsMigrating() const;
// Pings
struct pktPing_t {
int timestamp;
};
void PingPeers();
void SendPingValues();
void PumpPings();
void HandleReliablePing( int p, idBitMsg & msg );
void HandlePingReply( int p, const pktPing_t & ping );
void HandlePingValues( idBitMsg & msg );
void HandleBandwidhTestValue( int p, idBitMsg & msg );
void HandleMigrationGameData( idBitMsg & msg );
void HandleHeadsetStateChange( int fromPeer, idBitMsg & msg );
bool SendAnotherFragment( int p );
bool CanSendMoreData( int p );
void ProcessOutgoingMsg( int p, const void * data, int size, bool isOOB, int userData );
void ResendReliables( int p );
void PumpPackets();
void UpdateMatchParms( const idMatchParameters & p );
// SessionID helpers
idPacketProcessor::sessionId_t EncodeSessionID( uint32 key ) const;
void DecodeSessionID( idPacketProcessor::sessionId_t sessionID, uint32 & key ) const;
idPacketProcessor::sessionId_t GenerateSessionID() const;
bool SessionIDCanBeUsedForInBand( idPacketProcessor::sessionId_t sessionID ) const;
idPacketProcessor::sessionId_t IncrementSessionID( idPacketProcessor::sessionId_t sessionID ) const;
void HandleHelloAck( int p, idBitMsg & msg );
virtual const char * GetLobbyUserName( lobbyUserID_t lobbyUserID ) const;
virtual bool GetLobbyUserWeaponAutoReload( lobbyUserID_t lobbyUserID ) const;
virtual bool GetLobbyUserWeaponAutoSwitch( lobbyUserID_t lobbyUserID ) const;
virtual int GetLobbyUserSkinIndex( lobbyUserID_t lobbyUserID ) const;
virtual int GetLobbyUserLevel( lobbyUserID_t lobbyUserID ) const;
virtual int GetLobbyUserQoS( lobbyUserID_t lobbyUserID ) const;
virtual int GetLobbyUserTeam( lobbyUserID_t lobbyUserID ) const;
virtual bool SetLobbyUserTeam( lobbyUserID_t lobbyUserID, int teamNumber );
virtual int GetLobbyUserPartyToken( lobbyUserID_t lobbyUserID ) const;
virtual idPlayerProfile * GetProfileFromLobbyUser( lobbyUserID_t lobbyUserID );
virtual idLocalUser * GetLocalUserFromLobbyUser( lobbyUserID_t lobbyUserID );
virtual int GetNumLobbyUsersOnTeam( int teamNumber ) const;
const char * GetPeerName( int peerNum ) const;
virtual const char * GetHostUserName() const;
void HandleReliableMsg( int p, idBitMsg & msg );
// Bandwidth / Qos / Throttling
void BeginBandwidthTest();
bool BandwidthTestStarted();
void ServerUpdateBandwidthTest();
void ClientUpdateBandwidthTest();
void ThrottlePeerSnapRate( int peerNum );
//
// sys_session_instance_users.cpp
//
lobbyUser_t * AllocUser( const lobbyUser_t & defaults );
void FreeUser( lobbyUser_t * user );
bool VerifyUser( const lobbyUser_t * lobbyUser ) const;
void FreeAllUsers();
void RegisterUser( lobbyUser_t * lobbyUser );
void UnregisterUser( lobbyUser_t * lobbyUser );
bool IsSessionUserLocal( const lobbyUser_t * lobbyUser ) const;
bool IsSessionUserIndexLocal( int i ) const;
int GetLobbyUserIndexByID( lobbyUserID_t lobbyUserId, bool ignoreLobbyType = false ) const;
lobbyUser_t * GetLobbyUserByID( lobbyUserID_t lobbyUserId, bool ignoreLobbyType = false );
// Helper function to create a lobby user from a local user
lobbyUser_t CreateLobbyUserFromLocalUser( const idLocalUser * localUser );
// This function is designed to initialize the session users of type lobbyType (TYPE_GAME or TYPE_PARTY)
// to the current list of local users that are being tracked by the sign-in manager
void InitSessionUsersFromLocalUsers( bool onlineMatch );
// Convert an local userhandle to a session user (-1 if there is no session user with this handle)
int GetLobbyUserIndexByLocalUserHandle( const localUserHandle_t localUserHandle ) const;
// This takes a session user, and converts to a controller user
idLocalUser * GetLocalUserFromLobbyUserIndex( int lobbyUserIndex );
// Takes a controller user, and converts to a session user (will return NULL if there is no session user for this controller user)
lobbyUser_t * GetSessionUserFromLocalUser( const idLocalUser * controller );
void RemoveUsersWithDisconnectedPeers();
void RemoveSessionUsersByIDList( idList< lobbyUserID_t > & usersToRemoveByID );
void SendNewUsersToPeers( int skipPeer, int userStart, int numUsers );
void SendPeersMicStatusToNewUsers( int peerNumber );
void AddUsersFromMsg( idBitMsg & msg, int fromPeer );
void UpdateSessionUserOnPeers( idBitMsg & msg );
void HandleUpdateSessionUser( idBitMsg & msg );
void CreateUserUpdateMessage( int userIndex, idBitMsg & msg );
void UpdateLocalSessionUsers();
int PeerIndexForSessionUserIndex( int sessionUserIndex ) const;
void HandleUserConnectFailure( int p, idBitMsg & inMsg, int reliableType );
void ProcessUserDisconnectMsg( idBitMsg & msg );
void CompactDisconnectedUsers();
// Sends a request to the host to join a local user to a session
void RequestLocalUserJoin( idLocalUser * localUser );
// Sends a request to the host to remove a session user from the session
void RequestSessionUserDisconnect( int sessionUserIndex );
// This function sycs the session users with the current list of of local users on the signin manager.
// It will remove the session users that are either no longer on the signin manager, or it
// will remove them if they are no longer allowed to be in the session.
// If it finds a local users that are not in a particular session, it will add that user if allowed.
void SyncLobbyUsersWithLocalUsers( bool allowJoin, bool onlineMatch );
bool ValidateConnectedUser( const lobbyUser_t * user ) const;
virtual bool IsLobbyUserDisconnected( int userIndex ) const;
virtual bool IsLobbyUserValid( lobbyUserID_t lobbyUserID ) const;
virtual bool IsLobbyUserLoaded( lobbyUserID_t lobbyUserID ) const;
virtual bool LobbyUserHasFirstFullSnap( lobbyUserID_t lobbyUserID ) const;
virtual lobbyUserID_t GetLobbyUserIdByOrdinal( int userIndex ) const;
virtual int GetLobbyUserIndexFromLobbyUserID( lobbyUserID_t lobbyUserID ) const;
virtual void EnableSnapshotsForLobbyUser( lobbyUserID_t lobbyUserID );
virtual bool IsPeerDisconnected( int peerIndex ) const { return !peers[peerIndex].IsConnected(); }
float GetAverageSessionLevel();
float GetAverageLocalUserLevel( bool onlineOnly );
void QueueReliablePlayerToPlayerMessage( int fromSessionUserIndex, int toSessionUserIndex, reliablePlayerToPlayer_t type, const byte * data, int dataLen );
virtual void KickLobbyUser( lobbyUserID_t lobbyUserID );
int GetNumConnectedUsers() const;
//
// sys_session_instance_migrate.cpp
//
bool IsBetterHost( int ping1, lobbyUserID_t userId1, int ping2, lobbyUserID_t userId2 );
int FindMigrationInviteIndex( lobbyAddress_t & address );
void UpdateHostMigration();
void BuildMigrationInviteList( bool inviteOldHost );
void PickNewHost( bool forceMe = false, bool inviteOldHost = false );
void PickNewHostInternal( bool forceMe, bool inviteOldHost );
void BecomeHost();
void EndMigration();
void ResetAllMigrationState();
void SendMigrationGameData();
bool GetMigrationGameData( idBitMsg &msg, bool reading );
bool GetMigrationGameDataUser( lobbyUserID_t lobbyUserID, idBitMsg &msg, bool reading );
//
// Snapshots
// sys_session_instance_snapshot.cpp
//
void UpdateSnaps();
bool SendCompletedSnaps();
bool SendResources( int p );
bool SubmitPendingSnap( int p );
void SendCompletedPendingSnap( int p );
void CheckPeerThrottle( int p );
void ApplySnapshotDelta( int p, int snapshotNumber );
bool ApplySnapshotDeltaInternal( int p, int snapshotNumber );
void SendSnapshotToPeer( idSnapShot & ss, int p );
bool AllPeersHaveBaseState();
void ThrottleSnapsForXSeconds( int p, int seconds, bool recoverPing );
bool FirstSnapHasBeenSent( int p );
virtual bool EnsureAllPeersHaveBaseState();
virtual bool AllPeersHaveStaleSnapObj( int objId );
virtual bool AllPeersHaveExpectedSnapObj( int objId );
virtual void MarkSnapObjDeleted( int objId );
virtual void RefreshSnapObj( int objId );
void ResetBandwidthStats();
void DetectSaturation( int p );
virtual void AddSnapObjTemplate( int objID, idBitMsg & msg );
static const int MAX_PEERS = MAX_PLAYERS;
//------------------------
// Pings
//------------------------
struct pktPingValues_t {
idArray<short, MAX_PEERS> pings;
};
static const int PING_INTERVAL_MS = 3000;
int lastPingValuesRecvTime; // so clients can display something when server stops pinging
int nextSendPingValuesTime; // the next time to send RELIABLE_PING_VALUES
static const int MIGRATION_GAME_DATA_INTERVAL_MS = 1000;
int nextSendMigrationGameTime; // when to send next migration game data
int nextSendMigrationGamePeer; // who to send next migration game data to
lobbyType_t lobbyType;
lobbyState_t state; // State of this lobby
failedReason_t failedReason;
int host; // which peer is the host of this type of session (-1 if we are the host)
int peerIndexOnHost; // -1 if we are the host
lobbyAddress_t hostAddress; // address of the host for this type of session
bool isHost; // true if we are the host
idLobbyBackend * lobbyBackend;
int helloStartTime; // Used to determine when the first hello was sent
int lastConnectRequest; // Used to determine when the last hello was sent
int connectionAttempts; // Number of connection attempts
bool needToDisplayMigrateMsg; // If true, we migrated as host, so we need to display the msg as soon as the lobby is active
gameDialogMessages_t migrationDlg; // current migration dialog we should be showing
uint8 migrateMsgFlags; // cached match flags from the old game we migrated from, so we know what type of msg to display
bool joiningMigratedGame; // we are joining a migrated game and need to tell the session mgr if we succeed or fail
// ------------------------
// Bandwidth challenge
// ------------------------
int bandwidthChallengeEndTime; // When the challenge will end/timeout
int bandwidthChallengeStartTime; // time in MS the challenge started
bool bandwidthChallengeFinished; // (HOST) test is finished and we received results back from all peers (or timed out)
int bandwidthChallengeNumGoodSeq; // (PEER) num of good, in order packets we recevieved
int lastSnapBspHistoryUpdateSequence;
void SaveDisconnectedUser( const lobbyUser_t & user ); // This is needed to get the a user's gamertag after disconnection.
idSessionCallbacks * sessionCB;
enum migrationState_t {
MIGRATE_NONE,
MIGRATE_PICKING_HOST,
MIGRATE_BECOMING_HOST,
};
struct migrationInvite_t {
migrationInvite_t() {
lastInviteTime = -1;
pingMs = 0;
migrationGameData = -1;
}
lobbyAddress_t address;
int pingMs;
lobbyUserID_t userId;
int lastInviteTime;
int migrationGameData;
};
struct migrationInfo_t {
migrationInfo_t() {
state = MIGRATE_NONE;
ourPingMs = 0;
ourUserId = lobbyUserID_t();
}
migrationState_t state;
idStaticList< migrationInvite_t, MAX_PEERS > invites;
int migrationStartTime;
int ourPingMs;
lobbyUserID_t ourUserId;
struct persistUntilGameEnds_t {
persistUntilGameEnds_t() {
Clear();
}
void Clear() {
wasMigratedHost = false;
wasMigratedJoin = false;
wasMigratedGame = false;
ourGameData = -1;
hasGameData = false;
hasRelaunchedMigratedGame = false;
memset( gameData, 0, sizeof( gameData ) );
memset( gameDataUser, 0, sizeof( gameDataUser ) );
}
int ourGameData;
bool wasMigratedHost; // we are hosting a migrated session
bool wasMigratedJoin; // we joined a migrated session
bool wasMigratedGame; // If true, we migrated from a game
bool hasRelaunchedMigratedGame;
// A generic blob of data that the gamechallenge (or anything else) can read and write to for host migration
static const int MIGRATION_GAME_DATA_SIZE = 32;
byte gameData[ MIGRATION_GAME_DATA_SIZE ];
static const int MIGRATION_GAME_DATA_USER_SIZE = 64;
byte gameDataUser[ MAX_PLAYERS ][ MIGRATION_GAME_DATA_USER_SIZE ];
bool hasGameData;
} persistUntilGameEndsData;
};
struct disconnectedUser_t {
lobbyUserID_t lobbyUserID; // Locally generated to be unique, and internally keeps the local user handle
char gamertag[lobbyUser_t::MAX_GAMERTAG];
};
migrationInfo_t migrationInfo;
bool showHostLeftTheSession;
bool connectIsFromInvite;
idList< lobbyConnectInfo_t > searchResults;
typedef idStaticList< lobbyUser_t *, MAX_PLAYERS > idLobbyUserList;
typedef idStaticList< lobbyUser_t, MAX_PLAYERS > idLobbyUserPool;
idLobbyUserList userList; // list of currently connected users to this lobby
idLobbyUserList freeUsers; // list of free users
idLobbyUserPool userPool;
idList< disconnectedUser_t> disconnectedUsers; // List of users which were connected, but aren't anymore, for printing their name on the hud
idStaticList< peer_t, MAX_PEERS > peers; // Unique machines connected to this lobby
uint32 partyToken;
idMatchParameters parms;
bool loaded; // Used for game sessions, whether this machine is loaded or not
bool respondToArbitrate; // true when the host has requested us to arbitrate our session (for TYPE_GAME only)
bool everyoneArbitrated;
bool waitForPartyOk;
bool startLoadingFromHost;
//------------------------
// Snapshot jobs
//------------------------
static const int SNAP_OBJ_JOB_MEMORY = 1024 * 128; // 128k of obj memory
lzwCompressionData_t * lzwData; // Shared across all snapshot jobs
uint8 * objMemory; // Shared across all snapshot jobs
bool haveSubmittedSnaps; // True if we previously submitted snaps to jobs
idSnapShot * localReadSS;
struct snapDeltaAck_t {
int p;
int snapshotNumber;
};
idStaticList< snapDeltaAck_t, 16 > snapDeltaAckQueue;
};
/*
========================
idSessionCallbacks
========================
*/
class idSessionCallbacks {
public:
virtual idLobby & GetPartyLobby() = 0;
virtual idLobby & GetGameLobby() = 0;
virtual idLobby & GetActingGameStateLobby() = 0;
virtual idLobby * GetLobbyFromType( idLobby::lobbyType_t lobbyType ) = 0;
virtual int GetUniquePlayerId() const = 0;
virtual idSignInManagerBase & GetSignInManager() = 0;
virtual void SendRawPacket( const lobbyAddress_t & to, const void * data, int size, bool useDirectPort ) = 0;
virtual bool BecomingHost( idLobby & lobby ) = 0; // Called when a lobby is about to become host
virtual void BecameHost( idLobby & lobby ) = 0; // Called when a lobby becomes a host
virtual bool BecomingPeer( idLobby & lobby ) = 0; // Called when a lobby is about to become peer
virtual void BecamePeer( idLobby & lobby ) = 0; // Called when a lobby becomes a peer
virtual void FailedGameMigration( idLobby & lobby ) = 0;
virtual void MigrationEnded( idLobby & lobby ) = 0;
virtual void GoodbyeFromHost( idLobby & lobby, int peerNum, const lobbyAddress_t & remoteAddress, int msgType ) = 0;
virtual uint32 GetSessionOptions() = 0;
virtual bool AnyPeerHasAddress( const lobbyAddress_t & remoteAddress ) const = 0;
virtual idSession::sessionState_t GetState() const = 0;
virtual void ClearMigrationState() = 0;
// Called when the lobby receives a RELIABLE_ENDMATCH msg
virtual void EndMatchInternal( bool premature=false ) = 0;
// Called when the game lobby receives leaderboard stats
virtual void RecvLeaderboardStats( idBitMsg & msg ) = 0;
// Called once the lobby received its first full snap (used to advance from LOADING to INGAME state)
virtual void ReceivedFullSnap() = 0;
// Called when lobby received RELIABLE_PARTY_LEAVE_GAME_LOBBY msg
virtual void LeaveGameLobby() = 0;
virtual void PrePickNewHost( idLobby & lobby, bool forceMe, bool inviteOldHost ) = 0;
virtual bool PreMigrateInvite( idLobby & lobby ) = 0;
virtual void HandleOobVoiceAudio( const lobbyAddress_t & from, const idBitMsg & msg ) = 0;
// ConnectAndMoveToLobby is called when the lobby receives a RELIABLE_CONNECT_AND_MOVE_TO_LOBBY
virtual void ConnectAndMoveToLobby( idLobby::lobbyType_t destLobbyType, const lobbyConnectInfo_t & connectInfo, bool waitForPartyOk ) = 0;
virtual class idVoiceChatMgr * GetVoiceChat() = 0;
virtual void HandleServerQueryRequest( lobbyAddress_t & remoteAddr, idBitMsg & msg, int msgType ) = 0;
virtual void HandleServerQueryAck( lobbyAddress_t & remoteAddr, idBitMsg & msg ) = 0;
virtual void HandlePeerMatchParamUpdate( int peer, int msg ) = 0;
virtual idLobbyBackend * CreateLobbyBackend( const idMatchParameters & p, float skillLevel, idLobbyBackend::lobbyBackendType_t lobbyType ) = 0;
virtual idLobbyBackend * FindLobbyBackend( const idMatchParameters & p, int numPartyUsers, float skillLevel, idLobbyBackend::lobbyBackendType_t lobbyType ) = 0;
virtual idLobbyBackend * JoinFromConnectInfo( const lobbyConnectInfo_t & connectInfo , idLobbyBackend::lobbyBackendType_t lobbyType ) = 0;
virtual void DestroyLobbyBackend( idLobbyBackend * lobbyBackend ) = 0;
};
Reference in a new issue Copy permalink