1.13 Добавляем поддержку игры по сети

//-----------------------------------------------------------------------------
// File: Network.h
// Класс-обёртка (wrapper class) для DirectPlay. Поддержка игры по сети представлена
// в виде пиринговой (peer-to-peer) архитектуры.
//
// Original SourceCode:
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#ifndef NETWORK_H
#define NETWORK_H

//-----------------------------------------------------------------------------
// Стандартные определения (defines) сообщений
//-----------------------------------------------------------------------------
#define MSGID_CREATE_PLAYER 0x12001
#define MSGID_DESTROY_PLAYER 0x12002
#define MSGID_TERMINATE_SESSION 0x12003

//-----------------------------------------------------------------------------
// Структура сетевого сообщения
//-----------------------------------------------------------------------------
struct NetworkMessage
{
	unsigned long msgid; // Message ID.
	DPNID dpnid; // DirectPlay player ID.
};

//-----------------------------------------------------------------------------
// Структура полученного сообщения
//-----------------------------------------------------------------------------
struct ReceivedMessage : public NetworkMessage
{
	char data[32]; // Данные сообщения.
};

//-----------------------------------------------------------------------------
// Структура информации энумерированной сессии (Enumerated Session Information Structure)
//-----------------------------------------------------------------------------
struct SessionInfo
{
	IDirectPlay8Address *address; // Session network address.
	DPN_APPLICATION_DESC description; // Application description.
};

//-----------------------------------------------------------------------------
// Структура информации игрока (Player Information Structure)
//-----------------------------------------------------------------------------
struct PlayerInfo
{
	DPNID dpnid; // DirectPlay player ID.
	char *name; // Name of the player.
	void *data; // Данные игрока, специфичные для приложения (Application specific player data).
	unsigned long size; // Data size.

	//-------------------------------------------------------------------------
	// The player information structure constructor.
	//-------------------------------------------------------------------------
	PlayerInfo()
	{
		dpnid = 0;
		name = NULL;
		data = NULL;
		size = 0;
	}

	//-------------------------------------------------------------------------
	// The player information structure destructor.
	//-------------------------------------------------------------------------
	~PlayerInfo()
	{
		SAFE_DELETE( name );
		SAFE_DELETE( data );
	}
};

//-----------------------------------------------------------------------------
// Network Class
//-----------------------------------------------------------------------------
class Network
{
public:
	Network( GUID guid, void (*HandleNetworkMessageFunction)( ReceivedMessage *msg ) );
	virtual ~Network();

	void Update();

	void EnumerateSessions();

	bool Host( char *name, char *session, int players = 0, void *playerData = NULL, unsigned long dataSize = 0 );
	bool Join( char *name, int session = 0, void *playerData = NULL, unsigned long dataSize = 0 );
	void Terminate();

	void SetReceiveAllowed( bool allowed );

	SessionInfo *GetNextSession( bool restart = false );
	PlayerInfo *GetPlayer( DPNID dpnid );

	DPNID GetLocalID();
	DPNID GetHostID();
	bool IsHost();

	void Send( void *data, long size, DPNID dpnid = DPNID_ALL_PLAYERS_GROUP, long flags = 0 );

private:
	static HRESULT WINAPI NetworkMessageHandler( PVOID context, DWORD msgid, PVOID data );

private:
	GUID m_guid; // Application specific GUID.
	IDirectPlay8Peer *m_dpp; // DirectPlay peer interface.
	IDirectPlay8Address *m_device; // DirectPlay device address.

	unsigned long m_port; // Port for network communication.
	unsigned long m_sendTimeOut; // Таймаут для отпреаленных сетевых сообщений (Timeout for sent network messages.)
	unsigned long m_processingTime; /* Допустимый период времени для обработки полученных сетевых сообщений.
(Allowed time period for processing received network messages.) */


	DPNID m_dpnidLocal; // DirectPlay ID of the local player.
	DPNID m_dpnidHost; // DirectPlay ID of the host player.

	CRITICAL_SECTION m_sessionCS; // Enumerated session list critical section.
	LinkedList< SessionInfo > *m_sessions; // Связный список энумерированных сессий (Linked list of enumerated sessions.)

	CRITICAL_SECTION m_playerCS; // Player list critical section.
	LinkedList< PlayerInfo > *m_players; // Связный список игроков (Linked list of players.)

bool m_receiveAllowed; /* Флаг, указывающий, разрешено ли сети получать сообщения, специфичные для приложения
(Inidcates if the network is allowed to receive application specific messages.)*/
	CRITICAL_SECTION m_messageCS; // Network message list critical section.
	LinkedList< ReceivedMessage > *m_messages; // Linked list of network messages.
void (*HandleNetworkMessage)( ReceivedMessage *msg ); // Указатель на обработчик сообщений, специфичных для приложения
						//(Pointer to an application specific network message handler.)
};

#endif

...
//-----------------------------------------------------------------------------
// Структура сетевого сообщения
//-----------------------------------------------------------------------------
struct NetworkMessage
{
	unsigned long msgid; // Message ID.
	DPNID dpnid; // DirectPlay player ID.
};
...

...
//-----------------------------------------------------------------------------
// Структура информации игрока (Player Information Structure)
//-----------------------------------------------------------------------------
struct PlayerInfo
{
	DPNID dpnid; // DirectPlay player ID.
	char *name; // Name of the player.
	void *data; // Данные игрока, специфичные для приложения (Application specific player data).
	unsigned long size; // Data size.

	//-------------------------------------------------------------------------
	// The player information structure constructor.
	//-------------------------------------------------------------------------
	PlayerInfo()
	{
		dpnid = 0;
		name = NULL;
		data = NULL;
		size = 0;
	}

	//-------------------------------------------------------------------------
	// The player information structure destructor.
	//-------------------------------------------------------------------------
	~PlayerInfo()
	{
		SAFE_DELETE( name );
		SAFE_DELETE( data );
	}
};
...

EnterCriticalSection(SmyCS);
// Любой код, размещённый здесь, защищен от внешни:': посягательств других потоков и функций.
LeaveCriticalSection(SmyCS);

...
//-----------------------------------------------------------------------------
// Network Class
//-----------------------------------------------------------------------------
class Network
{
public:
	Network( GUID guid, void (*HandleNetworkMessageFunction)( ReceivedMessage *msg ) );
	virtual ~Network();

	void Update();

	void EnumerateSessions();

	bool Host( char *name, char *session, int players = 0, void *playerData = NULL, unsigned long dataSize = 0 );
	bool Join( char *name, int session = 0, void *playerData = NULL, unsigned long dataSize = 0 );
	void Terminate();

	void SetReceiveAllowed( bool allowed );

	SessionInfo *GetNextSession( bool restart = false );
	PlayerInfo *GetPlayer( DPNID dpnid );

	DPNID GetLocalID();
	DPNID GetHostID();
	bool IsHost();

	void Send( void *data, long size, DPNID dpnid = DPNID_ALL_PLAYERS_GROUP, long flags = 0 );

private:
	static HRESULT WINAPI NetworkMessageHandler( PVOID context, DWORD msgid, PVOID data );

private:
	GUID m_guid; // Application specific GUID.
	IDirectPlay8Peer *m_dpp; // DirectPlay peer interface.
	IDirectPlay8Address *m_device; // DirectPlay device address.

	unsigned long m_port; // Port for network communication.
	unsigned long m_sendTimeOut; // Таймаут для отпреаленных сетевых сообщений (Timeout for sent network messages.)
	unsigned long m_processingTime; /* Допустимый период времени для обработки полученных сетевых сообщений.
(Allowed time period for processing received network messages.) */


	DPNID m_dpnidLocal; // DirectPlay ID of the local player.
	DPNID m_dpnidHost; // DirectPlay ID of the host player.

	CRITICAL_SECTION m_sessionCS; // Enumerated session list critical section.
	LinkedList< SessionInfo > *m_sessions; // Связный список энумерированных сессий (Linked list of enumerated sessions.)

