{

SESSION_STATE_NONE,

SESSION_STATE_CREATING,

SESSION_STATE_MIGRATING,

SESSION_STATE_IDLE,

SESSION_STATE_WAITING_FOR_REGISTRATION,

SESSION_STATE_REGISTERING,

SESSION_STATE_REGISTERED,

SESSION_STATE_STARTING,

SESSION_STATE_IN_GAME,

SESSION_STATE_ENDING,

SESSION_STATE_FINISHED,

SESSION_STATE_DELETING

{

SLOTS_TOTALPUBLIC,

SLOTS_TOTALPRIVATE,

SLOTS_FILLEDPUBLIC,

SLOTS_FILLEDPRIVATE,

SLOTS_LAST

{

public:

uint64 m_id; // machine id

netadr_t m_adr; // IP and Port

XNADDR m_xnaddr; // XNADDR

XUID m_xuids[MAX_PLAYERS_PER_CLIENT]; // XUIDs

bool m_bInvited; // use private slots

bool m_bRegistered; // registered for arbitration

bool m_bMigrated; // successfully completed migration

bool m_bModified; // completed session modification

bool m_bReportedStats; // reported session stats to Live

bool m_bLoaded; // map load is complete

byte m_cVoiceState[MAX_PLAYERS_PER_CLIENT]; // has voice permission

char m_cPlayers; // number of players on this client

char m_iControllers[MAX_PLAYERS_PER_CLIENT]; // the controller (user index) for each player

char m_iTeam[MAX_PLAYERS_PER_CLIENT]; // each player's team

char m_szGamertags[MAX_PLAYERS_PER_CLIENT][MAX_PLAYER_NAME_LENGTH];

char mutable m_numPrivateSlotsUsed; // number of private slots used by this client if invited

CClientInfo()

{

Clear();

}

void Clear()

{

Q_memset( this, 0, sizeof( CClientInfo ) );

Q_memset( &m_iTeam, -1, sizeof( m_iTeam ) );

}

{

public:

CSession();

~CSession();

void ResetSession();

void SetParent( CMatchmaking *pParent );

void RunFrame();

bool CreateSession();

void CancelCreateSession();

void DestroySession();

void RegisterForArbitration();

bool MigrateHost();

void JoinLocal( const CClientInfo *pClient );

void JoinRemote( const CClientInfo *pClient );

void RemoveLocal( const CClientInfo *pClient );

void RemoveRemote( const CClientInfo *pClient );

// Accessors

HANDLE GetSessionHandle();

void SetSessionInfo( XSESSION_INFO *pInfo );

void SetNewSessionInfo( XSESSION_INFO *pInfo );

void GetSessionInfo( XSESSION_INFO *pInfo );

void GetNewSessionInfo( XSESSION_INFO *pInfo );

void SetSessionNonce( int64 nonce );

uint64 GetSessionNonce();

XNKID GetSessionId();

void SetSessionSlots( unsigned int nSlot, unsigned int nPlayers );

uint GetSessionSlots( unsigned int nSlot );

void SetSessionFlags( uint flags );

uint GetSessionFlags();

int GetPlayerCount();

void SetFlag( uint dwFlag );

void SetIsHost( bool bHost );

void SetIsSystemLink( bool bSystemLink );

void SetOwnerId( uint id );

bool IsHost();

bool IsFull();

bool IsArbitrated();

bool IsSystemLink();

void SwitchToState( SESSION_STATE newState );

void SetContext( const uint nContextId, const uint nContextValue, const bool bAsync = true );

void SetProperty( const uint nPropertyId, const uint cbValue, const void *pvValue, const bool bAsync = true );

XSESSION_REGISTRATION_RESULTS *GetRegistrationResults() { return m_pRegistrationResults; }

private:

// Update functions

void UpdateCreating();

void UpdateMigrating();

void UpdateRegistering();

void SendNotification( SESSION_NOTIFY notification );

void UpdateSlots( const CClientInfo *pClient, bool bAddPlayers );

double GetTime();

HANDLE m_hSession; // Session handle

bool m_bIsHost; // Is hosting

bool m_bIsArbitrated; // Is Arbitrated

bool m_bUsingQoS; // Is the QoS listener enabled

bool m_bIsSystemLink; // Is this a system link session

XSESSION_INFO m_SessionInfo; // Session ID, key, and host address

XSESSION_INFO m_NewSessionInfo; // Session ID, key, and host address

uint64 m_SessionNonce; // Nonce of the session

uint m_nSessionFlags; // Session creation flags

uint m_nOwnerId; // Which player created the session

uint m_SessionState;

double m_fOperationStartTime;

CMatchmaking *m_pParent;

AsyncHandle_t m_hCreateHandle;

AsyncHandle_t m_hMigrateHandle;

AsyncHandle_t m_hRegisterHandle;

XSESSION_REGISTRATION_RESULTS *m_pRegistrationResults;

// public/private slots for the session

uint m_nPlayerSlots[SLOTS_LAST];