zhaobu
/
zhujimajiang_redis
1
0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
诸暨麻将添加redis
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
6 Révisions
2 Branches
57 MiB
 
 
 
 
 
 
Aborescence: 522a9556dd
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de '522a9556dd'
${ noResults }
zhujimajiang_redis/游戏服务器/Poker/TableFrameSinkPoker.cpp

1916 lignes
59 KiB
Brut Annotations Historique 

  1. #include "stdafx.h"

  2. #include "TableFrameSinkPoker.h"

  3. #include "消息定义/CMD_Poker_Sparrow.h"

  4. 

  5. #define  MyZeroMemory(x) ZeroMemory(x,sizeof(x))

  6. CTableFrameSinkPoker::CTableFrameSinkPoker()

  7. {

  8. 	m_pITableFrame = NULL;

  9. 	m_pGameServiceOption = NULL;

  10. 	memset(&m_gameConfig, 0, sizeof(CMD_S_GameConfig_Poker));

  11. 	m_cbPlayerNum = GAME_PLAYER;

  12. 	m_cbCardNum = FULL_COUNT_Poker;

  13. 

  14. // 	// 用户状态

  15. 	ZeroMemory(m_cbOffline, sizeof(m_cbOffline));//是否断线 0正常 1断线

  16. 	ZeroMemory(m_cbTrustee, sizeof(m_cbTrustee));//是否托管 0正常 1托管

  17. 	ZeroMemory(m_cbTimeOutCount, sizeof(m_cbTimeOutCount));//超时次数 连续两次触发托管

  18. // 	// 玩家分数

  19. 	//16局积分

  20. 	ZeroMemory(m_lGameTatolScore, sizeof(m_lGameTatolScore));

  21. 

  22. 	//流水详情

  23. 	MyZeroMemory(m_HuPaiLiuShui);

  24. 	// 游戏回放

  25. 	m_bReplayRecordStart = false;

  26. 	m_UserReplayRecord.clear();

  27. 

  28. // 	单局变量

  29. 

  30. 	MyZeroMemory(m_GameScore);//本局总积分

  31. 	MyZeroMemory(m_lGameGongXianScore);//本局贡献分

  32. 	MyZeroMemory(m_lGameAwardScore);//本局双扣基础分

  33. 

  34. 	m_wBankerUser = INVALID_CHAIR;//庄家用户

  35. 

  36. 	MyZeroMemory(m_bTrustee);

  37. 	m_bSwitchChair = false;//交换位置

  38. 	MyZeroMemory(m_wSourceID);//原始ID

  39. 	MyZeroMemory(m_wTargetID);//目标ID

  40. 	MyZeroMemory(m_bResponse);//用户反馈

  41. 	m_wCurrentUser = INVALID_CHAIR;

  42. 	m_wCurrentOperate = INVALID_CHAIR;

  43. 	m_cbStartRandCard = 0xff;

  44. 	m_cbTurnCardCount = 0;

  45. 	m_wWinCount = 0;

  46. 	

  47. 	m_wWinOrder[0] = 255;

  48. 	m_wWinOrder[1] = 255;

  49. 	m_wWinOrder[2] = 255;

  50. 	m_wWinOrder[3] = 255;

  51. 

  52. 	MyZeroMemory(m_BomoCouut);

  53. 	//输赢情况

  54. 	MyZeroMemory(m_winLoseCount);

  55. 	m_lastLianxianInfo = 0;

  56. 	MyZeroMemory(&m_struOutCard);

  57. 	MyZeroMemory(m_cbJokerReplacePoker);

  58. 	MyZeroMemory(m_BoomCountInfo);

  59. }

  60. 

  61. CTableFrameSinkPoker::~CTableFrameSinkPoker()

  62. {

  63. 

  64. }

  65. 

  66. void * CTableFrameSinkPoker::QueryInterface(const IID & Guid, DWORD dwQueryVer)

  67. {

  68. 	if ((Guid == IID_ITableFrameSink) && (InterfaceVersionCompare(dwQueryVer, VER_ITableFrameSinkZhiPai)))

  69. 		return static_cast<ITableFrameSink *>(this);

  70. 	QUERYINTERFACE(ITableUserAction, Guid, dwQueryVer);

  71. 	if ((Guid == IID_IUnknownEx) && (InterfaceVersionCompare(dwQueryVer, VER_IUnknownEx)))

  72. 		return static_cast<IUnknownEx *>(static_cast<ITableFrameSink *>(this));

  73. 	return NULL;

  74. }

  75. 

  76. bool CTableFrameSinkPoker::Initialization(IUnknownEx * pIUnknownEx)

  77. {

  78. 	//查询接口

  79. 	ASSERT(pIUnknownEx != NULL);

  80. 	m_pITableFrame = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, ITableFrame);

  81. 	if (m_pITableFrame == NULL)

  82. 		return false;

  83. 

  84. 	//获取参数

  85. 	m_pGameServiceOption = m_pITableFrame->GetGameServiceOption();

  86. 	ASSERT(m_pGameServiceOption != NULL);

  87. 

  88. 	//开始模式

  89. 	m_pITableFrame->SetStartMode(START_MODE_FULL_READY);

  90. 

  91. 	return true;

  92. }

  93. //复位桌子

  94. VOID CTableFrameSinkPoker::RepositionSink()

  95. {

  96. 

  97. 	// 	// 用户状态

  98. 	ZeroMemory(m_cbOffline, sizeof(m_cbOffline));//是否断线 0正常 1断线

  99. 	ZeroMemory(m_cbTrustee, sizeof(m_cbTrustee));//是否托管 0正常 1托管

  100. 	ZeroMemory(m_cbTimeOutCount, sizeof(m_cbTimeOutCount));//超时次数 连续两次触发托管

  101. 	//游戏回放

  102. 	m_bReplayRecordStart = false;

  103. 	// 	单局变量

  104. 

  105. 	MyZeroMemory(m_GameScore);//本局总积分

  106. 	MyZeroMemory(m_lGameGongXianScore);//本局贡献分

  107. 	MyZeroMemory(m_lGameAwardScore);//本局双扣基础分

  108. 

  109. 	m_wBankerUser = INVALID_CHAIR;//庄家用户

  110. 

  111. 	MyZeroMemory(m_bTrustee);

  112. 	m_bSwitchChair = false;//交换位置

  113. 	MyZeroMemory(m_wSourceID);//原始ID

  114. 	MyZeroMemory(m_wTargetID);//目标ID

  115. 	MyZeroMemory(m_bResponse);//用户反馈

  116. 	m_wCurrentUser = INVALID_CHAIR;

  117. 	m_wCurrentOperate = INVALID_CHAIR;

  118. 	m_cbStartRandCard = 0xff;

  119. 	m_cbTurnCardCount = 0;

  120. 	m_wWinCount = 0;

  121. 	m_wWinOrder[0] = 255;

  122. 	m_wWinOrder[1] = 255;

  123. 	m_wWinOrder[2] = 255;

  124. 	m_wWinOrder[3] = 255;

  125. 

  126. 	MyZeroMemory(m_BomoCouut);

  127. 	m_lastLianxianInfo = 0;

  128. 	MyZeroMemory(&m_struOutCard);

  129. 	MyZeroMemory(m_cbJokerReplacePoker);

  130. 	m_listOutCard.clear();

  131. 	MyZeroMemory(m_BoomCountInfo);

  132. }

  133. 

  134. void CTableFrameSinkPoker::DeletePrivateTable(bool bSendState /*= false*/)

  135. {

  136. 	tagScoreInfo ScoreInfoArray[GAME_PLAYER];

  137. 	ZeroMemory(&ScoreInfoArray, sizeof(ScoreInfoArray));

  138. 

  139. 	WORD wChairCount = m_pITableFrame->GetChairCount();

  140. 	for (int i = 0; i < wChairCount; ++i)

  141. 	{

  142. 		IServerUserItem *pIUserItem = m_pITableFrame->GetTableUserItem(i);

  143. 		if (pIUserItem == NULL)

  144. 			continue;

  145. 		ScoreInfoArray[i].cbType = SCORE_TYPE_END;

  146. 		ScoreInfoArray[i].lScore = 0;			//记录临时分

  147. 	}

  148. 	m_pITableFrame->WriteTableScore(ScoreInfoArray, CountArray(ScoreInfoArray));

  149. 

  150. 	ConcludeGame(GAME_STATUS_DELETE, bSendState);

  151. 	m_pITableFrame->DeletePrivateTableNow();

  152. }

  153. 

  154. 

  155. bool CTableFrameSinkPoker::OnActionUserConnect(WORD wChairID, IServerUserItem * pIServerUserItem)

  156. {

  157. 	//TRACE("断线重连 wChairID = %d \n", wChairID);

  158. 	if (wChairID >= m_cbCardNum) return false;

  159. 	m_cbOffline[wChairID] = 1;

  160. 	return true;

  161. }

  162. //用户坐下

  163. bool CTableFrameSinkPoker::OnActionUserSitDown(WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)

  164. {

  165. 	return TRUE;

  166. }

  167. //用户起来

  168. bool CTableFrameSinkPoker::OnActionUserStandUp(WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)

  169. {

  170. 	//庄家设置

  171. 	if (bLookonUser == false && !QueryUseTemporaryScore())

  172. 	{

  173. 		m_cbTrustee[wChairID] = false;

  174. 		//托管广播

  175. 		CMD_C_Trustee_SK Trustee = { 0 };

  176. 		Trustee.cbTrustee = 0;

  177. 		Trustee.wChairID = wChairID;

  178. 		RepayRecord(INVALID_CHAIR, SUB_S_TRUSTEE_Poker, &Trustee, sizeof(Trustee));

  179. 		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_TRUSTEE_Poker, &Trustee, sizeof(Trustee));

  180. 		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_TRUSTEE_Poker, &Trustee, sizeof(Trustee));

  181. 	}

  182. 

  183. 	return true;

  184. }

  185. 

  186. bool CTableFrameSinkPoker::OnActionUserOnReady(WORD wChairID, IServerUserItem * pIServerUserItem, void * pData, WORD wDataSize)

  187. {

  188. 	return true;

  189. }

  190. //游戏中途旁观进入

  191. bool CTableFrameSinkPoker::PerformLookonLogin(IServerUserItem * pIServerUserItem)

  192. {

  193. 	CMD_S_PangGuan_Poler StatusPlay = { 0 };

  194. 	CopyMemory(&StatusPlay.gameConfig, &m_gameConfig, sizeof(CMD_S_GameConfig));

  195. 	CopyMemory(StatusPlay.lUserTmpScore, m_lGameTatolScore, sizeof(m_lGameTatolScore));

  196. 	StatusPlay.gameConfig.IsOwner = m_pITableFrame->GetPrivateTableOwnerID() == pIServerUserItem->GetUserID() ? 1 : 0;

  197. 	StatusPlay.GameStatus = m_pITableFrame->IsDrawStarted();

  198. 	if (StatusPlay.GameStatus)

  199. 	{

  200. 		//发送场景

  201. 		StatusPlay.wBankerUser = m_wBankerUser;

  202. 		StatusPlay.wCurrentUser = m_wCurrentUser;

  203. 		StatusPlay.cbCurrPlayCount = m_gameConfig.wHadPlayCount;

  204. 		StatusPlay.cbTotaPlayCount = m_gameConfig.wPlayCountRule;

  205. 		StatusPlay.leftOptTime = 0;

  206. 		int tmpUser = m_wCurrentUser;

  207. 		for (BYTE i = 0; i < m_cbPlayerNum; i++)

  208. 		{

  209. 			tmpUser = (tmpUser - 1) % m_cbPlayerNum;

  210. 			if (tmpUser < 0) tmpUser += m_cbPlayerNum;

  211. 			if (tmpUser == m_wCurrentUser)

  212. 				continue;

  213. 			if (m_cbResponse[tmpUser] == 1)

  214. 				StatusPlay.cbOtherOperate[tmpUser] = OPERATE_MASK_PASS_Poker;

  215. 			else if (m_cbResponse[tmpUser] == 2)

  216. 			{

  217. 				StatusPlay.cbCardType = m_struOutCard.cbOutCardType;

  218. 				StatusPlay.cbOtherOperate[tmpUser] = OPERATE_MASK_OUT_Poker;

  219. 				std::list<OutCard>::reverse_iterator rIt;

  220. 				for (rIt = m_listOutCard.rbegin(); rIt != m_listOutCard.rend(); rIt++)

  221. 				{

  222. 					if (rIt->wOutCardUser == tmpUser)

  223. 					{

  224. 						memcpy(StatusPlay.cbOutCardData[tmpUser], rIt->cbOutCardData, MAX_COUNT_Poker*sizeof(BYTE));

  225. 						break;

  226. 					}

  227. 				}

  228. 			}

  229. 		}

  230. 		StatusPlay.cbCardType = m_wCurrentOperate;

  231. 		StatusPlay.cbDiscardType = m_struOutCard.cbOutCardType;

  232. 		CopyMemory(StatusPlay.cbReplaceCard, m_cbJokerReplacePoker, sizeof(m_cbJokerReplacePoker));

  233. 		//扑克数目、玩家手牌

  234. 		for (BYTE i = 0; i < m_cbPlayerNum; i++)

  235. 		{

  236. 			StatusPlay.cbCardCount[i] = m_cbCardDataCount[i];

  237. 			StatusPlay.cbRankIndex[i] = m_wWinOrder[i];

  238. 			StatusPlay.cbTrusteeStatus[i] = m_cbTrustee[i];

  239. 			StatusPlay.UserGongXianScore[i] = m_lGameGongXianScore[i];

  240. 			memset(StatusPlay.cbCardData[i], 0xff, StatusPlay.cbCardCount[i]);

  241. 		}

  242. 		StatusPlay.LeftMinPokerVal = m_cbStartRandCard;

  243. 	}

  244. 	CString strOut;

  245. 	strOut.Format(L"局数 [%d/%d] 扑克数目[%d %d %d %d] 随机牌[%x] 当前积分[%d %d %d %d] 贡献分 [%d %d %d %d]",

  246. 		StatusPlay.cbCurrPlayCount, StatusPlay.cbTotaPlayCount,

  247. 		StatusPlay.cbCardCount[0], StatusPlay.cbCardCount[1], StatusPlay.cbCardCount[2], StatusPlay.cbCardCount[3],

  248. 		StatusPlay.LeftMinPokerVal,

  249. 		StatusPlay.lUserTmpScore[0], StatusPlay.lUserTmpScore[1], StatusPlay.lUserTmpScore[2], StatusPlay.lUserTmpScore[3],

  250. 		StatusPlay.UserGongXianScore[0], StatusPlay.UserGongXianScore[1], StatusPlay.UserGongXianScore[2], StatusPlay.UserGongXianScore[3]);

  251. 		

  252. 	return m_pITableFrame->SendUserItemData(pIServerUserItem, SUB_S_PANGGUAN, &StatusPlay, sizeof(StatusPlay));

  253. 	

  254. }

  255. 

  256. void CTableFrameSinkPoker::SetGameConfig(VOID * pDataBuffer, WORD wDataSize, std::wstring sPrivateRoomId)

  257. {

  258. 	//TRACE("游戏配置设置 \n");

  259. 	memset(&m_gameConfig, 0, sizeof(CMD_S_GameConfig_Poker));

  260. 	CMD_S_GameConfig_Poker* ppConfig = (CMD_S_GameConfig_Poker*)pDataBuffer;

  261. 	CopyMemory(&m_gameConfig, ppConfig, sizeof(CMD_S_GameConfig_Poker));

  262. 	m_gameConfig.wHadPlayCount = 0;

  263. 	m_GameLogic.SetMagicType(m_gameConfig.bDuoLai);

  264. 	m_cbPlayerNum = m_gameConfig.PeoplesNum;

  265. 	m_cbCardNum = FULL_COUNT_Poker;

  266. 	m_pITableFrame->SetChairCount(m_cbPlayerNum);

  267. }

  268. //翻牌换桌

  269. void CTableFrameSinkPoker::SwapSeat()

  270. {

  271. 	BOOL bSwitch = FALSE;

  272. 	FindCardOwner(bSwitch);

  273. 	if (bSwitch==FALSE)

  274. 	{

  275. 		return;

  276. 	}

  277. 	

  278. 		//队友换桌，对面

  279. 	

  280. 		IServerUserItem *pIServerUserItem = m_pITableFrame->GetTableUserItem(m_wSourceID[0]);

  281. 		pIServerUserItem->SetChairID(m_wSourceID[1]);

  282. 		pIServerUserItem = m_pITableFrame->GetTableUserItem(m_wSourceID[1]);

  283. 		pIServerUserItem->SetChairID(m_wSourceID[0]);

  284. 		m_pITableFrame->SwapChair();

  285. 

  286. 		//换手牌，总积分，流水详情

  287. 		swap(m_cbCardData[m_wSourceID[0]], m_cbCardData[m_wSourceID[1]]);

  288. // 		CString outFen2 = _T("变换前的分数 ");

  289. // 		for (int i = 0; i < 4; i++)

  290. // 		{

  291. // 			CString TMP;

  292. // 			TMP.Format(_T(" %d "), m_lGameTatolScore[i]);

  293. // 			outFen2 += TMP;

  294. // 		}

  295. // 		OutputDebugString(outFen2);

  296. 		//换总积分  

  297. 		int lGameScore = m_lGameTatolScore[m_wSourceID[0]];

  298. 		m_lGameTatolScore[m_wSourceID[0]] = m_lGameTatolScore[m_wSourceID[1]];

  299. 		m_lGameTatolScore[m_wSourceID[1]] = lGameScore;

  300. // 		CString outFen;

  301. // 		outFen = _T("变换后的分数 ");

  302. // 		for (int i = 0; i < 4;i++)

  303. // 		{

  304. // 			CString TMP;

  305. // 			TMP.Format(_T(" %d "), m_lGameTatolScore[i]);

  306. // 			outFen += TMP;

  307. // 		}

  308. // 		OutputDebugString(outFen);

  309. // 		

  310. 		//	换流水 和

  311. 	

  312. 		for (BYTE i = 0; i < (m_gameConfig.wHadPlayCount - 1); i++)

  313. 		{

  314. 			lGameScore = m_HuPaiLiuShui[i * m_cbPlayerNum + m_wSourceID[0]];

  315. 			m_HuPaiLiuShui[i * m_cbPlayerNum + m_wSourceID[0]] = m_HuPaiLiuShui[i * m_cbPlayerNum + m_wSourceID[1]];

  316. 			m_HuPaiLiuShui[i * m_cbPlayerNum + m_wSourceID[1]] = lGameScore;

  317. 		}

  318. 		// 输赢次数

  319. 		int wins = 0;

  320. 		wins = m_winLoseCount[m_wSourceID[0]];

  321. 		m_winLoseCount[m_wSourceID[0]] = m_winLoseCount[ m_wSourceID[0]];

  322. 		m_winLoseCount[m_wSourceID[1]] = wins;

  323. 

  324. 		

  325. 	

  326. }

  327. 

  328. bool CTableFrameSinkPoker::OnUserHint(WORD wChairID)

  329. {

  330. 	if (m_wCurrentUser != wChairID)

  331. 		return false;

  332. 

  333. 	if (m_cbCurrentHintNum + 1 > m_cbHintNum)

  334. 		m_cbCurrentHintNum = 0;

  335. 	TRACE("用户出牌提示 wChairID = %d m_cbCurrentHintNum = %d m_cbHintNum = %d \n", wChairID, m_cbCurrentHintNum, m_cbHintNum);

  336. // 	CString strBuffer;

  337. // 	strBuffer.Format(L"用户出牌提示 wChairID = %d m_cbCurrentHintNum = %d m_cbHintNum = %d ", wChairID, m_cbCurrentHintNum, m_cbHintNum);

  338. // 	OutputDebugString(strBuffer);

  339. 	//提示结果

  340. 	CMD_S_Hint_Result_Poker HintResult = { 0 };

  341. 	memcpy(HintResult.cbHintCardData, mHistList[m_cbCurrentHintNum].cbHintLogicCardData, MAX_COUNT_Poker*sizeof(BYTE));

  342. 	HintResult.cbCardType = mHistList[m_cbCurrentHintNum].cbCardType;

  343. 	//特殊处理 将所有 1 2 转换成14 15 

  344. 	for (int i = 0; i < MAX_COUNT_Poker;i++)

  345. 	{

  346. 		if (HintResult.cbHintCardData[i]==0)

  347. 		{

  348. 			break;

  349. 		}

  350. 		if (HintResult.cbHintCardData[i]<=2)

  351. 		{

  352. 			HintResult.cbHintCardData[i] = m_GameLogic.GetCardLogicValue(HintResult.cbHintCardData[i]);

  353. 		}

  354. 	

  355. 	}

  356. 	PrintCards(HintResult.cbHintCardData, MAX_COUNT_Poker);

  357. 	m_pITableFrame->SendTableData(wChairID, SUB_S_HINT_RESULT, &HintResult, sizeof(HintResult));

  358. 	m_cbCurrentHintNum++;

  359. 	return true;

  360. }

  361. 

  362. bool CTableFrameSinkPoker::OnEventGameStart()

  363. {

  364. 	TRACE("游戏开始 \n");

  365. 	m_pITableFrame->SetGameStatus(GS_MJ_PLAY);

  366. 	m_gameConfig.wHadPlayCount++;

  367. 

  368. 

  369. 	//开始记录回放数据

  370. 	RepayRecordStart();

  371. 	//混乱扑克

  372. 	WORD wRoomId = m_gameConfig.RoomId;

  373. 	m_GameLogic.RandCardList(m_cbRepertoryCard, CountArray(m_cbRepertoryCard), m_gameConfig.tmp2, wRoomId);

  374. 	ReadGameData();

  375. 	//////////////////////////////////////////////////////////////////////////

  376. 

  377. 	{

  378. 		m_cbLeftCardCount = FULL_COUNT_Poker;

  379. 		//发牌

  380. 		for (BYTE i = 0; i < m_cbPlayerNum; i++)

  381. 		{

  382. 			m_cbCardDataCount[i] = MAX_COUNT_Poker;

  383. 			CopyMemory(&m_cbCardData[i], &(m_cbRepertoryCard[i*m_cbCardDataCount[i]]), MAX_COUNT_Poker);

  384. 		}

  385. 

  386. 	}

  387. 	//////////////////////////////////////////////////////////////////////////

  388. 

  389. 

  390. 

  391. 

  392. // 	//发送数据

  393. // 	OutputDebugString(_T("洗牌后4个玩家的数据输出"));

  394. // 	

  395. // 	for (int i = 0; i < m_cbPlayerNum;i++)

  396. // 	{

  397. // 		PrintCards(m_cbCardData[i], MAX_COUNT_Poker);

  398. // 	}

  399. // 	OutputDebugString(_T("洗牌后4个玩家的数据输出End"));

  400. 

  401. 	//随机取一张牌

  402. 	BYTE cbRandData = m_cbRepertoryCard[rand() % FULL_COUNT_Poker];

  403. 	m_cbStartRandCard = cbRandData;

  404. 

  405. 	SwapSeat();

  406. 	

  407. 	for (int i = 0; i < 4; i++)

  408. 	{

  409. 		PrintCards(m_cbCardData[i], m_cbCardDataCount[i]);

  410. 	}

  411. 	//排列扑克

  412. 	for (WORD i = 0; i < GAME_PLAYER; i++)

  413. 	{

  414. 		m_GameLogic.SortCardList(m_cbCardData[i], m_cbCardDataCount[i], ST_ORDER);

  415. 	}

  416. 	for (int i = 0; i < 4; i++)

  417. 	{

  418. 		PrintCards(m_cbCardData[i], m_cbCardDataCount[i]);

  419. 	}

  420. 

  421. 	//游戏变量

  422. 	m_wTurnWiner = INVALID_CHAIR;

  423. 	m_wCurrentUser = m_wBankerUser;

  424. 	

  425. 	CMD_S_GameStart_SK GameStart;

  426. 	ZeroMemory(&GameStart, sizeof(GameStart));

  427. 

  428. 	GameStart.wCurrentUser = m_wCurrentUser;

  429. 	//交换位置

  430. 	for (INT i = 0; i < GAME_PLAYER; i++){

  431. 		IServerUserItem * pIServerUserItem = m_pITableFrame->GetTableUserItem(i);

  432. 		m_unUserID[i] = pIServerUserItem->GetUserID();

  433. 	}

  434. 

  435. // 	CString strUserID;

  436. // 	for (int i = 0; i < m_cbPlayerNum;i++)

  437. // 	{

  438. // 		CString tmp;

  439. // 		tmp.Format(_T("wchaid=%d userid=%d \r\n"),i,m_unUserID[i]);

  440. // 		strUserID += tmp;

  441. // 	}

  442. // 	OutputDebugString(strUserID);

  443. 	for (int i = 0; i < m_cbPlayerNum;i++)

  444. 	{

  445. 		GameStart.lCellScore[i] = m_lGameTatolScore[i];

  446. 	}

  447. 	ZeroMemory(GameStart.cbPartnerCardData, MAX_COUNT_Poker);

  448. 	GameStart.bTrustee = false;

  449. 	GameStart.cbStartRandCard = m_cbStartRandCard;

  450. 	CopyMemory(GameStart.userSortID, m_unUserID, sizeof(m_unUserID));

  451. 	GameStart.cbCurrPlay = (BYTE)m_gameConfig.wHadPlayCount;

  452. 	ZeroMemory(GameStart.cbCardData, GAME_PLAYER*MAX_COUNT_Poker);

  453. 	for (int i = 0; i < m_cbPlayerNum;i++)

  454. 	{

  455. 		CopyMemory(GameStart.cbCardData[i], m_cbCardData[i], MAX_COUNT_Poker);

  456. 	}

  457. 	RepayRecord(INVALID_CHAIR, SUB_S_GAME_START_Poker, &GameStart, sizeof(GameStart));

  458. 	for (int i = 0; i < m_cbPlayerNum;i++)

  459. 	{

  460. 		ZeroMemory(GameStart.cbCardData, GAME_PLAYER*MAX_COUNT_Poker);

  461. 		CopyMemory(GameStart.cbCardData[i], m_cbCardData[i], MAX_COUNT_Poker);

  462. 		m_pITableFrame->SendTableData(i, SUB_S_GAME_START_Poker, &GameStart, sizeof(GameStart));

  463. 	}

  464. 

  465. 

  466. 

  467. 	ZeroMemory(GameStart.cbCardData, sizeof(GameStart.cbCardData));//用户回放

  468. 	//清手牌 旁观只能发一次

  469. 

  470. 	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_START_Poker, &GameStart, sizeof(GameStart));

  471. 

  472. 	m_wCurrentOperate = OPERATE_MASK_OUT_Poker | OPERATE_MASK_HINT_Poker;

  473. 

  474. 	m_GameLogic.FindAllHit(m_cbCardData[m_wCurrentUser], m_cbCardDataCount[m_wCurrentUser], mHistList);

  475. 	m_cbHintNum = mHistList.size();

  476. 	

  477. 	return TRUE;

  478. }

  479. //游戏消息处理

  480. bool CTableFrameSinkPoker::OnGameMessage(WORD wSubCmdID, VOID * pDataBuffer, WORD wDataSize, IServerUserItem * pIServerUserItem)

  481. {

  482. 	WORD wChairId = pIServerUserItem->GetChairID();

  483. // 	CString str;

  484. // 	str.Format(_T("OnGameMessage wSubCmdID =%d"), wSubCmdID);

  485. // 	OutputDebugString(str);

  486. 	switch (wSubCmdID){

  487. 

  488. 	case SUB_C_OPERATE_CALLBACK_Poker:{

  489. 		//用户操作 出牌/ 过 / 要不起

  490. 		//效验消息

  491. 		ASSERT(wDataSize == sizeof(struct CMD_C_OPERATE_CALLBACK_SK	));

  492. 		if (wDataSize != sizeof(CMD_C_OPERATE_CALLBACK_SK))

  493. 			return false;

  494. 

  495. 		//消息处理

  496. 		CMD_C_OPERATE_CALLBACK_SK * pOperateCallback = (CMD_C_OPERATE_CALLBACK_SK *)pDataBuffer;

  497. 		bool ret = OnUserOperate(wChairId, pOperateCallback);

  498. // 		if (ret)

  499. // 		{

  500. // 			OutputDebugString(_T("OnUserOperate Ret True"));

  501. // 		}

  502. // 		else{

  503. // 			OutputDebugString(_T("OnUserOperate Ret False"));

  504. // 		}

  505. 		return ret;

  506. 		break;

  507. 	}

  508. 		 //用户托管

  509. 	case SUB_C_TRUSTEE_Poker:{

  510. 		//效验消息

  511. 		ASSERT(wDataSize == sizeof(CMD_C_Trustee));

  512. 		if (wDataSize != sizeof(CMD_C_Trustee))

  513. 			return false;

  514. 

  515. 		CMD_C_Trustee *pTrustee = (CMD_C_Trustee *)pDataBuffer;

  516. 		m_cbTrustee[wChairId] = pTrustee->bTrustee;

  517. 		m_cbTimeOutCount[wChairId] = 0;

  518. 		//托管广播

  519. 		CMD_S_Trustee_Poler Trustee = { 0 };

  520. 		Trustee.cbTrustee = pTrustee->bTrustee;

  521. 		Trustee.wChairID = wChairId;

  522. 		RepayRecord(INVALID_CHAIR, SUB_S_TRUSTEE_Poker, &Trustee, sizeof(Trustee));

  523. 		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_TRUSTEE_Poker, &Trustee, sizeof(Trustee));

  524. 		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_TRUSTEE_Poker, &Trustee, sizeof(Trustee));

  525. 

  526. 		TRACE("用户托管 %d 是否托管 %d \n", wChairId, pTrustee->bTrustee);

  527. 		//当前玩家托管、立刻响应

  528. 		if (m_cbTrustee[wChairId])

  529. 		{

  530. 			if (m_wCurrentUser == wChairId)

  531. 				return TrusteeOut(wChairId);

  532. 		}

  533. 		else if (m_cbTrustee[wChairId] == 0 && m_wCurrentUser == wChairId)

  534. 		{

  535. 			//m_pITableFrame->KillGameTimer(17);

  536. 			//m_pITableFrame->KillGameTimer(18);

  537. 		}

  538. 

  539. 		return true;

  540. 	

  541. 

  542. 

  543. 		break;

  544. 	}

  545. 	}

  546. 	return true;

  547. }

  548. 

  549. bool CTableFrameSinkPoker::OnFrameMessage(WORD wSubCmdID, VOID * pDataBuffer, WORD wDataSize, IServerUserItem * pIServerUserItem)

  550. {

  551. 	return false;

  552. }

  553. 

  554. bool CTableFrameSinkPoker::OnEventSendGameScene(WORD wChiarID, IServerUserItem * pIServerUserItem, BYTE cbGameStatus, bool bSendSecret)

  555. {

  556. // 	CString  str;

  557. // 	str.Format(L"OnEventSendGameScene wChiarID =%d cbGameStatus=%d ", wChiarID, cbGameStatus);

  558. // 	OutputDebugString(str);

  559. 	switch (cbGameStatus)

  560. 	{

  561. 	case GS_MJ_FREE:	//空闲状态

  562. 	{

  563. 		TRACE("发送场景 wChairID = %d 空闲状态 \n", wChiarID);

  564. 

  565. 		//发送场景

  566. 		CMD_S_StatusFree StatusFree = { 0 };

  567. 		CopyMemory(&StatusFree.gameConfig, &m_gameConfig, sizeof(CMD_S_GameConfig));

  568. 		StatusFree.gameConfig.IsOwner = m_pITableFrame->GetPrivateTableOwnerID() == pIServerUserItem->GetUserID() ? 1 : 0;

  569. 		CopyMemory(StatusFree.lUserTmpScore, m_lGameTatolScore, sizeof(m_lGameTatolScore));

  570. 		StatusFree.UserStat = pIServerUserItem->GetUserInfo()->cbUserStatus;

  571. 		return m_pITableFrame->SendGameScene(pIServerUserItem, &StatusFree, sizeof(StatusFree));

  572. 	}

  573. 	case GS_MJ_PLAY:	//游戏状态

  574. 	{

  575. 		TRACE("发送场景 wChairID = %d 游戏状态 \n", wChiarID);

  576. 		for (int i = 0; i < m_cbPlayerNum;i++)

  577. 		{

  578. 			m_GameLogic.SortCardList(m_cbCardData[i], m_cbCardDataCount[i]);

  579. 		}

  580. 		try

  581. 		{

  582. 			CMD_S_StatusPlay_SK StatusPlay = {0};

  583. 			StatusPlay.gameConfig.IsOwner = m_pITableFrame->GetPrivateTableOwnerID() == pIServerUserItem->GetUserID() ? 1 : 0;

  584. 			CopyMemory(&StatusPlay.gameConfig, &m_gameConfig, sizeof(CMD_S_GameConfig_Poker));

  585. 			CopyMemory(StatusPlay.lUserTmpScore, m_lGameTatolScore, sizeof(m_lGameTatolScore));

  586. 		

  587. 			int cfgSize = sizeof(CMD_S_GameConfig_Poker);

  588. 	

  589. 			StatusPlay.wBankerUser = m_wBankerUser;

  590. 			StatusPlay.wCurrentUser = m_wCurrentUser;

  591. 

  592. 			//如果是 正在出牌的玩家重连

  593. 			if (m_wCurrentUser == wChiarID)

  594. 				StatusPlay.cbcardType = m_wCurrentOperate;

  595. 			int tmpUser = wChiarID;

  596. 			for (int userindex = 0; userindex < m_cbPlayerNum; userindex++)

  597. 			{

  598. 				StatusPlay.cbOtherOperateType[tmpUser] = m_cbUserOPerate_mask[tmpUser];

  599. 				//没看懂

  600. 				tmpUser = (tmpUser - 1) % m_cbPlayerNum;

  601. 				if (tmpUser < 0) tmpUser += m_cbPlayerNum;

  602. 				if (tmpUser == wChiarID && wChiarID == m_wCurrentUser)

  603. 					continue;

  604. 				//记录每个人的操作

  605. 				if (m_cbResponse[tmpUser] == 1)

  606. 					StatusPlay.cbOtherOperateType[tmpUser] = m_cbUserOPerate_mask[tmpUser];

  607. 

  608. 				else if (m_cbResponse[tmpUser] == 2)

  609. 				{

  610. 					BYTE cbLevel;

  611. 					BomoType bomoinof;

  612. 					BYTE cbReplaceCards[27] = { 0 };

  613. 					m_GameLogic.ReplaceWangCards(m_cbTurnCardData, m_cbTurnCardCount, m_cbJokerReplacePoker[tmpUser], cbReplaceCards);

  614. 					StatusPlay.cbDiscardType = m_GameLogic.GetCardType(cbReplaceCards, m_cbTurnCardCount, cbLevel, bomoinof);

  615. 					StatusPlay.cbOtherOperateType[tmpUser] = OPERATE_MASK_OUT_Poker;

  616. 					std::list<OutCard>::reverse_iterator rIt;

  617. 					for (rIt = m_listOutCard.rbegin(); rIt != m_listOutCard.rend(); rIt++)

  618. 					{

  619. 						if (rIt->wOutCardUser == tmpUser)

  620. 						{

  621. 							memcpy(StatusPlay.cbOutCardData[tmpUser], rIt->cbOutCardData, MAX_COUNT_Poker*sizeof(BYTE));

  622. 							break;

  623. 						}

  624. 					}

  625. 				}

  626. 

  627. 			}

  628. 

  629. 			//扑克数目、玩家手牌

  630. 			for (BYTE i = 0; i < m_cbPlayerNum; i++)

  631. 			{

  632. 				StatusPlay.cbCardCount[i] = m_cbCardDataCount[i];

  633. 				StatusPlay.lUserTmpScore[i] = m_lGameTatolScore[i];

  634. 				StatusPlay.UserGongXianScore[i] = m_lGameGongXianScore[i];

  635. 				if (i==wChiarID)

  636. 				{

  637. 					if (m_cbCardDataCount[i]==0)

  638. 					{

  639. 						//此时可以看对家的牌

  640. 						CopyMemory(StatusPlay.cbTeamCardData, m_cbCardData[(i + 2) % GAME_PLAYER],MAX_COUNT_Poker);

  641. 						PrintCards(StatusPlay.cbTeamCardData, MAX_COUNT_Poker);

  642. 					}

  643. 					//我自己的牌

  644. 					CopyMemory(StatusPlay.cbCardData[i], m_cbCardData[i], MAX_COUNT_Poker);

  645. 				}

  646. 				StatusPlay.cbRankIndex[i] = m_wWinOrder[i];

  647. 			}

  648. 			StatusPlay.LeftMinPokerVal = m_cbStartRandCard;

  649. 			StatusPlay.cbCurrPlayCount = m_gameConfig.wHadPlayCount;

  650. 			StatusPlay.cbTotaPlayCount = m_gameConfig.wPlayCountRule;

  651. 			StatusPlay.LianXianInfo = m_lastLianxianInfo;

  652. 			CopyMemory(StatusPlay.cbReplaceCard, m_cbJokerReplacePoker, sizeof(m_cbJokerReplacePoker));

  653. // 			OutputDebugString(L"断线癞子替换");

  654. // 			PrintCards(StatusPlay.cbReplaceCard,16);

  655. // 			CString strInfo;

  656. // 			strInfo.Format(_T("积分：[%d %d %d %d] 贡献分:[%d %d %d %d] 当前用户[%d] 我的出牌类型[%d] 名次 [%d %d %d %d] 当前扑克->"),

  657. // 				StatusPlay.lUserTmpScore[0], StatusPlay.lUserTmpScore[1], StatusPlay.lUserTmpScore[2], StatusPlay.lUserTmpScore[3],

  658. // 				StatusPlay.UserGongXianScore[0], StatusPlay.UserGongXianScore[1], StatusPlay.UserGongXianScore[2], StatusPlay.UserGongXianScore[3],

  659. // 				StatusPlay.wCurrentUser, StatusPlay.cbcardType, StatusPlay.cbRankIndex[0], StatusPlay.cbRankIndex[1], StatusPlay.cbRankIndex[2], StatusPlay.cbRankIndex[3]

  660. // 				);

  661. // 			CString csPoker;

  662. // 			for (int i = 0; i < m_cbCardDataCount[wChiarID];i++)

  663. // 			{

  664. // 				CString tmp;

  665. // 				tmp.Format(_T("%02x,"), StatusPlay.cbCardData[wChiarID][i]);

  666. // 				csPoker += tmp;

  667. // 			}

  668. // 			strInfo += csPoker;

  669. // 			OutputDebugString(strInfo);

  670. // 			CString tmp;

  671. // 			for (int i = 0; i < sizeof(StatusPlay);i++)

  672. // 			{

  673. // 				CString strTmp;

  674. // 				strTmp.Format(_T("%02x "), ((BYTE*)&StatusPlay)[i]);

  675. // 				tmp += strTmp;

  676. // 			}

  677. // 			OutputDebugString(tmp);

  678. 			return m_pITableFrame->SendGameScene(pIServerUserItem, &StatusPlay, sizeof(StatusPlay));

  679. 		}

  680. 		catch (...) {}

  681. 	}

  682. 	}

  683. 	return false;

  684. 	

  685. 	

  686. 	

  687. 	return true;

  688. }

  689. 

  690. bool CTableFrameSinkPoker::OnEventGameConclude(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason, bool bSendState /*= false*/)

  691. {

  692. 	TRACE("游戏结束 wChairID = %d cbReason = %#X \n", wChairID, cbReason);

  693. 	bool bFinish = (m_gameConfig.wHadPlayCount >= m_gameConfig.wPlayCountRule) ? 1 : 0;

  694. 	

  695. 

  696. 	switch (cbReason)

  697. 	{

  698. 	case GER_DELETE_PRIVATE:

  699. 		//bFinish = true;

  700. 		//bDelete = true;

  701. 		//if (!m_pITableFrame->IsGameStarted())

  702. 		//{

  703. 		//	DeletePrivateTable(bSendState);

  704. 		//	return true;

  705. 		//}

  706. 		ConcludeGame(GS_MJ_FREE);

  707. 		DeletePrivateTable(bSendState);

  708. 		return true;

  709. 	case GER_NORMAL:

  710. 	{

  711. 		//常规结束

  712. 		CMD_S_GameEnd_SK GameEnd = { 0 };

  713. 	

  714. 		GameEnd.cbEndType = 1;

  715. 	

  716. 			//玩家手牌//名次排行

  717. 			for (int i = 0; i < m_cbPlayerNum; i++)

  718. 			{

  719. 				GameEnd.cbCardCount[i] = m_cbCardDataCount[i];

  720. 				CopyMemory(GameEnd.cbCardData[i], m_cbCardData[i], m_cbCardDataCount[i]);

  721. 			}

  722. 

  723. 			if (m_wWinOrder[0] == (m_wWinOrder[1] + 2) % GAME_PLAYER)//双扣判断

  724. 			{

  725. 

  726. 				//游戏积分 胜利玩家 每人+4

  727. 

  728. 				ZeroMemory(GameEnd.cbWinorLose, sizeof(GameEnd.cbWinorLose));

  729. 				//玩家输赢情况

  730. 				GameEnd.cbWinorLose[m_wWinOrder[0]] = 1;

  731. 				GameEnd.cbWinorLose[(m_wWinOrder[0] + 2) % GAME_PLAYER] = 1;

  732. 				//玩家输赢次数 //双扣分数

  733. 				for (int i = 0; i < m_cbPlayerNum; i++)

  734. 				{

  735. 					if (i == m_wWinOrder[0] || i == ((m_wWinOrder[0] + 2) % GAME_PLAYER))

  736. 					{

  737. 						m_winLoseCount[i]++;

  738. 						m_lGameAwardScore[i] += 3;

  739. 					}

  740. 					else

  741. 					{

  742. 						//m_winLoseCount[i]--;

  743. 						m_lGameAwardScore[i] -= 3;

  744. 					}

  745. 				}

  746. 				//切换庄家

  747. 				m_wBankerUser = rand() % 4;

  748. 			}

  749. 			else

  750. 			//单双扣 判断

  751. 			if (m_wWinOrder[0] == (m_wWinOrder[2] + 2) % GAME_PLAYER) //单扣判断

  752. 			{

  753. 

  754. 				//游戏积分 胜利玩家没人+2

  755. 				ZeroMemory(GameEnd.cbWinorLose, sizeof(GameEnd.cbWinorLose));

  756. 				//玩家输赢情况

  757. 				GameEnd.cbWinorLose[m_wWinOrder[0]] = 1;

  758. 				GameEnd.cbWinorLose[(m_wWinOrder[0]+2)%GAME_PLAYER] = 1;

  759. 				//玩家输赢次数 		//双扣分数

  760. 				for (int i = 0; i < m_cbPlayerNum; i++)

  761. 				{

  762. 					if (i == m_wWinOrder[0] || i == ((m_wWinOrder[0] + 2) % GAME_PLAYER))

  763. 					{

  764. 						m_winLoseCount[i]++;

  765. 						m_lGameAwardScore[i] += 2;

  766. 					}

  767. 					else

  768. 					{

  769. 						//m_winLoseCount[i]--;

  770. 						m_lGameAwardScore[i] -= 2;

  771. 					}

  772. 				}

  773. 		

  774. 				//切换庄家

  775. 				m_wBankerUser = m_wWinOrder[0];

  776. 

  777. 			}else

  778. 			{

  779. 				BOOL DuiJiabChu = FALSE;

  780. 				for (int i = 0; i < 4; i++)

  781. 				{

  782. 					if (((m_wWinOrder[0] + 2) % GAME_PLAYER) == m_wWinOrder[i])

  783. 					{

  784. 						DuiJiabChu = TRUE;

  785. 					}

  786. 

  787. 				}

  788. 				if (DuiJiabChu==FALSE) //平扣判断

  789. 				{

  790. 

  791. 					//游戏积分 胜利玩家 没人+1

  792. 					//玩家输赢情况

  793. 					GameEnd.cbWinorLose[m_wWinOrder[0]] = 1;

  794. 					GameEnd.cbWinorLose[(m_wWinOrder[0] + 2) % GAME_PLAYER] = 1;

  795. 					//玩家输赢次数

  796. 					for (int i = 0; i < m_cbPlayerNum; i++)

  797. 					{

  798. 						if (i == m_wWinOrder[0] || i == ((m_wWinOrder[0] + 2) % GAME_PLAYER))

  799. 						{

  800. 							m_winLoseCount[i]++;

  801. 							m_lGameAwardScore[i] += 1;

  802. 						}

  803. 						else

  804. 						{

  805. 							//m_winLoseCount[i]--;

  806. 							m_lGameAwardScore[i] -= 1;

  807. 						}

  808. 					}

  809. 					//切换庄家

  810. 					m_wBankerUser = rand() % 4;

  811. 				}

  812. 			}

  813. 			

  814. 			//排名逻辑 单独处理

  815. 

  816. 			//特殊处理 游戏结束 排名

  817. 			BYTE outCrank[4] = { 0xff };

  818. 			RestartRank(m_wWinOrder, outCrank);

  819. 			for (BYTE i = 0; i < m_cbPlayerNum;i++)

  820. 			{

  821. 			

  822. 				//本局总积分

  823. 				m_GameScore[i] = m_lGameGongXianScore[i] + m_lGameAwardScore[i];

  824. 				//16局总积分

  825. 				m_lGameTatolScore[i] += m_GameScore[i];

  826. 				//结束消息

  827. 				//玩家排名

  828. 				GameEnd.cbRank[i] = outCrank[i];

  829. 				//输赢次数

  830. 				GameEnd.cbWinorLoseCount[i] = m_winLoseCount[i];

  831. 				//本局积分

  832. 				GameEnd.nWanJiaScore[i] = m_GameScore[i];

  833. 				//贡献分

  834. 				GameEnd.GongxianScore[i] = m_lGameGongXianScore[i];

  835. 				//奖金

  836. 				GameEnd.AwardScore[i] = m_lGameAwardScore[i];

  837. 				//16局总积分

  838. 				GameEnd.cbWanJiaTotalScore[i] = m_lGameTatolScore[i];

  839. 

  840. 			}

  841. 			for (BYTE i = 0; i < m_cbPlayerNum;i++)

  842. 			{

  843. 				//流水

  844. 				m_HuPaiLiuShui[(m_gameConfig.wHadPlayCount - 1) * m_cbPlayerNum + i] = m_GameScore[i];

  845. 			}

  846. 			

  847. 			CopyMemory(GameEnd.lGameScoreDetail, m_HuPaiLiuShui, sizeof(m_HuPaiLiuShui));

  848. 			/*PrintCards(GameEnd.lGameScoreDetail, sizeof(GameEnd.lGameScoreDetail));*/

  849. 			//写入积分 稍后写

  850. 			tagScoreInfo ScoreInfoArray[GAME_PLAYER];

  851. 			ZeroMemory(&ScoreInfoArray, sizeof(ScoreInfoArray));

  852. 			for (WORD i = 0; i < m_cbPlayerNum; i++)

  853. 			{

  854. 				IServerUserItem *pUserItem = m_pITableFrame->GetTableUserItem(i);

  855. 				if (NULL == pUserItem) continue;

  856. 

  857. 				BYTE ScoreKind;

  858. 				if (m_GameScore[i] > 0L) ScoreKind = SCORE_TYPE_WIN;

  859. 				else if (m_GameScore[i] < 0L) ScoreKind = SCORE_TYPE_LOSE;

  860. 				else ScoreKind = SCORE_TYPE_DRAW;

  861. 

  862. 				ScoreInfoArray[i].lScore = m_GameScore[i];

  863. 				ScoreInfoArray[i].cbType = ScoreKind;

  864. 			}

  865. 			m_pITableFrame->WriteTableScore(ScoreInfoArray, CountArray(ScoreInfoArray));

  866. 			

  867. 

  868. 			GameEnd.bFinish = bFinish;

  869. 			GameEnd.playGameNum = m_gameConfig.wHadPlayCount;

  870. 		

  871. 			RepayRecord(INVALID_CHAIR, SUB_S_GAME_END_Poker, &GameEnd, sizeof(GameEnd));

  872. 			//发送结束信息

  873. 			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END_Poker, &GameEnd, sizeof(GameEnd));

  874. 			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END_Poker, &GameEnd, sizeof(GameEnd));

  875. 			PrintCards((BYTE*)&GameEnd, sizeof(GameEnd));

  876. 			CString csStr;

  877. 			csStr.Format(_T("名次 [%d %d %d %d] 玩家单局输赢情况 [%d %d %d %d ] 本局积分 [%d %d %d %d] 贡献分[%d %d %d %d] 双扣[%d %d %d %d] 总积分[%d %d %d %d] bfinsh[%d] endType=[%d] 胜局[%d %d %d %d]"),

  878. 				GameEnd.cbRank[0], GameEnd.cbRank[1], GameEnd.cbRank[2], GameEnd.cbRank[3], 

  879. 				GameEnd.cbWinorLose[0], GameEnd.cbWinorLose[1], GameEnd.cbWinorLose[2], GameEnd.cbWinorLose[3],

  880. 				GameEnd.nWanJiaScore[0], GameEnd.nWanJiaScore[1], GameEnd.nWanJiaScore[2], GameEnd.nWanJiaScore[3],

  881. 				GameEnd.GongxianScore[0], GameEnd.GongxianScore[1], GameEnd.GongxianScore[2], GameEnd.GongxianScore[3],

  882. 				GameEnd.AwardScore[0], GameEnd.AwardScore[1], GameEnd.AwardScore[2], GameEnd.AwardScore[3],

  883. 				GameEnd.cbWanJiaTotalScore[0], GameEnd.cbWanJiaTotalScore[1], GameEnd.cbWanJiaTotalScore[2], GameEnd.cbWanJiaTotalScore[3],

  884. 				GameEnd.bFinish,GameEnd.cbEndType,

  885. 				m_winLoseCount[0], m_winLoseCount[1], m_winLoseCount[2], m_winLoseCount[3]

  886. 				);

  887. 			OutputDebugString(csStr);

  888. 			//结束回放

  889. 			ConcludeGame(GS_MJ_FREE);

  890. 	

  891. 				if (bFinish)

  892. 				{

  893. 					DeletePrivateTable(true);

  894. 				}

  895. 			

  896. 		

  897. 		return true;

  898. 	}

  899. 	case GER_DISMISS:		//游戏解散

  900. 	{

  901. 		//常规结束

  902. 		CMD_S_GameEnd_SK GameEnd = { 0 };

  903. 		GameEnd.cbEndType = 2;

  904. 		GameEnd.bFinish = 1;

  905. 		//玩家手牌//名次排行

  906. 		for (int i = 0; i < m_cbPlayerNum; i++)

  907. 		{

  908. 			GameEnd.cbCardCount[i] = m_cbCardDataCount[i];

  909. 			CopyMemory(GameEnd.cbCardData[i], m_cbCardData[i], m_cbCardDataCount[i]);

  910. 		}

  911. 		//特殊处理 游戏结束 排名

  912. 		BYTE outCrank[4] = { 0xff };

  913. 		RestartRank(m_wWinOrder, outCrank);

  914. 			for (BYTE i = 0; i < m_cbPlayerNum; i++)

  915. 			{

  916. 

  917. 				//本局总积分

  918. 				m_GameScore[i] = m_lGameGongXianScore[i] + m_lGameAwardScore[i];

  919. 				//16局总积分

  920. 				m_lGameTatolScore[i] += m_GameScore[i];

  921. 				//结束消息

  922. 				//玩家排名

  923. 				GameEnd.cbRank[i] = outCrank[i];

  924. 				//输赢次数

  925. 				GameEnd.cbWinorLoseCount[i] = m_winLoseCount[i];

  926. 				//本局积分

  927. 				GameEnd.nWanJiaScore[i] = m_GameScore[i];

  928. 				//贡献分

  929. 				GameEnd.GongxianScore[i] = m_lGameGongXianScore[i];

  930. 				//奖金

  931. 				GameEnd.AwardScore[i] = m_lGameAwardScore[i];

  932. 				//16局总积分

  933. 				GameEnd.cbWanJiaTotalScore[i] = m_lGameTatolScore[i];

  934. 

  935. 			}

  936. 			for (BYTE i = 0; i < m_cbPlayerNum; i++)

  937. 			{

  938. 				//流水

  939. 				m_HuPaiLiuShui[(m_gameConfig.wHadPlayCount - 1) * m_cbPlayerNum + i] = m_GameScore[i];

  940. 			}

  941. 

  942. 			CopyMemory(GameEnd.lGameScoreDetail, m_HuPaiLiuShui, sizeof(m_HuPaiLiuShui));

  943. 			/*PrintCards(GameEnd.lGameScoreDetail, sizeof(GameEnd.lGameScoreDetail));*/

  944. 		

  945. 

  946. 			

  947. 			GameEnd.playGameNum = m_gameConfig.wHadPlayCount;

  948. 

  949. 			RepayRecord(INVALID_CHAIR, SUB_S_GAME_END_Poker, &GameEnd, sizeof(GameEnd));

  950. 			//发送结束信息

  951. 			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_END_Poker, &GameEnd, sizeof(GameEnd));

  952. 			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_END_Poker, &GameEnd, sizeof(GameEnd));

  953. 			if (m_pITableFrame->GetGameStatus() == GS_MJ_FREE)

  954. 			{

  955. 				DeletePrivateTable(true);

  956. 				return true;

  957. 			}

  958. 			//写入积分 稍后写

  959. 			tagScoreInfo ScoreInfoArray[GAME_PLAYER];

  960. 			ZeroMemory(&ScoreInfoArray, sizeof(ScoreInfoArray));

  961. 			for (WORD i = 0; i < m_cbPlayerNum; i++)

  962. 			{

  963. 				IServerUserItem *pUserItem = m_pITableFrame->GetTableUserItem(i);

  964. 				if (NULL == pUserItem) continue;

  965. 

  966. 				BYTE ScoreKind;

  967. 				if (m_GameScore[i] > 0L) ScoreKind = SCORE_TYPE_WIN;

  968. 				else if (m_GameScore[i] < 0L) ScoreKind = SCORE_TYPE_LOSE;

  969. 				else ScoreKind = SCORE_TYPE_DRAW;

  970. 

  971. 				ScoreInfoArray[i].lScore = m_GameScore[i];

  972. 				ScoreInfoArray[i].cbType = ScoreKind;

  973. 			}

  974. 			m_pITableFrame->WriteTableScore(ScoreInfoArray, CountArray(ScoreInfoArray));

  975. 

  976. 			PrintCards((BYTE*)&GameEnd, sizeof(GameEnd));

  977. 			CString csStr;

  978. 			csStr.Format(_T("名次 [%d %d %d %d] 玩家单局输赢情况 [%d %d %d %d ] 本局积分 [%d %d %d %d] 贡献分[%d %d %d %d] 双扣[%d %d %d %d] 总积分[%d %d %d %d]"),

  979. 				GameEnd.cbRank[0], GameEnd.cbRank[1], GameEnd.cbRank[2], GameEnd.cbRank[3],

  980. 				GameEnd.cbWinorLose[0], GameEnd.cbWinorLose[1], GameEnd.cbWinorLose[2], GameEnd.cbWinorLose[3],

  981. 				GameEnd.nWanJiaScore[0], GameEnd.nWanJiaScore[1], GameEnd.nWanJiaScore[2], GameEnd.nWanJiaScore[3],

  982. 				GameEnd.GongxianScore[0], GameEnd.GongxianScore[1], GameEnd.GongxianScore[2], GameEnd.GongxianScore[3],

  983. 				GameEnd.AwardScore[0], GameEnd.AwardScore[1], GameEnd.AwardScore[2], GameEnd.AwardScore[3],

  984. 				GameEnd.cbWanJiaTotalScore[0], GameEnd.cbWanJiaTotalScore[1], GameEnd.cbWanJiaTotalScore[2], GameEnd.cbWanJiaTotalScore[3]

  985. 				);

  986. 			OutputDebugString(csStr);

  987. 			//结束回放

  988. 			ConcludeGame(GS_MJ_FREE);

  989. 			DeletePrivateTable(bSendState);

  990. 			return true;

  991. 	}

  992. 	case GER_NETWORK_ERROR:		//网络错误

  993. 	case GER_USER_LEAVE:		//用户强退

  994. 	{

  995. 		if (pIServerUserItem!=NULL)

  996. 		{

  997. 			DWORD dwUserID = pIServerUserItem->GetUserID();

  998. 			m_cbOffline[dwUserID] = 1;

  999. 		}

  1000. 	

  1001. 		return true;

  1002. 

  1003. 	}

  1004. 	}

  1005. 

  1006. 	//错误断言

  1007. 	ASSERT(FALSE);

  1008. 	return false;

  1009. }

  1010. 

  1011. bool CTableFrameSinkPoker::OnTimerMessage(DWORD wTimerID, WPARAM wBindParam)

  1012. {

  1013. 	return true;

  1014. }

  1015. 

  1016. bool CTableFrameSinkPoker::OnDataBaseMessage(WORD wRequestID, VOID * pData, WORD wDataSize)

  1017. {

  1018. 	return true;

  1019. }

  1020. 

  1021. bool CTableFrameSinkPoker::OnUserScroeNotify(WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason)

  1022. {

  1023. 	return true;

  1024. }

  1025. 

  1026. bool CTableFrameSinkPoker::RepayRecordStart()

  1027. {

  1028. 	m_bReplayRecordStart = true;

  1029. 	/*for (GameRecordPacket grp : m_UserReplayRecord)

  1030. 	{

  1031. 		delete[] grp.pData;

  1032. 		grp.pData = nullptr;

  1033. 	}*/

  1034. 	m_UserReplayRecord.clear();

  1035. 	m_UserReplayRecord.shrink_to_fit();

  1036. 	return true;

  1037. }

  1038. 

  1039. bool CTableFrameSinkPoker::RepayRecord(WORD wChairID, WORD wSubCmdId, void* pData, WORD wSize)

  1040. {

  1041. 	GameRecordPacket record;

  1042. 	record.wSize = wSize;

  1043. 	record.wChairID = wChairID;

  1044. 	record.wSubCmdID = wSubCmdId;

  1045. 	record.wMainCmdID = MDM_GF_GAME;

  1046. 	/*record.pData = new char[wSize];

  1047. 	CopyMemory(record.pData, pData, wSize);*/

  1048. 	m_UserReplayRecord.push_back(record);

  1049. 	return true;

  1050. }

  1051. 

  1052. bool CTableFrameSinkPoker::RepayRecordEnd()

  1053. {

  1054. 	TRACE("回放 RepayRecordEnd：m_bReplayRecordStart = %d \n", m_bReplayRecordStart);

  1055. 	if (!m_bReplayRecordStart)

  1056. 		return false;

  1057. 

  1058. 	m_bReplayRecordStart = false;

  1059. 

  1060. 	CMD_GR_ReplayRecordResp_Poker urr;

  1061. 	ZeroMemory(&urr, sizeof(CMD_GR_ReplayRecordResp_Poker));

  1062. 

  1063. 	urr.m_UUID = 0;

  1064. 	urr.m_UserId = 0;

  1065. 	urr.m_startTime = time(0);

  1066. 	urr.m_endTime = time(0);

  1067. 	urr.m_gameconfig = m_gameConfig;

  1068. 	//urr.m_UserId = pIServerUserItem->GetUserID();

  1069. 

  1070. 	for (int j = 0; j < m_cbPlayerNum; ++j)

  1071. 	{

  1072. 		IServerUserItem * pIServerUserItem = m_pITableFrame->GetTableUserItem(j);

  1073. 		if ((pIServerUserItem == NULL) /*|| (pIServerUserItem->IsClientReady() == false)*/)

  1074. 			continue;

  1075. 		auto& chairInfo = urr.m_chairList[j];

  1076. 		chairInfo.dwUserId = pIServerUserItem->GetUserID();

  1077. 		chairInfo.wChairId = pIServerUserItem->GetChairID();

  1078. 		lstrcpy(chairInfo.userName, pIServerUserItem->GetNickName());

  1079. 		lstrcpy(chairInfo.headUrl, pIServerUserItem->GetUserInfo()->szHeadUrl);

  1080. 	}

  1081. 	urr.m_recordCount = m_UserReplayRecord.size();

  1082. 

  1083. 	int GameRecordPacketSize = sizeof(GameRecordPacket) - sizeof(void*);//每条记录头长度

  1084. 	int totalSize = sizeof(CMD_GR_ReplayRecordResp);//总记录头长度

  1085. 	for (GameRecordPacket grp : m_UserReplayRecord)

  1086. 		totalSize += (GameRecordPacketSize + grp.wSize);

  1087. 

  1088. 	char* replyRecordData = new char[totalSize];

  1089. 	ZeroMemory(replyRecordData, totalSize);

  1090. 

  1091. 	CopyMemory(replyRecordData, &urr, sizeof(CMD_GR_ReplayRecordResp));

  1092. 	int nOffset = sizeof(CMD_GR_ReplayRecordResp);

  1093. 

  1094. 

  1095. 	for (GameRecordPacket &grp : m_UserReplayRecord)

  1096. 	{

  1097. 		CopyMemory(replyRecordData + nOffset, &grp, GameRecordPacketSize);

  1098. 		nOffset += GameRecordPacketSize;

  1099. 		/*CopyMemory(replyRecordData + nOffset, grp.pData, grp.wSize);*/

  1100. 		/*nOffset += grp.wSize;*/

  1101. 		/*delete[] grp.pData;

  1102. 		grp.pData = NULL;*/

  1103. 	}

  1104. 	//m_UserReplayRecord.clear();

  1105. 	//std::vector<GameRecordPacket>(m_UserReplayRecord).swap(m_UserReplayRecord);

  1106. 

  1107. 	//FILE *fp = NULL;

  1108. 	//fp = fopen("test.bin", "wb");

  1109. 	//fwrite(replyRecordData, totalSize, 1, fp);

  1110. 	//fclose(fp);

  1111. 

  1112. 	m_pITableFrame->SaveReplayRecord(replyRecordData, totalSize);

  1113. 

  1114. 	//delete replyRecordData;不能删除，已托管给SaveReplayRecord函数

  1115. 	return true;

  1116. }

  1117. 

  1118. bool CTableFrameSinkPoker::OnUserOperate(WORD wChairID, CMD_C_OPERATE_CALLBACK_SK* pOperateCallback, BYTE cbType /*= 0*/)

  1119. {

  1120. 	m_cbTimeOutCount[wChairID] = 0;

  1121. 

  1122. 	TRACE("用户操作 wChairID = %d 操作类型： %d \n", wChairID, pOperateCallback->wOperateType);

  1123. 	m_cbUserOPerate_mask[wChairID] = pOperateCallback->wOperateType;

  1124. 	switch (pOperateCallback->wOperateType)

  1125. 	{

  1126. 	case OPERATE_MASK_OUT_Poker: //出牌

  1127. 	{

  1128. 		BYTE cbCardCount = m_GameLogic.GetCardCount(pOperateCallback->cbCardData);

  1129. 		BYTE LianxianInfo = pOperateCallback->LianxianInfo;

  1130. 		return OnUserOutCard(wChairID, pOperateCallback->cbCardData, cbCardCount, pOperateCallback->cbCardType, pOperateCallback->cbJokerReplacePoker, LianxianInfo);

  1131. 	}

  1132. 	case OPERATE_MASK_NOOUT_Poker: //要不起

  1133. 	case OPERATE_MASK_PASS_Poker: //不出

  1134. 	{

  1135. 		m_cbResponse[wChairID] = 1;

  1136. 		/*

  1137. 			struct CMD_S_Out_Broadcast_SK

  1138. 			{

  1139. 			WORD wOutCardUser;			//出牌用户

  1140. 			WORD cbOperateType;			//操作类型

  1141. 			WORD cbCardType;			//出牌牌型

  1142. 			BYTE cbJokerReplacePoker[4];//替换癞子的牌

  1143. 			BYTE cbOutCardData[27];		//出牌扑克

  1144. 			BYTE cbIsFreeOut;			//是否自由出牌

  1145. 			BYTE cbIsTrusteeOut;		//是否托管出牌

  1146. 			BYTE cbLeftCount;			//剩余牌数

  1147. 			BYTE cbRanking;				//当前名次

  1148. 			};

  1149. 		*/

  1150. 		//出牌广播

  1151. 		CMD_S_Out_Broadcast_SK  outCard = { 0 };

  1152. 		outCard.wOutCardUser = wChairID;

  1153. 		outCard.cbOperateType = pOperateCallback->wOperateType;

  1154. 		outCard.cbCardType = CT_ERROR;

  1155. 		CopyMemory(outCard.cbJokerReplacePoker, pOperateCallback->cbJokerReplacePoker, sizeof(pOperateCallback->cbJokerReplacePoker));

  1156. 		//CopyMemory(outCard.cbOutCardData, pOperateCallback->bCardData, 0);

  1157. 		outCard.cbIsFreeOut = FALSE;

  1158. 		outCard.cbIsTrusteeOut = 0;

  1159. 		outCard.cbLeftCount = m_cbCardDataCount[wChairID];

  1160. 		outCard.cbRanking[0] =m_wWinOrder[0];

  1161. 		outCard.cbRanking[1] = m_wWinOrder[1];

  1162. 		outCard.cbRanking[2] = m_wWinOrder[2];

  1163. 		outCard.cbRanking[3] = m_wWinOrder[3];

  1164. 		m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OUT_BROADCAST_Poker, &outCard, sizeof(outCard));

  1165. 		m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OUT_BROADCAST_Poker, &outCard, sizeof(outCard));

  1166. 		RepayRecord(INVALID_CHAIR, SUB_S_OUT_BROADCAST_Poker, &outCard, sizeof(outCard));

  1167. 		return NextOperate(wChairID);

  1168. 	}

  1169. 	case OPERATE_MASK_HINT_Poker: //提示

  1170. 		return OnUserHint(wChairID);

  1171. 	default:

  1172. 		CString tmp;

  1173. 		tmp.Format(_T("OnUserOperate 收到 %d "), pOperateCallback->wOperateType);

  1174. 		break;

  1175. 	}

  1176. 	return true;

  1177. }

  1178. //去花色排序

  1179. void CTableFrameSinkPoker::SortCard(BYTE cbCardData[], BYTE cbCardCount)

  1180. {

  1181. 	BYTE tmp = 0;

  1182. 	for (BYTE i = 0; i < cbCardCount; ++i)

  1183. 	{

  1184. 		cbCardData[i] &= 0x0f;

  1185. 		tmp = cbCardData[i];

  1186. 		cbCardData[i] = m_GameLogic.GetCardLogicValue(tmp);

  1187. 	}

  1188. 

  1189. 	sort(cbCardData, cbCardData + cbCardCount);

  1190. 

  1191. 	for (BYTE i = 0; i < cbCardCount; ++i)

  1192. 	{

  1193. 		tmp = cbCardData[i];

  1194. 		cbCardData[i] = m_GameLogic.GetCardValue(tmp);

  1195. 	}

  1196. }

  1197. 

  1198. bool CTableFrameSinkPoker::IsTeShuCard(BYTE cbCardData[], BYTE cbCount, BomoType& BomoInfo, WORD&WinScore)

  1199. {

  1200. 	BYTE cbLevel;

  1201. 	BYTE CardType=m_GameLogic.GetCardType(cbCardData, cbCount, cbLevel, BomoInfo);

  1202. 

  1203. 	if ((CardType == 7 && cbCount >= 5) ||CardType>7)

  1204. 	{

  1205. 		BYTE tmpXian =0;

  1206. 		if (CardType==7)

  1207. 		{

  1208. 			tmpXian = cbCount;

  1209. 		}

  1210. 		else

  1211. 		{

  1212. 			tmpXian = BomoInfo.Level;

  1213. 		}

  1214. 		//计算分数

  1215. 		switch (tmpXian)

  1216. 		{

  1217. 		case 5:

  1218. 			WinScore = 1*(m_cbPlayerNum-1);

  1219. 			break;

  1220. 		case 6:

  1221. 		case 7:

  1222. 		case 8:

  1223. 		case 9:

  1224. 		case 10:

  1225. 		case 11:

  1226. 		case 12:

  1227. 		case 13:

  1228. 			WinScore = pow(2, tmpXian-5)*3;

  1229. 			break;

  1230. 		default:

  1231. 			break;

  1232. 		}

  1233. 		return TRUE;

  1234. 	}

  1235. 	return false;

  1236. }

  1237. 

  1238. BOOL CTableFrameSinkPoker::IsWinByChairID(BYTE wChairID)

  1239. {

  1240. 	for (int i = 0; i < m_cbPlayerNum;i++)

  1241. 	{

  1242. 		if (m_wWinOrder[i] == wChairID)

  1243. 		{

  1244. 			return TRUE;

  1245. 		}

  1246. 	}

  1247. 	return FALSE;

  1248. }

  1249. 

  1250. void CTableFrameSinkPoker::WithByteAnalyzeCardFlags(BYTE lianxianinfo,BomoType &BomoInfo)

  1251. {

  1252. 	//第一位 0 标示付 1 表示连 

  1253. 	//2-4 标示 几付 /几连

  1254. 	//最后4位 表示 几线 

  1255. 	BOOL IsLian = lianxianinfo >> 7;

  1256. 	BYTE fuOrLian = (lianxianinfo & 0x70) >> 4;

  1257. 	BYTE xian = (lianxianinfo & 15) >> 1;

  1258. 	if (lianxianinfo>0)

  1259. 	{

  1260. 		BomoInfo.BomoTypes = IsLian == 0? BomoTypeXian : BomoTypeLian;

  1261. 		if (IsLian)

  1262. 		{

  1263. 			BomoInfo.tong = xian;

  1264. 			BomoInfo.lian = fuOrLian;

  1265. 		}

  1266. 		else

  1267. 		{

  1268. 			BomoInfo.fu = fuOrLian;

  1269. 			BomoInfo.xian = xian;

  1270. 		}

  1271. 		m_GameLogic.SetBomoLevel(BomoInfo);

  1272. 	}

  1273. 

  1274. 

  1275. }

  1276. 

  1277. void CTableFrameSinkPoker::SetCardFlags(BOOL IsLian, BYTE fuOrLian, BYTE xian)

  1278. {

  1279. 	//第一位 0 标示付 1 表示连 

  1280. 	//2-4 标示 几付 /几连

  1281. 	//最后4位 表示 几线 

  1282. 	BYTE lianxinfo;

  1283. 	lianxinfo = IsLian << 7;

  1284. 	lianxinfo |= fuOrLian << 4;

  1285. 	lianxinfo |= xian << 1;

  1286. 	BomoType BomoInfo;

  1287. 	WithByteAnalyzeCardFlags(lianxinfo, BomoInfo);

  1288. }

  1289. //托管出牌 全部发要不起

  1290. bool CTableFrameSinkPoker::TrusteeOut(WORD wChairID)

  1291. {

  1292. 	if (BeOutCardFree(wChairID)){

  1293. 

  1294. 		BYTE cbCardData[1];

  1295. 		BYTE cbCardCount = 1;

  1296. 		cbCardData[0] = m_cbCardData[wChairID][0];

  1297. 		BYTE Joker[4] = { 0 };

  1298. 		return OnUserOutCard(wChairID, cbCardData, cbCardCount, CT_SINGLE, Joker,0);

  1299. 	}

  1300. 	else

  1301. 	{

  1302. 		//出牌广播

  1303. 		CMD_S_Out_Broadcast_SK OutCard = { 0 };

  1304. 		 

  1305. 		OutCard.wOutCardUser = wChairID;

  1306. 		OutCard.cbOperateType = OPERATE_MASK_NOOUT_Poker;

  1307. 		OutCard.cbIsTrusteeOut = 1;

  1308. 		OutCard.cbLeftCount = m_cbCardDataCount[wChairID];

  1309. 		m_pITableFrame->SendTableData(INVALID_CHAIR, OPERATE_MASK_NOOUT_Poker, &OutCard, sizeof(OutCard));

  1310. 		m_pITableFrame->SendLookonData(INVALID_CHAIR, OPERATE_MASK_NOOUT_Poker, &OutCard, sizeof(OutCard));

  1311. 		RepayRecord(INVALID_CHAIR, OPERATE_MASK_NOOUT_Poker, &OutCard, sizeof(OutCard));

  1312. 		return NextOperate(wChairID);

  1313. 	}

  1314. }

  1315. 

  1316. bool CTableFrameSinkPoker::SendTeamfrindCards(WORD MyWchairID)

  1317. {

  1318. 	//myWchirID 标示 把我的牌 发给我的队友

  1319. 	WORD myTeamFrindChirID = (MyWchairID + 2 )% GAME_PLAYER;

  1320. 	if (IsWinByChairID(myTeamFrindChirID))

  1321. 	{

  1322. 		//队友手牌

  1323. // 		struct CMD_S_TEAMMATE_HANDCARD

  1324. // 		{

  1325. // 			WORD wTeammateChairID;	 		//队友座位

  1326. // 			BYTE cbCardData[27];			//队友手牌

  1327. // 		};

  1328. 		CMD_S_TEAMMATE_HANDCARD st = { 0 };

  1329. 

  1330. 		st.wTeammateChairID = myTeamFrindChirID;

  1331. 		CopyMemory(st.cbCardData, m_cbCardData[MyWchairID], m_cbCardDataCount[MyWchairID]);

  1332. 		m_pITableFrame->SendTableData(myTeamFrindChirID, SUB_S_TEAMMATE_HANDCARD_Poker, &st, sizeof(st));

  1333. 		//RepayRecord(myTeamFrindChirID, SUB_S_TEAMMATE_HANDCARD_Poker, &st, sizeof(st));

  1334. 	}

  1335. 	return true;

  1336. }

  1337. 

  1338. bool CTableFrameSinkPoker::RestartRank(const BYTE cbRank[4], BYTE outRandToEnd[4])

  1339. {

  1340. 	memset(outRandToEnd, 0xff, 4);

  1341. 	for (int i = 0; i < 4;i++)

  1342. 	{

  1343. 		for (int j = 0; j < 4;j++)

  1344. 		{

  1345. 			if (cbRank[j]==i)

  1346. 			{

  1347. 				outRandToEnd[i] = j+1;

  1348. 			}

  1349. 		}

  1350. 	}

  1351. 	

  1352. 	return 0;

  1353. }

  1354. 

  1355. BOOL CTableFrameSinkPoker::DeleteListOutCardRecord(DWORD wChairID)

  1356. {

  1357. 	list<OutCard>::iterator it;

  1358. 	for (it = m_listOutCard.begin(); it != m_listOutCard.end();)

  1359. 	{

  1360. 		if (it->wOutCardUser == wChairID)

  1361. 			it = m_listOutCard.erase(it);     //返回下一个有效的迭代器，无需+1  

  1362. 		else

  1363. 			++it;

  1364. 	}

  1365. 	return TRUE;

  1366. }

  1367. 

  1368. void CTableFrameSinkPoker::ReadGameData()

  1369. {

  1370. 	CString strFileName;

  1371. 	strFileName = _T("Table.dat");

  1372. 	if (!PathFileExists(_T("Table.dat")))

  1373. 	{

  1374. 		return;

  1375. 	}

  1376. 

  1377. 	HANDLE hFile = CreateFile(strFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_ALWAYS, NULL, NULL);

  1378. 	if (hFile != INVALID_HANDLE_VALUE)

  1379. 	{

  1380. 		DWORD dwRead;

  1381. 		DWORD dwFileSize;

  1382. 		DWORD fileSize = GetFileSize(hFile, &dwFileSize);

  1383. 		if (fileSize != 108)

  1384. 		{

  1385. 			CloseHandle(hFile);

  1386. 			return;

  1387. 		}

  1388. 		SetFilePointer(hFile, 0, 0, FILE_BEGIN);

  1389. 

  1390. 		ReadFile(hFile, m_cbRepertoryCard, 108, &dwRead, NULL);

  1391. 

  1392. 		CloseHandle(hFile);

  1393. 

  1394. 	

  1395. 	}

  1396. }

  1397. 

  1398. BOOL CTableFrameSinkPoker::IsHaveBoomCountScore(BYTE wCharid, BYTE cbCardCount, WORD & WinScore)

  1399. {

  1400. 	int nFu = m_BoomCountInfo[wCharid][cbCardCount - 4];

  1401. 	int nXian = cbCardCount;

  1402. 	if (nFu<3)

  1403. 	{

  1404. 		return FALSE;

  1405. 	}

  1406. 	if (nFu==3&&nXian<=5)

  1407. 	{

  1408. 		return FALSE;

  1409. 	}

  1410. 	int tmpXian = 0;

  1411. 	switch (nXian)

  1412. 	{

  1413. 	case 4:

  1414. 		tmpXian = nFu + 1;

  1415. 		break;

  1416. 	case 5:

  1417. 		tmpXian = nFu + 4;

  1418. 		break;

  1419. 	case 6:

  1420. 	case 7:

  1421. 	case 8:

  1422. 	case 9:{

  1423. 		tmpXian = nFu + nXian;

  1424. 		break;

  1425. 	}

  1426. 

  1427. 	default:

  1428. 		break;

  1429. 	}

  1430. 	

  1431. 	//计算分数

  1432. 	switch (tmpXian)

  1433. 	{

  1434. 	case 5:

  1435. 		WinScore = 1 * (m_cbPlayerNum - 1);

  1436. 		break;

  1437. 	case 6:

  1438. 	case 7:

  1439. 	case 8:

  1440. 	case 9:

  1441. 	case 10:

  1442. 	case 11:

  1443. 	case 12:

  1444. 	case 13:

  1445. 		WinScore = pow(2, tmpXian - 5) * 3;

  1446. 		break;

  1447. 	default:

  1448. 		break;

  1449. 	}

  1450. 	return TRUE;

  1451. }

  1452. 

  1453. bool CTableFrameSinkPoker::OnUserOutCard(WORD wChairID, BYTE bCardData[], BYTE bCardCount, BYTE cbCardType, BYTE cbJokerReplacePoker[4],BYTE LianxianInfo)

  1454. {

  1455. 	m_lastLianxianInfo = LianxianInfo;

  1456. //	OutputDebugString(_T("OnUserOutCard "));

  1457. 	CopyMemory(m_cbJokerReplacePoker[wChairID], cbJokerReplacePoker, sizeof(cbJokerReplacePoker));

  1458. //	PrintCards(cbJokerReplacePoker,sizeof(cbJokerReplacePoker));

  1459. 	//效验状态

  1460. 	if (wChairID != m_wCurrentUser)

  1461. 	{

  1462. 		OutputDebugString(L"当前玩家和出牌玩家不是一个 返回失败");

  1463. 		return false;

  1464. 	}

  1465. 	

  1466. 	//生成出牌数据(不带花色)

  1467. 	OutCard struOutCard = { 0 };

  1468. 	struOutCard.wOutCardUser = wChairID;

  1469. 	memcpy(struOutCard.cbOutCardData, bCardData, bCardCount*sizeof(BYTE));

  1470. 	SortCard(struOutCard.cbOutCardData, bCardCount);

  1471. 	struOutCard.cbOutCardCount = bCardCount;

  1472. 	struOutCard.cbOutCardType = cbCardType;

  1473. 

  1474. 	

  1475. 	//变幻扑克

  1476. 	//[10040] 1b,1b,0b,1c,0c,0c,3d,0d,0d,4e,4f,4f, 

  1477. 

  1478. 	PrintCards(bCardData, bCardCount);

  1479. 	PrintCards(cbJokerReplacePoker, 4);//[10040] 0b,0c,0d,00,

  1480. 

  1481. 	//将王牌替换

  1482. 	BYTE cbMagicCardData[MAX_COUNT_Poker] = { 0 };

  1483. 	CopyMemory(cbMagicCardData, bCardData, bCardCount);

  1484. 	m_GameLogic.ReplaceWangCards(bCardData, bCardCount, cbJokerReplacePoker, cbMagicCardData);

  1485. 	//m_GameLogic.MagicCardData(bCardData, bCardCount, cbMagicCardData);

  1486. 	PrintCards(cbMagicCardData, bCardCount);

  1487. 	//[10040] 1b,1b,0b,1c,0c,0c,3d,0d,0d,4e,4f,4f, 

  1488. 

  1489. 

  1490. 	//判断是否为自由出牌

  1491. 	BYTE cbIsFreeOut = BeOutCardFree(wChairID);

  1492. 

  1493. 	////出牌判断 目前前端已经判断 稍后重构这部分判断

  1494. 	if (m_cbTurnCardCount != 0 && cbIsFreeOut == false)

  1495. 	{

  1496. 		//对比扑克

  1497. 		if (m_GameLogic.CompareCard(m_cbMagicCardData, cbMagicCardData, m_cbTurnCardCount, bCardCount) == false)

  1498. 		{

  1499. 			ASSERT(FALSE);

  1500. 			OutputDebugString(L"扑克比较 失败，出牌玩家的牌没有上家大  返回失败");

  1501. 

  1502. 			return false;

  1503. 		}

  1504. 	}

  1505. 

  1506. 

  1507. 	//类型判断

  1508. 	BYTE cbStarLevel;

  1509. 	BomoType bomoinof;

  1510. 	BYTE bCardType = m_GameLogic.GetCardType(cbMagicCardData, bCardCount, cbStarLevel, bomoinof);

  1511. 	if (bCardType == 7 && bCardCount == 4)

  1512. 	{

  1513. 		m_BomoCouut[wChairID]++;

  1514. 	}

  1515. 	if (bCardType == CT_BOMB&&bCardCount>=4)

  1516. 	{

  1517. 		m_BoomCountInfo[wChairID][bCardCount - 4]++;

  1518. 	}

  1519. 

  1520. 	if (bCardType>=10)

  1521. 	{

  1522. 		bCardType = 10;

  1523. 	}

  1524. 

  1525. 

  1526. 	//删除扑克

  1527. 	if (m_GameLogic.RemoveCard(bCardData, bCardCount, m_cbCardData[wChairID], m_cbCardDataCount[wChairID]) == false)

  1528. 	{

  1529. 		OutputDebugString(_T("删除扑克失败失败"));

  1530. 		

  1531. 		ASSERT(FALSE);

  1532. 		return false;

  1533. 	}

  1534. 

  1535. 	//出牌记录

  1536. 	memset(&m_struOutCard, 0, sizeof(OutCard));

  1537. 	memcpy(&m_struOutCard, &struOutCard, sizeof(OutCard));

  1538. 	memcpy(struOutCard.cbOutCardData, bCardData, bCardCount*sizeof(BYTE));

  1539. 	m_listOutCard.push_back(struOutCard);

  1540. 

  1541. 

  1542. 	//设置变量

  1543. 	m_cbTurnCardCount = bCardCount;

  1544. 	m_cbCardDataCount[wChairID] -= bCardCount;

  1545. 	CopyMemory(m_cbTurnCardData, bCardData, sizeof(BYTE)*bCardCount);

  1546. 	CopyMemory(m_cbMagicCardData, cbMagicCardData, sizeof(BYTE)*bCardCount);

  1547. 	

  1548. 

  1549. 	/*

  1550. 	struct CMD_S_Out_Broadcast_SK

  1551. 	{

  1552. 		WORD wOutCardUser;			//出牌用户

  1553. 		WORD cbOperateType;			//操作类型

  1554. 		WORD cbCardType;			//出牌牌型

  1555. 		BYTE cbJokerReplacePoker[4];//替换癞子的牌

  1556. 		BYTE cbOutCardData[27];		//出牌扑克

  1557. 		BYTE cbIsFreeOut;			//是否自由出牌

  1558. 		BYTE cbIsTrusteeOut;		//是否托管出牌

  1559. 		BYTE cbLeftCount;			//剩余牌数

  1560. 		BYTE cbRanking;				//当前名次

  1561. 	}; */

  1562. 	if (m_cbCardDataCount[wChairID] == 0){

  1563. 		//设置用户

  1564. 		m_wWinOrder[m_wWinCount++] = wChairID;

  1565. 		m_wTurnWiner = wChairID;

  1566. 	}

  1567. 	m_cbResponse[wChairID] = 2;

  1568. 	CMD_S_Out_Broadcast_SK  outCard = { 0 };

  1569. 	outCard.wOutCardUser = wChairID;

  1570. 	outCard.cbOperateType = OPERATE_MASK_OUT_Poker;

  1571. 	outCard.cbCardType = bCardType;

  1572. 	CopyMemory(outCard.cbJokerReplacePoker, cbJokerReplacePoker, sizeof(cbJokerReplacePoker));

  1573. 	CopyMemory(outCard.cbOutCardData, bCardData, bCardCount*sizeof(BYTE));

  1574. 	outCard.cbIsFreeOut = cbIsFreeOut;

  1575. 	outCard.cbIsTrusteeOut = 0;

  1576. 	outCard.cbLeftCount = m_cbCardDataCount[wChairID];

  1577. 	outCard.cbRanking[0] = m_wWinOrder[0];

  1578. 	outCard.cbRanking[1] = m_wWinOrder[1];

  1579. 	outCard.cbRanking[2] = m_wWinOrder[2];

  1580. 	outCard.cbRanking[3] = m_wWinOrder[3];

  1581. 	outCard.LianXianInfo = LianxianInfo;

  1582. 	m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OUT_BROADCAST_Poker, &outCard, sizeof(outCard));

  1583. 	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OUT_BROADCAST_Poker, &outCard, sizeof(outCard));

  1584. 	RepayRecord(INVALID_CHAIR, SUB_S_OUT_BROADCAST_Poker, &outCard, sizeof(outCard));

  1585. 	PrintCards((const BYTE*)&outCard, sizeof(CMD_S_Out_Broadcast_SK));

  1586. 	//胜利判断

  1587. 	if (m_cbCardDataCount[wChairID] == 0)

  1588. 	{

  1589. 	

  1590. 		//用户统计

  1591. 		if (m_cbCardDataCount[(wChairID + 2) % GAME_PLAYER] == 0)

  1592. 			m_wCurrentUser = INVALID_CHAIR;

  1593. 

  1594. 		//把队友的牌发给我

  1595. 		BYTE TeamFrindChairid = (wChairID + 2) % GAME_PLAYER;

  1596. 		SendTeamfrindCards(TeamFrindChairid);

  1597. 

  1598. 		//m_cbResponse[wChairID] = 0;

  1599. 	}

  1600. 	else

  1601. 	{

  1602. 		SendTeamfrindCards(wChairID);

  1603. 	

  1604. 	}

  1605. 	if (m_gameConfig.HaveBoomScore)

  1606. 	{

  1607. 		//判断是否是大牌

  1608. 		BomoType BomoInfo;

  1609. 		WORD WinScore = 0;

  1610. 		if (IsTeShuCard(cbMagicCardData, bCardCount, BomoInfo, WinScore))

  1611. 		{

  1612. 			if (bCardType==CT_BOMB)

  1613. 			{

  1614. 				IsHaveBoomCountScore(wChairID, bCardCount, WinScore);

  1615. 			}

  1616. 			OutputDebugString(_T("特殊牌"));

  1617. 			PrintCards(cbMagicCardData, bCardCount);

  1618. 			CMD_S_JiangJin jiangjin;

  1619. 			jiangjin.wOperateUser = wChairID;

  1620. 			ZeroMemory(jiangjin.cbCardData, MAX_COUNT_Poker);

  1621. 			CopyMemory(jiangjin.cbCardData, bCardData, bCardCount);

  1622. 			cbCardType = bCardType;

  1623. 			m_BomoCouut[wChairID]++;

  1624. 			//这个tmp 应该是计算出来的

  1625. 			int tmpScore = WinScore;

  1626. 			if (m_BomoCouut[wChairID] >= 4)

  1627. 			{

  1628. 				tmpScore += (m_BomoCouut[wChairID] - 3) * 3;

  1629. 				CString strInfo;

  1630. 				strInfo.Format(_T("tmpScore =%d m_BomoCouut[wChairID] =%d"), tmpScore, m_BomoCouut[wChairID]);

  1631. 				OutputDebugString(strInfo);

  1632. 			}

  1633. 

  1634. 			jiangjin.Scores[wChairID] = tmpScore;

  1635. 			m_lGameGongXianScore[wChairID] += tmpScore;

  1636. 			jiangjin.TureScores[wChairID] = m_lGameGongXianScore[wChairID];

  1637. 			for (int i = 0; i < m_cbPlayerNum; i++)

  1638. 			{

  1639. 				if (wChairID == i)

  1640. 				{

  1641. 					continue;

  1642. 				}

  1643. 				jiangjin.Scores[i] = 0 - tmpScore / 3;

  1644. 				m_lGameGongXianScore[i] += jiangjin.Scores[i];

  1645. 				jiangjin.TureScores[i] = m_lGameGongXianScore[i];

  1646. 				CString strInfo;

  1647. 				strInfo.Format(_T("ID=%d jiangjin.Scores =%d m_lGameGongXianScore =%d\r\n"), i, jiangjin.Scores[i], m_lGameGongXianScore[i]);

  1648. 				OutputDebugString(strInfo);

  1649. 			}

  1650. 

  1651. 			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_JiangJin_Poker, &jiangjin, sizeof(jiangjin));

  1652. 			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_JiangJin_Poker, &jiangjin, sizeof(jiangjin));

  1653. 			RepayRecord(INVALID_CHAIR, SUB_S_GAME_JiangJin_Poker, &jiangjin, sizeof(jiangjin));

  1654. 		}

  1655. 		else if (bCardType == 7 && bCardCount == 4 && m_BomoCouut[wChairID] >= 4)

  1656. 		{

  1657. 			int tmpScore = 0;

  1658. 			if (m_BomoCouut[wChairID] >= 4)

  1659. 			{

  1660. 				tmpScore += (m_BomoCouut[wChairID] - 3) * 3;

  1661. 			}

  1662. 			if (bCardType == CT_BOMB)

  1663. 			{

  1664. 				WORD WinScore = 0;

  1665. 				IsHaveBoomCountScore(wChairID, bCardCount, WinScore);

  1666. 				tmpScore += WinScore;

  1667. 			}

  1668. 			CMD_S_JiangJin jiangjin;

  1669. 			jiangjin.wOperateUser = wChairID;

  1670. 			ZeroMemory(jiangjin.cbCardData, MAX_COUNT_Poker);

  1671. 			CopyMemory(jiangjin.cbCardData, bCardData, bCardCount);

  1672. 			jiangjin.Scores[wChairID] = tmpScore;

  1673. 			m_lGameGongXianScore[wChairID] += tmpScore;

  1674. 			jiangjin.TureScores[wChairID] = m_lGameGongXianScore[wChairID];

  1675. 			for (int i = 0; i < m_cbPlayerNum; i++)

  1676. 			{

  1677. 				if (wChairID == i)

  1678. 				{

  1679. 					continue;

  1680. 				}

  1681. 				jiangjin.Scores[i] = 0 - tmpScore / 3;

  1682. 				m_lGameGongXianScore[i] += jiangjin.Scores[i];

  1683. 				jiangjin.TureScores[i] = m_lGameGongXianScore[i];

  1684. 			}

  1685. 			m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_GAME_JiangJin_Poker, &jiangjin, sizeof(jiangjin));

  1686. 			m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_GAME_JiangJin_Poker, &jiangjin, sizeof(jiangjin));

  1687. 			RepayRecord(INVALID_CHAIR, SUB_S_GAME_JiangJin_Poker, &jiangjin, sizeof(jiangjin));

  1688. 			// 		OutputDebugString(_T("普通"));

  1689. 			// 		PrintCards(cbMagicCardData, bCardCount);

  1690. 		}

  1691. 	}

  1692. 	

  1693. 

  1694. 	//结束判断

  1695. 	if (m_wCurrentUser == INVALID_CHAIR) 

  1696. 	{ 

  1697. 		OnEventGameConclude(wChairID, NULL, GER_NORMAL);

  1698. 		return true;

  1699. 	}

  1700. 		

  1701. 	

  1702. 	return  NextOperate(wChairID);

  1703. 

  1704. }

  1705. 

  1706. bool CTableFrameSinkPoker::BeOutCardFree(WORD wChairID)

  1707. {

  1708. 	for (BYTE i = 0; i < GAME_PLAYER; ++i)

  1709. 	{

  1710. 		if (i == wChairID) continue;

  1711. 		if (m_cbResponse[i] == 2)

  1712. 			return false;

  1713. 

  1714. 

  1715. 	}

  1716. 	ZeroMemory(m_cbResponse, sizeof(m_cbResponse));

  1717. 	MyZeroMemory(m_cbUserOPerate_mask);

  1718. 	return true;

  1719. }

  1720. 

  1721. bool CTableFrameSinkPoker::NextOperate(WORD wChairID)

  1722. {

  1723. 	//切换用户

  1724. 	PrintCards(m_cbResponse, 4);

  1725. 	do 

  1726. 	{

  1727. 		//设置用户

  1728. 		m_wCurrentUser = (m_wCurrentUser + 1) % GAME_PLAYER;

  1729. 

  1730. 		//完成判断

  1731. 		if (m_wCurrentUser == m_wTurnWiner)

  1732. 		{

  1733. 			//设置变量

  1734. 			//m_cbTurnCardCount = 0;

  1735. 

  1736. 			if (BeOutCardFree(m_wCurrentUser))

  1737. 			{

  1738. 				//接风处理

  1739. 				if (m_cbCardDataCount[m_wTurnWiner] == 0)

  1740. 				{

  1741. 					m_wCurrentUser = (m_wTurnWiner + 2) % GAME_PLAYER;

  1742. 				}

  1743. 				m_wTurnWiner = INVALID_CHAIR;

  1744. 				ZeroMemory(m_cbResponse, sizeof(m_cbResponse));

  1745. 				MyZeroMemory(m_cbUserOPerate_mask);

  1746. 				break;

  1747. 			}

  1748. 			else

  1749. 			{

  1750. 				m_cbResponse[m_wTurnWiner] = 0;

  1751. 				m_cbUserOPerate_mask[m_wTurnWiner] = 0;

  1752. 				m_wTurnWiner = INVALID_CHAIR;

  1753. 				

  1754. 			}

  1755. 		}

  1756. 

  1757. 		//继续处理

  1758. 		if (m_cbCardDataCount[m_wCurrentUser] != 0){

  1759. 			break;

  1760. 		}

  1761. 		else

  1762. 		{

  1763. 			if (m_cbResponse[m_wCurrentUser] == 2 && m_wWinCount==2)

  1764. 			{

  1765. 				m_cbResponse[m_wCurrentUser] = 0;

  1766. 			}

  1767. 		}

  1768. 	} while (true);

  1769. 	/*

  1770. 	struct CMD_S_Operate_SK

  1771. 	{

  1772. 	WORD wOperateUser;			//操作用户

  1773. 	WORD wOperateType;			//操作掩码

  1774. 	BYTE cbOptTime;				//操作时间（秒）

  1775. 	BYTE cbIsFreeOut;			//是否自由出牌

  1776. 	};

  1777. 	*/

  1778. 	PrintCards(m_cbResponse, 4);//1 0 2 1 

  1779. 	CMD_S_Operate_SK Operate = { 0 };

  1780. 	Operate.wOperateUser = m_wCurrentUser;

  1781. 	if (!BeOutCardFree(m_wCurrentUser))

  1782. 	{

  1783. 		Operate.cbIsFreeOut = 0;

  1784. 		m_cbHintNum = 0;

  1785. 		m_cbCurrentHintNum = 0;

  1786. 		mHistList.clear();

  1787. 		if (m_GameLogic.bCanOutCard(m_cbMagicCardData, m_cbTurnCardCount, m_cbCardData[m_wCurrentUser], m_cbCardDataCount[m_wCurrentUser],mHistList))

  1788. 		{

  1789. 			//要得起

  1790. 			Operate.wOperateType = OPERATE_MASK_OUT_Poker | OPERATE_MASK_HINT_Poker | OPERATE_MASK_PASS_Poker;

  1791. 		}

  1792. 		else

  1793. 		{

  1794. 			//要不起

  1795. 			Operate.wOperateType = OPERATE_MASK_NOOUT_Poker ;

  1796. 		}

  1797. 		m_cbHintNum = mHistList.size();

  1798. 		DeleteListOutCardRecord(m_wCurrentUser);

  1799. 	}

  1800. 	else

  1801. 	{//自由

  1802. 		mHistList.clear();

  1803. 		m_GameLogic.FindAllHit(m_cbCardData[m_wCurrentUser], m_cbCardDataCount[m_wCurrentUser], mHistList);

  1804. 		m_cbHintNum = mHistList.size();

  1805. 		Operate.cbIsFreeOut = 1;

  1806. 		Operate.wOperateType = OPERATE_MASK_OUT_Poker | OPERATE_MASK_HINT_Poker;

  1807. // 		CString strOut;

  1808. // 		strOut.Format(_T("有玩家自由 清空替换牌WID =%d"), m_wCurrentUser);

  1809. // 		OutputDebugString(strOut);

  1810. 		PrintCards(m_cbJokerReplacePoker[0], 16);

  1811. 		ZeroMemory(m_cbJokerReplacePoker, sizeof(m_cbJokerReplacePoker));

  1812. 		m_listOutCard.clear();

  1813. 	}

  1814. 	//清空当前玩家出过的牌

  1815. 

  1816. 	m_wCurrentOperate = Operate.wOperateType;

  1817. 	Operate.cbOptTime = GAME_TIMEOUT;

  1818. 	Operate.LianXianInfo = m_lastLianxianInfo;

  1819. 

  1820. 	m_pITableFrame->SendTableData(INVALID_CHAIR, SUB_S_OPERATE_Poker, &Operate, sizeof(Operate));

  1821. 	m_pITableFrame->SendLookonData(INVALID_CHAIR, SUB_S_OPERATE_Poker, &Operate, sizeof(Operate));

  1822. 	RepayRecord(INVALID_CHAIR, SUB_S_OPERATE_Poker, &Operate, sizeof(Operate));

  1823. 	//if (wChairID == m_wTurnWiner&&m_cbResponse[wChairID]!=0)

  1824. 	//{

  1825. 	//	m_cbResponse[wChairID] = 0;

  1826. 	//}

  1827. 	return true;

  1828. }

  1829. 

  1830. void CTableFrameSinkPoker::PrintCards(const BYTE cbCardData[], short cbCount)

  1831. {

  1832. 	CString strPrint;

  1833. 	for (int i = 0; i < cbCount;i++)

  1834. 	{

  1835. 		CString str;

  1836. 		str.Format(_T("%02x,"),cbCardData[i]);

  1837. 		strPrint += str;

  1838. 	}

  1839. 	CString tmp1;

  1840. 	tmp1.Format(L" 字节数=%d", cbCount);

  1841. 	strPrint += tmp1;

  1842. 	strPrint.Append(_T("\r\n"));

  1843. 	OutputDebugString(strPrint);

  1844. }

  1845. 

  1846. void CTableFrameSinkPoker::FindCardOwner(BOOL &bSwitchChair)

  1847. {

  1848. 	/*

  1849. 	开始计算变换位置

  1850. 	*/

  1851. 	bSwitchChair = false;

  1852. 	WORD wSourceID[] = { INVALID_CHAIR, INVALID_CHAIR };

  1853. 

  1854. 	if (m_wBankerUser == INVALID_CHAIR)

  1855. 	{

  1856. 		//寻找庄家用户

  1857. 		for (WORD userIndex = 0; userIndex < m_cbPlayerNum; userIndex++)

  1858. 		{

  1859. 			for (BYTE j = 0; j < MAX_COUNT_Poker; j++)

  1860. 			{

  1861. 				if (m_cbCardData[userIndex][j] == m_cbStartRandCard)

  1862. 				{

  1863. 					m_wBankerUser = userIndex;

  1864. 					break;

  1865. 				}

  1866. 			}

  1867. 			if (m_wBankerUser != INVALID_CHAIR)

  1868. 				break;

  1869. 		}

  1870. 		ASSERT(m_wBankerUser != INVALID_CHAIR);

  1871. 		//wGetRandCardID[0] = m_wBankerUser;

  1872. 		//寻找对家  分2中情况  1：庄家全有 2 任意一家有

  1873. 		for (WORD UserIndex = 0; UserIndex < m_cbPlayerNum; UserIndex++)

  1874. 		{

  1875. 			BYTE TmpCardPosition[2] = { 0 };

  1876. 			if (UserIndex == m_wBankerUser)

  1877. 			{

  1878. 

  1879. 				if (m_GameLogic.FindHaveCardCount(m_cbCardData[UserIndex], m_cbCardDataCount[UserIndex], m_cbStartRandCard, TmpCardPosition) == 2)

  1880. 				{

  1881. 					break;

  1882. 				}

  1883. 				

  1884. 			}

  1885. 

  1886. 			if (m_GameLogic.FindHaveCardCount(m_cbCardData[UserIndex], m_cbCardDataCount[UserIndex], m_cbStartRandCard, TmpCardPosition) == 1)

  1887. 			{

  1888. 				//2中情况  拥有该牌的玩家 坐在庄家对边 和没做在庄家对面

  1889. 

  1890. 				if (UserIndex != m_wBankerUser&&UserIndex != (m_wBankerUser + 2) % m_cbPlayerNum)

  1891. 				{

  1892. 					//拥有一样的牌的玩家，并没有坐在庄家对面

  1893. 					m_wSourceID[0] = UserIndex;

  1894. 					m_wSourceID[1] = (m_wBankerUser + 2) % m_cbPlayerNum;

  1895. 					//对家找到了

  1896. 					bSwitchChair = true;

  1897. 				}

  1898. 				if (UserIndex != m_wBankerUser&&UserIndex == (m_wBankerUser + 2) % m_cbPlayerNum)

  1899. 				{

  1900. 					//拥有一样的牌的玩家，坐在对面了

  1901. 					//对家找到了

  1902. 				}

  1903. 			}

  1904. 

  1905. 			if (bSwitchChair == TRUE)

  1906. 			{

  1907. 				break;

  1908. 			}

  1909. 

  1910. 		}

  1911. 	}

  1912. // 	CString str;

  1913. // 	str.Format(_T("变换完毕 是否变换=%d 变换玩家的ID=%d %d CardData=0x%x"), bSwitchChair, wSourceID[0], wSourceID[1], m_cbStartRandCard);

  1914. // 	OutputDebugString(str);

  1915. }