zhaobu
/
zhujimajiang_redis
1
0
Vork 0
Code Kwesties 0 Pull-aanvragen 0 Publicaties 0 Wiki Activiteit
诸暨麻将添加redis
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
2 Branches
57 MiB
 
 
 
 
 
 
Tree: 86964399f5
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van '86964399f5'
${ noResults }
zhujimajiang_redis/俱乐部/Games/Normal/松滋晃晃血流/游戏客户端/CardControl.cpp

1537 regels
40 KiB
Ruw Blame Geschiedenis 

  1. #include "StdAfx.h"

  2. #include "Resource.h"

  3. #include "CardControl.h"

  4. 

  5. //////////////////////////////////////////////////////////////////////////

  6. //宏定义

  7. 

  8. //公共定义

  9. #define POS_SHOOT					5									//弹起象素

  10. #define POS_SPACE					8									//分隔间隔

  11. #define ITEM_COUNT					28									//子项数目

  12. #define INVALID_ITEM				0xFFFF								//无效索引

  13. 

  14. //扑克大小

  15. #define CARD_WIDTH					45									//扑克宽度

  16. #define CARD_HEIGHT					72									//扑克高度

  17. 

  18. //////////////////////////////////////////////////////////////////////////

  19. 

  20. //构造函数

  21. CCardListImage::CCardListImage()

  22. {

  23. 	//位置变量

  24. 	m_nItemWidth=0;

  25. 	m_nItemHeight=0;

  26. 	m_nViewWidth=0;

  27. 	m_nViewHeight=0;

  28. 

  29. 	return;

  30. }

  31. 

  32. //析构函数

  33. CCardListImage::~CCardListImage()

  34. {

  35. }

  36. 

  37. //加载资源

  38. bool CCardListImage::LoadResource(LPCTSTR uResourceID, int nViewWidth, int nViewHeight)

  39. {

  40. 	//加载资源

  41. 	//m_CardListImage.LoadFromResource(AfxGetInstanceHandle(),uResourceID);

  42. 	m_CardListImage.LoadImage(AfxGetInstanceHandle(),uResourceID);

  43. 

  44. 	//设置变量

  45. 	m_nViewWidth=nViewWidth;

  46. 	m_nViewHeight=nViewHeight;

  47. 	m_nItemHeight=m_CardListImage.GetHeight();

  48. 	m_nItemWidth=m_CardListImage.GetWidth()/ITEM_COUNT;

  49. 

  50. 	return true;

  51. }

  52. 

  53. //释放资源

  54. bool CCardListImage::DestroyResource()

  55. {

  56. 	//设置变量

  57. 	m_nItemWidth=0;

  58. 	m_nItemHeight=0;

  59. 

  60. 	//释放资源

  61. 	//m_CardListImage.Destroy();

  62. 

  63. 	return true;

  64. }

  65. 

  66. //获取位置

  67. int CCardListImage::GetImageIndex(BYTE cbCardData)

  68. {

  69. 	//背景判断

  70. 	if (cbCardData==0) 

  71. 		return 0;

  72. 

  73. 	//计算位置

  74. 	BYTE cbValue=cbCardData&MASK_VALUE;

  75. 	BYTE cbColor=(cbCardData&MASK_COLOR)>>4;

  76. 	return (cbColor>=0x03)?(cbValue+27):(cbColor*9+cbValue);

  77. }

  78. 

  79. //绘画扑克

  80. bool CCardListImage::DrawCardItem(CDC * pDestDC, BYTE cbCardData, int xDest, int yDest)

  81. {

  82. 	//效验状态

  83. 	ASSERT(m_CardListImage.IsNull()==false);

  84. 	ASSERT((m_nItemWidth!=0)&&(m_nItemHeight!=0));

  85. 

  86. 	//绘画子项

  87. 	if(cbCardData<=0x37)

  88. 	{

  89. 		int nImageXPos=GetImageIndex(cbCardData)*m_nItemWidth;

  90. 		//m_CardListImage.AlphaDrawImage(pDestDC,xDest,yDest,m_nItemWidth,m_nItemHeight,nImageXPos,0,RGB(255,0,255));

  91. 		m_CardListImage.DrawImage(pDestDC,

  92. 									xDest,	//X坐标

  93. 									yDest,	//Y坐标

  94. 									m_CardListImage.GetWidth()/28,				//宽

  95. 									m_CardListImage.GetHeight(),				//高

  96. 									nImageXPos,//起始位置X

  97. 									0);

  98. 	}

  99. 	return true;

  100. }

  101. 

  102. //////////////////////////////////////////////////////////////////////////

  103. 

  104. //构造函数

  105. CCardResource::CCardResource()

  106. {

  107. }

  108. 

  109. //析构函数

  110. CCardResource::~CCardResource()

  111. {

  112. }

  113. 

  114. //加载资源

  115. bool CCardResource::LoadResource()

  116. {

  117. 	//变量定义

  118. 	HINSTANCE hInstance=AfxGetInstanceHandle();

  119. 

  120. 	//用户扑克

  121. 	m_ImageUserTop.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_USER_TOP"));

  122. 	m_ImageUserBottom.LoadResource(TEXT("CARD_USER_BOTTOM"),CARD_WIDTH,CARD_HEIGHT);

  123. 

  124. 	m_ImageUserLeft.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_USER_LEFT"));

  125. 	m_ImageUserRight.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_USER_RIGHT"));

  126. 

  127. 	//桌子扑克

  128. 	m_ImageTableTop.LoadResource(TEXT("CARD_TABLE_TOP"),31,64);

  129. 	m_ImageTableLeft.LoadResource(TEXT("CARD_TABLE_LEFT"),53,35);

  130. 	m_ImageTableRight.LoadResource(TEXT("CARD_TABLE_RIGHT"),53,35);

  131. 	m_ImageTableBottom.LoadResource(TEXT("CARD_TABLE_BOTTOM"),34,70);

  132. 

  133. 	//左边

  134. 	m_ImageHeapDoubleLV.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_HEAP_DOUBLE_LV"));

  135. 	m_ImageHeapSingleLV.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_HEAP_SINGLE_LV"));

  136. 

  137. 	//右边

  138. 	m_ImageHeapDoubleRV.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_HEAP_DOUBLE_RV"));

  139. 	m_ImageHeapSingleRV.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_HEAP_SINGLE_RV"));

  140. 	

  141. 	//上面的

  142. 	m_ImageHeapDoubleTV.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_HEAP_DOUBLE_TV"));

  143. 	m_ImageHeapSingleTV.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_HEAP_SINGLE_TV"));

  144. 

  145. 	//下面的

  146. 	m_ImageHeapDoubleBV.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_HEAP_DOUBLE_BV"));

  147. 	m_ImageHeapSingleBV.LoadImage(AfxGetInstanceHandle(),TEXT("CARD_HEAP_SINGLE_BV"));

  148. 	

  149. 	//m_ImageArrow.LoadImage(AfxGetInstanceHandle(),TEXT("ARROW"));

  150. 

  151. 	return true;

  152. }

  153. 

  154. //消耗资源

  155. bool CCardResource::DestroyResource()

  156. {

  157. 	//用户扑克

  158. 	m_ImageUserBottom.DestroyResource();

  159. 

  160. 	//桌子扑克

  161. 	m_ImageTableTop.DestroyResource();

  162. 	m_ImageTableLeft.DestroyResource();

  163. 	m_ImageTableRight.DestroyResource();

  164. 	m_ImageTableBottom.DestroyResource();

  165. 

  166. 	return true;

  167. }

  168. 

  169. //////////////////////////////////////////////////////////////////////////

  170. 

  171. //构造函数

  172. CHeapCard::CHeapCard()

  173. {

  174. 	//控制变量

  175. 	m_ControlPoint.SetPoint(0,0);

  176. 	m_CardDirection=Direction_East;

  177. 

  178. 	//扑克变量

  179. 	m_wFullCount=0;

  180. 	m_wMinusHeadCount=0;

  181. 	m_wMinusLastCount=0;

  182. 

  183. 	return;

  184. }

  185. 

  186. //析构函数

  187. CHeapCard::~CHeapCard()

  188. {

  189. }

  190. 

  191. //绘画扑克

  192. void CHeapCard::DrawCardControl(CDC * pDC)

  193. {

  194. 	int nOffset=3;	//偏移量

  195. 

  196. 	switch (m_CardDirection)

  197. 	{

  198. 	case Direction_East:	//东向   右		右

  199. 		{

  200. 			//绘画扑克

  201. 			if ((m_wFullCount-m_wMinusHeadCount-m_wMinusLastCount)>0)

  202. 			{

  203. 				//变量定义

  204. 				int nXPos=0,nYPos=0;

  205. 				WORD wHeapIndex=m_wMinusHeadCount/2;

  206. 				WORD wDoubleHeap=(m_wMinusHeadCount+1)/2;

  207. 				WORD wDoubleLast=(m_wFullCount-m_wMinusLastCount)/2;

  208. 				WORD wFinallyIndex=(m_wFullCount-m_wMinusLastCount)/2;

  209. 

  210. 				//头部扑克

  211. 				if (m_wMinusHeadCount%2!=0)

  212. 				{

  213. 					nXPos=m_ControlPoint.x + wHeapIndex*nOffset;

  214. 					nYPos=m_ControlPoint.y+wHeapIndex*16+13;

  215. 

  216. 					g_CardResource.m_ImageHeapSingleRV.DrawImage(pDC,

  217. 									nXPos,	//X坐标

  218. 									nYPos,	//Y坐标

  219. 									g_CardResource.m_ImageHeapSingleRV.GetWidth(),				//宽

  220. 									g_CardResource.m_ImageHeapSingleRV.GetHeight(),				//高

  221. 									0,//起始位置X

  222. 									0);

  223. 				}

  224. 

  225. 				//中间扑克

  226. 				for (WORD i=wDoubleHeap;i<wFinallyIndex;i++)

  227. 				{

  228. 					nXPos=m_ControlPoint.x + i*nOffset;

  229. 					nYPos=m_ControlPoint.y+i*16;

  230. 

  231. 					g_CardResource.m_ImageHeapDoubleRV.DrawImage(pDC,

  232. 									nXPos,	//X坐标

  233. 									nYPos,	//Y坐标

  234. 									g_CardResource.m_ImageHeapDoubleRV.GetWidth(),				//宽

  235. 									g_CardResource.m_ImageHeapDoubleRV.GetHeight(),				//高

  236. 									0,//起始位置X

  237. 									0);

  238. 				}

  239. 

  240. 				//尾部扑克

  241. 				if (m_wMinusLastCount%2!=0)

  242. 				{

  243. 					nXPos=m_ControlPoint.x + wFinallyIndex*nOffset;

  244. 					nYPos=m_ControlPoint.y+wFinallyIndex*16+13;

  245. 

  246. 					g_CardResource.m_ImageHeapSingleRV.DrawImage(pDC,

  247. 									nXPos,	//X坐标

  248. 									nYPos,	//Y坐标

  249. 									g_CardResource.m_ImageHeapSingleRV.GetWidth(),				//宽

  250. 									g_CardResource.m_ImageHeapSingleRV.GetHeight(),				//高

  251. 									0,//起始位置X

  252. 									0);

  253. 				}

  254. 			}

  255. 			

  256. 			break;

  257. 		}

  258. 	case Direction_South:	//南向	下

  259. 		{

  260. 			//绘画扑克

  261. 			if ((m_wFullCount-m_wMinusHeadCount-m_wMinusLastCount)>0)

  262. 			{

  263. 				//变量定义

  264. 				int nXPos=0,nYPos=0;

  265. 				WORD wHeapIndex=m_wMinusLastCount/2;

  266. 				WORD wDoubleHeap=(m_wMinusLastCount+1)/2;

  267. 				WORD wDoubleLast=(m_wFullCount-m_wMinusHeadCount)/2;

  268. 				WORD wFinallyIndex=(m_wFullCount-m_wMinusHeadCount)/2;

  269. 

  270. 				//尾部扑克

  271. 				if (m_wMinusLastCount%2!=0)

  272. 				{

  273. 					nYPos=m_ControlPoint.y+16;

  274. 					nXPos=m_ControlPoint.x+wHeapIndex*34; //42

  275. 					g_CardResource.m_ImageHeapSingleBV.DrawImage(pDC,

  276. 									nXPos,	//X坐标

  277. 									nYPos,	//Y坐标

  278. 									g_CardResource.m_ImageHeapSingleBV.GetWidth(),				//宽

  279. 									g_CardResource.m_ImageHeapSingleBV.GetHeight(),				//高

  280. 									0,//起始位置X

  281. 									0);

  282. 				}

  283. 

  284. 				//中间扑克

  285. 				for (WORD i=wDoubleHeap;i<wFinallyIndex;i++)

  286. 				{

  287. 					nYPos=m_ControlPoint.y;

  288. 					nXPos=m_ControlPoint.x+i*34;

  289. 					

  290. 					g_CardResource.m_ImageHeapDoubleBV.DrawImage(pDC,

  291. 									nXPos,	//X坐标

  292. 									nYPos,	//Y坐标

  293. 									g_CardResource.m_ImageHeapDoubleBV.GetWidth(),				//宽

  294. 									g_CardResource.m_ImageHeapDoubleBV.GetHeight(),				//高

  295. 									0,//起始位置X

  296. 									0);

  297. 				}

  298. 

  299. 				//头部扑克

  300. 				if (m_wMinusHeadCount%2!=0)

  301. 				{

  302. 					nYPos=m_ControlPoint.y+16;

  303. 					nXPos=m_ControlPoint.x+wFinallyIndex*34;

  304. 

  305. 					g_CardResource.m_ImageHeapSingleBV.DrawImage(pDC,

  306. 									nXPos,	//X坐标

  307. 									nYPos,	//Y坐标

  308. 									g_CardResource.m_ImageHeapSingleBV.GetWidth(),				//宽

  309. 									g_CardResource.m_ImageHeapSingleBV.GetHeight(),				//高

  310. 									0,//起始位置X

  311. 									0);

  312. 				}

  313. 			}

  314. 			

  315. 			break;

  316. 		}

  317. 	case Direction_West:	//西向		左

  318. 		{

  319. 			//绘画扑克

  320. 			if ((m_wFullCount-m_wMinusHeadCount-m_wMinusLastCount)>0)

  321. 			{

  322. 				//变量定义

  323. 				int nXPos=0,nYPos=0;

  324. 				WORD wHeapIndex=m_wMinusLastCount/2;

  325. 				WORD wDoubleHeap=(m_wMinusLastCount+1)/2;

  326. 				WORD wDoubleLast=(m_wFullCount-m_wMinusHeadCount)/2;

  327. 				WORD wFinallyIndex=(m_wFullCount-m_wMinusHeadCount)/2;

  328. 

  329. 				//尾部扑克

  330. 				if (m_wMinusLastCount%2!=0)

  331. 				{

  332. 					nXPos=m_ControlPoint.x - wHeapIndex*nOffset;

  333. 					nYPos=m_ControlPoint.y+wHeapIndex*16+13;

  334. 

  335. 					g_CardResource.m_ImageHeapSingleLV.DrawImage(pDC,

  336. 									nXPos,	//X坐标

  337. 									nYPos,	//Y坐标

  338. 									g_CardResource.m_ImageHeapSingleLV.GetWidth(),				//宽

  339. 									g_CardResource.m_ImageHeapSingleLV.GetHeight(),				//高

  340. 									0,//起始位置X

  341. 									0);

  342. 				}

  343. 

  344. 				//中间扑克

  345. 				for (WORD i=wDoubleHeap;i<wFinallyIndex;i++)

  346. 				{

  347. 					nXPos=m_ControlPoint.x - i*nOffset;

  348. 					nYPos=m_ControlPoint.y+i*16;

  349. 				

  350. 					g_CardResource.m_ImageHeapDoubleLV.DrawImage(pDC,

  351. 									nXPos,	//X坐标

  352. 									nYPos,	//Y坐标

  353. 									g_CardResource.m_ImageHeapDoubleLV.GetWidth(),				//宽

  354. 									g_CardResource.m_ImageHeapDoubleLV.GetHeight(),				//高

  355. 									0,//起始位置X

  356. 									0);

  357. 				}

  358. 

  359. 				//头部扑克

  360. 				if (m_wMinusHeadCount%2!=0)

  361. 				{

  362. 					nXPos=m_ControlPoint.x - wFinallyIndex*nOffset;

  363. 					nYPos=m_ControlPoint.y+wFinallyIndex*16+13;

  364. 				

  365. 					g_CardResource.m_ImageHeapSingleLV.DrawImage(pDC,

  366. 									nXPos,	//X坐标

  367. 									nYPos,	//Y坐标

  368. 									g_CardResource.m_ImageHeapSingleLV.GetWidth(),				//宽

  369. 									g_CardResource.m_ImageHeapSingleLV.GetHeight(),				//高

  370. 									0,//起始位置X

  371. 									0);

  372. 				}

  373. 			}

  374. 			

  375. 			break;

  376. 		}

  377. 	case Direction_North:	//北向		上

  378. 		{

  379. 			//绘画扑克

  380. 			if ((m_wFullCount-m_wMinusHeadCount-m_wMinusLastCount)>0)

  381. 			{

  382. 				//变量定义

  383. 				int nXPos=0,nYPos=0;

  384. 				WORD wHeapIndex=m_wMinusHeadCount/2;

  385. 				WORD wDoubleHeap=(m_wMinusHeadCount+1)/2;

  386. 				WORD wDoubleLast=(m_wFullCount-m_wMinusLastCount)/2;

  387. 				WORD wFinallyIndex=(m_wFullCount-m_wMinusLastCount)/2;

  388. 

  389. 				//头部扑克

  390. 				if (m_wMinusHeadCount%2!=0)

  391. 				{

  392. 					nYPos=m_ControlPoint.y+15;

  393. 					nXPos=m_ControlPoint.x+wHeapIndex*31;

  394. 

  395. 					g_CardResource.m_ImageHeapSingleTV.DrawImage(pDC,

  396. 									nXPos,	//X坐标

  397. 									nYPos,	//Y坐标

  398. 									g_CardResource.m_ImageHeapSingleTV.GetWidth(),				//宽

  399. 									g_CardResource.m_ImageHeapSingleTV.GetHeight(),				//高

  400. 									0,//起始位置X

  401. 									0);

  402. 				}

  403. 

  404. 				//中间扑克

  405. 				for (WORD i=wDoubleHeap;i<wFinallyIndex;i++)

  406. 				{

  407. 					nYPos=m_ControlPoint.y;

  408. 					nXPos=m_ControlPoint.x+i*31;

  409. 

  410. 					g_CardResource.m_ImageHeapDoubleTV.DrawImage(pDC,

  411. 									nXPos,	//X坐标

  412. 									nYPos,	//Y坐标

  413. 									g_CardResource.m_ImageHeapDoubleTV.GetWidth(),				//宽

  414. 									g_CardResource.m_ImageHeapDoubleTV.GetHeight(),				//高

  415. 									0,//起始位置X

  416. 									0);

  417. 				}

  418. 

  419. 				//尾部扑克

  420. 				if (m_wMinusLastCount%2!=0)

  421. 				{

  422. 					nYPos=m_ControlPoint.y+15;

  423. 					nXPos=m_ControlPoint.x+wFinallyIndex*31;

  424. 

  425. 					g_CardResource.m_ImageHeapSingleTV.DrawImage(pDC,

  426. 									nXPos,	//X坐标

  427. 									nYPos,	//Y坐标

  428. 									g_CardResource.m_ImageHeapSingleTV.GetWidth(),				//宽

  429. 									g_CardResource.m_ImageHeapSingleTV.GetHeight(),				//高

  430. 									0,//起始位置X

  431. 									0);

  432. 				}

  433. 			}

  434. 			

  435. 			break;

  436. 		}

  437. 	}

  438. 

  439. 	return;

  440. }

  441. 

  442. //设置扑克

  443. bool CHeapCard::SetCardData(WORD wMinusHeadCount, WORD wMinusLastCount, WORD wFullCount)

  444. {

  445. 	//设置变量

  446. 	m_wFullCount=wFullCount;

  447. 	m_wMinusHeadCount=wMinusHeadCount;

  448. 	m_wMinusLastCount=wMinusLastCount;

  449. 

  450. 	return true;

  451. }

  452. 

  453. //////////////////////////////////////////////////////////////////////////

  454. 

  455. //构造函数

  456. CWeaveCard::CWeaveCard()

  457. {

  458. 	//状态变量

  459. 	m_bDisplayItem=false;

  460. 	m_ControlPoint.SetPoint(0,0);

  461. 	m_CardDirection=Direction_South;

  462. 	m_cbDirectionCardPos = 1;

  463. 	m_bGameEnd = false;

  464. 

  465. 	//扑克数据

  466. 	m_wCardCount=0;

  467. 	ZeroMemory(&m_cbCardData,sizeof(m_cbCardData));

  468. 

  469. 	return;

  470. }

  471. 

  472. //析构函数

  473. CWeaveCard::~CWeaveCard()

  474. {

  475. }

  476. 

  477. //绘画扑克

  478. void CWeaveCard::DrawCardControl(CDC * pDC)

  479. {

  480. 	//显示判断

  481. 	if (m_wCardCount==0) 

  482. 		return;

  483. 

  484. 	//变量定义

  485. 	int nXScreenPos=0,nYScreenPos=0;

  486. 	int nItemWidth=0,nItemHeight=0,nItemWidthEx=0,nItemHeightEx=0;

  487. 

  488. 	//绘画扑克

  489. 	switch (m_CardDirection)

  490. 	{

  491. 	case Direction_East:	//东向   右

  492. 		{

  493. 			//变量定义

  494. 			nItemWidth=g_CardResource.m_ImageTableRight.GetViewWidth();

  495. 			nItemHeight=g_CardResource.m_ImageTableRight.GetViewHeight()-18;

  496. 			nItemWidthEx=g_CardResource.m_ImageTableTop.GetViewWidth();

  497. 			nItemHeightEx=g_CardResource.m_ImageTableTop.GetViewHeight()-10;

  498. 

  499. 			nYScreenPos = m_ControlPoint.y;			

  500. 			//if(m_cbDirectionCardPos == 2)

  501. 			//{

  502. 			//	nXScreenPos=m_ControlPoint.x+nItemWidthEx;

  503. 			//	g_CardResource.m_ImageTableTop.DrawCardItem(pDC,GetCardData(2),nXScreenPos,nYScreenPos);

  504. 			//	nYScreenPos += nItemHeightEx;

  505. 			//}

  506. 			//else

  507. 			{

  508. 				nXScreenPos=m_ControlPoint.x+nItemWidthEx*2-nItemWidth;

  509. 				g_CardResource.m_ImageTableRight.DrawCardItem(pDC,GetCardData(2),nXScreenPos,nYScreenPos);

  510. 				nYScreenPos += nItemHeight;

  511. 			}

  512. 

  513. 

  514. 			//第二扑克

  515. 			nXScreenPos=m_ControlPoint.x+nItemWidthEx*2-nItemWidth + 3;

  516. 			g_CardResource.m_ImageTableRight.DrawCardItem(pDC,GetCardData(1),nXScreenPos,nYScreenPos);

  517. 			//第四扑克

  518. 			if (m_wCardCount==4)

  519. 			{

  520. 				g_CardResource.m_ImageTableRight.DrawCardItem(pDC,GetCardData(3),nXScreenPos,nYScreenPos-17);

  521. 			}

  522. 			nYScreenPos += nItemHeight;

  523. 

  524. 			//第一扑克

  525. 			//if(m_cbDirectionCardPos == 0)

  526. 			//{

  527. 			//	nXScreenPos=m_ControlPoint.x+nItemWidthEx + 6;

  528. 			//	g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,GetCardData(0),nXScreenPos,nYScreenPos);

  529. 			//}

  530. 			//else

  531. 			{

  532. 				nXScreenPos=m_ControlPoint.x+nItemWidthEx*2-nItemWidth +6;

  533. 				g_CardResource.m_ImageTableRight.DrawCardItem(pDC,GetCardData(0),nXScreenPos,nYScreenPos);

  534. 

  535. 			}

  536. 

  537. 			break;

  538. 		}

  539. 	case Direction_South:	//南向	下

  540. 		{

  541. 			//变量定义

  542. 			nItemWidth=g_CardResource.m_ImageTableBottom.GetViewWidth();

  543. 			nItemHeight=g_CardResource.m_ImageTableBottom.GetViewHeight();

  544. 			nItemWidthEx=g_CardResource.m_ImageTableRight.GetViewWidth();

  545. 			nItemHeightEx=g_CardResource.m_ImageTableRight.GetViewHeight();

  546. 

  547. 			//第三扑克

  548. 			nXScreenPos = m_ControlPoint.x;

  549. 			//if(m_cbDirectionCardPos == 2)

  550. 			//{

  551. 			//	nXScreenPos -= nItemWidthEx;

  552. 			//	nYScreenPos=m_ControlPoint.y+nItemHeightEx;

  553. 			//	g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(2),nXScreenPos,nYScreenPos);

  554. 			//}

  555. 			//else

  556. 			{

  557. 				nXScreenPos -= nItemWidth;

  558. 				nYScreenPos=m_ControlPoint.y+nItemHeightEx*2-nItemHeight;

  559. 				g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,GetCardData(2),nXScreenPos,nYScreenPos);

  560. 			}			

  561. 

  562. 			//第二扑克

  563. 			nXScreenPos -= nItemWidth;

  564. 			nYScreenPos=m_ControlPoint.y+nItemHeightEx*2-nItemHeight;

  565. 			g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,GetCardData(1),nXScreenPos,nYScreenPos);

  566. 			//第四扑克

  567. 			if (m_wCardCount==4)

  568. 			{

  569. 				g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,GetCardData(3),nXScreenPos,nYScreenPos-18);

  570. 			}

  571. 

  572. 

  573. 			//第一扑克

  574. 			//if(m_cbDirectionCardPos == 0)

  575. 			//{

  576. 			//	nXScreenPos -= nItemWidthEx;

  577. 			//	nYScreenPos=m_ControlPoint.y+nItemHeightEx;

  578. 			//	g_CardResource.m_ImageTableRight.DrawCardItem(pDC,GetCardData(0),nXScreenPos,nYScreenPos);

  579. 			//}

  580. 			//else

  581. 			{

  582. 				nXScreenPos -= nItemWidth;

  583. 				nYScreenPos=m_ControlPoint.y+nItemHeightEx*2-nItemHeight;

  584. 				g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,GetCardData(0),nXScreenPos,nYScreenPos);

  585. 			}

  586. 

  587. 

  588. 			break;

  589. 		}

  590. 	case Direction_West:	//西向	左

  591. 		{

  592. 			//变量定义

  593. 			nItemWidth=g_CardResource.m_ImageTableLeft.GetViewWidth();

  594. 			nItemHeight=g_CardResource.m_ImageTableLeft.GetViewHeight()-18;

  595. 			nItemWidthEx=g_CardResource.m_ImageTableBottom.GetViewWidth();

  596. 			nItemHeightEx=g_CardResource.m_ImageTableBottom.GetViewHeight()-10;

  597. 

  598. 			//if(m_cbDirectionCardPos != 1)

  599. 			{

  600. 				//第一扑克

  601. 				nYScreenPos=m_ControlPoint.y-nItemHeightEx-nItemHeight*2;

  602. 				//if(m_cbDirectionCardPos == 0)

  603. 				//{

  604. 				//	nXScreenPos=m_ControlPoint.x-nItemWidthEx*2;

  605. 				//	g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,GetCardData(0),nXScreenPos,nYScreenPos);

  606. 				//	nYScreenPos += nItemHeightEx;

  607. 				//}

  608. 				//else

  609. 				{

  610. 					nXScreenPos=m_ControlPoint.x-nItemWidthEx*2;

  611. 					g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(0),nXScreenPos,nYScreenPos);

  612. 					nYScreenPos += nItemHeight;

  613. 				}

  614. 				//第二扑克

  615. 				nXScreenPos=m_ControlPoint.x-nItemWidthEx*2 - 3;

  616. 				g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(1),nXScreenPos,nYScreenPos);

  617. 				//第四扑克

  618. 				if (m_wCardCount==4)

  619. 				{

  620. 					g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(3),nXScreenPos,nYScreenPos-17);

  621. 				}

  622. 				nYScreenPos += nItemHeight;

  623. 

  624. 				//第三扑克

  625. 				//if(m_cbDirectionCardPos == 2)

  626. 				//{

  627. 				//	nXScreenPos=m_ControlPoint.x-nItemWidthEx*2 - 6;

  628. 				//	g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,GetCardData(2),nXScreenPos,nYScreenPos);

  629. 				//}

  630. 				//else

  631. 				{

  632. 					nXScreenPos=m_ControlPoint.x-nItemWidthEx*2 - 6;

  633. 					g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(2),nXScreenPos,nYScreenPos);

  634. 				}

  635. 

  636. 			}

  637. 			//else

  638. 			//{			

  639. 			//	//第一扑克

  640. 			//	nYScreenPos = m_ControlPoint.y-nItemHeight*3;

  641. 			//	//nXScreenPos=m_ControlPoint.x-nItemWidth;

  642. 			//	nXScreenPos=m_ControlPoint.x-nItemWidthEx*2;

  643. 			//	g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(0),nXScreenPos,nYScreenPos);

  644. 			//	//第二扑克

  645. 			//	nYScreenPos += nItemHeight;

  646. 			//	g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(1),nXScreenPos,nYScreenPos);

  647. 			//	//第四扑克

  648. 			//	if (m_wCardCount==4)

  649. 			//	{

  650. 			//		g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(3),nXScreenPos,nYScreenPos-12);

  651. 			//	}

  652. 			//	//第三扑克

  653. 			//	nYScreenPos += nItemHeight;

  654. 			//	g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(2),nXScreenPos,nYScreenPos);

  655. 			//}

  656. 

  657. 			break;

  658. 		}

  659. 	case Direction_North:	//北向	上。

  660. 		{

  661. 			//变量定义

  662. 			nItemWidth=g_CardResource.m_ImageTableTop.GetViewWidth();

  663. 			nItemHeight=g_CardResource.m_ImageTableTop.GetViewHeight();

  664. 			nItemWidthEx=g_CardResource.m_ImageTableLeft.GetViewWidth();

  665. 			nItemHeightEx=g_CardResource.m_ImageTableLeft.GetViewHeight();

  666. 

  667. 			//第三扑克

  668. 			nXScreenPos = m_ControlPoint.x;

  669. 			//if(m_cbDirectionCardPos == 2)

  670. 			//{

  671. 			//	nYScreenPos = m_ControlPoint.y-nItemHeight;

  672. 			//	g_CardResource.m_ImageTableRight.DrawCardItem(pDC,GetCardData(2),nXScreenPos,nYScreenPos);

  673. 			//	nXScreenPos += nItemWidthEx;

  674. 			//}

  675. 			//else

  676. 			{

  677. 				nYScreenPos = m_ControlPoint.y-nItemHeight;

  678. 				g_CardResource.m_ImageTableTop.DrawCardItem(pDC,GetCardData(2),nXScreenPos,nYScreenPos);

  679. 				nXScreenPos += nItemWidth;

  680. 			}

  681. 

  682. 			//第二扑克

  683. 			nYScreenPos = m_ControlPoint.y-nItemHeight;

  684. 			g_CardResource.m_ImageTableTop.DrawCardItem(pDC,GetCardData(1),nXScreenPos,nYScreenPos);			

  685. 			//第四扑克

  686. 			if (m_wCardCount==4)

  687. 			{

  688. 				g_CardResource.m_ImageTableTop.DrawCardItem(pDC,GetCardData(3),nXScreenPos,nYScreenPos-17);

  689. 			}

  690. 			nXScreenPos += nItemWidth;

  691. 

  692. 

  693. 			//第一扑克

  694. 			//if(m_cbDirectionCardPos == 0)

  695. 			//{

  696. 			//	nYScreenPos=m_ControlPoint.y-nItemHeight;			

  697. 			//	g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(0),nXScreenPos,nYScreenPos);

  698. 			//}

  699. 			//else

  700. 			{

  701. 				nYScreenPos=m_ControlPoint.y-nItemHeight;		

  702. 				g_CardResource.m_ImageTableTop.DrawCardItem(pDC,GetCardData(0),nXScreenPos,nYScreenPos);

  703. 			}

  704. 

  705. 

  706. 			break;

  707. 		}

  708. 	}

  709. 

  710. 	return;

  711. }

  712. 

  713. //设置扑克

  714. bool CWeaveCard::SetCardData(const BYTE cbCardData[], WORD wCardCount)

  715. {

  716. 	//效验大小

  717. 	ASSERT(wCardCount<=CountArray(m_cbCardData));

  718. 	if (wCardCount>CountArray(m_cbCardData)) return false;

  719. 

  720. 	//设置扑克

  721. 	m_wCardCount=wCardCount;

  722. 	CopyMemory(m_cbCardData,cbCardData,sizeof(BYTE)*wCardCount);

  723. 

  724. 	return true;

  725. }

  726. 

  727. //获取扑克

  728. BYTE CWeaveCard::GetCardData(WORD wIndex)

  729. {

  730. 	ASSERT(wIndex<CountArray(m_cbCardData));

  731. 	return ((m_bDisplayItem==true)||(wIndex==3&&m_bGameEnd))?m_cbCardData[wIndex]:0;

  732. }

  733. //绘画扑克

  734. void CWeaveCard::DrawCardControl(CDC * pDC, int nXPos, int nYPos)

  735. {

  736. 	//设置位置

  737. 	SetControlPoint(nXPos,nYPos);

  738. 

  739. 	//显示判断

  740. 	if (m_wCardCount==0) 

  741. 		return;

  742. 

  743. 	//变量定义

  744. 	int nXScreenPos=0,nYScreenPos=0;

  745. 	int nItemWidth=0,nItemHeight=0,nItemWidthEx=0,nItemHeightEx=0;

  746. 

  747. 	//绘画扑克

  748. 	switch (m_CardDirection)

  749. 	{

  750. 	case Direction_East:	//东向   右

  751. 		{

  752. 

  753. 			//绘画扑克

  754. 			for (WORD i=0;i<3;i++)

  755. 			{

  756. 				int nXScreenPos=m_ControlPoint.x-g_CardResource.m_ImageTableRight.GetViewWidth();

  757. 				int nYScreenPos=m_ControlPoint.y+i*g_CardResource.m_ImageTableRight.GetViewHeight();

  758. 				g_CardResource.m_ImageTableRight.DrawCardItem(pDC,GetCardData(2-i),nXScreenPos,nYScreenPos);

  759. 			}

  760. 

  761. 			//第四扑克

  762. 			if (m_wCardCount==4)

  763. 			{

  764. 				int nXScreenPos=m_ControlPoint.x-g_CardResource.m_ImageTableRight.GetViewWidth();

  765. 				int nYScreenPos=m_ControlPoint.y-5+g_CardResource.m_ImageTableRight.GetViewHeight();

  766. 				g_CardResource.m_ImageTableRight.DrawCardItem(pDC,GetCardData(3),nXScreenPos,nYScreenPos);

  767. 			}

  768. 

  769. 			break;

  770. 	}

  771. 	case Direction_South:	//南向

  772. 		{

  773. 			//绘画扑克

  774. 			for (WORD i=0;i<3;i++)

  775. 			{

  776. 				int nXScreenPos=m_ControlPoint.x+i*g_CardResource.m_ImageTableBottom.GetViewWidth();

  777. 				int nYScreenPos=m_ControlPoint.y-g_CardResource.m_ImageTableBottom.GetViewHeight()-5;

  778. 				g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,GetCardData(i),nXScreenPos,nYScreenPos);

  779. 			}

  780. 

  781. 			//第四扑克

  782. 			if (m_wCardCount==4)

  783. 			{

  784. 				int nXScreenPos=m_ControlPoint.x+g_CardResource.m_ImageTableBottom.GetViewWidth();

  785. 				int nYScreenPos=m_ControlPoint.y-g_CardResource.m_ImageTableBottom.GetViewHeight()-5*2;

  786. 				g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,GetCardData(3),nXScreenPos,nYScreenPos);

  787. 			}

  788. 			break;

  789. 

  790. 		}

  791. 	case Direction_West:	//西向

  792. 		{

  793. 			//绘画扑克

  794. 			for (WORD i=0;i<3;i++)

  795. 			{

  796. 				int nXScreenPos=m_ControlPoint.x;

  797. 				int nYScreenPos=m_ControlPoint.y+i*g_CardResource.m_ImageTableLeft.GetViewHeight();

  798. 				g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(i),nXScreenPos,nYScreenPos);

  799. 			}

  800. 

  801. 			//第四扑克

  802. 			if (m_wCardCount==4)

  803. 			{

  804. 				int nXScreenPos=m_ControlPoint.x;

  805. 				int nYScreenPos=m_ControlPoint.y+g_CardResource.m_ImageTableLeft.GetViewHeight()-5;

  806. 				g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,GetCardData(3),nXScreenPos,nYScreenPos);

  807. 			}

  808. 

  809. 			break;

  810. 

  811. 		}

  812. 	case Direction_North:	//北向

  813. 		{

  814. 			//绘画扑克

  815. 			for (WORD i=0;i<3;i++)

  816. 			{

  817. 				int nYScreenPos=m_ControlPoint.y;

  818. 				int nXScreenPos=m_ControlPoint.x-(i+1)*g_CardResource.m_ImageTableTop.GetViewWidth();

  819. 				g_CardResource.m_ImageTableTop.DrawCardItem(pDC,GetCardData(2-i),nXScreenPos,nYScreenPos);

  820. 			}

  821. 

  822. 			//第四扑克

  823. 			if (m_wCardCount==4)

  824. 			{

  825. 				int nYScreenPos=m_ControlPoint.y-5;

  826. 				int nXScreenPos=m_ControlPoint.x-2*g_CardResource.m_ImageTableTop.GetViewWidth();

  827. 				g_CardResource.m_ImageTableTop.DrawCardItem(pDC,GetCardData(3),nXScreenPos,nYScreenPos);

  828. 			}

  829. 

  830. 			break;

  831. 

  832. 		}

  833. 	}

  834. 

  835. 	return;

  836. }

  837. 

  838. //////////////////////////////////////////////////////////////////////////

  839. 

  840. //构造函数

  841. CUserCard::CUserCard()

  842. {

  843. 	//扑克数据

  844. 	m_wCardCount=0;

  845. 	m_bCurrentCard=false;

  846. 

  847. 	//控制变量

  848. 	m_ControlPoint.SetPoint(0,0);

  849. 	m_CardDirection=Direction_East;

  850. 

  851. 	return;

  852. }

  853. 

  854. //析构函数

  855. CUserCard::~CUserCard()

  856. {

  857. }

  858. 

  859. //绘画扑克

  860. void CUserCard::DrawCardControl(CDC * pDC)

  861. {

  862. 	int nOffset=3;	//偏移量

  863. 

  864. 	switch (m_CardDirection)

  865. 	{

  866. 	case Direction_East:	//东向   右	右边

  867. 		{

  868. 			//当前扑克

  869. 			if (m_bCurrentCard==true)

  870. 			{

  871. 				int nXPos=m_ControlPoint.x - 5;

  872. 				int nYPos=m_ControlPoint.y + 15;

  873. 				//g_CardResource.m_ImageUserRight.AlphaDrawImage(pDC,nXPos,nYPos,RGB(255,0,255));

  874. 				g_CardResource.m_ImageUserRight.DrawImage(pDC,

  875. 									nXPos,	//X坐标

  876. 									nYPos,	//Y坐标

  877. 									g_CardResource.m_ImageUserRight.GetWidth(),				//宽

  878. 									g_CardResource.m_ImageUserRight.GetHeight(),				//高

  879. 									0,//起始位置X

  880. 									0);

  881. 			}

  882. 

  883. 			//正常扑克

  884. 			if (m_wCardCount>0)

  885. 			{

  886. 				int nXPos=0,nYPos=0;

  887. 				for (WORD i=0;i<m_wCardCount;i++)

  888. 				{

  889. 					nXPos=m_ControlPoint.x + i*nOffset;

  890. 					nYPos=m_ControlPoint.y+i*16+40;

  891. 					//g_CardResource.m_ImageUserRight.AlphaDrawImage(pDC,nXPos,nYPos,RGB(255,0,255));

  892. 					g_CardResource.m_ImageUserRight.DrawImage(pDC,

  893. 									nXPos,	//X坐标

  894. 									nYPos,	//Y坐标

  895. 									g_CardResource.m_ImageUserRight.GetWidth(),				//宽

  896. 									g_CardResource.m_ImageUserRight.GetHeight(),				//高

  897. 									0,//起始位置X

  898. 									0);

  899. 				}

  900. 			}

  901. 

  902. 			break;

  903. 		}

  904. 	case Direction_West:	//西向	左

  905. 		{

  906. 			//正常扑克

  907. 			if (m_wCardCount>0)

  908. 			{

  909. 				int nXPos=0,nYPos=0;

  910. 				for (WORD i=0;i<m_wCardCount;i++)

  911. 				{

  912. 					nXPos=m_ControlPoint.x + (m_wCardCount-i-1)*nOffset;

  913. 					nYPos=m_ControlPoint.y-(m_wCardCount-i-1)*16-92;

  914. 					//g_CardResource.m_ImageUserLeft.AlphaDrawImage(pDC,nXPos,nYPos,RGB(255,0,255));

  915. 					g_CardResource.m_ImageUserLeft.DrawImage(pDC,

  916. 									nXPos,	//X坐标

  917. 									nYPos,	//Y坐标

  918. 									g_CardResource.m_ImageUserLeft.GetWidth(),				//宽

  919. 									g_CardResource.m_ImageUserLeft.GetHeight(),				//高

  920. 									0,//起始位置X

  921. 									0);

  922. 				}

  923. 			}

  924. 

  925. 			//当前扑克

  926. 			if (m_bCurrentCard==true)

  927. 			{

  928. 				int nXPos=m_ControlPoint.x - 5;

  929. 				int nYPos=m_ControlPoint.y-49 - 18;

  930. 				//g_CardResource.m_ImageUserLeft.AlphaDrawImage(pDC,nXPos,nYPos,RGB(255,0,255));

  931. 				g_CardResource.m_ImageUserLeft.DrawImage(pDC,

  932. 									nXPos,	//X坐标

  933. 									nYPos,	//Y坐标

  934. 									g_CardResource.m_ImageUserLeft.GetWidth(),				//宽

  935. 									g_CardResource.m_ImageUserLeft.GetHeight(),				//高

  936. 									0,//起始位置X

  937. 									0);

  938. 			}

  939. 

  940. 			break;

  941. 		}

  942. 	case Direction_North:	//北向

  943. 		{

  944. 			//当前扑克

  945. 			if (m_bCurrentCard==true)

  946. 			{

  947. 				int nXPos=m_ControlPoint.x;

  948. 				int nYPos=m_ControlPoint.y;

  949. 				g_CardResource.m_ImageUserTop.DrawImage(pDC,nXPos,nYPos);

  950. 			}

  951. 

  952. 			//正常扑克

  953. 			if (m_wCardCount>0)

  954. 			{

  955. 				int nXPos=0,nYPos=0;

  956. 				for (WORD i=0;i<m_wCardCount;i++)

  957. 				{

  958. 					nYPos=m_ControlPoint.y;

  959. 					nXPos=m_ControlPoint.x+i*31+40;

  960. 					g_CardResource.m_ImageUserTop.DrawImage(pDC,nXPos,nYPos);

  961. 				}

  962. 			}

  963. 

  964. 			break;

  965. 		}

  966. 	}

  967. 

  968. 	return;

  969. }

  970. 

  971. //设置扑克

  972. bool CUserCard::SetCurrentCard(bool bCurrentCard)

  973. {

  974. 	//设置变量

  975. 	m_bCurrentCard=bCurrentCard;

  976. 

  977. 	return true;

  978. }

  979. 

  980. //设置扑克

  981. bool CUserCard::SetCardData(WORD wCardCount, bool bCurrentCard)

  982. {

  983. 	//设置变量

  984. 	m_wCardCount=wCardCount;

  985. 	m_bCurrentCard=bCurrentCard;

  986. 

  987. 	return true;

  988. }

  989. 

  990. //////////////////////////////////////////////////////////////////////////

  991. 

  992. //构造函数

  993. CDiscardCard::CDiscardCard()

  994. {

  995. 	//扑克数据

  996. 	m_wCardCount=0;

  997. 	ZeroMemory(m_cbCardData,sizeof(m_cbCardData));

  998. 

  999. 	//控制变量

  1000. 	m_ControlPoint.SetPoint(0,0);

  1001. 	m_CardDirection=Direction_East;

  1002. 

  1003. 	return;

  1004. }

  1005. 

  1006. //析构函数

  1007. CDiscardCard::~CDiscardCard()

  1008. {

  1009. }

  1010. 

  1011. //绘画扑克

  1012. void CDiscardCard::DrawCardControl(CDC * pDC)

  1013. {

  1014. 	int nOffset=3;	//偏移量

  1015. 

  1016. 	//绘画控制

  1017. 	switch (m_CardDirection)

  1018. 	{

  1019. 	case Direction_East:	//东向   右

  1020. 		{

  1021. 			//绘画扑克

  1022. 			

  1023. 			for (WORD i=0;i<m_wCardCount;i++)

  1024. 			{

  1025. 				if (i>=8) continue;

  1026. 				int nXPos=m_ControlPoint.x+(i/8)*50 + (i%8)*nOffset;

  1027. 				int nYPos=m_ControlPoint.y+(i%8)*18;

  1028. 				g_CardResource.m_ImageTableRight.DrawCardItem(pDC,m_cbCardData[i],nXPos,nYPos);

  1029. 			}

  1030. 

  1031. 			for (WORD i=0;i<m_wCardCount;i++)

  1032. 			{

  1033. 				if (i<8) continue; 

  1034. 				int nXPos=m_ControlPoint.x+(i/8)*50 + (i%8)*nOffset;

  1035. 				int nYPos=m_ControlPoint.y+(i%8)*18;

  1036. 				g_CardResource.m_ImageTableRight.DrawCardItem(pDC,m_cbCardData[i],nXPos,nYPos);

  1037. 			}

  1038. 

  1039. 

  1040. 			break;

  1041. 		}

  1042. 	case Direction_South:	//南向		下

  1043. 		{

  1044. 			//绘画扑克

  1045. 			for (WORD i=0;i<m_wCardCount;i++)

  1046. 			{

  1047. 				int nXPos=m_ControlPoint.x-(i%8)*34;

  1048. 				int nYPos=m_ControlPoint.y+(i/8)*35;

  1049. 				g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,m_cbCardData[i],nXPos,nYPos);

  1050. 			}

  1051. 

  1052. 			break;

  1053. 		}

  1054. 	case Direction_West:	//西向	左

  1055. 		{

  1056. 			//绘画扑克

  1057. 

  1058. 			for (WORD i=0;i<m_wCardCount;i++)

  1059. 			{

  1060. 				if ((m_wCardCount-i-1)>=8) continue;

  1061. 				int nXPos=m_ControlPoint.x-((m_wCardCount-1-i)/8)*50 + ((m_wCardCount-1-i)%8)*nOffset;

  1062. 				int nYPos=m_ControlPoint.y-((m_wCardCount-1-i)%8)*18;

  1063. 				g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,m_cbCardData[m_wCardCount-i-1],nXPos,nYPos);

  1064. 			}

  1065. 

  1066. 			for (WORD i=0;i<m_wCardCount;i++)

  1067. 			{

  1068. 				if ((m_wCardCount-i-1)<8) continue; 

  1069. 				int nXPos=m_ControlPoint.x-((m_wCardCount-1-i)/8)*50 + ((m_wCardCount-1-i)%8)*nOffset;

  1070. 				int nYPos=m_ControlPoint.y-((m_wCardCount-1-i)%8)*18;

  1071. 				g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,m_cbCardData[m_wCardCount-i-1],nXPos,nYPos);

  1072. 			}

  1073. 

  1074. 

  1075. 			//for (WORD i=0;i<m_wCardCount;i++)

  1076. 			//{

  1077. 			//	int nXPos=m_ControlPoint.x-((m_wCardCount-1-i)/8)*50 + ((m_wCardCount-1-i)%8)*nOffset;

  1078. 			//	int nYPos=m_ControlPoint.y-((m_wCardCount-1-i)%8)*20;

  1079. 			//	g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,m_cbCardData[m_wCardCount-i-1],nXPos,nYPos);

  1080. 			//}

  1081. 

  1082. 			break;

  1083. 		}

  1084. 	case Direction_North:	//北向		上

  1085. 		{

  1086. 			//绘画扑克

  1087. 			for (WORD i=0;i<m_wCardCount;i++)

  1088. 			{

  1089. 				int nXPos=m_ControlPoint.x+((m_wCardCount-1-i)%8)*30;

  1090. 				int nYPos=m_ControlPoint.y-((m_wCardCount-1-i)/8)*35-14;

  1091. 				g_CardResource.m_ImageTableTop.DrawCardItem(pDC,m_cbCardData[m_wCardCount-i-1],nXPos,nYPos);

  1092. 			}

  1093. 

  1094. 			break;

  1095. 		}

  1096. 	}

  1097. 

  1098. 	return;

  1099. }

  1100. 

  1101. //增加扑克

  1102. bool CDiscardCard::AddCardItem(BYTE cbCardData)

  1103. {

  1104. 	//清理扑克

  1105. 	if (m_wCardCount>=CountArray(m_cbCardData))

  1106. 	{

  1107. 		m_wCardCount--;

  1108. 		MoveMemory(m_cbCardData,m_cbCardData+1,CountArray(m_cbCardData)-1);

  1109. 	}

  1110. 

  1111. 	//设置扑克

  1112. 	m_cbCardData[m_wCardCount++]=cbCardData;

  1113. 

  1114. 	return true;

  1115. }

  1116. 

  1117. //设置扑克

  1118. bool CDiscardCard::SetCardData(const BYTE cbCardData[], WORD wCardCount)

  1119. {

  1120. 	//效验大小

  1121. 	ASSERT(wCardCount<=CountArray(m_cbCardData));

  1122. 	if (wCardCount>CountArray(m_cbCardData))

  1123. 		return false;

  1124. 

  1125. 	//设置扑克

  1126. 	m_wCardCount=wCardCount;

  1127. 	CopyMemory(m_cbCardData,cbCardData,sizeof(m_cbCardData[0])*wCardCount);

  1128. 

  1129. 	return true;

  1130. }

  1131. //获取位置

  1132. CPoint CDiscardCard::GetLastCardPosition()

  1133. {

  1134. 	switch (m_CardDirection)

  1135. 	{

  1136. 	case Direction_East:	//东向   右

  1137. 		{

  1138. 			//变量定义

  1139. 			int nCellWidth=g_CardResource.m_ImageTableRight.GetViewWidth();

  1140. 			int nCellHeight=g_CardResource.m_ImageTableRight.GetViewHeight();

  1141. 			int nXPos=m_ControlPoint.x+((m_wCardCount-1)/8)*50+18 + ((m_wCardCount-1)%8)*2 ;

  1142. 			int nYPos=m_ControlPoint.y+((m_wCardCount-1)%8)*18+11;

  1143. 

  1144. 

  1145. 			return CPoint(nXPos,nYPos);

  1146. 		}

  1147. 	case Direction_South:	//南向	下

  1148. 		{

  1149. 			//变量定义

  1150. 			int nCellWidth=g_CardResource.m_ImageTableBottom.GetViewWidth();

  1151. 			int nCellHeight=g_CardResource.m_ImageTableBottom.GetViewHeight();

  1152. 			int nXPos=m_ControlPoint.x-((m_wCardCount-1)%8)*34+14 + 2;

  1153. 			int nYPos=m_ControlPoint.y+((m_wCardCount-1)/8)*35+16;

  1154. 

  1155. 			return CPoint(nXPos,nYPos);

  1156. 

  1157. 		}

  1158. 	case Direction_West:	//西向	左

  1159. 		{

  1160. 			//变量定义

  1161. 			int nCellWidth=g_CardResource.m_ImageTableLeft.GetViewWidth();

  1162. 			int nCellHeight=g_CardResource.m_ImageTableLeft.GetViewHeight();

  1163. 			int nXPos=m_ControlPoint.x-((m_wCardCount-1)/8)*50+17 + ((m_wCardCount-1)%8)*2 + 20;

  1164. 			int nYPos=m_ControlPoint.y-((m_wCardCount-1)%8)*18+10;

  1165. 			return CPoint(nXPos,nYPos);

  1166. 

  1167. 		}

  1168. 	case Direction_North:	//北向	上

  1169. 		{

  1170. 			//变量定义

  1171. 			int nCellWidth=g_CardResource.m_ImageTableTop.GetViewWidth();

  1172. 			int nCellHeight=g_CardResource.m_ImageTableTop.GetViewHeight();            

  1173. 			int nXPos=m_ControlPoint.x+((m_wCardCount-1)%8)*30+14;

  1174. 			int nYPos=m_ControlPoint.y+((-m_wCardCount+1)/8)*35+17 - 10;

  1175. 			return CPoint(nXPos,nYPos);

  1176. 		}

  1177. 	}

  1178. 	return CPoint(0,0);

  1179. 

  1180. }

  1181. 

  1182. //////////////////////////////////////////////////////////////////////////

  1183. 

  1184. //构造函数

  1185. CTableCard::CTableCard()

  1186. {

  1187. 	//扑克数据

  1188. 	m_wCardCount=0;

  1189. 	ZeroMemory(m_cbCardData,sizeof(m_cbCardData));

  1190. 

  1191. 	//控制变量

  1192. 	m_ControlPoint.SetPoint(0,0);

  1193. 	m_CardDirection=Direction_East;

  1194. 

  1195. 	return;

  1196. }

  1197. 

  1198. //析构函数

  1199. CTableCard::~CTableCard()

  1200. {

  1201. }

  1202. 

  1203. //绘画扑克

  1204. void CTableCard::DrawCardControl(CDC * pDC)

  1205. {

  1206. 	int nOffset=3;	//偏移量

  1207. 

  1208. 	//绘画控制

  1209. 	switch (m_CardDirection)

  1210. 	{

  1211. 	case Direction_East:	//东向   右

  1212. 		{

  1213. 			//绘画扑克

  1214. 			for (WORD i=0;i<m_wCardCount;i++)

  1215. 			{

  1216. 				int nXPos=m_ControlPoint.x-33 + i*nOffset;

  1217. 				int nYPos=m_ControlPoint.y+i*17;

  1218. 				g_CardResource.m_ImageTableRight.DrawCardItem(pDC,m_cbCardData[m_wCardCount-i-1],nXPos,nYPos);

  1219. 			}

  1220. 

  1221. 			break;

  1222. 		}

  1223. 	case Direction_South:	//南向	下

  1224. 		{

  1225. 			//绘画扑克

  1226. 			for (WORD i=0;i<m_wCardCount;i++)

  1227. 			{

  1228. 				int nYPos=m_ControlPoint.y-36;

  1229. 				int nXPos=m_ControlPoint.x-(m_wCardCount-i)*34;

  1230. 				g_CardResource.m_ImageTableBottom.DrawCardItem(pDC,m_cbCardData[i],nXPos,nYPos);

  1231. 			}

  1232. 

  1233. 			break;

  1234. 		}

  1235. 	case Direction_West:	//西向	左

  1236. 		{

  1237. 			//绘画扑克

  1238. 			for (WORD i=0;i<m_wCardCount;i++)

  1239. 			{

  1240. 				int nXPos=m_ControlPoint.x + (m_wCardCount-i)*nOffset;

  1241. 				int nYPos=m_ControlPoint.y-(m_wCardCount-i)*17;

  1242. 				g_CardResource.m_ImageTableLeft.DrawCardItem(pDC,m_cbCardData[i],nXPos,nYPos);

  1243. 			}

  1244. 

  1245. 			break;

  1246. 		}

  1247. 	case Direction_North:	//北向	上

  1248. 		{

  1249. 			//绘画扑克

  1250. 			for (WORD i=0;i<m_wCardCount;i++)

  1251. 			{

  1252. 				int nYPos=m_ControlPoint.y;

  1253. 				int nXPos=m_ControlPoint.x+i*31;

  1254. 				g_CardResource.m_ImageTableTop.DrawCardItem(pDC,m_cbCardData[m_wCardCount-i-1],nXPos,nYPos);

  1255. 			}

  1256. 

  1257. 			break;

  1258. 		}

  1259. 	}

  1260. 

  1261. 	return;

  1262. }

  1263. 

  1264. //设置扑克

  1265. bool CTableCard::SetCardData(const BYTE cbCardData[], WORD wCardCount)

  1266. {

  1267. 	//效验大小

  1268. 	ASSERT(wCardCount<=CountArray(m_cbCardData));

  1269. 	if (wCardCount>CountArray(m_cbCardData))

  1270. 		return false;

  1271. 

  1272. 	//设置扑克

  1273. 	m_wCardCount=wCardCount;

  1274. 	CopyMemory(m_cbCardData,cbCardData,sizeof(m_cbCardData[0])*wCardCount);

  1275. 

  1276. 	return true;

  1277. }

  1278. 

  1279. //////////////////////////////////////////////////////////////////////////

  1280. 

  1281. //构造函数

  1282. CCardControl::CCardControl()

  1283. {

  1284. 	//状态变量

  1285. 	m_bPositively=false;

  1286. 	m_bDisplayItem=false;

  1287. 

  1288. 	//位置变量

  1289. 	m_XCollocateMode=enXCenter;

  1290. 	m_YCollocateMode=enYCenter;

  1291. 	m_BenchmarkPos.SetPoint(0,0);

  1292. 

  1293. 	//扑克数据

  1294. 	m_wCardCount=0;

  1295. 	m_wHoverItem=INVALID_ITEM;

  1296. 	ZeroMemory(&m_CurrentCard,sizeof(m_CurrentCard));

  1297. 	ZeroMemory(&m_CardItemArray,sizeof(m_CardItemArray));

  1298. 

  1299. 	//加载设置

  1300. 	m_ControlPoint.SetPoint(0,0);

  1301. 	m_ControlSize.cy=CARD_HEIGHT+POS_SHOOT;

  1302. 	m_ControlSize.cx=(CountArray(m_CardItemArray)+1)*CARD_WIDTH+POS_SPACE;

  1303. 

  1304. 	return;

  1305. }

  1306. 

  1307. //析构函数

  1308. CCardControl::~CCardControl()

  1309. {

  1310. }

  1311. 

  1312. //基准位置

  1313. void CCardControl::SetBenchmarkPos(int nXPos, int nYPos, enXCollocateMode XCollocateMode, enYCollocateMode YCollocateMode)

  1314. {

  1315. 	//设置变量

  1316. 	m_BenchmarkPos.x=nXPos;

  1317. 	m_BenchmarkPos.y=nYPos;

  1318. 	m_XCollocateMode=XCollocateMode;

  1319. 	m_YCollocateMode=YCollocateMode;

  1320. 

  1321. 	//横向位置

  1322. 	switch (m_XCollocateMode)

  1323. 	{

  1324. 	case enXLeft:	{ m_ControlPoint.x=m_BenchmarkPos.x; break; }

  1325. 	case enXCenter: { m_ControlPoint.x=m_BenchmarkPos.x-m_ControlSize.cx/2; break; }

  1326. 	case enXRight:	{ m_ControlPoint.x=m_BenchmarkPos.x-m_ControlSize.cx; break; }

  1327. 	}

  1328. 

  1329. 	//竖向位置

  1330. 	switch (m_YCollocateMode)

  1331. 	{

  1332. 	case enYTop:	{ m_ControlPoint.y=m_BenchmarkPos.y; break; }

  1333. 	case enYCenter: { m_ControlPoint.y=m_BenchmarkPos.y-m_ControlSize.cy/2; break; }

  1334. 	case enYBottom: { m_ControlPoint.y=m_BenchmarkPos.y-m_ControlSize.cy; break; }

  1335. 	}

  1336. 

  1337. 	return;

  1338. }

  1339. 

  1340. //基准位置

  1341. void CCardControl::SetBenchmarkPos(const CPoint & BenchmarkPos, enXCollocateMode XCollocateMode, enYCollocateMode YCollocateMode)

  1342. {

  1343. 	//设置变量

  1344. 	m_BenchmarkPos=BenchmarkPos;

  1345. 	m_XCollocateMode=XCollocateMode;

  1346. 	m_YCollocateMode=YCollocateMode;

  1347. 

  1348. 	//横向位置

  1349. 	switch (m_XCollocateMode)

  1350. 	{

  1351. 	case enXLeft:	{ m_ControlPoint.x=m_BenchmarkPos.x; break; }

  1352. 	case enXCenter: { m_ControlPoint.x=m_BenchmarkPos.x-m_ControlSize.cx/2; break; }

  1353. 	case enXRight:	{ m_ControlPoint.x=m_BenchmarkPos.x-m_ControlSize.cx; break; }

  1354. 	}

  1355. 

  1356. 	//竖向位置

  1357. 	switch (m_YCollocateMode)

  1358. 	{

  1359. 	case enYTop:	{ m_ControlPoint.y=m_BenchmarkPos.y; break; }

  1360. 	case enYCenter: { m_ControlPoint.y=m_BenchmarkPos.y-m_ControlSize.cy/2; break; }

  1361. 	case enYBottom: { m_ControlPoint.y=m_BenchmarkPos.y-m_ControlSize.cy; break; }

  1362. 	}

  1363. 

  1364. 	return;

  1365. }

  1366. 

  1367. //获取扑克

  1368. BYTE CCardControl::GetHoverCard()

  1369. {

  1370. 	//获取扑克

  1371. 	if (m_wHoverItem!=INVALID_ITEM)

  1372. 	{

  1373. 		if (m_wHoverItem==CountArray(m_CardItemArray))

  1374. 			return m_CurrentCard.cbCardData;

  1375. 		return m_CardItemArray[m_wHoverItem].cbCardData;

  1376. 	}

  1377. 

  1378. 	return 0;

  1379. }

  1380. 

  1381. //设置扑克

  1382. bool CCardControl::SetCurrentCard(BYTE cbCardData)

  1383. {

  1384. 	//设置变量

  1385. 	m_CurrentCard.bShoot=false;

  1386. 	m_CurrentCard.cbCardData=cbCardData;

  1387. 

  1388. 	return true;

  1389. }

  1390. 

  1391. //设置扑克

  1392. bool CCardControl::SetCurrentCard(tagCardItem CardItem)

  1393. {

  1394. 	//设置变量

  1395. 	m_CurrentCard.bShoot=CardItem.bShoot;

  1396. 	m_CurrentCard.cbCardData=CardItem.cbCardData;

  1397. 

  1398. 	return true;

  1399. }

  1400. 

  1401. //设置扑克

  1402. bool CCardControl::SetCardData(const BYTE cbCardData[], WORD wCardCount, BYTE cbCurrentCard)

  1403. {

  1404. 	//效验大小

  1405. 	ASSERT(wCardCount<=CountArray(m_CardItemArray));

  1406. 	if (wCardCount>CountArray(m_CardItemArray)) 

  1407. 		return false;

  1408. 

  1409. 	//当前扑克

  1410. 	m_CurrentCard.bShoot=false;

  1411. 	m_CurrentCard.cbCardData=cbCurrentCard;

  1412. 

  1413. 	//设置扑克

  1414. 	m_wCardCount=wCardCount;

  1415. 	for (WORD i=0;i<m_wCardCount;i++)

  1416. 	{

  1417. 		m_CardItemArray[i].bShoot=false;

  1418. 		m_CardItemArray[i].cbCardData=cbCardData[i];

  1419. 	}

  1420. 

  1421. 	return true;

  1422. }

  1423. 

  1424. //设置扑克

  1425. bool CCardControl::SetCardItem(const tagCardItem CardItemArray[], WORD wCardCount)

  1426. {

  1427. 	//效验大小

  1428. 	ASSERT(wCardCount<=CountArray(m_CardItemArray));

  1429. 	if (wCardCount>CountArray(m_CardItemArray))

  1430. 		return false;

  1431. 

  1432. 	//设置扑克

  1433. 	m_wCardCount=wCardCount;

  1434. 	for (WORD i=0;i<m_wCardCount;i++)

  1435. 	{

  1436. 		m_CardItemArray[i].bShoot=CardItemArray[i].bShoot;

  1437. 		m_CardItemArray[i].cbCardData=CardItemArray[i].cbCardData;

  1438. 	}

  1439. 

  1440. 	return true;

  1441. }

  1442. 

  1443. //绘画扑克

  1444. void CCardControl::DrawCardControl(CDC * pDC)

  1445. {

  1446. 	//绘画准备

  1447. 	int nXExcursion=m_ControlPoint.x+(CountArray(m_CardItemArray)-m_wCardCount)*CARD_WIDTH;

  1448. 

  1449. 	//绘画扑克

  1450. 	for (WORD i=0;i<m_wCardCount;i++)

  1451. 	{

  1452. 		//计算位置

  1453. 		int nXScreenPos=nXExcursion+CARD_WIDTH*i;

  1454. 		int nYScreenPos=m_ControlPoint.y+(((m_CardItemArray[i].bShoot==false)&&(m_wHoverItem!=i))?POS_SHOOT:0);

  1455. 

  1456. 		//绘画扑克

  1457. 		BYTE cbCardData=(m_bDisplayItem==true)?m_CardItemArray[i].cbCardData:0;

  1458. 		g_CardResource.m_ImageUserBottom.DrawCardItem(pDC,cbCardData,nXScreenPos,nYScreenPos);

  1459. 	}

  1460. 

  1461. 	//当前扑克

  1462. 	if (m_CurrentCard.cbCardData!=0)

  1463. 	{

  1464. 		//计算位置

  1465. 		int nXScreenPos=m_ControlPoint.x+m_ControlSize.cx-CARD_WIDTH;

  1466. 		int nYScreenPos=m_ControlPoint.y+(((m_CurrentCard.bShoot==false)&&(m_wHoverItem!=CountArray(m_CardItemArray)))?POS_SHOOT:0);

  1467. 

  1468. 		//绘画扑克

  1469. 		BYTE cbCardData=(m_bDisplayItem==true)?m_CurrentCard.cbCardData:0;

  1470. 		g_CardResource.m_ImageUserBottom.DrawCardItem(pDC,cbCardData,nXScreenPos,nYScreenPos);

  1471. 	}

  1472. 

  1473. 	return;

  1474. }

  1475. 

  1476. //索引切换

  1477. WORD CCardControl::SwitchCardPoint(CPoint & MousePoint)

  1478. {

  1479. 	//基准位置

  1480. 	int nXPos=MousePoint.x-m_ControlPoint.x;

  1481. 	int nYPos=MousePoint.y-m_ControlPoint.y;

  1482. 

  1483. 	//范围判断

  1484. 	if ((nXPos<0)||(nXPos>m_ControlSize.cx)) 

  1485. 		return INVALID_ITEM;

  1486. 	if ((nYPos<POS_SHOOT)||(nYPos>m_ControlSize.cy)) 

  1487. 		return INVALID_ITEM;

  1488. 

  1489. 	//牌列子项

  1490. 	if (nXPos<CARD_WIDTH*CountArray(m_CardItemArray))

  1491. 	{

  1492. 		WORD wViewIndex=(WORD)(nXPos/CARD_WIDTH)+m_wCardCount;

  1493. 		if (wViewIndex>=CountArray(m_CardItemArray))

  1494. 			return wViewIndex-CountArray(m_CardItemArray);

  1495. 		return INVALID_ITEM;

  1496. 	}

  1497. 

  1498. 	//当前子项

  1499. 	if ((m_CurrentCard.cbCardData!=0)&&(nXPos>=(m_ControlSize.cx-CARD_WIDTH))) 

  1500. 		return CountArray(m_CardItemArray);

  1501. 

  1502. 	return INVALID_ITEM;

  1503. }

  1504. 

  1505. //光标消息

  1506. bool CCardControl::OnEventSetCursor(CPoint Point, bool & bRePaint)

  1507. {

  1508. 	//获取索引

  1509. 	WORD wHoverItem=SwitchCardPoint(Point);

  1510. 

  1511. 	//响应判断

  1512. 	if ((m_bPositively==false)&&(m_wHoverItem!=INVALID_ITEM))

  1513. 	{

  1514. 		bRePaint=true;

  1515. 		m_wHoverItem=INVALID_ITEM;

  1516. 	}

  1517. 

  1518. 	//更新判断

  1519. 	if ((wHoverItem!=m_wHoverItem)&&(m_bPositively==true))

  1520. 	{

  1521. 		bRePaint=true;

  1522. 		m_wHoverItem=wHoverItem;

  1523. 		SetCursor(LoadCursor(AfxGetInstanceHandle(),MAKEINTRESOURCE(IDC_CARD_CUR)));

  1524. 	}

  1525. 

  1526. 	return (wHoverItem!=INVALID_ITEM);

  1527. }

  1528. 

  1529. //////////////////////////////////////////////////////////////////////////

  1530. 

  1531. //////////////////////////////////////////////////////////////////////////

  1532. 

  1533. //变量声明

  1534. CCardResource						g_CardResource;						//扑克资源

  1535. 

  1536. //////////////////////////////////////////////////////////////////////////