cmultiplayer.cpp

一个2D的赛车游戏 在VC下运行 开发库DIRECTX8.1以上

	}

	return NULL;
}

int cMultiplayer::GetSPOptionType(int iOption)
{
	if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_MODEM)
	{
		switch(iOption)
		{
		case 0:
			return 0;
		case 1:
			return 1;
		}
	}

	if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_TCPIP)
	{
		switch(iOption)
		{
		case 0:
			return 1;
		}
	}

	if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_SERIAL)
	{
		return 0;
	}

	if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_IPX)
	{
		return 1;
	}

	return 0;

}

void cMultiplayer::EnumDevices()
{

	if(m_pdnDeviceInfo)
		delete[] m_pdnDeviceInfo;
	
	HRESULT	hr;

    DWORD                       dwSize          = 0;

    // Determine the required buffer size
    hr = m_pDP->EnumServiceProviders(GetSPGuid(m_iSPIndex), NULL, NULL, &dwSize, &m_dwNumDevices, 0);

#ifdef _DEBUG
	Log("Devices: Size: %d NumDevices: %d\n", dwSize, m_dwNumSP);
#endif

	m_pdnDeviceInfo = (DPN_SERVICE_PROVIDER_INFO*) new BYTE[dwSize];
    //Fill the buffer with service provider information
    hr = m_pDP->EnumServiceProviders(GetSPGuid(m_iSPIndex), NULL, m_pdnDeviceInfo, &dwSize, &m_dwNumDevices, 0);

}

char* cMultiplayer::GetRegStringValue(char* lpszValueName, char* szBuffer, DWORD dwBufLen)
{
    HKEY hKey;
    LONG lRet;

    if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\RaceX",
                    0,
                    KEY_QUERY_VALUE,
                    &hKey) != ERROR_SUCCESS)
		return NULL;

    lRet = RegQueryValueEx(hKey,
                    lpszValueName,
                    NULL,
                    NULL,
                    (LPBYTE)szBuffer,
                    &dwBufLen);

    if(lRet != ERROR_SUCCESS) return NULL;

	RegCloseKey(hKey);

	return szBuffer;
}

DWORD cMultiplayer::GetRegDWValue(char* lpszValueName)
{

	DWORD dwSize=sizeof(DWORD), dwValue, dwType=REG_DWORD;
    HKEY hKey;
    LONG lRet;

    if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\RaceX",
                    0,
                    KEY_QUERY_VALUE,
                    &hKey) != ERROR_SUCCESS)
		return NULL;


    lRet=RegQueryValueEx(hKey,
                        lpszValueName,
                        0,
                        &dwType,
                        (LPBYTE)&dwValue,
                        &dwSize );

	if(lRet != ERROR_SUCCESS) return NULL;

	RegCloseKey(hKey);

	return dwValue;
}

void cMultiplayer::SetRegDWValue(char* lpszValueName, DWORD dwValue)
{
	DWORD dwSize=sizeof(DWORD), dwType=REG_DWORD;
    HKEY hKey;
    LONG lRet;

    if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\RaceX",
                    0,
                    KEY_WRITE,
                    &hKey) != ERROR_SUCCESS)
	{

		if(RegCreateKey(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\RaceX", &hKey) != ERROR_SUCCESS)
			return;
	}


    lRet=RegSetValueEx(hKey,
                        lpszValueName,
                        0,
                        dwType,
                        (LPBYTE)&dwValue,
                        dwSize );

	if(lRet != ERROR_SUCCESS) return;

	RegCloseKey(hKey);
	return;
}

void cMultiplayer::SetRegStringValue(char* lpszValueName, char* lpszValue)
{
	DWORD dwSize=sizeof(DWORD), dwType=REG_SZ;
    HKEY hKey;
	LONG lRet;

    if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\RaceX",
                    0,
                    KEY_WRITE,
                    &hKey) != ERROR_SUCCESS)
	{

		if(RegCreateKey(HKEY_LOCAL_MACHINE,
        "SOFTWARE\\RaceX", &hKey) != ERROR_SUCCESS)
			return;
	}

	dwSize = strlen(lpszValue) + 1;
    lRet=RegSetValueEx(hKey,
                        lpszValueName,
                        0,
                        dwType,
                        (LPBYTE)lpszValue,
                        dwSize );

	if(lRet != ERROR_SUCCESS) return;

	RegCloseKey(hKey);

	return;
}

