开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
cMultiplayer.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：29k
源码类别：

游戏

开发平台：

Visual C++

cMultiplayer.cpp：源码内容
  1. // CMAIN LIB - APPLICATION AND DIRECT WRAPPER
  2. //
  3. // Written by Mauricio Teichmann Ritter
  4. //
  5. // Copyright (C) 2002, Brazil. All rights reserved.
  6. // 
  7. //
  10. // cMultiplayer.cpp: implementation of the cMultiplayer class.
  11. //
  12. //////////////////////////////////////////////////////////////////////
  14. #include "stdafx.h"
  15. #include "cMultiplayer.h"
  17. //////////////////////////////////////////////////////////////////////
  18. // Construction/Destruction
  19. //////////////////////////////////////////////////////////////////////
  22. cMultiplayer::cMultiplayer()
  23. {
  24. m_pdnSPInfo = NULL;
  25. m_pdnDeviceInfo = NULL;
  26. m_pDP = NULL;
  27. m_pDeviceAddress = NULL;
  28. m_iSPIndex = 0;
  29. m_iSerialDevice = NULL;
  30. m_iModemDevice = NULL;
  31. m_dwTcpPort = NULL;
  32. m_dwBaudRate = NULL;
  33. m_sFlowControl[0] = NULL;
  34. m_sParity[0] = NULL;
  35. m_sStopBits[0] = NULL;
  37. m_pHostList = NULL;
  38. m_iNumHosts = 0;
  39. m_bCanConnect = TRUE;
  40. m_iPlayerType = 0;
  41. m_dpnidHost = 0;
  42. m_dpnidSelf = 0;
  43. m_pDP = NULL;
  45. m_pHandler = NULL;
  48. }
  50. cMultiplayer::~cMultiplayer()
  51. {
  53. }
  55. BOOL cMultiplayer::Initialize()
  56. {
  57. HRESULT hr;
  59. hr = CoCreateInstance( CLSID_DirectPlay8Peer, NULL, 
  60.    CLSCTX_INPROC_SERVER,
  61.    IID_IDirectPlay8Peer, 
  62.    (LPVOID*) &m_pDP);
  63. if(hr != 0)
  64. {
  65. #ifdef _DEBUG
  66. Log("HRES: %d - %sn", hr, DXGetErrorString8(hr));
  67. #endif
  68. return FALSE;
  69. }
  71. // Initialize DirectPlay
  72. hr = m_pDP->Initialize(this, StaticDirectPlayMessageHandler, 0);
  74. if(hr != 0)
  75. {
  76. #ifdef _DEBUG
  77. Log("HRES: %d - %sn", hr, DXGetErrorString8(hr));
  78. #endif
  79. return FALSE;
  80. }
  82. m_lstPlayers.clear();
  84. InitializeCriticalSection(&m_csMessages);
  86. m_dpnidSelf = 0;
  87. m_dpnidHost = 0;
  89. return TRUE;
  90. }
  92. HRESULT WINAPI cMultiplayer::StaticDirectPlayMessageHandler(
  93.   PVOID pvUserContext,
  94.   DWORD dwMessageId,
  95.   PVOID pMsgBuffer )
  96. {
  97. return ((cMultiplayer*)pvUserContext)->DirectPlayMessageHandler(pvUserContext, dwMessageId, pMsgBuffer);
  98. }
  100. HRESULT WINAPI cMultiplayer::DirectPlayMessageHandler(
  101.   PVOID pvUserContext,
  102.   DWORD dwMessageId,
  103.   PVOID pMsgBuffer )
  104. {
  106. switch( dwMessageId )
  107. {
  108. case DPN_MSGID_CREATE_PLAYER:
  109. DPNMSG_CREATE_PLAYER* pCreatePlayer;
  110. pCreatePlayer = (DPNMSG_CREATE_PLAYER*)pMsgBuffer;
  112. if(m_iPlayerType == PLAYERTYPE_HOST)
  113. {
  115. PLAYER_INFO* pPlayerInfo;
  116. pPlayerInfo = new PLAYER_INFO;
  117. pPlayerInfo->dpnidPlayer = pCreatePlayer->dpnidPlayer;
  119. PLAYERINFO_VECTOR::iterator theIterator;
  120. BOOL bAdd = TRUE;
  122. for(theIterator = m_lstPlayers.begin();theIterator != m_lstPlayers.end();theIterator++)
  123. {
  124. if( (*theIterator)->dpnidPlayer == pCreatePlayer->dpnidPlayer)
  125. bAdd = FALSE;
  126. }
  128. if(bAdd)
  129. {
  130. if(m_dpnidSelf == 0)
  131. m_dpnidSelf = pCreatePlayer->dpnidPlayer;
  132. else
  133. m_lstPlayers.push_back(pPlayerInfo);
  135. #ifdef _DEBUG
  136. Log("DPN_MSGID_CREATE_PLAYER: %dn", pCreatePlayer->dpnidPlayer);
  137. #endif
  138. }
  139. }
  140. else
  141. {
  142. if(m_dpnidSelf == 0)
  143. m_dpnidSelf = pCreatePlayer->dpnidPlayer;
  144. #ifdef _DEBUG
  145. Log("DPN_MSGID_CREATE_PLAYER SELF: %dn", m_dpnidSelf);
  146. #endif
  147. FindHost();
  148. }
  149. break;
  151. case DPN_MSGID_CONNECT_COMPLETE:
  152. DPNMSG_CONNECT_COMPLETE* pConnect;
  153. pConnect = (DPNMSG_CONNECT_COMPLETE*)pMsgBuffer;
  154. //m_iMyId = *((int*)pConnect->pvApplicationReplyData);
  155. #ifdef _DEBUG
  156. Log("DPN_MSGID_CONNECT_COMPLETEn");
  157. #endif
  158. break;
  159. case DPN_MSGID_INDICATE_CONNECT:
  160. #ifdef _DEBUG
  161. Log("DPN_MSGID_INDICATE_CONNECT: %dn", m_bCanConnect);
  162. #endif
  164. if(m_bCanConnect)
  165. return DPN_OK;
  166. else
  167. return DPNERR_GENERIC;
  168. break;
  169. case DPN_MSGID_ENUM_HOSTS_QUERY:
  170. return DPN_OK;
  171. break;
  172.     case DPN_MSGID_ENUM_HOSTS_RESPONSE:
  173.         PDPNMSG_ENUM_HOSTS_RESPONSE     pEnumHostsResponseMsg;
  174.         const DPN_APPLICATION_DESC*     pAppDesc;
  175.         HOST_NODE*                      pHostNode;
  176.         WCHAR*                          pwszSession;
  178. pwszSession = NULL;
  179. pHostNode = NULL;
  180.     
  181.         pEnumHostsResponseMsg = (PDPNMSG_ENUM_HOSTS_RESPONSE) pMsgBuffer;
  182.         pAppDesc = pEnumHostsResponseMsg->pApplicationDescription;
  183.     
  184.         // Insert each host response if it isn't already present
  185.         //EnterCriticalSection(&g_csHostList);
  187.     
  188.         for (pHostNode = m_pHostList; pHostNode; pHostNode = pHostNode->pNext)
  189.         {
  190.             if( pAppDesc->guidInstance == pHostNode->pAppDesc->guidInstance)
  191.             {
  192.                 // This host is already in the list
  193.                 pHostNode = NULL;
  194.                 goto Break_ENUM_HOSTS_RESPONSE;
  195.             }
  196.         }
  197.     
  198.         // This host session is not in the list then so insert it.
  199.         pHostNode = new HOST_NODE;
  200.         if( pHostNode == NULL)
  201.         {
  202.             goto Break_ENUM_HOSTS_RESPONSE;
  203.         }
  204.     
  205.         ZeroMemory(pHostNode, sizeof(HOST_NODE));
  206.     
  207.         // Copy the Host Address
  208.         if( FAILED( pEnumHostsResponseMsg->pAddressSender->Duplicate(&pHostNode->pHostAddress ) ) )
  209.         {
  210.             goto Break_ENUM_HOSTS_RESPONSE;
  211.         }
  212.     
  213.         pHostNode->pAppDesc = new DPN_APPLICATION_DESC;
  214.     
  215.         if( pHostNode == NULL)
  216.         {
  217.             goto Break_ENUM_HOSTS_RESPONSE;
  218.         }
  219.     
  220.         ZeroMemory(pHostNode->pAppDesc, sizeof(DPN_APPLICATION_DESC));
  221.         memcpy(pHostNode->pAppDesc, pAppDesc, sizeof(DPN_APPLICATION_DESC));
  222.     
  223.         // Null out all the pointers we aren't copying
  224.         pHostNode->pAppDesc->pwszSessionName = NULL;
  225.         pHostNode->pAppDesc->pwszPassword = NULL;
  226.         pHostNode->pAppDesc->pvReservedData = NULL;
  227.         pHostNode->pAppDesc->dwReservedDataSize = 0;
  228.         pHostNode->pAppDesc->pvApplicationReservedData = NULL;
  229.         pHostNode->pAppDesc->dwApplicationReservedDataSize = 0;
  230.     
  231. m_iNumHosts++;
  232.         if( pAppDesc->pwszSessionName)
  233.         {
  234.             pwszSession = new WCHAR[wcslen(pAppDesc->pwszSessionName) + 1];
  235.         
  236.             if( pwszSession)
  237.             {
  238.                 wcscpy(pwszSession, pAppDesc->pwszSessionName);
  239.             }
  240.         }
  241.     
  242.         pHostNode->pwszSessionName = pwszSession;
  243.     
  244.         // Insert it onto the front of the list
  245.         pHostNode->pNext = m_pHostList;// ? m_pHostList->pNext : NULL;
  246.         m_pHostList = pHostNode;
  247.         pHostNode = NULL;
  248.     
  249. Break_ENUM_HOSTS_RESPONSE:
  251.         //LeaveCriticalSection(&g_csHostList);       
  253.         if( pHostNode )
  254.         {
  255.             if(pHostNode->pHostAddress)
  256. pHostNode->pHostAddress->Release();
  258.             if(pHostNode->pAppDesc)
  259. {
  260. delete[] pHostNode->pAppDesc;
  261. }
  262.             delete pHostNode;
  263.         }
  264.         break;
  266.  case DPN_MSGID_RECEIVE:
  267.         {
  268.             PDPNMSG_RECEIVE     pMsg;
  270. PLAYER_MESSAGE* pPlayerMessage;
  271. pMsg = (PDPNMSG_RECEIVE) pMsgBuffer;
  272. //int iTmp;
  274. pPlayerMessage = (PLAYER_MESSAGE*) pMsg->pReceiveData;
  276. #ifdef _DEBUG
  277. //Log("DPN_MSGID_RECEIVE - dwSize:%d  dwDataSize: %d Type %dn", pMsg->dwSize, pMsg->dwReceiveDataSize, pPlayerMessage->m_iType);
  278. #endif
  280. if(m_pHandler)
  281. {
  282. m_pHandler->IncomingMessage(pPlayerMessage->m_iType, pMsg->dpnidSender, pMsg->pReceiveData+sizeof(int), pMsg->dwReceiveDataSize-sizeof(int));
  283. }
  284.             break;
  285.         }
  287. }
  289. return DPN_OK;
  290. }
  294. void cMultiplayer::EnumServiceProviders()
  295. {
  296. HRESULT hr;
  298.     DWORD                       dwSize          = 0;
  301.     // 确定需要的buffer大小
  302.     hr = m_pDP->EnumServiceProviders(NULL, NULL, NULL, &dwSize, &m_dwNumSP, 0);
  304. m_pdnSPInfo = (DPN_SERVICE_PROVIDER_INFO*) new BYTE[dwSize];
  305. #ifdef _DEBUG
  306. Log("SP Size: %d NumSP: %dn", dwSize, m_dwNumSP);
  307. #endif
  308.     //Fill the buffer with service provider information
  309.     hr = m_pDP->EnumServiceProviders(NULL, NULL, m_pdnSPInfo, &dwSize, &m_dwNumSP, 0);
  311. DWORD dwSp;
  313. dwSp = GetRegDWValue("ServiceProvider");
  314. if(dwSp != NULL)
  315. {
  316. int i = 0;
  317. SetRegDWValue("ServiceProvider", (DWORD) i);
  319. for(i=0;i<(int)m_dwNumSP;i++)
  320. {
  321. if(*GetSPGuid(i) == CLSID_DP8SP_TCPIP)
  322. {
  323. SetRegDWValue("ServiceProvider", (DWORD) i);
  324. m_iSPIndex = i;
  325. return;
  326. }
  327. }
  328. }
  329. else
  330. {
  331. m_iSPIndex = dwSp;
  332. }
  334. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_MODEM ||
  335.    *GetSPGuid(m_iSPIndex) == CLSID_DP8SP_SERIAL)
  336. {
  337. EnumDevices();
  338. }
  340. }
  342. void cMultiplayer::Destroy()
  343. {
  344. HRESULT hr;
  346. if(m_pdnSPInfo)
  347. delete[] m_pdnSPInfo;
  349. if(m_pdnDeviceInfo)
  350. delete[] m_pdnDeviceInfo;
  353. if(m_pDP)
  354. {
  355. hr = m_pDP->Close(0); 
  356. }
  358. if(m_pDeviceAddress)
  359. m_pDeviceAddress->Release();
  361. if(m_pDP)
  362. {
  363. m_pDP->Release();
  364. m_pDP = NULL;
  365. }
  367. if(m_pHostList)
  368. {
  369. HOST_NODE* pTmp;
  370. pTmp = m_pHostList;
  371. while(pTmp != NULL)
  372. {
  373. pTmp = m_pHostList->pNext;
  374. delete m_pHostList;
  375. m_pHostList = pTmp;
  376. }
  377. }
  379. PLAYERINFO_VECTOR::iterator theIterator;
  381. for(theIterator = m_lstPlayers.begin();theIterator != m_lstPlayers.end();theIterator++)
  382. {
  383. delete *theIterator;
  384. }
  385. m_lstPlayers.clear();
  388. PLAYERMESSAGE_ELEMENT MessageIterator;
  389. for(MessageIterator = m_lstMessages.begin();MessageIterator != m_lstMessages.end();MessageIterator++)
  390. {
  391. free( (*MessageIterator)->pReceiveData);
  392. delete *MessageIterator;
  393. }
  395. m_lstMessages.clear();
  396. }
  398. long cMultiplayer::GetNumSPs()
  399. {
  400. return m_dwNumSP;
  401. }
  403. char* cMultiplayer::GetSPName(int iIndex)
  404. {
  405. if(iIndex >= (int) m_dwNumSP)
  406. return NULL;
  408. DPN_SERVICE_PROVIDER_INFO* pSPInfoEnum;
  410. pSPInfoEnum = m_pdnSPInfo;
  412. int iTmp = 0;
  413. while(iTmp != iIndex)
  414. {
  415. pSPInfoEnum++;
  416. iTmp++;
  417. }
  419. if(pSPInfoEnum->guid == CLSID_DP8SP_MODEM)
  420. return "MODEM";
  421. if(pSPInfoEnum->guid == CLSID_DP8SP_TCPIP)
  422. return "TCP-IP NETWORK";
  423. if(pSPInfoEnum->guid == CLSID_DP8SP_IPX)
  424. return "IPX NETWORK";
  425. if(pSPInfoEnum->guid == CLSID_DP8SP_SERIAL)
  426. return "SERIAL PORT";
  428. /*case CLSID_DP8SP_TCPIP:
  429. return "TCPIP NETWORK";
  430. case CLSID_DP8SP_SERIAL:
  431. return "SERIAL PORT";*/
  433. return NULL;
  435. }
  437. GUID* cMultiplayer::GetSPGuid(int iIndex)
  438. {
  439. if(iIndex >= (int)  m_dwNumSP)
  440. return NULL;
  442. DPN_SERVICE_PROVIDER_INFO* pSPInfoEnum;
  444. pSPInfoEnum = m_pdnSPInfo;
  446. int iTmp = 0;
  447. while(iTmp != iIndex)
  448. {
  449. pSPInfoEnum++;
  450. iTmp++;
  451. }
  453. return &pSPInfoEnum->guid;
  454. }
  456. int cMultiplayer::GetNumSPOptions()
  457. {
  458. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_MODEM)
  459. return 2;
  461. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_TCPIP)
  462. return 1;
  464. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_SERIAL)
  465. return 5;
  467. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_IPX)
  468. return 1;
  470. return 0;
  471. }
  473. void cMultiplayer::NextSP()
  474. {
  475. m_iSPIndex++;
  476. if(m_iSPIndex >= (int) m_dwNumSP)
  477. m_iSPIndex = 0;
  479. SetRegDWValue("ServiceProvider", (DWORD) m_iSPIndex);
  480. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_MODEM ||
  481.    *GetSPGuid(m_iSPIndex) == CLSID_DP8SP_SERIAL)
  482. {
  483. EnumDevices();
  484. }
  485. }
  487. int cMultiplayer::GetSPIndex()
  488. {
  489. return m_iSPIndex;
  490. }
  492. void cMultiplayer::GetSPOption(int iOption, char* szBuffer, DWORD dwBufferSize)
  493. {
  494. DPN_SERVICE_PROVIDER_INFO* pDeviceInfoEnum;
  496. pDeviceInfoEnum = m_pdnDeviceInfo;
  498. int iTmp = 0;
  501. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_MODEM)
  502. {
  503. switch(iOption)
  504. {
  505. case 0:
  506. return;
  507. case 1:
  508. return;
  509. }
  510. }
  512. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_TCPIP)
  513. {
  514. switch(iOption)
  515. {
  516. case 0:
  517. if(!m_dwTcpPort)
  518. m_dwTcpPort =  GetRegDWValue("TcpIpPort");
  519. if(!m_dwTcpPort)
  520. {
  521. m_dwTcpPort = -1;
  522. SetRegDWValue("TcpIpPort", m_dwTcpPort);
  523. }
  525. if(m_dwTcpPort == -1)
  526. sprintf(szBuffer, "DEFAULT");
  527. else
  528. sprintf(szBuffer, "%d", m_dwTcpPort);
  529. break;
  530. }
  531. }
  533. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_SERIAL)
  534. {
  535. switch(iOption)
  536. {
  537. case 0:
  538. if(!m_iSerialDevice)
  539. m_iSerialDevice =  GetRegDWValue("SerialDevice");
  540. if(!m_iSerialDevice)
  541. {
  542. m_iSerialDevice = 0;
  543. SetRegDWValue("SerialDevice", m_iSerialDevice);
  544. }
  546. while(iTmp != m_iSerialDevice)
  547. {
  548. pDeviceInfoEnum++;
  549. iTmp++;
  550. }
  552. sprintf(szBuffer, "%S", pDeviceInfoEnum->pwszName);
  553. break;
  554. case 1:
  555. if(!m_dwBaudRate)
  556. m_dwBaudRate =  GetRegDWValue("BaudRate");
  557. if(!m_dwBaudRate)
  558. {
  559. m_dwBaudRate = DPNA_BAUD_RATE_9600;
  560. SetRegDWValue("BaudRate", m_dwBaudRate);
  561. }
  563. sprintf(szBuffer, "%d BPS", m_dwBaudRate);
  564. break;
  565. case 2:
  566. if(!m_sFlowControl[0])
  567. GetRegStringValue("FlowControl", m_sFlowControl, 10);
  568. if(!m_sFlowControl[0])
  569. {
  570. sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_NONE);
  571. SetRegStringValue("FlowControl", m_sFlowControl);
  572. }
  574. sprintf(szBuffer, "%s", m_sFlowControl);
  575. break;
  576. case 3:
  577. if(!m_sParity[0])
  578. GetRegStringValue("Parity", m_sParity, 10);
  579. if(!m_sParity[0])
  580. {
  581. sprintf(m_sParity, "%S", DPNA_PARITY_NONE);
  582. SetRegStringValue("Parity", m_sParity);
  583. }
  585. sprintf(szBuffer, "%s", m_sParity);
  586. break;
  587. case 4:
  588. if(!m_sStopBits[0])
  589. GetRegStringValue("StopBits", m_sStopBits, 10);
  590. if(!m_sStopBits[0])
  591. {
  592. sprintf(m_sStopBits, "%S", DPNA_STOP_BITS_ONE);
  593. SetRegStringValue("StopBits", m_sStopBits);
  594. }
  596. sprintf(szBuffer, "%s", m_sStopBits);
  597. break;
  598. }
  599. }
  601. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_IPX)
  602. {
  603. switch(iOption)
  604. {
  605. case 0:
  606. break;
  607. }
  608. }
  610. return;
  611. }
  613. char* cMultiplayer::GetSPOptionName(int iOption)
  614. {
  615. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_MODEM)
  616. {
  617. switch(iOption)
  618. {
  619. case 0:
  620. return "DEVICE";
  621. case 1:
  622. return "PHONE NUMBER";
  623. }
  624. }
  626. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_TCPIP)
  627. {
  628. switch(iOption)
  629. {
  630. case 0:
  631. return "PORT NUMBER";
  632. }
  633. }
  635. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_SERIAL)
  636. {
  637. switch(iOption)
  638. {
  639. case 0:
  640. return "DEVICE";
  641. case 1:
  642. return "BAUD RATE";
  643. case 2:
  644. return "FLOW CONTROL";
  645. case 3:
  646. return "PARITY";
  647. case 4:
  648. return "STOP BITS";
  649. }
  650. }
  652. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_IPX)
  653. {
  654. switch(iOption)
  655. {
  656. case 0:
  657. return "PORT NUMBER";
  658. }
  659. }
  661. return NULL;
  662. }
  664. int cMultiplayer::GetSPOptionType(int iOption)
  665. {
  666. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_MODEM)
  667. {
  668. switch(iOption)
  669. {
  670. case 0:
  671. return 0;
  672. case 1:
  673. return 1;
  674. }
  675. }
  677. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_TCPIP)
  678. {
  679. switch(iOption)
  680. {
  681. case 0:
  682. return 1;
  683. }
  684. }
  686. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_SERIAL)
  687. {
  688. return 0;
  689. }
  691. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_IPX)
  692. {
  693. return 1;
  694. }
  696. return 0;
  698. }
  700. void cMultiplayer::EnumDevices()
  701. {
  703. if(m_pdnDeviceInfo)
  704. delete[] m_pdnDeviceInfo;
  706. HRESULT hr;
  708.     DWORD                       dwSize          = 0;
  710.     // Determine the required buffer size
  711.     hr = m_pDP->EnumServiceProviders(GetSPGuid(m_iSPIndex), NULL, NULL, &dwSize, &m_dwNumDevices, 0);
  713. #ifdef _DEBUG
  714. Log("Devices: Size: %d NumDevices: %dn", dwSize, m_dwNumSP);
  715. #endif
  717. m_pdnDeviceInfo = (DPN_SERVICE_PROVIDER_INFO*) new BYTE[dwSize];
  718.     //Fill the buffer with service provider information
  719.     hr = m_pDP->EnumServiceProviders(GetSPGuid(m_iSPIndex), NULL, m_pdnDeviceInfo, &dwSize, &m_dwNumDevices, 0);
  721. }
  723. char* cMultiplayer::GetRegStringValue(char* lpszValueName, char* szBuffer, DWORD dwBufLen)
  724. {
  725.     HKEY hKey;
  726.     LONG lRet;
  728.     if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  729.         "SOFTWARE\RaceX",
  730.                     0,
  731.                     KEY_QUERY_VALUE,
  732.                     &hKey) != ERROR_SUCCESS)
  733. return NULL;
  735.     lRet = RegQueryValueEx(hKey,
  736.                     lpszValueName,
  737.                     NULL,
  738.                     NULL,
  739.                     (LPBYTE)szBuffer,
  740.                     &dwBufLen);
  742.     if(lRet != ERROR_SUCCESS) return NULL;
  744. RegCloseKey(hKey);
  746. return szBuffer;
  747. }
  749. DWORD cMultiplayer::GetRegDWValue(char* lpszValueName)
  750. {
  752. DWORD dwSize=sizeof(DWORD), dwValue, dwType=REG_DWORD;
  753.     HKEY hKey;
  754.     LONG lRet;
  756.     if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  757.         "SOFTWARE\RaceX",
  758.                     0,
  759.                     KEY_QUERY_VALUE,
  760.                     &hKey) != ERROR_SUCCESS)
  761. return NULL;
  764.     lRet=RegQueryValueEx(hKey,
  765.                         lpszValueName,
  766.                         0,
  767.                         &dwType,
  768.                         (LPBYTE)&dwValue,
  769.                         &dwSize );
  771. if(lRet != ERROR_SUCCESS) return NULL;
  773. RegCloseKey(hKey);
  775. return dwValue;
  776. }
  778. void cMultiplayer::SetRegDWValue(char* lpszValueName, DWORD dwValue)
  779. {
  780. DWORD dwSize=sizeof(DWORD), dwType=REG_DWORD;
  781.     HKEY hKey;
  782.     LONG lRet;
  784.     if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  785.         "SOFTWARE\RaceX",
  786.                     0,
  787.                     KEY_WRITE,
  788.                     &hKey) != ERROR_SUCCESS)
  789. {
  791. if(RegCreateKey(HKEY_LOCAL_MACHINE,
  792.         "SOFTWARE\RaceX", &hKey) != ERROR_SUCCESS)
  793. return;
  794. }
  797.     lRet=RegSetValueEx(hKey,
  798.                         lpszValueName,
  799.                         0,
  800.                         dwType,
  801.                         (LPBYTE)&dwValue,
  802.                         dwSize );
  804. if(lRet != ERROR_SUCCESS) return;
  806. RegCloseKey(hKey);
  807. return;
  808. }
  810. void cMultiplayer::SetRegStringValue(char* lpszValueName, char* lpszValue)
  811. {
  812. DWORD dwSize=sizeof(DWORD), dwType=REG_SZ;
  813.     HKEY hKey;
  814. LONG lRet;
  816.     if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
  817.         "SOFTWARE\RaceX",
  818.                     0,
  819.                     KEY_WRITE,
  820.                     &hKey) != ERROR_SUCCESS)
  821. {
  823. if(RegCreateKey(HKEY_LOCAL_MACHINE,
  824.         "SOFTWARE\RaceX", &hKey) != ERROR_SUCCESS)
  825. return;
  826. }
  828. dwSize = strlen(lpszValue) + 1;
  829.     lRet=RegSetValueEx(hKey,
  830.                         lpszValueName,
  831.                         0,
  832.                         dwType,
  833.                         (LPBYTE)lpszValue,
  834.                         dwSize );
  836. if(lRet != ERROR_SUCCESS) return;
  838. RegCloseKey(hKey);
  840. return;
  841. }
  843. void cMultiplayer::AdvanceSPOption(int iOption)
  844. {
  845. char buffer[20];
  847. int iTmp = 0;
  850. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_MODEM)
  851. {
  852. switch(iOption)
  853. {
  854. case 0:
  855. m_iModemDevice++;
  856. if(m_iModemDevice >= (int)m_dwNumDevices)
  857. m_iModemDevice = 0;
  858. SetRegDWValue("ModemDevice", (DWORD) m_iModemDevice);
  859. return;
  860. case 1:
  861. return;
  862. }
  863. }
  865. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_TCPIP)
  866. {
  867. return;
  868. }
  870. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_SERIAL)
  871. {
  872. switch(iOption)
  873. {
  874. case 0:
  875. m_iSerialDevice++;
  876. if(m_iSerialDevice >= (int)m_dwNumDevices)
  877. m_iSerialDevice = 0;
  878. SetRegDWValue("SerialDevice", (DWORD) m_iSerialDevice);
  879. break;
  880. case 1:
  881. switch(m_dwBaudRate)
  882. {
  883. case DPNA_BAUD_RATE_9600:
  884. m_dwBaudRate = DPNA_BAUD_RATE_14400;
  885. SetRegDWValue("BaudRate", m_dwBaudRate);
  886. break;
  887. case DPNA_BAUD_RATE_14400:
  888. m_dwBaudRate = DPNA_BAUD_RATE_19200;
  889. SetRegDWValue("BaudRate", m_dwBaudRate);
  890. break;
  891. case DPNA_BAUD_RATE_19200:
  892. m_dwBaudRate = DPNA_BAUD_RATE_38400;
  893. SetRegDWValue("BaudRate", m_dwBaudRate);
  894. break;
  895. case DPNA_BAUD_RATE_38400:
  896. m_dwBaudRate = DPNA_BAUD_RATE_56000;
  897. SetRegDWValue("BaudRate", m_dwBaudRate);
  898. break;
  899. case DPNA_BAUD_RATE_56000:
  900. m_dwBaudRate = DPNA_BAUD_RATE_9600;
  901. SetRegDWValue("BaudRate", m_dwBaudRate);
  902. break;
  903. }
  904. break;
  905. case 2:
  906. sprintf(buffer, "%S", DPNA_FLOW_CONTROL_NONE);
  907. if(strcmp(m_sFlowControl, buffer) == 0)
  908. {
  909. sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_DTR);
  910. SetRegStringValue("FlowControl", m_sFlowControl);
  911. break;
  912. }
  914. sprintf(buffer, "%S", DPNA_FLOW_CONTROL_DTR);
  915. if(strcmp(m_sFlowControl, buffer) == 0)
  916. {
  917. sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_XONXOFF);
  918. SetRegStringValue("FlowControl", m_sFlowControl);
  919. break;
  920. }
  922. sprintf(buffer, "%S", DPNA_FLOW_CONTROL_XONXOFF);
  923. if(strcmp(m_sFlowControl, buffer) == 0)
  924. {
  925. sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_RTSDTR);
  926. SetRegStringValue("FlowControl", m_sFlowControl);
  927. break;
  928. }
  930. sprintf(buffer, "%S", DPNA_FLOW_CONTROL_RTSDTR);
  931. if(strcmp(m_sFlowControl, buffer) == 0)
  932. {
  933. sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_RTS);
  934. SetRegStringValue("FlowControl", m_sFlowControl);
  935. break;
  936. }
  938. sprintf(buffer, "%S", DPNA_FLOW_CONTROL_RTS);
  939. if(strcmp(m_sFlowControl, buffer) == 0)
  940. {
  941. sprintf(m_sFlowControl, "%S", DPNA_FLOW_CONTROL_NONE);
  942. SetRegStringValue("FlowControl", m_sFlowControl);
  943. break;
  944. }
  945. break;
  947. case 3:
  949. sprintf(buffer, "%S", DPNA_PARITY_NONE);
  950. if(strcmp(m_sParity, buffer) == 0)
  951. {
  952. sprintf(m_sParity, "%S", DPNA_PARITY_MARK);
  953. SetRegStringValue("Parity", m_sParity);
  954. break;
  955. }
  957. sprintf(buffer, "%S", DPNA_PARITY_MARK);
  958. if(strcmp(m_sParity, buffer) == 0)
  959. {
  960. sprintf(m_sParity, "%S", DPNA_PARITY_EVEN);
  961. SetRegStringValue("Parity", m_sParity);
  962. break;
  963. }
  965. sprintf(buffer, "%S", DPNA_PARITY_EVEN);
  966. if(strcmp(m_sParity, buffer) == 0)
  967. {
  968. sprintf(m_sParity, "%S", DPNA_PARITY_SPACE);
  969. SetRegStringValue("Parity", m_sParity);
  970. break;
  971. }
  973. sprintf(buffer, "%S", DPNA_PARITY_SPACE);
  974. if(strcmp(m_sParity, buffer) == 0)
  975. {
  976. sprintf(m_sParity, "%S", DPNA_PARITY_ODD);
  977. SetRegStringValue("Parity", m_sParity);
  978. break;
  979. }
  981. sprintf(buffer, "%S", DPNA_PARITY_ODD);
  982. if(strcmp(m_sParity, buffer) == 0)
  983. {
  984. sprintf(m_sParity, "%S", DPNA_PARITY_NONE);
  985. SetRegStringValue("Parity", m_sParity);
  986. break;
  987. }
  988. break;
  989. case 4:
  991. sprintf(buffer, "%S", DPNA_STOP_BITS_ONE);
  992. if(strcmp(m_sStopBits, buffer) == 0)
  993. {
  994. sprintf(m_sStopBits, "%S", DPNA_STOP_BITS_ONE_FIVE);
  995. SetRegStringValue("StopBits", m_sStopBits);
  996. break;
  997. }
  999. sprintf(buffer, "%S", DPNA_STOP_BITS_ONE_FIVE);
  1000. if(strcmp(m_sStopBits, buffer) == 0)
  1001. {
  1002. sprintf(m_sStopBits, "%S", DPNA_STOP_BITS_TWO);
  1003. SetRegStringValue("StopBits", m_sStopBits);
  1004. break;
  1005. }
  1007. sprintf(buffer, "%S", DPNA_STOP_BITS_TWO);
  1008. if(strcmp(m_sStopBits, buffer) == 0)
  1009. {
  1010. sprintf(m_sStopBits, "%S", DPNA_STOP_BITS_ONE);
  1011. SetRegStringValue("StopBits", m_sStopBits);
  1012. break;
  1013. }
  1015. break;
  1016. }
  1017. }
  1019. if(*GetSPGuid(m_iSPIndex) == CLSID_DP8SP_IPX)
  1020. {
  1021. return;
  1022. }
  1024. }
  1026. BOOL cMultiplayer::Host(char *sSessionName)
  1027. {
  1028. m_iPlayerType =  PLAYERTYPE_HOST;
  1030. HRESULT hr;
  1031. // Create our IDirectPlay8Address Device Address
  1032. hr = CoCreateInstance( CLSID_DirectPlay8Address, NULL,
  1033.    CLSCTX_INPROC_SERVER,
  1034.    IID_IDirectPlay8Address,
  1035.    (LPVOID*) &m_pDeviceAddress ); 
  1037. if(SUCCEEDED(hr))
  1038. {
  1040. }
  1043. // Set the SP for our Device Address
  1044. hr = m_pDeviceAddress->SetSP(GetSPGuid(m_iSPIndex));
  1046.     DPN_APPLICATION_DESC    dpAppDesc;
  1048.     // Set up the application description.
  1049.     ZeroMemory(&dpAppDesc, sizeof(DPN_APPLICATION_DESC));
  1050.     dpAppDesc.dwSize = sizeof(DPN_APPLICATION_DESC);
  1051.     dpAppDesc.guidApplication = g_guidApp;
  1052. dpAppDesc.dwMaxPlayers = 4;
  1055. WCHAR wstrSessionName[MAX_PATH];
  1056. MultiByteToWideChar(CP_ACP, 0, sSessionName, 
  1057. strlen(sSessionName), 
  1058. wstrSessionName, 
  1059. MAX_PATH);
  1061. dpAppDesc.pwszSessionName = new WCHAR[wcslen(wstrSessionName)+1];
  1062. wcscpy( dpAppDesc.pwszSessionName, wstrSessionName );
  1064.     // We are now ready to host the application.
  1065.     hr = m_pDP->Host( &dpAppDesc,          // AppDesc
  1066.                       &m_pDeviceAddress, 1,// Device Address
  1067.                       NULL, NULL,              // Reserved
  1068.                       NULL,                    // Player Context
  1069.                       0);                      // dwFlags
  1072. delete[] dpAppDesc.pwszSessionName;
  1074. return TRUE;
  1075. }
  1077. BOOL cMultiplayer::EnumSessions()
  1078. {
  1079.     DPN_APPLICATION_DESC    dpAppDesc;
  1080. HRESULT hr;
  1081. HOST_NODE*              pHostNode = NULL;
  1082. WCHAR*                  pwszURL = NULL;
  1083. DWORD                   dwNumChars = 0;
  1085. // Create our IDirectPlay8Address Device Address
  1086. hr = CoCreateInstance( CLSID_DirectPlay8Address, NULL,
  1087.    CLSCTX_INPROC_SERVER,
  1088.    IID_IDirectPlay8Address,
  1089.    (LPVOID*) &m_pDeviceAddress ); 
  1090. // Set the SP for our Device Address
  1091. hr = m_pDeviceAddress->SetSP(GetSPGuid(m_iSPIndex));
  1094. // TODO: Add your control notification handler code here
  1095. ZeroMemory(&dpAppDesc, sizeof(DPN_APPLICATION_DESC));
  1096. dpAppDesc.dwSize = sizeof(DPN_APPLICATION_DESC);
  1097. dpAppDesc.guidApplication = g_guidApp;
  1099. m_iNumHosts = 0;
  1101. hr = m_pDP->EnumHosts( &dpAppDesc,  // pApplicationDesc
  1102.    NULL,  // Host Address
  1103.    m_pDeviceAddress,// Device Address
  1104.    NULL, 0,   // pvUserEnumData, size
  1105.    4,         // dwEnumCount
  1106.    0,         // dwRetryInterval
  1107.    0,         // dwTimeOut
  1108.    NULL,      // pvUserContext
  1109.    NULL,      // pAsyncHandle
  1110.    DPNENUMHOSTS_SYNC); // dwFlags
  1113. return TRUE;
  1114. }
  1116. int cMultiplayer::GetNumSessions()
  1117. {
  1118. return m_iNumHosts;
  1119. }
  1121. void cMultiplayer::GetSessionName(int iIndex, char *sValue, int iSize)
  1122. {
  1123. HOST_NODE*              pHostNode = NULL;
  1125. pHostNode = m_pHostList;
  1126. for(int i=0;i<iIndex;i++)
  1127. {
  1128. pHostNode = pHostNode->pNext;
  1129. }
  1131. sprintf(sValue, "%S", pHostNode->pwszSessionName);
  1133. return;
  1134. }
  1136. void cMultiplayer::SetCanConnect(BOOL bValue)
  1137. {
  1138. m_bCanConnect = bValue;
  1139. }
  1141. BOOL cMultiplayer::GetCanConnect()
  1142. {
  1143. return m_bCanConnect;
  1144. }
  1146. void cMultiplayer::Connect(int iHost)
  1147. {
  1148. // TODO: Add your control notification handler code here
  1149.     DPN_APPLICATION_DESC        dpnAppDesc;
  1150.     IDirectPlay8Address*        pHostAddress = NULL;
  1151. HRESULT hr;
  1152. HOST_NODE*              pHostNode = NULL;
  1154. m_iPlayerType =  PLAYERTYPE_PEER;
  1155. m_dpnidSelf = 0;
  1157.     ZeroMemory(&dpnAppDesc, sizeof(DPN_APPLICATION_DESC));
  1158.     dpnAppDesc.dwSize = sizeof(DPN_APPLICATION_DESC);
  1159.     dpnAppDesc.guidApplication = g_guidApp;
  1161. pHostNode = m_pHostList;
  1162. for(int i=0;i<iHost;i++)
  1163. {
  1164. pHostNode = pHostNode->pNext;
  1165. }
  1167.     hr = pHostNode->pHostAddress->Duplicate(&pHostAddress);
  1169.     hr = m_pDP->Connect(&dpnAppDesc,    // Application Description
  1170.                         pHostAddress,       // Host Address
  1171.                         m_pDeviceAddress,   
  1172.                         NULL,  
  1173.                         NULL,
  1174.                         NULL, 0, 
  1175.                         NULL, 
  1176.                         NULL,
  1177.                         NULL, 
  1178.                         DPNCONNECT_SYNC);
  1180. pHostAddress->Release();
  1183. }
  1185. BOOL cMultiplayer::IsHosting()
  1186. {
  1187. if(m_iPlayerType == PLAYERTYPE_HOST)
  1188. return TRUE;
  1189. else
  1190. return FALSE;
  1191. }
  1193. int cMultiplayer::GetNumConnected()
  1194. {
  1195. return m_lstPlayers.size();
  1196. }
  1198. PLAYER_INFO* cMultiplayer::GetPlayerInfo(int iIndex)
  1199. {
  1200. return m_lstPlayers[iIndex];
  1201. }
  1203. void cMultiplayer::SendTo(DPNID dpnidTarget, int iType, LPBYTE lpBuffer, DWORD dwSize, DWORD dwFlags)
  1204. {
  1205.     DPNHANDLE       hAsync;
  1206.     DPNHANDLE*      phAsync;
  1208.     DPN_BUFFER_DESC dpnBuffer;
  1209. HRESULT hr;
  1211. LPBYTE pTmpBuffer;
  1212. pTmpBuffer = (LPBYTE) malloc(sizeof(int) + dwSize);
  1213. memcpy(pTmpBuffer, &iType, sizeof(int));
  1214. memcpy(pTmpBuffer+sizeof(int), lpBuffer, dwSize);
  1216.     dpnBuffer.pBufferData = pTmpBuffer;
  1217.     dpnBuffer.dwBufferSize = sizeof(int) + dwSize;
  1219. if(dwFlags & DPNSEND_SYNC)
  1220. phAsync = NULL;
  1221. else
  1222. phAsync = &hAsync;
  1224.     hr = m_pDP->SendTo( dpnidTarget, // dpnid
  1225.                                     &dpnBuffer,  // pBufferDesc
  1226.                                     1,           // cBufferDesc
  1227.                                     0,           // dwTimeOut
  1228.                                     NULL,        // pvAsyncContext
  1229.                                     phAsync,        // pvAsyncHandle
  1230.                                     dwFlags );    // dwFlags
  1232. free(pTmpBuffer);
  1233. }
  1235. int cMultiplayer::GetNumMessages()
  1236. {
  1237. DWORD dwTemp;
  1239. dwTemp = m_lstMessages.size();
  1240. return dwTemp;
  1241. }
  1243. PLAYER_MESSAGE* cMultiplayer::GetMessage(int iIndex)
  1244. {
  1245. PLAYERMESSAGE_ELEMENT theIterator;
  1247. EnterCriticalSection(&m_csMessages);
  1248. theIterator = m_lstMessages.begin();
  1249. for(int i=0;i<iIndex;i++)
  1250. theIterator++;
  1251. return (*theIterator);
  1252. }
  1254. void cMultiplayer::RemoveMessage(PLAYER_MESSAGE *pMessage)
  1255. {
  1256. free(pMessage->pReceiveData);
  1257. m_lstMessages.remove(pMessage);
  1258. delete pMessage;
  1259. }
  1261. int cMultiplayer::GetHost()
  1262. {
  1263. return m_dpnidHost;
  1264. }
  1266. void cMultiplayer::FindHost()
  1267. {
  1268. DWORD dwSize = NULL, dwSize2 = NULL;
  1269. DPNID* pDPNIDs = NULL;
  1270. DPN_PLAYER_INFO *pPlayerInfo = NULL;
  1272. m_pDP->EnumPlayersAndGroups(pDPNIDs, &dwSize, DPNENUM_PLAYERS);
  1273. pDPNIDs = (DPNID*)malloc(dwSize * sizeof(DPNID));
  1274. m_pDP->EnumPlayersAndGroups(pDPNIDs, &dwSize, DPNENUM_PLAYERS);
  1276. for(int i=0;i<dwSize;i++)
  1277. {
  1278. dwSize2 = NULL;
  1279. m_pDP->GetPeerInfo(pDPNIDs[i], pPlayerInfo, &dwSize2, 0);
  1280. pPlayerInfo = (DPN_PLAYER_INFO*) malloc(dwSize2);
  1281. m_pDP->GetPeerInfo(pDPNIDs[i], pPlayerInfo, &dwSize2, 0);
  1282. if(pPlayerInfo->dwPlayerFlags & DPNPLAYER_HOST)
  1283. {
  1284. m_dpnidHost = pDPNIDs[i];
  1285. free(pPlayerInfo);
  1286. break;
  1287. }
  1288. free(pPlayerInfo);
  1289. }
  1291. free(pDPNIDs);
  1293. #ifdef _DEBUG
  1294. Log("FIND HOST: %dn", m_dpnidHost);
  1295. #endif
  1297. }
  1299. int cMultiplayer::GetMyId()
  1300. {
  1301. return m_dpnidSelf;
  1302. }
  1304. void cMultiplayer::ReleaseMessage()
  1305. {
  1306. #ifdef _DEBUG
  1307. //Log("LEAVING CRITICAL SECTIONn");
  1308. #endif
  1309. LeaveCriticalSection(&m_csMessages);
  1310. }
  1312. void cMultiplayer::SetHandler(cMessageHandler *pHandler)
  1313. {
  1314. m_pHandler = pHandler;
  1315. }