cocos2dx 制作单机麻将

标准的麻将(联网的) 会分为服务器模块, 客户端模块, 逻辑模块. 服务器模块必须由逻辑模块支持, 客户端模块很少用到逻辑模块,大多是从服务器发来的判断结果,必要时还是会用到逻辑模块. 因为逻辑模块需要共用, 所以里面都是调用的接口,返回服务器和客户端需要的结果值.

举个例子

客户端触发开始发生给服务端 > 服务端开始游戏 > 通过逻辑模块得到整理好的牌堆 > 服务端通过牌堆和规则计算拿到各个玩家的手牌 > 把手牌数据发到指定客户端 > 客户端根据发来的牌数据显示牌 > 用户打牌 > 客户端把用户想打的牌发送给服务端 > 服务端通过逻辑模块得出该牌能否打并计算是否有吃碰杠之类的操作, 如果能打(如果有操作牌也是这样) > 把这张能打的牌发给客户端 > 客户端得到该牌并显示出牌动画

所以客户端只负责接受需要绘制的消息, 那些逻辑一般都交给服务端. 客户端的逻辑一般就是判断服务器发来的是哪种消息, 根据不同消息绘制界面.

现在想想 服务端模块, 客户端模块, 逻辑模块 哪个最难?

最难的应该是逻辑模块, 其次是客户端, 最简单是服务端.  服务端最简单是因为他只负责发送数据,那些逻辑判断只要调用逻辑模块, 当然还要存储所有玩家的牌数据. 客户端的话因为也可能要绘制各个玩家牌,所以也要存储玩家的牌数据.

项目内容每增加一点, 服务端只要添加一个值来存储增加的内容, 而逻辑和客户端就要改很多东西.


在我们这个项目中,因为没有服务端, 所以我们让客户端模块直接和逻辑模块进行交互(虽然客户端只是控制台窗口), 首先应该把游戏逻辑模块单独出来, 放在逻辑类中. 客户端模块应该按照面向对象的方式组织

该项目中的客户端比较简单, 只有一个玩家对象和牌堆对象

目前这些对象中的属性和方法都很少.

添加了几个类和文件

1. //
   
2. //  CMD_Sparrow.h
   
3. //  MajiangLogicTest
   
4. //
   
5. //  Created by TinyUlt on 14-8-17.
   
6. //  Copyright (c) 2014年 TinyUlt. All rights reserved.
   
7. //
   
8. 
   
9. #ifndef MajiangLogicTest_CMD_Sparrow_h
   
10. #define MajiangLogicTest_CMD_Sparrow_h
    
11. 
    
12. #define MAX_REPERTORY 144
    
13. typedef unsigned char BYTE;
    
14. typedef unsigned short WORD;
    
15. //数组维数
    
16. #ifndef CountArray
    
17. #define CountArray(Array) (sizeof(Array)/sizeof(Array[0]))
    
18. #endif
    
19. //逻辑掩码
    
20. 
    
21. #define        MASK_COLOR                                        0xF0                                                                //花色掩码
    
22. #define        MASK_VALUE                                        0x0F                                                                //数值掩码
    
23. #define MAX_INDEX        42                                                  //最大索引
    
24. #define MAX_COUNT                                        14                                                                        //最大数目
    
25. #define GAME_PLAYER                                        4                                                                        //游戏人数
    
26. 
    
27. #endif

复制代码

1. //
   
2. //  CPile.h
   
3. //  MajiangLogicTest
   
4. //
   
5. //  Created by TinyUlt on 14-8-17.
   
6. //  Copyright (c) 2014年 TinyUlt. All rights reserved.
   
7. //
   
8. 
   
9. #ifndef __MajiangLogicTest__CPile__
   
10. #define __MajiangLogicTest__CPile__
    
11. 
    
12. #include <iostream>
    
13. #include "CMD_Sparrow.h"
    
14. class CPile
    
15. {
    
16. public:
    
17.     CPile();
    
18. private:
    
19.     //牌堆
    
20.     BYTE m_cardPile[MAX_REPERTORY];
    
21.    
    
22.     //摸牌位置
    
23.     BYTE m_currentIndex;
    
24.    
    
25. public:
    
26.     //得到牌堆数据
    
27.     BYTE* getCardPile();
    
28.    
    
29.     //取一张牌
    
30.     BYTE takeOnCard();
    
31.    
    
32.     //根据索引获取牌的数据
    
33.     BYTE getCardDataByIndex(BYTE index);
    
34.    
    
35.     //得到当前牌堆中牌的数量
    
36.     BYTE getCount();
    
37. };
    