void cMultiplayer::AdvanceSPOption(int iOption)
{
	char	buffer[20];

	int	iTmp = 0;


	if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_MODEM)
	{
		switch(iOption)
		{
		case 0:
			m_iModemDevice++;
			if(m_iModemDevice >= (int)m_dwNumDevices)
				m_iModemDevice = 0;
			SetRegDWValue("ModemDevice", (DWORD) m_iModemDevice);
			return;
		case 1:
			return;
		}
	}

	if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_TCPIP)
	{
		return;
	}

	if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_SERIAL)
	{
		switch(iOption)
		{
		case 0:
			m_iSerialDevice++;
			if(m_iSerialDevice >= (int)m_dwNumDevices)
				m_iSerialDevice = 0;
			SetRegDWValue("SerialDevice", (DWORD) m_iSerialDevice);
			break;
		case 1:
			switch(m_dwBaudRate)
			{
			case DPNA_BAUD_RATE_9600:
				m_dwBaudRate = DPNA_BAUD_RATE_14400;
				SetRegDWValue("BaudRate", m_dwBaudRate);
				break;
			case DPNA_BAUD_RATE_14400:
				m_dwBaudRate = DPNA_BAUD_RATE_19200;
				SetRegDWValue("BaudRate", m_dwBaudRate);
				break;
			case DPNA_BAUD_RATE_19200:
				m_dwBaudRate = DPNA_BAUD_RATE_38400;
				SetRegDWValue("BaudRate", m_dwBaudRate);
				break;
			case DPNA_BAUD_RATE_38400:
				m_dwBaudRate = DPNA_BAUD_RATE_56000;
				SetRegDWValue("BaudRate", m_dwBaudRate);
				break;
			case DPNA_BAUD_RATE_56000:
				m_dwBaudRate = DPNA_BAUD_RATE_9600;
				SetRegDWValue("BaudRate", m_dwBaudRate);
				break;
			}
			break;
		case 2:
			sprintf(buffer, "%S", DPNA_FLOW_CONTROL_NONE);
			if(strcmp(m_sFlowControl, buffer) == 0)
			{
				sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_DTR);
				SetRegStringValue("FlowControl", m_sFlowControl);
				break;
			}

			sprintf(buffer, "%S", DPNA_FLOW_CONTROL_DTR);
			if(strcmp(m_sFlowControl, buffer) == 0)
			{
				sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_XONXOFF);
				SetRegStringValue("FlowControl", m_sFlowControl);
				break;
			}

			sprintf(buffer, "%S", DPNA_FLOW_CONTROL_XONXOFF);
			if(strcmp(m_sFlowControl, buffer) == 0)
			{
				sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_RTSDTR);
				SetRegStringValue("FlowControl", m_sFlowControl);
				break;
			}

			sprintf(buffer, "%S", DPNA_FLOW_CONTROL_RTSDTR);
			if(strcmp(m_sFlowControl, buffer) == 0)
			{
				sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_RTS);
				SetRegStringValue("FlowControl", m_sFlowControl);
				break;
			}

			sprintf(buffer, "%S", DPNA_FLOW_CONTROL_RTS);
			if(strcmp(m_sFlowControl, buffer) == 0)
			{
				sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_NONE);
				SetRegStringValue("FlowControl", m_sFlowControl);
				break;
			}
			break;

		case 3:

			sprintf(buffer, "%S", DPNA_PARITY_NONE);
			if(strcmp(m_sParity, buffer) == 0)
			{
				sprintf(m_sParity, "%S", DPNA_PARITY_MARK);
				SetRegStringValue("Parity", m_sParity);
				break;
			}

			sprintf(buffer, "%S", DPNA_PARITY_MARK);
			if(strcmp(m_sParity, buffer) == 0)
			{
				sprintf(m_sParity, "%S", DPNA_PARITY_EVEN);
				SetRegStringValue("Parity", m_sParity);
				break;
			}

			sprintf(buffer, "%S", DPNA_PARITY_EVEN);
			if(strcmp(m_sParity, buffer) == 0)
			{
				sprintf(m_sParity, "%S", DPNA_PARITY_SPACE);
				SetRegStringValue("Parity", m_sParity);
				break;
			}

			sprintf(buffer, "%S", DPNA_PARITY_SPACE);
			if(strcmp(m_sParity, buffer) == 0)
			{
				sprintf(m_sParity, "%S", DPNA_PARITY_ODD);
				SetRegStringValue("Parity", m_sParity);
				break;
			}

			sprintf(buffer, "%S", DPNA_PARITY_ODD);
			if(strcmp(m_sParity, buffer) == 0)
			{
				sprintf(m_sParity, "%S", DPNA_PARITY_NONE);
				SetRegStringValue("Parity", m_sParity);
				break;
			}
			break;
		case 4:

			sprintf(buffer, "%S", DPNA_STOP_BITS_ONE);
			if(strcmp(m_sStopBits, buffer) == 0)
			{
				sprintf(m_sStopBits, "%S", DPNA_STOP_BITS_ONE_FIVE);
				SetRegStringValue("StopBits", m_sStopBits);
				break;
			}

			sprintf(buffer, "%S", DPNA_STOP_BITS_ONE_FIVE);
			if(strcmp(m_sStopBits, buffer) == 0)
			{
				sprintf(m_sStopBits, "%S", DPNA_STOP_BITS_TWO);
				SetRegStringValue("StopBits", m_sStopBits);
				break;
			}

			sprintf(buffer, "%S", DPNA_STOP_BITS_TWO);
			if(strcmp(m_sStopBits, buffer) == 0)
			{
				sprintf(m_sStopBits, "%S", DPNA_STOP_BITS_ONE);
				SetRegStringValue("StopBits", m_sStopBits);
				break;
			}

			break;
		}
	}

	if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_IPX)
	{
		return;
	}

}

