mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-12 21:41:48 +00:00
474 lines
16 KiB
C++
474 lines
16 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
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 "../framework/Common_local.h"
|
|
#include "sys_session_local.h"
|
|
|
|
// The more the idLobby class needs to call back into this class, the more likely we're doing something wrong, and there is a better way.
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::BecomingHost
|
|
This is called when
|
|
========================
|
|
*/
|
|
bool idSessionLocalCallbacks::BecomingHost( idLobby& lobby )
|
|
{
|
|
if( lobby.lobbyType == idLobby::TYPE_GAME )
|
|
{
|
|
if( sessionLocal->GetActivePlatformLobby() != &lobby )
|
|
{
|
|
idLib::Printf( "BecomingHost: Must be past the party lobby to become host of a game lobby.\n" );
|
|
return false;
|
|
}
|
|
if( sessionLocal->localState == idSessionLocal::STATE_INGAME || sessionLocal->localState == idSessionLocal::STATE_LOADING )
|
|
{
|
|
// If we are in a game, go back to the lobby before becoming the new host of a game lobby
|
|
sessionLocal->SetState( idSessionLocal::STATE_GAME_LOBBY_PEER );
|
|
|
|
// session mgr housekeeping that would usually be done through the standard EndMatch path
|
|
sessionLocal->EndMatchForMigration();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::BecameHost
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::BecameHost( idLobby& lobby )
|
|
{
|
|
// If we were in the lobby when we switched to host, then set the right state
|
|
if( lobby.lobbyType == idLobby::TYPE_PARTY && sessionLocal->localState == idSessionLocal::STATE_PARTY_LOBBY_PEER )
|
|
{
|
|
sessionLocal->SetState( idSessionLocal::STATE_PARTY_LOBBY_HOST );
|
|
}
|
|
else if( lobby.lobbyType == idLobby::TYPE_GAME && sessionLocal->localState == idSessionLocal::STATE_GAME_LOBBY_PEER )
|
|
{
|
|
sessionLocal->SetState( idSessionLocal::STATE_GAME_LOBBY_HOST );
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::BecomingPeer
|
|
========================
|
|
*/
|
|
bool idSessionLocalCallbacks::BecomingPeer( idLobby& lobby )
|
|
{
|
|
if( lobby.lobbyType == idLobby::TYPE_GAME )
|
|
{
|
|
if( sessionLocal->localState == idSessionLocal::STATE_INGAME || sessionLocal->localState == idSessionLocal::STATE_LOADING )
|
|
{
|
|
// Go to the party lobby while we try to connect to the new host
|
|
// This isn't totally necessary but we want to end the current game now and go to some screen.
|
|
// When the connection goes through or fails will send the session mgr to the appropriate state (game lobby or main menu)
|
|
|
|
// What happens if we got the game migration before the party migration?
|
|
sessionLocal->SetState( sessionLocal->GetPartyLobby().IsHost() ? idSessionLocal::STATE_PARTY_LOBBY_HOST : idSessionLocal::STATE_PARTY_LOBBY_PEER );
|
|
|
|
// session mgr housekeeping that would usually be done through the standard EndMatch path
|
|
sessionLocal->EndMatchForMigration();
|
|
|
|
return true; // return true tells the session that we want him to tell us when the connects/fails
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::BecamePeer
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::BecamePeer( idLobby& lobby )
|
|
{
|
|
if( lobby.lobbyType == idLobby::TYPE_GAME )
|
|
{
|
|
sessionLocal->SetState( idSessionLocal::STATE_GAME_LOBBY_PEER );
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::FailedGameMigration
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::FailedGameMigration( idLobby& lobby )
|
|
{
|
|
// We failed to complete a game migration this could happen for a couple reasons:
|
|
// -The network invites failed / failed to join migrated session
|
|
// -There was nobody to invite
|
|
lobby.ResetAllMigrationState();
|
|
if( lobby.lobbyType == idLobby::TYPE_GAME ) // this check is a redundant since we should only get this CB from the game session
|
|
{
|
|
|
|
sessionLocal->SetState( idSessionLocal::STATE_GAME_LOBBY_HOST );
|
|
|
|
// Make sure the sessions are joinable again
|
|
sessionLocal->EndSessions();
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::MigrationEnded
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::MigrationEnded( idLobby& lobby )
|
|
{
|
|
if( lobby.migrationInfo.persistUntilGameEndsData.wasMigratedGame )
|
|
{
|
|
#if 1
|
|
if( lobby.lobbyType == idLobby::TYPE_GAME || ( lobby.lobbyType == idLobby::TYPE_PARTY && session->GetState() <= idSession::PARTY_LOBBY ) )
|
|
{
|
|
common->Dialog().ClearDialog( GDM_MIGRATING );
|
|
common->Dialog().ClearDialog( GDM_MIGRATING_WAITING );
|
|
common->Dialog().ClearDialog( GDM_MIGRATING_RELAUNCHING );
|
|
|
|
if( lobby.GetNumLobbyUsers() <= 1 )
|
|
{
|
|
if( MatchTypeHasStats( lobby.parms.matchFlags ) )
|
|
{
|
|
common->Dialog().AddDialog( GDM_MIGRATING_FAILED_DISBANDED_STATS, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true ); // Game has disbanded
|
|
}
|
|
else
|
|
{
|
|
common->Dialog().AddDialog( GDM_MIGRATING_FAILED_DISBANDED, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true ); // Game has disbanded
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//common->Dialog().AddDialog( GDM_MIGRATING_FAILED_CONNECTION, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true ); // Lost connection to game
|
|
if( lobby.lobbyType == idLobby::TYPE_GAME && MatchTypeHasStats( lobby.parms.matchFlags ) )
|
|
{
|
|
// This means we came from a public match, so tell them they didn't lose stats
|
|
common->Dialog().AddDialog( GDM_HOST_CONNECTION_LOST_STATS, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true ); // The connection to the host has been lost. This game will not count towards your ranking.
|
|
}
|
|
else
|
|
{
|
|
// This means we came from a private match, just say host quit
|
|
common->Dialog().AddDialog( GDM_HOST_CONNECTION_LOST, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true ); // The connection to the host has been lost.
|
|
}
|
|
}
|
|
|
|
lobby.ResetAllMigrationState();
|
|
|
|
// Make sure the sessions are joinable again
|
|
sessionLocal->EndSessions();
|
|
}
|
|
#else
|
|
// If we get here, we migrated from a game
|
|
if( lobby.GetNumLobbyUsers() <= 1 && lobby.lobbyType == idLobby::TYPE_GAME )
|
|
{
|
|
if( !MatchTypeIsJoinInProgress( lobby.parms.matchFlags ) )
|
|
{
|
|
// Handles 'soft' failed game migration where we migrated from a game and are now alone
|
|
gameDialogMessages_t errorDlg = GDM_INVALID;
|
|
lobby.migrationInfo.persistUntilGameEndsData.hasGameData = false; // never restart the game if we are by ourselves
|
|
if( lobby.migrationInfo.invites.Num() > 0 )
|
|
{
|
|
// outstanding invites: migration failed
|
|
errorDlg = ( MatchTypeHasStats( lobby.migrateMsgFlags ) && ( sessionLocal->GetFlushedStats() == false ) ) ? GDM_MIGRATING_FAILED_CONNECTION_STATS : GDM_MIGRATING_FAILED_CONNECTION;
|
|
}
|
|
else
|
|
{
|
|
// there was no one to invite
|
|
errorDlg = ( MatchTypeHasStats( lobby.migrateMsgFlags ) && ( sessionLocal->GetFlushedStats() == false ) ) ? GDM_MIGRATING_FAILED_DISBANDED_STATS : GDM_MIGRATING_FAILED_DISBANDED;
|
|
}
|
|
if( errorDlg != GDM_INVALID )
|
|
{
|
|
common->Dialog().AddDialog( errorDlg, DIALOG_ACCEPT, NULL, NULL, false );
|
|
}
|
|
common->Dialog().ClearDialog( GDM_MIGRATING );
|
|
common->Dialog().ClearDialog( GDM_MIGRATING_WAITING );
|
|
common->Dialog().ClearDialog( GDM_MIGRATING_RELAUNCHING );
|
|
|
|
FailedGameMigration( lobby );
|
|
}
|
|
}
|
|
else if( lobby.lobbyType == idLobby::TYPE_PARTY )
|
|
{
|
|
if( session->GetState() <= idSession::PARTY_LOBBY )
|
|
{
|
|
// We got dropped the party lobby, let them know what happened
|
|
common->Dialog().ClearDialog( GDM_MIGRATING );
|
|
common->Dialog().ClearDialog( GDM_MIGRATING_WAITING );
|
|
common->Dialog().ClearDialog( GDM_MIGRATING_RELAUNCHING );
|
|
|
|
if( lobby.GetNumLobbyUsers() <= 1 )
|
|
{
|
|
common->Dialog().AddDialog( GDM_MIGRATING_FAILED_DISBANDED, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true ); // Game has disbanded
|
|
}
|
|
else
|
|
{
|
|
//common->Dialog().AddDialog( GDM_MIGRATING_FAILED_CONNECTION, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true ); // Lost connection to game
|
|
common->Dialog().AddDialog( GDM_HOST_CONNECTION_LOST_STATS, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true );
|
|
}
|
|
|
|
lobby.ResetAllMigrationState();
|
|
|
|
// Make sure the sessions are joinable again
|
|
sessionLocal->EndSessions();
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
else if( lobby.GetNumLobbyUsers() <= 1 && session->GetState() == idSession::PARTY_LOBBY )
|
|
{
|
|
// If they didn't come from a game, and are by themselves, just show the lobby disband msg
|
|
common->Dialog().AddDialog( GDM_LOBBY_DISBANDED, DIALOG_ACCEPT, NULL, NULL, false, "", 0, true ); // The lobby you were previously in has disbanded
|
|
|
|
// Make sure the sessions are joinable again
|
|
sessionLocal->EndSessions();
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::GoodbyeFromHost
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::GoodbyeFromHost( idLobby& lobby, int peerNum, const lobbyAddress_t& remoteAddress, int msgType )
|
|
{
|
|
sessionLocal->GoodbyeFromHost( lobby, peerNum, remoteAddress, msgType );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::AnyPeerHasAddress
|
|
========================
|
|
*/
|
|
bool idSessionLocalCallbacks::AnyPeerHasAddress( const lobbyAddress_t& remoteAddress ) const
|
|
{
|
|
return sessionLocal->GetPartyLobby().FindAnyPeer( remoteAddress ) || sessionLocal->GetGameLobby().FindAnyPeer( remoteAddress );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::RecvLeaderboardStats
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::RecvLeaderboardStats( idBitMsg& msg )
|
|
{
|
|
// Steam and PS3 just write them as they come per player, they don't need to flush
|
|
sessionLocal->RecvLeaderboardStatsForPlayer( msg );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::ReceivedFullSnap
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::ReceivedFullSnap()
|
|
{
|
|
// If we received a full snap, then we can transition into the INGAME state
|
|
sessionLocal->numFullSnapsReceived++;
|
|
|
|
if( sessionLocal->numFullSnapsReceived < 2 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( sessionLocal->localState != idSessionLocal::STATE_INGAME )
|
|
{
|
|
sessionLocal->GetActingGameStateLobby().QueueReliableMessage( sessionLocal->GetActingGameStateLobby().host, idLobby::RELIABLE_IN_GAME ); // Let host know we are in game now
|
|
sessionLocal->SetState( idSessionLocal::STATE_INGAME );
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::LeaveGameLobby
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::LeaveGameLobby()
|
|
{
|
|
|
|
// Make sure we're in the game lobby
|
|
if( session->GetState() != idSession::GAME_LOBBY )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// If we're the host of the party, only we are allowed to make this call
|
|
if( sessionLocal->GetPartyLobby().IsHost() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
sessionLocal->GetGameLobby().Shutdown();
|
|
sessionLocal->SetState( idSessionLocal::STATE_PARTY_LOBBY_PEER );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::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 idSessionLocalCallbacks::PrePickNewHost( idLobby& lobby, bool forceMe, bool inviteOldHost )
|
|
{
|
|
sessionLocal->PrePickNewHost( lobby, forceMe, inviteOldHost );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::PreMigrateInvite
|
|
This is called just before we get invited to a migrated session
|
|
If we return false, the invite will be ignored
|
|
========================
|
|
*/
|
|
bool idSessionLocalCallbacks::PreMigrateInvite( idLobby& lobby )
|
|
{
|
|
return sessionLocal->PreMigrateInvite( lobby );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::ConnectAndMoveToLobby
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::ConnectAndMoveToLobby( idLobby::lobbyType_t destLobbyType, const lobbyConnectInfo_t& connectInfo, bool waitForPartyOk )
|
|
{
|
|
|
|
// See if we are already in the game lobby
|
|
idLobby* lobby = sessionLocal->GetLobbyFromType( destLobbyType );
|
|
|
|
if( lobby == NULL )
|
|
{
|
|
idLib::Printf( "RELIABLE_CONNECT_AND_MOVE_TO_LOBBY: Invalid lobby type.\n" );
|
|
return;
|
|
}
|
|
|
|
if( lobby->lobbyBackend != NULL && lobby->lobbyBackend->IsOwnerOfConnectInfo( connectInfo ) )
|
|
{
|
|
idLib::Printf( "RELIABLE_CONNECT_AND_MOVE_TO_LOBBY: Already in lobby.\n" );
|
|
return;
|
|
}
|
|
|
|
// See if we are in a game, or loading into a game. If so, ignore invites from our party host
|
|
if( destLobbyType == idLobby::TYPE_GAME || destLobbyType == idLobby::TYPE_GAME_STATE )
|
|
{
|
|
if( GetState() == idSession::INGAME || GetState() == idSession::LOADING )
|
|
{
|
|
idLib::Printf( "RELIABLE_CONNECT_AND_MOVE_TO_LOBBY: In a different game, ignoring.\n" );
|
|
return;
|
|
}
|
|
}
|
|
|
|
// End current game lobby
|
|
lobby->Shutdown();
|
|
|
|
// waitForPartyOk will be true if the party host wants us to wait for his ok to stay in the lobby
|
|
lobby->waitForPartyOk = waitForPartyOk;
|
|
|
|
// Connect to new game lobby
|
|
sessionLocal->ConnectAndMoveToLobby( *lobby, connectInfo, true ); // Consider this an invite if party host told us to connect
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::HandleServerQueryRequest
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::HandleServerQueryRequest( lobbyAddress_t& remoteAddr, idBitMsg& msg, int msgType )
|
|
{
|
|
sessionLocal->HandleServerQueryRequest( remoteAddr, msg, msgType );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::HandleServerQueryAck
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::HandleServerQueryAck( lobbyAddress_t& remoteAddr, idBitMsg& msg )
|
|
{
|
|
sessionLocal->HandleServerQueryAck( remoteAddr, msg );
|
|
}
|
|
|
|
extern idCVar net_headlessServer;
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::HandlePeerMatchParamUpdate
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::HandlePeerMatchParamUpdate( int peer, int msg )
|
|
{
|
|
if( net_headlessServer.GetBool() )
|
|
{
|
|
sessionLocal->storedPeer = peer;
|
|
sessionLocal->storedMsgType = msg;
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::CreateLobbyBackend
|
|
========================
|
|
*/
|
|
idLobbyBackend* idSessionLocalCallbacks::CreateLobbyBackend( const idMatchParameters& p, float skillLevel, idLobbyBackend::lobbyBackendType_t lobbyType )
|
|
{
|
|
return sessionLocal->CreateLobbyBackend( p, skillLevel, lobbyType );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::FindLobbyBackend
|
|
========================
|
|
*/
|
|
idLobbyBackend* idSessionLocalCallbacks::FindLobbyBackend( const idMatchParameters& p, int numPartyUsers, float skillLevel, idLobbyBackend::lobbyBackendType_t lobbyType )
|
|
{
|
|
return sessionLocal->FindLobbyBackend( p, numPartyUsers, skillLevel, lobbyType );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::JoinFromConnectInfo
|
|
========================
|
|
*/
|
|
idLobbyBackend* idSessionLocalCallbacks::JoinFromConnectInfo( const lobbyConnectInfo_t& connectInfo , idLobbyBackend::lobbyBackendType_t lobbyType )
|
|
{
|
|
return sessionLocal->JoinFromConnectInfo( connectInfo, lobbyType );
|
|
}
|
|
|
|
/*
|
|
========================
|
|
idSessionLocalCallbacks::DestroyLobbyBackend
|
|
========================
|
|
*/
|
|
void idSessionLocalCallbacks::DestroyLobbyBackend( idLobbyBackend* lobbyBackend )
|
|
{
|
|
sessionLocal->DestroyLobbyBackend( lobbyBackend );
|
|
}
|