	CRITICAL_SECTION m_playerCS; // Player list critical section.
	LinkedList< PlayerInfo > *m_players; // Связный список игроков (Linked list of players.)

bool m_receiveAllowed; /* Флаг, указывающий, разрешено ли сети получать сообщения, специфичные для приложения
(Inidcates if the network is allowed to receive application specific messages.)*/
	CRITICAL_SECTION m_messageCS; // Network message list critical section.
	LinkedList< ReceivedMessage > *m_messages; // Linked list of network messages.
void (*HandleNetworkMessage)( ReceivedMessage *msg ); // Указатель на обработчик сообщений, специфичных для приложения
						//(Pointer to an application specific network message handler.)
};
...

//-----------------------------------------------------------------------------
// File: Network.cpp
// Реализация классов и функций, объявленных в Network.h.
// Смотри объявление интерфейсов в Network.h для получения более подробной информации.
//
// Original SourceCode:
// Programming a Multiplayer First Person Shooter in DirectX
// Copyright (c) 2004 Vaughan Young
//-----------------------------------------------------------------------------
#include "Engine.h"

//-----------------------------------------------------------------------------
// The network class constructor.
//-----------------------------------------------------------------------------
Network::Network( GUID guid, void (*HandleNetworkMessageFunction)( ReceivedMessage *msg ) )
{
	// Иницииализируем критические секции.
	InitializeCriticalSection( &m_sessionCS );
	InitializeCriticalSection( &m_playerCS );
	InitializeCriticalSection( &m_messageCS );

	// Обнуляем пиринговый (peer) интерфейс DirectPlay и экземпляр устройства.
	m_dpp = NULL;
	m_device = NULL;

	// Сохраняем GUID приложения.
	memcpy( &m_guid, &guid, sizeof( GUID ) );

	// Создаём связный список энумеруемых сессий.
	m_sessions = new LinkedList< SessionInfo >;

	// Создаём связный список игроков.
	m_players = new LinkedList< PlayerInfo >;

	// Создаём связный список сетевых сообщений.
	m_messages = new LinkedList< ReceivedMessage >;

	// Загружаем сетевые настройки из файла NetworkSettings.txt.
	Script *settings = new Script( "NetworkSettings.txt" );
	if( settings->GetNumberData( "processing_time" ) == NULL )
	{
		m_port = 2509;
		m_sendTimeOut = 100;
		m_processingTime = 100;
	}
	else
	{
		m_port = *settings->GetNumberData( "port" );
		m_sendTimeOut = *settings->GetNumberData( "send_time_out" );
		m_processingTime = *settings->GetNumberData( "processing_time" );
	}
	SAFE_DELETE( settings );

	// Изначально системе сетевых сообщений запрещено получать сообщения, специфичные для приложения.
	m_receiveAllowed = false;

	// Устанавливаем обработчик сетевых сообщений (network message handler).
	HandleNetworkMessage = HandleNetworkMessageFunction;

	// Создаём и инициализируем пиринговый (peer) интерфейс DirectPlay.
	CoCreateInstance( CLSID_DirectPlay8Peer, NULL, CLSCTX_INPROC, IID_IDirectPlay8Peer, (void**)&m_dpp );
	m_dpp->Initialize( (PVOID)this, NetworkMessageHandler, 0 );

	// Создаём адрес устройства (device address).
	CoCreateInstance( CLSID_DirectPlay8Address, NULL, CLSCTX_INPROC, IID_IDirectPlay8Address, (LPVOID*) &m_device );
	m_device->SetSP( &CLSID_DP8SP_TCPIP );
	m_device->AddComponent( DPNA_KEY_PORT, &m_port, sizeof(DWORD), DPNA_DATATYPE_DWORD );
}

//-----------------------------------------------------------------------------
// The network class destructor.
//-----------------------------------------------------------------------------
Network::~Network()
{
	// Сохраняем сетевые настройки.
	Script *settings = new Script( "NetworkSettings.txt" );
	if( settings->GetNumberData( "processing_time" ) == NULL )
	{
		settings->AddVariable( "port", VARIABLE_NUMBER, &m_port );
		settings->AddVariable( "send_time_out", VARIABLE_NUMBER, &m_sendTimeOut );
		settings->AddVariable( "processing_time", VARIABLE_NUMBER, &m_processingTime );
	}
	else
	{
		settings->SetVariable( "port", &m_port );
		settings->SetVariable( "send_time_out", &m_sendTimeOut );
		settings->SetVariable( "processing_time", &m_processingTime );
	}
	settings->SaveScript();
	SAFE_DELETE( settings );

	// Освобождаем адрес устройства.
	SAFE_RELEASE( m_device );

	// Закрываем и освобождаем пиринговый (peer) интерфейс DirectPlay.
	if( m_dpp != NULL )
		m_dpp->Close( 0 );
	SAFE_RELEASE( m_dpp );

	// Уничтожаем связный список энумерированных сессий.
	SAFE_DELETE( m_sessions );

	// Уничтожаем связный список игроков.
	SAFE_DELETE( m_players );

	// Уничтожаем связный список сетевых сообщений.
	SAFE_DELETE( m_messages );

	// Уничтожаем критические секции.
	DeleteCriticalSection( &m_sessionCS );
	DeleteCriticalSection( &m_playerCS );
	DeleteCriticalSection( &m_messageCS );
}

//-----------------------------------------------------------------------------
// Обновляем (Update) объект сетевого устройства, позволяя ему обрабатывать сообщения.
//-----------------------------------------------------------------------------
void Network::Update()
{
	EnterCriticalSection( &m_messageCS );

	ReceivedMessage *message = m_messages->GetFirst();

	unsigned long endTime = timeGetTime() + m_processingTime;
	while( endTime > timeGetTime() && message != NULL )
	{
		HandleNetworkMessage( message );
		m_messages->Remove( &message );
		message = m_messages->GetFirst();
	}

	LeaveCriticalSection( &m_messageCS );
}

//-----------------------------------------------------------------------------
// Энумерируем сессии в локальной сети (LAN).
//-----------------------------------------------------------------------------
void Network::EnumerateSessions()
{
	// Очищаем связные списки.
	m_players->Empty();
	m_messages->Empty();
	m_sessions->Empty();

	// Подготавливаем описание приложения (application description).
	DPN_APPLICATION_DESC description;
	ZeroMemory( &description, sizeof( DPN_APPLICATION_DESC ) );
	description.dwSize = sizeof( DPN_APPLICATION_DESC );
	description.guidApplication = m_guid;

	// Энумерируем сессии синхронно (synchronously).
	m_dpp->EnumHosts( &description, NULL, m_device, NULL, 0, 1, 0, 0, NULL, NULL, DPNENUMHOSTS_SYNC );
}

//-----------------------------------------------------------------------------
// Пытаемся захостить (host) сессию.
//-----------------------------------------------------------------------------
bool Network::Host( char *name, char *session, int players, void *playerData, unsigned long dataSize )
{
	WCHAR wide[MAX_PATH];

	// Подготавливаем и заполняем структуру информации об игроке (player information structure).
	DPN_PLAYER_INFO player;
	ZeroMemory( &player, sizeof( DPN_PLAYER_INFO ) );
	player.dwSize = sizeof( DPN_PLAYER_INFO );
	player.pvData = playerData;
	player.dwDataSize = dataSize;
	player.dwInfoFlags = DPNINFO_NAME | DPNINFO_DATA;
	mbstowcs( wide, name, MAX_PATH );
	player.pwszName = wide;
	if( FAILED( m_dpp->SetPeerInfo( &player, NULL, NULL, DPNSETPEERINFO_SYNC ) ) )
		return false;

	// Подготавливаем описание приложения (application description).
	DPN_APPLICATION_DESC description;
	ZeroMemory( &description, sizeof( DPN_APPLICATION_DESC ) );
	description.dwSize = sizeof( DPN_APPLICATION_DESC );
	description.guidApplication = m_guid;
	description.dwMaxPlayers = players;
	mbstowcs( wide, session, MAX_PATH );
	description.pwszSessionName = wide;

	// Host the session.
	if( FAILED( m_dpp->Host( &description, &m_device, 1, NULL, NULL, NULL, 0 ) ) )
		return false;

	return true;
}

