1351 lines
36 KiB
C++
1351 lines
36 KiB
C++
//===== Copyright © 1996-2009, Valve Corporation, All rights reserved. ======//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include "mm_framework.h"
|
|
|
|
#include "fmtstr.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
#ifdef _X360
|
|
|
|
|
|
|
|
//
|
|
// Dormant operations
|
|
//
|
|
|
|
struct OverlappedDormant_t
|
|
{
|
|
XOVERLAPPED *m_pOverlapped;
|
|
void ( *m_pfnCompletion )( XOVERLAPPED *, void * );
|
|
void *m_pvParam;
|
|
};
|
|
static CUtlVector< OverlappedDormant_t > s_arrOverlappedDormants;
|
|
|
|
struct ScheduledCall_t
|
|
{
|
|
float m_flTimeToCall;
|
|
void ( *m_pfnCall )( ScheduledCall_t *pThis );
|
|
};
|
|
static CUtlVector< ScheduledCall_t * > s_arrScheduledCalls;
|
|
|
|
static CUtlVector< IDormantOperation * > s_arrDormantInterfaces;
|
|
|
|
XOVERLAPPED * MMX360_NewOverlappedDormant( void (*pfnCompletion)( XOVERLAPPED *, void * ), void *pvParam )
|
|
{
|
|
XOVERLAPPED *pOverlapped = new XOVERLAPPED;
|
|
memset( pOverlapped, 0, sizeof( XOVERLAPPED ) );
|
|
OverlappedDormant_t od = { pOverlapped, pfnCompletion, pvParam };
|
|
s_arrOverlappedDormants.AddToTail( od );
|
|
return pOverlapped;
|
|
}
|
|
|
|
void MMX360_RegisterDormant( IDormantOperation *pDormant )
|
|
{
|
|
if ( !pDormant )
|
|
return;
|
|
|
|
if ( s_arrDormantInterfaces.Find( pDormant ) != s_arrDormantInterfaces.InvalidIndex() )
|
|
return;
|
|
|
|
s_arrDormantInterfaces.AddToTail( pDormant );
|
|
}
|
|
|
|
void MMX360_UpdateDormantOperations()
|
|
{
|
|
int nQueuedOverlapped = s_arrOverlappedDormants.Count();
|
|
for ( int k = 0; k < s_arrOverlappedDormants.Count(); ++ k )
|
|
{
|
|
OverlappedDormant_t od = s_arrOverlappedDormants[k];
|
|
if ( XHasOverlappedIoCompleted( od.m_pOverlapped ) )
|
|
{
|
|
s_arrOverlappedDormants.FastRemove( k -- );
|
|
if ( od.m_pfnCompletion )
|
|
{
|
|
(od.m_pfnCompletion)( od.m_pOverlapped, od.m_pvParam );
|
|
}
|
|
delete od.m_pOverlapped;
|
|
}
|
|
}
|
|
if ( nQueuedOverlapped && !s_arrOverlappedDormants.Count() )
|
|
{
|
|
DevMsg( 2, "MMX360_UpdateDormantOperations finished all overlapped calls.\n" );
|
|
}
|
|
|
|
int nQueuedScheduledCalls = s_arrScheduledCalls.Count();
|
|
for ( int k = 0; k < s_arrScheduledCalls.Count(); ++ k )
|
|
{
|
|
ScheduledCall_t *pCall = s_arrScheduledCalls[k];
|
|
if ( Plat_FloatTime() > pCall->m_flTimeToCall )
|
|
{
|
|
s_arrScheduledCalls.FastRemove( k -- );
|
|
( pCall->m_pfnCall )( pCall );
|
|
}
|
|
}
|
|
if ( nQueuedScheduledCalls && !s_arrScheduledCalls.Count() )
|
|
{
|
|
DevMsg( 2, "MMX360_UpdateDormantOperations finished all scheduled calls.\n" );
|
|
}
|
|
|
|
int nDormantInterfaces = s_arrDormantInterfaces.Count();
|
|
for ( int k = 0; k < s_arrDormantInterfaces.Count(); ++ k )
|
|
{
|
|
IDormantOperation *pDormant = s_arrDormantInterfaces[k];
|
|
bool bKeepRunning = pDormant->UpdateDormantOperation();
|
|
if ( !bKeepRunning )
|
|
s_arrDormantInterfaces.Remove( k -- );
|
|
}
|
|
if ( nDormantInterfaces && !s_arrDormantInterfaces.Count() )
|
|
{
|
|
DevMsg( 2, "MMX360_UpdateDormantOperations finished all dormant interfaces.\n" );
|
|
}
|
|
}
|
|
|
|
int MMX360_GetUserCtrlrIndex( XUID xuid )
|
|
{
|
|
if ( !xuid )
|
|
return -1;
|
|
|
|
for ( int k = 0; k < ( int ) XBX_GetNumGameUsers(); ++ k )
|
|
{
|
|
int iCtrlr = XBX_GetUserId( k );
|
|
XUID xuidLocal = 0;
|
|
if ( ERROR_SUCCESS == XUserGetXUID( iCtrlr, &xuidLocal ) )
|
|
{
|
|
if ( xuidLocal == xuid )
|
|
return iCtrlr;
|
|
}
|
|
XUSER_SIGNIN_INFO xsi;
|
|
if ( ERROR_SUCCESS == XUserGetSigninInfo( iCtrlr, XUSER_GET_SIGNIN_INFO_OFFLINE_XUID_ONLY, &xsi ) )
|
|
{
|
|
if ( xsi.xuid == xuid )
|
|
return iCtrlr;
|
|
}
|
|
if ( ERROR_SUCCESS == XUserGetSigninInfo( iCtrlr, XUSER_GET_SIGNIN_INFO_ONLINE_XUID_ONLY, &xsi ) )
|
|
{
|
|
if ( xsi.xuid == xuid )
|
|
return iCtrlr;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void MMX360_Helper_DataToString( void const *pvData, int numBytes, char *pchBuffer )
|
|
{
|
|
for ( const unsigned char *pb = ( const unsigned char * ) pvData, *pbEnd = pb + numBytes;
|
|
pb < pbEnd; ++ pb )
|
|
{
|
|
*( pchBuffer ++ ) = '0' + ( unsigned char )( pb[0] & 0x0Fu );
|
|
*( pchBuffer ++ ) = '0' + ( unsigned char )( ( pb[0] >> 4 ) & 0x0Fu );
|
|
}
|
|
*pchBuffer = 0;
|
|
}
|
|
|
|
void MMX360_Helper_DataFromString( void *pvData, int numBytes, char const *pchBuffer )
|
|
{
|
|
if ( !pchBuffer )
|
|
goto parse_error;
|
|
|
|
for ( unsigned char *pb = ( unsigned char * ) pvData, *pbEnd = pb + numBytes;
|
|
pb < pbEnd; ++ pb )
|
|
{
|
|
if ( !pchBuffer[0] || !pchBuffer[1] )
|
|
goto parse_error;
|
|
|
|
pb[0] = ( unsigned char )( ( pchBuffer[0] - '0' ) & 0x0Fu ) |
|
|
( unsigned char )( ( ( pchBuffer[1] - '0' ) & 0x0Fu ) << 4 );
|
|
|
|
pchBuffer += 2;
|
|
}
|
|
return;
|
|
|
|
parse_error:
|
|
memset( pvData, 0, numBytes );
|
|
}
|
|
|
|
void MMX360_SessionInfoToString( XSESSION_INFO const &xsi, char *pchBuffer )
|
|
{
|
|
MMX360_Helper_DataToString( &xsi, sizeof( xsi ), pchBuffer );
|
|
}
|
|
|
|
void MMX360_SessionInfoFromString( XSESSION_INFO &xsi, char const *pchBuffer )
|
|
{
|
|
MMX360_Helper_DataFromString( &xsi, sizeof( xsi ), pchBuffer );
|
|
}
|
|
|
|
void MMX360_XnaddrToString( XNADDR const &xsi, char *pchBuffer )
|
|
{
|
|
MMX360_Helper_DataToString( &xsi, sizeof( xsi ), pchBuffer );
|
|
}
|
|
|
|
void MMX360_XnaddrFromString( XNADDR &xsi, char const *pchBuffer )
|
|
{
|
|
MMX360_Helper_DataFromString( &xsi, sizeof( xsi ), pchBuffer );
|
|
}
|
|
|
|
//
|
|
// Active gameplay sessions stack
|
|
//
|
|
// Only one session can be considered active gameplay session
|
|
// and we will consider the last session that received XSessionStart
|
|
//
|
|
struct CX360ActiveGameplaySession_t
|
|
{
|
|
CX360ActiveGameplaySession_t( HANDLE hHandle )
|
|
{
|
|
m_hHandle = hHandle;
|
|
m_flLastFlushTime = Plat_FloatTime();
|
|
m_bNeedsFlush = false;
|
|
}
|
|
|
|
HANDLE m_hHandle;
|
|
float m_flLastFlushTime;
|
|
bool m_bNeedsFlush;
|
|
};
|
|
static CUtlVector< CX360ActiveGameplaySession_t > s_arrActiveGameplaySessions;
|
|
|
|
CX360ActiveGameplaySession_t * MMX360_GetActiveGameplaySession()
|
|
{
|
|
return s_arrActiveGameplaySessions.Count() ? &s_arrActiveGameplaySessions.Tail() : NULL;
|
|
}
|
|
|
|
|
|
//
|
|
// Session stats flush scheduled call
|
|
//
|
|
|
|
struct ScheduledCall_FlushSessionStats : public ScheduledCall_t
|
|
{
|
|
ScheduledCall_FlushSessionStats()
|
|
{
|
|
m_flTimeToCall = Plat_FloatTime() + 0.1f;
|
|
m_pfnCall = Callback;
|
|
}
|
|
|
|
protected:
|
|
void Run()
|
|
{
|
|
// Walk all the scheduled sessions and XSessionFlushStats them if needed
|
|
for ( int k = 0; k < s_arrActiveGameplaySessions.Count(); ++ k )
|
|
{
|
|
CX360ActiveGameplaySession_t &ags = s_arrActiveGameplaySessions[k];
|
|
if ( !ags.m_bNeedsFlush )
|
|
continue;
|
|
|
|
if ( Plat_FloatTime() < ags.m_flLastFlushTime + 6*60 )
|
|
// TCR: cannot flush within 5 minutes of last flush (use 6 minutes just in case)
|
|
continue;
|
|
|
|
// Schedule an overlapped flush
|
|
ags.m_flLastFlushTime = Plat_FloatTime();
|
|
ags.m_bNeedsFlush = false;
|
|
|
|
DevMsg( "ScheduledCall_FlushSessionStats for session %p (@%.2f)\n", ags.m_hHandle, ags.m_flLastFlushTime );
|
|
g_pMatchExtensions->GetIXOnline()->XSessionFlushStats( ags.m_hHandle, MMX360_NewOverlappedDormant() );
|
|
}
|
|
delete this;
|
|
}
|
|
static void Callback( ScheduledCall_t *pThis )
|
|
{
|
|
( ( ScheduledCall_FlushSessionStats * )( pThis ) )->Run();
|
|
}
|
|
};
|
|
|
|
//
|
|
// Leaderboard async requests implementation
|
|
//
|
|
|
|
class CLeaderboardX360_Writer : public IX360LeaderboardBatchWriter
|
|
{
|
|
public:
|
|
explicit CLeaderboardX360_Writer( XUID xuidGamer );
|
|
|
|
public:
|
|
virtual void AddProperty( int dwViewId, XUSER_PROPERTY const &xp );
|
|
virtual void WriteBatchAndDestroy();
|
|
|
|
protected:
|
|
bool WriteBatch();
|
|
void Destroy();
|
|
|
|
static void OnXSessionWriteStatsCompleted( XOVERLAPPED *, void *pvThis )
|
|
{
|
|
( ( CLeaderboardX360_Writer * )pvThis )->Destroy();
|
|
}
|
|
|
|
public:
|
|
CUtlVector< XSESSION_VIEW_PROPERTIES > m_arrLbViews;
|
|
CUtlVectorFixed< XUSER_PROPERTY, 64 > m_arrLbProperties;
|
|
HANDLE m_hSession;
|
|
XUID m_xuidGamer;
|
|
};
|
|
|
|
IX360LeaderboardBatchWriter * MMX360_CreateLeaderboardBatchWriter( XUID xuidGamer )
|
|
{
|
|
if ( !MMX360_GetActiveGameplaySession() )
|
|
{
|
|
Warning( "MMX360_CreateLeaderboardBatchWriter called with no active gameplay session!\n" );
|
|
Assert( 0 );
|
|
return NULL;
|
|
}
|
|
|
|
return new CLeaderboardX360_Writer( xuidGamer );
|
|
}
|
|
|
|
CLeaderboardX360_Writer::CLeaderboardX360_Writer( XUID xuidGamer )
|
|
{
|
|
CX360ActiveGameplaySession_t *ags = MMX360_GetActiveGameplaySession();
|
|
m_hSession = ags ? ags->m_hHandle : NULL;
|
|
m_xuidGamer = xuidGamer;
|
|
}
|
|
|
|
void CLeaderboardX360_Writer::AddProperty( int dwViewId, XUSER_PROPERTY const &xp )
|
|
{
|
|
if ( m_arrLbProperties.Count() >= 63 )
|
|
{
|
|
Warning( "CLeaderboardX360_Writer: exceeded number of properties for update!\n" );
|
|
return;
|
|
}
|
|
|
|
m_arrLbProperties.AddMultipleToTail( 1, &xp );
|
|
XUSER_PROPERTY *xProp = &m_arrLbProperties.Tail();
|
|
|
|
if ( !m_arrLbViews.Count() || m_arrLbViews.Tail().dwViewId != ( DWORD ) dwViewId )
|
|
{
|
|
m_arrLbViews.AddMultipleToTail( 1 );
|
|
|
|
XSESSION_VIEW_PROPERTIES *xView = &m_arrLbViews.Tail();
|
|
xView->dwViewId = dwViewId;
|
|
xView->dwNumProperties = 0;
|
|
xView->pProperties = xProp;
|
|
}
|
|
|
|
++ m_arrLbViews.Tail().dwNumProperties;
|
|
}
|
|
|
|
bool CLeaderboardX360_Writer::WriteBatch()
|
|
{
|
|
if ( !m_arrLbViews.Count() )
|
|
return false;
|
|
|
|
CX360ActiveGameplaySession_t &ags = *MMX360_GetActiveGameplaySession();
|
|
if ( !&ags || !ags.m_hHandle )
|
|
{
|
|
Warning( "CLeaderboardX360_Writer::WriteBatch called without active gameplay session!\n" );
|
|
Assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
if ( ags.m_hHandle != m_hSession )
|
|
{
|
|
Warning( "CLeaderboardX360_Writer::WriteBatch called when active gameplay session changed!\n" );
|
|
Assert( 0 );
|
|
return false;
|
|
}
|
|
|
|
DWORD ret = g_pMatchExtensions->GetIXOnline()->XSessionWriteStats( ags.m_hHandle,
|
|
m_xuidGamer, m_arrLbViews.Count(), m_arrLbViews.Base(),
|
|
MMX360_NewOverlappedDormant( OnXSessionWriteStatsCompleted, this ) );
|
|
if ( ret != ERROR_SUCCESS && ret != ERROR_IO_PENDING )
|
|
{
|
|
Warning( "XSessionWriteStats failed, code %d, xuid=%llx, numViews=%d, numProps=%d\n",
|
|
ret, m_xuidGamer, m_arrLbViews.Count(), m_arrLbProperties.Count() );
|
|
return false;
|
|
}
|
|
|
|
// Mark the session as needing a flush when the TCR allows us to flush session stats
|
|
ags.m_bNeedsFlush = true;
|
|
DevMsg( "XSessionWriteStats for session %p (%.2f, last flush @%.2f)\n", ags.m_hHandle, Plat_FloatTime(), ags.m_flLastFlushTime );
|
|
return true;
|
|
}
|
|
|
|
void CLeaderboardX360_Writer::Destroy()
|
|
{
|
|
m_hSession = NULL;
|
|
delete this;
|
|
|
|
// Submit a scheduled call to flush session stats for all previously written stats that might need a flush
|
|
DevMsg( "ScheduledCall_FlushSessionStats @%.2f\n", Plat_FloatTime() );
|
|
s_arrScheduledCalls.AddToTail( new ScheduledCall_FlushSessionStats );
|
|
}
|
|
|
|
void CLeaderboardX360_Writer::WriteBatchAndDestroy()
|
|
{
|
|
if ( !WriteBatch() )
|
|
Destroy();
|
|
}
|
|
|
|
|
|
//
|
|
// Basic async operation on a lobby
|
|
//
|
|
|
|
class CX360LobbyAsyncOperation : public IX360LobbyAsyncOperation, public IDormantOperation
|
|
{
|
|
public:
|
|
CX360LobbyAsyncOperation() : m_eState( AOS_RUNNING ), m_result( 0 ), m_pCancelOverlappedJob( NULL )
|
|
{
|
|
memset( &m_xOverlapped, 0, sizeof( m_xOverlapped ) );
|
|
}
|
|
|
|
virtual ~CX360LobbyAsyncOperation()
|
|
{
|
|
;
|
|
}
|
|
|
|
//
|
|
// IMatchAsyncOperation
|
|
//
|
|
public:
|
|
// Poll if operation has completed
|
|
virtual bool IsFinished() { return m_eState >= AOS_ABORTED; }
|
|
|
|
// Operation state
|
|
virtual AsyncOperationState_t GetState() { return m_eState; }
|
|
|
|
// Retrieve a generic completion result for simple operations
|
|
// that return simple results upon success,
|
|
// results are operation-specific, may result in undefined behavior
|
|
// if operation is still in progress.
|
|
virtual uint64 GetResult() { return m_result; }
|
|
|
|
// Request operation to be aborted
|
|
virtual void Abort();
|
|
|
|
// Release the operation interface and all resources
|
|
// associated with the operation. Operation callbacks
|
|
// will not be called after Release. Operation object
|
|
// cannot be accessed after Release.
|
|
virtual void Release();
|
|
|
|
//
|
|
// Overrides
|
|
//
|
|
public:
|
|
virtual CX360LobbyObject const & GetLobby() { return m_lobby; }
|
|
virtual void Update();
|
|
virtual void OnFinished( DWORD dwRetCode, DWORD dwResult );
|
|
|
|
virtual bool UpdateDormantOperation();
|
|
|
|
public:
|
|
AsyncOperationState_t m_eState;
|
|
XOVERLAPPED m_xOverlapped;
|
|
uint64 m_result;
|
|
CX360LobbyObject m_lobby;
|
|
CJob *m_pCancelOverlappedJob;
|
|
};
|
|
|
|
void CX360LobbyAsyncOperation::Abort()
|
|
{
|
|
Update();
|
|
if ( m_eState != AOS_RUNNING )
|
|
return;
|
|
|
|
m_eState = AOS_ABORTING;
|
|
|
|
m_pCancelOverlappedJob = ThreadExecute( MMX360_CancelOverlapped, &m_xOverlapped );
|
|
m_eState = AOS_ABORTED;
|
|
}
|
|
|
|
void CX360LobbyAsyncOperation::Release()
|
|
{
|
|
if ( !IsFinished() )
|
|
{
|
|
Abort();
|
|
}
|
|
|
|
if ( m_pCancelOverlappedJob )
|
|
MMX360_RegisterDormant( this );
|
|
else
|
|
delete this;
|
|
}
|
|
|
|
void CX360LobbyAsyncOperation::Update()
|
|
{
|
|
if ( IsFinished() )
|
|
return;
|
|
|
|
// Check if the operation has completed
|
|
if ( !XHasOverlappedIoCompleted( &m_xOverlapped ) )
|
|
return;
|
|
|
|
DWORD dwResult;
|
|
DWORD dwRetCode = XGetOverlappedResult( &m_xOverlapped, &dwResult, FALSE );
|
|
|
|
m_eState = ( dwRetCode == ERROR_SUCCESS ) ? AOS_SUCCEEDED : AOS_FAILED;
|
|
|
|
OnFinished( dwRetCode, dwResult );
|
|
}
|
|
|
|
bool CX360LobbyAsyncOperation::UpdateDormantOperation()
|
|
{
|
|
if ( !m_pCancelOverlappedJob->IsFinished() )
|
|
return true; // keep running dormant
|
|
|
|
m_pCancelOverlappedJob->Release();
|
|
m_pCancelOverlappedJob = NULL;
|
|
|
|
delete this;
|
|
return false; // destroyed object, remove from dormant list
|
|
}
|
|
|
|
void CX360LobbyAsyncOperation::OnFinished( DWORD dwRetCode, DWORD dwResult )
|
|
{
|
|
m_result = dwResult;
|
|
}
|
|
|
|
class CX360LobbyQosOperation : public CX360LobbyAsyncOperation
|
|
{
|
|
public:
|
|
CX360LobbyQosOperation() : m_pXnQos( NULL ) {}
|
|
|
|
public:
|
|
virtual void Abort();
|
|
virtual void Update();
|
|
|
|
public:
|
|
XNQOS *m_pXnQos;
|
|
};
|
|
|
|
void CX360LobbyQosOperation::Abort()
|
|
{
|
|
Update();
|
|
if ( m_eState != AOS_RUNNING )
|
|
return;
|
|
|
|
g_pMatchExtensions->GetIXOnline()->XNetQosRelease( m_pXnQos );
|
|
m_pXnQos = NULL;
|
|
m_eState = AOS_ABORTED;
|
|
}
|
|
|
|
void CX360LobbyQosOperation::Update()
|
|
{
|
|
if ( IsFinished() )
|
|
return;
|
|
|
|
// Check if the QOS is not running
|
|
if ( !m_pXnQos )
|
|
{
|
|
m_eState = AOS_FAILED;
|
|
OnFinished( ERROR_SUCCESS, ERROR_SUCCESS );
|
|
return;
|
|
}
|
|
|
|
// Check if still pending
|
|
if ( m_pXnQos->cxnqosPending > 0 )
|
|
return;
|
|
|
|
bool bSuccess = true;
|
|
BYTE uNeedFlags = XNET_XNQOSINFO_TARGET_CONTACTED | XNET_XNQOSINFO_DATA_RECEIVED;
|
|
for ( uint k = 0; k < m_pXnQos->cxnqos; ++ k )
|
|
{
|
|
XNQOSINFO &xqi = m_pXnQos->axnqosinfo[k];
|
|
if ( ( ( xqi.bFlags & uNeedFlags ) != uNeedFlags) ||
|
|
( xqi.bFlags & XNET_XNQOSINFO_TARGET_DISABLED ) ||
|
|
!xqi.cbData || !xqi.pbData )
|
|
{
|
|
bSuccess = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
m_eState = ( bSuccess ) ? AOS_SUCCEEDED : AOS_FAILED;
|
|
DWORD dwCode = ( bSuccess ) ? ERROR_SUCCESS : ERROR_FILE_NOT_FOUND;
|
|
|
|
OnFinished( dwCode, dwCode );
|
|
|
|
// Release the QOS
|
|
g_pMatchExtensions->GetIXOnline()->XNetQosRelease( m_pXnQos );
|
|
m_pXnQos = NULL;
|
|
}
|
|
|
|
template < typename TBase = CX360LobbyAsyncOperation >
|
|
class CX360AsyncOperationDelegating : public TBase
|
|
{
|
|
public:
|
|
typedef CX360AsyncOperationDelegating<TBase> TX360AsyncOperationDelegating;
|
|
typedef TBase TX360AsyncOperationDelegatingBase;
|
|
|
|
public:
|
|
CX360AsyncOperationDelegating() : m_pDelegate( NULL )
|
|
{
|
|
}
|
|
|
|
//
|
|
// IMatchAsyncOperation
|
|
//
|
|
public:
|
|
// Poll if operation has completed
|
|
virtual bool IsFinished() { return m_pDelegate ? m_pDelegate->IsFinished() : TBase::IsFinished(); }
|
|
|
|
// Operation state
|
|
virtual AsyncOperationState_t GetState() { return m_pDelegate ? m_pDelegate->GetState() : TBase::GetState(); }
|
|
|
|
// Retrieve a generic completion result for simple operations
|
|
// that return simple results upon success,
|
|
// results are operation-specific, may result in undefined behavior
|
|
// if operation is still in progress.
|
|
virtual uint64 GetResult() { return m_pDelegate ? m_pDelegate->GetResult() : TBase::GetResult(); }
|
|
|
|
// Request operation to be aborted
|
|
virtual void Abort()
|
|
{
|
|
if ( m_pDelegate )
|
|
m_pDelegate->Abort();
|
|
else
|
|
TBase::Abort();
|
|
}
|
|
|
|
// Release the operation interface and all resources
|
|
// associated with the operation. Operation callbacks
|
|
// will not be called after Release. Operation object
|
|
// cannot be accessed after Release.
|
|
virtual void Release()
|
|
{
|
|
if ( m_pDelegate )
|
|
m_pDelegate->Release();
|
|
m_pDelegate = NULL;
|
|
TBase::Release();
|
|
}
|
|
|
|
//
|
|
// Overrides
|
|
//
|
|
public:
|
|
virtual CX360LobbyObject const & GetLobby()
|
|
{
|
|
if ( m_pDelegate )
|
|
return m_pDelegate->GetLobby();
|
|
else
|
|
return TBase::GetLobby();
|
|
}
|
|
virtual void Update()
|
|
{
|
|
if ( m_pDelegate )
|
|
m_pDelegate->Update();
|
|
else
|
|
TBase::Update();
|
|
}
|
|
|
|
public:
|
|
IX360LobbyAsyncOperation *m_pDelegate;
|
|
};
|
|
|
|
|
|
//
|
|
// Deleting a lobby
|
|
//
|
|
|
|
class CX360LobbyAsyncOperation_LobbyDelete : public CX360LobbyAsyncOperation
|
|
{
|
|
public:
|
|
explicit CX360LobbyAsyncOperation_LobbyDelete( CX360LobbyObject &lobby )
|
|
{
|
|
m_lobby = lobby;
|
|
|
|
// Submit XSessionDelete
|
|
DWORD ret = g_pMatchExtensions->GetIXOnline()->XSessionDelete( m_lobby.m_hHandle, &m_xOverlapped );
|
|
|
|
if ( ret != ERROR_IO_PENDING )
|
|
{
|
|
DevWarning( "XSessionDelete failed (code 0x%08X)\n", ret );
|
|
Assert( 0 );
|
|
|
|
m_eState = AOS_FAILED;
|
|
m_result = ret;
|
|
}
|
|
}
|
|
|
|
virtual void Abort()
|
|
{
|
|
DevWarning( "XSessionDelete cannot be aborted!\n" );
|
|
Assert( 0 );
|
|
}
|
|
|
|
virtual void OnFinished( DWORD dwRetCode, DWORD dwResult )
|
|
{
|
|
CX360LobbyAsyncOperation::OnFinished( dwRetCode, dwResult );
|
|
CloseHandle( m_lobby.m_hHandle );
|
|
}
|
|
};
|
|
|
|
void MMX360_LobbyDelete( CX360LobbyObject &lobby, IX360LobbyAsyncOperation **ppOperation )
|
|
{
|
|
Assert( lobby.m_hHandle );
|
|
Assert( ppOperation );
|
|
|
|
if ( ppOperation )
|
|
*ppOperation = NULL;
|
|
else
|
|
return;
|
|
|
|
// Release QOS listener
|
|
g_pMatchExtensions->GetIXOnline()->XNetQosListen( &lobby.m_xiInfo.sessionID, 0, 0, 0, XNET_QOS_LISTEN_RELEASE );
|
|
|
|
if ( lobby.m_bXSessionStarted )
|
|
{
|
|
DevWarning( "LobbyDelete called on an active gameplay session, forcing XSessionEnd!\n" );
|
|
// TODO: investigate whether this is not resulting in any side-effects in arbitrated ranked games
|
|
// especially when the host leaves the game.
|
|
MMX360_LobbySetActiveGameplayState( lobby, false, NULL );
|
|
}
|
|
|
|
*ppOperation = new CX360LobbyAsyncOperation_LobbyDelete( lobby );
|
|
lobby = CX360LobbyObject();
|
|
}
|
|
|
|
|
|
//
|
|
// Describing lobby flags
|
|
//
|
|
|
|
CX360LobbyFlags_t MMX360_DescribeLobbyFlags( KeyValues *pSettings, bool bHost, bool bWantLocked )
|
|
{
|
|
CX360LobbyFlags_t fl = {0};
|
|
|
|
char const *szLock = pSettings->GetString( "system/lock", NULL );
|
|
char const *szNetwork = pSettings->GetString( "system/network", "LIVE" );
|
|
char const *szAccess = pSettings->GetString( "system/access", "public" );
|
|
char const *szNetFlag = pSettings->GetString( "system/netflag", NULL );
|
|
int numSlots = pSettings->GetInt( "members/numSlots", XBX_GetNumGameUsers() );
|
|
|
|
// Gametype
|
|
fl.m_dwGameType = X_CONTEXT_GAME_TYPE_STANDARD;
|
|
|
|
// Flags
|
|
if ( !Q_stricmp( szNetwork, "LIVE" ) )
|
|
{
|
|
fl.m_dwFlags = XSESSION_CREATE_LIVE_MULTIPLAYER_STANDARD;
|
|
|
|
if ( szNetFlag )
|
|
{
|
|
if ( !Q_stricmp( szNetFlag, "teamlobby" ) )
|
|
{
|
|
fl.m_dwFlags = XSESSION_CREATE_USES_PRESENCE | XSESSION_CREATE_USES_PEER_NETWORK;
|
|
}
|
|
else if ( !Q_stricmp( szNetFlag, "teamlink" ) )
|
|
{
|
|
fl.m_dwFlags = /*XSESSION_CREATE_USES_STATS |*/ XSESSION_CREATE_USES_MATCHMAKING | XSESSION_CREATE_USES_PEER_NETWORK;
|
|
}
|
|
}
|
|
}
|
|
else if ( !Q_stricmp( szNetwork, "lan" ) )
|
|
{
|
|
fl.m_dwFlags = XSESSION_CREATE_SYSTEMLINK;
|
|
}
|
|
else
|
|
{
|
|
fl.m_dwFlags = XSESSION_CREATE_SINGLEPLAYER_WITH_STATS;
|
|
}
|
|
|
|
// Whether session can be disabled in XUI
|
|
fl.m_bCanLockJoins = ( ( fl.m_dwFlags & XSESSION_CREATE_USES_PRESENCE ) == XSESSION_CREATE_USES_PRESENCE );
|
|
|
|
// Hosting
|
|
if ( bHost )
|
|
{
|
|
fl.m_dwFlags |= XSESSION_CREATE_HOST;
|
|
}
|
|
|
|
bool bPublic = true;
|
|
if ( fl.m_bCanLockJoins )
|
|
{
|
|
if ( bWantLocked || ( szLock && *szLock && !IsX360() ) )
|
|
{
|
|
bPublic = false;
|
|
fl.m_dwFlags |= ( XSESSION_CREATE_INVITES_DISABLED | XSESSION_CREATE_JOIN_VIA_PRESENCE_DISABLED | XSESSION_CREATE_JOIN_IN_PROGRESS_DISABLED );
|
|
}
|
|
else if ( !Q_stricmp( "private", szAccess ) )
|
|
{
|
|
bPublic = false;
|
|
fl.m_dwFlags |= XSESSION_CREATE_JOIN_VIA_PRESENCE_DISABLED;
|
|
}
|
|
else if ( !Q_stricmp( "friends", szAccess ) )
|
|
{
|
|
fl.m_dwFlags |= XSESSION_CREATE_JOIN_VIA_PRESENCE_FRIENDS_ONLY;
|
|
}
|
|
}
|
|
|
|
fl.m_numPublicSlots = bPublic ? numSlots : 0;
|
|
fl.m_numPrivateSlots = bPublic ? 0 : numSlots;
|
|
|
|
return fl;
|
|
}
|
|
|
|
|
|
//
|
|
// Lobby creation
|
|
//
|
|
|
|
class CX360LobbyAsyncOperation_LobbyCreate : public CX360LobbyAsyncOperation
|
|
{
|
|
public:
|
|
explicit CX360LobbyAsyncOperation_LobbyCreate( CX360LobbyFlags_t const &fl )
|
|
{
|
|
// Set the required contexts
|
|
for ( int k = 0; k < ( int ) XBX_GetNumGameUsers(); ++ k )
|
|
{
|
|
int iCtrlr = XBX_GetUserId( k );
|
|
XUserSetContext( iCtrlr, X_CONTEXT_GAME_TYPE, fl.m_dwGameType );
|
|
}
|
|
|
|
// Submit XSessionCreate
|
|
DWORD ret = g_pMatchExtensions->GetIXOnline()->XSessionCreate( fl.m_dwFlags, XBX_GetPrimaryUserId(), fl.m_numPublicSlots, fl.m_numPrivateSlots,
|
|
&m_lobby.m_uiNonce, &m_lobby.m_xiInfo, &m_xOverlapped, &m_lobby.m_hHandle );
|
|
|
|
if ( ret != ERROR_IO_PENDING )
|
|
{
|
|
DevWarning( "XSessionCreate failed (code 0x%08X)\n", ret );
|
|
Assert( 0 );
|
|
|
|
m_eState = AOS_FAILED;
|
|
m_result = ret;
|
|
}
|
|
}
|
|
|
|
virtual void OnFinished( DWORD dwRetCode, DWORD dwResult )
|
|
{
|
|
CX360LobbyAsyncOperation::OnFinished( dwRetCode, dwResult );
|
|
if ( GetState() == AOS_SUCCEEDED )
|
|
{
|
|
// Enable QOS listener when session creation succeeds
|
|
g_pMatchExtensions->GetIXOnline()->XNetQosListen( &m_lobby.m_xiInfo.sessionID, 0, 0, 0, XNET_QOS_LISTEN_ENABLE );
|
|
}
|
|
}
|
|
};
|
|
|
|
void MMX360_LobbyCreate( KeyValues *pSettings, IX360LobbyAsyncOperation **ppOperation )
|
|
{
|
|
Assert( pSettings );
|
|
Assert( ppOperation );
|
|
|
|
if ( ppOperation )
|
|
*ppOperation = NULL;
|
|
else
|
|
return;
|
|
|
|
if ( !pSettings )
|
|
return;
|
|
|
|
// Determine parameters
|
|
CX360LobbyFlags_t fl = MMX360_DescribeLobbyFlags( pSettings, true, true );
|
|
if ( KeyValues *pKv = g_pMMF->GetMatchTitleGameSettingsMgr()->PrepareForSessionCreate( pSettings ) )
|
|
{
|
|
pKv->deleteThis();
|
|
}
|
|
|
|
// Allocate our lobby object
|
|
*ppOperation = new CX360LobbyAsyncOperation_LobbyCreate( fl );
|
|
}
|
|
|
|
|
|
//
|
|
// Lobby connect operation
|
|
//
|
|
|
|
class CX360LobbyAsyncOperation_LobbyConnect : public CX360LobbyAsyncOperation
|
|
{
|
|
public:
|
|
explicit CX360LobbyAsyncOperation_LobbyConnect( KeyValues *pHostSettings, XSESSION_INFO const &xsi )
|
|
{
|
|
m_lobby.m_xiInfo = xsi;
|
|
|
|
// Prepare for lobby create
|
|
CX360LobbyFlags_t fl = MMX360_DescribeLobbyFlags( pHostSettings, false, true );
|
|
if ( KeyValues *pKv = g_pMMF->GetMatchTitleGameSettingsMgr()->PrepareForSessionCreate( pHostSettings ) )
|
|
{
|
|
pKv->deleteThis();
|
|
}
|
|
|
|
// Set the required contexts
|
|
for ( int k = 0; k < ( int ) XBX_GetNumGameUsers(); ++ k )
|
|
{
|
|
int iCtrlr = XBX_GetUserId( k );
|
|
XUserSetContext( iCtrlr, X_CONTEXT_GAME_TYPE, fl.m_dwGameType );
|
|
}
|
|
|
|
// Submit XSessionCreate
|
|
DWORD ret = g_pMatchExtensions->GetIXOnline()->XSessionCreate( fl.m_dwFlags, XBX_GetPrimaryUserId(), fl.m_numPublicSlots, fl.m_numPrivateSlots,
|
|
&m_lobby.m_uiNonce, &m_lobby.m_xiInfo, &m_xOverlapped, &m_lobby.m_hHandle );
|
|
|
|
if ( ret != ERROR_IO_PENDING )
|
|
{
|
|
DevWarning( "XSessionCreate failed (code 0x%08X)\n", ret );
|
|
Assert( 0 );
|
|
|
|
m_eState = AOS_FAILED;
|
|
m_result = ret;
|
|
}
|
|
}
|
|
};
|
|
|
|
class CX360LobbyAsyncOperation_LobbyQosAndConnect : public CX360AsyncOperationDelegating< CX360LobbyQosOperation >
|
|
{
|
|
public:
|
|
explicit CX360LobbyAsyncOperation_LobbyQosAndConnect( XSESSION_INFO const &xsi ) :
|
|
m_xsiQosInfo( xsi )
|
|
{
|
|
// Perform the QOS lookup
|
|
m_pXnaddr = &m_xsiQosInfo.hostAddress;
|
|
m_pXnkid = &m_xsiQosInfo.sessionID;
|
|
m_pXnkey = &m_xsiQosInfo.keyExchangeKey;
|
|
INT ret = g_pMatchExtensions->GetIXOnline()->XNetQosLookup( 1, &m_pXnaddr, &m_pXnkid, &m_pXnkey,
|
|
0, NULL, NULL, 2, 0, 0, NULL,
|
|
&m_pXnQos );
|
|
|
|
if ( 0 != ret )
|
|
{
|
|
DevWarning( "XNetQosLookup failed (code 0x%08X)\n", ret );
|
|
Assert( 0 );
|
|
|
|
m_eState = AOS_FAILED;
|
|
m_result = ERROR_NO_SUCH_PRIVILEGE;
|
|
return;
|
|
}
|
|
}
|
|
|
|
public:
|
|
virtual void OnFinished( DWORD dwRetCode, DWORD dwResult )
|
|
{
|
|
TX360AsyncOperationDelegating::OnFinished( dwRetCode, dwResult );
|
|
if ( m_eState == AOS_SUCCEEDED && !m_pDelegate )
|
|
{
|
|
// We successfully contacted the QOS host and obtained the data
|
|
XNQOSINFO &xqi = m_pXnQos->axnqosinfo[0];
|
|
|
|
MM_GameDetails_QOS_t gd = { xqi.pbData, xqi.cbData, xqi.wRttMedInMsecs };
|
|
KeyValues *pHostGameDetails = g_pMatchFramework->GetMatchNetworkMsgController()->UnpackGameDetailsFromQOS( &gd );
|
|
KeyValues::AutoDelete autodelete_pHostGameDetails( pHostGameDetails );
|
|
|
|
// Output unpacked game details from host
|
|
KeyValuesDumpAsDevMsg( pHostGameDetails, 1, 2 );
|
|
|
|
m_pDelegate = new CX360LobbyAsyncOperation_LobbyConnect( pHostGameDetails, m_xsiQosInfo );
|
|
return;
|
|
}
|
|
|
|
Assert( !m_pDelegate );
|
|
m_eState = AOS_FAILED;
|
|
}
|
|
|
|
protected:
|
|
XSESSION_INFO m_xsiQosInfo;
|
|
XNADDR const *m_pXnaddr;
|
|
XNKID const *m_pXnkid;
|
|
XNKEY const *m_pXnkey;
|
|
};
|
|
|
|
class CX360LobbyAsyncOperation_LobbyDiscoverAndQosAndConnect : public CX360AsyncOperationDelegating< CX360LobbyAsyncOperation >
|
|
{
|
|
public:
|
|
explicit CX360LobbyAsyncOperation_LobbyDiscoverAndQosAndConnect( uint64 const &uiSessionId )
|
|
{
|
|
XNKID xnkid = ( XNKID const & ) uiSessionId;
|
|
int iCtrlr = XBX_GetPrimaryUserId();
|
|
|
|
DWORD dwSize = 0;
|
|
DWORD ret = g_pMatchExtensions->GetIXOnline()->XSessionSearchByID( xnkid, iCtrlr, &dwSize, NULL, NULL );
|
|
if( ret != ERROR_INSUFFICIENT_BUFFER )
|
|
{
|
|
DevWarning( "XSessionSearchByID failed to determine size (code 0x%08X)\n", ret );
|
|
Assert( 0 );
|
|
|
|
m_eState = AOS_FAILED;
|
|
m_result = ret;
|
|
return;
|
|
}
|
|
|
|
// Allocate buffer
|
|
m_bufSearchResultHeader.EnsureCapacity( dwSize );
|
|
ZeroMemory( m_bufSearchResultHeader.Base(), dwSize );
|
|
|
|
ret = g_pMatchExtensions->GetIXOnline()->XSessionSearchByID( xnkid, iCtrlr, &dwSize,
|
|
(XSESSION_SEARCHRESULT_HEADER *) m_bufSearchResultHeader.Base(),
|
|
&m_xOverlapped );
|
|
if( ret != ERROR_IO_PENDING )
|
|
{
|
|
DevWarning( "XSessionSearchByID failed to initiate search (code 0x%08X)\n", ret );
|
|
Assert( 0 );
|
|
|
|
m_eState = AOS_FAILED;
|
|
m_result = ret;
|
|
return;
|
|
}
|
|
}
|
|
|
|
public:
|
|
virtual void OnFinished( DWORD dwRetCode, DWORD dwResult )
|
|
{
|
|
TX360AsyncOperationDelegating::OnFinished( dwRetCode, dwResult );
|
|
if ( m_eState == AOS_SUCCEEDED && !m_pDelegate )
|
|
{
|
|
// We successfully resolved our XNKID
|
|
XSESSION_SEARCHRESULT_HEADER *xsh = ( XSESSION_SEARCHRESULT_HEADER * ) m_bufSearchResultHeader.Base();
|
|
|
|
if( xsh->dwSearchResults >= 1)
|
|
{
|
|
m_lobby.m_xiInfo = xsh->pResults[0].info;
|
|
m_pDelegate = new CX360LobbyAsyncOperation_LobbyQosAndConnect( m_lobby.m_xiInfo );
|
|
return;
|
|
}
|
|
}
|
|
|
|
Assert( !m_pDelegate );
|
|
m_eState = AOS_FAILED;
|
|
}
|
|
|
|
protected:
|
|
CUtlBuffer m_bufSearchResultHeader;
|
|
};
|
|
|
|
void MMX360_LobbyConnect( KeyValues *pSettings, IX360LobbyAsyncOperation **ppOperation )
|
|
{
|
|
Assert( pSettings );
|
|
Assert( ppOperation );
|
|
|
|
if ( ppOperation )
|
|
*ppOperation = NULL;
|
|
else
|
|
return;
|
|
|
|
if ( !pSettings )
|
|
return;
|
|
|
|
// Parse the information from the settings
|
|
uint64 uiSessionID = pSettings->GetUint64( "options/sessionid", 0ull );
|
|
char const *szSessionInfo = pSettings->GetString( "options/sessioninfo", NULL );
|
|
KeyValues *pSessionHostData = ( KeyValues * ) pSettings->GetPtr( "options/sessionHostData", NULL );
|
|
|
|
// Handle the case when we have session info and it is up to date
|
|
XSESSION_INFO xsi = {0};
|
|
if ( szSessionInfo )
|
|
MMX360_SessionInfoFromString( xsi, szSessionInfo );
|
|
|
|
if ( ( const uint64 & ) xsi.sessionID != ( const uint64 & ) uiSessionID )
|
|
{
|
|
// Need to discover session info first
|
|
*ppOperation = new CX360LobbyAsyncOperation_LobbyDiscoverAndQosAndConnect( uiSessionID );
|
|
return;
|
|
}
|
|
|
|
if ( !pSessionHostData && !Q_stricmp( "LIVE", pSettings->GetString( "system/network" ) ) )
|
|
{
|
|
// QOS and connect using the host-supplied information
|
|
*ppOperation = new CX360LobbyAsyncOperation_LobbyQosAndConnect( xsi );
|
|
return;
|
|
}
|
|
|
|
// Otherwise use the client-settings hoping that they match the host-settings
|
|
if ( !pSessionHostData )
|
|
pSessionHostData = pSettings;
|
|
|
|
// Connect immediately with session information that we have
|
|
*ppOperation = new CX360LobbyAsyncOperation_LobbyConnect( pSessionHostData, xsi );
|
|
}
|
|
|
|
//
|
|
// Host migration implementation
|
|
//
|
|
|
|
struct CX360LobbyMigrateHandleImpl
|
|
{
|
|
CX360LobbyMigrateOperation_t *m_pListener;
|
|
XSESSION_INFO m_xsi;
|
|
|
|
static void Finished( XOVERLAPPED *pxOverlapped, void *pvThis )
|
|
{
|
|
CX360LobbyMigrateHandleImpl *pHandle = ( CX360LobbyMigrateHandleImpl * ) pvThis;
|
|
if ( pHandle->m_pListener )
|
|
{
|
|
XGetOverlappedResult( pxOverlapped, &pHandle->m_pListener->m_ret, FALSE );
|
|
pHandle->m_pListener->m_pLobby->m_xiInfo = pHandle->m_xsi;
|
|
pHandle->m_pListener->m_bFinished = true;
|
|
}
|
|
delete pHandle;
|
|
}
|
|
};
|
|
|
|
CX360LobbyMigrateHandle_t MMX360_LobbyMigrateHost( CX360LobbyObject &lobby, CX360LobbyMigrateOperation_t *pOperation )
|
|
{
|
|
if ( !XNetXnKidIsSystemLink( &lobby.m_xiInfo.sessionID ) )
|
|
{
|
|
CX360LobbyMigrateHandleImpl *pHandleImpl = new CX360LobbyMigrateHandleImpl;
|
|
pHandleImpl->m_pListener = pOperation;
|
|
pHandleImpl->m_xsi = lobby.m_xiInfo;
|
|
if ( pOperation )
|
|
{
|
|
pOperation->m_bFinished = false;
|
|
pOperation->m_ret = ERROR_IO_PENDING;
|
|
pOperation->m_pLobby = &lobby;
|
|
}
|
|
|
|
// Submit XSessionMigrateHost
|
|
DWORD ret = g_pMatchExtensions->GetIXOnline()->XSessionMigrateHost( lobby.m_hHandle, XBX_GetPrimaryUserId(),
|
|
&pHandleImpl->m_xsi,
|
|
MMX360_NewOverlappedDormant( CX360LobbyMigrateHandleImpl::Finished, pHandleImpl ) );
|
|
|
|
if ( ret != ERROR_SUCCESS && ret != ERROR_IO_PENDING )
|
|
{
|
|
DevWarning( "XSessionMigrateHost(hosting) failed (code 0x%08X)\n", ret );
|
|
Assert( 0 );
|
|
}
|
|
|
|
return pHandleImpl;
|
|
}
|
|
else
|
|
{
|
|
DevWarning( "XSessionMigrateHost(hosting) unavailable because the session is SystemLink\n" );
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
CX360LobbyMigrateHandle_t MMX360_LobbyMigrateClient( CX360LobbyObject &lobby, XSESSION_INFO const &xsiNewHost, CX360LobbyMigrateOperation_t *pOperation )
|
|
{
|
|
if ( !XNetXnKidIsSystemLink( &lobby.m_xiInfo.sessionID ) )
|
|
{
|
|
CX360LobbyMigrateHandleImpl *pHandleImpl = new CX360LobbyMigrateHandleImpl;
|
|
pHandleImpl->m_pListener = pOperation;
|
|
pHandleImpl->m_xsi = xsiNewHost;
|
|
if ( pOperation )
|
|
{
|
|
pOperation->m_bFinished = false;
|
|
pOperation->m_ret = ERROR_IO_PENDING;
|
|
pOperation->m_pLobby = &lobby;
|
|
}
|
|
|
|
// Submit XSessionMigrateHost
|
|
DWORD ret = g_pMatchExtensions->GetIXOnline()->XSessionMigrateHost( lobby.m_hHandle, XUSER_INDEX_NONE,
|
|
&pHandleImpl->m_xsi,
|
|
MMX360_NewOverlappedDormant( CX360LobbyMigrateHandleImpl::Finished, pHandleImpl ) );
|
|
|
|
if ( ret != ERROR_SUCCESS && ret != ERROR_IO_PENDING )
|
|
{
|
|
DevWarning( "XSessionMigrateHost(client) failed (code 0x%08X)\n", ret );
|
|
Assert( 0 );
|
|
}
|
|
|
|
return pHandleImpl;
|
|
}
|
|
else
|
|
{
|
|
DevWarning( "XSessionMigrateHost(client) unavailable because the session is SystemLink\n" );
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
CX360LobbyMigrateOperation_t * MMX360_LobbyMigrateSetListener( CX360LobbyMigrateHandle_t hMigrateCall, CX360LobbyMigrateOperation_t *pOperation )
|
|
{
|
|
CX360LobbyMigrateHandleImpl *pHandle = ( CX360LobbyMigrateHandleImpl * ) hMigrateCall;
|
|
CX360LobbyMigrateOperation_t *pOldListener = NULL;
|
|
if ( pHandle )
|
|
{
|
|
pOldListener = pHandle->m_pListener;
|
|
if ( pOperation && pHandle->m_pListener )
|
|
*pOperation = *pHandle->m_pListener;
|
|
pHandle->m_pListener = pOperation;
|
|
}
|
|
return pOldListener;
|
|
}
|
|
|
|
|
|
//
|
|
// Join and Leave implementation
|
|
//
|
|
|
|
static DWORD MMX360_Helper_LobbyJoin( CX360LobbyObject &lobby, XUID xuid )
|
|
{
|
|
static const BOOL bPrivate = TRUE;
|
|
|
|
int iCtrlr = MMX360_GetUserCtrlrIndex( xuid );
|
|
DevMsg( "Session %llx: ADDED %llx%s\n", lobby.m_uiNonce, xuid, ( iCtrlr >= 0 ) ? " local" : "" );
|
|
|
|
if ( iCtrlr >= 0 )
|
|
{
|
|
DWORD *pdwUserIndex = new DWORD( iCtrlr );
|
|
return g_pMatchExtensions->GetIXOnline()->XSessionJoinLocal( lobby.m_hHandle,
|
|
1, pdwUserIndex, &bPrivate,
|
|
MMX360_NewOverlappedDormant( OnCompleted_DeleteData< DWORD >, pdwUserIndex ) );
|
|
}
|
|
else
|
|
{
|
|
XUID *pXuids = new XUID( xuid );
|
|
return g_pMatchExtensions->GetIXOnline()->XSessionJoinRemote( lobby.m_hHandle,
|
|
1, pXuids, &bPrivate,
|
|
MMX360_NewOverlappedDormant( OnCompleted_DeleteData< XUID >, pXuids ) );
|
|
}
|
|
}
|
|
|
|
static DWORD MMX360_Helper_LobbyLeave( CX360LobbyObject &lobby, XUID xuid )
|
|
{
|
|
int iCtrlr = MMX360_GetUserCtrlrIndex( xuid );
|
|
DevMsg( "Session %llx: LEAVE %llx%s\n", lobby.m_uiNonce, xuid, ( iCtrlr >= 0 ) ? " local" : "" );
|
|
|
|
if ( iCtrlr >= 0 )
|
|
{
|
|
DWORD *pdwUserIndex = new DWORD( iCtrlr );
|
|
return g_pMatchExtensions->GetIXOnline()->XSessionLeaveLocal( lobby.m_hHandle,
|
|
1, pdwUserIndex,
|
|
MMX360_NewOverlappedDormant( OnCompleted_DeleteData< DWORD >, pdwUserIndex ) );
|
|
}
|
|
else
|
|
{
|
|
XUID *pXuids = new XUID( xuid );
|
|
return g_pMatchExtensions->GetIXOnline()->XSessionLeaveRemote( lobby.m_hHandle,
|
|
1, pXuids,
|
|
MMX360_NewOverlappedDormant( OnCompleted_DeleteData< XUID >, pXuids ) );
|
|
}
|
|
}
|
|
|
|
static void MMX360_Helper_LobbyJoinLeaveMembers( KeyValues *pSettings, CX360LobbyObject &lobby,
|
|
DWORD (*pfn)( CX360LobbyObject&, XUID ),
|
|
int idxMachineStart, int idxMachineEnd )
|
|
{
|
|
if ( !pSettings )
|
|
return;
|
|
|
|
KeyValues *kvMembers = pSettings->FindKey( "members" );
|
|
if ( !kvMembers )
|
|
return;
|
|
|
|
int numMachines = kvMembers->GetInt( "numMachines", 0 );
|
|
|
|
if ( idxMachineEnd < 0 || idxMachineEnd >= numMachines )
|
|
idxMachineEnd = numMachines - 1;
|
|
|
|
for ( int k = idxMachineStart; k <= idxMachineEnd; ++ k )
|
|
{
|
|
KeyValues *kvMachine = kvMembers->FindKey( CFmtStr( "machine%d", k ) );
|
|
if ( !kvMachine )
|
|
continue;
|
|
|
|
int numPlayers = kvMachine->GetInt( "numPlayers", 0 );
|
|
for ( int j = 0; j < numPlayers; ++ j )
|
|
{
|
|
KeyValues *kvPlayer = kvMachine->FindKey( CFmtStr( "player%d", j ) );
|
|
if ( !kvPlayer )
|
|
continue;
|
|
|
|
XUID xuid = kvPlayer->GetUint64( "xuid", 0ull );
|
|
if ( !xuid )
|
|
continue;
|
|
|
|
DWORD ret = pfn( lobby, xuid );
|
|
if ( ERROR_SUCCESS != ret && ERROR_IO_PENDING != ret )
|
|
{
|
|
DevWarning( "XSessionJoin/Leave (pfn=%p) failed (code 0x%08X)!\n", pfn, ret );
|
|
Assert( 0 );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void MMX360_LobbyJoinMembers( KeyValues *pSettings, CX360LobbyObject &lobby, int idxMachineStart, int idxMachineEnd )
|
|
{
|
|
MMX360_Helper_LobbyJoinLeaveMembers( pSettings, lobby, MMX360_Helper_LobbyJoin, idxMachineStart, idxMachineEnd );
|
|
}
|
|
|
|
void MMX360_LobbyLeaveMembers( KeyValues *pSettings, CX360LobbyObject &lobby, int idxMachineStart, int idxMachineEnd )
|
|
{
|
|
MMX360_Helper_LobbyJoinLeaveMembers( pSettings, lobby, MMX360_Helper_LobbyLeave, idxMachineStart, idxMachineEnd );
|
|
}
|
|
|
|
bool MMX360_LobbySetActiveGameplayState( CX360LobbyObject &lobby, bool bActive, char const *szSecureServerAddress )
|
|
{
|
|
if ( bActive == lobby.m_bXSessionStarted )
|
|
{
|
|
DevWarning( "LobbySetActiveGameplayState called in same state '%s', ignored!\n",
|
|
bActive ? "active" : "inactive" );
|
|
Assert( bActive != lobby.m_bXSessionStarted );
|
|
return false;
|
|
}
|
|
|
|
DWORD ret = ERROR_SUCCESS;
|
|
if ( bActive )
|
|
{
|
|
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues(
|
|
"OnProfilesWriteOpportunity", "reason", "sessionstart"
|
|
) );
|
|
|
|
ret = g_pMatchExtensions->GetIXOnline()->XSessionStart( lobby.m_hHandle, 0, MMX360_NewOverlappedDormant() );
|
|
|
|
// Parse the address
|
|
if ( szSecureServerAddress )
|
|
{
|
|
if ( char const *szExternalPeer = StringAfterPrefix( szSecureServerAddress, "SESSIONINFO " ) )
|
|
{
|
|
MMX360_SessionInfoFromString( lobby.m_xiExternalPeer, szExternalPeer );
|
|
}
|
|
else
|
|
{
|
|
netadr_t na;
|
|
na.SetFromString( szSecureServerAddress );
|
|
lobby.m_inaSecure.s_addr = na.GetIPNetworkByteOrder();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
g_pMatchFramework->GetEventsSubscription()->BroadcastEvent( new KeyValues(
|
|
"OnProfilesWriteOpportunity", "reason", "sessionend"
|
|
) );
|
|
|
|
// Asynchronous call to XSessionEnd
|
|
ret = g_pMatchExtensions->GetIXOnline()->XSessionEnd( lobby.m_hHandle, MMX360_NewOverlappedDormant() );
|
|
|
|
if ( lobby.m_inaSecure.s_addr )
|
|
{
|
|
g_pMatchExtensions->GetIXOnline()->XNetUnregisterInAddr( lobby.m_inaSecure );
|
|
lobby.m_inaSecure.s_addr = 0;
|
|
}
|
|
|
|
if ( 0ull != ( const uint64 & ) lobby.m_xiExternalPeer.sessionID )
|
|
{
|
|
g_pMatchExtensions->GetIXOnline()->XNetUnregisterKey( &lobby.m_xiExternalPeer.sessionID );
|
|
memset( &lobby.m_xiExternalPeer, 0, sizeof( lobby.m_xiExternalPeer ) );
|
|
}
|
|
}
|
|
|
|
if ( ret != ERROR_SUCCESS && ret != ERROR_IO_PENDING )
|
|
{
|
|
DevWarning( "LobbySetActiveGameplayState failed to become '%s', code = 0x%08X!\n",
|
|
bActive ? "active" : "inactive", ret );
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
lobby.m_bXSessionStarted = bActive;
|
|
|
|
// Update active gameplay sessions stack
|
|
CX360ActiveGameplaySession_t ags( lobby.m_hHandle );
|
|
for ( int k = 0; k < s_arrActiveGameplaySessions.Count(); ++ k )
|
|
{
|
|
CX360ActiveGameplaySession_t const &x = s_arrActiveGameplaySessions[k];
|
|
if ( x.m_hHandle == ags.m_hHandle )
|
|
{
|
|
s_arrActiveGameplaySessions.Remove( k -- );
|
|
}
|
|
}
|
|
|
|
if ( lobby.m_bXSessionStarted )
|
|
{
|
|
s_arrActiveGameplaySessions.AddToTail( ags );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void MMX360_CancelOverlapped( XOVERLAPPED *pxOverlapped )
|
|
{
|
|
g_pMatchExtensions->GetIXOnline()->XCancelOverlapped( pxOverlapped );
|
|
}
|
|
|
|
#endif
|