38. #endif /* defined(__MajiangLogicTest__CPile__) */

复制代码

1. //
   
2. //  CPile.cpp
   
3. //  MajiangLogicTest
   
4. //
   
5. //  Created by TinyUlt on 14-8-17.
   
6. //  Copyright (c) 2014年 TinyUlt. All rights reserved.
   
7. //
   
8. 
   
9. #include "CPile.h"
   
10. CPile::CPile()
    
11. {
    
12.     m_currentIndex = 0;
    
13. }
    
14. 
    
15. BYTE* CPile::getCardPile()
    
16. {
    
17.     return m_cardPile;
    
18. }
    
19. 
    
20. BYTE CPile::getCardDataByIndex(BYTE index)
    
21. {
    
22.     return m_cardPile[index];
    
23. }
    
24. 
    
25. BYTE CPile::takeOnCard()
    
26. {
    
27.     return m_cardPile[m_currentIndex++];
    
28. }
    
29. 
    
30. BYTE CPile::getCount()
    
31. {
    
32.     return MAX_REPERTORY - m_currentIndex;
    
33. }

复制代码

1. //
   
2. //  CUser.h
   
3. //  MajiangLogicTest
   
4. //
   
5. //  Created by TinyUlt on 14-8-17.
   
6. //  Copyright (c) 2014年 TinyUlt. All rights reserved.
   
7. //
   
8. 
   
9. #ifndef __MajiangLogicTest__CUser__
   
10. #define __MajiangLogicTest__CUser__
    
11. 
    
12. #include <iostream>
    
13. #include "CMD_Sparrow.h"
    
14. class CUser
    
15. {
    
16. public:
    
17.     //存储牌数据的容器
    
18.     BYTE m_cardsIndexStore[MAX_INDEX];
    
19.    
    
20. };
    
21. #endif /* defined(__MajiangLogicTest__CUser__) */

复制代码

1. //
   
2. //  CGameLogic.h
   
3. //  MajiangLogicTest
   
4. //
   
5. //  Created by TinyUlt on 14-8-17.
   
6. //  Copyright (c) 2014年 TinyUlt. All rights reserved.
   
7. //
   
8. 
   
9. #ifndef __MajiangLogicTest__CGameLogic__
   
10. #define __MajiangLogicTest__CGameLogic__
    
11. 
    
12. #include <iostream>
    
13. #include "CMD_Sparrow.h"
    
14. 
    
15. class CGameLogic
    
16. {
    
17.     //变量定义
    
18. protected:
    
19.     static const BYTE                                m_cbCardDataArray[MAX_REPERTORY];                        //扑克数据
    
20.    
    
21. public:
    
22.     static const char*              m_cbCardWordArray[MAX_INDEX];               //中文扑克
    
23. public:
    
24.     //混乱扑克
    
25.     static void RandCardData(BYTE cbCardData[],BYTE cbMaxCount);
    
26.     //混乱扑克2
    
27.     static void RandAppointCardData(BYTE cbCardData[],BYTE cbMaxCount,BYTE OriginalData[]/*源牌堆数据*/);
    
28.     //扑克转换(索引->牌值)
    
29.     static BYTE SwitchToCardData(BYTE cbCardIndex);
    
30.     //扑克转换(牌型->索引)
    
31.     static BYTE SwitchToCardIndex(BYTE cbCardData);
    
32.     //扑克转换
    
33.     static BYTE SwitchToCardData(BYTE cbCardIndex[MAX_INDEX]/*传入统计所有牌数量的表格*/, BYTE cbCardData[MAX_COUNT]/*传出手牌数据*/);
    
34.     //删除扑克
    
35.     static bool RemoveCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbRemoveCard);
    
36.     //根据中文牌,得到牌索引
    
37.     static int getIndexByWord(const char* ch);
    
38.     //根据牌索引,得到中文牌
    
39.     static const char* getWordByIndex(int index);
    
40.     //根据牌型值,得到中文牌
    