//-----------------------------------------------------------------------------
// Пытаемся вступить (to join) в выбранную сессию из связного списка энумерированных сессий.
//-----------------------------------------------------------------------------
bool Network::Join( char *name, int session, void *playerData, unsigned long dataSize )
{
	WCHAR wide[MAX_PATH];

	// Очищаем связные списки игроков (player list) и сетевых сообщений (newtork messages).
	m_players->Empty();
	m_messages->Empty();

	// Игнорим неправильные (invalid) сессии.
	if( session < 0 )
		return false;

	// Подготавливаем и заполняем структуру информации об игроке (player information structure).
	DPN_PLAYER_INFO player;
	ZeroMemory( &player, sizeof( DPN_PLAYER_INFO ) );
	player.dwSize = sizeof( DPN_PLAYER_INFO );
	player.pvData = playerData;
	player.dwDataSize = dataSize;
	player.dwInfoFlags = DPNINFO_NAME | DPNINFO_DATA;
	mbstowcs( wide, name, MAX_PATH );
	player.pwszName = wide;
	if( FAILED( m_dpp->SetPeerInfo( &player, NULL, NULL, DPNSETPEERINFO_SYNC ) ) )
		return false;

	// Входим в критическую секцию связного списка энумерированных сессий (sessions linked list critical section).
	EnterCriticalSection( &m_sessionCS );

	// Находим хост выбранной сессии.
	m_sessions->Iterate( true );
	for( int s = 0; s < session + 1; s++ )
	{
		if( m_sessions->Iterate() ==  NULL )
		{
			LeaveCriticalSection( &m_sessionCS );
			return false;
		}
	}

	// Вступаем (join) в сессию.
	if( FAILED( m_dpp->Connect( &m_sessions->GetCurrent()->description, m_sessions->GetCurrent()->address,
		m_device, NULL, NULL, NULL, 0, NULL, NULL, NULL, DPNCONNECT_SYNC ) ) )
	{
		LeaveCriticalSection( &m_sessionCS );
		return false;
	}
	LeaveCriticalSection( &m_sessionCS );

	return true;
}

//-----------------------------------------------------------------------------
// Уничтожаем текущую сессию.
//-----------------------------------------------------------------------------
void Network::Terminate()
{
	// Разрешаем уничтожать (terminate) сессию только хосту.
	if( m_dpnidHost == m_dpnidLocal )
		m_dpp->TerminateSession( NULL, 0, 0 );

	// Закрываем соединение. Это также приводит к деинициализации пирингового (peer) интерфейса DirectPlay.
	if( m_dpp != NULL )
		m_dpp->Close( 0 );

	// Инициализируем пиринговый (peer) интерфейс DirectPlay.
	m_dpp->Initialize( (PVOID)this, NetworkMessageHandler, 0 );
}

//-----------------------------------------------------------------------------
// Устанавливаем флаг, разрешающий получение и обработку сетевых сообщений.
//-----------------------------------------------------------------------------
void Network::SetReceiveAllowed( bool allowed )
{
	m_receiveAllowed = allowed;
}

//-----------------------------------------------------------------------------
// Возвращает следующую (next) итерированную сессию из связного списка энумерированных сессий.
//-----------------------------------------------------------------------------
SessionInfo *Network::GetNextSession( bool restart )
{
	EnterCriticalSection( &m_sessionCS );

	m_sessions->Iterate( restart );
	if( restart == true )
		m_sessions->Iterate();

	LeaveCriticalSection( &m_sessionCS );

	return m_sessions->GetCurrent();
}

//-----------------------------------------------------------------------------
// Возвращает указатель (pointer) на структуру с информацией о данном игроке (player information structure of the given player).
//-----------------------------------------------------------------------------
PlayerInfo *Network::GetPlayer( DPNID dpnid )
{
	EnterCriticalSection( &m_playerCS );

	m_players->Iterate( true );
	while( m_players->Iterate() )
	{
		if( m_players->GetCurrent()->dpnid == dpnid )
		{
			LeaveCriticalSection( &m_playerCS );

			return m_players->GetCurrent();
		}
	}

	LeaveCriticalSection( &m_playerCS );

	return NULL;
}

//-----------------------------------------------------------------------------
// Возвращает DirectPlay ID локального игрока.
//-----------------------------------------------------------------------------
DPNID Network::GetLocalID()
{
	return m_dpnidLocal;
}

//-----------------------------------------------------------------------------
// Возвращает DirectPlay ID хоста.
//-----------------------------------------------------------------------------
DPNID Network::GetHostID()
{
	return m_dpnidHost;
}

//-----------------------------------------------------------------------------
// Определяет, является ли выбранный сетевой объект хостом или нет.
//-----------------------------------------------------------------------------
bool Network::IsHost()
{
	if( m_dpnidHost == m_dpnidLocal )
		return true;
	else
		return false;
}

//-----------------------------------------------------------------------------
// Отправляет сетевое сообщение.
//-----------------------------------------------------------------------------
void Network::Send( void *data, long size, DPNID dpnid, long flags )
{
	DPNHANDLE hAsync;
	DPN_BUFFER_DESC dpbd;

	if( ( dpbd.dwBufferSize = size ) == 0 )
		return;
	dpbd.pBufferData = (BYTE*)data;

	m_dpp->SendTo( dpnid, &dpbd, 1, m_sendTimeOut, NULL, &hAsync, DPNSEND_NOCOMPLETE);
}