BOOL cMultiplayer::Host(char *sSessionName)
{
	m_iPlayerType =  PLAYERTYPE_HOST;

	HRESULT	hr;
	// Create our IDirectPlay8Address Device Address
	hr = CoCreateInstance( CLSID_DirectPlay8Address, NULL,
									   CLSCTX_INPROC_SERVER,
									   IID_IDirectPlay8Address,
									   (LPVOID*) &m_pDeviceAddress ); 
	
	if(SUCCEEDED(hr))
	{

	}
	

	// Set the SP for our Device Address
	hr = m_pDeviceAddress->SetSP(GetSPGuid(m_iSPIndex));

    DPN_APPLICATION_DESC    dpAppDesc;

    // Set up the application description.
    ZeroMemory(&dpAppDesc, sizeof(DPN_APPLICATION_DESC));
    dpAppDesc.dwSize = sizeof(DPN_APPLICATION_DESC);
    dpAppDesc.guidApplication = g_guidApp;
	dpAppDesc.dwMaxPlayers = 4;


	WCHAR wstrSessionName[MAX_PATH];
	MultiByteToWideChar(CP_ACP, 0, sSessionName, 
		strlen(sSessionName), 
		wstrSessionName, 
		MAX_PATH);

	dpAppDesc.pwszSessionName = new WCHAR[wcslen(wstrSessionName)+1];
	wcscpy( dpAppDesc.pwszSessionName, wstrSessionName );

    // We are now ready to host the application.
    hr = m_pDP->Host( &dpAppDesc,          // AppDesc
                      &m_pDeviceAddress, 1,// Device Address
                      NULL, NULL,              // Reserved
                      NULL,                    // Player Context
                      0);                      // dwFlags


	delete[] dpAppDesc.pwszSessionName;

	return TRUE;
}