41.     static const char* getWordByData(BYTE cbCardData);
    
42.     //轮转玩家
    
43.     static int changePlayer(int id);
    
44. };
    
45. #endif /* defined(__MajiangLogicTest__CGameLogic__) */

复制代码

1. //
   
2. //  CGameLogic.cpp
   
3. //  MajiangLogicTest
   
4. //
   
5. //  Created by TinyUlt on 14-8-17.
   
6. //  Copyright (c) 2014年 TinyUlt. All rights reserved.
   
7. //
   
8. 
   
9. #include "CGameLogic.h"
   
10. //扑克数据
    
11. const BYTE CGameLogic::m_cbCardDataArray[MAX_REPERTORY]=
    
12. {
    
13.     0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,                                                //万子
    
14.     0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,                                                //万子
    
15.     0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,                                                //万子
    
16.     0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,                                                //万子
    
17.     0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,                                                //同子
    
18.     0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,                                                //同子
    
19.     0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,                                                //同子
    
20.     0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,                                                //同子
    
21.     0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,                                                //索子
    
22.     0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,                                                //索子
    
23.     0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,                                                //索子
    
24.     0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,                                                //索子
    
25.    
    
26.     0x31,0x32,0x33,0x34,                                                                                                //风牌
    
27.     0x31,0x32,0x33,0x34,                                                                                                //风牌
    
28.     0x31,0x32,0x33,0x34,                                                                                                //风牌
    
29.     0x31,0x32,0x33,0x34,                                                                                                //风牌
    
30.     0x41,0x42,0x43,                                                                                                                //箭牌
    
31.     0x41,0x42,0x43,                                                                                                                //箭牌
    
32.     0x41,0x42,0x43,                                                                                                                //箭牌
    
33.     0x41,0x42,0x43,                                                                                                                //箭牌
    
34.    
    
35.     0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,                                                        //花牌
    
36.    
    
37. };
    
38. const char* CGameLogic::m_cbCardWordArray[MAX_INDEX]=
    
39. {
    
40.     "一万","二万","三万","四万","五万","六万","七万","八万","九万",
    
41.     "一筒","二筒","三筒","四筒","五筒","六筒","七筒","八筒","九筒",
    
42.     "一索","二索","三索","四索","五索","六索","七索","八索","九索",
    
43.     "东", "南", "西", "北", "中", "发", "白",
    
44.     "春", "夏", "秋", "冬", "梅", "兰", "竹", "菊"
    
45. };
    
46. 
    
47. void CGameLogic::RandCardData(BYTE cbCardData[],BYTE cbMaxCount)
    
48. {
    
49.     //混乱准备
    
50.     BYTE cbCardDataTemp[CountArray(m_cbCardDataArray)];//为什么直接用MAX_REPERTORY? 因为这样无耦合
    
51.     memcpy(cbCardDataTemp,m_cbCardDataArray,sizeof(m_cbCardDataArray));//拷贝一份到临时牌数组中
    
52.    
    
53.     //混乱扑克(关键的核心打乱代码)
    
54.     BYTE cbRandCount=0,cbPosition=0;
    
55.     do
    
56.     {
    
57.         cbPosition=rand()%(cbMaxCount-cbRandCount);
    
58.         cbCardData[cbRandCount++]=cbCardDataTemp[cbPosition];
    
59.         cbCardDataTemp[cbPosition]=cbCardDataTemp[cbMaxCount-cbRandCount];
    
60.     } while (cbRandCount<cbMaxCount);
    
61.    
    
62.     return;
    
63.    
    
64. }
    
65. //混乱扑克2
    
66. void CGameLogic::RandAppointCardData(BYTE cbCardData[],BYTE cbMaxCount,BYTE OriginalData[]/*源牌堆数据*/)
    
67. {
    
68.     //混乱扑克
    
69.     BYTE cbRandCount=0,cbPosition=0;
    
70.     do
    
71.     {
    
72.         cbPosition=rand()%(cbMaxCount-cbRandCount);
    
73.         cbCardData[cbRandCount++]=OriginalData[cbPosition];
    
74.         OriginalData[cbPosition]=OriginalData[cbMaxCount-cbRandCount];
    
75.     } while (cbRandCount<cbMaxCount);
    
76.    
    
77.     return;
    
78. }
    