//-----------------------------------------------------------------------------
// Внутренний обработчик сетевых сообщений (internal network message handler).
//-----------------------------------------------------------------------------
HRESULT WINAPI Network::NetworkMessageHandler( PVOID context, DWORD msgid, PVOID data )
{
	// Получаем указатель на вызываемый сетевой объект.
	Network *network = (Network*)context;

	// Обрабатываем входящие сообщения, основываясь на их типе.
	switch( msgid )
	{
		case DPN_MSGID_CREATE_PLAYER:
		{
			unsigned long size = 0;
			DPN_PLAYER_INFO *info = NULL;
			HRESULT hr = DPNERR_CONNECTING;
			PDPNMSG_CREATE_PLAYER msgCreatePlayer = (PDPNMSG_CREATE_PLAYER)data;

			// Создаём структуру информации об игроке (player information structure) для нового игрока.
			PlayerInfo *playerInfo = new PlayerInfo;
			ZeroMemory( playerInfo, sizeof( PlayerInfo ) );
			playerInfo->dpnid = msgCreatePlayer->dpnidPlayer;

			// Продолжаем вызывать функцию GetPeerInfo(), т.к. он всё ещё может пытаться подключиться.
			while( hr == DPNERR_CONNECTING )
				hr = network->m_dpp->GetPeerInfo( playerInfo->dpnid, info, &size, 0 );

			// Проверяем, вернула ли функция GetPeerInfo() размер структуры DPN_PLAYER_INFO.
			if( hr == DPNERR_BUFFERTOOSMALL )
			{
				info = (DPN_PLAYER_INFO*) new BYTE[size];
				ZeroMemory( info, size );
				info->dwSize = sizeof( DPN_PLAYER_INFO );

				// Пытаемся снова, используя верный размер.
				if( SUCCEEDED( network->m_dpp->GetPeerInfo( playerInfo->dpnid, info, &size, 0 ) ) )
				{
					// Сохраняем имя нового игрока.
					playerInfo->name = new char[wcslen( info->pwszName ) + 1];
					ZeroMemory( playerInfo->name, wcslen( info->pwszName ) + 1 );
					wcstombs( playerInfo->name, info->pwszName, wcslen( info->pwszName ) );

					// Сохраняем данные нового игрока.
					playerInfo->data = new BYTE[info->dwDataSize];
					memcpy( playerInfo->data, info->pvData, info->dwDataSize );
					playerInfo->size = info->dwDataSize;

					// Сохраняем остальные установки локального игркоа и хоста.
					if( info->dwPlayerFlags & DPNPLAYER_LOCAL )
						network->m_dpnidLocal = playerInfo->dpnid;
					if( info->dwPlayerFlags & DPNPLAYER_HOST )
						network->m_dpnidHost = playerInfo->dpnid;
				}

				SAFE_DELETE_ARRAY( info );
			}

			// Добавляем нового игрока в связный список игроков (player list).
			EnterCriticalSection( &network->m_playerCS );
			network->m_players->Add( playerInfo );
			LeaveCriticalSection( &network->m_playerCS );

			// Если нет никакого обработчика сетевых сообщений, то немедленно прерываем (break).
			if( network->HandleNetworkMessage == NULL )
				break;

			// Создаём сообщение игрока о создании игрока.
			ReceivedMessage *message = new ReceivedMessage;
			message->msgid = MSGID_CREATE_PLAYER;
			message->dpnid = playerInfo->dpnid;

			// Сохраняем сообщение для последующей обработки приложением.
			EnterCriticalSection( &network->m_messageCS );
			network->m_messages->Add( message );
			LeaveCriticalSection( &network->m_messageCS );

			break;
		}

		case DPN_MSGID_DESTROY_PLAYER:
		{
			// Находим игрока, уничтожаем его и убираем из связного списка игроков (player list).
			EnterCriticalSection( &network->m_playerCS );
			network->m_players->Iterate( true );
			while( network->m_players->Iterate() )
			{
				if( network->m_players->GetCurrent()->dpnid == ( (PDPNMSG_DESTROY_PLAYER)data )->dpnidPlayer )
				{
					network->m_players->Remove( (PlayerInfo**)network->m_players->GetCurrent() );
					break;
				}
			}
			LeaveCriticalSection( &network->m_playerCS );

			// Если нет никакого обработчика сетевых сообщений, то немедленно прерываем (break).
			if( network->HandleNetworkMessage == NULL )
				break;

			// Создаём сообщение игрока об уничтожении игрока.
			ReceivedMessage *message = new ReceivedMessage;
			message->msgid = MSGID_DESTROY_PLAYER;
			message->dpnid = ( (PDPNMSG_DESTROY_PLAYER)data )->dpnidPlayer;

			// Сохраняем сообщение для последующей обработки приложением.
			EnterCriticalSection( &network->m_messageCS );
			network->m_messages->Add( message );
			LeaveCriticalSection( &network->m_messageCS );

			break;
		}

		case DPN_MSGID_ENUM_HOSTS_RESPONSE:
		{
			PDPNMSG_ENUM_HOSTS_RESPONSE response = (PDPNMSG_ENUM_HOSTS_RESPONSE)data;

			// Создаём структуру информации о сессии (session information structure) для новой сессии.
			SessionInfo *sessionInfo = new SessionInfo;
			response->pAddressSender->Duplicate( &sessionInfo->address );
			memcpy( &sessionInfo->description, response->pApplicationDescription, sizeof( DPN_APPLICATION_DESC ) );

			// Добавляем новую сессию в свзяный список сессий (session list).
			EnterCriticalSection( &network->m_sessionCS );
			network->m_sessions->Add( sessionInfo );
			LeaveCriticalSection( &network->m_sessionCS );

			break;
		}

		case DPN_MSGID_RECEIVE:
		{
			// Если нет никакого обработчика сетевых сообщений, то немедленно прерываем (break).
			if( network->HandleNetworkMessage == NULL )
				break;

			// Проверяем, разрешено ли системе поддержки сети получать сообщения, специфичные для приложения (application specific messages).
			if( network->m_receiveAllowed == false )
				break;

			// Создаём сообщение о получении сообщения.
			ReceivedMessage *message = new ReceivedMessage;
			memcpy( message, ( (PDPNMSG_RECEIVE)data )->pReceiveData, ( (PDPNMSG_RECEIVE)data )->dwReceiveDataSize );

			// Сохраняем сообщение для последующей обработки приложением.
			EnterCriticalSection( &network->m_messageCS );
			network->m_messages->Add( message );
			LeaveCriticalSection( &network->m_messageCS );

			break;
		}

		case DPN_MSGID_TERMINATE_SESSION:
		{
			// Если нет никакого обработчика сетевых сообщений, то немедленно прерываем (break).
			if( network->HandleNetworkMessage == NULL )
				break;

			// Создаём сообщение об уничтожении сессии.
			ReceivedMessage *message = new ReceivedMessage;
			message->msgid = MSGID_TERMINATE_SESSION;

			// Сохраняем сообщение для последующей обработки приложением.
			EnterCriticalSection( &network->m_messageCS );
			network->m_messages->Add( message );
			LeaveCriticalSection( &network->m_messageCS );

			break;
		}
	}

	return S_OK;
}

...
//-----------------------------------------------------------------------------
// The network class constructor.
//-----------------------------------------------------------------------------
Network::Network( GUID guid, void (*HandleNetworkMessageFunction)( ReceivedMessage *msg ) )
{
	// Иницииализируем критические секции.
	InitializeCriticalSection( &m_sessionCS );
	InitializeCriticalSection( &m_playerCS );
	InitializeCriticalSection( &m_messageCS );

	// Обнуляем пиринговый (peer) интерфейс DirectPlay и экземпляр устройства.
	m_dpp = NULL;
	m_device = NULL;

	// Сохраняем GUID приложения.
	memcpy( &m_guid, &guid, sizeof( GUID ) );

	// Создаём связный список энумеруемых сессий.
	m_sessions = new LinkedList< SessionInfo >;

	// Создаём связный список игроков.
	m_players = new LinkedList< PlayerInfo >;

	// Создаём связный список сетевых сообщений.
	m_messages = new LinkedList< ReceivedMessage >;

	// Загружаем сетевые настройки из файла NetworkSettings.txt.
	Script *settings = new Script( "NetworkSettings.txt" );
	if( settings->GetNumberData( "processing_time" ) == NULL )
	{
		m_port = 2509;
		m_sendTimeOut = 100;
		m_processingTime = 100;
	}
	else
	{
		m_port = *settings->GetNumberData( "port" );
		m_sendTimeOut = *settings->GetNumberData( "send_time_out" );
		m_processingTime = *settings->GetNumberData( "processing_time" );
	}
	SAFE_DELETE( settings );

	// Изначально системе сетевых сообщений запрещено получать сообщения, специфичные для приложения.
	m_receiveAllowed = false;

	// Устанавливаем обработчик сетевых сообщений (network message handler).
	HandleNetworkMessage = HandleNetworkMessageFunction;

	// Создаём и инициализируем пиринговый (peer) интерфейс DirectPlay.
	CoCreateInstance( CLSID_DirectPlay8Peer, NULL, CLSCTX_INPROC, IID_IDirectPlay8Peer, (void**)&m_dpp );
	m_dpp->Initialize( (PVOID)this, NetworkMessageHandler, 0 );

	// Создаём адрес устройства (device address).
	CoCreateInstance( CLSID_DirectPlay8Address, NULL, CLSCTX_INPROC, IID_IDirectPlay8Address, (LPVOID*) &m_device );
	m_device->SetSP( &CLSID_DP8SP_TCPIP );
	m_device->AddComponent( DPNA_KEY_PORT, &m_port, sizeof(DWORD), DPNA_DATATYPE_DWORD );
}
...

...
	// Создаём связный список энумеруемых сессий.
	m_sessions = new LinkedList< SessionInfo >;

	// Создаём связный список игроков.
	m_players = new LinkedList< PlayerInfo >;

	// Создаём связный список сетевых сообщений.
	m_messages = new LinkedList< ReceivedMessage >;
...

...
	// Загружаем сетевые настройки из файла NetworkSettings.txt.
	Script *settings = new Script( "NetworkSettings.txt" );
	if( settings->GetNumberData( "processing_time" ) == NULL )
	{
		m_port = 2509;
		m_sendTimeOut = 100;
		m_processingTime = 100;
	}
	else
	{
		m_port = *settings->GetNumberData( "port" );
		m_sendTimeOut = *settings->GetNumberData( "send_time_out" );
		m_processingTime = *settings->GetNumberData( "processing_time" );
	}
	SAFE_DELETE( settings );
...

...
	// Изначально системе сетевых сообщений запрещено получать сообщения, специфичные для приложения.
	m_receiveAllowed = false;

	// Устанавливаем обработчик сетевых сообщений (network message handler).
	HandleNetworkMessage = HandleNetworkMessageFunction;
...

...
	// Создаём и инициализируем пиринговый (peer) интерфейс DirectPlay.
	CoCreateInstance( CLSID_DirectPlay8Peer, NULL, CLSCTX_INPROC, IID_IDirectPlay8Peer, (void**)&m_dpp );
	m_dpp->Initialize( (PVOID)this, NetworkMessageHandler, 0 );

	// Создаём адрес устройства (device address).
	CoCreateInstance( CLSID_DirectPlay8Address, NULL, CLSCTX_INPROC, IID_IDirectPlay8Address, (LPVOID*) &m_device );
	m_device->SetSP( &CLSID_DP8SP_TCPIP );
	m_device->AddComponent( DPNA_KEY_PORT, &m_port, sizeof(DWORD), DPNA_DATATYPE_DWORD );
}
...

