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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
SERVER.CPP
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：14k
源码类别：

Windows编程

开发平台：

Visual C++

SERVER.CPP：源码内容
  1. /*==========================================================================
  2.  *
  3.  *  Copyright (C) 1997 Microsoft Corporation.  All Rights Reserved.
  4.  *
  5.  *  File:       server.cpp
  6.  *  Content: Slot machine server using DirectPlay.
  7.  *
  8.  ***************************************************************************/
  10. #include <windows.h>
  11. #include <windowsx.h>
  12. #include <stdio.h>
  14. #include "dpslots.h"
  15. #include "resource.h"
  17. // constants
  18. const UINT MAX_RECORD_LENGTH = 256; // max database record size
  19. const DWORD INDEX_JACKPOT = 3; // index of jackpot image
  20. const DWORD INDEX_SPOILER = 5; // index of spoiler image
  22. // window messages
  23. const UINT WM_USER_ADDSTRING = WM_USER + 257; // add string to log window
  25. // structures
  26. typedef struct {
  27. DWORD dwBalance; // account record from database
  28. } ACCOUNTINFO, *LPACCOUNTINFO;
  30. // globals
  31. HWND ghServerWnd = NULL; // main window
  32. FILE *glpFile = NULL; // database file
  34. // prototypes
  35. HRESULT HandleBalanceRequest(LPDPLAYINFO lpDPInfo, LPMSG_BALANCEREQUEST lpBalance, DPID idTo);
  36. HRESULT HandleSpinRequest(LPDPLAYINFO lpDPInfo, LPMSG_SPINREQUEST lpBalance, DPID idTo);
  37. void LogRequest(LPSTR lpszFormat, LPDPACCOUNTDESC lpAccountDesc, DWORD dwValue);
  38. LONG GetAmountWonOrLost(DWORD dwAmountBet, DWORD dwIndex[]);
  39. FILE* OpenAccountDB(LPSTR lpszDBName);
  40. void CloseAccountDB(FILE *lpFile);
  41. BOOL QueryAccount(FILE *lpFile, LPSTR lpszAccountID, LPACCOUNTINFO lpAccountInfo);
  42. BOOL UpdateAccount(FILE *lpFile, LPSTR lpszAccountID, LPACCOUNTINFO lpAccountInfo);
  43. HRESULT GetAccountDesc(LPDPLAYINFO lpDPInfo, DPID idPlayer, LPDPACCOUNTDESC *lplpAccountDesc);
  45. BOOL CALLBACK ServerWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  46. {
  47. static LPDPLAYINFO lpDPInfo = NULL;
  48. static UINT idTimer = 0;
  49. static FILE *lpFile = NULL;
  50. DWORD dwTextLen;
  52.     switch(uMsg)
  53.     {
  54.     case WM_INITDIALOG:
  55.         // save the connection info pointer
  56.         lpDPInfo = (LPDPLAYINFO) lParam;
  58. // store global window
  59. ghServerWnd = hWnd;
  61. // open account database
  62. glpFile = OpenAccountDB(gszDatabaseName);
  63. break;
  65.     case WM_DESTROY:
  66. // stop the timer
  67. if (idTimer)
  68. {
  69. KillTimer(hWnd, idTimer); 
  70. idTimer = 0;
  71. }
  73. // close account database
  74. if (glpFile)
  75. CloseAccountDB(glpFile);
  77. ghServerWnd = NULL;
  78.         break;
  80. // this is a user-defined message used to add strings to the log window
  81. case WM_USER_ADDSTRING:
  82. // get length of text in log window
  83. dwTextLen = SendDlgItemMessage(hWnd, IDC_LOGEDIT, WM_GETTEXTLENGTH,
  84.    (WPARAM) 0, (LPARAM) 0);
  86. // put selection at end
  87. dwTextLen = SendDlgItemMessage(hWnd, IDC_LOGEDIT, EM_SETSEL,
  88.    (WPARAM) dwTextLen, (LPARAM) dwTextLen);
  90. // add string in lParam to log window
  91. SendDlgItemMessage(hWnd, IDC_LOGEDIT, EM_REPLACESEL,
  92. (WPARAM) FALSE, (LPARAM) lParam);
  93. GlobalFreePtr((LPVOID) lParam);
  94. break;
  96. case WM_COMMAND:
  97.         switch(LOWORD(wParam))
  98.         {
  99.         case IDCANCEL:
  100. EndDialog(hWnd, FALSE);
  101.             break;
  102. }
  103. break;
  104. }
  106.     // Allow for default processing
  107.     return FALSE;
  108. }
  110. void ServerApplicationMessage(LPDPLAYINFO lpDPInfo, LPDPMSG_GENERIC lpMsg, DWORD dwMsgSize,
  111.   DPID idFrom, DPID idTo)
  112. {
  113. switch (lpMsg->dwType)
  114. {
  115.     case BALANCEREQUEST:
  117. HandleBalanceRequest(lpDPInfo, (LPMSG_BALANCEREQUEST)lpMsg, idFrom);
  118.         break;
  120.     case SPINREQUEST:
  122. HandleSpinRequest(lpDPInfo, (LPMSG_SPINREQUEST)lpMsg, idFrom);
  123.         break;
  125.     default:
  126.         break; 
  127. }
  128. }
  130. void ServerSystemMessage(LPDPLAYINFO lpDPInfo, LPDPMSG_GENERIC lpMsg, DWORD dwMsgSize,
  131.  DPID idFrom, DPID idTo)
  132. {
  133.     // The body of each case is there so you can set a breakpoint and examine
  134.     // the contents of the message received.
  135. switch (lpMsg->dwType)
  136. {
  137. case DPSYS_CREATEPLAYERORGROUP:
  138.         {
  139.             LPDPMSG_CREATEPLAYERORGROUP lp = (LPDPMSG_CREATEPLAYERORGROUP) lpMsg;
  140.         }
  141. break;
  143. case DPSYS_DESTROYPLAYERORGROUP:
  144.         {
  145.             LPDPMSG_DESTROYPLAYERORGROUP lp = (LPDPMSG_DESTROYPLAYERORGROUP)lpMsg;
  146.         }
  147. break;
  149. case DPSYS_ADDPLAYERTOGROUP:
  150.         {
  151.             LPDPMSG_ADDPLAYERTOGROUP lp = (LPDPMSG_ADDPLAYERTOGROUP)lpMsg;
  152.         }
  153. break;
  155. case DPSYS_DELETEPLAYERFROMGROUP:
  156.         {
  157.             LPDPMSG_DELETEPLAYERFROMGROUP lp = (LPDPMSG_DELETEPLAYERFROMGROUP)lpMsg;
  158.         }
  159. break;
  161. case DPSYS_SESSIONLOST:
  162.         {
  163.             LPDPMSG_SESSIONLOST lp = (LPDPMSG_SESSIONLOST)lpMsg;
  164.         }
  165. break;
  167. case DPSYS_HOST:
  168.         {
  169.             LPDPMSG_HOST lp = (LPDPMSG_HOST)lpMsg;
  170.         }
  171. break;
  173. case DPSYS_SETPLAYERORGROUPDATA:
  174.         {
  175.             LPDPMSG_SETPLAYERORGROUPDATA lp = (LPDPMSG_SETPLAYERORGROUPDATA)lpMsg;
  176.         }
  177. break;
  179. case DPSYS_SETPLAYERORGROUPNAME:
  180.         {
  181.             LPDPMSG_SETPLAYERORGROUPNAME lp = (LPDPMSG_SETPLAYERORGROUPNAME)lpMsg;
  182.         }
  183. break;
  185. case DPSYS_SECUREMESSAGE:
  186.         {
  187.             LPDPMSG_SECUREMESSAGE lp = (LPDPMSG_SECUREMESSAGE)lpMsg;
  189. ServerApplicationMessage(lpDPInfo, (LPDPMSG_GENERIC) lp->lpData, lp->dwDataSize,
  190.   lp->dpIdFrom, idTo);
  192.         }
  193. break;
  194. }
  195. }
  197. HRESULT HandleBalanceRequest(LPDPLAYINFO lpDPInfo, LPMSG_BALANCEREQUEST lpBalance, DPID idTo)
  198. {
  199.     MSG_BALANCERESPONSE Msg;
  200. LPDPACCOUNTDESC lpAccountDesc = NULL;
  201. ACCOUNTINFO AccountInfo;
  202. HRESULT hr;
  204. // create balance response message
  205. ZeroMemory(&Msg, sizeof(MSG_BALANCERESPONSE));
  206. Msg.dwType = BALANCERESPONSE;
  208. // get account description for this player
  209. hr = GetAccountDesc(lpDPInfo, idTo, &lpAccountDesc);
  210.     if FAILED(hr)
  211. goto FAILURE;
  213. // get account information from database using account ID
  214. if ((glpFile == NULL) ||
  215. (!QueryAccount(glpFile, lpAccountDesc->lpszAccountIDA, &AccountInfo)))
  216. {
  217. hr = DPERR_ACCESSDENIED;
  218. goto FAILURE;
  219. }
  221. // return balance from database
  222. Msg.dwBalance = AccountInfo.dwBalance;
  224. FAILURE:
  225. Msg.hr = hr;
  227. if FAILED(Msg.hr)
  228. LogRequest("Balance request for "%s" failed: 0x%08Xrn", lpAccountDesc, Msg.hr);
  229. else
  230. LogRequest("Balance request for "%s" returned $%drn", lpAccountDesc, Msg.dwBalance);
  232. if (lpAccountDesc)
  233. GlobalFreePtr(lpAccountDesc);
  235. // send the message
  236.     return (lpDPInfo->lpDirectPlay3A->Send(lpDPInfo->dpidPlayer,
  237. idTo, SENDFLAGS(lpDPInfo->bIsSecure),
  238. &Msg, sizeof(MSG_BALANCERESPONSE)));
  239. }
  241. HRESULT HandleSpinRequest(LPDPLAYINFO lpDPInfo, LPMSG_SPINREQUEST lpSpin, DPID idTo)
  242. {
  243.     MSG_SPINRESPONSE Msg;
  244. LPDPACCOUNTDESC lpAccountDesc = NULL;
  245. ACCOUNTINFO AccountInfo;
  246. DWORD i;
  247. HRESULT hr;
  249. // create spin response message
  250.     ZeroMemory(&Msg, sizeof(MSG_SPINRESPONSE));
  251.     Msg.dwType = SPINRESPONSE;
  253. // get account description for this player
  254. hr = GetAccountDesc(lpDPInfo, idTo, &lpAccountDesc);
  255.     if FAILED(hr)
  256. goto FAILURE;
  258. // get account information from database using account ID
  259. if ((glpFile == NULL) ||
  260. (!QueryAccount(glpFile, lpAccountDesc->lpszAccountIDA, &AccountInfo)))
  261. {
  262. hr = DPERR_ACCESSDENIED;
  263. goto FAILURE;
  264. }
  266. // bet exceeds balance in database
  267. if (lpSpin->dwAmountBet > AccountInfo.dwBalance)
  268. {
  269. hr = DPERR_UNAVAILABLE;
  270. goto FAILURE;
  271. }
  273. // generate new slot settings
  274. for (i = 0; i < NUMWHEELS; i++)
  275. Msg.dwIndex[i] = ((DWORD)rand()) % SLOTSPERWHEEL;
  277. // determine amount won or lost
  278. Msg.dwAmountWonOrLost = GetAmountWonOrLost(lpSpin->dwAmountBet, Msg.dwIndex);
  280. // update account info in database for this player
  281. AccountInfo.dwBalance += Msg.dwAmountWonOrLost;
  283. if (!UpdateAccount(glpFile, lpAccountDesc->lpszAccountIDA, &AccountInfo))
  284. {
  285. hr = DPERR_ACCESSDENIED;
  286. goto FAILURE;
  287. }
  289. // send new balance back
  290.     Msg.dwBalance = AccountInfo.dwBalance;
  292. FAILURE:
  293. Msg.hr = hr;
  295. if FAILED(Msg.hr)
  296. LogRequest("Spin request for "%s" failed: 0x%08Xrn", lpAccountDesc, Msg.hr);
  297. else
  298. LogRequest("Spin request for "%s" returned $%drn", lpAccountDesc, Msg.dwAmountWonOrLost);
  300. if (lpAccountDesc)
  301. GlobalFreePtr(lpAccountDesc);
  303. // send the message
  304.     return (lpDPInfo->lpDirectPlay3A->Send(lpDPInfo->dpidPlayer,
  305. idTo, SENDFLAGS(lpDPInfo->bIsSecure),
  306. &Msg, sizeof(MSG_SPINRESPONSE)));
  307. }
  309. void LogRequest(LPSTR lpszFormat, LPDPACCOUNTDESC lpAccountDesc, DWORD dwValue)
  310. {
  311. LPSTR lpszStr;
  312. LPSTR lpszAccountID;
  314. // make sure we have an account ID
  315. if (lpAccountDesc == NULL)
  316. lpszAccountID = "unknown";
  317. else
  318. lpszAccountID = lpAccountDesc->lpszAccountIDA;
  320. // create a buffer for the output string, account string and a numeric value
  321. lpszStr = (LPSTR) GlobalAllocPtr(GHND, strlen(lpszFormat) + strlen(lpszAccountID) + 10);
  322. if (lpszStr == NULL)
  323. return;
  325. // format the string to log
  326. wsprintf(lpszStr, lpszFormat, lpszAccountID, dwValue);
  328. // log it - main wnd proc will dispose of the string
  329. PostMessage(ghServerWnd, WM_USER_ADDSTRING, (WPARAM) 0, (LPARAM) lpszStr);
  330. }
  332. LONG GetAmountWonOrLost(DWORD dwAmountBet, DWORD dwIndex[])
  333. {
  334. LONG    nMultiplier;
  336. // check for jackpot
  337. if ((dwIndex[0] == INDEX_JACKPOT) &&
  338. (dwIndex[1] == INDEX_JACKPOT) &&
  339. (dwIndex[2] == INDEX_JACKPOT))
  340. {
  341. nMultiplier = 100;
  342. }
  344. // three in a row
  345. else if ((dwIndex[0] == dwIndex[1]) &&
  346.  (dwIndex[1] == dwIndex[2]))
  347. {
  348. nMultiplier = 25;
  349. }
  351. // first two match
  352. else if (dwIndex[0] == dwIndex[1])
  353. {
  354. nMultiplier = 5;
  355. }
  357. // you lose!
  358. else
  359. nMultiplier = -1;
  361. // any spoiler and you lose
  362. if ((dwIndex[0] == INDEX_SPOILER) ||
  363. (dwIndex[1] == INDEX_SPOILER) ||
  364. (dwIndex[2] == INDEX_SPOILER))
  365. {
  366. nMultiplier = -1;
  367. }
  369. // return amount won or lost
  370. return (dwAmountBet * nMultiplier);
  371. }
  373. FILE* OpenAccountDB(LPSTR lpszDBName)
  374. {
  375. FILE *lpFile;
  377. lpFile = fopen(lpszDBName, "r+b");
  379. return (lpFile);
  380. }
  382. void CloseAccountDB(FILE *lpFile)
  383. {
  384. fclose(lpFile);
  385. }
  387. BOOL GetRecord(FILE *lpFile, LPSTR lpszKey, LPSTR lpszRecord)
  388. {
  389. rewind(lpFile);
  390. while (fgets(lpszRecord, MAX_RECORD_LENGTH, lpFile))
  391. {
  392. _strupr(lpszRecord);
  393. if (!strncmp(lpszRecord, lpszKey, strlen(lpszKey)))
  394. return (TRUE);
  395. }
  397. return (FALSE);
  398. }
  400. BOOL PutRecord(FILE *lpFile, LPSTR lpszKey, LPSTR lpszRecord)
  401. {
  402. CHAR szLine[MAX_RECORD_LENGTH];
  403. DWORD dwRecordIndex;
  405. rewind(lpFile);
  406. dwRecordIndex = 0;
  407. while (fgets(szLine, MAX_RECORD_LENGTH, lpFile))
  408. {
  409. _strupr(szLine);
  410. if (!strncmp(szLine, lpszKey, strlen(lpszKey)))
  411. {
  412. fseek(lpFile, dwRecordIndex, SEEK_SET);
  413. fputs(lpszRecord, lpFile);
  414. return (TRUE);
  415. }
  416. dwRecordIndex += strlen(szLine);
  417. }
  419. return (FALSE);
  420. }
  422. BOOL QueryAccount(FILE *lpFile, LPSTR lpszAccountID, LPACCOUNTINFO lpAccountInfo)
  423. {
  424.     CHAR szBuffer[MAX_RECORD_LENGTH];
  425.     CHAR *lpToken;
  427.     if (!GetRecord(lpFile, lpszAccountID, szBuffer))
  428.     {
  429.         return FALSE;
  430.     }
  432.     lpToken = strtok(szBuffer, ",");
  433.     if (lpToken)
  434.     {
  435.         lpToken = strtok(NULL, "n");
  436.         if (lpToken)
  437.         {
  438.             lpAccountInfo->dwBalance = atoi(lpToken);
  439.         }
  440.     }
  442.     return TRUE;
  443. }
  445. BOOL UpdateAccount(FILE *lpFile, LPSTR lpszAccountID, LPACCOUNTINFO lpAccountInfo)
  446. {
  447.     CHAR szBuffer[MAX_RECORD_LENGTH];
  449.     if (!GetRecord(lpFile, lpszAccountID, szBuffer))
  450.     {
  451.         return FALSE;
  452.     }
  454. sprintf(szBuffer, "%s,%8d", lpszAccountID, lpAccountInfo->dwBalance);
  455. return (PutRecord(lpFile, lpszAccountID, szBuffer));
  456. }
  458. HRESULT GetSecureAccountDesc(LPDPLAYINFO lpDPInfo, DPID idPlayer, LPDPACCOUNTDESC *lplpAccountDesc)
  459. {
  460. LPDPACCOUNTDESC lpAccountDesc = NULL;
  461. DWORD dwAccountDescSize;
  462. HRESULT hr;
  464. // get size of account description
  465. hr = lpDPInfo->lpDirectPlay3A->GetPlayerAccount(idPlayer, 0,
  466. NULL, &dwAccountDescSize);
  467. if (hr != DPERR_BUFFERTOOSMALL)
  468. goto FAILURE;
  470. // make room for it
  471. lpAccountDesc = (LPDPACCOUNTDESC) GlobalAllocPtr(GHND, dwAccountDescSize);
  472. if (lpAccountDesc == NULL)
  473. {
  474. hr = DPERR_OUTOFMEMORY;
  475. goto FAILURE;
  476. }
  478. // get the account description for this player
  479. hr = lpDPInfo->lpDirectPlay3A->GetPlayerAccount(idPlayer, 0,
  480. lpAccountDesc, &dwAccountDescSize);
  481. if FAILED(hr)
  482. goto FAILURE;
  484. // return account description
  485. _strupr(lpAccountDesc->lpszAccountIDA);
  486. *lplpAccountDesc = lpAccountDesc;
  487. lpAccountDesc = NULL;
  489. FAILURE:
  490. if (lpAccountDesc)
  491. GlobalFreePtr(lpAccountDesc);
  493. return (hr);
  494. }
  496. HRESULT GetUnsecureAccountDesc(LPDPLAYINFO lpDPInfo, DPID idPlayer, LPDPACCOUNTDESC *lplpAccountDesc)
  497. {
  498. LPDPACCOUNTDESC lpAccountDesc = NULL;
  499. DWORD dwAccountDescSize;
  500. LPDPNAME lpName;
  501. HRESULT hr;
  503. // get size of player name
  504. hr = lpDPInfo->lpDirectPlay3A->GetPlayerName(idPlayer,
  505. NULL, &dwAccountDescSize);
  506. if (hr != DPERR_BUFFERTOOSMALL)
  507. goto FAILURE;
  509. // make room for it
  510. lpAccountDesc = (LPDPACCOUNTDESC) GlobalAllocPtr(GHND, sizeof(DPACCOUNTDESC) + dwAccountDescSize);
  511. if (lpAccountDesc == NULL)
  512. {
  513. hr = DPERR_OUTOFMEMORY;
  514. goto FAILURE;
  515. }
  517. // get the player name
  518. lpName = (LPDPNAME) (((LPSTR)lpAccountDesc) + sizeof(DPACCOUNTDESC));
  519. hr = lpDPInfo->lpDirectPlay3A->GetPlayerName(idPlayer,
  520. lpName, &dwAccountDescSize);
  521. if FAILED(hr)
  522. goto FAILURE;
  524. // return account description
  525. lpAccountDesc->lpszAccountIDA = lpName->lpszShortNameA;
  526. _strupr(lpAccountDesc->lpszAccountIDA);
  527. *lplpAccountDesc = lpAccountDesc;
  528. lpAccountDesc = NULL;
  530. FAILURE:
  531. if (lpAccountDesc)
  532. GlobalFreePtr(lpAccountDesc);
  534. return (hr);
  535. }
  537. HRESULT GetAccountDesc(LPDPLAYINFO lpDPInfo, DPID idPlayer, LPDPACCOUNTDESC *lplpAccountDesc)
  538. {
  539. HRESULT hr;
  541. if (lpDPInfo->bIsSecure)
  542. {
  543. hr = GetSecureAccountDesc(lpDPInfo, idPlayer, lplpAccountDesc);
  544. }
  545. else
  546. {
  547. hr = GetUnsecureAccountDesc(lpDPInfo, idPlayer, lplpAccountDesc);
  548. }
  550. return (hr);
  551. }