612 lines
16 KiB
C++
612 lines
16 KiB
C++
//========= 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();
|
|
}
|
|
|