...
//-----------------------------------------------------------------------------
// The network class destructor.
//-----------------------------------------------------------------------------
Network::~Network()
{
	// Сохраняем сетевые настройки.
	Script *settings = new Script( "NetworkSettings.txt" );
	if( settings->GetNumberData( "processing_time" ) == NULL )
	{
		settings->AddVariable( "port", VARIABLE_NUMBER, &m_port );
		settings->AddVariable( "send_time_out", VARIABLE_NUMBER, &m_sendTimeOut );
		settings->AddVariable( "processing_time", VARIABLE_NUMBER, &m_processingTime );
	}
	else
	{
		settings->SetVariable( "port", &m_port );
		settings->SetVariable( "send_time_out", &m_sendTimeOut );
		settings->SetVariable( "processing_time", &m_processingTime );
	}
	settings->SaveScript();
	SAFE_DELETE( settings );

	// Освобождаем адрес устройства.
	SAFE_RELEASE( m_device );

	// Закрываем и освобождаем пиринговый (peer) интерфейс DirectPlay.
	if( m_dpp != NULL )
		m_dpp->Close( 0 );
	SAFE_RELEASE( m_dpp );

	// Уничтожаем связный список энумерированных сессий.
	SAFE_DELETE( m_sessions );

	// Уничтожаем связный список игроков.
	SAFE_DELETE( m_players );

	// Уничтожаем связный список сетевых сообщений.
	SAFE_DELETE( m_messages );

	// Уничтожаем критические секции.
	DeleteCriticalSection( &m_sessionCS );
	DeleteCriticalSection( &m_playerCS );
	DeleteCriticalSection( &m_messageCS );
}
...

...
//-----------------------------------------------------------------------------
// Структура информации энумерированной сессии (Enumerated Session Information Structure)
//-----------------------------------------------------------------------------
struct SessionInfo
{
	IDirectPlay8Address *address; // Session network address.
	DPN_APPLICATION_DESC description; // Application description.
};
...

typedef struct _DPN_APPLICATION_DESC {
    DWORD dwSize;		// Размер структуры
    DWORD dwFlags;		// Флаги, описывающие поведение приложения
    GUID guidInstance;	// GUID, сгенерированный во время инициализации DirectPlay
    GUID guidApplication;	// GUID приложения
    DWORD dwMaxPlayers;		// Максимальное число игроков, разрешённое в данной сессии или игре
    DWORD dwCurrentPlayers;	// Количество игроков, подключенные к сессии в данный момент
    WCHAR *pwszSessionName;	// Имя сессии
    WCHAR *pwszPassword;	// Пароль для подключения к сессии
    PVOID pvReservedData;	// Зарезервированные данные, которые не должны изменяться
    DWORD dwReservedDataSize;
    PVOID pvApplicationReservedData;	// Данные, специфичные для приложения
    DWORD dwApplicationReservedDataSize;
} DPN_APPLICATION_DESC, *PDPN_APPLICATION_DESC;

...
//-----------------------------------------------------------------------------
// Энумерируем сессии в локальной сети (LAN).
//-----------------------------------------------------------------------------
void Network::EnumerateSessions()
{
	// Очищаем связные списки.
	m_players->Empty();
	m_messages->Empty();
	m_sessions->Empty();

	// Подготавливаем описание приложения (application description).
	DPN_APPLICATION_DESC description;
	ZeroMemory( &description, sizeof( DPN_APPLICATION_DESC ) );
	description.dwSize = sizeof( DPN_APPLICATION_DESC );
	description.guidApplication = m_guid;

	// Энумерируем сессии синхронно (synchronously).
	m_dpp->EnumHosts( &description, NULL, m_device, NULL, 0, 1, 0, 0, NULL, NULL, DPNENUMHOSTS_SYNC );
}
...

HRESULT EnumHosts(      
    PDPN_APPLICATION_DESC const pApplicationDesc,
    IDirectPlay8Address *const pdpaddrHost,
    IDirectPlay8Address *const pdpaddrDeviceInfo,
    PVOID const pvUserEnumData,
    const DWORD dwUserEnumDataSize,
    const DWORD dwEnumCount,
    const DWORD dwRetryInterval,
    const DWORD dwTimeOut,
    PVOID const pvUserContext,
    HANDLE *const pAsyncHandle,
    const DWORD dwFlags
);

...
		case DPN_MSGID_ENUM_HOSTS_RESPONSE:
		{
			PDPNMSG_ENUM_HOSTS_RESPONSE response = (PDPNMSG_ENUM_HOSTS_RESPONSE)data;

			// Создаём структуру информации о сессии (session information structure) для новой сессии.
			SessionInfo *sessionInfo = new SessionInfo;
			response->pAddressSender->Duplicate( &sessionInfo->address );
			memcpy( &sessionInfo->description, response->pApplicationDescription, sizeof( DPN_APPLICATION_DESC ) );

			// Добавляем новую сессию в свзяный список сессий (session list).
			EnterCriticalSection( &network->m_sessionCS );
			network->m_sessions->Add( sessionInfo );
			LeaveCriticalSection( &network->m_sessionCS );

			break;
		}
...

...
//-----------------------------------------------------------------------------
// Пытаемся захостить (host) сессию.
//-----------------------------------------------------------------------------
bool Network::Host( char *name, char *session, int players, void *playerData, unsigned long dataSize )
{
	WCHAR wide[MAX_PATH];

	// Подготавливаем и заполняем структуру информации об игроке (player information structure).
	DPN_PLAYER_INFO player;
	ZeroMemory( &player, sizeof( DPN_PLAYER_INFO ) );
	player.dwSize = sizeof( DPN_PLAYER_INFO );
	player.pvData = playerData;
	player.dwDataSize = dataSize;
	player.dwInfoFlags = DPNINFO_NAME | DPNINFO_DATA;
	mbstowcs( wide, name, MAX_PATH );
	player.pwszName = wide;
	if( FAILED( m_dpp->SetPeerInfo( &player, NULL, NULL, DPNSETPEERINFO_SYNC ) ) )
		return false;

	// Подготавливаем описание приложения (application description).
	DPN_APPLICATION_DESC description;
	ZeroMemory( &description, sizeof( DPN_APPLICATION_DESC ) );
	description.dwSize = sizeof( DPN_APPLICATION_DESC );
	description.guidApplication = m_guid;
	description.dwMaxPlayers = players;
	mbstowcs( wide, session, MAX_PATH );
	description.pwszSessionName = wide;

	// Host the session.
	if( FAILED( m_dpp->Host( &description, &m_device, 1, NULL, NULL, NULL, 0 ) ) )
		return false;

	return true;
}
...

typedef struct _DPN_PLAYER_INFO {
    DWORD dwSize;	// Размер структуры
    DWORD dwInfoFlags;	// Идентифицирует содержимое структуры
    PWSTR pwszName;		// Имя игрока
    PVOID pvData;		// Данные, специфичные для игрока
    DWORD dwDataSize;	// Размер данных, специфичных для пользователя
    DWORD dwPlayerFlags;	// Идентифицирует гост/локальный игрок
} DPN_PLAYER_INFO, *PDPN_PLAYER_INFO;

...
	if( FAILED( m_dpp->SetPeerInfo( &player, NULL, NULL, DPNSETPEERINFO_SYNC ) ) )
		return false;
...

...
	// Подготавливаем описание приложения (application description).
	DPN_APPLICATION_DESC description;
	ZeroMemory( &description, sizeof( DPN_APPLICATION_DESC ) );
	description.dwSize = sizeof( DPN_APPLICATION_DESC );
	description.guidApplication = m_guid;
	description.dwMaxPlayers = players;
	mbstowcs( wide, session, MAX_PATH );
	description.pwszSessionName = wide;
...

typedef struct _DPN_APPLICATION_DESC {
    DWORD dwSize;
    DWORD dwFlags;
    GUID guidInstance;
    GUID guidApplication;
    DWORD dwMaxPlayers;
    DWORD dwCurrentPlayers;
    WCHAR *pwszSessionName;
    WCHAR *pwszPassword;
    PVOID pvReservedData;
    DWORD dwReservedDataSize;
    PVOID pvApplicationReservedData;
    DWORD dwApplicationReservedDataSize;
} DPN_APPLICATION_DESC, *PDPN_APPLICATION_DESC;

