mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2026-03-20 00:49:47 +01:00
Initial commit
This commit is contained in:
Brian Harris
546
neo/sys/sys_lobby_migrate.cpp
Normal file
546
neo/sys/sys_lobby_migrate.cpp
Normal file
@@ -0,0 +1,546 @@
|
||||
/*
|
||||
===========================================================================
|
||||
|
||||
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.
|
||||
|
||||
===========================================================================
|
||||
*/
|
||||
#pragma hdrstop
|
||||
#include "../idlib/precompiled.h"
|
||||
#include "sys_lobby.h"
|
||||
|
||||
idCVar net_migration_debug( "net_migration_debug", "0", CVAR_BOOL, "debug" );
|
||||
idCVar net_migration_disable( "net_migration_disable", "0", CVAR_BOOL, "debug" );
|
||||
idCVar net_migration_forcePeerAsHost( "net_migration_forcePeerAsHost", "-1", CVAR_INTEGER, "When set to >-1, it forces that peer number to be the new host during migration" );
|
||||
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::IsBetterHost
|
||||
========================
|
||||
*/
|
||||
bool idLobby::IsBetterHost( int ping1, lobbyUserID_t userId1, int ping2, lobbyUserID_t userId2 ) {
|
||||
if ( lobbyType == TYPE_PARTY ) {
|
||||
return userId1 < userId2; // Only use user id for party, since ping doesn't matter
|
||||
}
|
||||
|
||||
if ( ping1 < ping2 ) {
|
||||
// Better ping wins
|
||||
return true;
|
||||
} else if ( ping1 == ping2 && userId1 < userId2 ) {
|
||||
// User id is tie breaker
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::FindMigrationInviteIndex
|
||||
========================
|
||||
*/
|
||||
int idLobby::FindMigrationInviteIndex( lobbyAddress_t & address ) {
|
||||
if ( migrationInfo.state == MIGRATE_NONE ) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
for ( int i = 0; i < migrationInfo.invites.Num(); i++ ) {
|
||||
if ( migrationInfo.invites[i].address.Compare( address, true ) ) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::UpdateHostMigration
|
||||
========================
|
||||
*/
|
||||
void idLobby::UpdateHostMigration() {
|
||||
|
||||
int time = Sys_Milliseconds();
|
||||
|
||||
// If we are picking a new host, then update that
|
||||
if ( migrationInfo.state == MIGRATE_PICKING_HOST ) {
|
||||
const int MIGRATION_PICKING_HOST_TIMEOUT_IN_SECONDS = 20; // FIXME: set back to 5 // Give other hosts 5 seconds
|
||||
|
||||
if ( time - migrationInfo.migrationStartTime > session->GetTitleStorageInt( "MIGRATION_PICKING_HOST_TIMEOUT_IN_SECONDS", MIGRATION_PICKING_HOST_TIMEOUT_IN_SECONDS ) * 1000 ) {
|
||||
// Just become the host if we haven't heard from a host in awhile
|
||||
BecomeHost();
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// See if we are a new migrated host that needs to invite the original members back
|
||||
if ( migrationInfo.state != MIGRATE_BECOMING_HOST ) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ( lobbyBackend == NULL || lobbyBackend->GetState() != idLobbyBackend::STATE_READY ) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ( state != STATE_IDLE ) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ( !IsHost() ) {
|
||||
return;
|
||||
}
|
||||
|
||||
const int MIGRATION_TIMEOUT_IN_SECONDS = 30; // FIXME: setting to 30 for dev purposes. 10 seems more reasonable. Need to make unloading game / loading lobby async
|
||||
const int MIGRATION_INVITE_TIME_IN_SECONDS = 2;
|
||||
|
||||
if ( migrationInfo.invites.Num() == 0 || time - migrationInfo.migrationStartTime > session->GetTitleStorageInt( "MIGRATION_TIMEOUT_IN_SECONDS", MIGRATION_TIMEOUT_IN_SECONDS ) * 1000 ) {
|
||||
// Either everyone acked, or we timed out, just keep who we have, and stop sending invites
|
||||
EndMigration();
|
||||
return;
|
||||
}
|
||||
|
||||
// Send invites to anyone who hasn't responded
|
||||
for ( int i = 0; i < migrationInfo.invites.Num(); i++ ) {
|
||||
if ( time - migrationInfo.invites[i].lastInviteTime < session->GetTitleStorageInt( "MIGRATION_INVITE_TIME_IN_SECONDS", MIGRATION_INVITE_TIME_IN_SECONDS ) * 1000 ) {
|
||||
continue; // Not enough time passed
|
||||
}
|
||||
|
||||
// Mark the time
|
||||
migrationInfo.invites[i].lastInviteTime = time;
|
||||
|
||||
byte buffer[ idPacketProcessor::MAX_PACKET_SIZE - 2 ];
|
||||
idBitMsg outmsg( buffer, sizeof( buffer ) );
|
||||
|
||||
// Have lobbyBackend fill out msg with connection info
|
||||
lobbyConnectInfo_t connectInfo = lobbyBackend->GetConnectInfo();
|
||||
connectInfo.WriteToMsg( outmsg );
|
||||
|
||||
// Let them know whether or not this was from in game
|
||||
outmsg.WriteBool( migrationInfo.persistUntilGameEndsData.wasMigratedGame );
|
||||
|
||||
NET_VERBOSE_PRINT( "NET: Sending migration invite to %s\n", migrationInfo.invites[i].address.ToString() );
|
||||
|
||||
// Send the migration invite
|
||||
SendConnectionLess( migrationInfo.invites[i].address, OOB_MIGRATE_INVITE, outmsg.GetReadData(), outmsg.GetSize() );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::BuildMigrationInviteList
|
||||
========================
|
||||
*/
|
||||
void idLobby::BuildMigrationInviteList( bool inviteOldHost ) {
|
||||
migrationInfo.invites.Clear();
|
||||
|
||||
// Build a list of addresses we will send invites to (gather all unique remote addresses from the session user list)
|
||||
for ( int i = 0; i < GetNumLobbyUsers(); i++ ) {
|
||||
lobbyUser_t * user = GetLobbyUser( i );
|
||||
|
||||
if ( !verify( user != NULL ) ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( user->IsDisconnected() ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( IsSessionUserIndexLocal( i ) ) {
|
||||
migrationInfo.ourPingMs = user->pingMs;
|
||||
migrationInfo.ourUserId = user->lobbyUserID;
|
||||
migrationInfo.persistUntilGameEndsData.ourGameData = user->migrationGameData;
|
||||
NET_VERBOSE_PRINT( "^2NET: Migration game data for local user is index %d \n", user->migrationGameData );
|
||||
|
||||
continue; // Only interested in remote users
|
||||
}
|
||||
|
||||
if ( !inviteOldHost && user->peerIndex == -1 ) {
|
||||
continue; // Don't invite old host if told not to do so
|
||||
}
|
||||
|
||||
if ( FindMigrationInviteIndex( user->address ) == -1 ) {
|
||||
migrationInvite_t invite;
|
||||
invite.address = user->address;
|
||||
invite.pingMs = user->pingMs;
|
||||
invite.userId = user->lobbyUserID;
|
||||
invite.migrationGameData = user->migrationGameData;
|
||||
invite.lastInviteTime = 0;
|
||||
|
||||
NET_VERBOSE_PRINT( "^2NET: Migration game data for user %s is index %d \n", user->gamertag, user->migrationGameData );
|
||||
|
||||
migrationInfo.invites.Append( invite );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::PickNewHost
|
||||
========================
|
||||
*/
|
||||
void idLobby::PickNewHost( bool forceMe, bool inviteOldHost ) {
|
||||
if ( IsHost() ) {
|
||||
idLib::Printf( "PickNewHost: Already host of session %s\n", GetLobbyName() );
|
||||
return;
|
||||
}
|
||||
|
||||
sessionCB->PrePickNewHost( *this, forceMe, inviteOldHost );
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::PickNewHostInternal
|
||||
========================
|
||||
*/
|
||||
void idLobby::PickNewHostInternal( bool forceMe, bool inviteOldHost ) {
|
||||
|
||||
if ( migrationInfo.state == MIGRATE_PICKING_HOST ) {
|
||||
return; // Already picking new host
|
||||
}
|
||||
|
||||
idLib::Printf( "PickNewHost: Started picking new host %s.\n", GetLobbyName() );
|
||||
|
||||
if ( IsHost() ) {
|
||||
idLib::Printf( "PickNewHost: Already host of session %s\n", GetLobbyName() );
|
||||
return;
|
||||
}
|
||||
|
||||
// Find the user with the lowest ping
|
||||
int bestUserIndex = -1;
|
||||
int bestPingMs = 0;
|
||||
lobbyUserID_t bestUserId;
|
||||
|
||||
for ( int i = 0; i < GetNumLobbyUsers(); i++ ) {
|
||||
lobbyUser_t * user = GetLobbyUser( i );
|
||||
|
||||
if ( !verify( user != NULL ) ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( user->IsDisconnected() ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if ( user->peerIndex == -1 ) {
|
||||
continue; // Don't try and pick old host
|
||||
}
|
||||
|
||||
if ( bestUserIndex == -1 || IsBetterHost( user->pingMs, user->lobbyUserID, bestPingMs, bestUserId ) ) {
|
||||
bestUserIndex = i;
|
||||
bestPingMs = user->pingMs;
|
||||
bestUserId = user->lobbyUserID;
|
||||
}
|
||||
|
||||
if ( user->peerIndex == net_migration_forcePeerAsHost.GetInteger() ) {
|
||||
bestUserIndex = i;
|
||||
bestPingMs = user->pingMs;
|
||||
bestUserId = user->lobbyUserID;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Remember when we first started picking a new host
|
||||
migrationInfo.state = MIGRATE_PICKING_HOST;
|
||||
migrationInfo.migrationStartTime = Sys_Milliseconds();
|
||||
|
||||
migrationInfo.persistUntilGameEndsData.wasMigratedGame = sessionCB->GetState() == idSession::INGAME;
|
||||
|
||||
if ( bestUserIndex == -1 ) { // This can happen if we call PickNewHost on an lobby that was Shutdown
|
||||
NET_VERBOSE_PRINT( "MIGRATION: PickNewHost was called on an lobby that was Shutdown\n" );
|
||||
BecomeHost();
|
||||
return;
|
||||
}
|
||||
|
||||
NET_VERBOSE_PRINT( "MIGRATION: Chose user index %d (%s) for new host\n", bestUserIndex, GetLobbyUser( bestUserIndex )->gamertag );
|
||||
|
||||
bool bestWasLocal = IsSessionUserIndexLocal( bestUserIndex ); // Check before shutting down the lobby
|
||||
migrateMsgFlags = parms.matchFlags; // Save off match parms
|
||||
|
||||
// Build invite list
|
||||
BuildMigrationInviteList( inviteOldHost );
|
||||
|
||||
// If the best user is on this machine, then we become the host now, otherwise, wait for a new host to contact us
|
||||
if ( forceMe || bestWasLocal ) {
|
||||
BecomeHost();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::BecomeHost
|
||||
========================
|
||||
*/
|
||||
void idLobby::BecomeHost() {
|
||||
|
||||
if ( !verify( migrationInfo.state == MIGRATE_PICKING_HOST ) ) {
|
||||
idLib::Printf( "BecomeHost: Must be called from PickNewHost.\n" );
|
||||
EndMigration();
|
||||
return;
|
||||
}
|
||||
|
||||
if ( IsHost() ) {
|
||||
idLib::Printf( "BecomeHost: Already host of session.\n" );
|
||||
EndMigration();
|
||||
return;
|
||||
}
|
||||
|
||||
if ( !sessionCB->BecomingHost( *this ) ) {
|
||||
EndMigration();
|
||||
return;
|
||||
}
|
||||
|
||||
idLib::Printf( "BecomeHost: Sending %i invites on %s.\n", migrationInfo.invites.Num(), GetLobbyName() );
|
||||
|
||||
migrationInfo.state = MIGRATE_BECOMING_HOST;
|
||||
migrationInfo.migrationStartTime = Sys_Milliseconds();
|
||||
|
||||
if ( lobbyBackend == NULL ) {
|
||||
// If we don't have a lobbyBackend, then just create one
|
||||
Shutdown();
|
||||
StartCreating();
|
||||
return;
|
||||
}
|
||||
|
||||
// Shutdown the current lobby, but keep the lobbyBackend (we'll migrate it)
|
||||
Shutdown( true );
|
||||
|
||||
// Migrate the lobbyBackend to host
|
||||
lobbyBackend->BecomeHost( migrationInfo.invites.Num() );
|
||||
|
||||
// Wait for it to complete
|
||||
SetState( STATE_CREATE_LOBBY_BACKEND );
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::EndMigration
|
||||
This gets called when we are done migrating, and invites will no longer be sent out.
|
||||
========================
|
||||
*/
|
||||
void idLobby::EndMigration() {
|
||||
if ( migrationInfo.state == MIGRATE_NONE ) {
|
||||
idLib::Printf( "idSessionLocal::EndMigration: Not migrating.\n" );
|
||||
return;
|
||||
}
|
||||
|
||||
sessionCB->MigrationEnded( *this );
|
||||
|
||||
if ( lobbyBackend != NULL ) {
|
||||
lobbyBackend->FinishBecomeHost();
|
||||
}
|
||||
|
||||
migrationInfo.state = MIGRATE_NONE;
|
||||
migrationInfo.invites.Clear();
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::ResetAllMigrationState
|
||||
This will reset all state related to host migration. Should be called
|
||||
at match end so our next game is not treated as a migrated game
|
||||
========================
|
||||
*/
|
||||
void idLobby::ResetAllMigrationState() {
|
||||
migrationInfo.state = MIGRATE_NONE;
|
||||
migrationInfo.invites.Clear();
|
||||
migrationInfo.persistUntilGameEndsData.Clear();
|
||||
|
||||
migrateMsgFlags = 0;
|
||||
|
||||
common->Dialog().ClearDialog( GDM_MIGRATING );
|
||||
common->Dialog().ClearDialog( GDM_MIGRATING_WAITING );
|
||||
common->Dialog().ClearDialog( GDM_MIGRATING_RELAUNCHING );
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::GetMigrationGameData
|
||||
This will setup the passed in idBitMsg to either read or write from the global migration game data buffer
|
||||
========================
|
||||
*/
|
||||
bool idLobby::GetMigrationGameData( idBitMsg &msg, bool reading ) {
|
||||
if ( reading ) {
|
||||
if ( !IsMigratedStatsGame() || !migrationInfo.persistUntilGameEndsData.wasMigratedHost ) {
|
||||
// This was not a migrated session, we have no migration data
|
||||
return false;
|
||||
}
|
||||
msg.InitRead( migrationInfo.persistUntilGameEndsData.gameData, sizeof( migrationInfo.persistUntilGameEndsData.gameData ) );
|
||||
} else {
|
||||
migrationInfo.persistUntilGameEndsData.hasGameData = true;
|
||||
memset( migrationInfo.persistUntilGameEndsData.gameData, 0, sizeof( migrationInfo.persistUntilGameEndsData.gameData ) );
|
||||
msg.InitWrite( migrationInfo.persistUntilGameEndsData.gameData, sizeof( migrationInfo.persistUntilGameEndsData.gameData ) );
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::GetMigrationGameDataUser
|
||||
This will setup the passed in idBitMsg to either read or write from the user's migration game data buffer
|
||||
========================
|
||||
*/
|
||||
bool idLobby::GetMigrationGameDataUser( lobbyUserID_t lobbyUserID, idBitMsg & msg, bool reading ) {
|
||||
const int userNum = GetLobbyUserIndexByID( lobbyUserID );
|
||||
|
||||
if ( !verify( userNum >=0 && userNum < MAX_PLAYERS ) ) {
|
||||
return false;
|
||||
}
|
||||
|
||||
lobbyUser_t * u = GetLobbyUser( userNum );
|
||||
if ( u != NULL ) {
|
||||
if ( reading ) {
|
||||
|
||||
if ( !IsMigratedStatsGame() || !migrationInfo.persistUntilGameEndsData.wasMigratedHost ) {
|
||||
// This was not a migrated session, we have no migration data
|
||||
return false;
|
||||
}
|
||||
|
||||
if ( u->migrationGameData >= 0 && u->migrationGameData < MAX_PLAYERS ) {
|
||||
msg.InitRead( migrationInfo.persistUntilGameEndsData.gameDataUser[ u->migrationGameData ], sizeof( migrationInfo.persistUntilGameEndsData.gameDataUser[ 0 ] ) );
|
||||
} else {
|
||||
// We don't have migration data for this user
|
||||
idLib::Warning( "No migration data for user %d in a migrated game (%d)", userNum, u->migrationGameData );
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
// Writing
|
||||
migrationInfo.persistUntilGameEndsData.hasGameData = true;
|
||||
u->migrationGameData = userNum;
|
||||
memset( migrationInfo.persistUntilGameEndsData.gameDataUser[ userNum ], 0, sizeof( migrationInfo.persistUntilGameEndsData.gameDataUser[0] ) );
|
||||
msg.InitWrite( migrationInfo.persistUntilGameEndsData.gameDataUser[ userNum ], sizeof( migrationInfo.persistUntilGameEndsData.gameDataUser[0] ) );
|
||||
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::HandleMigrationGameData
|
||||
========================
|
||||
*/
|
||||
void idLobby::HandleMigrationGameData( idBitMsg & msg ) {
|
||||
// Receives game migration data from the server. Just save off the raw data. If we ever become host we'll let the game code read
|
||||
// that chunk in (we can't do anything with it now anyways: we don't have entities or any server code to read it in to)
|
||||
migrationInfo.persistUntilGameEndsData.hasGameData = true;
|
||||
|
||||
// Reset each user's migration game data. If we don't receive new data for them in this msg, we don't want to use the old data
|
||||
for ( int i=0; i < GetNumLobbyUsers(); i++ ) {
|
||||
lobbyUser_t * u = GetLobbyUser( i );
|
||||
if ( u != NULL ) {
|
||||
u->migrationGameData = -1;
|
||||
}
|
||||
}
|
||||
|
||||
msg.ReadData( migrationInfo.persistUntilGameEndsData.gameData, sizeof( migrationInfo.persistUntilGameEndsData.gameData ) );
|
||||
int numUsers = msg.ReadByte();
|
||||
int dataIndex=0;
|
||||
for ( int i=0; i < numUsers; i++ ) {
|
||||
lobbyUserID_t lobbyUserID;
|
||||
lobbyUserID.ReadFromMsg( msg );
|
||||
lobbyUser_t * user = GetLobbyUser( GetLobbyUserIndexByID( lobbyUserID ) );
|
||||
if ( user != NULL ) {
|
||||
|
||||
NET_VERBOSE_PRINT( "NET: Got migration data[%d] for user %s\n", dataIndex, user->gamertag );
|
||||
|
||||
user->migrationGameData = dataIndex;
|
||||
msg.ReadData( migrationInfo.persistUntilGameEndsData.gameDataUser[ dataIndex ], sizeof( migrationInfo.persistUntilGameEndsData.gameDataUser[ dataIndex ] ) );
|
||||
dataIndex++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
========================
|
||||
idLobby::SendMigrationGameData
|
||||
========================
|
||||
*/
|
||||
void idLobby::SendMigrationGameData() {
|
||||
if ( net_migration_disable.GetBool() ) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ( sessionCB->GetState() != idSession::INGAME ) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ( !migrationInfo.persistUntilGameEndsData.hasGameData ) {
|
||||
// Haven't been given any migration game data yet
|
||||
return;
|
||||
}
|
||||
|
||||
const int now = Sys_Milliseconds();
|
||||
if ( nextSendMigrationGameTime > now ) {
|
||||
return;
|
||||
}
|
||||
|
||||
byte packetData[ idPacketProcessor::MAX_MSG_SIZE ];
|
||||
idBitMsg msg( packetData, sizeof(packetData) );
|
||||
|
||||
// Write global data
|
||||
msg.WriteData( &migrationInfo.persistUntilGameEndsData.gameData, sizeof( migrationInfo.persistUntilGameEndsData.gameData ) );
|
||||
msg.WriteByte( GetNumLobbyUsers() );
|
||||
|
||||
// Write user data
|
||||
for ( int userIndex = 0; userIndex < GetNumLobbyUsers(); ++userIndex ) {
|
||||
lobbyUser_t * u = GetLobbyUser( userIndex );
|
||||
if ( u->IsDisconnected() || u->migrationGameData < 0 ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
u->lobbyUserID.WriteToMsg( msg );
|
||||
msg.WriteData( migrationInfo.persistUntilGameEndsData.gameDataUser[ u->migrationGameData ], sizeof( migrationInfo.persistUntilGameEndsData.gameDataUser[ u->migrationGameData ] ) );
|
||||
}
|
||||
|
||||
// Send to 1 peer
|
||||
for ( int i=0; i < peers.Num(); i++ ) {
|
||||
int peerToSend = ( nextSendMigrationGamePeer + i ) % peers.Num();
|
||||
|
||||
if ( peers[ peerToSend ].IsConnected() && peers[ peerToSend ].loaded ) {
|
||||
if ( peers[ peerToSend ].packetProc->NumQueuedReliables() > idPacketProcessor::MAX_RELIABLE_QUEUE / 2 ) {
|
||||
// This is kind of a hack for development so we don't DC clients by sending them too many reliable migration messages
|
||||
// when they aren't responding. Doesn't seem like a horrible thing to have in a shipping product but is not necessary.
|
||||
NET_VERBOSE_PRINT("NET: Skipping reliable game migration data msg because client reliable queue is > half full\n");
|
||||
|
||||
} else {
|
||||
if ( net_migration_debug.GetBool() ) {
|
||||
idLib::Printf( "NET: Sending migration game data to peer %d. size: %d\n", peerToSend, msg.GetSize() );
|
||||
}
|
||||
QueueReliableMessage( peerToSend, RELIABLE_MIGRATION_GAME_DATA, msg.GetReadData(), msg.GetSize() );
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Increment next send time / next send peer
|
||||
nextSendMigrationGamePeer++;
|
||||
if ( nextSendMigrationGamePeer >= peers.Num() ) {
|
||||
nextSendMigrationGamePeer = 0;
|
||||
}
|
||||
|
||||
nextSendMigrationGameTime = now + MIGRATION_GAME_DATA_INTERVAL_MS;
|
||||
}
|
||||
Reference in New Issue
Block a user