79. //扑克转换(索引->牌值)
    
80. BYTE CGameLogic::SwitchToCardData(BYTE cbCardIndex)
    
81. {
    
82.     //assert(cbCardIndex<42);
    
83.     if(cbCardIndex<31)   return ((cbCardIndex/9)<<4)|(cbCardIndex%9+1);
    
84.     if(cbCardIndex>=31&&cbCardIndex<=33)  return(((cbCardIndex/7)<<4)+cbCardIndex%10 );
    
85.     if(cbCardIndex>33)   return(cbCardIndex+0x2F);
    
86.     //assert(false);
    
87.     return 0;
    
88. }
    
89. //扑克转换(牌型->索引)
    
90. BYTE CGameLogic::SwitchToCardIndex(BYTE cbCardData)
    
91. {
    
92.     //  ASSERT(IsValidCard(cbCardData));
    
93.     if((cbCardData&MASK_COLOR)<=0x30)
    
94.         return (((cbCardData&MASK_COLOR)>>4)*9+(cbCardData&MASK_VALUE)-1);
    
95.     if((cbCardData&MASK_COLOR)==0x40)
    
96.         return (31+(cbCardData&MASK_VALUE)-1);
    
97.     if((cbCardData&MASK_COLOR)==0x50)
    
98.         return (34+(cbCardData&MASK_VALUE)-1);
    
99.     //ASSERT(false);
    
100.     return 0;
     
101. }
     
102. 
     
103. //扑克转换
     
104. BYTE CGameLogic::SwitchToCardData(BYTE cbCardIndex[MAX_INDEX]/*传入统计所有牌数量的表格*/, BYTE cbCardData[MAX_COUNT]/*传出手牌数据*/)
     
105. {
     
106.     //转换扑克
     
107.     BYTE cbPosition=0;
     
108.     for (BYTE i=0;i<MAX_INDEX;i++)
     
109.     {
     
110.         if (cbCardIndex[i]!=0)
     
111.         {
     
112.             for (BYTE j=0;j<cbCardIndex[i];j++)
     
113.             {
     
114.                 // ASSERT(cbPosition<MAX_COUNT);
     
115.                 cbCardData[cbPosition++]=SwitchToCardData(i);
     
116.             }
     
117.         }
     
118.     }
     
119.    
     
120.     return cbPosition;//返回手牌数
     
121. }
     
122. //根据中文牌,得到牌索引
     
123. int CGameLogic::getIndexByWord(const char* ch)
     
124. {
     
125.     for (int i = 0; i < MAX_INDEX; i++)
     
126.     {
     
127.         if (!strcmp(ch,m_cbCardWordArray[i]))
     
128.         {
     
129.             return i;
     
130.         }
     
131.     }
     
132.     return -1;
     
133. }
     
134. const char* CGameLogic::getWordByIndex(int index)
     
135. {
     
136.     return m_cbCardWordArray[index];
     
137. }
     
138. const char* CGameLogic::getWordByData(BYTE cbCardData)
     
139. {
     
140.     return getWordByIndex(SwitchToCardIndex(cbCardData));
     
141. }
     
142. //删除扑克
     
143. bool CGameLogic::RemoveCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbRemoveCard)
     
144. {
     
145.    
     
146.     //效验扑克
     
147.     //ASSERT(IsValidCard(cbRemoveCard));
     
148.     BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard);
     
149.     //ASSERT(cbCardIndex[cbRemoveIndex]>0);
     
150.    
     
151.     //删除扑克
     
152.     if (cbCardIndex[cbRemoveIndex]>0)
     
153.     {
     
154.         cbCardIndex[cbRemoveIndex]--;
     
155.         return true;
     
156.     }
     
157.    
     
158.     //失败效验
     
159.     // ASSERT(FALSE);
     
160.    
     
161.     return false;
     
162. }
     
163. //轮转玩家
     
164. int CGameLogic::changePlayer(int id)
     
165. {
     
166.     id += 1;
     
167.     if (id>=GAME_PLAYER) {
     
168.         id = 0;
     
169.     }
     
170.    
     
171.     return id;
     
172. }

复制代码

1. //
   
2. //  main.cpp
   
3. //  MajiangLogicTest
   
4. //
   
5. //  Created by TinyUlt on 14-8-16.
   