...
	// Host the session.
	if( FAILED( m_dpp->Host( &description, &m_device, 1, NULL, NULL, NULL, 0 ) ) )
		return false;
...

HRESULT Host(      
    const DPN_APPLICATION_DESC *const pdnAppDesc,	// Специальная структура, описывающая приложение
    IDirectPlay8Address **const prgpDeviceInfo,		// Указатель на интерфейс (Адрес устройства)
    const DWORD cDeviceInfo,				// Указывает на количество объектов
    const DPN_SECURITY_DESC *const pdpSecurity,		// Зарезервировано - NULL
    const DPN_SECURITY_CREDENTIALS *const pdpCredentials,	// Зарезервировано - NULL
    VOID *const pvPlayerContext,	// Необязательный параметр – увеличивается при присоединении клиента
    const DWORD dwFlags		// Флаг
);

...
//-----------------------------------------------------------------------------
// Пытаемся вступить (to join) в выбранную сессию из связного списка энумерированных сессий.
//-----------------------------------------------------------------------------
bool Network::Join( char *name, int session, void *playerData, unsigned long dataSize )
{
	WCHAR wide[MAX_PATH];

	// Очищаем связные списки игроков (player list) и сетевых сообщений (newtork messages).
	m_players->Empty();
	m_messages->Empty();

	// Игнорим неправильные (invalid) сессии.
	if( session < 0 )
		return false;

	// Подготавливаем и заполняем структуру информации об игроке (player information structure).
	DPN_PLAYER_INFO player;
	ZeroMemory( &player, sizeof( DPN_PLAYER_INFO ) );
	player.dwSize = sizeof( DPN_PLAYER_INFO );
	player.pvData = playerData;
	player.dwDataSize = dataSize;
	player.dwInfoFlags = DPNINFO_NAME | DPNINFO_DATA;
	mbstowcs( wide, name, MAX_PATH );
	player.pwszName = wide;
	if( FAILED( m_dpp->SetPeerInfo( &player, NULL, NULL, DPNSETPEERINFO_SYNC ) ) )
		return false;

	// Входим в критическую секцию связного списка энумерированных сессий (sessions linked list critical section).
	EnterCriticalSection( &m_sessionCS );

	// Находим хост выбранной сессии.
	m_sessions->Iterate( true );
	for( int s = 0; s < session + 1; s++ )
	{
		if( m_sessions->Iterate() ==  NULL )
		{
			LeaveCriticalSection( &m_sessionCS );
			return false;
		}
	}

	// Вступаем (join) в сессию.
	if( FAILED( m_dpp->Connect( &m_sessions->GetCurrent()->description, m_sessions->GetCurrent()->address,
		m_device, NULL, NULL, NULL, 0, NULL, NULL, NULL, DPNCONNECT_SYNC ) ) )
	{
		LeaveCriticalSection( &m_sessionCS );
		return false;
	}
	LeaveCriticalSection( &m_sessionCS );

	return true;
}
...

...
	// Очищаем связные списки игроков (player list) и сетевых сообщений (newtork messages).
	m_players->Empty();
	m_messages->Empty();nterCriticalSection( &m_sessionCS );
...

...
	// Входим в критическую секцию связного списка энумерированных сессий (sessions linked list critical section).
	EnterCriticalSection( &m_sessionCS );

	// Находим хост выбранной сессии.
	m_sessions->Iterate( true );
	for( int s = 0; s < session + 1; s++ )
	{
		if( m_sessions->Iterate() ==  NULL )
		{
			LeaveCriticalSection( &m_sessionCS );
			return false;
		}
	}

	// Вступаем (join) в сессию.
	if( FAILED( m_dpp->Connect( &m_sessions->GetCurrent()->description, m_sessions->GetCurrent()->address,
		m_device, NULL, NULL, NULL, 0, NULL, NULL, NULL, DPNCONNECT_SYNC ) ) )
	{
		LeaveCriticalSection( &m_sessionCS );
		return false;
	}
	LeaveCriticalSection( &m_sessionCS );
...

HRESULT Connect(      
    const DPN_APPLICATION_DESC *const pdnAppDesc,	// Структура, описывающая сетевое приложение
    IDirectPlay8Address *const pHostAddr,		// Адрес хоста
    IDirectPlay8Address *const pDeviceInfo,		// Адрес устройства
    const DPN_SECURITY_DESC *const pdnSecurity,	// Зарезервировано - NULL
    const DPN_SECURITY_CREDENTIALS *const pdnCredentials,	// Зарезервировано - NULL
    const void *const pvUserConnectData,// Информация о соединяющемся пользователе (Опционально - NULL)
    const DWORD dwUserConnectDataSize,	// Размер
    void *const pvPlayerContext,	// Опционально - NULL
    void *const pvAsyncContext,		// Опционально - NULL
    DPNHANDLE *const phAsyncHandle,	// Переключатель (хэндл) асинхронного выполнения
    const DWORD dwFlags		// Флаги
);

...
//-----------------------------------------------------------------------------
// Отправляет сетевое сообщение.
//-----------------------------------------------------------------------------
void Network::Send( void *data, long size, DPNID dpnid, long flags )
{
	DPNHANDLE hAsync;
	DPN_BUFFER_DESC dpbd;

	if( ( dpbd.dwBufferSize = size ) == 0 )
		return;
	dpbd.pBufferData = (BYTE*)data;

	m_dpp->SendTo( dpnid, &dpbd, 1, m_sendTimeOut, NULL, &hAsync, DPNSEND_NOCOMPLETE);
}
...

HRESULT SendTo(      
    const DPNID dpnid,
    const DPN_BUFFER_DESC *const pBufferDesc,
    const DWORD cBufferDesc,
    const DWORD dwTimeOut,
    void *const pvAsyncContext,
    DPNHANDLE *const phAsyncHandle,
    const DWORD dwFlags
);

