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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
Draw_Cards_Engine.cpp
资源名称：斗地主_src.rar　[点击查看]
上传用户：may_xy
上传日期：2007-08-09
资源大小：1519k
文件大小：24k
源码类别：

游戏

开发平台：

C/C++

Draw_Cards_Engine.cpp：源码内容
  1. // Draw_Cards_Engine.cpp: implementation of the CDrawCardsEngine class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  4. #include "stdafx.h"
  5. #include "斗地主.h"
  7. #include "MainFrm.h"
  9. #include "Game.h"
  11. #include "My_DirectInput.h"
  12. #include "my_directdraw.h"
  14. #include "Draw_Cards_Engine.h"
  15. #include "Playing_Cards.h"
  17. #ifdef _DEBUG
  18. #undef THIS_FILE
  19. static char THIS_FILE[]=__FILE__;
  20. #define new DEBUG_NEW
  21. #endif
  22. //////////////////////////////////////////////////////////////////////
  23. // Construction/Destruction
  24. //////////////////////////////////////////////////////////////////////
  25. //扑克的位置;
  26. CCardPos::CCardPos()
  27. {
  28. m_nX      = -1;       //表示没有;
  29. m_nY      = -1;
  30. m_bVisual = 1;   //表示可见;
  31. }
  32. //扑克牌布局地图结构初始化;
  33. CCardsMap::CCardsMap()
  34. {
  35. for(int i=0;i<20;i++)
  36. {
  37. Center0[i].m_nX = Center_x0 + Card_Distance1 * i;
  38. Center0[i].m_nY = Center_y0;
  40. Center1[i].m_nX = Center_x1 + Card_Distance0 * i;
  41. Center1[i].m_nY = Center_y1;
  43. Center2[i].m_nX = Center_x2 + Card_Distance2 * i;
  44. Center2[i].m_nY = Center_y2;
  45. }
  47. for(int j=0;j<20;j++)
  48. {
  49. Left0[j].m_nX = Left_x0; 
  50. Left0[j].m_nY = Left_y0 + Card_Distance0 * j;
  52. Left1[j].m_nX = Left_x1;
  53. Left1[j].m_nY = Left_y1 + Card_Distance1 * j;
  55. Left2[j].m_nX = Left_x2;
  56. Left2[j].m_nY = Left_y2 + Card_Distance2 * j;
  57. }
  59. for(int k=0;k<20;k++)
  60. {
  61. Right0[k].m_nX = Right_x0;
  62. Right0[k].m_nY = Right_y0 + Card_Distance0 * k;
  64. Right1[k].m_nX = Right_x1;
  65. Right1[k].m_nY = Right_y1 + Card_Distance1 * k;
  67. Right2[k].m_nX = Right_x2;
  68. Right2[k].m_nY = Right_y2 + Card_Distance2 * k;
  69. }
  71. m_cLordCards[0].m_nX = Lord_Card1_x;
  72. m_cLordCards[0].m_nY = Lord_Card1_y;
  74. m_cLordCards[1].m_nX = Lord_Card2_x;
  75. m_cLordCards[1].m_nY = Lord_Card2_y;
  77. m_cLordCards[2].m_nX = Lord_Card3_x;
  78. m_cLordCards[2].m_nY = Lord_Card3_y;
  80. m_cDistributeCard.m_nX = Card_x; 
  81. m_cDistributeCard.m_nY = Card_y; 
  83. m_nLordCards = 0;
  84. m_nUpCounter = 0;
  85. }
  87. //CDrawCardsEngine
  88. CDrawCardsEngine::CDrawCardsEngine():BLUE( _RGB32BIT(0,0,0,255) )
  89. {
  90. m_bVisual = FALSE;
  91. }
  93. CDrawCardsEngine::~CDrawCardsEngine()
  94. {
  96. }
  97. //渲染初始化;
  98. int CDrawCardsEngine::Init()
  99. {
  100. char* file;
  101. //14种牌从小到大的加载;
  102. //3-10
  103. char filename[50];
  104. for(int i=0;i<=7;i++)
  105. {
  106. sprintf(filename,"bmp\Cards\%d.bmp",i+3);
  107. lpddsbg_Cards[i] = pDraw->CreateSurface(Cards_Width*4,Cards_Height,0,BLUE);
  108. pDraw->BitmapToSurface(lpddsbg_Cards[i],0,0,filename,Cards_Width*4,Cards_Height);
  109. }
  111. //J
  112. file = "bmp\Cards\j.bmp";
  113. lpddsbg_Cards[8] = pDraw->CreateSurface(Cards_Width*4,Cards_Height,0,BLUE);
  114. pDraw->BitmapToSurface(lpddsbg_Cards[8],0,0,file,Cards_Width*4,Cards_Height);
  115. //Q
  116. file = "bmp\Cards\Q.bmp";
  117. lpddsbg_Cards[9] = pDraw->CreateSurface(Cards_Width*4,Cards_Height,0,BLUE);
  118. pDraw->BitmapToSurface(lpddsbg_Cards[9],0,0,file,Cards_Width*4,Cards_Height);
  119. //K
  120. file = "bmp\Cards\K.bmp";
  121. lpddsbg_Cards[10] = pDraw->CreateSurface(Cards_Width*4,Cards_Height,0,BLUE);
  122. pDraw->BitmapToSurface(lpddsbg_Cards[10],0,0,file,Cards_Width*4,Cards_Height);
  123. //A
  124. file = "bmp\Cards\A.bmp";
  125. lpddsbg_Cards[11] = pDraw->CreateSurface(Cards_Width*4,Cards_Height,0,BLUE);
  126. pDraw->BitmapToSurface(lpddsbg_Cards[11],0,0,file,Cards_Width*4,Cards_Height);
  127. //2
  128. file = "bmp\Cards\2.bmp";
  129. lpddsbg_Cards[12] = pDraw->CreateSurface(Cards_Width*4,Cards_Height,0,BLUE);
  130. pDraw->BitmapToSurface(lpddsbg_Cards[12],0,0,file,Cards_Width*4,Cards_Height);
  131. //加载百搭;
  132. file = "bmp\Cards\jokers.bmp";
  133. lpddsbg_Cards[13] = pDraw->CreateSurface(Cards_Width*2,Cards_Height,0,BLUE);
  134. pDraw->BitmapToSurface(lpddsbg_Cards[13],0,0,file,Cards_Width*2,Cards_Height);
  135. //加载扑克背面;
  136. file = "bmp\Cards\card_back1.bmp";
  137. lpddsbg_Cards[14] = pDraw->CreateSurface(Cards_Width,Cards_Height,0,BLUE);
  138. pDraw->BitmapToSurface(lpddsbg_Cards[14],0,0,file,Cards_Width,Cards_Height);
  140. return 1;
  141. }
  143. int CDrawCardsEngine::DrawCard(int x,
  144. int y,
  145. int Card_m_nColor,
  146. int Card_Value,
  147. LPDIRECTDRAWSURFACE7 lpdds_Dest ) 
  148. {
  150. lpdds_Dest->Blt(CRect(x,
  151.   y,
  152.   x+Cards_Width,
  153.   y+Cards_Height),
  154.     lpddsbg_Cards[Card_Value - 3],
  155.     CRect(Card_m_nColor*Cards_Width,
  156.   0,
  157.   Card_m_nColor*Cards_Width + Cards_Width,
  158.   Cards_Height),
  159.     DDBLT_WAIT | DDBLT_KEYSRC,
  160.     NULL);
  161. return 1;
  162. }
  164. int CDrawCardsEngine::MoveCard(int Dest_x,
  165.     int Dest_y,
  166. int Source_x,
  167. int Source_y,
  168. int Card_m_nColor,
  169. int Card_Value,
  170. int Speed) //移动速度,以象素为单位;
  171. // LPDIRECTDRAWSURFACE7 lpdds_Dest = lpddsback)
  172. {
  173. int dx,dy,dx2,dy2,x_inc,y_inc,error;
  175. int x = Source_x,y = Source_y;
  177. dx = Dest_x - Source_x;
  179. dy = Dest_y - Source_y;
  181. if(dx>=0)
  182. {
  183. x_inc = 1;
  184. }
  185. else
  186. {
  187. x_inc = -1;
  188. dx = -dx;
  189. }
  191. if(dy >= 0)
  192. {
  193. y_inc = 1;
  194. }
  195. else
  196. {
  197. y_inc = -1;
  198. dy = -dy;
  199. }
  201. dx2 = dx << 1;
  202. dy2 = dy << 1;
  204. if(dx > dy)
  205. {
  206. error = dy2 - dx;
  207. for(int i=0;i<dx;i++)
  208. {
  209. if(i%Speed == 0)
  210. {
  211. ::RedrawGame(NULL);
  213. DrawCard(x,y,Card_m_nColor,Card_Value);
  215. while (FAILED(lpddsprimary->Flip(NULL, DDFLIP_WAIT)));
  216. }
  218. if(error >= 0)
  219. {
  220. error-=dx2;
  221. y+=y_inc;
  222. }
  223. error+=dy2;
  224. x+=x_inc;
  225. }//end for~
  226. }
  227. else
  228. {
  229. error = dx2 - dy;
  230. for(int i=0;i<dy;i++)
  231. {
  232. if(i%Speed == 0)
  233. {
  234. ::RedrawGame(NULL);
  236. DrawCard(x,y,Card_m_nColor,Card_Value);
  238. while (FAILED(lpddsprimary->Flip(NULL, DDFLIP_WAIT)));
  239. }
  241. if(error >= 0)
  242. {
  243. error-=dy2;
  244. x+=x_inc;
  245. }
  246. error+=dx2;
  247. y+=y_inc;
  248. }//end for~
  250. }
  251. ::RedrawGame(NULL);
  253. DrawCard(x,y,Card_m_nColor,Card_Value);
  255. while (FAILED(lpddsprimary->Flip(NULL, DDFLIP_WAIT)));
  257. return 1;
  258. }
  259. //重新整理中间(本机)玩家的牌面;
  260. int CDrawCardsEngine::DrawCleanUp()
  261. {
  262. pCenterCards->CleanUp(); //整理牌;
  263. for(int i=0;i<pCenterCards->m_nCardsCounter;i++)
  264. {
  265. pCardsMap->Center0[i].m_bVisual = 0;
  266. }
  267. for(int j=0;j<pCenterCards->m_nCardsCounter;j++)
  268. {
  269. pCardsMap->Center0[j].m_bVisual = 1;
  270. ::RedrawGame(); //刷新;
  271. }
  272. return 1;
  273. }
  274. //发牌;
  275. int CDrawCardsEngine::Dealing()
  276. {
  277. //分牌给三个玩家;
  278. for(int i=0;i<17;i++)
  279. {
  280. //发牌给左边玩家;
  281. pLeftCards->m_cCards[i]  = g_cAllCards[i*3 + 0];
  282. MoveCard(Left_x0,
  283. pCardsMap->Left0[i].m_nY,
  284. Card_x,
  285. Card_y,
  286. 0,
  287. 17);
  289. pLeftCards->m_nCardsCounter++;
  291. //发牌给中间玩家;
  292. pCenterCards->m_cCards[i] = g_cAllCards[i*3 + 1];
  293. MoveCard(pCardsMap->Center0[i].m_nX,
  294. Center_y0,
  295. Card_x,
  296. Card_y,
  297. pCenterCards->m_cCards[i].m_nColor,
  298. pCenterCards->m_cCards[i].m_nValue,
  299. 100);
  300. pCenterCards->m_nCardsCounter++;
  302. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  303. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  304. //发牌给右边玩家;
  305. pRightCards->m_cCards[i] = g_cAllCards[i*3 + 2];  
  306. MoveCard(Right_x0,
  307. pCardsMap->Right0[i].m_nY,
  308. Card_x,
  309. Card_y,
  310. 0,
  311. 17);
  312. pRightCards->m_nCardsCounter++;
  313. }
  315. //测试用牌;
  316. // int j;
  317. // for(j=0;j<17;j++)
  318. // {
  319. // pCenterCards->m_cCards[j].m_nValue = 3+j/4;
  320. // }
  321. /*
  322. pCenterCards->m_cCards[0].m_nValue = 4;
  323. pCenterCards->m_cCards[1].m_nValue = 4;
  324. pCenterCards->m_cCards[2].m_nValue = 4;
  325. pCenterCards->m_cCards[3].m_nValue = 4;
  326. pCenterCards->m_cCards[4].m_nValue = 8;
  327. pCenterCards->m_cCards[5].m_nValue = 8;
  328. pCenterCards->m_cCards[6].m_nValue = 8;
  329. pCenterCards->m_cCards[7].m_nValue = 8;
  330. pCenterCards->m_cCards[8].m_nValue = 11;
  331. pCenterCards->m_cCards[9].m_nValue = 11;
  332. pCenterCards->m_cCards[10].m_nValue = 11;
  333. pCenterCards->m_cCards[12].m_nValue = 11;
  334. pCenterCards->m_cCards[13].m_nValue = 3;
  335. pCenterCards->m_cCards[14].m_nValue = 3;
  336. pCenterCards->m_cCards[15].m_nValue = 3;
  337. pCenterCards->m_cCards[16].m_nValue = 3;
  338. // for(j=0;j<17;j++)
  339. // {
  340. // pRightCards->m_cCards[j].m_nValue = 4+j/4;
  341. // }
  342. */
  343. /*
  344. pRightCards->m_cCards[0].m_nValue = 3;
  345. pRightCards->m_cCards[1].m_nValue = 3;
  346. pRightCards->m_cCards[2].m_nValue = 4;
  348. pRightCards->m_cCards[3].m_nValue = 4;
  349. pRightCards->m_cCards[4].m_nValue = 5;
  350. pRightCards->m_cCards[5].m_nValue = 5;
  351. pRightCards->m_cCards[6].m_nValue = 9;
  352. pRightCards->m_cCards[7].m_nValue = 9;
  353. pRightCards->m_cCards[8].m_nValue = 9;
  355. pRightCards->m_cCards[9].m_nValue = 8;
  356. pRightCards->m_cCards[10].m_nValue = 11;
  357. pRightCards->m_cCards[11].m_nValue = 11;
  358. pRightCards->m_cCards[12].m_nValue = 13;
  359. pRightCards->m_cCards[13].m_nValue = 13;
  360. pRightCards->m_cCards[14].m_nValue = 13;
  362. pRightCards->m_cCards[15].m_nValue = 16;
  363. pRightCards->m_cCards[15].m_nColor = 0;
  364. pRightCards->m_cCards[16].m_nValue = 16;
  365. pRightCards->m_cCards[16].m_nColor = 1;
  366. */
  367. // for(j=0;j<17;j++)
  368. // {
  369. // pLeftCards->m_cCards[j].m_nValue = 7+j/4;
  370. // }
  372. // pLeftCards->m_cCards[0].m_nValue = 3;
  373. // pLeftCards->m_cCards[1].m_nValue = 3;
  374. // pLeftCards->m_cCards[12].m_nValue = 4;
  375. // pLeftCards->m_cCards[13].m_nValue = 4;
  379. //开始向上发地主牌;
  380. //第一张地主牌;
  381. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  382. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  383. MoveCard(Lord_Card1_x,
  384. Lord_Card1_y,
  385. Card_x,
  386. Card_y,
  387. 0,
  388. 17,
  389. 50);
  391. pCardsMap->m_cLordCards[0].m_bVisual = 1;
  393. ::RedrawGame();
  395. //第二张地主牌;
  396. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  397. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  398. MoveCard(Lord_Card2_x,
  399. Lord_Card2_y,
  400. Card_x,
  401. Card_y,
  402. 0,
  403. 17,
  404. 50);
  406. pCardsMap->m_cLordCards[1].m_bVisual = 1;
  408. ::RedrawGame();
  409. //第三张地主牌;
  410. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  411. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  412. MoveCard(Lord_Card3_x,
  413. Lord_Card3_y,
  414. Card_x,
  415. Card_y,
  416. 0,
  417. 17,
  418. 50);
  419. pCardsMap->m_cLordCards[2].m_bVisual = 1;
  421. pCardsMap->m_cDistributeCard.m_bVisual = 0;   //让中间发的牌不可见;
  422. ::RedrawGame();
  424. DrawCleanUp();
  426. // Sleep(60000);
  427. return 1;
  428. }
  429. //发地主牌;
  430. int CDrawCardsEngine::DealingLord(int bLord)
  431. {
  432. pCardsMap->m_nLordCards = 2;
  433. ::RedrawGame();
  434. if(bLord == 0)
  435. {
  436. //发地主牌给左边玩家;
  437. //第一张;
  438. pLeftCards->m_cCards[17]  = g_cAllCards[51];  //第十八张牌;
  439. MoveCard(Left_x0,
  440.  pCardsMap->Left0[17].m_nY,
  441.  Lord_Card1_x,
  442.  Lord_Card1_y,
  443.  pLeftCards->m_cCards[17].m_nColor,
  444.  pLeftCards->m_cCards[17].m_nValue,
  445.  80);
  447. pLeftCards->m_nCardsCounter++;  //m_nCardsCounter =18
  449. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  450. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  451. // ::Redraw_Game();
  452. //第二张;
  453. pLeftCards->m_cCards[18]  = g_cAllCards[52];
  454. MoveCard(Left_x0,
  455.  pCardsMap->Left0[18].m_nY,
  456.  Lord_Card2_x,
  457.  Lord_Card2_y,
  458.  pLeftCards->m_cCards[18].m_nColor,
  459.  pLeftCards->m_cCards[18].m_nValue,
  460.  80);
  461. pLeftCards->m_nCardsCounter++; //m_nCardsCounter =19
  462. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  463. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  464. // ::Redraw_Game();
  466. //第三张;
  467. pLeftCards->m_cCards[19]  = g_cAllCards[53];
  468. MoveCard(Left_x0,
  469.  pCardsMap->Left0[19].m_nY,
  470.  Lord_Card3_x,
  471.  Lord_Card3_y,
  472.  pLeftCards->m_cCards[19].m_nColor,
  473.  pLeftCards->m_cCards[19].m_nValue,
  474.  80);
  475. pLeftCards->m_nCardsCounter++;  //m_nCardsCounter =20
  477. pLeftCards->m_nCardsTable[pLeftCards->m_cCards[17].m_nValue]++;
  478. pLeftCards->m_nCardsTable[pLeftCards->m_cCards[18].m_nValue]++;
  479. pLeftCards->m_nCardsTable[pLeftCards->m_cCards[19].m_nValue]++;
  481. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  482. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  483. ::RedrawGame();
  484. }
  485. else if(bLord == 1)
  486. {
  487. //发地主牌给中间玩家;
  488. //第一张;
  489. pCenterCards->m_cCards[17]  = g_cAllCards[51];  //第十八张牌;
  490. MoveCard(pCardsMap->Center0[17].m_nX,
  491.  Center_y0,
  492.  Lord_Card1_x,
  493.  Lord_Card1_y,
  494.  pCenterCards->m_cCards[17].m_nColor,
  495.  pCenterCards->m_cCards[17].m_nValue,
  496.  80);
  497. pCenterCards->m_nCardsCounter++;  //m_nCardsCounter =18
  498. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  499. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  500. // ::Redraw_Game();
  501. //第二张;
  503. pCenterCards->m_cCards[18]  = g_cAllCards[52];
  504. MoveCard(pCardsMap->Center0[18].m_nX,
  505.  Center_y0,
  506.  Lord_Card2_x,
  507.  Lord_Card2_y,
  508.  pCenterCards->m_cCards[18].m_nColor,
  509.  pCenterCards->m_cCards[18].m_nValue,
  510.  80);
  511. pCenterCards->m_nCardsCounter++; //m_nCardsCounter =19
  512. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  513. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  514. // ::Redraw_Game();
  516. //第三张;
  517. pCenterCards->m_cCards[19]  = g_cAllCards[53];
  518. MoveCard(pCardsMap->Center0[19].m_nX,
  519.  Center_y0,
  520.  Lord_Card3_x,
  521.  Lord_Card3_y,
  522.  pCenterCards->m_cCards[19].m_nColor,
  523.  pCenterCards->m_cCards[19].m_nValue,
  524.  80);
  525. pCenterCards->m_nCardsCounter++;  //m_nCardsCounter =20
  526. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  527. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  528. ::RedrawGame();
  529. //拿到地主牌后再整理一次;
  530. DrawCleanUp();
  531. }
  532. else if(bLord == 2)
  533. {
  534. //发地主牌给右边玩家;
  535. //第一张;
  536. pRightCards->m_cCards[17]  = g_cAllCards[51];  //第十八张牌;
  537. MoveCard(Right_x0,
  538.    pCardsMap->Right0[17].m_nY,
  539.  Lord_Card1_x,
  540.  Lord_Card1_y,
  541.  pRightCards->m_cCards[17].m_nColor,
  542.  pRightCards->m_cCards[17].m_nValue,
  543.  80);
  544. pRightCards->m_nCardsCounter++;  //m_nCardsCounter =18
  545. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  546. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  547. // ::Redraw_Game();
  548. //第二张;
  550. pRightCards->m_cCards[18]  = g_cAllCards[52];
  551. MoveCard(Right_x0,
  552.  pCardsMap->Right0[18].m_nY,
  553.  Lord_Card2_x,
  554.    Lord_Card2_y,
  555.  pRightCards->m_cCards[18].m_nColor,
  556.  pRightCards->m_cCards[18].m_nValue,
  557.  80);
  558. pRightCards->m_nCardsCounter++; //m_nCardsCounter =19
  559. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  560. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  561. // ::Redraw_Game();
  563. //第三张;
  564. pRightCards->m_cCards[19] = g_cAllCards[53];
  565. MoveCard(Right_x0,
  566.  pCardsMap->Right0[19].m_nY,
  567.  Lord_Card3_x,
  568.  Lord_Card3_y,
  569.  pRightCards->m_cCards[19].m_nColor,
  570.  pRightCards->m_cCards[19].m_nValue,
  571.  80);
  572. pRightCards->m_nCardsCounter++;  //m_nCardsCounter =20
  574. pRightCards->m_nCardsTable[pRightCards->m_cCards[17].m_nValue]++;
  575. pRightCards->m_nCardsTable[pRightCards->m_cCards[18].m_nValue]++;
  576. pRightCards->m_nCardsTable[pRightCards->m_cCards[19].m_nValue]++;
  578. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  579. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  581. ::RedrawGame();
  582. }
  583. pLeftCards->CleanUp();
  584. pRightCards->CleanUp();
  585. ::RedrawGame();
  586. return 1;
  587. }
  588. //中间(本机)玩家出牌;
  589. int CDrawCardsEngine::CenterDiscarding()
  590. {
  591. ///检查出牌的合法性,调用CPlaying_Cards的方法;
  593. int counter = 0;
  595. pCenterCards->m_nDiscardingCounter = 0;
  597. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  598. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  600. for(int i=0;i<pCenterCards->m_nCardsCounter;i++)
  601. {
  602. if(pCardsMap->Center0[i].m_nY == Center_y0 - Card_Up)
  603. {
  604. //移动提起的牌到刚出牌区;
  605. pCardsMap->Center0[i].m_bVisual = 0;
  607. MoveCard(pCardsMap->Center2[pCenterCards->m_nDiscardingCounter].m_nX,
  608. pCardsMap->Center2[pCenterCards->m_nDiscardingCounter].m_nY,
  609. pCardsMap->Center0[i].m_nX,
  610. pCardsMap->Center0[i].m_nY,
  611.     pCenterCards->m_cCards[i].m_nColor,
  612. pCenterCards->m_cCards[i].m_nValue,
  613. 80);
  615. pCardsMap->Center0[i].m_nY += Card_Up;
  617. pCenterCards->m_cCards[i].m_nColor = 4;   //花色为4表示已经出过牌;
  618. pCenterCards->m_cCards[i].m_nValue = 17;   //值为17表示已经出过牌;
  619. counter++;
  620. pCenterCards->m_nDiscardingCounter++;
  621. }
  622. }
  623. //将中间(本机)的牌置为可见;
  624. for(int j=0;j<pCenterCards->m_nCardsCounter;j++)
  625. {
  626. pCardsMap->Center0[j].m_bVisual = 1;
  627. }
  628. DrawCleanUp();
  629. pCenterCards->m_nCardsCounter -= counter;
  630. // pCenterCards->m_nDiscardingCounter = 0;
  632. pCardsMap->m_nUpCounter = 0;  //提起牌数为0;
  634. return 1;
  635. }
  636. //本机玩家刚出的牌从刚出牌区移动到已经出牌区;
  637. int CDrawCardsEngine::CenterBacking()
  638. {
  639. int temp_counter = pCenterCards->m_nDiscardingCounter ;
  641. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  642. SND_RESOURCE|SND_NODEFAULT );  //
  644. for(int i=0;i<temp_counter;i++)
  645. {
  646. //移动提起的牌到刚出牌区;
  648. MoveCard(pCardsMap->Center1[pCenterCards->m_nDiscardedCounter].m_nX,
  649. pCardsMap->Center1[pCenterCards->m_nDiscardedCounter].m_nY,
  650. pCardsMap->Center2[i].m_nX,
  651. pCardsMap->Center2[i].m_nY,
  652. pCenterCards->m_cDiscarding[i].m_nColor,
  653. pCenterCards->m_cDiscarding[i].m_nValue,
  654. 100);
  656. pCenterCards->m_nDiscardingCounter--;
  658. pCenterCards->m_cDiscarded[pCenterCards->m_nDiscardedCounter] = pCenterCards->m_cDiscarding[i];
  659. pCenterCards->m_nDiscardedCounter++;
  661. }
  662. ::RedrawGame();
  663. return 1;
  664. }
  665. //左边玩家出牌;
  666. int CDrawCardsEngine::LeftDiscarding()  
  667. {
  668. int temp_counter = pLeftCards->m_nDiscardingCounter;
  670. pLeftCards->m_nDiscardingCounter = 0;
  672. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  673. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  675. for(int i=0;i<temp_counter;i++)
  676. {
  678. //移动提起的牌到刚出牌区;
  679. MoveCard(pCardsMap->Left2[i].m_nX,
  680. pCardsMap->Left2[i].m_nY,
  681. pCardsMap->Left0[pLeftCards->m_nCardsCounter - 1].m_nX,
  682. pCardsMap->Left0[pLeftCards->m_nCardsCounter - 1].m_nY,
  683. pLeftCards->m_cDiscarding[i].m_nColor,
  684. pLeftCards->m_cDiscarding[i].m_nValue,
  685. 100);
  687. pLeftCards->m_nDiscardingCounter++;
  688. pLeftCards->m_nCardsCounter--;
  689. }
  690. // ::Redraw_Game();
  691. return 1;
  692. }
  693. //左边玩家刚出的牌从刚出牌区移动到已经出牌区;
  694. int CDrawCardsEngine::LeftBacking()
  695. {
  696. int temp_counter = pLeftCards->m_nDiscardingCounter ;
  698. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  699. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  701. for(int i=0;i<temp_counter;i++)
  702. {
  704. //移动提起的牌到刚出牌区;
  706. MoveCard(pCardsMap->Left1[pLeftCards->m_nDiscardedCounter].m_nX,
  707. pCardsMap->Left1[pLeftCards->m_nDiscardedCounter].m_nY,
  708. pCardsMap->Left2[i].m_nX,
  709. pCardsMap->Left2[i].m_nY,
  710. pLeftCards->m_cDiscarding[i].m_nColor,
  711. pLeftCards->m_cDiscarding[i].m_nValue,
  712. 140);
  714. pLeftCards->m_nDiscardingCounter--;
  716. pLeftCards->m_cDiscarded[pLeftCards->m_nDiscardedCounter] = pLeftCards->m_cDiscarding[i];
  717. pLeftCards->m_nDiscardedCounter++;
  719. }
  720. ::RedrawGame();
  721. return 1;
  722. }
  723. //右边玩家出牌;
  724. int CDrawCardsEngine::RightDiscarding()
  725. {
  726. int temp_counter = pRightCards->m_nDiscardingCounter;
  728. pRightCards->m_nDiscardingCounter = 0;
  730. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  731. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  732. for(int i=0;i<temp_counter;i++)
  733. {
  735. //移动提起的牌到刚出牌区;
  736. MoveCard(pCardsMap->Right2[i].m_nX,
  737. pCardsMap->Right2[i].m_nY,
  738. pCardsMap->Right0[pRightCards->m_nCardsCounter - 1].m_nX,
  739. pCardsMap->Right0[pRightCards->m_nCardsCounter - 1].m_nY,
  740. pRightCards->m_cDiscarding[i].m_nColor,
  741. pRightCards->m_cDiscarding[i].m_nValue,
  742. 100);
  744. pRightCards->m_nDiscardingCounter++;
  745. pRightCards->m_nCardsCounter--;
  746. }
  747. return 1;
  748. }
  749. //右边玩家刚出的牌从刚出牌区移动到已经出牌区;
  750. int CDrawCardsEngine::RightBacking()
  751. {
  752. int temp_counter = pRightCards->m_nDiscardingCounter ;
  754. PlaySound(MAKEINTRESOURCE(IDR_GIVE),AfxGetResourceHandle(),
  755. SND_ASYNC|SND_RESOURCE|SND_NODEFAULT );  //
  757. for(int i=0;i<temp_counter;i++)
  758. {
  760. //移动提起的牌到刚出牌区;
  762. MoveCard(pCardsMap->Right1[pLeftCards->m_nDiscardedCounter].m_nX,
  763. pCardsMap->Right1[pLeftCards->m_nDiscardedCounter].m_nY,
  764. pCardsMap->Right2[i].m_nX,
  765. pCardsMap->Right2[i].m_nY,
  766. pRightCards->m_cDiscarding[i].m_nColor,
  767. pRightCards->m_cDiscarding[i].m_nValue,
  768. 140);
  770. pRightCards->m_nDiscardingCounter--;
  772. pRightCards->m_cDiscarded[pRightCards->m_nDiscardedCounter] = pRightCards->m_cDiscarding[i];
  773. pRightCards->m_nDiscardedCounter++;
  775. }
  776. ::RedrawGame();
  777. return 1;
  778. }
  779. //重画;
  780. void CDrawCardsEngine::Redraw(LPDIRECTDRAWSURFACE7  pSurface)
  781. {
  782. //左边未出的牌;
  783. int i;
  784. if( m_bVisual )
  785. {
  786. for(i=0;i<pLeftCards->m_nCardsCounter;i++)
  787. {
  788. if(pCardsMap->Left0[i].m_bVisual == 1)
  789. {
  790. DrawCard(pCardsMap->Left0[i].m_nX,
  791.  pCardsMap->Left0[i].m_nY,
  792.  pLeftCards->m_cCards[i].m_nColor,
  793.  pLeftCards->m_cCards[i].m_nValue);
  794. }
  795. }
  796. }
  797. else//
  798. {
  799. for(i=0;i<pLeftCards->m_nCardsCounter;i++)
  800. {
  801. if(pCardsMap->Left0[i].m_bVisual == 1)
  802. {
  803. DrawCard(pCardsMap->Left0[i].m_nX,
  804.  pCardsMap->Left0[i].m_nY,
  805.  0,
  806.  17);
  807. }
  808. }
  809. }
  810. //左边已经出的牌;
  811. for(i=0;i<pLeftCards->m_nDiscardedCounter;i++)
  812. {
  813. if(pCardsMap->Left1[i].m_bVisual == 1)
  814. {
  815. DrawCard(pCardsMap->Left1[i].m_nX,
  816.  pCardsMap->Left1[i].m_nY,
  817.  pLeftCards->m_cDiscarded[i].m_nColor,
  818.  pLeftCards->m_cDiscarded[i].m_nValue);
  819. }
  820. }
  821. //左边刚出的牌;
  822. for(i=0;i<pLeftCards->m_nDiscardingCounter;i++)
  823. {
  824. if(pCardsMap->Left2[i].m_bVisual == 1)
  825. {
  826. DrawCard(pCardsMap->Left2[i].m_nX,
  827.  pCardsMap->Left2[i].m_nY,
  828.  pLeftCards->m_cDiscarding[i].m_nColor,
  829.  pLeftCards->m_cDiscarding[i].m_nValue);
  830. }
  831. }
  832. //中间未出的牌;
  833. for(i=0;i<pCenterCards->m_nCardsCounter;i++)
  834. {
  835. if(pCardsMap->Center0[i].m_bVisual == 1)
  836. {
  837. DrawCard(pCardsMap->Center0[i].m_nX,
  838. pCardsMap->Center0[i].m_nY,
  839. pCenterCards->m_cCards[i].m_nColor,
  840. pCenterCards->m_cCards[i].m_nValue);
  841. }
  842. }
  843. //中间已经出的牌;
  844. for(i=0;i<pCenterCards->m_nDiscardedCounter;i++)
  845. {
  846. if(pCardsMap->Center1[i].m_bVisual == 1)
  847. {
  848. DrawCard(pCardsMap->Center1[i].m_nX,
  849.  pCardsMap->Center1[i].m_nY,
  850.  pCenterCards->m_cDiscarded[i].m_nColor,
  851.  pCenterCards->m_cDiscarded[i].m_nValue);
  852. }
  853. }
  854. //中间刚出的牌;
  855. for(i=0;i<pCenterCards->m_nDiscardingCounter;i++)
  856. {
  857. if(pCardsMap->Center2[i].m_bVisual == 1)
  858. {
  859. DrawCard(pCardsMap->Center2[i].m_nX,
  860.  pCardsMap->Center2[i].m_nY,
  861.  pCenterCards->m_cDiscarding[i].m_nColor,
  862.  pCenterCards->m_cDiscarding[i].m_nValue);
  863. }
  864. }
  865. //右边未出的牌;
  866. if( m_bVisual )
  867. {
  868. for(i=0;i<pRightCards->m_nCardsCounter;i++)
  869. {
  870. if(pCardsMap->Right0[i].m_bVisual == 1)
  871. {
  872. DrawCard(pCardsMap->Right0[i].m_nX,
  873.  pCardsMap->Right0[i].m_nY,
  874.  pRightCards->m_cCards[i].m_nColor,
  875.  pRightCards->m_cCards[i].m_nValue);
  876. }
  877. }
  878. }
  879. else
  880. {
  881. for(i=0;i<pRightCards->m_nCardsCounter;i++)
  882. {
  883. if(pCardsMap->Right0[i].m_bVisual == 1)
  884. {
  885. DrawCard(pCardsMap->Right0[i].m_nX,
  886.  pCardsMap->Right0[i].m_nY,
  887.  0,
  888.  17);
  889. }
  890. }
  891. }
  892. //右边已经出的牌;
  893. for(i=0;i<pRightCards->m_nDiscardedCounter;i++)
  894. {
  895. if(pCardsMap->Right1[i].m_bVisual == 1)
  896. {
  897. DrawCard(pCardsMap->Right1[i].m_nX,
  898.  pCardsMap->Right1[i].m_nY,
  899.  pRightCards->m_cDiscarded[i].m_nColor,
  900.  pRightCards->m_cDiscarded[i].m_nValue);
  901. }
  902. }
  903. //右边刚出的牌;
  904. for(i=0;i<pRightCards->m_nDiscardingCounter;i++)
  905. {
  906. if(pCardsMap->Right2[i].m_bVisual == 1)
  907. {
  908. DrawCard(pCardsMap->Right2[i].m_nX,
  909.  pCardsMap->Right2[i].m_nY,
  910.  pRightCards->m_cDiscarding[i].m_nColor,
  911.  pRightCards->m_cDiscarding[i].m_nValue);
  912. }
  913. }
  914. //正在发的牌;
  916. if(pCardsMap->m_cDistributeCard.m_bVisual == 1)
  917. {
  918. DrawCard(pCardsMap->m_cDistributeCard.m_nX,
  919.  pCardsMap->m_cDistributeCard.m_nY,
  920.  0,
  921.  17);
  922. }
  923. //陈列的三张地主牌;
  924. if(pCardsMap->m_nLordCards == 1)
  925. {
  926. for(i=0;i<3;i++)
  927. {
  928. if(pCardsMap->m_cLordCards[i].m_bVisual == 1)
  929. {
  930. DrawCard(pCardsMap->m_cLordCards[i].m_nX,
  931.  pCardsMap->m_cLordCards[i].m_nY,
  932.      0,
  933.  17);
  934. }
  935. }//end for
  936. }
  937. else if(pCardsMap->m_nLordCards == 2)
  938. {
  939. for(i=0;i<3;i++)
  940. {
  941. if(pCardsMap->m_cLordCards[i].m_bVisual == 1)
  942. {
  943. DrawCard(pCardsMap->m_cLordCards[i].m_nX,
  944.  pCardsMap->m_cLordCards[i].m_nY,
  945.  ::g_cAllCards[51+i].m_nColor,
  946.  ::g_cAllCards[51+i].m_nValue);
  947. }
  948. }//end for
  949. }
  950. }