6. //  Copyright (c) 2014年 TinyUlt. All rights reserved.
   
7. //
   
8. /*
   
9. 最基础的麻将逻辑
   
10. 
    
11. 根据自己需要 设置麻将人数GAME_PLAYER
    
12. 
    
13. 基本流程:
    
14. 
    
15. 初始化牌堆,
    
16. 判断庄家
    
17. 玩家0摸13张牌
    
18. 玩家1摸13张牌
    
19. 玩家2摸13张牌
    
20. 玩家3摸13张牌
    
21. 庄家摸一张牌
    
22. 庄家出牌
    
23. 闲家摸牌
    
24. 闲家出牌
    
25. 闲家摸牌
    
26. 闲家出牌
    
27. 闲家摸牌
    
28. 闲家出牌
    
29. 庄家摸一张牌
    
30. 庄家出牌
    
31. 闲家摸牌
    
32. 闲家出牌
    
33. .......
    
34. 牌堆数为0 结束
    
35. 
    
36. 其他功能 比如 碰吃杠听胡等等 先不实现
    
37. 
    
38. */
    
39. #include <iostream>
    
40. #include "CGameLogic.h"
    
41. #include "CPile.h"
    
42. #include "CUser.h"
    
43. using namespace std;
    
44. 
    
45. 
    
46. //混乱扑克
    
47. 
    
48. int main(int argc, const char * argv[])
    