...
//-----------------------------------------------------------------------------
// Внутренний обработчик сетевых сообщений (internal network message handler).
//-----------------------------------------------------------------------------
HRESULT WINAPI Network::NetworkMessageHandler( PVOID context, DWORD msgid, PVOID data )
{
	// Получаем указатель на вызываемый сетевой объект.
	Network *network = (Network*)context;

	// Обрабатываем входящие сообщения, основываясь на их типе.
	switch( msgid )
	{
		case DPN_MSGID_CREATE_PLAYER:
		{
			unsigned long size = 0;
			DPN_PLAYER_INFO *info = NULL;
			HRESULT hr = DPNERR_CONNECTING;
			PDPNMSG_CREATE_PLAYER msgCreatePlayer = (PDPNMSG_CREATE_PLAYER)data;

			// Создаём структуру информации об игроке (player information structure) для нового игрока.
			PlayerInfo *playerInfo = new PlayerInfo;
			ZeroMemory( playerInfo, sizeof( PlayerInfo ) );
			playerInfo->dpnid = msgCreatePlayer->dpnidPlayer;

			// Продолжаем вызывать функцию GetPeerInfo(), т.к. он всё ещё может пытаться подключиться.
			while( hr == DPNERR_CONNECTING )
				hr = network->m_dpp->GetPeerInfo( playerInfo->dpnid, info, &size, 0 );

			// Проверяем, вернула ли функция GetPeerInfo() размер структуры DPN_PLAYER_INFO.
			if( hr == DPNERR_BUFFERTOOSMALL )
			{
				info = (DPN_PLAYER_INFO*) new BYTE[size];
				ZeroMemory( info, size );
				info->dwSize = sizeof( DPN_PLAYER_INFO );

				// Пытаемся снова, используя верный размер.
				if( SUCCEEDED( network->m_dpp->GetPeerInfo( playerInfo->dpnid, info, &size, 0 ) ) )
				{
					// Сохраняем имя нового игрока.
					playerInfo->name = new char[wcslen( info->pwszName ) + 1];
					ZeroMemory( playerInfo->name, wcslen( info->pwszName ) + 1 );
					wcstombs( playerInfo->name, info->pwszName, wcslen( info->pwszName ) );

					// Сохраняем данные нового игрока.
					playerInfo->data = new BYTE[info->dwDataSize];
					memcpy( playerInfo->data, info->pvData, info->dwDataSize );
					playerInfo->size = info->dwDataSize;

					// Сохраняем остальные установки локального игркоа и хоста.
					if( info->dwPlayerFlags & DPNPLAYER_LOCAL )
						network->m_dpnidLocal = playerInfo->dpnid;
					if( info->dwPlayerFlags & DPNPLAYER_HOST )
						network->m_dpnidHost = playerInfo->dpnid;
				}

				SAFE_DELETE_ARRAY( info );
			}

			// Добавляем нового игрока в связный список игроков (player list).
			EnterCriticalSection( &network->m_playerCS );
			network->m_players->Add( playerInfo );
			LeaveCriticalSection( &network->m_playerCS );

			// Если нет никакого обработчика сетевых сообщений, то немедленно прерываем (break).
			if( network->HandleNetworkMessage == NULL )
				break;

			// Создаём сообщение игрока о создании игрока.
			ReceivedMessage *message = new ReceivedMessage;
			message->msgid = MSGID_CREATE_PLAYER;
			message->dpnid = playerInfo->dpnid;

			// Сохраняем сообщение для последующей обработки приложением.
			EnterCriticalSection( &network->m_messageCS );
			network->m_messages->Add( message );
			LeaveCriticalSection( &network->m_messageCS );

			break;
		}

		case DPN_MSGID_DESTROY_PLAYER:
		{
			// Находим игрока, уничтожаем его и убираем из связного списка игроков (player list).
			EnterCriticalSection( &network->m_playerCS );
			network->m_players->Iterate( true );
			while( network->m_players->Iterate() )
			{
				if( network->m_players->GetCurrent()->dpnid == ( (PDPNMSG_DESTROY_PLAYER)data )->dpnidPlayer )
				{
					network->m_players->Remove( (PlayerInfo**)network->m_players->GetCurrent() );
					break;
				}
			}
			LeaveCriticalSection( &network->m_playerCS );

			// Если нет никакого обработчика сетевых сообщений, то немедленно прерываем (break).
			if( network->HandleNetworkMessage == NULL )
				break;

			// Создаём сообщение игрока об уничтожении игрока.
			ReceivedMessage *message = new ReceivedMessage;
			message->msgid = MSGID_DESTROY_PLAYER;
			message->dpnid = ( (PDPNMSG_DESTROY_PLAYER)data )->dpnidPlayer;

			// Сохраняем сообщение для последующей обработки приложением.
			EnterCriticalSection( &network->m_messageCS );
			network->m_messages->Add( message );
			LeaveCriticalSection( &network->m_messageCS );

			break;
		}

		case DPN_MSGID_ENUM_HOSTS_RESPONSE:
		{
			PDPNMSG_ENUM_HOSTS_RESPONSE response = (PDPNMSG_ENUM_HOSTS_RESPONSE)data;

			// Создаём структуру информации о сессии (session information structure) для новой сессии.
			SessionInfo *sessionInfo = new SessionInfo;
			response->pAddressSender->Duplicate( &sessionInfo->address );
			memcpy( &sessionInfo->description, response->pApplicationDescription, sizeof( DPN_APPLICATION_DESC ) );

			// Добавляем новую сессию в свзяный список сессий (session list).
			EnterCriticalSection( &network->m_sessionCS );
			network->m_sessions->Add( sessionInfo );
			LeaveCriticalSection( &network->m_sessionCS );

			break;
		}

		case DPN_MSGID_RECEIVE:
		{
			// Если нет никакого обработчика сетевых сообщений, то немедленно прерываем (break).
			if( network->HandleNetworkMessage == NULL )
				break;

			// Проверяем, разрешено ли системе поддержки сети получать сообщения, специфичные для приложения (application specific messages).
			if( network->m_receiveAllowed == false )
				break;

			// Создаём сообщение о получении сообщения.
			ReceivedMessage *message = new ReceivedMessage;
			memcpy( message, ( (PDPNMSG_RECEIVE)data )->pReceiveData, ( (PDPNMSG_RECEIVE)data )->dwReceiveDataSize );

			// Сохраняем сообщение для последующей обработки приложением.
			EnterCriticalSection( &network->m_messageCS );
			network->m_messages->Add( message );
			LeaveCriticalSection( &network->m_messageCS );

			break;
		}

		case DPN_MSGID_TERMINATE_SESSION:
		{
			// Если нет никакого обработчика сетевых сообщений, то немедленно прерываем (break).
			if( network->HandleNetworkMessage == NULL )
				break;

			// Создаём сообщение об уничтожении сессии.
			ReceivedMessage *message = new ReceivedMessage;
			message->msgid = MSGID_TERMINATE_SESSION;

			// Сохраняем сообщение для последующей обработки приложением.
			EnterCriticalSection( &network->m_messageCS );
			network->m_messages->Add( message );
			LeaveCriticalSection( &network->m_messageCS );

			break;
		}
	}

	return S_OK;
}
...

...
//-----------------------------------------------------------------------------
// Обновляем (Update) объект сетевого устройства, позволяя ему обрабатывать сообщения.
//-----------------------------------------------------------------------------
void Network::Update()
{
	EnterCriticalSection( &m_messageCS );

	ReceivedMessage *message = m_messages->GetFirst();

	unsigned long endTime = timeGetTime() + m_processingTime;
	while( endTime > timeGetTime() && message != NULL )
	{
		HandleNetworkMessage( message );
		m_messages->Remove( &message );
		message = m_messages->GetFirst();
	}

	LeaveCriticalSection( &m_messageCS );
}
...

...
//-----------------------------
// Engine Includes
//-----------------------------
#include "resource.h"
#include "LinkedList.h"
#include "ResourceManagement.h"
#include "Geometry.h"
#include "Font.h"
#include "Scripting.h"
#include "DeviceEnumeration.h"
#include "Input.h"
#include "Network.h"
#include "SoundSystem.h"
#include "State.h"
...

...
//-----------------
// DirectX Includes
//-----------------
#include <d3dx9.h>
#include <dinput.h>
#include <dplay8.h>
#include <dmusici.h>
...

GUID guid;
void (*HandleNetworkMessage)( ReceivedMessage *msg );

...
struct EngineSetup
{
	HINSTANCE instance; // Application instance handle.
					// Дескриптор инстанса приложения
	GUID guid; // Application GUID.
	char *name; // Name of the application.
	void (*StateSetup)(); // Функция подготовки стейта.
	float scale; // Масштаб (scale) в метрах/футах.
	unsigned char totalBackBuffers; // Число используемых бэкбуферов.
	void (*HandleNetworkMessage)( ReceivedMessage *msg ); // Обработчик сетевых сообщений
...

GUID defaultGUID = { 0x24215591, 0х24с0, 0x4316, { 0xb5, 0хЬ2, 0x67, 0x98, 0x2с, ОхЬЗ, 0x82, 0x54 } };
HandleNetworkMessage = NULL;

...
	//-------------------------------------------------------------------------
	// The engine setup structure constructor.
	//-------------------------------------------------------------------------
	EngineSetup()
	{
		GUID defaultGUID = { 0x24215591, 0х24с0, 0x4316, { 0xb5, 0хЬ2, 0x67, 0x98, 0x2с, ОхЬЗ, 0x82, 0x54 } };
		instance = NULL;
		name = "Application";
		HandleNetworkMessage = NULL;
		scale = 1.0f;
		totalBackBuffers = 1;
		StateSetup = NULL;
	}
...

Network *m_network;

...
private:
	bool m_loaded; // Indicates if the engine is loading.
					// Флаг показывает, загружен ли движок
	HWND m_window; // Main window handle.
					// Дескриптор главного окна приложения
	bool m_deactive; // Indicates if the application is active or not.
					// Флаг активности приложения

	EngineSetup *m_setup; // Copy of the engine setup structure.
					// Копия структуры EngineSetup
	IDirect3DDevice9 *m_device;
	D3DDISPLAYMODE m_displayMode;
	ID3DXSprite *m_sprite;
	unsigned char m_currentBackBuffer;

	LinkedList< State > *m_states; // Связный список (Linked list) стейтов.
	State *m_currentState; // Указатель на текущий стейт.
	bool m_stateChanged; // Флаг показывает, изменён ли стейт в текущем кадре.
	ResourceManager< Script > *m_scriptManager; // Менеджер скриптов.
	Input *m_input;
	Network *m_network; // Объект класса Network.
	SoundSystem *m_soundSystem; // Объект класса SoundSystem.
};
...

