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

4094 lines
128 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.
===========================================================================
*/
#pragma hdrstop
#include "../idlib/precompiled.h"
#include "sys_session_local.h"
#include "sys_voicechat.h"
#include "sys_dedicated_server_search.h"
idCVar ui_skinIndex( "ui_skinIndex", "0", CVAR_ARCHIVE, "Selected skin index" );
idCVar ui_autoSwitch( "ui_autoSwitch", "1", CVAR_ARCHIVE | CVAR_BOOL, "auto switch weapon" );
idCVar ui_autoReload( "ui_autoReload", "1", CVAR_ARCHIVE | CVAR_BOOL, "auto reload weapon" );
idCVar net_maxSearchResults( "net_maxSearchResults", "25", CVAR_INTEGER, "Max results that are allowed to be returned in a search request" );
idCVar net_maxSearchResultsToTry( "net_maxSearchResultsToTry", "5", CVAR_INTEGER, "Max results to try before giving up." ); // At 15 second timeouts per, 1 min 15 worth of connecting attempt time
idCVar net_LobbyCoalesceTimeInSeconds( "net_LobbyCoalesceTimeInSeconds", "30", CVAR_INTEGER, "Time in seconds when a lobby will try to coalesce with another lobby when there is only one user." );
idCVar net_LobbyRandomCoalesceTimeInSeconds( "net_LobbyRandomCoalesceTimeInSeconds", "3", CVAR_INTEGER, "Random time to add to net_LobbyCoalesceTimeInSeconds" );
idCVar net_useGameStateLobby( "net_useGameStateLobby", "0", CVAR_BOOL, "" );
//idCVar net_useGameStateLobby( "net_useGameStateLobby", "1", CVAR_BOOL, "" );
#if !defined( ID_RETAIL ) || defined( ID_RETAIL_INTERNAL )
idCVar net_ignoreTitleStorage( "net_ignoreTitleStorage", "0", CVAR_BOOL, "Ignore title storage" );
#endif
idCVar net_maxLoadResourcesTimeInSeconds( "net_maxLoadResourcesTimeInSeconds", "0", CVAR_INTEGER, "How long, in seconds, clients have to load resources. Used for loose asset builds." );
idCVar net_migrateHost( "net_migrateHost", "-1", CVAR_INTEGER, "Become host of session (0 = party, 1 = game) for testing purposes" );
extern idCVar net_debugBaseStates;
idCVar net_testPartyMemberConnectFail( "net_testPartyMemberConnectFail", "-1", CVAR_INTEGER, "Force this party member index to fail to connect to games." );
//FIXME: this could use a better name.
idCVar net_offlineTransitionThreshold( "net_offlineTransitionThreshold", "1000", CVAR_INTEGER, "Time, in milliseconds, to wait before kicking back to the main menu when a profile losses backend connection during an online game");
idCVar net_port( "net_port", "27015", CVAR_INTEGER, "host port number" ); // Port to host when using dedicated servers, port to broadcast on when looking for a dedicated server to connect to
idCVar net_headlessServer( "net_headlessServer", "0", CVAR_BOOL, "toggle to automatically host a game and allow peer[0] to control menus" );
const char * idSessionLocal::stateToString[ NUM_STATES ] = {
ASSERT_ENUM_STRING( STATE_PRESS_START, 0 ),
ASSERT_ENUM_STRING( STATE_IDLE, 1 ),
ASSERT_ENUM_STRING( STATE_PARTY_LOBBY_HOST, 2 ),
ASSERT_ENUM_STRING( STATE_PARTY_LOBBY_PEER, 3 ),
ASSERT_ENUM_STRING( STATE_GAME_LOBBY_HOST, 4 ),
ASSERT_ENUM_STRING( STATE_GAME_LOBBY_PEER, 5 ),
ASSERT_ENUM_STRING( STATE_GAME_STATE_LOBBY_HOST, 6 ),
ASSERT_ENUM_STRING( STATE_GAME_STATE_LOBBY_PEER, 7 ),
ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY, 8 ),
ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_GAME_LOBBY, 9 ),
ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY, 10 ),
ASSERT_ENUM_STRING( STATE_FIND_OR_CREATE_MATCH, 11 ),
ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_PARTY, 12 ),
ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_GAME, 13 ),
ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_GAME_STATE, 14 ),
ASSERT_ENUM_STRING( STATE_BUSY, 15 ),
ASSERT_ENUM_STRING( STATE_LOADING, 16 ),
ASSERT_ENUM_STRING( STATE_INGAME, 17 ),
};
struct netVersion_s {
netVersion_s() { sprintf( string, "%s.%d", ENGINE_VERSION, BUILD_NUMBER ); }
char string[256];
} netVersion;
/*
========================
NetGetVersionChecksum
========================
*/
unsigned long NetGetVersionChecksum() {
#if 0
return idStr( com_version.GetString() ).Hash();
#else
unsigned long ret = 0;
CRC32_InitChecksum( ret );
CRC32_UpdateChecksum( ret, netVersion.string, idStr::Length( netVersion.string ) );
CRC32_FinishChecksum( ret );
NET_VERBOSE_PRINT( "NetGetVersionChecksum - string : %s\n", netVersion.string );
NET_VERBOSE_PRINT( "NetGetVersionChecksum - checksum : %i\n", ret );
return ret;
#endif
}
/*
========================
idSessionLocal::idSessionLocal
========================
*/
idSessionLocal::idSessionLocal() :
processorSaveFiles( new (TAG_SAVEGAMES) idSaveGameProcessorSaveFiles ),
processorLoadFiles( new (TAG_SAVEGAMES) idSaveGameProcessorLoadFiles ),
processorDelete( new (TAG_SAVEGAMES) idSaveGameProcessorDelete ),
processorEnumerate( new (TAG_SAVEGAMES) idSaveGameProcessorEnumerateGames ) {
InitBaseState();
}
/*
========================
idSessionLocal::idSessionLocal
========================
*/
idSessionLocal::~idSessionLocal() {
delete processorSaveFiles;
delete processorLoadFiles;
delete processorDelete;
delete processorEnumerate;
delete sessionCallbacks;
}
/*
========================
idSessionLocal::InitBaseState
========================
*/
void idSessionLocal::InitBaseState() {
//assert( mem.IsGlobalHeap() );
localState = STATE_PRESS_START;
sessionOptions = 0;
currentID = 0;
sessionCallbacks = new (TAG_NETWORKING) idSessionLocalCallbacks( this );
connectType = CONNECT_NONE;
connectTime = 0;
upstreamDropRate = 0.0f;
upstreamDropRateTime = 0;
upstreamQueueRate = 0.0f;
upstreamQueueRateTime = 0;
queuedBytes = 0;
lastVoiceSendtime = 0;
hasShownVoiceRestrictionDialog = false;
isSysUIShowing = false;
pendingInviteDevice = 0;
pendingInviteMode = PENDING_INVITE_NONE;
downloadedContent.Clear();
marketplaceHasNewContent = false;
offlineTransitionTimerStart = 0;
showMigratingInfoStartTime = 0;
nextGameCoalesceTime = 0;
gameLobbyWasCoalesced = false;
numFullSnapsReceived = 0;
flushedStats = false;
titleStorageLoaded = false;
droppedByHost = false;
loadingID = 0;
storedPeer = -1;
storedMsgType = -1;
inviteInfoRequested = false;
enumerationHandle = 0;
waitingOnGameStateMembersToLeaveTime = 0;
waitingOnGameStateMembersToJoinTime = 0;
}
/*
========================
idSessionLocal::FinishDisconnect
========================
*/
void idSessionLocal::FinishDisconnect() {
GetPort().Close();
while ( sendQueue.Peek() != NULL ) {
sendQueue.RemoveFirst();
}
while ( recvQueue.Peek() != NULL ) {
recvQueue.RemoveFirst();
}
}
//====================================================================================
idCVar net_connectTimeoutInSeconds( "net_connectTimeoutInSeconds", "15", CVAR_INTEGER, "timeout (in seconds) while connecting" );
/*
========================
idSessionLocal::CreatePartyLobby
========================
*/
void idSessionLocal::CreatePartyLobby( const idMatchParameters & parms_ ) {
NET_VERBOSE_PRINT( "NET: CreatePartyLobby\n" );
// Shutdown any possible party lobby
GetPartyLobby().Shutdown();
GetPartyLobby().ResetAllMigrationState();
// Shutdown any possible game lobby
GetGameLobby().Shutdown();
GetGameStateLobby().Shutdown();
// Start hosting a new party lobby
GetPartyLobby().StartHosting( parms_ );
connectType = CONNECT_NONE;
connectTime = Sys_Milliseconds();
// Wait for it to complete
SetState( STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY );
}
/*
========================
idSessionLocal::CreateMatch
========================
*/
void idSessionLocal::CreateMatch( const idMatchParameters & p ) {
NET_VERBOSE_PRINT( "NET: CreateMatch\n" );
if ( ( p.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) && !GetPartyLobby().IsLobbyActive() ) {
NET_VERBOSE_PRINT( "NET: CreateMatch MATCH_PARTY_INVITE_PLACEHOLDER\n" );
CreatePartyLobby( p );
connectType = CONNECT_NONE;
return;
}
// Shutdown any possible game lobby
GetGameLobby().Shutdown();
GetGameStateLobby().Shutdown();
GetGameLobby().ResetAllMigrationState();
// Start hosting a new game lobby
GetGameLobby().StartHosting( p );
connectType = CONNECT_NONE;
connectTime = Sys_Milliseconds();
// Wait for it to complete
SetState( STATE_CREATE_AND_MOVE_TO_GAME_LOBBY );
}
/*
========================
idSessionLocal::CreateGameStateLobby
========================
*/
void idSessionLocal::CreateGameStateLobby( const idMatchParameters & p ) {
NET_VERBOSE_PRINT( "NET: CreateGameStateLobby\n" );
// Shutdown any possible game state lobby
GetGameStateLobby().Shutdown();
GetGameStateLobby().ResetAllMigrationState();
// Start hosting a new game lobby
GetGameStateLobby().StartHosting( p );
connectType = CONNECT_NONE;
connectTime = Sys_Milliseconds();
waitingOnGameStateMembersToLeaveTime = 0; // Make sure to reset
waitingOnGameStateMembersToJoinTime = 0;
// Wait for it to complete
SetState( STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY );
}
/*
========================
idSessionLocal::FindOrCreateMatch
========================
*/
void idSessionLocal::FindOrCreateMatch( const idMatchParameters & p ) {
NET_VERBOSE_PRINT( "NET: FindOrCreateMatch\n" );
if ( ( p.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) && !GetPartyLobby().IsLobbyActive() ) {
NET_VERBOSE_PRINT( "NET: FindOrCreateMatch MATCH_PARTY_INVITE_PLACEHOLDER\n" );
CreatePartyLobby( p );
connectType = CONNECT_FIND_OR_CREATE;
return;
}
// Shutdown any possible game lobby
GetGameLobby().Shutdown();
GetGameStateLobby().Shutdown();
GetGameLobby().ResetAllMigrationState();
// Start searching for a game
GetGameLobby().StartFinding( p );
connectType = CONNECT_FIND_OR_CREATE;
connectTime = Sys_Milliseconds();
gameLobbyWasCoalesced = false;
numFullSnapsReceived = 0;
// Wait for searching to complete
SetState( STATE_FIND_OR_CREATE_MATCH );
}
/*
========================
idSessionLocal::StartLoading
========================
*/
void idSessionLocal::StartLoading() {
NET_VERBOSE_PRINT( "NET: StartLoading\n" );
if ( MatchTypeIsOnline( GetActingGameStateLobby().parms.matchFlags ) ) {
if ( !GetActingGameStateLobby().IsHost() ) {
idLib::Warning( "Ignoring call to StartLoading because we are not the host. state is %s", stateToString[ localState ] );
return;
}
for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
if ( GetActingGameStateLobby().peers[p].IsConnected() ) {
GetActingGameStateLobby().QueueReliableMessage( p, idLobby::RELIABLE_START_LOADING );
GetActingGameStateLobby().peers[p].startResourceLoadTime = Sys_Milliseconds();
}
}
}
VerifySnapshotInitialState();
SetState( STATE_LOADING );
}
/*
========================
idSessionLocal::StartMatch
========================
*/
void idSessionLocal::StartMatch() {
NET_VERBOSE_PRINT( "NET: StartMatch\n" );
if ( net_headlessServer.GetBool() ) {
StartLoading(); // This is so we can force start matches on headless servers to test performance using bots
return;
}
if ( localState != STATE_GAME_LOBBY_HOST ) {
idLib::Warning( "idSessionLocal::StartMatch called when not hosting game lobby" );
return;
}
assert( !GetGameStateLobby().IsLobbyActive() );
// make absolutely sure we only call StartMatch once per migrate
GetGameLobby().migrationInfo.persistUntilGameEndsData.hasRelaunchedMigratedGame = true;
// Clear snap ack queue between games
GetGameLobby().snapDeltaAckQueue.Clear();
extern idCVar net_bw_challenge_enable;
if ( session->GetTitleStorageBool( "net_bw_challenge_enable", net_bw_challenge_enable.GetBool() ) && GetGameLobby().HasActivePeers() ) {
GetGameLobby().bandwidthChallengeFinished = false;
StartOrContinueBandwidthChallenge( false );
}
if ( GetGameLobby().BandwidthTestStarted() ) {
// Put session in busy state
NET_VERBOSE_PRINT( "NET: StartMatch -> Start Bandwidth Challenge\n" );
SetState( STATE_BUSY );
} else {
// Start loading
StartLoading();
}
}
/*
========================
idSessionLocal::GetBackState
========================
*/
idSessionLocal::sessionState_t idSessionLocal::GetBackState() {
sessionState_t currentState = GetState();
const bool isInGameLobby = currentState == GAME_LOBBY;
const bool isInPartyLobby = currentState == PARTY_LOBBY;
const bool isInGame = currentState == INGAME || currentState == LOADING; // Counting loading as ingame as far as what back state to go to
if ( isInGame ) {
return GAME_LOBBY; // If in the game, go back to game lobby
}
if ( !isInPartyLobby && isInGameLobby && ShouldHavePartyLobby() ) {
return PARTY_LOBBY; // If in the game lobby, and we should have a party lobby, and we are the host, go back to party lobby
}
if ( currentState != IDLE ) {
return IDLE; // From here, go to idle if we aren't there yet
}
return PRESS_START; // Otherwise, go back to press start
}
/*
========================
idSessionLocal::Cancel
========================
*/
void idSessionLocal::Cancel() {
NET_VERBOSE_PRINT( "NET: Cancel\n" );
if ( localState == STATE_PRESS_START ) {
return; // We're as far back as we can go
}
ClearVoiceGroups(); // this is here as a catch-all
// See what state we need to go to
switch ( GetBackState() ) {
case GAME_LOBBY:
EndMatch(); // End current match to go to game lobby
break;
case PARTY_LOBBY:
if ( GetPartyLobby().IsHost() ) {
if ( sessionOptions & OPTION_LEAVE_WITH_PARTY ) {
// NOTE - This will send a message on the team lobby channel,
// so it won't be affected by the fact that we're shutting down the game lobby
GetPartyLobby().NotifyPartyOfLeavingGameLobby();
} else {
// Host wants to be alone, disconnect all peers from the party
GetPartyLobby().DisconnectAllPeers();
}
// End the game lobby, and go back to party lobby as host
GetGameLobby().Shutdown();
GetGameStateLobby().Shutdown();
SetState( STATE_PARTY_LOBBY_HOST );
// Always remove this flag. SendGoodbye uses this to determine if we should send a "leave with party"
// and we don't want this flag hanging around, and causing false positives when it's called in the future.
// Make them set this each time.
sessionOptions &= ~OPTION_LEAVE_WITH_PARTY;
} else {
// If we aren't the host of a party and we want to go back to one, we need to create a party now
CreatePartyLobby( GetPartyLobby().parms );
}
break;
case IDLE:
// Go back to main menu
GetGameLobby().Shutdown();
GetGameStateLobby().Shutdown();
GetPartyLobby().Shutdown();
SetState( STATE_IDLE );
break;
case PRESS_START:
// Go back to press start/main
GetGameLobby().Shutdown();
GetGameStateLobby().Shutdown();
GetPartyLobby().Shutdown();
SetState( STATE_PRESS_START );
break;
}
// Validate the current lobby immediately
ValidateLobbies();
}
/*
========================
idSessionLocal::MoveToPressStart
========================
*/
void idSessionLocal::MoveToPressStart() {
if ( localState != STATE_PRESS_START ) {
assert( signInManager != NULL );
signInManager->RemoveAllLocalUsers();
hasShownVoiceRestrictionDialog = false;
MoveToMainMenu();
session->FinishDisconnect();
SetState( STATE_PRESS_START );
}
}
/*
========================
idSessionLocal::ShouldShowMigratingDialog
========================
*/
bool idSessionLocal::ShouldShowMigratingDialog() const {
const idLobby * activeLobby = GetActivePlatformLobby();
if ( activeLobby == NULL ) {
return false;
}
return activeLobby->ShouldShowMigratingDialog();
}
/*
========================
idSessionLocal::IsCurrentLobbyMigrating
========================
*/
bool idSessionLocal::IsCurrentLobbyMigrating() const {
const idLobby * activeLobby = GetActivePlatformLobby();
if ( activeLobby == NULL ) {
return false;
}
return activeLobby->IsMigrating();
}
/*
========================
idSessionLocal::IsLosingConnectionToHost
========================
*/
bool idSessionLocal::IsLosingConnectionToHost() const {
return GetActingGameStateLobby().IsLosingConnectionToHost();
}
/*
========================
idSessionLocal::WasMigrationGame
returns true if we are hosting a migrated game and we had valid migration data
========================
*/
bool idSessionLocal::WasMigrationGame() const {
return GetGameLobby().IsMigratedStatsGame();
}
/*
========================
idSessionLocal::ShouldRelaunchMigrationGame
returns true if we are hosting a migrated game and we had valid migration data
========================
*/
bool idSessionLocal::ShouldRelaunchMigrationGame() const {
return GetGameLobby().ShouldRelaunchMigrationGame() && !IsCurrentLobbyMigrating();
}
/*
========================
idSessionLocal::GetMigrationGameData
========================
*/
bool idSessionLocal::GetMigrationGameData( idBitMsg & msg, bool reading ) {
return GetGameLobby().GetMigrationGameData( msg, reading );
}
/*
========================
idSessionLocal::GetMigrationGameDataUser
========================
*/
bool idSessionLocal::GetMigrationGameDataUser( lobbyUserID_t lobbyUserID, idBitMsg & msg, bool reading ) {
if ( GetGameStateLobby().IsHost() ) {
return false;
}
return GetGameLobby().GetMigrationGameDataUser( lobbyUserID, msg, reading );
}
/*
========================
idSessionLocal::GetMatchParamUpdate
========================
*/
bool idSessionLocal::GetMatchParamUpdate( int &peer, int &msg ){
if ( storedPeer != -1 && storedMsgType != -1 ) {
peer = storedPeer;
msg = storedMsgType;
storedPeer = -1;
storedMsgType = -1;
return true;
}
return false;
}
/*
========================
idSessionLocal::UpdatePartyParms
Updates the party parameters when in a party lobby OR a game lobby in order to keep them always in sync.
========================
*/
void idSessionLocal::UpdatePartyParms( const idMatchParameters & p ) {
if ( ( GetState() != PARTY_LOBBY && GetState() != GAME_LOBBY ) || !GetPartyLobby().IsHost() ) {
return;
}
// NET_VERBOSE_PRINT( "NET: UpdatePartyParms\n" );
GetPartyLobby().UpdateMatchParms( p );
}
/*
========================
idSessionLocal::UpdateMatchParms
========================
*/
void idSessionLocal::UpdateMatchParms( const idMatchParameters & p ) {
if ( GetState() != GAME_LOBBY || !GetGameLobby().IsHost() ) {
return;
}
NET_VERBOSE_PRINT( "NET: UpdateMatchParms\n" );
GetGameLobby().UpdateMatchParms( p );
}
/*
========================
idSessionLocal::StartSessions
========================
*/
void idSessionLocal::StartSessions() {
if ( GetPartyLobby().lobbyBackend != NULL ) {
GetPartyLobby().lobbyBackend->StartSession();
}
if ( GetGameLobby().lobbyBackend != NULL ) {
GetGameLobby().lobbyBackend->StartSession();
}
SetLobbiesAreJoinable( false );
}
/*
========================
idSessionLocal::EndSessions
========================
*/
void idSessionLocal::EndSessions() {
if ( GetPartyLobby().lobbyBackend != NULL ) {
GetPartyLobby().lobbyBackend->EndSession();
}
if ( GetGameLobby().lobbyBackend != NULL ) {
GetGameLobby().lobbyBackend->EndSession();
}
SetLobbiesAreJoinable( true );
}
/*
========================
idSessionLocal::SetLobbiesAreJoinable
========================
*/
void idSessionLocal::SetLobbiesAreJoinable( bool joinable ) {
// NOTE - We don't manipulate the joinable state when we are supporting join in progress
// Lobbies will naturally be non searchable when there are no free slots
if ( GetPartyLobby().lobbyBackend != NULL && !MatchTypeIsJoinInProgress( GetPartyLobby().parms.matchFlags ) ) {
NET_VERBOSE_PRINT( "Party lobbyBackend SetIsJoinable: %d\n", joinable );
GetPartyLobby().lobbyBackend->SetIsJoinable( joinable );
}
if ( GetGameLobby().lobbyBackend != NULL && !MatchTypeIsJoinInProgress( GetGameLobby().parms.matchFlags ) ) {
GetGameLobby().lobbyBackend->SetIsJoinable( joinable );
NET_VERBOSE_PRINT( "Game lobbyBackend SetIsJoinable: %d\n", joinable );
}
}
/*
========================
idSessionLocal::MoveToMainMenu
========================
*/
void idSessionLocal::MoveToMainMenu() {
GetPartyLobby().Shutdown();
GetGameLobby().Shutdown();
GetGameStateLobby().Shutdown();
SetState( STATE_IDLE );
}
/*
========================
idSessionLocal::HandleVoiceRestrictionDialog
========================
*/
void idSessionLocal::HandleVoiceRestrictionDialog() {
// don't bother complaining about voice restrictions when in a splitscreen lobby
if ( MatchTypeIsLocal( GetActivePlatformLobby()->parms.matchFlags ) ) {
return;
}
// Pop a dialog up the first time we are in a lobby and have voice chat restrictions due to account privileges
if ( voiceChat != NULL && voiceChat->IsRestrictedByPrivleges() && !hasShownVoiceRestrictionDialog ) {
common->Dialog().AddDialog( GDM_VOICE_RESTRICTED, DIALOG_ACCEPT, NULL, NULL, false );
hasShownVoiceRestrictionDialog = true;
}
}
/*
========================
idSessionLocal::WaitOnLobbyCreate
Called from State_Create_And_Move_To_Party_Lobby and State_Create_And_Move_To_Game_Lobby and State_Create_And_Move_To_Game_State_Lobby.
This function will create the lobby, then wait for it to either succeed or fail.
========================
*/
bool idSessionLocal::WaitOnLobbyCreate( idLobby & lobby ) {
assert( localState == STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY || localState == STATE_CREATE_AND_MOVE_TO_GAME_LOBBY || localState == STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY );
assert( connectType == CONNECT_FIND_OR_CREATE || connectType == CONNECT_NONE );
if ( lobby.GetState() == idLobby::STATE_FAILED ) {
NET_VERBOSE_PRINT( "NET: idSessionLocal::WaitOnLobbyCreate lobby.GetState() == idLobby::STATE_FAILED (%s)\n", lobby.GetLobbyName() );
// If we failed to create a lobby, assume connection to backend service was lost
MoveToMainMenu();
common->Dialog().ClearDialogs( true );
common->Dialog().AddDialog( GDM_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, true, "", 0, true );
return false;
}
if ( DetectDisconnectFromService( true ) ) {
return false;
}
if ( lobby.GetState() != idLobby::STATE_IDLE ) {
return false; // Valid but busy
}
NET_VERBOSE_PRINT( "NET: idSessionLocal::WaitOnLobbyCreate SUCCESS (%s)\n", lobby.GetLobbyName() );
return true;
}
/*
========================
idSessionLocal::DetectDisconnectFromService
Called from CreateMatch/CreatePartyLobby/FindOrCreateMatch state machines
========================
*/
bool idSessionLocal::DetectDisconnectFromService( bool cancelAndShowMsg ) {
const int DETECT_SERVICE_DISCONNECT_TIMEOUT_IN_SECONDS = session->GetTitleStorageInt( "DETECT_SERVICE_DISCONNECT_TIMEOUT_IN_SECONDS", 30 );
// If we are taking too long, cancel the connection
if ( DETECT_SERVICE_DISCONNECT_TIMEOUT_IN_SECONDS > 0 ) {
if ( Sys_Milliseconds() - connectTime > 1000 * DETECT_SERVICE_DISCONNECT_TIMEOUT_IN_SECONDS ) {
NET_VERBOSE_PRINT( "NET: idSessionLocal::DetectDisconnectFromService timed out\n" );
if ( cancelAndShowMsg ) {
MoveToMainMenu();
common->Dialog().ClearDialogs( true );
common->Dialog().AddDialog( GDM_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true );
}
return true;
}
}
return false;
}
/*
========================
idSessionLocal::HandleConnectionFailed
Called anytime a connection fails, and does the right thing.
========================
*/
void idSessionLocal::HandleConnectionFailed( idLobby & lobby, bool wasFull ) {
assert( localState == STATE_CONNECT_AND_MOVE_TO_PARTY || localState == STATE_CONNECT_AND_MOVE_TO_GAME || localState == STATE_CONNECT_AND_MOVE_TO_GAME_STATE );
assert( connectType == CONNECT_FIND_OR_CREATE || connectType == CONNECT_DIRECT );
bool canPlayOnline = true;
// Check for online status (this is only a problem on the PS3 at the moment. The 360 LIVE system handles this for us
if ( GetSignInManager().GetMasterLocalUser() != NULL ) {
canPlayOnline = GetSignInManager().GetMasterLocalUser()->CanPlayOnline();
}
if ( connectType == CONNECT_FIND_OR_CREATE ) {
// Clear the "Lobby was Full" dialog in case it's up
// We only want to see this msg when doing a direct connect (CONNECT_DIRECT)
common->Dialog().ClearDialog( GDM_LOBBY_FULL );
assert( localState == STATE_CONNECT_AND_MOVE_TO_GAME || localState == STATE_CONNECT_AND_MOVE_TO_GAME_STATE );
assert( lobby.lobbyType == idLobby::TYPE_GAME );
if ( !lobby.ConnectToNextSearchResult() ) {
CreateMatch( GetGameLobby().parms ); // Assume any time we are connecting to a game lobby, it is from a FindOrCreateMatch call, so create a match
}
} else if ( connectType == CONNECT_DIRECT ) {
if ( localState == STATE_CONNECT_AND_MOVE_TO_GAME && GetPartyLobby().IsPeer() ) {
int flags = GetPartyLobby().parms.matchFlags;
if ( MatchTypeIsOnline( flags ) && ( flags & MATCH_REQUIRE_PARTY_LOBBY ) && ( ( flags & MATCH_PARTY_INVITE_PLACEHOLDER ) == 0 ) ) {
// We get here when our party host told us to connect to a game, but the game didn't exist.
// Just drop back to the party lobby and wait for further orders.
SetState( STATE_PARTY_LOBBY_PEER );
return;
}
}
if ( wasFull ) {
common->Dialog().AddDialog( GDM_LOBBY_FULL, DIALOG_ACCEPT, NULL, NULL, false );
} else if ( !canPlayOnline ) {
common->Dialog().AddDialog( GDM_PLAY_ONLINE_NO_PROFILE, DIALOG_ACCEPT, NULL, NULL, false );
} else {
// TEMP HACK: We detect the steam lobby is full in idLobbyBackendWin, and then STATE_FAILED, which brings us here. Need to find a way to notify
// session local that the game was full so we don't do this check here
// eeubanks: Pollard, how do you think we should handle this?
if ( !common->Dialog().HasDialogMsg( GDM_LOBBY_FULL, NULL ) ) {
common->Dialog().AddDialog( GDM_INVALID_INVITE, DIALOG_ACCEPT, NULL, NULL, false );
}
}
MoveToMainMenu();
} else {
// Shouldn't be possible, but just in case
MoveToMainMenu();
}
}
/*
========================
idSessionLocal::HandleConnectAndMoveToLobby
Called from State_Connect_And_Move_To_Party/State_Connect_And_Move_To_Game
========================
*/
bool idSessionLocal::HandleConnectAndMoveToLobby( idLobby & lobby ) {
assert( localState == STATE_CONNECT_AND_MOVE_TO_PARTY || localState == STATE_CONNECT_AND_MOVE_TO_GAME || localState == STATE_CONNECT_AND_MOVE_TO_GAME_STATE );
assert( connectType == CONNECT_FIND_OR_CREATE || connectType == CONNECT_DIRECT );
if ( lobby.GetState() == idLobby::STATE_FAILED ) {
// If we get here, we were trying to connect to a lobby (from state State_Connect_And_Move_To_Party/State_Connect_And_Move_To_Game)
HandleConnectionFailed( lobby, false );
return true;
}
if ( lobby.GetState() != idLobby::STATE_IDLE ) {
return HandlePackets(); // Valid but busy
}
assert( !GetPartyLobby().waitForPartyOk );
//
// Past this point, we've connected to the lobby
//
// If we are connecting to a game lobby, see if we need to keep waiting as either a host or peer while we're confirming all party members made it
if ( lobby.lobbyType == idLobby::TYPE_GAME ) {
if ( GetPartyLobby().IsHost() ) {
// As a host, wait until all party members make it
assert( !GetGameLobby().waitForPartyOk );
const int timeoutMs = session->GetTitleStorageInt( "net_connectTimeoutInSeconds", net_connectTimeoutInSeconds.GetInteger() ) * 1000;
if ( timeoutMs != 0 && Sys_Milliseconds() - lobby.helloStartTime > timeoutMs ) {
// Took too long, move to next result, or create a game instead
HandleConnectionFailed( lobby, false );
return true;
}
int numUsersIn = 0;
for ( int i = 0; i < GetPartyLobby().GetNumLobbyUsers(); i++ ) {
if ( net_testPartyMemberConnectFail.GetInteger() == i ) {
continue;
}
bool foundUser = false;
lobbyUser_t * partyUser = GetPartyLobby().GetLobbyUser( i );
for ( int j = 0; j < GetGameLobby().GetNumLobbyUsers(); j++ ) {
lobbyUser_t * gameUser = GetGameLobby().GetLobbyUser( j );
if ( GetGameLobby().IsSessionUserLocal( gameUser ) || gameUser->address.Compare( partyUser->address, true ) ) {
numUsersIn++;
foundUser = true;
break;
}
}
assert( !GetPartyLobby().IsSessionUserIndexLocal( i ) || foundUser );
}
if ( numUsersIn != GetPartyLobby().GetNumLobbyUsers() ) {
return HandlePackets(); // All users not in, keep waiting until all user make it, or we time out
}
NET_VERBOSE_PRINT( "NET: All party members made it into the game lobby.\n" );
// Let all the party members know everyone made it, and it's ok to stay at this server
for ( int i = 0; i < GetPartyLobby().peers.Num(); i++ ) {
if ( GetPartyLobby().peers[ i ].IsConnected() ) {
GetPartyLobby().QueueReliableMessage( i, idLobby::RELIABLE_PARTY_CONNECT_OK );
}
}
} else {
if ( !verify ( lobby.host != -1 ) ) {
MoveToMainMenu();
connectType = CONNECT_NONE;
return false;
}
// As a peer, wait for server to tell us everyone made it
if ( GetGameLobby().waitForPartyOk ) {
const int timeoutMs = session->GetTitleStorageInt( "net_connectTimeoutInSeconds", net_connectTimeoutInSeconds.GetInteger() ) * 1000;
if ( timeoutMs != 0 && Sys_Milliseconds() - lobby.helloStartTime > timeoutMs ) {
GetGameLobby().waitForPartyOk = false; // Just connect to this game lobby if we haven't heard from the party host for the entire timeout duration
}
}
if ( GetGameLobby().waitForPartyOk ) {
return HandlePackets(); // Waiting on party host to tell us everyone made it
}
}
}
// Success
switch ( lobby.lobbyType ) {
case idLobby::TYPE_PARTY:
SetState( STATE_PARTY_LOBBY_PEER );
break;
case idLobby::TYPE_GAME:
SetState( STATE_GAME_LOBBY_PEER );
break;
case idLobby::TYPE_GAME_STATE:
waitingOnGameStateMembersToJoinTime = Sys_Milliseconds();
// As a host of the game lobby, it's our duty to notify our members to also join this game state lobby
GetGameLobby().SendMembersToLobby( GetGameStateLobby(), false );
SetState( STATE_GAME_STATE_LOBBY_PEER );
break;
}
connectType = CONNECT_NONE;
return false;
}
/*
========================
idSessionLocal::State_Create_And_Move_To_Party_Lobby
========================
*/
bool idSessionLocal::State_Create_And_Move_To_Party_Lobby() {
if ( WaitOnLobbyCreate( GetPartyLobby() ) ) {
if ( GetPartyLobby().parms.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) {
// If this party lobby was for a placeholder, continue on with either finding or creating a game lobby
if ( connectType == CONNECT_FIND_OR_CREATE ) {
FindOrCreateMatch( GetPartyLobby().parms );
return true;
} else if ( connectType == CONNECT_NONE ) {
CreateMatch( GetPartyLobby().parms );
return true;
}
}
// Success
SetState( STATE_PARTY_LOBBY_HOST );
return true;
}
return HandlePackets(); // Valid but busy
}
/*
========================
idSessionLocal::State_Create_And_Move_To_Game_Lobby
========================
*/
bool idSessionLocal::State_Create_And_Move_To_Game_Lobby() {
if ( WaitOnLobbyCreate( GetGameLobby() ) ) {
// Success
SetState( STATE_GAME_LOBBY_HOST );
// Now that we've created our game lobby, send our own party users to it
// NOTE - We pass in false to wait on party members since we are the host, and we know they can connect to us
GetPartyLobby().SendMembersToLobby( GetGameLobby(), false );
return true;
}
return false;
}
/*
========================
idSessionLocal::State_Create_And_Move_To_Game_State_Lobby
========================
*/
bool idSessionLocal::State_Create_And_Move_To_Game_State_Lobby() {
if ( WaitOnLobbyCreate( GetGameStateLobby() ) ) {
// Success
SetState( STATE_GAME_STATE_LOBBY_HOST );
// Now that we've created our game state lobby, send our own game users to it
// NOTE - We pass in false to wait on party members since we are the host, and we know they can connect to us
GetGameLobby().SendMembersToLobby( GetGameStateLobby(), false );
// If we are the host of a game lobby, we know we are not using dedicated servers, so we want to start the match immediately
// as soon as we detect all users have connected.
if ( GetGameLobby().IsHost() ) {
waitingOnGameStateMembersToJoinTime = Sys_Milliseconds();
}
return true;
}
return false;
}
/*
========================
idSessionLocal::State_Find_Or_Create_Match
========================
*/
bool idSessionLocal::State_Find_Or_Create_Match() {
assert( connectType == CONNECT_FIND_OR_CREATE );
if ( GetGameLobby().GetState() == idLobby::STATE_FAILED ) {
// Failed to find any games. Create one instead (we're assuming this always gets called from FindOrCreateMatch
CreateMatch( GetGameLobby().parms );
return true;
}
if ( DetectDisconnectFromService( true ) ) {
return false;
}
if ( GetGameLobby().GetState() != idLobby::STATE_IDLE ) {
return HandlePackets(); // Valid but busy
}
// Done searching, connect to the first search result
if ( !GetGameLobby().ConnectToNextSearchResult() ) {
// Failed to find any games. Create one instead (we're assuming this always gets called from FindOrCreateMatch
CreateMatch( GetGameLobby().parms );
return true;
}
SetState( STATE_CONNECT_AND_MOVE_TO_GAME );
return true;
}
/*
========================
idSessionLocal::State_Connect_And_Move_To_Party
========================
*/
bool idSessionLocal::State_Connect_And_Move_To_Party() {
return HandleConnectAndMoveToLobby( GetPartyLobby() );
}
/*
========================
idSessionLocal::State_Connect_And_Move_To_Game
========================
*/
bool idSessionLocal::State_Connect_And_Move_To_Game() {
return HandleConnectAndMoveToLobby( GetGameLobby() );
}
/*
========================
idSessionLocal::State_Connect_And_Move_To_Game_State
========================
*/
bool idSessionLocal::State_Connect_And_Move_To_Game_State() {
return HandleConnectAndMoveToLobby( GetGameStateLobby() );
}
/*
========================
idSessionLocal::State_InGame
========================
*/
bool idSessionLocal::State_InGame() {
return HandlePackets();
}
/*
========================
idSessionLocal::State_Loading
========================
*/
bool idSessionLocal::State_Loading() {
HandlePackets();
if ( !GetActingGameStateLobby().loaded ) {
return false;
}
SetVoiceGroupsToTeams();
if ( GetActingGameStateLobby().IsHost() ) {
bool everyoneLoaded = true;
for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
idLobby::peer_t & peer = GetActingGameStateLobby().peers[p];
if ( !peer.IsConnected() ) {
continue; // We don't care about peers that aren't connected as a game session
}
if ( !peer.loaded ) {
everyoneLoaded = false;
continue; // Don't waste time sending resources to a peer who hasn't loaded the map yet
}
if ( GetActingGameStateLobby().SendResources( p ) ) {
everyoneLoaded = false;
// if client is taking a LONG time to load up - give them the boot: they're just holding up the lunch line. Useful for loose assets playtesting.
int time = Sys_Milliseconds();
int maxLoadTime = net_maxLoadResourcesTimeInSeconds.GetInteger();
if ( maxLoadTime > 0 && peer.startResourceLoadTime + SEC2MS( maxLoadTime ) < time ) {
NET_VERBOSERESOURCE_PRINT( "NET: dropping client %i - %s because they took too long to load resources.\n Check 'net_maxLoadResourcesTimeInSeconds' to adjust the time allowed.\n", p, GetPeerName( p ) );
GetActingGameStateLobby().DisconnectPeerFromSession( p );
continue;
}
}
}
if ( !everyoneLoaded ) {
return false;
}
} else {
// not sure how we got there, but we won't be receiving anything that could get us out of this state anymore
// possible step towards fixing the join stalling/disconnect problems
if ( GetActingGameStateLobby().peers.Num() == 0 ) {
NET_VERBOSE_PRINT( "NET: no peers in idSessionLocal::State_Loading - giving up\n" );
MoveToMainMenu();
}
// need at least a peer with a real connection
bool haveOneGoodPeer = false;
for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
if ( GetActingGameStateLobby().peers[p].IsConnected() ) {
haveOneGoodPeer = true;
break;
}
}
if ( !haveOneGoodPeer ) {
NET_VERBOSE_PRINT( "NET: no good peers in idSessionLocal::State_Loading - giving up\n" );
MoveToMainMenu();
}
return false;
}
GetActingGameStateLobby().ResetBandwidthStats();
// if we got here then we're the host and everyone indicated map load finished
NET_VERBOSE_PRINT( "NET: (loading) Starting Game\n" );
SetState( STATE_INGAME ); // NOTE - Only the host is in-game at this point, all peers will start becoming in-game when they receive their first full snap
return true;
}
/*
========================
idSessionLocal::State_Busy
========================
*/
bool idSessionLocal::State_Busy() {
idLobby * activeLobby = GetActivePlatformLobby();
if ( activeLobby == NULL ) {
idLib::Warning("No active session lobby when idSessionLocal::State_Busy called");
return false;
}
if ( activeLobby->bandwidthChallengeFinished ) {
// Start loading
NET_VERBOSE_PRINT( "NET: Bandwidth test finished - Start loading\n" );
StartLoading();
}
return HandlePackets();
}
/*
========================
idSessionLocal::VerifySnapshotInitialState
========================
*/
void idSessionLocal::VerifySnapshotInitialState() {
// Verify that snapshot state is reset
for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
if ( !GetActingGameStateLobby().peers[p].IsConnected() ) {
assert( GetActingGameStateLobby().peers[p].snapProc == NULL );
continue;
}
assert( GetActingGameStateLobby().peers[p].snapProc != NULL );
if ( !verify( GetActingGameStateLobby().peers[p].needToSubmitPendingSnap == false ) ) {
idLib::Error( "Invalid needToSubmitPendingSnap state\n" );
}
if ( !verify( GetActingGameStateLobby().peers[p].snapProc->HasPendingSnap() == false ) ) {
idLib::Error( "Invalid HasPendingSnap state\n" );
}
if ( !verify( GetActingGameStateLobby().peers[p].snapProc->GetSnapSequence() == idSnapshotProcessor::INITIAL_SNAP_SEQUENCE ) ) {
idLib::Error( "Invalid INITIAL_SNAP_SEQUENCE state %d for peer %d \n", GetActingGameStateLobby().peers[p].snapProc->GetSnapSequence(), p );
}
if ( !verify( GetActingGameStateLobby().peers[p].snapProc->GetBaseSequence() == -1 ) ) {
idLib::Error( "Invalid GetBaseSequence state\n" );
}
}
}
/*
========================
idSessionLocal::State_Party_Lobby_Host
========================
*/
bool idSessionLocal::State_Party_Lobby_Host() {
HandleVoiceRestrictionDialog();
return HandlePackets();
}
/*
========================
idSessionLocal::State_Game_Lobby_Host
========================
*/
bool idSessionLocal::State_Game_Lobby_Host() {
HandleVoiceRestrictionDialog();
return HandlePackets();
}
/*
========================
idSessionLocal::State_Game_State_Lobby_Host
========================
*/
bool idSessionLocal::State_Game_State_Lobby_Host() {
HandleVoiceRestrictionDialog();
if ( waitingOnGameStateMembersToLeaveTime != 0 ) {
const int MAX_LEAVE_WAIT_TIME_IN_SECONDS = 5;
const bool forceDisconnectMembers = ( Sys_Milliseconds() - waitingOnGameStateMembersToLeaveTime ) > MAX_LEAVE_WAIT_TIME_IN_SECONDS * 1000;
// Check to see if all peers have finally left
if ( GetGameStateLobby().GetNumConnectedPeers() == 0 || forceDisconnectMembers ) {
//
// All peers left, we can stop waiting
//
waitingOnGameStateMembersToLeaveTime = 0;
assert( !GetGameLobby().IsPeer() );
if ( GetGameLobby().IsHost() ) {
// If we aren't a dedicated game state host, then drop back to the game lobby as host
GetGameStateLobby().Shutdown();
SetState( STATE_GAME_LOBBY_HOST );
} else {
// A dedicated game state host will remain in State_Game_State_Lobby_Host mode while waiting for another set of users to join
// DEDICATED_SERVER_FIXME: Notify master server we can server another game now
GetGameStateLobby().DisconnectAllPeers();
}
}
} else {
// When all the players from the game lobby are in the game state lobby, StartLoading
if ( GetGameLobby().IsHost() ) {
if ( GetGameStateLobby().GetNumLobbyUsers() == GetGameLobby().GetNumLobbyUsers() ) {
waitingOnGameStateMembersToJoinTime = 0;
StartLoading();
}
} else {
// The dedicated server host relies on the game host to say when all users are in
if ( GetGameStateLobby().startLoadingFromHost ) {
GetGameStateLobby().startLoadingFromHost = false;
StartLoading();
}
}
}
return HandlePackets();
}
/*
========================
idSessionLocal::State_Party_Lobby_Peer
========================
*/
bool idSessionLocal::State_Party_Lobby_Peer() {
HandleVoiceRestrictionDialog();
return HandlePackets();
}
/*
========================
idSessionLocal::State_Game_Lobby_Peer
========================
*/
bool idSessionLocal::State_Game_Lobby_Peer() {
HandleVoiceRestrictionDialog();
bool saving = false;
idPlayerProfile * profile = GetProfileFromMasterLocalUser();
if ( profile != NULL && ( profile->GetState() == idPlayerProfile::SAVING || profile->GetRequestedState() == idPlayerProfile::SAVE_REQUESTED ) ) {
saving = true;
}
if ( GetActingGameStateLobby().startLoadingFromHost && !saving ) {
common->Dialog().ClearDialog( GDM_HOST_RETURNED_TO_LOBBY );
common->Dialog().ClearDialog( GDM_HOST_RETURNED_TO_LOBBY_STATS_DROPPED );
VerifySnapshotInitialState();
// Set loading flag back to false
GetActingGameStateLobby().startLoadingFromHost = false;
// Set state to loading
SetState( STATE_LOADING );
loadingID++;
return true;
}
return HandlePackets();
}
/*
========================
idSessionLocal::State_Game_State_Lobby_Peer
========================
*/
bool idSessionLocal::State_Game_State_Lobby_Peer() {
// We are in charge of telling the dedicated host that all our members are in
if ( GetGameLobby().IsHost() && waitingOnGameStateMembersToJoinTime != 0 ) {
int foundMembers = 0;
for ( int i = 0; i < GetGameLobby().GetNumLobbyUsers(); i++ ) {
if ( GetGameStateLobby().GetLobbyUserByID( GetGameLobby().GetLobbyUser( i )->lobbyUserID, true ) != NULL ) {
foundMembers++;
}
}
// Give all of our game members 10 seconds to join, otherwise start without them
const int MAX_JOIN_WAIT_TIME_IN_SECONDS = 10;
const bool forceStart = ( Sys_Milliseconds() - waitingOnGameStateMembersToJoinTime ) > MAX_JOIN_WAIT_TIME_IN_SECONDS * 1000;
if ( foundMembers == GetGameLobby().GetNumLobbyUsers() || forceStart ) {
byte buffer[ idPacketProcessor::MAX_PACKET_SIZE ];
idBitMsg msg( buffer, sizeof( buffer ) );
// Write match paramaters to the game state host, and tell him to start
GetGameLobby().parms.Write( msg );
// Tell the game state lobby host we are ready
GetGameStateLobby().QueueReliableMessage( GetGameStateLobby().host, idLobby::RELIABLE_START_MATCH_GAME_LOBBY_HOST, msg.GetReadData(), msg.GetSize() );
waitingOnGameStateMembersToJoinTime = 0;
}
}
return State_Game_Lobby_Peer();
}
/*
========================
idSessionLocal::~idSession
========================
*/
idSession::~idSession() {
delete signInManager;
signInManager = NULL;
delete saveGameManager;
saveGameManager = NULL;
delete dedicatedServerSearch;
dedicatedServerSearch = NULL;
}
idCVar net_verbose( "net_verbose", "0", CVAR_BOOL, "Print a bunch of message about the network session" );
idCVar net_verboseResource( "net_verboseResource", "0", CVAR_BOOL, "Prints a bunch of message about network resources" );
idCVar net_verboseReliable( "net_verboseReliable", "0", CVAR_BOOL, "Prints the more spammy messages about reliable network msgs" );
idCVar si_splitscreen( "si_splitscreen", "0", CVAR_INTEGER, "force splitscreen" );
idCVar net_forceLatency( "net_forceLatency", "0", CVAR_INTEGER, "Simulate network latency (milliseconds round trip time - applied equally on the receive and on the send)" );
idCVar net_forceDrop( "net_forceDrop", "0", CVAR_INTEGER, "Percentage chance of simulated network packet loss" );
idCVar net_forceUpstream( "net_forceUpstream", "0", CVAR_FLOAT, "Force a maximum upstream in kB/s (256kbps <-> 32kB/s)" ); // I would much rather deal in kbps but most of the code is written in bytes ..
idCVar net_forceUpstreamQueue( "net_forceUpstreamQueue", "64", CVAR_INTEGER, "How much data is queued when enforcing upstream (in kB)" );
idCVar net_verboseSimulatedTraffic( "net_verboseSimulatedTraffic", "0", CVAR_BOOL, "Print some stats about simulated traffic (net_force* cvars)" );
/*
========================
idSessionLocal::Initialize
========================
*/
void idSessionLocal::Initialize() {
}
/*
========================
idSessionLocal::Shutdown
========================
*/
void idSessionLocal::Shutdown() {
}
/*
========================
idSession interface semi-common between platforms (#ifdef's in sys_session_local.cpp)
========================
*/
idCVar com_deviceZeroOverride( "com_deviceZeroOverride", "-1", CVAR_INTEGER, "change input routing for device 0 to poll a different device" );
idCVar mp_bot_input_override( "mp_bot_input_override", "-1", CVAR_INTEGER, "Override local input routing for bot control" );
/*
========================
idSessionLocal::GetInputRouting
This function sets up inputRouting to be a mapping from inputDevice index to session user index.
========================
*/
int idSessionLocal::GetInputRouting( int inputRouting[ MAX_INPUT_DEVICES ] ) {
int numLocalUsers = 0;
for ( int i = 0; i < MAX_INPUT_DEVICES; i++ ) {
inputRouting[i] = -1;
}
for ( int i = 0; i < GetActingGameStateLobby().GetNumLobbyUsers(); i++ ) {
if ( GetActingGameStateLobby().IsSessionUserIndexLocal( i ) ) {
// Find the local user that this session user maps to
const idLocalUser * localUser = GetActingGameStateLobby().GetLocalUserFromLobbyUserIndex( i );
if ( localUser != NULL ) {
int localDevice = localUser->GetInputDevice();
if ( localDevice == 0 && com_deviceZeroOverride.GetInteger() > 0 ) {
localDevice = com_deviceZeroOverride.GetInteger();
}
assert( localDevice < MAX_INPUT_DEVICES );
// Route the input device that this local user is mapped to
assert( inputRouting[localDevice] == -1 ); // Make sure to only initialize each entry once
inputRouting[localDevice] = i;
if ( mp_bot_input_override.GetInteger() >= 0 ) {
inputRouting[localDevice] = mp_bot_input_override.GetInteger();
}
numLocalUsers++;
}
}
}
// For testing swapping controllers
if ( si_splitscreen.GetInteger() == 2 && numLocalUsers == 2 ) {
SwapValues( inputRouting[0], inputRouting[1] );
}
return numLocalUsers;
}
/*
========================
idSessionLocal::EndMatch
EndMatch is meant for the host to cleanly end a match and return to the lobby page
========================
*/
void idSessionLocal::EndMatch( bool premature /*=false*/ ) {
if ( verify( GetActingGameStateLobby().IsHost() ) ) {
// Host quits back to game lobby, and will notify peers internally to do the same
EndMatchInternal( premature );
}
}
/*
========================
idSessionLocal::EndMatch
this is for when the game is over before we go back to lobby. Need this incase the host leaves during this time
========================
*/
void idSessionLocal::MatchFinished( ) {
if ( verify( GetActingGameStateLobby().IsHost() ) ) {
// host is putting up end game stats make sure other peers know and clear migration data
MatchFinishedInternal();
}
}
/*
========================
idSessionLocal::QuitMatch
QuitMatch is considered a premature ending of a match, and does the right thing depending on whether the host or peer is quitting
========================
*/
void idSessionLocal::QuitMatch() {
if ( GetActingGameStateLobby().IsHost() && !MatchTypeIsRanked( GetActingGameStateLobby().parms.matchFlags ) ) {
EndMatch( true ); // When host quits private match, takes members back to game lobby
} else {
// Quitting a public match (or not being a host) before it ends takes you to an empty party lobby
CreatePartyLobby( GetActingGameStateLobby().parms );
}
}
/*
========================
idSessionLocal::QuitMatchToTitle
QuitMatchToTitle will forcefully quit the match and return to the title screen.
========================
*/
void idSessionLocal::QuitMatchToTitle() {
MoveToMainMenu();
}
/*
========================
idSessionLocal::ClearMigrationState
========================
*/
void idSessionLocal::ClearMigrationState() {
// We are ending the match without migration, so clear that state
GetPartyLobby().ResetAllMigrationState();
GetGameLobby().ResetAllMigrationState();
}
/*
========================
idSessionLocal::EndMatchInternal
========================
*/
void idSessionLocal::EndMatchInternal( bool premature/*=false*/ ) {
assert( GetGameStateLobby().IsLobbyActive() == net_useGameStateLobby.GetBool() );
ClearVoiceGroups();
for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
// If we are the host, increment the session ID. The client will use a rolling check to catch it
if ( GetActingGameStateLobby().IsHost() ) {
if ( GetActingGameStateLobby().peers[p].IsConnected() ) {
if ( GetActingGameStateLobby().peers[p].packetProc != NULL ) {
GetActingGameStateLobby().peers[p].packetProc->VerifyEmptyReliableQueue( idLobby::RELIABLE_GAME_DATA, idLobby::RELIABLE_DUMMY_MSG );
}
GetActingGameStateLobby().peers[p].sessionID = GetActingGameStateLobby().IncrementSessionID( GetActingGameStateLobby().peers[p].sessionID );
}
}
GetActingGameStateLobby().peers[p].ResetMatchData();
}
GetActingGameStateLobby().snapDeltaAckQueue.Clear();
GetActingGameStateLobby().loaded = false;
gameLobbyWasCoalesced = false; // Reset this back to false. We use this so the lobby code doesn't randomly choose a map when we coalesce
numFullSnapsReceived = 0;
ClearMigrationState();
if ( GetActingGameStateLobby().IsLobbyActive() && ( GetActingGameStateLobby().GetMatchParms().matchFlags & MATCH_REQUIRE_PARTY_LOBBY ) ) {
// All peers need to remove disconnected users to stay in sync
GetActingGameStateLobby().CompactDisconnectedUsers();
// Go back to the game lobby
if ( GetActingGameStateLobby().IsHost() ) {
// We want the game state host to go back to STATE_GAME_STATE_LOBBY_HOST, so he can wait on all his game state peers to leave
SetState( GetGameStateLobby().IsHost() ? STATE_GAME_STATE_LOBBY_HOST : STATE_GAME_LOBBY_HOST ); // We want the dedicated host to go back to STATE_GAME_STATE_LOBBY_HOST
} else {
SetState( STATE_GAME_LOBBY_PEER );
}
} else {
SetState( STATE_IDLE );
}
if ( GetActingGameStateLobby().IsHost() ) {
// Send a reliable msg to all peers to also "EndMatch"
for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
GetActingGameStateLobby().QueueReliableMessage( p, premature ? idLobby::RELIABLE_ENDMATCH_PREMATURE : idLobby::RELIABLE_ENDMATCH );
}
} else if ( premature ) {
// Notify client that host left early and thats why we are back in the lobby
const bool stats = MatchTypeHasStats( GetActingGameStateLobby().GetMatchParms().matchFlags ) && ( GetFlushedStats() == false );
common->Dialog().AddDialog( stats ? GDM_HOST_RETURNED_TO_LOBBY_STATS_DROPPED : GDM_HOST_RETURNED_TO_LOBBY, DIALOG_ACCEPT, NULL, NULL, false, __FUNCTION__, __LINE__, true );
}
if ( GetGameStateLobby().IsLobbyActive() ) {
if ( GetGameStateLobby().IsHost() ) {
// As a game state host, keep the lobby around, so we can make sure we know when everyone leaves (which means they got the reliable msg to EndMatch)
waitingOnGameStateMembersToLeaveTime = Sys_Milliseconds();
} else if ( GetGameStateLobby().IsPeer() ) {
// Game state lobby peers should disconnect now
GetGameStateLobby().Shutdown();
}
}
}
/*
========================
idSessionLocal::MatchFinishedInternal
========================
*/
void idSessionLocal::MatchFinishedInternal() {
ClearMigrationState();
if ( GetActingGameStateLobby().IsHost() ) {
// Send a reliable msg to all peers to also "EndMatch"
for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
GetActingGameStateLobby().QueueReliableMessage( p, idLobby::RELIABLE_MATCHFINISHED );
}
}
}
/*
========================
idSessionLocal::EndMatchForMigration
========================
*/
void idSessionLocal::EndMatchForMigration() {
ClearVoiceGroups();
}
/*
========================
idSessionLocal::ShouldHavePartyLobby
========================
*/
bool idSessionLocal::ShouldHavePartyLobby() {
if ( GetActivePlatformLobby() == NULL ) {
return false;
}
idMatchParameters & parms = GetActivePlatformLobby()->parms;
int flags = parms.matchFlags;
// Don't we always have a party lobby if we're online? At least in Doom 3?
return MatchTypeIsOnline( flags ) && ( ( flags & MATCH_PARTY_INVITE_PLACEHOLDER ) == 0 );
}
/*
========================
idSessionLocal::ValidateLobbies
Determines if any of the session instances need to become the host
========================
*/
void idSessionLocal::ValidateLobbies() {
if ( localState == STATE_PRESS_START || localState == STATE_IDLE ) {
// At press start or main menu, don't do anything
return;
}
if ( GetActivePlatformLobby() == NULL ) {
// If we're in between lobbies, don't do anything yet (the state transitioning code will handle error cases)
return;
}
// Validate lobbies that should be alive and active
if ( ShouldHavePartyLobby() && GetState() >= idSession::PARTY_LOBBY ) {
ValidateLobby( GetPartyLobby() );
}
if ( GetState() >= idSession::GAME_LOBBY && !net_headlessServer.GetBool() ) {
ValidateLobby( GetGameLobby() );
}
}
/*
========================
idSessionLocal::ValidateLobby
========================
*/
void idSessionLocal::ValidateLobby( idLobby & lobby ) {
if ( lobby.lobbyBackend == NULL || lobby.lobbyBackend->GetState() == idLobbyBackend::STATE_FAILED || lobby.GetState() == idLobby::STATE_FAILED ) {
NET_VERBOSE_PRINT( "NET: ValidateLobby: FAILED (lobbyType = %i, state = %s)\n", lobby.lobbyType, stateToString[ localState ] );
if ( lobby.failedReason == idLobby::FAILED_MIGRATION_CONNECT_FAILED || lobby.failedReason == idLobby::FAILED_CONNECT_FAILED ) {
MoveToMainMenu();
common->Dialog().AddDialog( GDM_INVALID_INVITE, DIALOG_ACCEPT, NULL, NULL, false ); // The game session no longer exists
} else {
// If the lobbyBackend goes bad under our feet for no known reason, assume we lost connection to the back end service
MoveToMainMenu();
common->Dialog().ClearDialogs( true );
common->Dialog().AddDialog( GDM_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, false ); // Lost connection to XBox LIVE
}
}
}
/*
========================
idSessionLocal::Pump
========================
*/
void idSessionLocal::Pump() {
SCOPED_PROFILE_EVENT( "Session::Pump" );
static int lastPumpTime = -1;
const int time = Sys_Milliseconds();
const int elapsedPumpSeconds = ( time - lastPumpTime ) / 1000;
if ( lastPumpTime != -1 && elapsedPumpSeconds > 2 ) {
idLib::Warning( "idSessionLocal::Pump was not called for %i seconds", elapsedPumpSeconds );
}
lastPumpTime = time;
if ( net_migrateHost.GetInteger() >= 0 ) {
if ( net_migrateHost.GetInteger() <= 2 ) {
if ( net_migrateHost.GetInteger() == 0 ) {
GetPartyLobby().PickNewHost( true, true );
} else {
GetGameLobby().PickNewHost( true, true );
}
} else {
GetPartyLobby().PickNewHost( true, true );
GetGameLobby().PickNewHost( true, true );
}
net_migrateHost.SetInteger( -1 );
}
PlatformPump();
if ( HasAchievementSystem() ) {
GetAchievementSystem().Pump();
}
// Send any voice packets if it's time
SendVoiceAudio();
bool shouldContinue = true;
while ( shouldContinue ) {
// Each iteration, validate the session instances
ValidateLobbies();
// Pump state
shouldContinue = HandleState();
// Pump lobbies
PumpLobbies();
}
if ( GetPartyLobby().lobbyBackend != NULL ) {
// Make sure game properties aren't set on the lobbyBackend if we aren't in a game lobby.
// This is so we show up properly in search results in Play with Friends option
GetPartyLobby().lobbyBackend->SetInGame( GetGameLobby().IsLobbyActive() );
// Temp location
UpdateMasterUserHeadsetState();
}
// Do some last minute checks, make sure everything about the current state and lobbyBackend state is valid, otherwise, take action
ValidateLobbies();
GetActingGameStateLobby().UpdateSnaps();
idLobby * activeLobby = GetActivePlatformLobby();
// Pump pings for the active lobby
if ( activeLobby != NULL ) {
activeLobby->PumpPings();
}
// Pump packet processing for all lobbies
GetPartyLobby().PumpPackets();
GetGameLobby().PumpPackets();
GetGameStateLobby().PumpPackets();
int currentTime = Sys_Milliseconds();
const int SHOW_MIGRATING_INFO_IN_SECONDS = 3; // Show for at least this long once we start showing it
if ( ShouldShowMigratingDialog() ) {
showMigratingInfoStartTime = currentTime;
} else if ( showMigratingInfoStartTime > 0 && ( ( currentTime - showMigratingInfoStartTime ) > SHOW_MIGRATING_INFO_IN_SECONDS * 1000 ) ) {
showMigratingInfoStartTime = 0;
}
bool isShowingMigrate = common->Dialog().HasDialogMsg( GDM_MIGRATING, NULL );
if ( showMigratingInfoStartTime != 0 ) {
if ( !isShowingMigrate ) {
common->Dialog().AddDialog( GDM_MIGRATING, DIALOG_WAIT, NULL, NULL, false, "", 0, false, false, true );
}
} else if ( isShowingMigrate ) {
common->Dialog().ClearDialog( GDM_MIGRATING );
}
// Update possible pending invite
UpdatePendingInvite();
// Check to see if we should coalesce the lobby
if ( nextGameCoalesceTime != 0 ) {
if ( GetGameLobby().IsLobbyActive() &&
GetGameLobby().IsHost() &&
GetState() == idSession::GAME_LOBBY &&
GetPartyLobby().GetNumLobbyUsers() <= 1 &&
GetGameLobby().GetNumLobbyUsers() == 1 &&
MatchTypeIsRanked( GetGameLobby().parms.matchFlags ) &&
Sys_Milliseconds() > nextGameCoalesceTime ) {
// If the player doesn't care about the mode or map,
// make sure the search is broadened.
idMatchParameters newGameParms = GetGameLobby().parms;
newGameParms.gameMap = GAME_MAP_RANDOM;
// Assume that if the party lobby's mode is random,
// the player chose "Quick Match" and doesn't care about the mode.
// If the player chose "Find Match" and a specific mode,
// the party lobby mode will be set to non-random.
if ( GetPartyLobby().parms.gameMode == GAME_MODE_RANDOM ) {
newGameParms.gameMode = GAME_MODE_RANDOM;
}
FindOrCreateMatch( newGameParms );
gameLobbyWasCoalesced = true; // Remember that this round was coalesced. We so this so main menu doesn't randomize the map, which looks odd
nextGameCoalesceTime = 0;
}
}
}
/*
========================
idSessionLocal::ProcessSnapAckQueue
========================
*/
void idSessionLocal::ProcessSnapAckQueue() {
if ( GetActingGameStateLobby().IsLobbyActive() ) {
GetActingGameStateLobby().ProcessSnapAckQueue();
}
}
/*
========================
idSessionLocal::UpdatePendingInvite
========================
*/
void idSessionLocal::UpdatePendingInvite() {
if ( pendingInviteMode == PENDING_INVITE_NONE ) {
return; // No pending invite
}
idLocalUser * masterLocalUser = signInManager->GetMasterLocalUser();
if ( masterLocalUser == NULL && signInManager->IsDeviceBeingRegistered( pendingInviteDevice ) ) {
idLib::Printf( "masterLocalUser == NULL\n" );
return; // Waiting on master to sign in to continue with invite
}
const bool wasFromInvite = pendingInviteMode == PENDING_INVITE_WAITING; // Remember if this was a real invite, or a self invitation (matters when lobby is invite only)
// At this point, the invitee should be ready
pendingInviteMode = PENDING_INVITE_NONE;
if ( masterLocalUser == NULL || masterLocalUser->GetInputDevice() != pendingInviteDevice || !masterLocalUser->IsOnline() ) {
idLib::Printf( "ignoring invite - master local user is not setup properly\n" );
return; // If there is no master, if the invitee is not online, or different than the current master, then ignore invite
}
// Clear any current dialogs, as we're going into a state which will be unstable for any current dialogs.
// Do we want to throw an assert if a dialog is currently up?
common->Dialog().ClearDialogs( true );
// Everything looks good, let's join the party
ConnectAndMoveToLobby( GetPartyLobby(), pendingInviteConnectInfo, wasFromInvite );
}
/*
========================
idSessionLocal::HandleState
========================
*/
bool idSessionLocal::HandleState() {
// Handle individual lobby states
GetPartyLobby().Pump();
GetGameLobby().Pump();
GetGameStateLobby().Pump();
// Let IsHost be authoritative on the qualification of peer/host state types
if ( GetPartyLobby().IsHost() && localState == STATE_PARTY_LOBBY_PEER ) {
SetState( STATE_PARTY_LOBBY_HOST );
} else if ( GetPartyLobby().IsPeer() && localState == STATE_PARTY_LOBBY_HOST ) {
SetState( STATE_PARTY_LOBBY_PEER );
}
// Let IsHost be authoritative on the qualification of peer/host state types
if ( GetGameLobby().IsHost() && localState == STATE_GAME_LOBBY_PEER ) {
SetState( STATE_GAME_LOBBY_HOST );
} else if ( GetGameLobby().IsPeer() && localState == STATE_GAME_LOBBY_HOST ) {
SetState( STATE_GAME_LOBBY_PEER );
}
switch ( localState ) {
case STATE_PRESS_START: return false;
case STATE_IDLE: HandlePackets(); return false; // Call handle packets, since packets from old sessions could still be in flight, which need to be emptied
case STATE_PARTY_LOBBY_HOST: return State_Party_Lobby_Host();
case STATE_PARTY_LOBBY_PEER: return State_Party_Lobby_Peer();
case STATE_GAME_LOBBY_HOST: return State_Game_Lobby_Host();
case STATE_GAME_LOBBY_PEER: return State_Game_Lobby_Peer();
case STATE_GAME_STATE_LOBBY_HOST: return State_Game_State_Lobby_Host();
case STATE_GAME_STATE_LOBBY_PEER: return State_Game_State_Lobby_Peer();
case STATE_LOADING: return State_Loading();
case STATE_INGAME: return State_InGame();
case STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY: return State_Create_And_Move_To_Party_Lobby();
case STATE_CREATE_AND_MOVE_TO_GAME_LOBBY: return State_Create_And_Move_To_Game_Lobby();
case STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY: return State_Create_And_Move_To_Game_State_Lobby();
case STATE_FIND_OR_CREATE_MATCH: return State_Find_Or_Create_Match();
case STATE_CONNECT_AND_MOVE_TO_PARTY: return State_Connect_And_Move_To_Party();
case STATE_CONNECT_AND_MOVE_TO_GAME: return State_Connect_And_Move_To_Game();
case STATE_CONNECT_AND_MOVE_TO_GAME_STATE: return State_Connect_And_Move_To_Game_State();
case STATE_BUSY: return State_Busy();
default:
idLib::Error( "HandleState: Unknown state in idSessionLocal" );
}
}
/*
========================
idSessionLocal::GetState
========================
*/
idSessionLocal::sessionState_t idSessionLocal::GetState() const {
// Convert our internal state to one of the external states
switch ( localState ) {
case STATE_PRESS_START: return PRESS_START;
case STATE_IDLE: return IDLE;
case STATE_PARTY_LOBBY_HOST: return PARTY_LOBBY;
case STATE_PARTY_LOBBY_PEER: return PARTY_LOBBY;
case STATE_GAME_LOBBY_HOST: return GAME_LOBBY;
case STATE_GAME_LOBBY_PEER: return GAME_LOBBY;
case STATE_GAME_STATE_LOBBY_HOST: return GAME_LOBBY;
case STATE_GAME_STATE_LOBBY_PEER: return GAME_LOBBY;
case STATE_LOADING: return LOADING;
case STATE_INGAME: return INGAME;
case STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY: return CONNECTING;
case STATE_CREATE_AND_MOVE_TO_GAME_LOBBY: return CONNECTING;
case STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY: return CONNECTING;
case STATE_FIND_OR_CREATE_MATCH: return SEARCHING;
case STATE_CONNECT_AND_MOVE_TO_PARTY: return CONNECTING;
case STATE_CONNECT_AND_MOVE_TO_GAME: return CONNECTING;
case STATE_CONNECT_AND_MOVE_TO_GAME_STATE: return CONNECTING;
case STATE_BUSY: return BUSY;
default: {
idLib::Error( "GetState: Unknown state in idSessionLocal" );
}
};
}
const char * idSessionLocal::GetStateString() const {
static const char * stateToString[] = {
ASSERT_ENUM_STRING( STATE_PRESS_START, 0 ),
ASSERT_ENUM_STRING( STATE_IDLE, 1 ),
ASSERT_ENUM_STRING( STATE_PARTY_LOBBY_HOST, 2 ),
ASSERT_ENUM_STRING( STATE_PARTY_LOBBY_PEER, 3 ),
ASSERT_ENUM_STRING( STATE_GAME_LOBBY_HOST, 4 ),
ASSERT_ENUM_STRING( STATE_GAME_LOBBY_PEER, 5 ),
ASSERT_ENUM_STRING( STATE_GAME_STATE_LOBBY_HOST, 6 ),
ASSERT_ENUM_STRING( STATE_GAME_STATE_LOBBY_PEER, 7 ),
ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_PARTY_LOBBY, 8 ),
ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_GAME_LOBBY, 9 ),
ASSERT_ENUM_STRING( STATE_CREATE_AND_MOVE_TO_GAME_STATE_LOBBY, 10 ),
ASSERT_ENUM_STRING( STATE_FIND_OR_CREATE_MATCH, 11 ),
ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_PARTY, 12 ),
ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_GAME, 13 ),
ASSERT_ENUM_STRING( STATE_CONNECT_AND_MOVE_TO_GAME_STATE, 14 ),
ASSERT_ENUM_STRING( STATE_BUSY, 15 ),
ASSERT_ENUM_STRING( STATE_LOADING, 16 ),
ASSERT_ENUM_STRING( STATE_INGAME, 17 )
};
return stateToString[ localState ];
}
// idSession interface
/*
========================
idSessionLocal::LoadingFinished
Only called by idCommonLocal::FinalizeMapChange
========================
*/
void idSessionLocal::LoadingFinished() {
NET_VERBOSE_PRINT( "NET: Loading Finished\n" );
assert( GetState() == idSession::LOADING );
common->Dialog().ClearDialog( GDM_VOICE_RESTRICTED );
GetActingGameStateLobby().loaded = true;
if ( MatchTypeIsLocal( GetActingGameStateLobby().parms.matchFlags ) ) {
SetState( STATE_INGAME );
} else if ( !GetActingGameStateLobby().IsHost() ) { // Tell game host we're done loading
byte buffer[ idPacketProcessor::MAX_PACKET_SIZE ];
idBitMsg msg( buffer, sizeof( buffer ) );
GetActingGameStateLobby().QueueReliableMessage( GetActingGameStateLobby().host, idLobby::RELIABLE_LOADING_DONE, msg.GetReadData(), msg.GetSize() );
} else {
SetState( STATE_INGAME );
}
SetFlushedStats( false );
}
/*
========================
idSessionLocal::SendUsercmds
========================
*/
void idSessionLocal::SendUsercmds( idBitMsg & msg ) {
if ( localState != STATE_INGAME ) {
return;
}
if ( GetActingGameStateLobby().IsPeer() ) {
idLobby::peer_t & hostPeer = GetActingGameStateLobby().peers[GetActingGameStateLobby().host];
// Don't send user cmds if we have unsent packet fragments
// (This can happen if we have packets to send, but SendAnotherFragment got throttled)
if ( hostPeer.packetProc->HasMoreFragments() ) {
idLib::Warning( "NET: Client called SendUsercmds while HasMoreFragments(). Skipping userCmds for this frame." );
return;
}
int sequence = hostPeer.snapProc->GetLastAppendedSequence();
// Add incoming BPS for QoS
float incomingBPS = hostPeer.receivedBps;
if ( hostPeer.receivedBpsIndex != sequence ) {
incomingBPS = idMath::ClampFloat( 0.0f, static_cast<float>( idLobby::BANDWIDTH_REPORTING_MAX ), hostPeer.packetProc->GetIncomingRateBytes() );
hostPeer.receivedBpsIndex = sequence;
hostPeer.receivedBps = incomingBPS;
}
uint16 incomingBPS_quantized = idMath::Ftoi( incomingBPS * ( ( BIT( idLobby::BANDWIDTH_REPORTING_BITS ) - 1 ) / idLobby::BANDWIDTH_REPORTING_MAX ) );
byte buffer[idPacketProcessor::MAX_FINAL_PACKET_SIZE];
lzwCompressionData_t lzwData;
idLZWCompressor lzwCompressor( &lzwData );
lzwCompressor.Start( buffer, sizeof( buffer ) );
lzwCompressor.WriteAgnostic( sequence );
lzwCompressor.WriteAgnostic( incomingBPS_quantized );
lzwCompressor.Write( msg.GetReadData(), msg.GetSize() );
lzwCompressor.End();
GetActingGameStateLobby().ProcessOutgoingMsg( GetActingGameStateLobby().host, buffer, lzwCompressor.Length(), false, 0 );
if ( net_debugBaseStates.GetBool() && sequence < 50 ) {
idLib::Printf( "NET: Acking snap %d \n", sequence );
}
}
}
/*
========================
idSessionLocal::SendSnapshot
========================
*/
void idSessionLocal::SendSnapshot( idSnapShot & ss ) {
for ( int p = 0; p < GetActingGameStateLobby().peers.Num(); p++ ) {
idLobby::peer_t & peer = GetActingGameStateLobby().peers[p];
if ( !peer.IsConnected() ) {
continue;
}
if ( !peer.loaded ) {
continue;
}
if ( peer.pauseSnapshots ) {
continue;
}
GetActingGameStateLobby().SendSnapshotToPeer( ss, p );
}
}
/*
========================
idSessionLocal::UpdateSignInManager
========================
*/
void idSessionLocal::UpdateSignInManager() {
if ( !HasSignInManager() ) {
return;
}
if ( net_headlessServer.GetBool() ) {
return;
}
// FIXME: We need to ask the menu system for this info. Just making a best guess for now
// (assume we are allowed to join the party as a splitscreen user if we are in the party lobby)
bool allowJoinParty = ( localState == STATE_PARTY_LOBBY_HOST || localState == STATE_PARTY_LOBBY_PEER ) && GetPartyLobby().state == idLobby::STATE_IDLE;
bool allowJoinGame = ( localState == STATE_GAME_LOBBY_HOST || localState == STATE_GAME_LOBBY_PEER ) && GetGameLobby().state == idLobby::STATE_IDLE;
bool eitherLobbyRunning = GetActivePlatformLobby() != NULL && ( GetPartyLobby().IsLobbyActive() || GetGameLobby().IsLobbyActive() );
bool onlineMatch = eitherLobbyRunning && MatchTypeIsOnline( GetActivePlatformLobby()->parms.matchFlags );
//=================================================================================
// Get the number of desired signed in local users depending on what mode we're in.
//=================================================================================
int minDesiredUsers = 0;
int maxDesiredUsers = Max( 1, signInManager->GetNumLocalUsers() );
if ( si_splitscreen.GetInteger() != 0 ) {
// For debugging, force 2 splitscreen players
minDesiredUsers = 2;
maxDesiredUsers = 2;
allowJoinGame = true;
} else if ( onlineMatch || ( eitherLobbyRunning == false ) ) {
// If this an online game, then only 1 user can join locally.
// Also, if no sessions are active, remove any extra players.
maxDesiredUsers = 1;
} else if ( allowJoinParty || allowJoinGame ) {
// If we are in the party lobby, allow 2 splitscreen users to join
maxDesiredUsers = 2;
}
// Set the number of desired users
signInManager->SetDesiredLocalUsers( minDesiredUsers, maxDesiredUsers );
//=================================================================================
// Update signin manager
//=================================================================================
// Update signin mgr. This manager tracks signed in local users, which the session then uses
// to determine who should be in the lobby.
signInManager->Pump();
// Get the master local user
idLocalUser * masterUser = signInManager->GetMasterLocalUser();
if ( onlineMatch && masterUser != NULL && !masterUser->CanPlayOnline() && !masterUser->HasOwnerChanged() ) {
if ( localState > STATE_IDLE ) {
// User is still valid, just no longer online
if ( offlineTransitionTimerStart == 0 ) {
offlineTransitionTimerStart = Sys_Milliseconds();
}
if ( ( Sys_Milliseconds() - offlineTransitionTimerStart ) > net_offlineTransitionThreshold.GetInteger() ) {
MoveToMainMenu();
common->Dialog().ClearDialogs();
common->Dialog().AddDialog( GDM_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true );
}
}
return; // Bail out so signInManager->ValidateLocalUsers below doesn't prematurely remove the master user before we can detect loss of connection
} else {
offlineTransitionTimerStart = 0;
}
// Remove local users (from the signin manager) who aren't allowed to be online if this is an online match.
// Remove local user (from the signin manager) who are not properly signed into a profile.
signInManager->ValidateLocalUsers( onlineMatch );
//=================================================================================
// Check to see if we need to go to "Press Start"
//=================================================================================
// Get the master local user (again, after ValidateOnlineLocalUsers, to make sure he is still valid)
masterUser = signInManager->GetMasterLocalUser();
if ( masterUser == NULL ) {
// If we don't have a master user at all, then we need to be at "Press Start"
MoveToPressStart( GDM_SP_SIGNIN_CHANGE_POST );
return;
} else if ( localState == STATE_PRESS_START ) {
// If we have a master user, and we are at press start, move to the menu area
SetState( STATE_IDLE );
}
// See if the master user either isn't persistent (but needs to be), OR, if the owner changed
// RequirePersistentMaster is poorly named, this really means RequireSignedInMaster
if ( masterUser->HasOwnerChanged() || ( RequirePersistentMaster() && !masterUser->IsProfileReady() ) ) {
MoveToPressStart( GDM_SP_SIGNIN_CHANGE_POST );
return;
}
//=================================================================================
// Sync lobby users with the signed in users
// The initial list of session users are normally determined at connect or create time.
// These functions allow splitscreen users to join in, or check to see if existing
// users (including the master) need to be removed.
//=================================================================================
GetPartyLobby().SyncLobbyUsersWithLocalUsers( allowJoinParty, onlineMatch );
GetGameLobby().SyncLobbyUsersWithLocalUsers( allowJoinGame, onlineMatch );
GetGameStateLobby().SyncLobbyUsersWithLocalUsers( allowJoinGame, onlineMatch );
}
/*
========================
idSessionLocal::GetProfileFromMasterLocalUser
========================
*/
idPlayerProfile * idSessionLocal::GetProfileFromMasterLocalUser() {
idPlayerProfile * profile = NULL;
idLocalUser * masterUser = signInManager->GetMasterLocalUser();
if ( masterUser != NULL ) {
profile = masterUser->GetProfile();
}
if ( profile == NULL ) {
// Whoops
profile = signInManager->GetDefaultProfile();
//idLib::Warning( "Returning fake profile until the code is fixed to handle NULL profiles." );
}
return profile;
}
/*
========================
/*
========================
idSessionLocal::MoveToPressStart
========================
*/
void idSessionLocal::MoveToPressStart( gameDialogMessages_t msg ) {
if ( localState != STATE_PRESS_START ) {
MoveToPressStart();
common->Dialog().ClearDialogs();
common->Dialog().AddDialog( msg, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true );
}
}
/*
========================
idSessionLocal::GetPeerName
========================
*/
const char * idSessionLocal::GetPeerName( int peerNum ) {
return GetActingGameStateLobby().GetPeerName( peerNum );
}
/*
========================
idSessionLocal::SetState
========================
*/
void idSessionLocal::SetState( state_t newState ) {
assert( newState < NUM_STATES );
assert( localState < NUM_STATES );
verify_array_size( stateToString, NUM_STATES );
if ( newState == localState ) {
NET_VERBOSE_PRINT( "NET: SetState: State SAME %s\n", stateToString[ newState ] );
return;
}
// Set the current state
NET_VERBOSE_PRINT( "NET: SetState: State changing from %s to %s\n", stateToString[ localState ], stateToString[ newState ] );
if ( localState < STATE_LOADING && newState >= STATE_LOADING ) {
// Tell lobby instances that the match has started
StartSessions();
// Clear certain dialog boxes we don't want to see in-game
common->Dialog().ClearDialog( GDM_LOBBY_DISBANDED ); // The lobby you were previously in has disbanded
} else if ( localState >= STATE_LOADING && newState < STATE_LOADING ) {
// Tell lobby instances that the match has ended
if ( !WasMigrationGame() ) { // Don't end the session if we are going right back into the game
EndSessions();
}
}
if ( newState == STATE_GAME_LOBBY_HOST || newState == STATE_GAME_LOBBY_PEER ) {
ComputeNextGameCoalesceTime();
}
localState = newState;
}
/*
========================
idSessionLocal::HandlePackets
========================
*/
bool idSessionLocal::HandlePackets() {
SCOPED_PROFILE_EVENT( "Session::HandlePackets" );
byte packetBuffer[ idPacketProcessor::MAX_FINAL_PACKET_SIZE ];
lobbyAddress_t remoteAddress;
int recvSize = 0;
bool fromDedicated = false;
while ( ReadRawPacket( remoteAddress, packetBuffer, recvSize, fromDedicated, sizeof( packetBuffer ) ) && recvSize > 0 ) {
// fragMsg will hold the raw packet
idBitMsg fragMsg;
fragMsg.InitRead( packetBuffer, recvSize );
// Peek at the session ID
idPacketProcessor::sessionId_t sessionID = idPacketProcessor::GetSessionID( fragMsg );
// idLib::Printf( "NET: HandlePackets - session %d, size %d \n", sessionID, recvSize );
// Make sure it's valid
if ( sessionID == idPacketProcessor::SESSION_ID_INVALID ) {
idLib::Printf( "NET: Invalid sessionID %s.\n", remoteAddress.ToString() );
continue;
}
//
// Distribute the packet to the proper lobby
//
const int maskedType = sessionID & idPacketProcessor::LOBBY_TYPE_MASK;
if ( !verify( maskedType > 0 ) ) {
continue;
}
idLobby::lobbyType_t lobbyType = (idLobby::lobbyType_t)( maskedType - 1 );
switch ( lobbyType ) {
case idLobby::TYPE_PARTY: GetPartyLobby().HandlePacket( remoteAddress, fragMsg, sessionID ); break;
case idLobby::TYPE_GAME: GetGameLobby().HandlePacket( remoteAddress, fragMsg, sessionID ); break;
case idLobby::TYPE_GAME_STATE: GetGameStateLobby().HandlePacket( remoteAddress, fragMsg, sessionID ); break;
default: assert( 0 );
}
}
return false;
}
/*
========================
idSessionLocal::GetActivePlatformLobby
========================
*/
idLobby * idSessionLocal::GetActivePlatformLobby() {
sessionState_t state = GetState();
if ( ( state == GAME_LOBBY ) || ( state == BUSY ) || ( state == INGAME ) || ( state == LOADING ) ) {
return &GetGameLobby();
} else if ( state == PARTY_LOBBY ) {
return &GetPartyLobby();
}
return NULL;
}
/*
========================
idSessionLocal::GetActivePlatformLobby
========================
*/
const idLobby * idSessionLocal::GetActivePlatformLobby() const {
sessionState_t state = GetState();
if ( ( state == GAME_LOBBY ) || ( state == BUSY ) || ( state == INGAME ) || ( state == LOADING ) ) {
return &GetGameLobby();
} else if ( state == PARTY_LOBBY ) {
return &GetPartyLobby();
}
return NULL;
}
/*
========================
idSessionLocal::GetActingGameStateLobby
========================
*/
idLobby & idSessionLocal::GetActingGameStateLobby() {
if ( net_useGameStateLobby.GetBool() ) {
return GetGameStateLobby();
}
return GetGameLobby();
}
/*
========================
idSessionLocal::GetActingGameStateLobby
========================
*/
const idLobby & idSessionLocal::GetActingGameStateLobby() const {
if ( net_useGameStateLobby.GetBool() ) {
return GetGameStateLobby();
}
return GetGameLobby();
}
/*
========================
idSessionLocal::GetLobbyFromType
========================
*/
idLobby * idSessionLocal::GetLobbyFromType( idLobby::lobbyType_t lobbyType ) {
switch ( lobbyType ) {
case idLobby::TYPE_PARTY: return &GetPartyLobby();
case idLobby::TYPE_GAME: return &GetGameLobby();
case idLobby::TYPE_GAME_STATE: return &GetGameStateLobby();
}
return NULL;
}
/*
========================
idSessionLocal::GetActivePlatformLobbyBase
This returns the base version for the idSession version
========================
*/
idLobbyBase & idSessionLocal::GetActivePlatformLobbyBase() {
idLobby * activeLobby = GetActivePlatformLobby();
if ( activeLobby != NULL ) {
return *activeLobby;
}
return stubLobby; // So we can return at least something
}
/*
========================
idSessionLocal::GetLobbyFromLobbyUserID
========================
*/
idLobbyBase & idSessionLocal::GetLobbyFromLobbyUserID( lobbyUserID_t lobbyUserID ) {
if ( !lobbyUserID.IsValid() ) {
return stubLobby; // So we can return at least something
}
idLobby * lobby = GetLobbyFromType( (idLobby::lobbyType_t)lobbyUserID.GetLobbyType() );
if ( lobby != NULL ) {
return *lobby;
}
return stubLobby; // So we can return at least something
}
/*
========================
idSessionLocal::TickSendQueue
========================
*/
void idSessionLocal::TickSendQueue() {
assert( !sendQueue.IsEmpty() );
int now = Sys_Milliseconds();
idQueuePacket * packet = sendQueue.Peek();
while ( packet != NULL ) {
if ( now < packet->time ) {
break;
}
GetPort( packet->dedicated ).SendRawPacket( packet->address, packet->data, packet->size );
if ( net_forceUpstream.GetFloat() != 0.0f && net_forceUpstreamQueue.GetFloat() != 0.0f ) {
// FIXME: no can do both
assert( net_forceLatency.GetInteger() == 0 );
// compute / update an added traffic due to the queuing
// we can't piggyback on upstreamDropRate because of the way it's computed and clamped to zero
int time = Sys_Milliseconds();
if ( time > upstreamQueueRateTime ) {
upstreamQueueRate -= upstreamQueueRate * ( float )( time - upstreamQueueRateTime ) / 1000.0f;
if ( upstreamQueueRate < 0.0f ) {
upstreamQueueRate = 0.0f;
}
upstreamQueueRateTime = time;
}
// update queued bytes
queuedBytes -= packet->size;
if ( net_verboseSimulatedTraffic.GetBool() ) {
idLib::Printf( "send queued packet size %d to %s\n", packet->size, packet->address.ToString() );
}
}
sendQueue.RemoveFirst(); // we have it already, just push it off the queue before freeing
packetAllocator.Free( packet );
packet = sendQueue.Peek();
}
}
/*
========================
idSessionLocal::QueuePacket
========================
*/
void idSessionLocal::QueuePacket( idQueue< idQueuePacket,&idQueuePacket::queueNode > & queue, int time, const lobbyAddress_t & to, const void * data, int size, bool dedicated ) {
//mem.PushHeap();
idQueuePacket * packet = packetAllocator.Alloc();
packet->address = to;
packet->size = size;
packet->dedicated = dedicated;
packet->time = time;
memcpy( packet->data, data, size );
queue.Add( packet );
//mem.PopHeap();
}
/*
========================
idSessionLocal::ReadRawPacketFromQueue
========================
*/
bool idSessionLocal::ReadRawPacketFromQueue( int time, lobbyAddress_t & from, void * data, int & size, bool & outDedicated, int maxSize ) {
idQueuePacket * packet = recvQueue.Peek();
if ( packet == NULL || time < packet->time ) {
return false; // Either there are no packets, or no packet is ready
}
//idLib::Printf( "NET: Packet recvd: %d ms\n", now );
from = packet->address;
size = packet->size;
assert( size <= maxSize );
outDedicated = packet->dedicated;
memcpy( data, packet->data, packet->size );
recvQueue.RemoveFirst(); // we have it already, just push it off the queue before freeing
packetAllocator.Free( packet );
return true;
}
/*
========================
idSessionLocal::SendRawPacket
========================
*/
void idSessionLocal::SendRawPacket( const lobbyAddress_t & to, const void * data, int size, bool dedicated ) {
const int now = Sys_Milliseconds();
if ( net_forceUpstream.GetFloat() != 0 ) {
// the total bandwidth rate at which the networking systems are trying to push data through
float totalOutgoingRate = (float)GetActingGameStateLobby().GetTotalOutgoingRate(); // B/s
// update the rate at which we have been taking data out by dropping it
int time = Sys_Milliseconds();
if ( time > upstreamDropRateTime ) {
upstreamDropRate -= upstreamDropRate * ( float )( time - upstreamDropRateTime ) / 1000.0f;
if ( upstreamDropRate < 0.0f ) {
upstreamDropRate = 0.0f;
}
upstreamDropRateTime = time;
}
if ( (float)( totalOutgoingRate - upstreamDropRate + upstreamQueueRate ) > net_forceUpstream.GetFloat() * 1024.0f ) { // net_forceUpstream is in kB/s, everything else in B/s
if ( net_forceUpstreamQueue.GetFloat() == 0.0f ) {
// just drop the packet - not representative, but simple
if ( net_verboseSimulatedTraffic.GetBool() ) {
idLib::Printf( "drop %d bytes to %s\n", size, to.ToString() );
}
// increase the instant drop rate with the data we just dropped
upstreamDropRate += size;
return;
}
// simulate a network device with a send queue
// do we have room in the queue?
assert( net_forceUpstreamQueue.GetFloat() > 0.0f );
if ( (float)( queuedBytes + size ) > net_forceUpstreamQueue.GetFloat() * 1024.0f ) { // net_forceUpstreamQueue is in kB/s
// too much queued, this is still a drop
// FIXME: factorize
// just drop the packet - not representative, but simple
if ( net_verboseSimulatedTraffic.GetBool() ) {
idLib::Printf( "full queue: drop %d bytes to %s\n", size, to.ToString() );
}
// increase the instant drop rate with the data we just dropped
upstreamDropRate += size;
return;
}
// there is room to buffer up in the queue
queuedBytes += size;
// with queuedBytes and the current upstream, when should this packet be sent?
int queuedPacketSendDelay = 1000.0f * ( (float)queuedBytes / ( net_forceUpstream.GetFloat() * 1024.0f ) ); // in ms
// queue for sending
if ( net_verboseSimulatedTraffic.GetBool() ) {
idLib::Printf( "queuing packet: %d bytes delayed %d ms\n", size, queuedPacketSendDelay );
}
QueuePacket( sendQueue, now + queuedPacketSendDelay, to, data, size, dedicated );
// will abuse the forced latency code below to take care of the sending
// FIXME: right now, can't have both on
assert( net_forceLatency.GetInteger() == 0 );
}
}
// short path
// NOTE: network queuing: will go to tick the queue whenever sendQueue isn't empty, regardless of latency
if ( net_forceLatency.GetInteger() == 0 && sendQueue.IsEmpty() ) {
GetPort( dedicated ).SendRawPacket( to, data, size );
return;
}
if ( net_forceUpstream.GetFloat() != 0.0f && net_forceUpstreamQueue.GetFloat() != 0.0f ) {
// FIXME: not doing both just yet
assert( net_forceLatency.GetInteger() == 0 );
TickSendQueue();
return; // we done (at least for queue only path)
}
// queue up
assert( size != 0 && size <= idPacketProcessor::MAX_FINAL_PACKET_SIZE );
QueuePacket( sendQueue, now + net_forceLatency.GetInteger() / 2, to, data, size, dedicated );
TickSendQueue();
}
/*
========================
idSessionLocal::ReadRawPacket
========================
*/
bool idSessionLocal::ReadRawPacket( lobbyAddress_t & from, void * data, int & size, bool & outDedicated, int maxSize ) {
SCOPED_PROFILE_EVENT( "Session::ReadRawPacket" );
assert( maxSize <= idPacketProcessor::MAX_FINAL_PACKET_SIZE );
if ( !sendQueue.IsEmpty() ) {
TickSendQueue();
}
const int now = Sys_Milliseconds();
// Make sure we give both ports equal time
static bool currentDedicated = false;
currentDedicated = !currentDedicated;
for ( int i = 0; i < 2; i++ ) {
// BRIAN_FIXME: Dedicated servers fuck up running 2 instances on the same machine
// outDedicated = ( i == 0 ) ? currentDedicated : !currentDedicated;
outDedicated = false;
if ( GetPort( outDedicated ).ReadRawPacket( from, data, size, maxSize ) ) {
if ( net_forceLatency.GetInteger() == 0 && recvQueue.IsEmpty() ) {
// If we aren't forcing latency, and queue is empty, return result immediately
return true;
}
// the cvar is meant to be a round trip latency so we're applying half on the send and half on the recv
const int time = ( net_forceLatency.GetInteger() == 0 ) ? 0 : now + net_forceLatency.GetInteger() / 2;
// Otherwise, queue result
QueuePacket( recvQueue, time, from, data, size, outDedicated );
}
}
// Return any queued results
return ReadRawPacketFromQueue( now, from, data, size, outDedicated, maxSize );
}
/*
========================
idSessionLocal::ConnectAndMoveToLobby
========================
*/
void idSessionLocal::ConnectAndMoveToLobby( idLobby & lobby, const lobbyConnectInfo_t & connectInfo, bool fromInvite ) {
// Since we are connecting directly to a lobby, make sure no search results are left over from previous FindOrCreateMatch results
// If we don't do this, we might think we should attempt to connect to an old search result, and we don't want to in this case
lobby.searchResults.Clear();
// Attempt to connect to the lobby
lobby.ConnectTo( connectInfo, fromInvite );
connectType = CONNECT_DIRECT;
// Wait for connection
switch ( lobby.lobbyType ) {
case idLobby::TYPE_PARTY: SetState( STATE_CONNECT_AND_MOVE_TO_PARTY ); break;
case idLobby::TYPE_GAME: SetState( STATE_CONNECT_AND_MOVE_TO_GAME ); break;
case idLobby::TYPE_GAME_STATE: SetState( STATE_CONNECT_AND_MOVE_TO_GAME_STATE ); break;
}
}
/*
========================
idSessionLocal::GoodbyeFromHost
========================
*/
void idSessionLocal::GoodbyeFromHost( idLobby & lobby, int peerNum, const lobbyAddress_t & remoteAddress, int msgType ) {
if ( !verify( localState > STATE_IDLE ) ) {
idLib::Printf( "NET: Got disconnected from host %s on session %s when we were not in a lobby or game.\n", remoteAddress.ToString(), lobby.GetLobbyName() );
MoveToMainMenu();
return; // Ignore if we are not past the main menu
}
// Goodbye from host. See if we were connecting vs connected
if ( ( localState == STATE_CONNECT_AND_MOVE_TO_PARTY || localState == STATE_CONNECT_AND_MOVE_TO_GAME ) && lobby.peers[peerNum].GetConnectionState() == idLobby::CONNECTION_CONNECTING ) {
// We were denied a connection attempt
idLib::Printf( "NET: Denied connection attempt from host %s on session %s. MsgType %i.\n", remoteAddress.ToString(), lobby.GetLobbyName(), msgType );
// This will try to move to the next connection if one exists, otherwise will create a match
HandleConnectionFailed( lobby, msgType == idLobby::OOB_GOODBYE_FULL );
} else {
// We were disconnected from a server we were previously connected to
idLib::Printf( "NET: Disconnected from host %s on session %s. MsgType %i.\n", remoteAddress.ToString(), lobby.GetLobbyName(), msgType );
const bool leaveGameWithParty = ( msgType == idLobby::OOB_GOODBYE_W_PARTY );
if ( leaveGameWithParty && lobby.lobbyType == idLobby::TYPE_GAME && lobby.IsPeer() && GetState() == idSession::GAME_LOBBY && GetPartyLobby().host >= 0 &&
lobby.peers[peerNum].address.Compare( GetPartyLobby().peers[GetPartyLobby().host].address, true ) ) {
// If a host is telling us goodbye from a game lobby, and the game host is the same as our party host,
// and we aren't in a game, and the host wants us to leave with him, then do so now
GetGameLobby().Shutdown();
GetGameStateLobby().Shutdown();
SetState( STATE_PARTY_LOBBY_PEER );
} else {
// Host left, so pick a new host (possibly even us) for this lobby
lobby.PickNewHost();
}
}
}
/*
========================
idSessionLocal::WriteLeaderboardToMsg
========================
*/
void idSessionLocal::WriteLeaderboardToMsg( idBitMsg & msg, const leaderboardDefinition_t * leaderboard, const column_t * stats ) {
assert( Sys_FindLeaderboardDef( leaderboard->id ) == leaderboard );
msg.WriteLong( leaderboard->id );
for ( int i = 0; i < leaderboard->numColumns; ++i ) {
uint64 value = stats[i].value;
//idLib::Printf( "value = %i\n", (int32)value );
for ( int j = 0; j < leaderboard->columnDefs[i].bits; j++ ) {
msg.WriteBits( value & 1, 1 );
value >>= 1;
}
//msg.WriteData( &stats[i].value, sizeof( stats[i].value ) );
}
}
/*
========================
idSessionLocal::ReadLeaderboardFromMsg
========================
*/
const leaderboardDefinition_t * idSessionLocal::ReadLeaderboardFromMsg( idBitMsg & msg, column_t * stats ) {
int id = msg.ReadLong();
const leaderboardDefinition_t * leaderboard = Sys_FindLeaderboardDef( id );
if ( leaderboard == NULL ) {
idLib::Printf( "NET: Invalid leaderboard id: %i\n", id );
return NULL;
}
for ( int i = 0; i < leaderboard->numColumns; ++i ) {
uint64 value = 0;
for ( int j = 0; j < leaderboard->columnDefs[i].bits; j++ ) {
value |= (uint64)( msg.ReadBits( 1 ) & 1 ) << j;
}
stats[i].value = value;
//idLib::Printf( "value = %i\n", (int32)value );
//msg.ReadData( &stats[i].value, sizeof( stats[i].value ) );
}
return leaderboard;
}
/*
========================
idSessionLocal::SendLeaderboardStatsToPlayer
========================
*/
void idSessionLocal::SendLeaderboardStatsToPlayer( lobbyUserID_t lobbyUserID, const leaderboardDefinition_t * leaderboard, const column_t * stats ) {
const int sessionUserIndex = GetActingGameStateLobby().GetLobbyUserIndexByID( lobbyUserID );
if ( GetActingGameStateLobby().IsLobbyUserDisconnected( sessionUserIndex ) ) {
idLib::Warning( "Tried to tell disconnected user to report stats" );
return;
}
const int peerIndex = GetActingGameStateLobby().PeerIndexFromLobbyUser( lobbyUserID );
if ( peerIndex == -1 ) {
idLib::Warning( "Tried to tell invalid peer index to report stats" );
return;
}
if ( !verify( GetActingGameStateLobby().IsHost() ) ||
!verify( peerIndex < GetActingGameStateLobby().peers.Num() ) ||
!verify( GetActingGameStateLobby().peers[ peerIndex ].IsConnected() ) ) {
idLib::Warning( "Tried to tell invalid peer to report stats" );
return;
}
NET_VERBOSE_PRINT( "Telling sessionUserIndex %i (peer %i) to report stats\n", sessionUserIndex, peerIndex );
lobbyUser_t * gameUser = GetActingGameStateLobby().GetLobbyUser( sessionUserIndex );
if ( !verify( gameUser != NULL ) ) {
return;
}
byte buffer[ idPacketProcessor::MAX_PACKET_SIZE ];
idBitMsg msg( buffer, sizeof( buffer ) );
// Use the user ID
gameUser->lobbyUserID.WriteToMsg( msg );
WriteLeaderboardToMsg( msg, leaderboard, stats );
GetActingGameStateLobby().QueueReliableMessage( peerIndex, idLobby::RELIABLE_POST_STATS, msg.GetReadData(), msg.GetSize() );
}
/*
========================
idSessionLocal::RecvLeaderboardStatsForPlayer
========================
*/
void idSessionLocal::RecvLeaderboardStatsForPlayer( idBitMsg & msg ) {
column_t stats[ MAX_LEADERBOARD_COLUMNS ];
lobbyUserID_t lobbyUserID;
lobbyUserID.ReadFromMsg( msg );
const leaderboardDefinition_t * leaderboard = ReadLeaderboardFromMsg( msg, stats );
if ( leaderboard == NULL ) {
idLib::Printf( "RecvLeaderboardStatsForPlayer: Invalid lb.\n" );
return;
}
LeaderboardUpload( lobbyUserID, leaderboard, stats );
}
/*
========================
idSessionLocal::RequirePersistentMaster
========================
*/
bool idSessionLocal::RequirePersistentMaster() {
return signInManager->RequirePersistentMaster();
}
/*
========================
CheckAndUpdateValue
========================
*/
template<typename T>
bool CheckAndUpdateValue( T & value, const T & newValue ) {
if ( value == newValue ) {
return false;
}
value = newValue;
return true;
}
/*
========================
lobbyUser_t::UpdateClientMutableData
========================
*/
bool lobbyUser_t::UpdateClientMutableData( const idLocalUser * localUser ) {
bool updated = false;
const idPlayerProfile * profile = localUser->GetProfile();
if ( profile != NULL ) {
updated |= CheckAndUpdateValue( level, profile->GetLevel() );
}
updated |= CheckAndUpdateValue( selectedSkin, ui_skinIndex.GetInteger() );
updated |= CheckAndUpdateValue( weaponAutoSwitch, ui_autoSwitch.GetBool() );
updated |= CheckAndUpdateValue( weaponAutoReload, ui_autoReload.GetBool() );
return updated;
}
/*
========================
idSessionLocal::ComputeNextGameCoalesceTime
========================
*/
void idSessionLocal::ComputeNextGameCoalesceTime() {
const int coalesceTimeInSeconds = session->GetTitleStorageInt( "net_LobbyCoalesceTimeInSeconds", net_LobbyCoalesceTimeInSeconds.GetInteger() );
const int randomCoalesceTimeInSeconds = session->GetTitleStorageInt( "net_LobbyRandomCoalesceTimeInSeconds", net_LobbyRandomCoalesceTimeInSeconds.GetInteger() );
if ( coalesceTimeInSeconds != 0 ) {
static idRandom2 random( Sys_Milliseconds() );
nextGameCoalesceTime = Sys_Milliseconds() + ( coalesceTimeInSeconds + random.RandomInt( randomCoalesceTimeInSeconds ) ) * 1000;
} else {
nextGameCoalesceTime = 0;
}
}
/*
========================
lobbyUser_t::Net_BandwidthChallenge
========================
*/
CONSOLE_COMMAND( Net_BandwidthChallenge, "Test network bandwidth", 0 ) {
session->StartOrContinueBandwidthChallenge( true );
}
/*
========================
lobbyUser_t::Net_ThrottlePeer
========================
*/
CONSOLE_COMMAND( Net_ThrottlePeer, "Test network bandwidth", 0 ) {
int peerNum = -1;
int snapRate = 0;
if ( args.Argc() >= 3 ) {
peerNum = atoi( args.Argv(1) );
snapRate = atoi( args.Argv(2) );
}
// Note DebugSetPeerSnaprate will handle peerNum=-1 by printing out list of peers
session->DebugSetPeerSnaprate( peerNum, snapRate );
}
// FIXME: Move to sys_stats.cpp
idStaticList< leaderboardDefinition_t *, MAX_LEADERBOARDS > registeredLeaderboards;
/*
========================
Sys_FindLeaderboardDef
========================
*/
const leaderboardDefinition_t * Sys_FindLeaderboardDef( int id ) {
for ( int i = 0; i < registeredLeaderboards.Num() ; i++ ) {
if ( registeredLeaderboards[i] && registeredLeaderboards[i]->id == id ) {
return registeredLeaderboards[i];
}
}
return NULL;
}
/*
========================
Sys_CreateLeaderboardDef
========================
*/
leaderboardDefinition_t * Sys_CreateLeaderboardDef( int id_, int numColumns_, const columnDef_t * columnDefs_,
rankOrder_t rankOrder_, bool supportsAttachments_, bool checkAgainstCurrent_ ) {
leaderboardDefinition_t * newDef = new (TAG_NETWORKING) leaderboardDefinition_t( id_, numColumns_, columnDefs_, rankOrder_, supportsAttachments_, checkAgainstCurrent_ );
// try and reuse a free spot
int leaderboardHandle = registeredLeaderboards.FindNull();
if ( leaderboardHandle == -1 ) {
leaderboardHandle = registeredLeaderboards.Append( NULL );
}
registeredLeaderboards[ leaderboardHandle ] = newDef;
return newDef;
}
/*
========================
Sys_CreateLeaderboardDef
========================
*/
void Sys_DestroyLeaderboardDefs() {
// delete and clear all the contents of the registeredLeaderboards static list.
registeredLeaderboards.DeleteContents( true );
}
/*
========================
idSessionLocal::StartOrContinueBandwidthChallenge
This will start a bandwidth test if one is not active
returns true if a test has completed
========================
*/
bool idSessionLocal::StartOrContinueBandwidthChallenge( bool forceStart ) {
idLobby * activeLobby = GetActivePlatformLobby();
if ( activeLobby == NULL ) {
idLib::Warning("No active session lobby when idSessionLocal::StartBandwidthChallenge called");
return true;
}
if ( !forceStart && activeLobby->bandwidthChallengeFinished ) {
activeLobby->bandwidthChallengeFinished = false;
return true;
}
if ( !activeLobby->BandwidthTestStarted() ) {
activeLobby->BeginBandwidthTest();
}
return false;
}
/*
========================
idSessionLocal::DebugSetPeerSnaprate
This is debug function for manually setting peer's snaprate in game
========================
*/
void idSessionLocal::DebugSetPeerSnaprate( int peerIndex, int snapRateMS ) {
idLobby * activeLobby = GetActivePlatformLobby();
if ( activeLobby == NULL ) {
idLib::Warning("No active session lobby when idSessionLocal::StartBandwidthChallenge called");
return;
}
if ( peerIndex < 0 || peerIndex > activeLobby->peers.Num() ) {
idLib::Printf("Invalid peer %d\n", peerIndex );
for ( int i=0; i < activeLobby->peers.Num(); i++ ) {
idLib::Printf( "Peer[%d] %s\n", i, activeLobby->GetPeerName(i) );
}
return;
}
activeLobby->peers[peerIndex].throttledSnapRate = snapRateMS * 1000;
activeLobby->peers[peerIndex].receivedThrottle = 0;
idLib::Printf( "Set peer %s new snapRate: %d\n", activeLobby->GetPeerName(peerIndex), activeLobby->peers[peerIndex].throttledSnapRate );
}
/*
========================
idSessionLocal::DebugSetPeerSnaprate
This is debug function for manually setting peer's snaprate in game
========================
*/
float idSessionLocal::GetIncomingByteRate() {
idLobby * activeLobby = GetActivePlatformLobby();
if ( activeLobby == NULL ) {
idLib::Warning("No active session lobby when idSessionLocal::GetIncomingByteRate called");
return 0;
}
float total = 0;
for ( int p=0; p < activeLobby->peers.Num(); p++ ) {
if ( activeLobby->peers[p].IsConnected() ) {
total += activeLobby->peers[p].packetProc->GetIncomingRateBytes();
}
}
return total;
}
/*
========================
idSessionLocal::OnLocalUserSignin
========================
*/
void idSessionLocal::OnLocalUserSignin( idLocalUser * user ) {
// Do stuff before calling OnMasterLocalUserSignin()
session->GetAchievementSystem().RegisterLocalUser( user );
// We may not have a profile yet, need to call user's version...
user->LoadProfileSettings();
// for all consoles except the PS3 we enumerate right away because they don't
// take such a long time as the PS3. PS3 enumeration is done in the
// background and kicked off when the profile callback is triggered
if ( user == GetSignInManager().GetMasterLocalUser() ) {
OnMasterLocalUserSignin();
}
}
/*
========================
idSessionLocal::OnLocalUserSignout
========================
*/
void idSessionLocal::OnLocalUserSignout( idLocalUser * user ) {
// Do stuff before calling OnMasterLocalUserSignout()
session->GetAchievementSystem().RemoveLocalUser( user );
if ( GetSignInManager().GetMasterLocalUser() == NULL ) {
OnMasterLocalUserSignout();
}
}
/*
========================
idSessionLocal::OnMasterLocalUserSignout
========================
*/
void idSessionLocal::OnMasterLocalUserSignout() {
CancelSaveGameWithHandle( enumerationHandle );
enumerationHandle = 0;
GetSaveGameManager().GetEnumeratedSavegamesNonConst().Clear();
}
/*
========================
idSessionLocal::OnMasterLocalUserSignin
========================
*/
void idSessionLocal::OnMasterLocalUserSignin() {
enumerationHandle = EnumerateSaveGamesAsync();
}
/*
========================
idSessionLocal::OnLocalUserProfileLoaded
========================
*/
void idSessionLocal::OnLocalUserProfileLoaded( idLocalUser * user ) {
user->RequestSyncAchievements();
}
/*
========================
idSessionLocal::SetVoiceGroupsToTeams
========================
*/
void idSessionLocal::SetVoiceGroupsToTeams() {
// move voice chat to team
int myTeam = 0;
for ( int i = 0; i < GetGameLobby().GetNumLobbyUsers(); ++i ) {
const lobbyUser_t * gameUser = GetGameLobby().GetLobbyUser( i );
if ( !verify( gameUser != NULL ) ) {
continue;
}
if ( gameUser->IsDisconnected() ) {
continue;
}
int userTeam = gameUser->teamNumber;
voiceChat->SetTalkerGroup( gameUser, GetGameLobby().lobbyType, userTeam );
if ( GetGameLobby().IsSessionUserIndexLocal( i ) ) {
myTeam = userTeam;
}
}
SetActiveChatGroup( myTeam );
}
/*
========================
idSessionLocal::ClearVoiceGroups
========================
*/
void idSessionLocal::ClearVoiceGroups() {
for ( int i = 0; i < GetGameLobby().GetNumLobbyUsers(); ++i ) {
const lobbyUser_t * gameUser = GetGameLobby().GetLobbyUser( i );
if ( !verify( gameUser != NULL ) ) {
continue;
}
if ( gameUser->IsDisconnected() ) {
continue;
}
voiceChat->SetTalkerGroup( gameUser, GetGameLobby().lobbyType, 0 );
}
SetActiveChatGroup( 0 );
}
/*
========================
idSessionLocal::SendVoiceAudio
========================
*/
void idSessionLocal::SendVoiceAudio() {
if ( voiceChat == NULL ) {
return;
}
idLobby * activeLobby = GetActivePlatformLobby();
int activeSessionIndex = ( activeLobby != NULL ) ? activeLobby->lobbyType : -1;
voiceChat->SetActiveLobby( activeSessionIndex );
voiceChat->Pump();
if ( activeLobby == NULL ) {
return;
}
int time = Sys_Milliseconds();
const int VOICE_THROTTLE_TIME_IN_MS = session->GetTitleStorageInt( "VOICE_THROTTLE_TIME_IN_MS", 33) ; // Don't allow faster than 30hz send rate
if ( time - lastVoiceSendtime < VOICE_THROTTLE_TIME_IN_MS ) {
return;
}
lastVoiceSendtime = time;
idStaticList< int, MAX_PLAYERS > localTalkers;
voiceChat->GetActiveLocalTalkers( localTalkers );
for ( int i = 0; i < localTalkers.Num(); i++ ) {
// NOTE - For 360, we don't need more than XHV_MAX_VOICECHAT_PACKETS * XHV_VOICECHAT_MODE_PACKET_SIZE bytes
const int MAX_VDP_DATA_SIZE = 1000;
byte buffer[MAX_VDP_DATA_SIZE];
const int titleStorageDataSize = session->GetTitleStorageInt( "MAX_VDP_DATA_SIZE", 1000 );
const int dataSizeAvailable = Min< int >( titleStorageDataSize, sizeof( buffer ) );
// in-out parameter
int dataSize = dataSizeAvailable;
if ( !voiceChat->GetLocalChatData( localTalkers[i], buffer, dataSize ) ) {
continue;
}
assert( dataSize <= sizeof( buffer ) );
idStaticList< const lobbyAddress_t *, MAX_PLAYERS > recipients;
voiceChat->GetRecipientsForTalker( localTalkers[i], recipients );
for ( int j = 0; j < recipients.Num(); j++ ) {
activeLobby->SendConnectionLess( *recipients[j], idLobby::OOB_VOICE_AUDIO, buffer, dataSize );
}
}
}
/*
========================
idSessionLocal::HandleOobVoiceAudio
========================
*/
void idSessionLocal::HandleOobVoiceAudio( const lobbyAddress_t & from, const idBitMsg & msg ) {
idLobby * activeLobby = GetActivePlatformLobby();
if ( activeLobby == NULL ) {
return;
}
voiceChat->SetActiveLobby( activeLobby->lobbyType );
voiceChat->SubmitIncomingChatData( msg.GetReadData() + msg.GetReadCount(), msg.GetRemainingData() );
}
/*
========================
idSessionLocal::SetActiveChatGroup
========================
*/
void idSessionLocal::SetActiveChatGroup( int groupIndex ) {
voiceChat->SetActiveChatGroup( groupIndex );
}
/*
========================
idSessionLocal::GetLobbyUserVoiceState
========================
*/
voiceState_t idSessionLocal::GetLobbyUserVoiceState( lobbyUserID_t lobbyUserID ) {
idLobby * activeLobby = GetActivePlatformLobby();
if ( activeLobby == NULL ) {
return VOICECHAT_STATE_NOT_TALKING;
}
const lobbyUser_t * user = activeLobby->GetLobbyUserByID( lobbyUserID );
if ( !verify( user != NULL ) ) {
return VOICECHAT_STATE_NOT_TALKING;
}
return voiceChat->GetVoiceState( user );
}
/*
========================
idSessionLocal::GetDisplayStateFromVoiceState
========================
*/
voiceStateDisplay_t idSessionLocal::GetDisplayStateFromVoiceState( voiceState_t voiceState ) const {
if ( ( GetState() == GAME_LOBBY && MatchTypeIsLocal( GetGameLobby().GetMatchParms().matchFlags ) )
|| ( GetState() == PARTY_LOBBY && MatchTypeIsLocal( GetPartyLobby().GetMatchParms().matchFlags ) ) ) {
return VOICECHAT_DISPLAY_NONE; // never show voice stuff in splitscreen
}
switch ( voiceState ) {
case VOICECHAT_STATE_MUTED_REMOTE:
case VOICECHAT_STATE_MUTED_LOCAL:
case VOICECHAT_STATE_MUTED_ALL:
return VOICECHAT_DISPLAY_MUTED;
case VOICECHAT_STATE_NOT_TALKING:
return VOICECHAT_DISPLAY_NOTTALKING;
case VOICECHAT_STATE_TALKING:
return VOICECHAT_DISPLAY_TALKING;
case VOICECHAT_STATE_TALKING_GLOBAL:
return VOICECHAT_DISPLAY_TALKING_GLOBAL;
case VOICECHAT_STATE_NO_MIC:
default:
return VOICECHAT_DISPLAY_NOTTALKING;
}
}
/*
========================
idSessionLocal::ToggleLobbyUserVoiceMute
========================
*/
void idSessionLocal::ToggleLobbyUserVoiceMute( lobbyUserID_t lobbyUserID ) {
idLobby * activeLobby = GetActivePlatformLobby();
if ( activeLobby == NULL ) {
return;
}
// Get the master local user
idLocalUser * masterUser = signInManager->GetMasterLocalUser();
if ( masterUser == NULL ) {
return;
}
const lobbyUser_t * srcUser = activeLobby->GetLobbyUser( activeLobby->GetLobbyUserIndexByLocalUserHandle( masterUser->GetLocalUserHandle() ) );
if ( srcUser == NULL ) {
return;
}
const lobbyUser_t * targetUser = activeLobby->GetLobbyUserByID( lobbyUserID );
if ( !verify( targetUser != NULL ) ) {
return;
}
if ( srcUser == targetUser ) {
return; // Can't toggle yourself
}
voiceChat->ToggleMuteLocal( srcUser, targetUser );
}
/*
========================
idSessionLocal::UpdateMasterUserHeadsetState
========================
*/
void idSessionLocal::UpdateMasterUserHeadsetState()
{
if ( GetState() != PARTY_LOBBY && GetState() != GAME_LOBBY && GetState() != INGAME ) {
return;
}
lobbyUser_t * user = GetActivePlatformLobby()->GetSessionUserFromLocalUser( signInManager->GetMasterLocalUser() );
// TODO: Is this possible?
if ( user == NULL ) {
return;
}
int talkerIndex = voiceChat->FindTalkerByUserId( user->lobbyUserID, GetActivePlatformLobby()->lobbyType );
bool voiceChanged = voiceChat->HasHeadsetStateChanged( talkerIndex );
if ( voiceChanged ) {
byte buffer[ idPacketProcessor::MAX_MSG_SIZE ];
idBitMsg msg( buffer, sizeof( buffer ) );
msg.WriteLong( 1 );
user->lobbyUserID.WriteToMsg( msg );
msg.WriteBool( voiceChat->GetHeadsetState( talkerIndex ) );
idLib::Printf( "Sending voicestate %d for user %d %s\n", voiceChat->GetHeadsetState( talkerIndex ), talkerIndex, user->gamertag );
if ( GetActivePlatformLobby()->IsHost() ) {
for ( int p = 0; p < GetActivePlatformLobby()->peers.Num(); p++ ) {
if ( GetActivePlatformLobby()->peers[p].IsConnected() ) {
GetActivePlatformLobby()->QueueReliableMessage( p, idLobby::RELIABLE_HEADSET_STATE, msg.GetReadData(), msg.GetSize() );
}
}
} else {
GetActivePlatformLobby()->QueueReliableMessage( GetActivePlatformLobby()->host, idLobby::RELIABLE_HEADSET_STATE, msg.GetReadData(), msg.GetSize() );
}
}
}
/*
========================
idSessionLocal::GetNumContentPackages
========================
*/
int idSessionLocal::GetNumContentPackages() const {
return downloadedContent.Num();
}
/*
========================
idSessionLocal::GetContentPackageID
========================
*/
int idSessionLocal::GetContentPackageID( int contentIndex ) const {
assert( contentIndex < MAX_CONTENT_PACKAGES );
if ( downloadedContent[ contentIndex ].isMounted ) {
return downloadedContent[ contentIndex ].dlcID;
}
return 0;
}
/*
========================
idSessionLocal::GetContentPackagePath
========================
*/
const char * idSessionLocal::GetContentPackagePath( int contentIndex ) const {
assert( contentIndex < MAX_CONTENT_PACKAGES );
if ( downloadedContent[ contentIndex ].isMounted ) {
return downloadedContent[ contentIndex ].rootPath.c_str();
}
return NULL;
}
/*
========================
idSessionLocal::GetContentPackageIndexForID
========================
*/
int idSessionLocal::GetContentPackageIndexForID( int contentID ) const {
int contentIndex = -1;
for ( int i = 0; i < downloadedContent.Num(); i++ ) {
if ( downloadedContent[i].dlcID == contentID ) {
contentIndex = i;
break;
}
}
return contentIndex;
}
/*
========================
idSessionLocal::SetLobbyUserRelativeScore
========================
*/
void idSessionLocal::SetLobbyUserRelativeScore( lobbyUserID_t lobbyUserID, int relativeScore, int team ) {
// All platforms but 360 stub this out
}
/*
========================
idSessionLocal::ReadTitleStorage
========================
*/
void idSessionLocal::ReadTitleStorage( void * buffer, int bufferLen ) {
// https://ps3.scedev.net/projects/ps3_sdk_docs/docs/ps3-en,NP_Lookup-Reference,sceNpLookupTitleSmallStorageAsync/1
// If the file is not on the server, this will be handled as though a file of 0 bytes were on the server.
// This means that 0 will be set to contentLength and 0 (for normal termination) will return for the return value.
// This situation can occur with problems in actual operation, so the application must be designed not to hang up even in such situations
//bufferLen = 0;
idLib::Printf( "ReadTitleStorage: %i bytes\n", bufferLen );
#if !defined( ID_RETAIL ) || defined( ID_RETAIL_INTERNAL )
if ( net_ignoreTitleStorage.GetBool() ) {//&& idLib::GetProduction() < PROD_PRODUCTION ) {
idLib::Printf( "ReadTitleStorage: *********************** IGNORING ********************\n" );
return;
}
#endif
//idScopedGlobalHeap everythingHereGoesInTheGlobalHeap;
idParser parser( LEXFL_NOERRORS | LEXFL_NOFATALERRORS | LEXFL_NOSTRINGCONCAT );
parser.LoadMemory( ( const char* )buffer, bufferLen, "default.tss" );
bool valid = true;
while ( true ) {
idToken token;
if ( !parser.ReadToken( &token ) ) {
break;
}
if ( token.Icmp( "netvars" ) == 0 ) {
if ( !titleStorageVars.Parse( parser ) ) {
valid = false;
break;
}
} else {
valid = false;
break;
}
}
if ( valid ) {
titleStorageLoaded = true;
idLib::Printf( "ReadTitleStorage: SUCCESS\n" );
titleStorageVars.Print();
} else {
titleStorageLoaded = false;
idLib::Printf( "ReadTitleStorage: FAILED\n" );
titleStorageVars.Clear();
}
}
/*
========================
idSessionLocal::ReadDLCInfo
========================
*/
bool idSessionLocal::ReadDLCInfo( idDict & dlcInfo, void * buffer, int bufferLen ) {
idParser parser( LEXFL_NOERRORS | LEXFL_NOFATALERRORS | LEXFL_NOSTRINGCONCAT );
parser.LoadMemory( ( const char* )buffer, bufferLen, "info.txt" );
bool valid = true;
while ( true ) {
idToken token;
if ( !parser.ReadToken( &token ) ) {
break;
}
if ( token.Icmp( "dlcInfo" ) == 0 ) {
if ( !dlcInfo.Parse( parser ) ) {
valid = false;
break;
}
} else {
valid = false;
break;
}
}
return valid;
}
/*
========================
idSessionLocal::IsPlatformPartyInLobby
========================
*/
bool idSessionLocal::IsPlatformPartyInLobby() {
idLocalUser * user = session->GetSignInManager().GetMasterLocalUser();
idLobby * lobby = GetActivePlatformLobby();
if ( user == NULL || lobby == NULL ) {
return false;
}
if ( user->GetPartyCount() > MAX_PLAYERS || user->GetPartyCount() < 2 ) {
return false;
}
// TODO: Implement PC
return false;
}
/*
========================
idSessionLocal::PrePickNewHost
This is called when we have determined that we need to pick a new host.
Call PickNewHostInternal to continue on with the host picking process.
========================
*/
void idSessionLocal::PrePickNewHost( idLobby & lobby, bool forceMe, bool inviteOldHost ) {
NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: (%s)\n", lobby.GetLobbyName() );
if ( GetActivePlatformLobby() == NULL ) {
NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: GetActivePlatformLobby() == NULL (%s)\n", lobby.GetLobbyName() );
return;
}
// Check to see if we can migrate AT ALL
// This is checking for coop, we should make this a specific option (MATCH_ALLOW_MIGRATION)
if ( GetPartyLobby().parms.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) {
NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: MATCH_PARTY_INVITE_PLACEHOLDER (%s)\n", lobby.GetLobbyName() );
// Can't migrate, shut both lobbies down, and create a new match using the original parms
GetGameStateLobby().Shutdown();
GetGameLobby().Shutdown();
GetPartyLobby().Shutdown();
// Throw up the appropriate dialog message so the player knows what happeend
if ( localState >= idSessionLocal::STATE_LOADING ) {
NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: localState >= idSessionLocal::STATE_LOADING (%s)\n", lobby.GetLobbyName() );
common->Dialog().AddDialog( GDM_BECAME_HOST_GAME_STATS_DROPPED, DIALOG_ACCEPT, NULL, NULL, false, __FUNCTION__, __LINE__, true );
} else {
NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: localState < idSessionLocal::STATE_LOADING (%s)\n", lobby.GetLobbyName() );
common->Dialog().AddDialog( GDM_LOBBY_BECAME_HOST_GAME, DIALOG_ACCEPT, NULL, NULL, false, __FUNCTION__, __LINE__, true );
}
CreateMatch( GetActivePlatformLobby()->parms );
return;
}
// Check to see if the match is searchable
if ( GetState() >= idSession::GAME_LOBBY && MatchTypeIsSearchable( GetGameLobby().parms.matchFlags ) ) {
NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: MatchTypeIsSearchable (%s)\n", lobby.GetLobbyName() );
// Searchable games migrate lobbies independently, and don't need to stay in sync
lobby.PickNewHostInternal( forceMe, inviteOldHost );
return;
}
//
// Beyond this point, game lobbies must be sync'd with party lobbies as far as host status
// So to enforce that, we pull you out of the game lobby if you are in one when migration occurs
//
// Check to see if we should go back to a party lobby
if ( GetBackState() >= idSessionLocal::PARTY_LOBBY || GetState() == idSession::PARTY_LOBBY ) {
NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: GetBackState() >= idSessionLocal::PARTY_LOBBY || GetState() == idSession::PARTY_LOBBY (%s)\n", lobby.GetLobbyName() );
// Force the party lobby to start picking a new host if we lost the game lobby host
GetPartyLobby().PickNewHostInternal( forceMe, inviteOldHost );
// End the game lobby, and go back to party lobby
GetGameStateLobby().Shutdown();
GetGameLobby().Shutdown();
SetState( GetPartyLobby().IsHost() ? idSessionLocal::STATE_PARTY_LOBBY_HOST : idSessionLocal::STATE_PARTY_LOBBY_PEER );
} else {
NET_VERBOSE_PRINT("idSessionLocal::PrePickNewHost: GetBackState() < idSessionLocal::PARTY_LOBBY && GetState() != idSession::PARTY_LOBBY (%s)\n", lobby.GetLobbyName() );
if ( localState >= idSessionLocal::STATE_LOADING ) {
common->Dialog().AddDialog( GDM_HOST_QUIT, DIALOG_ACCEPT, NULL, NULL, false, __FUNCTION__, __LINE__, true ); // The host has quit the session. Returning to the main menu.
}
// Go back to main menu
GetGameLobby().Shutdown();
GetGameStateLobby().Shutdown();
GetPartyLobby().Shutdown();
SetState( idSessionLocal::STATE_IDLE );
}
}
/*
========================
idSessionLocal::PreMigrateInvite
This is called just before we get invited to a migrated session
If we return false, the invite will be ignored
========================
*/
bool idSessionLocal::PreMigrateInvite( idLobby & lobby )
{
if ( GetActivePlatformLobby() == NULL ) {
return false;
}
// Check to see if we can migrate AT ALL
// This is checking for coop, we should make this a specific option (MATCH_ALLOW_MIGRATION)
if ( !verify( ( GetPartyLobby().parms.matchFlags & MATCH_PARTY_INVITE_PLACEHOLDER ) == 0 ) ) {
return false; // Shouldn't get invites for coop (we should make this a specific option (MATCH_ALLOW_MIGRATION))
}
// Check to see if the match is searchable
if ( MatchTypeIsSearchable( GetGameLobby().parms.matchFlags ) ) {
// Searchable games migrate lobbies independently, and don't need to stay in sync
return true;
}
//
// Beyond this point, game lobbies must be sync'd with party lobbies as far as host status
// So to enforce that, we pull you out of the game lobby if you are in one when migration occurs
//
if ( lobby.lobbyType != idLobby::TYPE_PARTY ) {
return false; // We shouldn't be getting invites from non party lobbies when in a non searchable game
}
// Non placeholder Party lobbies can always migrate
if ( GetBackState() >= idSessionLocal::PARTY_LOBBY ) {
// Non searchable games go back to the party lobby
GetGameLobby().Shutdown();
SetState( GetPartyLobby().IsHost() ? idSessionLocal::STATE_PARTY_LOBBY_HOST : idSessionLocal::STATE_PARTY_LOBBY_PEER );
}
return true; // Non placeholder Party lobby invites joinable
}
/*
================================================================================================
lobbyAddress_t
================================================================================================
*/
/*
========================
lobbyAddress_t::lobbyAddress_t
========================
*/
lobbyAddress_t::lobbyAddress_t() {
memset( &netAddr, 0, sizeof( netAddr ) );
netAddr.type = NA_BAD;
}
/*
========================
lobbyAddress_t::InitFromIPandPort
========================
*/
void lobbyAddress_t::InitFromIPandPort( const char * ip, int port ) {
Sys_StringToNetAdr( ip, &netAddr, true );
if ( !netAddr.port ) {
netAddr.port = port;
}
}
/*
========================
lobbyAddress_t::InitFromNetadr
========================
*/
void lobbyAddress_t::InitFromNetadr( const netadr_t & netadr ) {
assert( netadr.type != NA_BAD );
netAddr = netadr;
}
/*
========================
lobbyAddress_t::ToString
========================
*/
const char * lobbyAddress_t::ToString() const {
return Sys_NetAdrToString( netAddr );
}
/*
========================
lobbyAddress_t::UsingRelay
========================
*/
bool lobbyAddress_t::UsingRelay() const {
return false;
}
/*
========================
lobbyAddress_t::Compare
========================
*/
bool lobbyAddress_t::Compare( const lobbyAddress_t & addr, bool ignoreSessionCheck ) const {
return Sys_CompareNetAdrBase( netAddr, addr.netAddr );
}
/*
========================
lobbyAddress_t::WriteToMsg
========================
*/
void lobbyAddress_t::WriteToMsg( idBitMsg & msg ) const {
msg.WriteData( &netAddr, sizeof( netAddr ) );
}
/*
========================
lobbyAddress_t::ReadFromMsg
========================
*/
void lobbyAddress_t::ReadFromMsg( idBitMsg & msg ) {
msg.ReadData( &netAddr, sizeof( netAddr ) );
}
/*
================================================================================================
idNetSessionPort
================================================================================================
*/
/*
========================
idNetSessionPort::idNetSessionPort
========================
*/
idNetSessionPort::idNetSessionPort() :
forcePacketDropPrev( 0.0f ),
forcePacketDropCurr( 0.0f )
{
}
/*
========================
idNetSessionPort::InitPort
========================
*/
bool idNetSessionPort::InitPort( int portNumber, bool useBackend ) {
return UDP.InitForPort( portNumber );
}
/*
========================
idNetSessionPort::ReadRawPacket
========================
*/
bool idNetSessionPort::ReadRawPacket( lobbyAddress_t & from, void * data, int & size, int maxSize ) {
bool result = UDP.GetPacket( from.netAddr, data, size, maxSize );
static idRandom2 random( Sys_Milliseconds() );
if ( net_forceDrop.GetInteger() != 0 ) {
forcePacketDropCurr = random.RandomInt( 100 );
if ( net_forceDrop.GetInteger() >= forcePacketDropCurr ) {
return false;
}
}
return result;
}
/*
========================
idNetSessionPort::SendRawPacket
========================
*/
void idNetSessionPort::SendRawPacket( const lobbyAddress_t & to, const void * data, int size ) {
static idRandom2 random( Sys_Milliseconds() );
if ( net_forceDrop.GetInteger() != 0 && net_forceDrop.GetInteger() >= random.RandomInt( 100 ) ) {
return;
}
assert( size <= idPacketProcessor::MAX_FINAL_PACKET_SIZE );
UDP.SendPacket( to.netAddr, data, size );
}
/*
========================
idNetSessionPort::IsOpen
========================
*/
bool idNetSessionPort::IsOpen() {
return UDP.IsOpen();
}
/*
========================
idNetSessionPort::Close
========================
*/
void idNetSessionPort::Close() {
UDP.Close();
}
/*
================================================================================================
Commands
================================================================================================
*/
//====================================================================================
CONSOLE_COMMAND( voicechat_mute, "TEMP", 0 ) {
if ( args.Argc() != 2 ) {
idLib::Printf( "Usage: voicechat_mute <user index>\n" );
return;
}
int i = atoi( args.Argv( 1 ) );
session->ToggleLobbyUserVoiceMute( session->GetActivePlatformLobbyBase().GetLobbyUserIdByOrdinal( i ) );
}
/*
========================
force_disconnect_all
========================
*/
CONSOLE_COMMAND( force_disconnect_all, "force disconnect on all users", 0 ) {
session->GetSignInManager().RemoveAllLocalUsers();
}
/*
========================
void Net_DebugOutputSignedInUsers_f
========================
*/
void Net_DebugOutputSignedInUsers_f( const idCmdArgs &args ) {
session->GetSignInManager().DebugOutputLocalUserInfo();
}
idCommandLink Net_DebugOutputSignedInUsers( "net_debugOutputSignedInUsers", Net_DebugOutputSignedInUsers_f, "Outputs all the local users and other debugging information from the sign in manager" );
/*
========================
void Net_RemoveUserFromLobby_f
========================
*/
void Net_RemoveUserFromLobby_f( const idCmdArgs &args ) {
if ( args.Argc() > 1 ) {
int localUserNum = atoi( args.Argv( 1 ) );
if ( localUserNum < session->GetSignInManager().GetNumLocalUsers() ) {
session->GetSignInManager().RemoveLocalUserByIndex( localUserNum );
} else {
idLib::Printf( "This user is not in the lobby\n" );
}
} else {
idLib::Printf( "Usage: net_RemoveUserFromLobby <localUserNum>\n" );
}
}
idCommandLink Net_RemoveUserFromLobby( "net_removeUserFromLobby", Net_RemoveUserFromLobby_f, "Removes the given user from the lobby" );
/*
========================
Net_dropClient
========================
*/
CONSOLE_COMMAND( Net_DropClient, "Drop a client", 0 ) {
if ( args.Argc() < 3 ) {
idLib::Printf( "usage: Net_DropClient <clientnum> [<session>] 0/default: drop from game, 1: drop from party, otherwise drop from both\n" );
return;
}
int lobbyType = 0;
if ( args.Argc() > 2 ) {
lobbyType = atoi( args.Argv( 2 ) );
}
session->DropClient( atoi( args.Argv(1) ), lobbyType );
}
/*
========================
idSessionLocal::DropClient
========================
*/
void idSessionLocal::DropClient( int peerNum, int session ) {
if ( session == 1 || session >= 2 ) {
GetPartyLobby().DisconnectPeerFromSession( peerNum );
}
if ( session == 0 || session >= 2 ) {
GetGameLobby().DisconnectPeerFromSession( peerNum );
}
}
/*
========================
idSessionLocal::ListServersCommon
========================
*/
void idSessionLocal::ListServersCommon() {
netadr_t broadcast;
memset( &broadcast, 0, sizeof( broadcast ) );
broadcast.type = NA_BROADCAST;
broadcast.port = net_port.GetInteger();
lobbyAddress_t address;
address.InitFromNetadr( broadcast );
byte buffer[ idPacketProcessor::MAX_PACKET_SIZE - 2 ];
idBitMsg msg( buffer, sizeof( buffer ) );
// Add the current version info to the query
const unsigned long localChecksum = NetGetVersionChecksum();
NET_VERBOSE_PRINT( "ListServers: Hash checksum: %i, broadcasting to: %s\n", localChecksum, address.ToString() );
msg.WriteLong( localChecksum );
GetPort();
// Send the query as a broadcast
GetPartyLobby().SendConnectionLess( address, idLobby::OOB_MATCH_QUERY, msg.GetReadData(), msg.GetSize() );
}
/*
========================
idSessionLocal::HandleDedicatedServerQueryRequest
========================
*/
void idSessionLocal::HandleDedicatedServerQueryRequest( lobbyAddress_t & remoteAddr, idBitMsg & msg, int msgType ) {
NET_VERBOSE_PRINT( "HandleDedicatedServerQueryRequest from %s\n", remoteAddr.ToString() );
bool canJoin = true;
const unsigned long localChecksum = NetGetVersionChecksum();
const unsigned long remoteChecksum = msg.ReadLong();
if ( remoteChecksum != localChecksum ) {
NET_VERBOSE_PRINT( "HandleServerQueryRequest: Invalid version from %s\n", remoteAddr.ToString() );
canJoin = false;
}
// Make sure we are the host of this party session
if ( !GetPartyLobby().IsHost() ) {
NET_VERBOSE_PRINT( "HandleServerQueryRequest: Not host of party\n" );
canJoin = false;
}
// Make sure there is a session active
if ( GetActivePlatformLobby() == NULL ) {
canJoin = false;
}
// Make sure we have enough free slots
if ( GetPartyLobby().NumFreeSlots() == 0 || GetGameLobby().NumFreeSlots() == 0 ) {
NET_VERBOSE_PRINT( "No free slots\n" );
canJoin = false;
}
if ( MatchTypeInviteOnly( GetPartyLobby().parms.matchFlags ) ) {
canJoin = false;
}
// Buffer to hold reply msg
byte buffer[ idPacketProcessor::MAX_PACKET_SIZE - 2 ];
idBitMsg retmsg( buffer, sizeof( buffer ) );
idLocalUser * masterUser = GetSignInManager().GetMasterLocalUser();
if ( masterUser == NULL && !net_headlessServer.GetBool() ) {
canJoin = false;
}
// Send the info about this game session to the caller
retmsg.WriteBool( canJoin );
if ( canJoin ) {
serverInfo_t serverInfo;
serverInfo.joinable = ( session->GetState() >= idSession::LOADING );
if ( !net_headlessServer.GetBool() ) {
serverInfo.serverName = masterUser->GetGamerTag();
}
if ( GetGameLobby().IsLobbyActive() ) {
serverInfo.gameMap = GetGameLobby().parms.gameMap;
serverInfo.gameMode = GetGameLobby().parms.gameMode;
} else {
serverInfo.gameMode = -1;
}
serverInfo.numPlayers = GetActivePlatformLobby()->GetNumLobbyUsers();
serverInfo.maxPlayers = GetActivePlatformLobby()->parms.numSlots;
serverInfo.Write( retmsg );
for ( int i = 0; i < GetActivePlatformLobby()->GetNumLobbyUsers(); i++ ) {
retmsg.WriteString( GetActivePlatformLobby()->GetLobbyUserName( GetActivePlatformLobby()->GetLobbyUserIdByOrdinal( i ) ) );
}
}
// Send it
GetPartyLobby().SendConnectionLess( remoteAddr, idLobby::OOB_MATCH_QUERY_ACK, retmsg.GetReadData(), retmsg.GetSize() );
}
/*
========================
idSessionLocal::HandleDedicatedServerQueryAck
========================
*/
void idSessionLocal::HandleDedicatedServerQueryAck( lobbyAddress_t & remoteAddr, idBitMsg & msg ) {
NET_VERBOSE_PRINT( "HandleDedicatedServerQueryAck from %s\n", remoteAddr.ToString() );
dedicatedServerSearch->HandleQueryAck( remoteAddr, msg );
}
/*
========================
idSessionLocal::ServerPlayerList
========================
*/
const idList< idStr > * idSessionLocal::ServerPlayerList( int i ) {
return NULL;
}
/*
========================
lobbyUserID_t::Serialize
========================
*/
void lobbyUserID_t::Serialize( idSerializer & ser ) {
localUserHandle.Serialize( ser );
ser.Serialize( lobbyType );
}
Reference in a new issue Copy permalink