BOOL cMultiplayer::EnumSessions()
{
    DPN_APPLICATION_DESC    dpAppDesc;
	HRESULT					hr;
	HOST_NODE*              pHostNode = NULL;
	WCHAR*                  pwszURL = NULL;
	DWORD                   dwNumChars = 0;

	// Create our IDirectPlay8Address Device Address
	hr = CoCreateInstance( CLSID_DirectPlay8Address, NULL,
									   CLSCTX_INPROC_SERVER,
									   IID_IDirectPlay8Address,
									   (LPVOID*) &m_pDeviceAddress ); 
	// Set the SP for our Device Address
	hr = m_pDeviceAddress->SetSP(GetSPGuid(m_iSPIndex));


	// TODO: Add your control notification handler code here
	ZeroMemory(&dpAppDesc, sizeof(DPN_APPLICATION_DESC));
	dpAppDesc.dwSize = sizeof(DPN_APPLICATION_DESC);
	dpAppDesc.guidApplication = g_guidApp;
	
	m_iNumHosts = 0;

	hr = m_pDP->EnumHosts( &dpAppDesc,  // pApplicationDesc
									   NULL,  // Host Address
									   m_pDeviceAddress,// Device Address
									   NULL, 0,   // pvUserEnumData, size
									   4,         // dwEnumCount
									   0,         // dwRetryInterval
									   0,         // dwTimeOut
									   NULL,      // pvUserContext
									   NULL,      // pAsyncHandle
									   DPNENUMHOSTS_SYNC); // dwFlags

	
	return TRUE;
}

int cMultiplayer::GetNumSessions()
{
	return m_iNumHosts;
}

void cMultiplayer::GetSessionName(int iIndex, char *sValue, int iSize)
{
	HOST_NODE*              pHostNode = NULL;

	pHostNode = m_pHostList;
	for(int i=0;i<iIndex;i++)
	{
		pHostNode = pHostNode->pNext;
	}

	sprintf(sValue, "%S", pHostNode->pwszSessionName);

	return;
}

void cMultiplayer::SetCanConnect(BOOL bValue)
{
	m_bCanConnect = bValue;
}

BOOL cMultiplayer::GetCanConnect()
{
	return m_bCanConnect;
}

void cMultiplayer::Connect(int iHost)
{
	// TODO: Add your control notification handler code here
    DPN_APPLICATION_DESC        dpnAppDesc;
    IDirectPlay8Address*        pHostAddress = NULL;
	HRESULT						hr;
	HOST_NODE*              pHostNode = NULL;

	m_iPlayerType =  PLAYERTYPE_PEER;
	m_dpnidSelf = 0;

    ZeroMemory(&dpnAppDesc, sizeof(DPN_APPLICATION_DESC));
    dpnAppDesc.dwSize = sizeof(DPN_APPLICATION_DESC);
    dpnAppDesc.guidApplication = g_guidApp;

	pHostNode = m_pHostList;
	for(int i=0;i<iHost;i++)
	{
		pHostNode = pHostNode->pNext;
	}

    hr = pHostNode->pHostAddress->Duplicate(&pHostAddress);

    hr = m_pDP->Connect(&dpnAppDesc,    // Application Description
                        pHostAddress,       // Host Address
                        m_pDeviceAddress,   
                        NULL,  
                        NULL,
                        NULL, 0, 
                        NULL, 
                        NULL,
                        NULL, 
                        DPNCONNECT_SYNC);

	pHostAddress->Release();


}

BOOL cMultiplayer::IsHosting()
{
	if(m_iPlayerType == PLAYERTYPE_HOST)
		return TRUE;
	else
		return FALSE;
}

int cMultiplayer::GetNumConnected()
{
	return m_lstPlayers.size();
}