49. {
    
50.     // insert code here...
    
51.    
    
52.     //创建摸牌堆
    
53.     CPile _pile;
    
54.    
    
55.     //创建玩家
    
56.     CUser _users[GAME_PLAYER];
    
57.    
    
58.     //出牌的次数
    
59.     BYTE _outCardTime = 0;
    
60.    
    
61.     //庄家用户索引
    
62.     BYTE _bankerId = rand()%GAME_PLAYER;
    
63.    
    
64.     /*第一种混乱法*/
    
65.     //得到牌堆数据
    
66.     CGameLogic::RandCardData(_pile.getCardPile(), MAX_REPERTORY);
    
67.    
    
68.     //输出牌堆数据
    
69.     cout<<"混乱初始牌堆"<<endl;
    
70.    
    
71.     for (int i = 0 ; i < MAX_REPERTORY; i++)
    
72.     {
    
73.         cout<<hex<<"0x"<<int(_pile.getCardDataByIndex(i))<<" ";
    
74.     }
    
75.     cout<<endl<<endl;
    
76. 
    
77.    
    
78.     //初始化玩家的牌数据
    
79.     for (int j = 0; j < GAME_PLAYER; j++)
    
80.     {
    
81.         for ( int i = 0; i < MAX_COUNT-1; i++)
    
82.         {
    
83.             BYTE _cardValue = _pile.takeOnCard();//得到牌堆中的牌
    
84.             int _index = CGameLogic::SwitchToCardIndex(_cardValue);//得到该牌对应的索引
    
85.             _users[j].m_cardsIndexStore[_index]++;//该牌型加一
    
86.         }
    
87.     }
    
88.     cout<<"-----------------------------------"<<endl;
    
89.    
    
90.     for (int j = 0; j< GAME_PLAYER; j++)
    
91.     {
    
92.         cout<<"玩家"<<j<<"的牌数据:"<<endl;
    
93.         for (int i = 0; i< MAX_INDEX; i++)
    
94.         {
    
95.             cout<<hex<<CGameLogic::getWordByIndex(i)<<"(0x"<<int(CGameLogic::SwitchToCardData(i))<<"):"<<dec<<(int)_users[j].m_cardsIndexStore[i]<<" ";//输出手牌中所有牌型对应的数量
    
96.         }
    
97.         cout<<endl<<endl;
    
98.     }
    
99.     cout<<"-----------------------------------"<<endl;
    
100.    
     
101.     for (int j = 0; j< GAME_PLAYER; j++)
     
102.     {
     
103.         cout<<"玩家"<<j<<"的手牌:"<<endl;
     
104.         
     
105.         BYTE _handCardData[MAX_COUNT];
     
106.         int _handandsCount = (int)CGameLogic::SwitchToCardData(_users[j].m_cardsIndexStore,_handCardData);
     
107.         
     
108.         for (int i = 0; i< _handandsCount; i++)
     
109.         {
     
110.            cout<<CGameLogic::getWordByData(_handCardData[i])<<"(0x"<<hex<<(int)_handCardData[i]<<") ";
     
111.         }
     
112.         cout<<endl<<endl;
     
113.     }
     
114.     cout<<"-----------------------------------"<<endl;
     
115.    
     
116.    
     
117.     //初始化工作做好后, 开始麻将的出牌逻辑循环
     
118.    
     
119.     cout<<"庄家: 玩家"<<(int)_bankerId<<endl;
     
120.     int _currentPlayer = _bankerId;
     
121.    
     
122.     while (_pile.getCount()>0)
     
123.     {
     
124.         //出牌次数
     
125.         cout<<"共出牌次数:"<<dec<<(int)_outCardTime<<endl;
     
126.         
     
127.         //准备出牌的玩家先从牌堆中取牌
     
128.         BYTE _cardValue = _pile.takeOnCard();//得到牌堆中的牌
     
129.         int _index = CGameLogic::SwitchToCardIndex(_cardValue);//得到该牌对应的索引
     
130.         _users[_currentPlayer].m_cardsIndexStore[_index]++;//该牌型加一
     
131.         cout<<"从牌堆中取牌:"<<CGameLogic::getWordByData(_cardValue)<<endl;
     
132.         cout<<"牌堆剩余:"<<dec<<(int)_pile.getCount()<<endl;
     
133.         
     
134.         //显示手牌
     
135.         {
     
136.             BYTE _handCardData[MAX_COUNT];
     
137.             int _handandsCount = (int)CGameLogic::SwitchToCardData(_users[_currentPlayer].m_cardsIndexStore,_handCardData);
     
138.             cout<<"玩家"<<_currentPlayer<<"的手牌有"<<dec<<_handandsCount<<"张:"<<endl;
     
139.             for (int i = 0; i< _handandsCount; i++)
     
140.             {
     
141.                 cout<<CGameLogic::getWordByData(_handCardData[i])<<"(0x"<<hex<<(int)_handCardData[i]<<") ";
     
142.             }
     
143.             cout<<endl;
     
144.         }
     
145.         
     
146.         //输入要出的牌
     
147.     recin:
     
148.         char ch[20];
     
149.         cout<<"玩家"<<_currentPlayer<<"要出的牌(比如 三万): ";
     
150.         cin>>ch;
     
151.         int _outCardIndex = CGameLogic::getIndexByWord(ch);
     
152.         if (_outCardIndex == -1)
     
153.         {
     
154.             cout<<"输入错误,请重新输入"<<endl;
     
155.             goto recin;
     
156.         }
     
157.         
     
158.         //根据索引得到麻将牌型值
     
159.         BYTE _outCardValue = CGameLogic::SwitchToCardData(_outCardIndex);
     
160.         
     
161.         //根据牌型值删除手中的牌
     
162.         bool _b = CGameLogic::RemoveCard(_users[_currentPlayer].m_cardsIndexStore, _outCardValue);
     
163.         if (_b)
     
164.         {
     
165.             cout<<"出牌成功,轮到下家"<<endl;
     
166.             _outCardTime++;
     
167.         }
     
168.         else
     
169.         {
     
170.             cout<<"输入错误,请重新输入"<<endl;
     
171.             goto recin;
     
172.         }
     
173.         
     
174.         //显示手牌
     
175.         {
     
176.             BYTE _handCardData[MAX_COUNT];
     
177.             int _handandsCount = (int)CGameLogic::SwitchToCardData(_users[_currentPlayer].m_cardsIndexStore,_handCardData);
     
178.             cout<<"出牌后玩家"<<_currentPlayer<<"的手牌有"<<dec<<_handandsCount<<"张:"<<endl;
     
179.             for (int i = 0; i< _handandsCount; i++)
     
180.             {
     
181.                 cout<<CGameLogic::getWordByData(_handCardData[i])<<"(0x"<<hex<<(int)_handCardData[i]<<") ";
     
182.             }
     
183.             cout<<endl;
     
184.         }
     
185.         
     
186.         cout<<"-----------------------------------"<<endl;
     
187.         _currentPlayer = CGameLogic::changePlayer(_currentPlayer);
     
188.     }
     
189.     return 0;
     
190. }

复制代码