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

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

Windows编程

开发平台：

Visual C++

CLIENT.CPP：源码内容
  1. /*==========================================================================
  2.  *
  3.  *  Copyright (C) 1997 Microsoft Corporation.  All Rights Reserved.
  4.  *
  5.  *  File:       client.cpp
  6.  *  Content: Slot machine client 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 DWORD SLOTWIDTH = 110; // width of slot
  19. const DWORD SLOTHEIGHT = 119; // height of slot
  20. const DWORD SLOTBORDER = 9; // space between slots
  21. const DWORD REVSPERSECOND = 1; // no. revolutions per second
  22. const DWORD PIXELSPERSLOT = SLOTHEIGHT - SLOTBORDER; // no. vertical pixels per slot
  23. const DWORD PIXELSPERREV = PIXELSPERSLOT * SLOTSPERWHEEL;// no. vertical pixels drawn per revolution
  24. const DWORD PIXELSPERSECOND = PIXELSPERREV * REVSPERSECOND; // no. vertical pixels drawn per second
  25. const UINT TIMERID = 1; // timer ID to use
  26. const UINT TIMERINTERVAL = 50; // timer interval
  27. const UINT MAXSTRING = 200; // max size of a string
  29. // window messages
  30. const UINT WM_USER_UPDATEBALANCE = WM_USER + BALANCERESPONSE;
  31. const UINT WM_USER_STARTSPINNING = WM_USER + SPINRESPONSE;
  33. // structures
  34. typedef struct {
  35. DWORD dwIndex; // index of wheel slot to show
  36.     DWORD dwStartTicks; // time wheel started spinning
  37. DWORD dwDuration; // duration wheel should spin
  38. } WHEELINFO, *LPWHEELINFO;
  40. // globals
  41. HWND ghClientWnd = NULL; // main window
  43. // prototypes
  44. HRESULT SendBalanceRequest(LPDPLAYINFO lpDPInfo);
  45. HRESULT SendSpinRequest(LPDPLAYINFO lpDPInfo, DWORD dwAmountBet);
  46. void DrawWheels(LPWHEELINFO lpWheels, HBITMAP hWheelBitmap,
  47.    HDC hDC, LPRECT lpBoundsRect);
  48. void StartSpinning(LPWHEELINFO lpWheels);
  49. BOOL SpinWheels(HWND hWnd, LPWHEELINFO lpWheels, HBITMAP hWheelBitmap);
  51. BOOL CALLBACK ClientWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  52. {
  53. static LPDPLAYINFO lpDPInfo = NULL;
  54. static UINT idTimer = 0;
  55. static HBITMAP hWheelBitmap = NULL;
  56. static WHEELINFO WheelInfo[NUMWHEELS];
  57. static MSG_SPINRESPONSE SpinResponse;
  58. CHAR szStr[MAXSTRING];
  59. DWORD i;
  60. DWORD dwAmountBet;
  62.     switch(uMsg)
  63.     {
  64.     case WM_INITDIALOG:
  65.         // save the connection info pointer
  66.         lpDPInfo = (LPDPLAYINFO) lParam;
  68. // store global window
  69. ghClientWnd = hWnd;
  71. // get slots bitmap
  72. hWheelBitmap = LoadBitmap(ghInstance, MAKEINTRESOURCE(IDB_SLOTSBITMAP));
  74. // initialize slots
  75. for (i = 0; i < NUMWHEELS; i++)
  76. WheelInfo[i].dwIndex = ((DWORD)rand()) % SLOTSPERWHEEL;
  78.         // get starting balance
  79. SendBalanceRequest(lpDPInfo);
  80. break;
  82.     case WM_DESTROY:
  83. // stop the timer
  84. if (idTimer)
  85. {
  86. KillTimer(hWnd, idTimer); 
  87. idTimer = 0;
  88. }
  90. // free the bitmap handle
  91. if (hWheelBitmap)
  92. {
  93. DeleteObject(hWheelBitmap);
  94. hWheelBitmap = NULL;
  95. }
  96. ghClientWnd = NULL;
  97.         break;
  99. case WM_USER_UPDATEBALANCE:
  101. // balance is in lParam
  102.         sprintf(szStr, "$%4d", lParam);
  104.         // display new balance
  105. SetDlgItemText(hWnd, IDC_EDIT_BALANCE, szStr);
  106. break;
  108. case WM_USER_STARTSPINNING:
  110. // copy spin response message from lParam
  111. SpinResponse = *((LPMSG_SPINRESPONSE) lParam);
  112. GlobalFreePtr((LPVOID) lParam); // free memory
  114. // check for valid spin
  115. if FAILED(SpinResponse.hr)
  116. {
  117. SetDlgItemText(hWnd, IDC_RESULTEDIT, "You don't have enough money!");
  118. }
  119. else
  120. {
  121. // copy slot settings specified by server
  122. for (i = 0; i < NUMWHEELS; i++)
  123. WheelInfo[i].dwIndex = SpinResponse.dwIndex[i];
  125. // clear win or lose
  126. SetDlgItemText(hWnd, IDC_RESULTEDIT, "");
  128. // start things spinning
  129. StartSpinning(WheelInfo);
  130. idTimer = SetTimer(hWnd, TIMERID, TIMERINTERVAL, NULL);
  132. // disable spin button while spinning
  133. EnableDlgButton(hWnd, IDC_SPINBUTTON, FALSE);
  134. }
  135. break;
  137. case WM_TIMER:
  138. // readraw any spinning wheels
  139. if (!SpinWheels(hWnd, WheelInfo, hWheelBitmap))
  140. {
  141. KillTimer(hWnd, idTimer); 
  142. idTimer = 0;
  144. // display amount won or lost
  145. if (SpinResponse.dwAmountWonOrLost > 0)
  146. {
  147. sprintf(szStr,"You win $%d!", SpinResponse.dwAmountWonOrLost);
  148. PlaySound(MAKEINTRESOURCE(IDR_WINWAVE), ghInstance, SND_ASYNC | SND_RESOURCE);
  149. }
  150. else if (SpinResponse.dwAmountWonOrLost < 0)
  151. {
  152. sprintf(szStr,"You lose $%d!", -SpinResponse.dwAmountWonOrLost);
  153. PlaySound(MAKEINTRESOURCE(IDR_LOSEWAVE), ghInstance, SND_ASYNC | SND_RESOURCE);
  154. }
  155. else
  156. {
  157. strcpy(szStr, "");
  158. }
  160. // display win or loss
  161. SetDlgItemText(hWnd, IDC_RESULTEDIT, szStr);
  163. PostMessage(hWnd, WM_USER_UPDATEBALANCE, (WPARAM) 0, (LPARAM) SpinResponse.dwBalance);
  165. // enable spin button again
  166. EnableDlgButton(hWnd, IDC_SPINBUTTON, TRUE);
  167. }
  168. break;
  170.     case WM_DRAWITEM:
  171. {
  172. DRAWITEMSTRUCT *diInfo;
  174. diInfo = (DRAWITEMSTRUCT *) lParam;
  176. switch (diInfo->CtlID)
  177. {
  178. case IDC_SLOTS:
  179. if (diInfo->itemAction == ODA_DRAWENTIRE)
  180. {
  181. DrawWheels(WheelInfo, hWheelBitmap, diInfo->hDC, &diInfo->rcItem);
  182. }
  183. break;
  184. }
  185. }
  186. break;
  188. case WM_COMMAND:
  189.         switch(LOWORD(wParam))
  190.         {
  191. case IDC_SPINBUTTON:
  192. // find out how much was bet
  193. dwAmountBet = 0;
  195. // one dollar
  196. if (DlgItemIsChecked(hWnd, IDC_BET1CHECK))
  197. dwAmountBet += 1;
  199. // five dollars
  200. if (DlgItemIsChecked(hWnd, IDC_BET2CHECK))
  201. dwAmountBet += 5;
  203. // ten dollars
  204. if (DlgItemIsChecked(hWnd, IDC_BET3CHECK))
  205. dwAmountBet += 10;
  207. // ask server for results of spin using this bet
  208.             SendSpinRequest(lpDPInfo, dwAmountBet);            
  209. break;
  211.         case IDCANCEL:
  212. EndDialog(hWnd, FALSE);
  213.             break;
  214. }
  215. break;
  216. }
  218.     // Allow for default processing
  219.     return FALSE;
  220. }
  222. void ClientApplicationMessage(LPDPLAYINFO lpDPInfo, LPDPMSG_GENERIC lpMsg, DWORD dwMsgSize,
  223.   DPID idFrom, DPID idTo)
  224. {
  225. switch (lpMsg->dwType)
  226. {
  227.     case BALANCERESPONSE:
  228.         {
  229.             LPMSG_BALANCERESPONSE lpBalance = (LPMSG_BALANCERESPONSE)lpMsg;
  231.   PostMessage(ghClientWnd, WM_USER_UPDATEBALANCE, (WPARAM) 0, (LPARAM) lpBalance->dwBalance);
  232.         }
  233.         break;
  235.     case SPINRESPONSE:
  236.         {
  237.             LPMSG_SPINRESPONSE lpSpin = (LPMSG_SPINRESPONSE)lpMsg;
  238.             LPMSG_SPINRESPONSE lpSpinCopy;
  240. // make a copy of the message so we can pass it to the wndproc
  241. lpSpinCopy = (LPMSG_SPINRESPONSE) GlobalAllocPtr(GHND, sizeof(MSG_SPINRESPONSE));
  242. if (lpSpinCopy == NULL)
  243. break;
  245. *lpSpinCopy = *lpSpin;
  247.             PostMessage(ghClientWnd, WM_USER_STARTSPINNING, (WPARAM) 0, (LPARAM) lpSpinCopy);
  248.         }
  249.         break;
  251.     default:
  252.         break; 
  253. }
  254. }
  256. void ClientSystemMessage(LPDPLAYINFO lpDPInfo, LPDPMSG_GENERIC lpMsg, DWORD dwMsgSize,
  257.  DPID idFrom, DPID idTo)
  258. {
  259.     // The body of each case is there so you can set a breakpoint and examine
  260.     // the contents of the message received.
  261. switch (lpMsg->dwType)
  262. {
  263. case DPSYS_CREATEPLAYERORGROUP:
  264.         {
  265.             LPDPMSG_CREATEPLAYERORGROUP lp = (LPDPMSG_CREATEPLAYERORGROUP) lpMsg;
  266.         }
  267. break;
  269. case DPSYS_DESTROYPLAYERORGROUP:
  270.         {
  271.             LPDPMSG_DESTROYPLAYERORGROUP lp = (LPDPMSG_DESTROYPLAYERORGROUP)lpMsg;
  272.         }
  273. break;
  275. case DPSYS_ADDPLAYERTOGROUP:
  276.         {
  277.             LPDPMSG_ADDPLAYERTOGROUP lp = (LPDPMSG_ADDPLAYERTOGROUP)lpMsg;
  278.         }
  279. break;
  281. case DPSYS_DELETEPLAYERFROMGROUP:
  282.         {
  283.             LPDPMSG_DELETEPLAYERFROMGROUP lp = (LPDPMSG_DELETEPLAYERFROMGROUP)lpMsg;
  284.         }
  285. break;
  287. case DPSYS_SESSIONLOST:
  288.         {
  289.             LPDPMSG_SESSIONLOST lp = (LPDPMSG_SESSIONLOST)lpMsg;
  290.         }
  291. break;
  293. case DPSYS_HOST:
  294.         {
  295.             LPDPMSG_HOST lp = (LPDPMSG_HOST)lpMsg;
  296.         }
  297. break;
  299. case DPSYS_SETPLAYERORGROUPDATA:
  300.         {
  301.             LPDPMSG_SETPLAYERORGROUPDATA lp = (LPDPMSG_SETPLAYERORGROUPDATA)lpMsg;
  302.         }
  303. break;
  305. case DPSYS_SETPLAYERORGROUPNAME:
  306.         {
  307.             LPDPMSG_SETPLAYERORGROUPNAME lp = (LPDPMSG_SETPLAYERORGROUPNAME)lpMsg;
  308.         }
  309. break;
  311. case DPSYS_SECUREMESSAGE:
  312.         {
  313.             LPDPMSG_SECUREMESSAGE lp = (LPDPMSG_SECUREMESSAGE)lpMsg;
  315. ClientApplicationMessage(lpDPInfo, (LPDPMSG_GENERIC) lp->lpData, lp->dwDataSize,
  316.   lp->dpIdFrom, idTo);
  318.         }
  319. break;
  320. }
  321. }
  323. HRESULT SendBalanceRequest(LPDPLAYINFO lpDPInfo)
  324. {
  325.     MSG_BALANCEREQUEST Msg;
  327.     ZeroMemory(&Msg, sizeof(MSG_BALANCEREQUEST));
  328.     Msg.dwType = BALANCEREQUEST;
  330.     return (lpDPInfo->lpDirectPlay3A->Send(lpDPInfo->dpidPlayer,
  331. DPID_SERVERPLAYER, SENDFLAGS(lpDPInfo->bIsSecure),
  332. &Msg, sizeof(MSG_BALANCEREQUEST)));
  333. }
  335. HRESULT SendSpinRequest(LPDPLAYINFO lpDPInfo, DWORD dwAmountBet)
  336. {
  337.     MSG_SPINREQUEST Msg;
  339.     ZeroMemory(&Msg, sizeof(MSG_SPINREQUEST));
  340.     Msg.dwType = SPINREQUEST;
  341. Msg.dwAmountBet = dwAmountBet;
  343.     return (lpDPInfo->lpDirectPlay3A->Send(lpDPInfo->dpidPlayer,
  344. DPID_SERVERPLAYER, SENDFLAGS(lpDPInfo->bIsSecure),
  345. &Msg, sizeof(MSG_SPINREQUEST)));
  346. }
  348. #define RECTWIDTH(lpRect)     ((lpRect)->right - (lpRect)->left)
  349. #define RECTHEIGHT(lpRect)    ((lpRect)->bottom - (lpRect)->top)
  351. BOOL PaintBitmap(HDC hDC, LPRECT lpDCRect, HBITMAP hDDB,  LPRECT lpDDBRect)
  352. {
  353.     HDC         hMemDC;            // Handle to memory DC
  354.     HBITMAP     hOldBitmap;        // Handle to previous bitmap
  355.     BOOL        bSuccess = FALSE;  // Success/fail flag
  357.     // Create a memory DC
  359.     hMemDC = CreateCompatibleDC(hDC);
  361.     // If this failed, return FALSE
  363.     if (!hMemDC)
  364.         return FALSE;
  366.     // Select bitmap into the memory DC
  368.     hOldBitmap = (HBITMAP) SelectObject (hMemDC, hDDB);
  370.     // Make sure to use the stretching mode best for color pictures
  372.     SetStretchBltMode (hDC, COLORONCOLOR);
  374.     // Determine whether to call StretchBlt() or BitBlt()
  375.     if ((RECTWIDTH(lpDCRect)  == RECTWIDTH(lpDDBRect)) &&
  376.             (RECTHEIGHT(lpDCRect) == RECTHEIGHT(lpDDBRect)))
  377.         bSuccess = BitBlt(hDC, lpDCRect->left, lpDCRect->top,
  378.                 lpDCRect->right - lpDCRect->left,
  379.                 lpDCRect->bottom - lpDCRect->top, hMemDC, lpDDBRect->left,
  380.                 lpDDBRect->top, SRCCOPY);
  381.     else
  382.         bSuccess = StretchBlt(hDC, lpDCRect->left,  lpDCRect->top, 
  383.                 lpDCRect->right - lpDCRect->left,
  384.                 lpDCRect->bottom - lpDCRect->top, hMemDC, lpDDBRect->left, 
  385.                 lpDDBRect->top,  lpDDBRect->right - lpDDBRect->left,
  386.                 lpDDBRect->bottom - lpDDBRect->top, SRCCOPY);
  388.     // Clean up
  390.     SelectObject(hMemDC, hOldBitmap);
  392.     DeleteDC(hMemDC);
  394.     // Return with success/fail flag
  396.     return bSuccess;
  397. }
  399. void DrawWheels(LPWHEELINFO lpWheels, HBITMAP hWheelBitmap, HDC hDC, LPRECT lpBoundsRect)
  400. {
  401. RECT rectDC, rectSlot;
  402. DWORD dwWidth, dwHeight, dwXOffset, dwYOffset;
  403. DWORD i;
  405. if (hWheelBitmap == NULL)
  406. return;
  408. dwWidth = lpBoundsRect->right - lpBoundsRect->left;
  409. dwHeight = lpBoundsRect->bottom - lpBoundsRect->top;
  411. dwXOffset = (dwWidth - (SLOTWIDTH * NUMWHEELS)) / (NUMWHEELS + 1);
  412. dwYOffset = (dwHeight - SLOTHEIGHT) / 2;
  414. SetRect(&rectDC, dwXOffset, dwYOffset,
  415. dwXOffset + SLOTWIDTH, dwYOffset + SLOTHEIGHT);
  417. for (i = 0; i < NUMWHEELS; i++)
  418. {
  419. SetRect(&rectSlot, 0, 0, SLOTWIDTH, SLOTHEIGHT);
  420. OffsetRect(&rectSlot, 0, lpWheels[i].dwIndex * PIXELSPERSLOT);
  422. PaintBitmap(hDC, &rectDC, hWheelBitmap, &rectSlot);
  424. OffsetRect(&rectDC, SLOTWIDTH + dwXOffset, 0);
  425. }
  426. }
  428. void StartSpinning(LPWHEELINFO lpWheels)
  429. {
  430. DWORD i;
  432. for (i = 0; i < NUMWHEELS; i++)
  433. {
  434. lpWheels[i].dwStartTicks = GetTickCount();
  435. lpWheels[i].dwStartTicks -= lpWheels[i].dwIndex * PIXELSPERSLOT * 1000 / PIXELSPERREV;
  436. lpWheels[i].dwDuration = 1000 * (i + 1) + 1000;
  437. }
  438. }
  440. BOOL SpinWheels(HWND hWnd, LPWHEELINFO lpWheels, HBITMAP hWheelBitmap)
  441. {
  442. HDC hDC;
  443. RECT rectBounds;
  444. LPRECT lpBoundsRect;
  445. RECT rectDC, rectSlot;
  446. DWORD dwWidth, dwHeight, dwXOffset, dwYOffset, dwYStart;
  447. DWORD i, dwTicks, dwStoppedCount;
  449. if (hWheelBitmap == NULL)
  450. return (FALSE);
  452. hDC = GetWindowDC(GetDlgItem(hWnd, IDC_SLOTS));
  453. if (hDC == NULL)
  454. return (FALSE);
  456. if (!GetWindowRect(GetDlgItem(hWnd, IDC_SLOTS), &rectBounds))
  457. return (FALSE);
  459. lpBoundsRect = &rectBounds;
  461. dwWidth = lpBoundsRect->right - lpBoundsRect->left;
  462. dwHeight = lpBoundsRect->bottom - lpBoundsRect->top;
  464. dwXOffset = (dwWidth - (SLOTWIDTH * NUMWHEELS)) / (NUMWHEELS + 1);
  465. dwYOffset = (dwHeight - SLOTHEIGHT) / 2;
  467. SetRect(&rectDC, dwXOffset, dwYOffset,
  468. dwXOffset + SLOTWIDTH, dwYOffset + SLOTHEIGHT);
  470. dwStoppedCount = 0;
  471. for (i = 0; i < NUMWHEELS; i++)
  472. {
  473. if (lpWheels[i].dwDuration == 0)
  474. {
  475. dwStoppedCount++;
  476. }
  477. else
  478. {
  479. dwTicks = GetTickCount() - lpWheels[i].dwStartTicks;
  480. dwYStart = (dwTicks * PIXELSPERSECOND) / 1000;
  481. dwYStart %= PIXELSPERREV;
  483. if (dwTicks >= lpWheels[i].dwDuration)
  484. {
  485. // lpWheels[i].value = ((dwYStart + (PIXELSPERSLOT - 1)) / PIXELSPERSLOT) % SLOTSPERWHEEL;
  487. SetRect(&rectSlot, 0, 0, SLOTWIDTH, SLOTHEIGHT);
  488. OffsetRect(&rectSlot, 0, lpWheels[i].dwIndex * PIXELSPERSLOT);
  489. PaintBitmap(hDC, &rectDC, hWheelBitmap, &rectSlot);
  491. lpWheels[i].dwDuration = 0;
  492.                 if (dwStoppedCount == (NUMWHEELS - 1))
  493.                     PlaySound(MAKEINTRESOURCE(IDR_STOPWAVE), ghInstance, SND_RESOURCE);
  494.                 else
  495.                     PlaySound(MAKEINTRESOURCE(IDR_STOPWAVE), ghInstance, SND_ASYNC | SND_RESOURCE);
  496.             }
  497. else
  498. {
  499. SetRect(&rectSlot, 0, 0, SLOTWIDTH, SLOTHEIGHT);
  500. OffsetRect(&rectSlot, 0, dwYStart);
  501. if (rectSlot.bottom > PIXELSPERREV)
  502. {
  503. RECT rectSlotTmp, rectDCTmp;
  504. DWORD height;
  506. // copy from bottom end of bitmap
  507. height = PIXELSPERREV - rectSlot.top;
  508. rectSlotTmp = rectSlot;
  509. rectSlotTmp.bottom = rectSlotTmp.top + height;
  510. rectDCTmp = rectDC;
  511. rectDCTmp.bottom = rectDCTmp.top + height;
  512. PaintBitmap(hDC, &rectDCTmp, hWheelBitmap, &rectSlotTmp);
  514. height = rectSlot.bottom - PIXELSPERREV;
  515. rectSlotTmp = rectSlot;
  516. rectSlotTmp.top = 0;
  517. rectSlotTmp.bottom = height;
  518. rectDCTmp = rectDC;
  519. rectDCTmp.top = rectDCTmp.bottom - height;
  520. PaintBitmap(hDC, &rectDCTmp, hWheelBitmap, &rectSlotTmp);
  521. }
  522. else
  523. PaintBitmap(hDC, &rectDC, hWheelBitmap, &rectSlot);
  524. }
  525. }
  526. OffsetRect(&rectDC, SLOTWIDTH + dwXOffset, 0);
  527. }
  529. return (dwStoppedCount != NUMWHEELS);
  530. }