Network *GetNetwork();

...
class Engine
{
public:
	Engine( EngineSetup *setup = NULL );
	virtual ~Engine();

	void Run();

	HWND GetWindow();
	void SetDeactiveFlag( bool deactive );
	float GetScale();
	IDirect3DDevice9 *GetDevice();
	D3DDISPLAYMODE *GetDisplayMode();
	ID3DXSprite *GetSprite();

	void AddState( State *state, bool change = true );
	void RemoveState ( State *state );
	void ChangeState( unsigned long id );
	State *GetCurrentState();
	ResourceManager< Script > *GetScriptManager();
	Input *GetInput();
	Network *GetNetwork();
	SoundSystem *GetSoundSystem();
...

m_network = new Network( m_setup->guid, m_setup->HandleNetworkMessage );

...
	// Создаём экземпляр класса Input.
	m_input = new Input( m_window );

	// Создаём экземпляр класса Network.
	m_network = new Network( m_setup->guid, m_setup->HandleNetworkMessage );

	m_soundSystem = new SoundSystem( m_setup->scale );
...

SAFE_DELETE( m_network );

...
		if( m_currentState != NULL )
		{
			// Уничтожаем связные списки со стейтами.
			m_currentState->Close();
			SAFE_DELETE( m_states );

			SAFE_DELETE( m_soundSystem );
			SAFE_DELETE( m_network );
...

m_network->Update();

...
			else if( !m_deactive )
			{
				// Calculate the elapsed time.
				// Подсчитываем затраченное время.
				unsigned long currentTime = timeGetTime();
				static unsigned long lastTime = currentTime;
				float elapsed = ( currentTime - lastTime ) / 1000.0f;
				lastTime = currentTime;

				// Обновляем объект класса Network, обрабатываем поступившие
				// пользовательские сообщения.
				m_network->Update();
				
				// Обновляем объект input, читаем ввод с клавиатуры и мыши.
				m_input->Update();
...

...
//-----------------------------------------------------------------------------
// Возвращает указатель на объект класса Network.
//-----------------------------------------------------------------------------
Network *Engine::GetNetwork()
{
	return m_network;
}
...

//-----------------------------------------------------------------------------
// System Includes
//-----------------------------------------------------------------------------
#include <windows.h>

//-----------------------------------------------------------------------------
// Engine Includes
//-----------------------------------------------------------------------------
#include "..\GameProject01\Engine.h"

//-----------------------------------------------------------------------------
// Test State Class
//-----------------------------------------------------------------------------
class TestState : public State
{
public:
	//-------------------------------------------------------------------------
	// Allows the test state to preform any pre-processing construction.
	//-------------------------------------------------------------------------
	virtual void Load()
	{
		m_font = new Font;
		m_text[0] = 0;
		m_connected = false;
	};

	//-------------------------------------------------------------------------
	// Allows the test state to preform any post-processing destruction.
	//-------------------------------------------------------------------------
	virtual void Close()
	{
		SAFE_DELETE( m_font );
	};

	//-------------------------------------------------------------------------
	// Returns the view setup details for the given frame.
	// Возвращает настройки вьюера в данном кадре.
	//-------------------------------------------------------------------------
	virtual void RequestViewer( ViewerSetup *viewer )
	{
		viewer->viewClearFlags = D3DCLEAR_TARGET;
	}

	//-------------------------------------------------------------------------
	// Updates the state.
	// Обновляем стейт
	//-------------------------------------------------------------------------
	virtual void Update( float elapsed )
	{
		// Check if the user wants to host a session.
		// Проверяем случай, когда юзер собирается хостить сессию.
		if( g_engine->GetInput()->GetKeyPress( DIK_H ) == true )
			m_connected = g_engine->GetNetwork()->Host( "host player", "session", 8 );

		// Check if the user wants to enumerate the sessions on the network.
		// Проверяем случай, когда юзер запрашивает список сессий.
		if( g_engine->GetInput()->GetKeyPress( DIK_E ) == true )
			g_engine->GetNetwork()->EnumerateSessions();

		// Check if the user wants to join the first session.
		// Проверяем случай, когда юзер хочет вступить в первую сессию.
		if( g_engine->GetInput()->GetKeyPress( DIK_1 ) == true )
			m_connected = g_engine->GetNetwork()->Join( "join player", 0 );

		// Check if the user wants to join the second session.
		// Проверяем случай, когда юзер хочет вступить во вторую сессию.
		if( g_engine->GetInput()->GetKeyPress( DIK_2 ) == true )
			m_connected = g_engine->GetNetwork()->Join( "join player", 1 );

		// Check if the user wants to join the third session.
		// Проверяем случай, когда юзер хочет вступить в третью сессию.
		if( g_engine->GetInput()->GetKeyPress( DIK_2 ) == true )
			m_connected = g_engine->GetNetwork()->Join( "join player", 2 );

		// Check if the user wants to quit.
		// Выход из приложения по нажатию Q на клавиатуре.
		if( g_engine->GetInput()->GetKeyPress( DIK_Q ) == true )
			PostQuitMessage( 0 );

		// Create the menu text.
		// Создаём текст меню.
		strcpy( m_text, "\n\n\nH - Host Session\n\nE - Enumerate Sessions" );

		// Go through the list of sessions found on the local network.
		// Перебираем (=итерируем) список сессий, найденных в локальной сети.
		char count = 0;
		char name[MAX_PATH];
		SessionInfo *session = g_engine->GetNetwork()->GetNextSession( true );
		while( session != NULL )
		{
			// Add the session count.
			// Добавляем сессию в список.
			sprintf( name, "\n   %d - ", ++count );
			strcat( m_text, name );

			// Add the session name.
			// Добавляем имя сессии.
			wcstombs( name, session->description.pwszSessionName, MAX_PATH );
			strcat( m_text, name );

			// Go to the next session.
			// Переходим к следующей сессии.
			session = g_engine->GetNetwork()->GetNextSession();
		}

		// Add the quit option to the menu text.
		// Добавляем опцию выход в текст меню.
		strcat( m_text, "\n\nQ - Quit" );

		// Add the connection status text.
		// Добавляем текст статуса соединения.
		if( m_connected == true )
		{
			if( g_engine->GetNetwork()->IsHost() == true )
				strcat( m_text, "\n\nCONNECTED - HOST" );
			else
				strcat( m_text, "\n\nCONNECTED - CLIENT" );
		}
		else
			strcat( m_text, "\n\nNOT CONNECTED" );
	};

	//-------------------------------------------------------------------------
	// Renders the state.
	// Рендерим стейт.
	//-------------------------------------------------------------------------
	virtual void Render()
	{
		m_font->Render( m_text, 0.0f, 0.0f );
	};

private:
	Font *m_font; // Font to display the menu options.
			// Шрифт для отображения опций.
	char m_text[MAX_PATH]; // Text for the menu options.
			// Текст для отображения опций.
	bool m_connected; // Indicates if the network object is connected.
			// Показывает, есть ли подключение в данный момент.
};

//-----------------------------------------------------------------------------
// Application specific state setup.
// Настройки стейта, специфичные для приложения.
//-----------------------------------------------------------------------------
void StateSetup()
{
	g_engine->AddState( new TestState, true );
}

//-----------------------------------------------------------------------------
// Entry point for the application.
// Точка входа в приложение.
//-----------------------------------------------------------------------------
int WINAPI WinMain( HINSTANCE instance, HINSTANCE prev, LPSTR cmdLine, int cmdShow )
{
	// A unique id for the test so it can be identified on a network.
	// Уникальный идентификатор для использования в сетевых подключениях.
	GUID guid = { 0x9ca7996f, 0xebb4, 0x4e9b, { 0xba, 0x6b, 0xe6, 0x4b, 0x45, 0x7f, 0x59, 0x98 } };

	// Create the engine setup structure.
	// Создаём структуру настреок движка.
	EngineSetup setup;
	setup.instance = instance;
	setup.guid = guid;
	setup.name = "Network Test";
	setup.StateSetup = StateSetup;

	// Create the engine (using the setup structure), then run it.
	// Создаём движок и запускаем его.
	new Engine( &setup );
	g_engine->Run();

	return true;
}