PLAYER_INFO* cMultiplayer::GetPlayerInfo(int iIndex)
{
	return m_lstPlayers[iIndex];
}

void cMultiplayer::SendTo(DPNID dpnidTarget, int iType, LPBYTE lpBuffer, DWORD dwSize, DWORD dwFlags)
{
    DPNHANDLE       hAsync;
    DPNHANDLE*      phAsync;

    DPN_BUFFER_DESC dpnBuffer;
	HRESULT			hr;

	LPBYTE	pTmpBuffer;
	pTmpBuffer = (LPBYTE) malloc(sizeof(int) + dwSize);
	memcpy(pTmpBuffer, &iType, sizeof(int));
	memcpy(pTmpBuffer+sizeof(int), lpBuffer, dwSize);

    dpnBuffer.pBufferData = pTmpBuffer;
    dpnBuffer.dwBufferSize = sizeof(int) + dwSize;

	if(dwFlags & DPNSEND_SYNC)
		phAsync = NULL;
	else
		phAsync = &hAsync;

    hr = m_pDP->SendTo( dpnidTarget, // dpnid
                                    &dpnBuffer,  // pBufferDesc
                                    1,           // cBufferDesc
                                    0,           // dwTimeOut
                                    NULL,        // pvAsyncContext
                                    phAsync,        // pvAsyncHandle
                                    dwFlags );    // dwFlags

	free(pTmpBuffer);
}

int cMultiplayer::GetNumMessages()
{
	DWORD	dwTemp;

	dwTemp = m_lstMessages.size();
	return dwTemp;
}

PLAYER_MESSAGE* cMultiplayer::GetMessage(int iIndex)
{
	PLAYERMESSAGE_ELEMENT	theIterator;

	EnterCriticalSection(&m_csMessages);
	theIterator = m_lstMessages.begin();
	for(int i=0;i<iIndex;i++)
		theIterator++;
	return (*theIterator);
}

void cMultiplayer::RemoveMessage(PLAYER_MESSAGE *pMessage)
{
	free(pMessage->pReceiveData);
	m_lstMessages.remove(pMessage);
	delete pMessage;
}

int cMultiplayer::GetHost()
{
	return m_dpnidHost;
}

void cMultiplayer::FindHost()
{
	DWORD dwSize = NULL, dwSize2 = NULL;
	DPNID* pDPNIDs = NULL;
	DPN_PLAYER_INFO *pPlayerInfo = NULL;

	m_pDP->EnumPlayersAndGroups(pDPNIDs, &dwSize, DPNENUM_PLAYERS);
	pDPNIDs = (DPNID*)malloc(dwSize * sizeof(DPNID));
	m_pDP->EnumPlayersAndGroups(pDPNIDs, &dwSize, DPNENUM_PLAYERS);

	for(int i=0;i<dwSize;i++)
	{
		dwSize2 = NULL;
		m_pDP->GetPeerInfo(pDPNIDs[i], pPlayerInfo, &dwSize2, 0);
		pPlayerInfo = (DPN_PLAYER_INFO*) malloc(dwSize2);
		m_pDP->GetPeerInfo(pDPNIDs[i], pPlayerInfo, &dwSize2, 0);
		if(pPlayerInfo->dwPlayerFlags & DPNPLAYER_HOST)
		{
			m_dpnidHost = pDPNIDs[i];
			free(pPlayerInfo);
			break;
		}
		free(pPlayerInfo);
	}

	free(pDPNIDs);

#ifdef _DEBUG
	Log("FIND HOST: %d\n", m_dpnidHost);
#endif

}

int cMultiplayer::GetMyId()
{
	return m_dpnidSelf;
}

void cMultiplayer::ReleaseMessage()
{
#ifdef _DEBUG
	//Log("LEAVING CRITICAL SECTION\n");
#endif
	LeaveCriticalSection(&m_csMessages);
}

void cMultiplayer::SetHandler(cMessageHandler *pHandler)
{
	m_pHandler = pHandler;
}