1
This commit is contained in:
FluorescentCIAAfricanAmerican
611
engine/Session.cpp
Normal file
611
engine/Session.cpp
Normal file
@ -0,0 +1,611 @@
|
||||
//========= 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();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user