394 lines
12 KiB
C++
394 lines
12 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: The main manager of the networking code in the game
|
|
//
|
|
// $Revision: $
|
|
// $NoKeywords: $
|
|
//===========================================================================//
|
|
|
|
#include "networkmanager.h"
|
|
#include "legion.h"
|
|
#include "networksystem/inetworkmessage.h"
|
|
#include "tier1/bitbuf.h"
|
|
#include "inetworkmessagelistener.h"
|
|
#include "tier0/icommandline.h"
|
|
#include "tier2/tier2.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Singleton accessor
|
|
//-----------------------------------------------------------------------------
|
|
static CNetworkManager s_NetworkManager;
|
|
extern CNetworkManager *g_pNetworkManager = &s_NetworkManager;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Static members.
|
|
// NOTE: Do *not* set this to 0; it could cause us to lose some registered
|
|
// menus since that list is set up during construction
|
|
//-----------------------------------------------------------------------------
|
|
INetworkMessageFactory *CNetworkManager::m_pFirstFactory;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Call to register methods to register network messages
|
|
//-----------------------------------------------------------------------------
|
|
INetworkMessageFactory *CNetworkManager::RegisterNetworkMessage( INetworkMessageFactory *pNetworkMessageFactory )
|
|
{
|
|
// NOTE: This method is expected to be called during global constructor
|
|
// time, so it must not require any global constructors to be called to work
|
|
INetworkMessageFactory *pPrevFactory = m_pFirstFactory;
|
|
m_pFirstFactory = pNetworkMessageFactory;
|
|
return pPrevFactory;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Init, shutdown
|
|
//-----------------------------------------------------------------------------
|
|
bool CNetworkManager::Init()
|
|
{
|
|
m_bIsClient = m_bIsServer = false;
|
|
m_pClientToServerConnection = NULL;
|
|
|
|
// Make a listener array for each message type
|
|
|
|
// Register all network messages
|
|
INetworkMessageFactory *pFactory;
|
|
for ( pFactory = m_pFirstFactory; pFactory; pFactory = pFactory->GetNextFactory() )
|
|
{
|
|
INetworkMessage *pNetworkMessage = pFactory->CreateNetworkMessage();
|
|
g_pNetworkSystem->RegisterMessage( pNetworkMessage );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CNetworkManager::Shutdown()
|
|
{
|
|
ShutdownClient();
|
|
ShutdownServer();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Start a server up
|
|
//-----------------------------------------------------------------------------
|
|
bool CNetworkManager::StartServer( unsigned short nServerListenPort )
|
|
{
|
|
ShutdownServer( );
|
|
if ( nServerListenPort == LEGION_DEFAULT_SERVER_PORT )
|
|
{
|
|
nServerListenPort = CommandLine()->ParmValue( "-serverport", NETWORKSYSTEM_DEFAULT_SERVER_PORT );
|
|
}
|
|
m_bIsServer = g_pNetworkSystem->StartServer( nServerListenPort );
|
|
return m_bIsServer;
|
|
}
|
|
|
|
void CNetworkManager::ShutdownServer( )
|
|
{
|
|
if ( m_bIsServer )
|
|
{
|
|
g_pNetworkSystem->ShutdownServer( );
|
|
m_bIsServer = false;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Start a client up
|
|
//-----------------------------------------------------------------------------
|
|
bool CNetworkManager::StartClient( unsigned short nClientListenPort )
|
|
{
|
|
ShutdownClient( );
|
|
|
|
if ( nClientListenPort == LEGION_DEFAULT_CLIENT_PORT )
|
|
{
|
|
nClientListenPort = CommandLine()->ParmValue( "-clientport", NETWORKSYSTEM_DEFAULT_CLIENT_PORT );
|
|
}
|
|
|
|
m_bIsClient = g_pNetworkSystem->StartClient( nClientListenPort );
|
|
return m_bIsClient;
|
|
}
|
|
|
|
void CNetworkManager::ShutdownClient( )
|
|
{
|
|
if ( m_bIsClient )
|
|
{
|
|
DisconnectClientFromServer();
|
|
g_pNetworkSystem->ShutdownClient( );
|
|
m_bIsClient = false;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Connects/disconnects the client to a server
|
|
//-----------------------------------------------------------------------------
|
|
bool CNetworkManager::ConnectClientToServer( const char *pServerName, unsigned short nServerListenPort )
|
|
{
|
|
DisconnectClientFromServer();
|
|
if ( !IsClient() )
|
|
return false;
|
|
|
|
if ( nServerListenPort == LEGION_DEFAULT_SERVER_PORT )
|
|
{
|
|
nServerListenPort = CommandLine()->ParmValue( "-serverport", NETWORKSYSTEM_DEFAULT_SERVER_PORT );
|
|
}
|
|
m_pClientToServerConnection = g_pNetworkSystem->ConnectClientToServer( pServerName, nServerListenPort );
|
|
return ( m_pClientToServerConnection != NULL );
|
|
}
|
|
|
|
void CNetworkManager::DisconnectClientFromServer( )
|
|
{
|
|
if ( m_pClientToServerConnection )
|
|
{
|
|
g_pNetworkSystem->DisconnectClientFromServer( m_pClientToServerConnection );
|
|
m_pClientToServerConnection = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Start up a game where the local player is playing
|
|
//-----------------------------------------------------------------------------
|
|
bool CNetworkManager::HostGame()
|
|
{
|
|
if ( !StartServer() )
|
|
return false;
|
|
|
|
if ( !StartClient() )
|
|
{
|
|
ShutdownServer();
|
|
return false;
|
|
}
|
|
|
|
if ( !ConnectClientToServer( "localhost" ) )
|
|
{
|
|
ShutdownClient();
|
|
ShutdownServer();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CNetworkManager::StopHostingGame()
|
|
{
|
|
ShutdownClient();
|
|
ShutdownServer();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Are we a client?/Are we a server? (we can be both)
|
|
//-----------------------------------------------------------------------------
|
|
bool CNetworkManager::IsClient()
|
|
{
|
|
return m_bIsClient;
|
|
}
|
|
|
|
bool CNetworkManager::IsServer()
|
|
{
|
|
return m_bIsServer;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// If we are a client, are we connected to the server?
|
|
//-----------------------------------------------------------------------------
|
|
bool CNetworkManager::IsClientConnected()
|
|
{
|
|
return m_bIsClient && ( m_pClientToServerConnection != NULL ) && ( m_pClientToServerConnection->GetConnectionState() == CONNECTION_STATE_CONNECTED );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Post a network message to the server
|
|
//-----------------------------------------------------------------------------
|
|
void CNetworkManager::PostClientToServerMessage( INetworkMessage *pMessage )
|
|
{
|
|
if ( IsClientConnected() )
|
|
{
|
|
m_pClientToServerConnection->AddNetMsg( pMessage );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Broadcast a network message to all clients
|
|
//-----------------------------------------------------------------------------
|
|
void CNetworkManager::BroadcastServerToClientMessage( INetworkMessage *pMessage )
|
|
{
|
|
if ( IsServer() )
|
|
{
|
|
int nCount = m_ServerToClientConnection.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
m_ServerToClientConnection[i]->AddNetMsg( pMessage );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Add, remove network message listeners
|
|
//-----------------------------------------------------------------------------
|
|
void CNetworkManager::AddListener( NetworkMessageRoute_t route, int nGroup, int nType, INetworkMessageListener *pListener )
|
|
{
|
|
CUtlVector< CUtlVector< CUtlVector < INetworkMessageListener* > > > &listeners = m_Listeners[ route ];
|
|
if ( listeners.Count() <= nGroup )
|
|
{
|
|
listeners.AddMultipleToTail( nGroup - listeners.Count() + 1 );
|
|
}
|
|
|
|
if ( listeners[nGroup].Count() <= nType )
|
|
{
|
|
listeners[nGroup].AddMultipleToTail( nType - listeners[nGroup].Count() + 1 );
|
|
}
|
|
|
|
Assert( listeners[nGroup][nType].Find( pListener ) < 0 );
|
|
listeners[nGroup][nType].AddToTail( pListener );
|
|
}
|
|
|
|
void CNetworkManager::RemoveListener( NetworkMessageRoute_t route, int nGroup, int nType, INetworkMessageListener *pListener )
|
|
{
|
|
CUtlVector< CUtlVector< CUtlVector < INetworkMessageListener* > > > &listeners = m_Listeners[ route ];
|
|
if ( listeners.Count() > nGroup )
|
|
{
|
|
if( listeners[nGroup].Count() > nType )
|
|
{
|
|
// Maintain order of listeners (not sure if it matters)
|
|
listeners[nGroup][nType].FindAndRemove( pListener );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Notifies listeners about a network message
|
|
//-----------------------------------------------------------------------------
|
|
void CNetworkManager::NotifyListeners( NetworkMessageRoute_t route, INetworkMessage *pMessage )
|
|
{
|
|
CUtlVector< CUtlVector< CUtlVector < INetworkMessageListener* > > > &listeners = m_Listeners[ route ];
|
|
|
|
// based on id, search for installed listeners
|
|
int nGroup = pMessage->GetGroup();
|
|
if ( listeners.Count() > nGroup )
|
|
{
|
|
int nType = pMessage->GetType();
|
|
if ( listeners[nGroup].Count() > nType )
|
|
{
|
|
CUtlVector< INetworkMessageListener* > &list = listeners[nGroup][nType];
|
|
int nCount = list.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
list[i]->OnNetworkMessage( route, pMessage );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Process messages received by the client
|
|
//-----------------------------------------------------------------------------
|
|
void CNetworkManager::ProcessClientMessages()
|
|
{
|
|
NetworkEvent_t *pEvent = g_pNetworkSystem->FirstNetworkEvent();
|
|
for ( ; pEvent; pEvent = g_pNetworkSystem->NextNetworkEvent( ) )
|
|
{
|
|
switch ( pEvent->m_nType )
|
|
{
|
|
/*
|
|
case NETWORK_EVENT_CONNECTED:
|
|
{
|
|
NetworkConnectionEvent_t* pConnectEvent = static_cast<NetworkConnectionEvent_t*>( pEvent );
|
|
m_pClientToServerConnection = pConnectEvent->m_pChannel;
|
|
}
|
|
break;
|
|
|
|
case NETWORK_EVENT_DISCONNECTED:
|
|
{
|
|
NetworkDisconnectionEvent_t* pDisconnectEvent = static_cast<NetworkDisconnectionEvent_t*>( pEvent );
|
|
Assert( m_pClientToServerConnection == pDisconnectEvent->m_pChannel );
|
|
if ( m_pClientToServerConnection == pDisconnectEvent->m_pChannel )
|
|
{
|
|
m_pClientToServerConnection = NULL;
|
|
}
|
|
}
|
|
break;
|
|
*/
|
|
|
|
case NETWORK_EVENT_MESSAGE_RECEIVED:
|
|
{
|
|
NetworkMessageReceivedEvent_t* pPacketEvent = static_cast<NetworkMessageReceivedEvent_t*>( pEvent );
|
|
NotifyListeners( NETWORK_MESSAGE_SERVER_TO_CLIENT, pPacketEvent->m_pNetworkMessage );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Process messages received by the server
|
|
//-----------------------------------------------------------------------------
|
|
void CNetworkManager::ProcessServerMessages()
|
|
{
|
|
NetworkEvent_t *pEvent = g_pNetworkSystem->FirstNetworkEvent();
|
|
for ( ; pEvent; pEvent = g_pNetworkSystem->NextNetworkEvent( ) )
|
|
{
|
|
switch ( pEvent->m_nType )
|
|
{
|
|
case NETWORK_EVENT_CONNECTED:
|
|
{
|
|
NetworkConnectionEvent_t* pConnectEvent = static_cast<NetworkConnectionEvent_t*>( pEvent );
|
|
m_ServerToClientConnection.AddToTail( pConnectEvent->m_pChannel );
|
|
}
|
|
break;
|
|
|
|
case NETWORK_EVENT_DISCONNECTED:
|
|
{
|
|
NetworkDisconnectionEvent_t* pDisconnectEvent = static_cast<NetworkDisconnectionEvent_t*>( pEvent );
|
|
m_ServerToClientConnection.FindAndRemove( pDisconnectEvent->m_pChannel );
|
|
}
|
|
break;
|
|
|
|
case NETWORK_EVENT_MESSAGE_RECEIVED:
|
|
{
|
|
NetworkMessageReceivedEvent_t* pPacketEvent = static_cast<NetworkMessageReceivedEvent_t*>( pEvent );
|
|
NotifyListeners( NETWORK_MESSAGE_CLIENT_TO_SERVER, pPacketEvent->m_pNetworkMessage );
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Per-frame update
|
|
//-----------------------------------------------------------------------------
|
|
void CNetworkManager::Update( )
|
|
{
|
|
if ( IsClient() )
|
|
{
|
|
g_pNetworkSystem->ClientSendMessages();
|
|
}
|
|
|
|
if ( IsServer() )
|
|
{
|
|
g_pNetworkSystem->ServerReceiveMessages();
|
|
ProcessServerMessages();
|
|
g_pNetworkSystem->ServerSendMessages();
|
|
}
|
|
|
|
if ( IsClient() )
|
|
{
|
|
g_pNetworkSystem->ClientReceiveMessages();
|
|
ProcessClientMessages();
|
|
}
|
|
}
|
|
|
|
|