d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
361 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: ba90de20d9
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ba90de20d9'
${ noResults }
source-engine/engine/Session.cpp

611 lines
16 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "Session.h"
#include "strtools.h"
#include "matchmaking.h"
#include "utllinkedlist.h"
#include "tslist.h"
#include "hl2orange.spa.h"
#include "dbg.h"
#ifdef IS_WINDOWS_PC
#include "winlite.h" // for CloseHandle()
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern IXboxSystem *g_pXboxSystem;
#define ASYNC_OK 0
#define ASYNC_FAIL 1
//-----------------------------------------------------------------------------
// Purpose: CSession class
//-----------------------------------------------------------------------------
CSession::CSession()
{
m_pParent = NULL;
m_hSession = INVALID_HANDLE_VALUE;
m_SessionState = SESSION_STATE_NONE;
m_pRegistrationResults = NULL;
ResetSession();
}
CSession::~CSession()
{
ResetSession();
}
//-----------------------------------------------------------------------------
// Purpose: Reset a session to it's initial state
//-----------------------------------------------------------------------------
void CSession::ResetSession()
{
// Cleanup first
switch( m_SessionState )
{
case SESSION_STATE_CREATING:
CancelCreateSession();
break;
case SESSION_STATE_MIGRATING:
// X360TBD:
break;
}
if ( m_hSession != INVALID_HANDLE_VALUE )
{
Msg( "ResetSession: Destroying current session.\n" );
DestroySession();
m_hSession = INVALID_HANDLE_VALUE;
}
SwitchToState( SESSION_STATE_NONE );
m_bIsHost = false;
m_bIsArbitrated = false;
m_bUsingQoS = false;
m_bIsSystemLink = false;
Q_memset( &m_nPlayerSlots, 0, sizeof( m_nPlayerSlots ) );
Q_memset( &m_SessionInfo, 0, sizeof( m_SessionInfo ) );
if ( m_pRegistrationResults )
{
delete m_pRegistrationResults;
}
m_nSessionFlags = 0;
}
//-----------------------------------------------------------------------------
// Purpose: Set session contexts and properties
//-----------------------------------------------------------------------------
void CSession::SetContext( const uint nContextId, const uint nContextValue, const bool bAsync )
{
g_pXboxSystem->UserSetContext( XBX_GetPrimaryUserId(), nContextId, nContextValue, bAsync );
}
void CSession::SetProperty( const uint nPropertyId, const uint cbValue, const void *pvValue, const bool bAsync )
{
g_pXboxSystem->UserSetProperty( XBX_GetPrimaryUserId(), nPropertyId, cbValue, pvValue, bAsync );
}
//-----------------------------------------------------------------------------
// Purpose: Send a notification to GameUI
//-----------------------------------------------------------------------------
void CSession::SendNotification( SESSION_NOTIFY notification )
{
Assert( m_pParent );
m_pParent->SessionNotification( notification );
}
//-----------------------------------------------------------------------------
// Purpose: Update the number of player slots filled
//-----------------------------------------------------------------------------
void CSession::UpdateSlots( const CClientInfo *pClient, bool bAddPlayers )
{
int cPlayers = pClient->m_cPlayers;
if ( bAddPlayers )
{
if ( pClient->m_bInvited )
{
// Fill private slots first, then overflow into public slots
m_nPlayerSlots[SLOTS_FILLEDPRIVATE] += cPlayers;
pClient->m_numPrivateSlotsUsed = cPlayers;
cPlayers = 0;
if ( m_nPlayerSlots[SLOTS_FILLEDPRIVATE] > m_nPlayerSlots[SLOTS_TOTALPRIVATE] )
{
cPlayers = m_nPlayerSlots[SLOTS_FILLEDPRIVATE] - m_nPlayerSlots[SLOTS_TOTALPRIVATE];
pClient->m_numPrivateSlotsUsed -= cPlayers;
m_nPlayerSlots[SLOTS_FILLEDPRIVATE] = m_nPlayerSlots[SLOTS_TOTALPRIVATE];
}
}
m_nPlayerSlots[SLOTS_FILLEDPUBLIC] += cPlayers;
if ( m_nPlayerSlots[SLOTS_FILLEDPUBLIC] > m_nPlayerSlots[SLOTS_TOTALPUBLIC] )
{
//Handle error
Warning( "Too many players!\n" );
}
}
else
{
// The cast to 'int' is needed since otherwise underflow will wrap around to very large
// numbers and the 'max' macro will do nothing.
m_nPlayerSlots[SLOTS_FILLEDPRIVATE] = max( 0, (int)( m_nPlayerSlots[SLOTS_FILLEDPRIVATE] - pClient->m_numPrivateSlotsUsed ) );
m_nPlayerSlots[SLOTS_FILLEDPUBLIC] = max( 0, (int)( m_nPlayerSlots[SLOTS_FILLEDPUBLIC] - ( pClient->m_cPlayers - pClient->m_numPrivateSlotsUsed ) ) );
}
}
//-----------------------------------------------------------------------------
// Purpose: Join players on the local client
//-----------------------------------------------------------------------------
void CSession::JoinLocal( const CClientInfo *pClient )
{
uint nUserIndex[MAX_PLAYERS_PER_CLIENT] = {0};
bool bPrivate[MAX_PLAYERS_PER_CLIENT] = {0};
for( int i = 0; i < pClient->m_cPlayers; ++i )
{
nUserIndex[i] = pClient->m_iControllers[i];
bPrivate[i] = pClient->m_bInvited;
}
// X360TBD: Make async?
uint ret = g_pXboxSystem->SessionJoinLocal( m_hSession, pClient->m_cPlayers, nUserIndex, bPrivate, false );
if ( ret != ERROR_SUCCESS )
{
// Handle error
Warning( "Failed to add local players\n" );
}
else
{
UpdateSlots( pClient, true );
}
}
//-----------------------------------------------------------------------------
// Purpose: Join players on a remote client
//-----------------------------------------------------------------------------
void CSession::JoinRemote( const CClientInfo *pClient )
{
XUID xuids[MAX_PLAYERS_PER_CLIENT] = {0};
bool bPrivate[MAX_PLAYERS_PER_CLIENT] = {0};
for( int i = 0; i < pClient->m_cPlayers; ++i )
{
xuids[i] = pClient->m_xuids[i];
bPrivate[i] = pClient->m_bInvited;
}
// X360TBD: Make async?
uint ret = g_pXboxSystem->SessionJoinRemote( m_hSession, pClient->m_cPlayers, xuids, bPrivate, false );
if ( ret != ERROR_SUCCESS )
{
// Handle error
Warning( "Join Remote Error\n" );
}
else
{
UpdateSlots( pClient, true );
}
}
//-----------------------------------------------------------------------------
// Purpose: Remove players on the local client
//-----------------------------------------------------------------------------
void CSession::RemoveLocal( const CClientInfo *pClient )
{
uint nUserIndex[MAX_PLAYERS_PER_CLIENT] = {0};
for( int i = 0; i < pClient->m_cPlayers; ++i )
{
nUserIndex[i] = pClient->m_iControllers[i];
}
// X360TBD: Make async?
uint ret = g_pXboxSystem->SessionLeaveLocal( m_hSession, pClient->m_cPlayers, nUserIndex, false );
if ( ret != ERROR_SUCCESS )
{
// Handle error
Warning( "Failed to remove local players\n" );
}
else
{
UpdateSlots( pClient, false );
}
}
//-----------------------------------------------------------------------------
// Purpose: Remove players on a remote client
//-----------------------------------------------------------------------------
void CSession::RemoveRemote( const CClientInfo *pClient )
{
XUID xuids[MAX_PLAYERS_PER_CLIENT] = {0};
for( int i = 0; i < pClient->m_cPlayers; ++i )
{
xuids[i] = pClient->m_xuids[i];
}
// X360TBD: Make async?
uint ret = g_pXboxSystem->SessionLeaveRemote( m_hSession, pClient->m_cPlayers, xuids, false );
if ( ret != ERROR_SUCCESS )
{
// Handle error
Warning( "Failed to remove remote players\n" );
}
else
{
UpdateSlots( pClient, false );
}
}
//-----------------------------------------------------------------------------
// Purpose: Create a new session
//-----------------------------------------------------------------------------
bool CSession::CreateSession()
{
if( INVALID_HANDLE_VALUE != m_hSession )
{
Warning( "CreateSession called on existing session!" );
DestroySession();
m_hSession = INVALID_HANDLE_VALUE;
}
uint flags = m_nSessionFlags;
if( m_bIsHost )
{
flags |= XSESSION_CREATE_HOST;
}
if ( flags & XSESSION_CREATE_USES_ARBITRATION )
{
m_bIsArbitrated = true;
}
m_hCreateHandle = g_pXboxSystem->CreateAsyncHandle();
// Create the session
uint ret = g_pXboxSystem->CreateSession( flags,
XBX_GetPrimaryUserId(),
m_nPlayerSlots[SLOTS_TOTALPUBLIC],
m_nPlayerSlots[SLOTS_TOTALPRIVATE],
&m_SessionNonce,
&m_SessionInfo,
&m_hSession,
true,
&m_hCreateHandle );
if( ret != ERROR_SUCCESS && ret != ERROR_IO_PENDING )
{
Warning( "XSessionCreate failed with error %d\n", ret );
return false;
}
SwitchToState( SESSION_STATE_CREATING );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Check for completion while creating a new session
//-----------------------------------------------------------------------------
void CSession::UpdateCreating()
{
DWORD ret = g_pXboxSystem->GetOverlappedResult( m_hCreateHandle, NULL, false );
if ( ret == ERROR_IO_INCOMPLETE )
{
// Still waiting
return;
}
else
{
SESSION_STATE nextState = SESSION_STATE_IDLE;
// Operation completed
SESSION_NOTIFY notification = IsHost() ? SESSION_NOTIFY_CREATED_HOST : SESSION_NOTIFY_CREATED_CLIENT;
if ( ret != ERROR_SUCCESS )
{
Warning( "CSession: CreateSession failed. Error %d\n", ret );
nextState = SESSION_STATE_NONE;
notification = SESSION_NOTIFY_FAIL_CREATE;
}
g_pXboxSystem->ReleaseAsyncHandle( m_hCreateHandle );
SendNotification( notification );
SwitchToState( nextState );
}
}
//-----------------------------------------------------------------------------
// Purpose: Cancel async session creation
//-----------------------------------------------------------------------------
void CSession::CancelCreateSession()
{
if ( m_SessionState != SESSION_STATE_CREATING )
return;
g_pXboxSystem->CancelOverlappedOperation( &m_hCreateHandle );
g_pXboxSystem->ReleaseAsyncHandle( m_hCreateHandle );
#ifndef POSIX
if( INVALID_HANDLE_VALUE != m_hSession )
{
CloseHandle( m_hSession );
m_hSession = INVALID_HANDLE_VALUE;
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Close an existing session
//-----------------------------------------------------------------------------
void CSession::DestroySession()
{
// TODO: Make this async
uint ret = g_pXboxSystem->DeleteSession( m_hSession, false );
if ( ret != ERROR_SUCCESS )
{
Warning( "Failed to delete session with error %d.\n", ret );
}
}
//-----------------------------------------------------------------------------
// Purpose: Register for arbritation in a ranked match
//-----------------------------------------------------------------------------
void CSession::RegisterForArbitration()
{
uint bytes = 0;
m_pRegistrationResults = NULL;
// Call once to determine size of results buffer
int ret = g_pXboxSystem->SessionArbitrationRegister( m_hSession, 0, m_SessionNonce, &bytes, NULL, false );
if ( ret != ERROR_INSUFFICIENT_BUFFER )
{
Warning( "Failed registering for arbitration\n" );
return;
}
m_pRegistrationResults = (XSESSION_REGISTRATION_RESULTS*)new byte[ bytes ];
m_hRegisterHandle = g_pXboxSystem->CreateAsyncHandle();
ret = g_pXboxSystem->SessionArbitrationRegister( m_hSession, 0, m_SessionNonce, &bytes, m_pRegistrationResults, true, &m_hRegisterHandle );
if( ret != ERROR_IO_PENDING )
{
Warning( "Failed registering for arbitration\n" );
}
m_SessionState = SESSION_STATE_REGISTERING;
}
//-----------------------------------------------------------------------------
// Purpose: Check for completion of arbitration registration
//-----------------------------------------------------------------------------
void CSession::UpdateRegistering()
{
DWORD ret = g_pXboxSystem->GetOverlappedResult( m_hRegisterHandle, NULL, false );
if ( ret == ERROR_IO_INCOMPLETE )
{
// Still waiting
return;
}
else
{
SESSION_STATE nextState = SESSION_STATE_IDLE;
// Operation completed
SESSION_NOTIFY notification = SESSION_NOTIFY_REGISTER_COMPLETED;
if ( ret != ERROR_SUCCESS )
{
Warning( "CSession: Registration failed. Error %d\n", ret );
nextState = SESSION_STATE_NONE;
notification = SESSION_NOTIFY_FAIL_REGISTER;
}
g_pXboxSystem->ReleaseAsyncHandle( m_hRegisterHandle );
SendNotification( notification );
SwitchToState( nextState );
}
}
//-----------------------------------------------------------------------------
// Purpose: Migrate the session to a new host
//-----------------------------------------------------------------------------
bool CSession::MigrateHost()
{
if ( IsHost() )
{
// Migrate call will fill this in for us
Q_memcpy( &m_NewSessionInfo, &m_SessionInfo, sizeof( m_NewSessionInfo ) );
}
m_hMigrateHandle = g_pXboxSystem->CreateAsyncHandle();
int ret = g_pXboxSystem->SessionMigrate( m_hSession, m_nOwnerId, &m_NewSessionInfo, true, &m_hMigrateHandle );
if ( ret != ERROR_IO_PENDING )
{
return false;
}
SwitchToState( SESSION_STATE_MIGRATING );
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Check for completion while migrating a session
//-----------------------------------------------------------------------------
void CSession::UpdateMigrating()
{
DWORD ret = g_pXboxSystem->GetOverlappedResult( m_hMigrateHandle, NULL, false );
if ( ret == ERROR_IO_INCOMPLETE )
{
// Still waiting
return;
}
else
{
SESSION_STATE nextState = SESSION_STATE_IDLE;
// Operation completed
SESSION_NOTIFY notification = SESSION_NOTIFY_MIGRATION_COMPLETED;
if ( ret != ERROR_SUCCESS )
{
Warning( "CSession: MigrateSession failed. Error %d\n", ret );
nextState = SESSION_STATE_NONE;
notification = SESSION_NOTIFY_FAIL_MIGRATE;
}
g_pXboxSystem->ReleaseAsyncHandle( m_hMigrateHandle );
SendNotification( notification );
SwitchToState( nextState );
}
}
//-----------------------------------------------------------------------------
// Purpose: Change state
//-----------------------------------------------------------------------------
void CSession::SwitchToState( SESSION_STATE newState )
{
m_SessionState = newState;
}
//-----------------------------------------------------------------------------
// Purpose: Per-frame update
//-----------------------------------------------------------------------------
void CSession::RunFrame()
{
switch( m_SessionState )
{
case SESSION_STATE_CREATING:
UpdateCreating();
break;
case SESSION_STATE_REGISTERING:
UpdateRegistering();
break;
case SESSION_STATE_MIGRATING:
UpdateMigrating();
break;
default:
break;
}
}
//-----------------------------------------------------------------------------
// Accessors
//-----------------------------------------------------------------------------
HANDLE CSession::GetSessionHandle()
{
return m_hSession;
}
void CSession::SetSessionInfo( XSESSION_INFO *pInfo )
{
memcpy( &m_SessionInfo, pInfo, sizeof( XSESSION_INFO ) );
}
void CSession::SetNewSessionInfo( XSESSION_INFO *pInfo )
{
memcpy( &m_NewSessionInfo, pInfo, sizeof( XSESSION_INFO ) );
}
void CSession::GetSessionInfo( XSESSION_INFO *pInfo )
{
Assert( pInfo );
memcpy( pInfo, &m_SessionInfo, sizeof( XSESSION_INFO ) );
}
void CSession::GetNewSessionInfo( XSESSION_INFO *pInfo )
{
Assert( pInfo );
memcpy( pInfo, &m_NewSessionInfo, sizeof( XSESSION_INFO ) );
}
void CSession::SetSessionNonce( int64 nonce )
{
m_SessionNonce = nonce;
}
uint64 CSession::GetSessionNonce()
{
return m_SessionNonce;
}
XNKID CSession::GetSessionId()
{
return m_SessionInfo.sessionID;
}
void CSession::SetSessionSlots(unsigned int nSlot, unsigned int nPlayers)
{
Assert( nSlot < SLOTS_LAST );
m_nPlayerSlots[nSlot] = nPlayers;
}
unsigned int CSession::GetSessionSlots( unsigned int nSlot )
{
Assert( nSlot < SLOTS_LAST );
return m_nPlayerSlots[nSlot];
}
void CSession::SetSessionFlags( uint flags )
{
m_nSessionFlags = flags;
}
uint CSession::GetSessionFlags()
{
return m_nSessionFlags;
}
int CSession::GetPlayerCount()
{
return m_nPlayerSlots[SLOTS_FILLEDPRIVATE] + m_nPlayerSlots[SLOTS_FILLEDPUBLIC];
}
void CSession::SetFlag( uint nFlag )
{
m_nSessionFlags |= nFlag;
}
void CSession::SetIsHost( bool bHost )
{
m_bIsHost = bHost;
}
void CSession::SetIsSystemLink( bool bSystemLink )
{
m_bIsSystemLink = bSystemLink;
}
void CSession::SetOwnerId( uint id )
{
m_nOwnerId = id;
}
bool CSession::IsHost()
{
return m_bIsHost;
}
bool CSession::IsFull()
{
return ( GetSessionSlots( SLOTS_TOTALPRIVATE ) == GetSessionSlots( SLOTS_FILLEDPRIVATE ) &&
GetSessionSlots( SLOTS_TOTALPUBLIC ) == GetSessionSlots( SLOTS_FILLEDPUBLIC ) );
}
bool CSession::IsArbitrated()
{
return m_bIsArbitrated;
}
bool CSession::IsSystemLink()
{
return m_bIsSystemLink;
}
void CSession::SetParent( CMatchmaking *pParent )
{
m_pParent = pParent;
}
double CSession::GetTime()
{
return Plat_FloatTime();
}