#include "StdAfx.h" #include "GameLogic.h" #include "math.h" #include "TableFrameSink.h" #include "fstream" ////////////////////////////////////////////////////////////////////////// //静态变量 bool CChiHuRight::m_bInit = false; DWORD CChiHuRight::m_dwRightMask[MAX_RIGHT_COUNT]; //构造函数 CChiHuRight::CChiHuRight() { ZeroMemory( m_dwRight,sizeof(m_dwRight) ); if( !m_bInit ) { m_bInit = true; for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ ) { if( 0 == i ) m_dwRightMask[i] = 0; else m_dwRightMask[i] = (DWORD(pow(2.0,i-1)))<<28; } } } //赋值符重载 CChiHuRight & CChiHuRight::operator = ( DWORD dwRight ) { DWORD dwOtherRight = 0; //验证权位 if( !IsValidRight( dwRight ) ) { //验证取反权位 ASSERT( IsValidRight( ~dwRight ) ); if( !IsValidRight( ~dwRight ) ) return *this; dwRight = ~dwRight; dwOtherRight = MASK_CHI_HU_RIGHT; } for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ ) { if( (dwRight&m_dwRightMask[i]) || (i==0&&dwRight<0x10000000) ) m_dwRight[i] = dwRight&MASK_CHI_HU_RIGHT; else m_dwRight[i] = dwOtherRight; } return *this; } //与等于 CChiHuRight & CChiHuRight::operator &= ( DWORD dwRight ) { bool bNavigate = false; //验证权位 if( !IsValidRight( dwRight ) ) { //验证取反权位 ASSERT( IsValidRight( ~dwRight ) ); if( !IsValidRight( ~dwRight ) ) return *this; //调整权位 DWORD dwHeadRight = (~dwRight)&0xF0000000; DWORD dwTailRight = dwRight&MASK_CHI_HU_RIGHT; dwRight = dwHeadRight|dwTailRight; bNavigate = true; } for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ ) { if( (dwRight&m_dwRightMask[i]) || (i==0&&dwRight<0x10000000) ) { m_dwRight[i] &= (dwRight&MASK_CHI_HU_RIGHT); } else if( !bNavigate ) m_dwRight[i] = 0; } return *this; } //或等于 CChiHuRight & CChiHuRight::operator |= ( DWORD dwRight ) { //验证权位 if( !IsValidRight( dwRight ) ) return *this; for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ ) { if( (dwRight&m_dwRightMask[i]) || (i==0&&dwRight<0x10000000) ) m_dwRight[i] |= (dwRight&MASK_CHI_HU_RIGHT); } return *this; } //异或等于 CChiHuRight & CChiHuRight::operator -= (DWORD dwRight) { //验证权位 if (!IsValidRight(dwRight)) return *this; for (BYTE i = 0; i < CountArray(m_dwRightMask); i++) { if ((dwRight&m_dwRightMask[i]) || (i == 0 && dwRight < 0x10000000)) if (m_dwRight[i]&dwRight) { m_dwRight[i] ^= dwRight; } } return *this; } //与 CChiHuRight CChiHuRight::operator & ( DWORD dwRight ) { CChiHuRight chr = *this; return (chr &= dwRight); } //与 CChiHuRight CChiHuRight::operator & ( DWORD dwRight ) const { CChiHuRight chr = *this; return (chr &= dwRight); } //或 CChiHuRight CChiHuRight::operator | ( DWORD dwRight ) { CChiHuRight chr = *this; return chr |= dwRight; } //或 CChiHuRight CChiHuRight::operator | ( DWORD dwRight ) const { CChiHuRight chr = *this; return chr |= dwRight; } //是否权位为空 bool CChiHuRight::IsEmpty() { for( BYTE i = 0; i < CountArray(m_dwRight); i++ ) if( m_dwRight[i] ) return false; return true; } //设置权位为空 void CChiHuRight::SetEmpty() { ZeroMemory( m_dwRight,sizeof(m_dwRight) ); return; } //获取权位数值 BYTE CChiHuRight::GetRightData( DWORD dwRight[], BYTE cbMaxCount ) { ASSERT( cbMaxCount >= CountArray(m_dwRight) ); if( cbMaxCount < CountArray(m_dwRight) ) return 0; CopyMemory( dwRight,m_dwRight,sizeof(DWORD)*CountArray(m_dwRight) ); return CountArray(m_dwRight); } //设置权位数值 bool CChiHuRight::SetRightData( const DWORD dwRight[], BYTE cbRightCount ) { ASSERT( cbRightCount <= CountArray(m_dwRight) ); if( cbRightCount > CountArray(m_dwRight) ) return false; ZeroMemory( m_dwRight,sizeof(m_dwRight) ); CopyMemory( m_dwRight,dwRight,sizeof(DWORD)*cbRightCount ); return true; } //检查仅位是否正确 bool CChiHuRight::IsValidRight( DWORD dwRight ) { DWORD dwRightHead = dwRight & 0xF0000000; for( BYTE i = 0; i < CountArray(m_dwRightMask); i++ ) if( m_dwRightMask[i] == dwRightHead ) return true; return false; } ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// //静态变量 //麻将数据 BYTE const CGameLogic::m_cbCardDataArray_ZJ[MAX_REPERTORY_ZJ] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, //万子 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, //万子 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, //万子 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, //万子 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //索子 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //索子 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //索子 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //索子 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, //同子 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, //同子 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, //同子 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, //同子 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, //风东南西北 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, //风东南西北 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, //风东南西北 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, //风东南西北 中发白 }; BYTE const CGameLogic::m_cbCardDataArray_ZJ_Two[MAX_REPERTORY_ZJ_Two] = { 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //索子 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //索子 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //索子 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, //索子 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, //同子 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, //同子 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, //同子 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, //同子 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, //风东南西北 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, //风东南西北 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, //风东南西北 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, //风东南西北 中发白 }; ////////////////////////////////////////////////////////////////////////// //构造函数 CGameLogic::CGameLogic(CTableFrameSink* pTableFramSink) { m_cbMagicIndexFirst = MAX_INDEX; m_cbMagicIndexSecond = MAX_INDEX; m_pTableFramSink = pTableFramSink; mIsBaoMjType = 0; } //析构函数 CGameLogic::~CGameLogic() { } //混乱扑克 BYTE CGameLogic::RandCardData(BYTE cbCardData[]) { BYTE cbCardDataTemp[MAX_REPERTORY_ZJ]; BYTE cbMaxCount = 0; CopyMemory(cbCardDataTemp, m_cbCardDataArray_ZJ, sizeof(m_cbCardDataArray_ZJ)); cbMaxCount = MAX_REPERTORY_ZJ; //} //混乱扑克 BYTE cbRandCount = 0, cbPosition = 0; srand((unsigned)time(NULL)); do { cbPosition = rand() % (cbMaxCount - cbRandCount); cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition]; cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount]; } while (cbRandCount < cbMaxCount); cbRandCount = 0, cbPosition = 0; ZeroMemory(cbCardDataTemp, sizeof(cbCardDataTemp)); CopyMemory(cbCardDataTemp, cbCardData, sizeof(cbCardDataTemp)); ZeroMemory(cbCardData, sizeof(cbCardData)); srand((unsigned)time(NULL)); do { cbPosition = rand() % (cbMaxCount - cbRandCount); cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition]; cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount]; } while (cbRandCount < cbMaxCount); return cbMaxCount; } BYTE CGameLogic::RandCardData_Two(BYTE cbCardData[]) { BYTE cbCardDataTemp[MAX_REPERTORY_ZJ_Two]; BYTE cbMaxCount = 0; CopyMemory(cbCardDataTemp, m_cbCardDataArray_ZJ_Two, sizeof(m_cbCardDataArray_ZJ_Two)); cbMaxCount = MAX_REPERTORY_ZJ_Two; //} //混乱扑克 BYTE cbRandCount = 0, cbPosition = 0; srand((unsigned)time(NULL)); do { cbPosition = rand() % (cbMaxCount - cbRandCount); cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition]; cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount]; } while (cbRandCount < cbMaxCount); cbRandCount = 0, cbPosition = 0; ZeroMemory(cbCardDataTemp, sizeof(cbCardDataTemp)); CopyMemory(cbCardDataTemp, cbCardData, sizeof(cbCardDataTemp)); ZeroMemory(cbCardData, sizeof(cbCardData)); srand((unsigned)time(NULL)); do { cbPosition = rand() % (cbMaxCount - cbRandCount); cbCardData[cbRandCount++] = cbCardDataTemp[cbPosition]; cbCardDataTemp[cbPosition] = cbCardDataTemp[cbMaxCount - cbRandCount]; } while (cbRandCount < cbMaxCount); return cbMaxCount; } //删除扑克 bool CGameLogic::RemoveCard(BYTE cbCardIndex[MAX_INDEX], BYTE cbRemoveCard) { //效验扑克 ASSERT(IsValidCard(cbRemoveCard)); ASSERT(cbCardIndex[SwitchToCardIndex(cbRemoveCard)]>0); //删除扑克 BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard); if (cbCardIndex[cbRemoveIndex]>0) { cbCardIndex[cbRemoveIndex]--; return true; } //失败效验 ASSERT(FALSE); return false; } //删除扑克 bool CGameLogic::RemoveCard(BYTE cbCardIndex[MAX_INDEX], const BYTE cbRemoveCard[], BYTE cbRemoveCount) { //删除扑克 for (BYTE i=0;i0); //删除扑克 BYTE cbRemoveIndex=SwitchToCardIndex(cbRemoveCard[i]); if (cbCardIndex[cbRemoveIndex]==0) { //错误断言 ASSERT(FALSE); //还原删除 for (BYTE j=0;jCountArray(cbTempCardData)) return false; CopyMemory(cbTempCardData,cbCardData,cbCardCount*sizeof(cbCardData[0])); //置零扑克 for (BYTE i=0;i>4; return (((cbValue>=1)&&(cbValue<=9)&&(cbColor<=2))||((cbValue>=1)&&(cbValue<=7)&&(cbColor==3))); } //扑克数目 BYTE CGameLogic::GetCardCount(const BYTE cbCardIndex[MAX_INDEX]) { //数目统计 BYTE cbCardCount=0; for (BYTE i=0;i=0x31 || IsMagicCard(cbCurrentCard) ) return WIK_NULL; //吃牌判断 int cbEatKind = 0; BYTE cbCurrentIndex=SwitchToCardIndex(cbCurrentCard); //获取手牌财神牌数目 BYTE CaiShenCount = GetMaigcCardCount(cbCardIndex); if (CaiShenCount > 1) { cbEatKind = WIK_SHUANG_CAICHI; } if (CaiShenCount > 0) { BYTE TempCardIndex[MAX_INDEX] = { 0 }; CopyMemory(TempCardIndex, cbCardIndex, sizeof(TempCardIndex)); // TempCardIndex[m_cbMagicIndexFirst] = 0; // TempCardIndex[m_cbMagicIndexSecond] = 0; DeleteMagicCards(TempCardIndex); BYTE cbFirstIndex = 0; BYTE cbExcursion[3] = { 0, 1, 2 }; BYTE cbItemKind[3] = { WIK_DAN_CHI, WIK_DAN_CHI, WIK_DAN_CHI }; for (BYTE i = 0; i < CountArray(cbItemKind); i++) { BYTE cbValueIndex = cbCurrentIndex % 9; if ((cbValueIndex >= cbExcursion[i]) && ((cbValueIndex - cbExcursion[i]) <= 6)) { //吃牌判断 cbFirstIndex = cbCurrentIndex - cbExcursion[i]; if ((TempCardIndex[cbFirstIndex ] >= 1 && (cbFirstIndex != cbCurrentIndex)) ||(TempCardIndex[cbFirstIndex + 1] >= 1 && (cbFirstIndex + 1 != cbCurrentIndex)) || ((cbFirstIndex + 2 != cbCurrentIndex) && TempCardIndex[cbFirstIndex + 2] >= 1)) { cbEatKind |= cbItemKind[i]; } } } } BYTE cbExcursion[3] = { 0, 1, 2 }; BYTE cbItemKind[3] = { WIK_LEFT, WIK_CENTER, WIK_RIGHT }; //吃牌判断 BYTE cbFirstIndex = 0; BYTE szTmpIndex[MAX_INDEX] = { 0 }; CopyMemory(szTmpIndex, cbCardIndex, MAX_INDEX); DeleteMagicCards(szTmpIndex);//删除财神牌，再来判断是否吃 for (BYTE i = 0; i < CountArray(cbItemKind); i++) { BYTE cbValueIndex = cbCurrentIndex % 9; if ((cbValueIndex >= cbExcursion[i]) && ((cbValueIndex - cbExcursion[i]) <= 6)) { //吃牌判断 cbFirstIndex = cbCurrentIndex - cbExcursion[i]; if ((cbCurrentIndex != cbFirstIndex) && (szTmpIndex[cbFirstIndex] == 0)) continue; if ((cbCurrentIndex != (cbFirstIndex + 1)) && (szTmpIndex[cbFirstIndex + 1] == 0)) continue; if ((cbCurrentIndex != (cbFirstIndex + 2)) && (szTmpIndex[cbFirstIndex + 2] == 0)) continue; //设置类型 cbEatKind |= cbItemKind[i]; } } return cbEatKind; } //碰牌判断 int CGameLogic::EstimatePengCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard) { int Operator = 0; //参数效验 ASSERT(IsValidCard(cbCurrentCard)); //过滤判断 if (IsMagicCard(cbCurrentCard)) return WIK_NULL; BYTE CaiShenCount = GetMaigcCardCount(cbCardIndex); if (CaiShenCount>1) { Operator = WIK_SHUANG_PENG; } if (CaiShenCount>0) { if (cbCardIndex[SwitchToCardIndex(cbCurrentCard)]>0) { Operator |= WIK_DAN_PENG; } } Operator |= ((cbCardIndex[SwitchToCardIndex(cbCurrentCard)] >= 2) ? WIK_PENG : WIK_NULL); //碰牌判断 return Operator; } //杠牌判断 int CGameLogic::EstimateGangCard(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCurrentCard) { int Operator = WIK_NULL; //参数效验 ASSERT(IsValidCard(cbCurrentCard)); //过滤判断 if ( IsMagicCard(cbCurrentCard) ) return WIK_NULL; BYTE index = SwitchToCardIndex(cbCurrentCard); BYTE CaiShenCount = GetMaigcCardCount(cbCardIndex); if (CaiShenCount > 2) { Operator = WIK_SAN_MING_GANG; } if (CaiShenCount > 1) { if (cbCardIndex[index] > 0) Operator |= WIK_SHUANG_MING_GANG; } if (CaiShenCount > 0) { if (cbCardIndex[index] > 1) { Operator |= WIK_DAN_MING_GANG; } } Operator |= (cbCardIndex[index] == 3) ? WIK_MING_GANG : WIK_NULL; //杠牌判断 return Operator; } //杠牌分析 // 修改杠牌提供的顺序 [9/4/2017 Zoro] int CGameLogic::AnalyseGangCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, tagGangCardResult & GangCardResult) { //设置变量 int cbActionMask = WIK_NULL; BYTE TempCardIndex[MAX_INDEX]; ZeroMemory(TempCardIndex, sizeof(TempCardIndex)); ZeroMemory(&GangCardResult, sizeof(GangCardResult)); CopyMemory(TempCardIndex, cbCardIndex, sizeof(TempCardIndex)); BYTE nMagicCount = GetMaigcCardCount(cbCardIndex); //手上杠牌 for (BYTE i = 0; i < MAX_INDEX; i++) { if (IsMagicCard(SwitchToCardData(i))) { continue; } if (cbCardIndex[i] == 4) { BYTE cbCardData = SwitchToCardData(i); cbActionMask |= WIK_AN_GANG; if (GangCardResult.cbCardCount < 6){ GangCardResult.cbCardData[GangCardResult.cbCardCount++] = cbCardData; } } } if (nMagicCount > 0)//单财杠 { for (BYTE i = 0; i < MAX_INDEX; i++) { if (IsMagicCard(SwitchToCardData(i))) { continue; } if (TempCardIndex[i] >= 3) { cbActionMask |= WIK_DAN_AN_GANG; if (GangCardResult.cbCardCount < 6){ GangCardResult.cbCardData[GangCardResult.cbCardCount++] = SwitchToCardData(i) | 0x0200; } } } } // [9/4/2017 Zoro] //先计算组合正杠 //组合杠牌 for (BYTE i = 0; i < cbWeaveCount; i++) { if (WeaveItem[i].cbWeaveKind & (WIK_PENG | WIK_DAN_PENG | WIK_SHUANG_PENG)) { if (cbCardIndex[SwitchToCardIndex(WeaveItem[i].cbCenterCard)] >= 1) { cbActionMask |= WIK_BU_GANG; if (GangCardResult.cbCardCount < 6){ GangCardResult.cbCardData[GangCardResult.cbCardCount++] = WeaveItem[i].cbCenterCard | 0x0100; } } } } //在计算组合单财杠 for (BYTE i = 0; i < cbWeaveCount; i++) { if (WeaveItem[i].cbWeaveKind & (WIK_PENG | WIK_DAN_PENG | WIK_SHUANG_PENG)) { if (nMagicCount> 0) { cbActionMask |= WIK_DAN_BU_GANG; if (GangCardResult.cbCardCount<6) { GangCardResult.cbCardData[GangCardResult.cbCardCount++] = WeaveItem[i].cbCenterCard | 0x0800; } } } } if (nMagicCount > 1)//双财杠 { for (BYTE i = 0; i < MAX_INDEX; i++) { if (IsMagicCard(SwitchToCardData(i))) { continue; } if (TempCardIndex[i] >= 2) { cbActionMask |= WIK_SHUANG_AN_GANG; if (GangCardResult.cbCardCount<6) { GangCardResult.cbCardData[GangCardResult.cbCardCount++] = SwitchToCardData(i) | 0x0400; } } } } if (nMagicCount>3) { cbActionMask |= WIK_QUANG_AN_GANG; //GangCardResult.cbCardData[GangCardResult.cbCardCount++] = m_cbLaiZiData; } if (nMagicCount > 2) { cbActionMask |= WIK_SAN_AN_GANG; } if (GangCardResult.cbCardCount>6) { GangCardResult.cbCardCount = 6; } return cbActionMask; } //胡牌分析，bFlag默认false表示正常胡牌，true标示杠上花 int CGameLogic::AnalyseChiHuCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE cbCurrentCard, CChiHuRight &ChiHuRight, BYTE& nHuTai, bool bFlag, bool bQiangGangFlag) { nHuTai = 0; BYTE cbTmpCardIndex[MAX_INDEX] = { 0 }; CopyMemory(cbTmpCardIndex, cbCardIndex, MAX_INDEX); cbTmpCardIndex[SwitchToCardIndex(cbCurrentCard)]++; BYTE CaiShenCount = GetMaigcCardCount(cbTmpCardIndex); switch (CaiShenCount) { //case 0: //{ // CAnalyseItemArray AnalyseItemArray; // //设置变量 // AnalyseItemArray.RemoveAll(); // ChiHuRight.SetEmpty(); // AnalyseCard(cbTmpCardIndex, WeaveItem, cbWeaveCount, AnalyseItemArray); // if (AnalyseItemArray.GetCount() > 0) // { // mSunTaiJiangInColor = GetCardColor(AnalyseItemArray[0].cbCardEye); // nHuTai = AnalyseCardTaiNum(cbTmpCardIndex, WeaveItem, cbWeaveCount); // if (nHuTai > 0 || bFlag) // { // if (bFlag) // nHuTai++; // ChiHuRight = mChiHuRight; // return WIK_ZI_MO; // } // } // return WIK_NULL; //} //case 1: //{ // CAnalyseItemArray AnalyseItemArray; // //设置变量 // AnalyseItemArray.RemoveAll(); // ChiHuRight.SetEmpty(); // BYTE LaiZiIndex = 0; // if (cbTmpCardIndex[m_cbMagicIndex] == 0) // { // cbTmpCardIndex[m_cbCaiShenIndex]--; // LaiZiIndex = m_cbCaiShenIndex; // } // else // { // cbTmpCardIndex[m_cbMagicIndex]--; // LaiZiIndex = m_cbMagicIndex; // } // BYTE MaxTaiShu = 0; // bool bHu = false; // BYTE Fanhui[MAX_INDEX]; // IsCanChangCardAndCount(cbTmpCardIndex, Fanhui); // for (BYTE i = 0; i < MAX_INDEX;i++) // { // if (i == LaiZiIndex || Fanhui[i] == 0)continue; // cbTmpCardIndex[i]++; // AnalyseCard(cbTmpCardIndex, WeaveItem, cbWeaveCount, AnalyseItemArray); // if (AnalyseItemArray.GetCount() > 0) // { // bHu = true; // cbTmpCardIndex[i]--; // break; // } // cbTmpCardIndex[i]--; // AnalyseItemArray.RemoveAll(); // } // cbTmpCardIndex[LaiZiIndex]++; // if (bHu) // { // nHuTai = AnalyseCardTaiNum(cbTmpCardIndex, WeaveItem, cbWeaveCount); // if (bFlag || nHuTai > 0) // { // if (bFlag)nHuTai++; // ChiHuRight = mChiHuRight; // return WIK_ZI_MO; // } // } // return WIK_NULL; //} default: { if (AnalyseCardNew(cbTmpCardIndex, WeaveItem, cbWeaveCount)) { m_cbHuCard = cbCurrentCard; int TmpJiangInColor = mJiangInColor; mSunTaiJiangInColor = mJiangInColor; int nTai = AnalyseCardTaiNum(cbTmpCardIndex, WeaveItem, cbWeaveCount); //如果胡了 而且将是在风牌中，且东中发白有一个为1且没有风牌刻字 且全顺 则不能胡 //DebugLog(_T("胡了 %02x 台数=%d\r\n"), cbCurrentCard, nTai); if (nTai>0||bFlag || bQiangGangFlag) { ChiHuRight = mChiHuRight; if (bFlag) { nTai++; } if (bQiangGangFlag) { nTai++; } nHuTai = nTai; return WIK_ZI_MO; } } return WIK_NULL; } } } // bool CGameLogic::AnalyseCardNew(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount) { BYTE TmpcbCardIndex[MAX_INDEX] = { 0 }; CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX); int nCurrentMagicCount = DeleteMagicCards(TmpcbCardIndex); int nHaveGangCount = 0; for (int i = 0; i < MAX_INDEX; i++) { if (TmpcbCardIndex[i] == 4) { // TmpcbCardIndex[i] = 0; nHaveGangCount++; } } if (nCurrentMagicCount==2&& GetCardCount(TmpcbCardIndex)==0) { return true; } bool bHu = TestHu(TmpcbCardIndex, nCurrentMagicCount, WeaveItem, cbWeaveCount); if (bHu) { return true; } else { if (nHaveGangCount > 0) { CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX); int nCurrentMagicCount = DeleteMagicCards(TmpcbCardIndex); if (TestHu(TmpcbCardIndex, nCurrentMagicCount, WeaveItem, cbWeaveCount)) { return true; } for (int i = 0; i < MAX_INDEX; i++) { if (TmpcbCardIndex[i] == 4) { TmpcbCardIndex[i] = 1; } } return TestHu(TmpcbCardIndex, nCurrentMagicCount, WeaveItem, cbWeaveCount); } } return bHu; } // bool CGameLogic::TestHu(const BYTE cbCardIndex[MAX_INDEX], int nCurrentMagicCount, const tagWeaveItem WeaveItem[], BYTE cbWeaveCount) { ////////////////////////////////////////////////////////////////////////// mJiangInColor = -1; mNeedMinMagicNum = 8; BYTE cbCardDataWan[MAX_COUNT] = { 0 }; int nCount; int WanNeedMagicCount, TiaoNeedMagicCount, BingNeedMagicCount, FengNeedMagicCount;//变量分别表示‘万’型需要财神牌数、。。。 int nWanCount, nTiaoCount, nBingCount, nFengCount; //万 mMagicDataCount = 0; ZeroMemory(mMagicData, 7); ZeroMemory(mMagicReplaceCard, MAX_INDEX); mNeedMinMagicNum = 8; GetOneColorCards(cbCardIndex, Color_Wan, cbCardDataWan, nCount); nWanCount = nCount; GetOneColorNeedMagicCards(cbCardDataWan, nCount, 0); WanNeedMagicCount = mNeedMinMagicNum; ShowMagicData(); ////////////////////////////////////////////////////////////////////////// //DebugLog(_T("*********************************************\r\n")); //条 mMagicDataCount = 0; ZeroMemory(mMagicData, 7); mNeedMinMagicNum = 8; GetOneColorCards(cbCardIndex, Color_Tiao, cbCardDataWan, nCount); nTiaoCount = nCount; GetOneColorNeedMagicCards(cbCardDataWan, nCount, 0); TiaoNeedMagicCount = mNeedMinMagicNum; ShowMagicData(); //DebugLog(_T("*********************************************\r\n")); //饼 mMagicDataCount = 0; ZeroMemory(mMagicData, 7); mNeedMinMagicNum = 8; GetOneColorCards(cbCardIndex, Color_Bing, cbCardDataWan, nCount); nBingCount = nCount; GetOneColorNeedMagicCards(cbCardDataWan, nCount, 0); BingNeedMagicCount = mNeedMinMagicNum; ShowMagicData(); //DebugLog(_T("*********************************************\r\n")); //风 mMagicDataCount = 0; ZeroMemory(mMagicData, 7); mNeedMinMagicNum = 8; GetOneColorCards(cbCardIndex, Color_Feng, cbCardDataWan, nCount); nFengCount = nCount; GetOneColorNeedMagicCards(cbCardDataWan, nCount, 0); FengNeedMagicCount = mNeedMinMagicNum; ShowMagicData(); //DebugLog(_T("*********************************************\r\n")); //将在万中 ShowMagicReplaceData(); //手牌全是财神 且满足3N+2 if (GetCardCount(cbCardIndex) == 0 && nCurrentMagicCount % 3 == 2) { mJiangInColor = Color_Wan; return true; } //这个 考虑好了在加 主要用于解决2个杠的问题 // if (WanNeedMagicCount+TiaoNeedMagicCount+BingNeedMagicCount+FengNeedMagicCount== nCurrentMagicCount) // { // return true; // // } //判断是否是2杠的牌 int nNeedMagicNum = BingNeedMagicCount + TiaoNeedMagicCount + FengNeedMagicCount; if (nNeedMagicNum <= nCurrentMagicCount) { //DebugLog(_T("jiang in W Need %d Have %d"),nNeedMagicNum,nCurrentMagicCount); //剩余几个财神 供给单颜色牌手牌 int nHasMagicNum = nCurrentMagicCount - nNeedMagicNum; BYTE cbTmpCardDataWan[MAX_COUNT] = { 0 }; int nTmpCount; GetOneColorCards(cbCardIndex, Color_Wan, cbTmpCardDataWan, nTmpCount); if (nTmpCount>0) { if (OneCardsCanHu(cbTmpCardDataWan, nTmpCount, nHasMagicNum)) { mJiangInColor = Color_Wan; return true; } } } //DebugLog(_T("*********************************************\r\n")); //tiao nNeedMagicNum = WanNeedMagicCount + BingNeedMagicCount + FengNeedMagicCount; if (nNeedMagicNum <= nCurrentMagicCount) { int nHasNum = nCurrentMagicCount - nNeedMagicNum; BYTE cbTmpCardDataWan[MAX_COUNT] = { 0 }; int nTmpCount; GetOneColorCards(cbCardIndex, Color_Tiao, cbTmpCardDataWan, nTmpCount); if (nTmpCount > 0){ if (OneCardsCanHu(cbTmpCardDataWan, nTmpCount, nHasNum)) { mJiangInColor = Color_Tiao; return true; } } } //DebugLog(_T("*********************************************\r\n")); //bing nNeedMagicNum = WanNeedMagicCount + TiaoNeedMagicCount + FengNeedMagicCount; if (nNeedMagicNum <= nCurrentMagicCount) { int nHasNum = nCurrentMagicCount - nNeedMagicNum; BYTE cbTmpCardDataWan[MAX_COUNT] = { 0 }; int nTmpCount; GetOneColorCards(cbCardIndex, Color_Bing, cbTmpCardDataWan, nTmpCount); if (nTmpCount > 0){ if (OneCardsCanHu(cbTmpCardDataWan, nTmpCount, nHasNum)) { mJiangInColor = Color_Bing; return true; } } } //DebugLog(_T("*********************************************\r\n")); //feng nNeedMagicNum = WanNeedMagicCount + BingNeedMagicCount + TiaoNeedMagicCount; if (nNeedMagicNum <= nCurrentMagicCount) { int nHasNum = nCurrentMagicCount - nNeedMagicNum; BYTE cbTmpCardDataWan[MAX_COUNT] = { 0 }; int nTmpCount; GetOneColorCards(cbCardIndex, Color_Feng, cbTmpCardDataWan, nTmpCount); if (nTmpCount > 0){ if (OneCardsCanHu(cbTmpCardDataWan, nTmpCount, nHasNum)) { mJiangInColor = Color_Feng; //如果将在凤牌中 如果东风做将 //if ((cbCardIndex[27] == 1) // || (cbCardIndex[31] == 1) // || (cbCardIndex[32] == 1) // || (cbCardIndex[33] == 1) // ) //{ // /* BYTE cbTmpCardIndex[MAX_INDEX] = { 0 }; // CopyMemory(cbTmpCardIndex, cbCardIndex,MAX_INDEX); // BYTE cbCard[2] = { 0 }; // cbTmpCardIndex[m_cbCaiShenIndex] = nCurrentMagicCount; // if (IsQuanShun(cbTmpCardIndex,WeaveItem,cbWeaveCount)) // { // return false; // }*/ // //if (IsCardsIsHunYiSe(cbTmpCardIndex, WeaveItem, cbWeaveCount) || IsPengPengHu(cbTmpCardIndex,WeaveItem,cbWeaveCount)) // //{ // // return true; // //} // //else{ // // ////OutputDebugString(_T("东 中发白 做将，不是混一色 也不是碰碰胡")); // // return false; // //} //} return true; } } } //DebugLog(_T("*********************************************\r\n")); return false; } //从cbCardIndex 获取 同一花色nColor的手牌牌值cbCardData与数量CardCount bool CGameLogic::GetOneColorCards(const BYTE cbCardIndex[MAX_INDEX], BYTE nColor, BYTE cbCardData[MAX_COUNT], int&CardCount) { CardCount = 0; ZeroMemory(cbCardData, MAX_COUNT); int nBegin = 0; int nEnd = 0; if (nColor == 0) { nBegin = 0; nEnd = 9; } if (nColor == 1 || nColor == 2){ nBegin = 9 * nColor; nEnd = nBegin + 9; } if (nColor == 3) { nBegin = 9 * nColor; nEnd = nBegin + 7; } for (int i = nBegin; i < nEnd; i++) { if (cbCardIndex[i]>0) { for (int j = 0; j < cbCardIndex[i]; j++){ cbCardData[CardCount++] = SwitchToCardData(i);//记录该玩家手牌 } } } return true; } //cbCardData:手牌中希望作将的同色牌，nCardCount:手牌数量，nMagicCount:剩余可用癞子数量 bool CGameLogic::OneCardsCanHu(const BYTE cbCardData[MAX_COUNT], int nCardCount, int nMagicCount, bool isQuanShun) { if (nCardCount <= 0) { //如果没有其他牌做将，那就两个癞子做将（黄石麻将不能2癞子做将） if (nMagicCount >= 2) { return true; } return false; } BYTE cbCard = cbCardData[0]; for (int i = 0; i < nCardCount; i++) { if (i == nCardCount - 1)//如果只有一张牌 { if (nMagicCount > 0) { nMagicCount = nMagicCount - 1; mNeedMinMagicNum = 8; GetOneColorNeedMagicCards(cbCardData, nCardCount - 1, 0, isQuanShun);//该单花色牌型不需要组成整扑，只需要和一个财神牌组成将 if (mNeedMinMagicNum <= nMagicCount) { PrintCards(cbCardData, nCardCount ); return true; } nMagicCount += 1; } } else { if (i + 2 == nCardCount || cbCardData[i] != cbCardData[i + 2])//如果不止两张牌，那可能需要整扑一将（该花色牌） { //DebugLog(_T("Other Pai %d"),i); if (test2Combine(cbCardData[i], cbCardData[i + 1])) { //DebugLog(_T("i=%d card=%02x card=%02x"), i, cbCardData[i], cbCardData[i + 1]); mNeedMinMagicNum = 8; BYTE tmpCbCardDatas[MAX_COUNT] = { 0 }; int TmpCardCount = nCardCount; BYTE deleteIndex[2]; deleteIndex[0] = i; deleteIndex[1] = i + 1;//有原始的一对将 DeleteCardDataFromCardDatas(deleteIndex, 2, cbCardData, TmpCardCount, tmpCbCardDatas); TmpCardCount = TmpCardCount - 2;//删除一对将 //再获取(其他牌和财神牌)能否组成整扑 GetOneColorNeedMagicCards(tmpCbCardDatas, TmpCardCount, 0, isQuanShun); if (mNeedMinMagicNum <= nMagicCount) { //能胡牌 PrintCards(tmpCbCardDatas, TmpCardCount); return true; } } } if (nMagicCount > 0 && cbCardData[i] != cbCardData[i + 1]) { nMagicCount -= 1; BYTE tmpCbCardDatas[MAX_COUNT] = { 0 }; int TmpCardCount = nCardCount; BYTE DeleteIndex[1]; DeleteIndex[0] = i;//做将中的一个，另一个为癞子 DeleteCardDataFromCardDatas(DeleteIndex, 1, cbCardData, TmpCardCount, tmpCbCardDatas); TmpCardCount--; mNeedMinMagicNum = 8; GetOneColorNeedMagicCards(tmpCbCardDatas, TmpCardCount, 0, isQuanShun); if (mNeedMinMagicNum <= nMagicCount) { PrintCards(tmpCbCardDatas, TmpCardCount); return true; } nMagicCount += 1; } } } return false; } //在数组cbCardData中删除DeleteCount个和数组vDeletIndex元素相同的元素，结果重新组合新的数组cbOutCardDatas int CGameLogic::DeleteCardDataFromCardDatas(const BYTE vDeletIndex[MAX_COUNT], int DeleteCount, const BYTE cbCardData[MAX_COUNT], BYTE nCount, BYTE cbOutCardDatas[MAX_COUNT]) { ZeroMemory(cbOutCardDatas, MAX_COUNT); int nPaiCount = 0; BYTE tmpData[MAX_COUNT] = { 0 }; CopyMemory(tmpData, cbCardData, nCount); for (int i = 0; i < DeleteCount; i++) { tmpData[vDeletIndex[i]] = 0; } for (int i = 0; i < nCount; i++) { if (tmpData[i] != 0) { cbOutCardDatas[nPaiCount++] = tmpData[i]; } } return true; } // int CGameLogic::PrintCards(const BYTE cbCardData[MAX_COUNT], int nCout) { std::wstring StrItems; StrItems = _T("PrintCards "); for (int i = 0; i < nCout; i++) { std::wstring item; TCHAR szBuffer[MAX_COUNT] = { 0 }; switch (GetCardColor(cbCardData[i])) { case Color_Wan:{ wsprintf(szBuffer, _T("%dW"), GetCardValue(cbCardData[i])); break; } case Color_Tiao:{ wsprintf(szBuffer, _T("%dT"), GetCardValue(cbCardData[i])); break; } case Color_Bing:{ wsprintf(szBuffer, _T("%dB"), GetCardValue(cbCardData[i])); break; } case Color_Feng:{ switch (GetCardValue(cbCardData[i])) { case 1: _tcscpy_s(szBuffer, _tclen(_T("东")) + 1, _T("东")); break; case 2:_tcscpy_s(szBuffer, _tclen(_T("南")) + 1, _T("南")); break; case 3: _tcscpy_s(szBuffer, _tclen(_T("西")) + 1, _T("西")); break; case 4:_tcscpy_s(szBuffer, _tclen(_T("北")) + 1, _T("北")); break; case 5:_tcscpy_s(szBuffer, _tclen(_T("中")) + 1, _T("中")); break; case 6: _tcscpy_s(szBuffer, _tclen(_T("发")) + 1, _T("发")); break; case 7:_tcscpy_s(szBuffer, _tclen(_T("白")) + 1, _T("白")); break; } break; } } item.append(_T("\t")); item.append(szBuffer); item.append(_T("\t")); StrItems += item; } StrItems.append(_T("\r\n")); //DebugLog(StrItems.c_str()); return true; } // int CGameLogic::AnalyseCardTaiNum(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount) { mChiHuRight.SetEmpty(); //首先算是不是 辣子胡 如果是 其他的就不用算了。封顶 bool WeavieIsLaZi = true; mTaiRight = 0; int nTai=0; tagWeaveItem AnalyseWeaveItem[5]; BYTE AnalyseCbWeaveCount; CopyMemory(AnalyseWeaveItem, WeaveItem, sizeof(tagWeaveItem)*cbWeaveCount); AnalyseCbWeaveCount = cbWeaveCount; /* 检测是否有全财暗杠，有则先去掉在计算。 */ int nQuanMagicAnGangCount = 0; for (int i = 0; i < AnalyseCbWeaveCount;i++) { if (WeaveItem[i].cbWeaveKind == WIK_QUANG_AN_GANG) { nQuanMagicAnGangCount++; } } if (nQuanMagicAnGangCount>0) { int nTmpCount = 0; for (int i = 0; i < AnalyseCbWeaveCount;i++) { if (WeaveItem[i].cbWeaveKind == WIK_QUANG_AN_GANG) { continue; } CopyMemory(&AnalyseWeaveItem[nTmpCount++], &WeaveItem[i], sizeof(tagWeaveItem)); } AnalyseCbWeaveCount = nTmpCount; } //落地牌是否全是碰/顺 int luodiKind = 0; //1 顺 2 碰 3非全顺/全碰 for (int i = 0; i < AnalyseCbWeaveCount; i++) { if (((AnalyseWeaveItem[i].cbWeaveKind == WIK_DAN_PENG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_SHUANG_PENG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_PENG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_MING_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_SAN_AN_GANG)|| (AnalyseWeaveItem[i].cbWeaveKind == WIK_SHUANG_AN_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_DAN_AN_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_AN_GANG)|| (AnalyseWeaveItem[i].cbWeaveKind == WIK_SAN_MING_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_SHUANG_MING_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_DAN_MING_GANG)|| (AnalyseWeaveItem[i].cbWeaveKind == WIK_BU_GANG) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_DAN_BU_GANG) )) { //计算是否有各种加台刻字 if (AnalyseWeaveItem[i].cbCenterCard < 0x31) { WeavieIsLaZi = false; } if (AnalyseWeaveItem[i].cbCenterCard == 0x31) { //DebugLog(_T("落地派中 发现东风刻字 %02x +2台"), WeaveItem[i].cbCenterCard); mChiHuRight |= ZJ_TAI_DongFeng; mTaiRight |= ZJ_TAI_DongFeng; nTai += 2; } if ((AnalyseWeaveItem[i].cbCenterCard == 0x35)) { //DebugLog(_T("落地派中 发现中发白刻字 %02x +1台"), WeaveItem[i].cbCenterCard); mChiHuRight |= ZJ_TAI_ZFB; mTaiRight |= ZJ_TAI_ZFB; nTai += 1; } if ( AnalyseWeaveItem[i].cbCenterCard == 0x36 ) { //DebugLog(_T("落地派中 发现中发白刻字 %02x +1台"), WeaveItem[i].cbCenterCard); mChiHuRight |= ZJ_TAI_ZFB; mTaiRight |= ZJ_TAI_ZFB; nTai += 1; } if ((AnalyseWeaveItem[i].cbCenterCard == 0x37)) { //DebugLog(_T("落地派中 发现中发白刻字 %02x +1台"), WeaveItem[i].cbCenterCard); mChiHuRight |= ZJ_TAI_ZFB; mTaiRight |= ZJ_TAI_ZFB; nTai += 1; } if (luodiKind == 1) { luodiKind = 3; } if (luodiKind == 0) { luodiKind = 2; } continue; } if (( (AnalyseWeaveItem[i].cbWeaveKind == WIK_DAN_CHI) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_SHUANG_CAICHI) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_LEFT) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_CENTER) || (AnalyseWeaveItem[i].cbWeaveKind == WIK_RIGHT) )) { WeavieIsLaZi = false; if (luodiKind == 2) { luodiKind = 3; } if (luodiKind == 0) { luodiKind = 1; } continue; } } //落地牌分析完毕 ////////////////////////////////////////////////////////////////////////// //全字 分析 if (WeavieIsLaZi == true) { for (int i = 0; i < 27; i++) { if (cbCardIndex[i]>0&&!IsMagicCard(SwitchToCardData(i)))//手牌中存在不是字牌，并且该牌不是财神牌（癞子与癞子皮） { WeavieIsLaZi = false; break; } } } if (WeavieIsLaZi == true) { mChiHuRight |= ZJ_TAI_QuanZi; mTaiRight |= ZJ_TAI_QuanZi; return 7; } ////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////// //更新算法 计算手牌包含刻字情况 //财东东 123 123 11 123 BYTE cbCardIndexTmp[MAX_INDEX]; tagWeaveItem WeaveItemTmp[5]; BYTE cbWeaveCountTmp; ZeroMemory(cbCardIndexTmp, MAX_INDEX); ZeroMemory(WeaveItemTmp, sizeof(WeaveItemTmp)); cbWeaveCountTmp = 0; CopyMemory(cbCardIndexTmp, cbCardIndex, MAX_INDEX); CopyMemory(WeaveItemTmp, AnalyseWeaveItem, sizeof(tagWeaveItem)*AnalyseCbWeaveCount); cbWeaveCountTmp = AnalyseCbWeaveCount; int nFengTai=0; BOOL haveFengKe=FALSE; for (int i = 0; i < 4; i++) { if (HaveFengKe(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp, 27))//东风刻字 { nTai += 2; nFengTai += 2; mChiHuRight |= ZJ_TAI_DongFeng; mTaiRight |= ZJ_TAI_DongFeng; haveFengKe = TRUE; //DebugLog(_T("手牌中 发现[东风]刻字 +2台")); //如果 删掉东风+财神 依然可以胡牌 那么就删掉3张牌 } else { break; } } for (int i = 0; i < 4; i++) { //计算中发白 刻字个数 if (HaveFengKe(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp, 31)) { nTai++; nFengTai++; mChiHuRight |= ZJ_TAI_ZFB; mTaiRight |= ZJ_TAI_ZFB; haveFengKe = TRUE; //DebugLog(_T("手牌中 发现[中发白]有2张 可能有刻字 +1台")); } else { break; } } for (int i = 0; i < 4; i++) { //计算中发白 刻字个数 if (HaveFengKe(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp, 32)) { nTai++; nFengTai++; mChiHuRight |= ZJ_TAI_ZFB; mTaiRight |= ZJ_TAI_ZFB; haveFengKe = TRUE; //DebugLog(_T("手牌中 发现[中发白]有2张 可能有刻字 +1台")); } else { break; } } for (int i = 0; i < 4; i++) { //计算中发白 刻字个数 if (HaveFengKe(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp, 33)) { nTai++; nFengTai++; mChiHuRight |= ZJ_TAI_ZFB; mTaiRight |= ZJ_TAI_ZFB; haveFengKe = TRUE; //DebugLog(_T("手牌中 发现[中发白]有2张 可能有刻字 +1台")); } else { break; } } if (nFengTai<4) { if (IsQingYiSe(cbCardIndex, AnalyseWeaveItem, AnalyseCbWeaveCount)) { nTai += 3; mChiHuRight |= ZJ_TAI_QingYiSe; mTaiRight |= ZJ_TAI_QingYiSe; //DebugLog(_T("清一色 +3台")); } } if (!HaveMagic(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp)&&nQuanMagicAnGangCount==0) { nTai += 1; mChiHuRight |= ZJ_TAI_WuMagic; mTaiRight |= ZJ_TAI_WuMagic; //DebugLog(_T("无财神 +1台")); } //是清一色 并且清一色的花色 不是风则 不走风刻的计算 if (!(mChiHuRight&ZJ_TAI_QingYiSe).IsEmpty() && nFengTai>0&&nFengTai<4) { BYTE color = 0; //得到清一色的花色 for (int i = 0; i < MAX_INDEX;i++) { if (cbCardIndex[i]>0 && !IsMagicCard(SwitchToCardData(i))) { color = GetCardColor(SwitchToCardData(i)); break; } } if (color!=Color_Feng) { nTai -= nFengTai; mChiHuRight -= ZJ_TAI_ZFB; mChiHuRight -= ZJ_TAI_DongFeng; if (mTaiRight&ZJ_TAI_ZFB) { mTaiRight ^= ZJ_TAI_ZFB; } if (mTaiRight&ZJ_TAI_DongFeng) { mTaiRight ^= ZJ_TAI_DongFeng; } haveFengKe = FALSE; cbWeaveCountTmp = 0; CopyMemory(cbCardIndexTmp, cbCardIndex, MAX_INDEX); CopyMemory(WeaveItemTmp, AnalyseWeaveItem, sizeof(tagWeaveItem)*AnalyseCbWeaveCount); cbWeaveCountTmp = AnalyseCbWeaveCount; } } if (!(mChiHuRight&ZJ_TAI_QingYiSe).IsEmpty() && nFengTai > 3) { BYTE color = 0; //得到清一色的花色 for (int i = 0; i < MAX_INDEX; i++) { if (cbCardIndex[i]>0 && !IsMagicCard(SwitchToCardData(i))) { color = GetCardColor(SwitchToCardData(i)); break; } } if (color != Color_Feng) { nTai -= 3; mChiHuRight -= ZJ_TAI_QingYiSe; if (mTaiRight&ZJ_TAI_QingYiSe) { mTaiRight ^= ZJ_TAI_QingYiSe; } cbWeaveCountTmp = 0; CopyMemory(cbCardIndexTmp, cbCardIndex, MAX_INDEX); CopyMemory(WeaveItemTmp, AnalyseWeaveItem, sizeof(tagWeaveItem)*AnalyseCbWeaveCount); cbWeaveCountTmp = AnalyseCbWeaveCount; } } if (luodiKind != 3) { //碰碰胡 和全顺 只能算出一个来 剩下的一个不要算了。 bool bOK = false; //全碰 if (IsPengPengHu(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp)) { nTai += 1; mChiHuRight |= ZJ_TAI_PengPeng; mTaiRight |= ZJ_TAI_PengPeng; //DebugLog(_T("碰碰胡 +1台")); bOK = true; } // if (bOK == false && haveFengKe==FALSE&&nQuanMagicAnGangCount==0) { if (IsQuanShun(cbCardIndex, AnalyseWeaveItem, AnalyseCbWeaveCount)) { nTai += 1; mChiHuRight |= ZJ_TAI_QuanShun; mTaiRight |= ZJ_TAI_QuanShun; // DebugLog(_T("全顺 +1台")); } } } //if (cbCardIndexTmp[31] >= 3 || cbCardIndexTmp[32] >= 3 || cbCardIndexTmp[33] >= 3) //{ // nTai++; // mChiHuRight |= ZJ_TAI_ZFB; // mTaiRight |= ZJ_TAI_ZFB; // //DebugLog(_T("手牌中 发现[中发白]刻字 +1台")); //} if ((mChiHuRight&ZJ_TAI_QingYiSe).IsEmpty()) { BOOL HaveFengKe = FALSE; if (!(mChiHuRight&ZJ_TAI_DongFeng).IsEmpty() || !(mChiHuRight&ZJ_TAI_ZFB).IsEmpty()) { HaveFengKe = TRUE; } if (IsCardsIsHunYiSe(cbCardIndexTmp, WeaveItemTmp, cbWeaveCountTmp, HaveFengKe)) { nTai += 1; mChiHuRight |= ZJ_TAI_HunYiSe; mTaiRight |= ZJ_TAI_HunYiSe; } } if (!(mChiHuRight&ZJ_TAI_QuanShun).IsEmpty()&& mSunTaiJiangInColor ==Color_Feng) { int nMagic = DeleteMagicCards(cbCardIndexTmp); if (mSunTaiJiangInColor ==Color_Feng) { if (nMagic>0) { if (cbCardIndexTmp[27] == 1 || cbCardIndexTmp[31] == 1 || cbCardIndexTmp[32] == 1 || cbCardIndexTmp[33] == 1 ) { //OutputDebugString(_T("财神+东 中发白做将 不让胡")); if (nTai>1) { mTaiRight ^= ZJ_TAI_QuanShun; mChiHuRight -= ZJ_TAI_QuanShun; nTai--; return nTai; } mTaiRight = WIK_NULL; mChiHuRight.SetEmpty(); return 0; } if (cbCardIndexTmp[27] == 2 || cbCardIndexTmp[31] == 2 || cbCardIndexTmp[32] == 2 || cbCardIndexTmp[33] == 2 ) { ////OutputDebugString(_T(" 中发白做将 不让胡")); if (nTai > 1) { mTaiRight ^= ZJ_TAI_QuanShun; mChiHuRight -= ZJ_TAI_QuanShun; nTai--; return nTai; } mTaiRight = WIK_NULL; mChiHuRight.SetEmpty(); return 0; } } else { if (cbCardIndexTmp[27] == 2 || cbCardIndexTmp[31] == 2 || cbCardIndexTmp[32] == 2 || cbCardIndexTmp[33] == 2 ) { ////OutputDebugString(_T(" 中发白做将 不让胡")); if (nTai > 1) { mTaiRight ^= ZJ_TAI_QuanShun; mChiHuRight -= ZJ_TAI_QuanShun; nTai--; return nTai; } mTaiRight = WIK_NULL; mChiHuRight.SetEmpty(); return 0; } } } //仅有全顺时 如果东 中发白 做将 不让胡 } //如果包含全财暗杠，并且胡牌不是辣子和全顺 则在原始牌台数基础上增加2*全财神个数 if (nQuanMagicAnGangCount>0 && (mChiHuRight&ZJ_TAI_QingYiSe).IsEmpty() && (mChiHuRight&ZJ_TAI_QuanZi).IsEmpty()) { nTai += 2; nFengTai += 2; mChiHuRight |= ZJ_TAI_DongFeng; mTaiRight |= ZJ_TAI_DongFeng; } //if ((cbCardIndexTmp[27] == 1 || cbCardIndexTmp[27] ==2 && !IsMagicCard(SwitchToCardData(27))) // || (cbCardIndexTmp[31] == 1 && !IsMagicCard(SwitchToCardData(31))) // || (cbCardIndexTmp[32] == 1 && !IsMagicCard(SwitchToCardData(32))) // || (cbCardIndexTmp[33] == 1 && !IsMagicCard(SwitchToCardData(33))) // ) //{ // nTai = 0; // QueryPerformanceCounter(&nEndTime); // strAddString.Format(_T("财神+东 中发白作将 全顺不能胡 花费时间 %f 秒"), (double)(nEndTime.QuadPart - nBeginTime.QuadPart) / (double)nFreq.QuadPart); // m_ResultList.AddString(strAddString); // return; //} return nTai; } // //bool CGameLogic::isHaveMaigc(const BYTE cardMagicIndex[4]) //{ // for (int i = 0; i < 4; i++){ // if (cardMagicIndex[i]>0) // { // return false; // } // } // return false; //} // bool CGameLogic::HaveMagic(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount) { BYTE TmpcbCardIndex[MAX_INDEX] = { 0 }; CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX); int nMagicCount = DeleteMagicCards(TmpcbCardIndex); if (nMagicCount > 0) { return true; } for (int i = 0; i < cbWeaveCount; i++) { if (WeaveItem[i].cbWeaveKind&( WIK_DAN_CHI | WIK_SHUANG_CAICHI | WIK_DAN_PENG | WIK_SHUANG_PENG | WIK_DAN_MING_GANG | WIK_SHUANG_MING_GANG | WIK_SAN_MING_GANG | WIK_DAN_BU_GANG | WIK_DAN_AN_GANG | WIK_SHUANG_AN_GANG | WIK_SAN_AN_GANG | WIK_QUANG_AN_GANG )) { return true; } if (WeaveItem[i].cbWeaveKind == WIK_BU_GANG && WeaveItem[i].cbMargicOffset[0] != 0) { return true; } } return false; } // bool CGameLogic::IsPengPengHu(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount) { BYTE TmpcbCardIndex[MAX_INDEX] = { 0 }; CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX); for (int i = 0; i < cbWeaveCount; i++) { if (WeaveItem[i].cbWeaveKind & (WIK_DAN_CHI | WIK_SHUANG_CAICHI | WIK_LEFT | WIK_CENTER | WIK_RIGHT ))//单财吃、双财吃、左、中、右吃 { return false; } } int nMagic = DeleteMagicCards(TmpcbCardIndex); //计算出剩余的牌 全部变成刻字需要多少张财神 //碰碰胡 分2种 3杠一对 4刻字一对 int nNeedMagic = 0; int nGangCount=0; for (int i = 0; i < MAX_INDEX; i++) { if (TmpcbCardIndex[i] == 1 || TmpcbCardIndex[i] == 2) { nNeedMagic += (3 - TmpcbCardIndex[i]); } if (TmpcbCardIndex[i]==4) { nNeedMagic += 2; nGangCount++; } } //if (nGangCount>1) //{ // return false; //} if (nNeedMagic == nMagic + 1 || nNeedMagic ==nMagic%3 +1||(nNeedMagic==0&& nMagic%3==2)) { return true; } //计算有几个杠 如果杠需要的财神=手牌财神+2 则 是碰碰胡 nNeedMagic = 0; for (int i = 0; i < MAX_INDEX; i++) { if (TmpcbCardIndex[i] == 1 || TmpcbCardIndex[i] == 2 || TmpcbCardIndex[i] == 3) { nNeedMagic += (4 - TmpcbCardIndex[i]); } } if (nNeedMagic == nMagic + 2 || nNeedMagic == nMagic % 3 + 2 ) { return true; } return false; } // bool CGameLogic::IsQuanShun(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount) { BYTE TmpcbCardIndex[MAX_INDEX] = { 0 }; CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX); for (int i = 0; i < cbWeaveCount; i++) { if (!(WeaveItem[i].cbWeaveKind &(WIK_CENTER | WIK_DAN_CHI | WIK_SHUANG_CAICHI|WIK_RIGHT|WIK_LEFT) )) { return false; } } //如果有风牌 不可能是全顺 //将手牌 遍历一次 把能够组成顺子 且 剩下的还能胡的牌 扔到组合里面。如果最后 剩下2张一样的牌 就判定是全顺 int nMagicCount = DeleteMagicCards(TmpcbCardIndex); int nFengCardCount=0; BYTE nFengCard[MAX_INDEX] = { 0 }; for (int i = 0; i < 7; i++) { if (TmpcbCardIndex[27 + i] >= 3) { return false; } if (TmpcbCardIndex[27 + i] >= 1) { nFengCard[nFengCardCount] = 27 + i; nFengCardCount++; } } if (nFengCardCount>=2) { return false; } BYTE cbUserIndexCardTmp[MAX_INDEX] = { 0 }; CopyMemory(cbUserIndexCardTmp, TmpcbCardIndex, MAX_INDEX); ////////////////////////////////////////////////////////////////////////// { BYTE cbJiangIndex[MAX_INDEX] = { 0 }; for (int i = 0; i < MAX_INDEX; i++) { if (cbUserIndexCardTmp[i] == 0) { continue; } if (cbUserIndexCardTmp[i] >= 2) { cbJiangIndex[i] = 1; } } for (int i = 0; i < MAX_INDEX; i++) { BYTE cbTmpCardIndex[MAX_INDEX] = { 0 }; CopyMemory(cbTmpCardIndex, cbUserIndexCardTmp, MAX_INDEX); if (cbJiangIndex[i] == 0) { continue; } if (cbJiangIndex[i] == 1) { cbTmpCardIndex[i] -= 2; //计算剩余的牌 全顺需要财神个数 int nNeedMagicCount = 0; BYTE cbColorCards[4][MAX_INDEX] = { 0 }; int cbColorCardCount[MAX_COUNT] = { 0 }; for (int iColor = 0; iColor < 4; iColor++) { mNeedMinMagicNum = 8; GetOneColorCards(cbTmpCardIndex, iColor, cbColorCards[iColor], cbColorCardCount[iColor]); int nNeedMagic = 0; GetOneColorNeedMagicCards(cbColorCards[iColor], cbColorCardCount[iColor], 0, true); nNeedMagic = mNeedMinMagicNum; nNeedMagicCount += nNeedMagic; //CString str; //str.Format(_T("花色 %d 需要财神个数 %d 才能组成全顺"), iColor, nNeedMagic); } if (nNeedMagicCount == nMagicCount) { if (nFengCardCount==1) { if (nFengCard[0]!=i) { continue; } } /* CString str; str.Format(_T("全顺 %02x 做将"), SwitchToCardData(i));*/ ////OutputDebugString(str); return true; } } } } ////////////////////////////////////////////////////////////////////////// //正将没有找到 尝试找找财将 { if (nMagicCount >= 1) { BYTE cbJiangIndex[MAX_INDEX] = { 0 }; for (int i = 0; i < MAX_INDEX; i++) { if (cbUserIndexCardTmp[i] == 0) { continue; } if (cbUserIndexCardTmp[i] >= 1) { cbJiangIndex[i] = 1; } } for (int i = 0; i < MAX_INDEX; i++) { BYTE cbTmpCardIndex[MAX_INDEX] = { 0 }; CopyMemory(cbTmpCardIndex, cbUserIndexCardTmp, MAX_INDEX); if (cbJiangIndex[i] == 0) { continue; } if (cbJiangIndex[i] == 1) { cbTmpCardIndex[i] -= 1; int nTmpMagicCount=nMagicCount-1; //计算剩余的牌 全顺需要财神个数 int nNeedMagicCount = 0; BYTE cbColorCards[4][MAX_INDEX] = { 0 }; int cbColorCardCount[MAX_COUNT] = { 0 }; for (int iColor = 0; iColor < 4; iColor++) { mNeedMinMagicNum = 8; GetOneColorCards(cbTmpCardIndex, iColor, cbColorCards[iColor], cbColorCardCount[iColor]); int nNeedMagic = 0; GetOneColorNeedMagicCards(cbColorCards[iColor], cbColorCardCount[iColor], 0, true); nNeedMagic = mNeedMinMagicNum; nNeedMagicCount += nNeedMagic; CString str; str.Format(_T("花色 %d 需要财神个数 %d 才能组成全顺"), iColor, nNeedMagic); } if (nNeedMagicCount == nTmpMagicCount||nNeedMagicCount==nTmpMagicCount%3) { if (nFengCardCount == 1) { if (nFengCard[0] != i) { continue; } } CString str; str.Format(_T("全顺 %02x 财神 做将"), SwitchToCardData(i)); return true; } } } } } ////////////////////////////////////////////////////////////////////////// //双财将 { //财将 也没有 那就试试 财财将 if (nMagicCount >= 2) { BYTE cbTmpCardIndex[MAX_INDEX] = { 0 }; CopyMemory(cbTmpCardIndex, cbUserIndexCardTmp, MAX_INDEX); nMagicCount -= 2; //计算剩余的牌 全顺需要财神个数 int nNeedMagicCount = 0; BYTE cbColorCards[4][MAX_INDEX] = { 0 }; int cbColorCardCount[MAX_COUNT] = { 0 }; for (int iColor = 0; iColor < 4; iColor++) { mNeedMinMagicNum = 8; GetOneColorCards(cbTmpCardIndex, iColor, cbColorCards[iColor], cbColorCardCount[iColor]); int nNeedMagic = 0; //nNeedMagicCount = nNeedMagicCount + cbColorCardCount[iColor] * 3 - cbColorCardCount[iColor]; //nNeedMagic = cbColorCardCount[iColor] * 3 - cbColorCardCount[iColor]; GetOneColorNeedMagicCards(cbColorCards[iColor], cbColorCardCount[iColor], 0, true); nNeedMagic = mNeedMinMagicNum; nNeedMagicCount += nNeedMagic; /* CString str; str.Format(_T("花色 %d 需要财神个数 %d 才能组成全顺"), iColor, nNeedMagic);*/ } if (nNeedMagicCount == nMagicCount||nNeedMagicCount==nMagicCount%3) { /* CString str; str.Format(_T("全顺 财神 财神 做将"));*/ return true; } } } ////////////////////////////////////////////////////////////////////////// return false; } // bool CGameLogic::IsCardsIsHunYiSe(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BOOL HaveFengKe) { BYTE TmpcbCardIndex[MAX_INDEX] = { 0 }; CopyMemory(TmpcbCardIndex, cbCardIndex, MAX_INDEX); ////////////////////////////////////////////////////////////////////////// //无风牌 不是混一色 int cbFengCount = 0; int cbItemColor = -1; bool bHasFeng2 = false; for (int i = 0; i < cbWeaveCount; i++) { BYTE cbColor = GetCardColor(WeaveItem[i].cbCenterCard); if (cbColor == Color_Feng) { bHasFeng2 = true; cbFengCount++; continue; } if (cbItemColor == -1) { cbItemColor = cbColor; } if (cbItemColor != cbColor) { return false; } } ////////////////////////////////////////////////////////////////////////// //删除风 删除财神 判断是否是一色 int nCurrentMagicCount = DeleteMagicCards(TmpcbCardIndex); //如果没有 东南西北中发白 不可能是混一色 for (int i = 1; i < 8; i++) { if (TmpcbCardIndex[26 + i] != 0 ) { bHasFeng2 = true; break; } else { continue; } } if (!bHasFeng2&&!cbFengCount&&!HaveFengKe) { return false; } if (cbItemColor != -1) { for (BYTE i = 0; i < 27; i++){ if (TmpcbCardIndex[i] != 0) { if (GetCardColor(SwitchToCardData(i)) != cbItemColor) { return false; } } } } else { BYTE cbFirst = 0; //遍历前 27张0-26 //得到第一张颜色 如果后面的颜色与第一个不一样，返回false for (BYTE i = 0; i < 27; i++){ if (TmpcbCardIndex[i] != 0) { if (cbFirst == 0) { cbFirst = SwitchToCardData(i); continue; } if (GetCardColor(cbFirst) != GetCardColor(SwitchToCardData(i))) { return false; } } } } return true; } //听牌分析, bool CGameLogic::AnalyseTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, BYTE *m_cbTingPaiData, const BYTE FanHui[MAX_INDEX], BYTE wChairID, BYTE wBaoUserID, BYTE BaoTai) { //复制数据 BYTE cbCardIndexTemp[MAX_INDEX]; CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp)); //BYTE FanHui[MAX_INDEX] = { 0 }; //IsCanChangCardAndCount(cbCardIndexTemp, FanHui); BYTE cbCardCount = GetCardCount(cbCardIndexTemp); if (cbCardCount > 1 && (cbCardCount - 1) % 3 != 0) { ASSERT(false); return false; } CChiHuRight chr; BYTE TaiShu = 0; bool isHu = false; for (BYTE i = 0; i < MAX_INDEX; i++) { if (FanHui[i]==0 && !IsMagicCard(SwitchToCardData(i))) { continue; } BYTE CardTempData = SwitchToCardData(i); if (WIK_ZI_MO & AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, CardTempData, chr, TaiShu)) { if (mIsBaoMjType==0) { //翻财神 m_cbTingPaiData[i] = TaiShu; isHu = true; } else{ //包麻将 if (wChairID == wBaoUserID) { if (TaiShu < BaoTai) { m_cbTingPaiData[i] = 0; } else { m_cbTingPaiData[i] = TaiShu; isHu = true; } } else { m_cbTingPaiData[i] = TaiShu; isHu = true; } } } else { m_cbTingPaiData[i] = 0; } } return isHu; } //是否听牌 //bool CGameLogic::IsTingCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, const BYTE FanHui[MAX_INDEX]) //{ // //复制数据 // BYTE cbCardIndexTemp[MAX_INDEX]; // CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp)); // //BYTE FanHui[MAX_INDEX] = { 0 }; // //IsCanChangCardAndCount(cbCardIndexTemp, FanHui); // for (BYTE i = 0; i < MAX_INDEX; i++) // { // if (FanHui[i] == 0)continue; // BYTE cbTempCardData = SwitchToCardData(i); // CChiHuRight chr; // BYTE TaiShu = 0; // if (WIK_ZI_MO & AnalyseChiHuCard(cbCardIndexTemp, WeaveItem, cbWeaveCount, cbTempCardData,chr,TaiShu)) // return true; // } // return false; //} //扑克转换 BYTE CGameLogic::SwitchToCardData(BYTE cbCardIndex) { //ASSERT(cbCardIndex<34); return ((cbCardIndex/9)<<4)|(cbCardIndex%9+1); } //扑克转换 BYTE CGameLogic::SwitchToCardIndex(BYTE cbCardData) { ASSERT(IsValidCard(cbCardData)); return ((cbCardData&MASK_COLOR)>>4)*9+(cbCardData&MASK_VALUE)-1; } //扑克转换 BYTE CGameLogic::SwitchToCardData(const BYTE cbCardIndex[MAX_INDEX], BYTE cbCardData[MAX_COUNT]) { //转换扑克 BYTE cbPosition=0; for (BYTE i=0;i0 bool CGameLogic::AnalyseCard(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray & AnalyseItemArray) { //计算数目 BYTE cbCardCount = GetCardCount(cbCardIndex); //效验数目 if ((cbCardCount<2) || (cbCardCount>MAX_COUNT) || ((cbCardCount - 2) % 3 != 0)) return false; //变量定义 BYTE cbKindItemCount = 0;//组合个数 tagKindItem KindItem[27 * 2 + 7 + 14]; ZeroMemory(KindItem, sizeof(KindItem)); //需求判断 BYTE cbLessKindItem = (cbCardCount - 2) / 3;//表示手牌需要几个组合才能胡牌 ASSERT((cbLessKindItem + cbWeaveCount) == 4); //单吊判断 if (cbLessKindItem == 0) { //牌眼判断 for (BYTE i = 0; i < MAX_INDEX; i++) { if (cbCardIndex[i] == 2) { //变量定义 tagAnalyseItem AnalyseItem; ZeroMemory(&AnalyseItem, sizeof(AnalyseItem)); //设置结果 for (BYTE j = 0; j < cbWeaveCount; j++) { AnalyseItem.cbWeaveKind[j] = WeaveItem[j].cbWeaveKind; AnalyseItem.cbCenterCard[j] = WeaveItem[j].cbCenterCard; GetWeaveCard(WeaveItem[j].cbWeaveKind, WeaveItem[j].cbCenterCard, WeaveItem[j].cbMargicOffset, AnalyseItem.cbCardData[j]); } AnalyseItem.cbCardEye = SwitchToCardData(i); AnalyseItem.bMagicEye = false; //插入结果 AnalyseItemArray.Add(AnalyseItem); return true; } } return false; } //拆分分析，用户手上的临时牌变量 BYTE cbMagicCardIndex[MAX_INDEX]; CopyMemory(cbMagicCardIndex, cbCardIndex, sizeof(cbMagicCardIndex)); if (cbCardCount >= 3) { for (BYTE i = 0; i < MAX_INDEX; i++) { //同牌判断 if (cbMagicCardIndex[i] >= 3) { ASSERT(cbKindItemCount < CountArray(KindItem)); KindItem[cbKindItemCount].cbCardIndex[0] = i; KindItem[cbKindItemCount].cbCardIndex[1] = i; KindItem[cbKindItemCount].cbCardIndex[2] = i; KindItem[cbKindItemCount].cbWeaveKind = WIK_PENG; KindItem[cbKindItemCount].cbCenterCard = SwitchToCardData(i); KindItem[cbKindItemCount].cbValidIndex[0] = i; KindItem[cbKindItemCount].cbValidIndex[1] = i; KindItem[cbKindItemCount].cbValidIndex[2] = i; cbKindItemCount++; } //连牌判断 if ((i < (MAX_INDEX - 9)) && ((i % 9) < 7)) { //只要财神牌数加上3个顺序索引的牌数大于等于3,则进行组合 if (cbMagicCardIndex[i] + cbMagicCardIndex[i + 1] + cbMagicCardIndex[i + 2] >= 3) { BYTE cbIndex[3] = { cbMagicCardIndex[i], cbMagicCardIndex[i + 1], cbMagicCardIndex[i + 2] }; int nMagicCountTemp = 0; BYTE cbValidIndex[3]; while (cbIndex[0] + cbIndex[1] + cbIndex[2] >= 3) { for (BYTE j = 0; j < CountArray(cbIndex); j++) { if (cbIndex[j] > 0) { cbIndex[j]--; cbValidIndex[j] = i + j; } else { nMagicCountTemp--; } } if (nMagicCountTemp == 0) { ASSERT(cbKindItemCount < CountArray(KindItem)); KindItem[cbKindItemCount].cbCardIndex[0] = i; KindItem[cbKindItemCount].cbCardIndex[1] = i + 1; KindItem[cbKindItemCount].cbCardIndex[2] = i + 2; KindItem[cbKindItemCount].cbWeaveKind = WIK_LEFT; KindItem[cbKindItemCount].cbCenterCard = SwitchToCardData(i); CopyMemory(KindItem[cbKindItemCount].cbValidIndex, cbValidIndex, sizeof(cbValidIndex)); cbKindItemCount++; } else break; } } } } } //组合分析 if (cbKindItemCount >= cbLessKindItem) { //变量定义 BYTE cbCardIndexTemp[MAX_INDEX]; ZeroMemory(cbCardIndexTemp, sizeof(cbCardIndexTemp)); //变量定义 BYTE cbIndex[4] = { 0, 1, 2, 3 }; tagKindItem * pKindItem[4]; ZeroMemory(&pKindItem, sizeof(pKindItem)); //开始组合 do { //设置变量 CopyMemory(cbCardIndexTemp, cbCardIndex, sizeof(cbCardIndexTemp)); for (BYTE i = 0; i < cbLessKindItem; i++) pKindItem[i] = &KindItem[cbIndex[i]]; //数量判断 bool bEnoughCard = true; for (BYTE i = 0; i < cbLessKindItem * 3; i++) { //存在判断 BYTE cbCardIndex = pKindItem[i / 3]->cbValidIndex[i % 3]; if (cbCardIndexTemp[cbCardIndex] == 0) { bEnoughCard = false; break; } else cbCardIndexTemp[cbCardIndex]--; } //胡牌判断 if (bEnoughCard == true) { //牌眼判断 BYTE cbCardEye = 0; bool bMagicEye = false; for (BYTE i = 0; i < MAX_INDEX; i++) { if (cbCardIndexTemp[i] == 2) { cbCardEye = SwitchToCardData(i); break; } } //组合类型 if (cbCardEye != 0) { //变量定义 tagAnalyseItem AnalyseItem; ZeroMemory(&AnalyseItem, sizeof(AnalyseItem)); //设置组合 for (BYTE i = 0; i < cbWeaveCount; i++) { AnalyseItem.cbWeaveKind[i] = WeaveItem[i].cbWeaveKind; AnalyseItem.cbCenterCard[i] = WeaveItem[i].cbCenterCard; GetWeaveCard(WeaveItem[i].cbWeaveKind, WeaveItem[i].cbCenterCard, WeaveItem[i].cbMargicOffset, AnalyseItem.cbCardData[i]); } //设置牌型 for (BYTE i = 0; i < cbLessKindItem; i++) { AnalyseItem.cbWeaveKind[i + cbWeaveCount] = pKindItem[i]->cbWeaveKind; AnalyseItem.cbCenterCard[i + cbWeaveCount] = pKindItem[i]->cbCenterCard; AnalyseItem.cbCardData[cbWeaveCount + i][0] = SwitchToCardData(pKindItem[i]->cbValidIndex[0]); AnalyseItem.cbCardData[cbWeaveCount + i][1] = SwitchToCardData(pKindItem[i]->cbValidIndex[1]); AnalyseItem.cbCardData[cbWeaveCount + i][2] = SwitchToCardData(pKindItem[i]->cbValidIndex[2]); } //设置牌眼 AnalyseItem.cbCardEye = cbCardEye; AnalyseItem.bMagicEye = bMagicEye; //插入结果 AnalyseItemArray.Add(AnalyseItem); } } //设置索引 if (cbIndex[cbLessKindItem - 1] == (cbKindItemCount - 1)) { BYTE i = cbLessKindItem - 1; for (; i > 0; i--) { if ((cbIndex[i - 1] + 1) != cbIndex[i]) { BYTE cbNewIndex = cbIndex[i - 1]; for (BYTE j = (i - 1); j < cbLessKindItem; j++) cbIndex[j] = cbNewIndex + j - i + 2; break; } } if (i == 0) break; } else cbIndex[cbLessKindItem - 1]++; } while (true); } return (AnalyseItemArray.GetCount() > 0); } //删除癞子牌 BYTE CGameLogic::DeleteMagicCards(BYTE cbCardIndex[MAX_INDEX]) { if (m_BaoMj_MagicType==MagicType_NoMagic) { return 0; } if (m_BaoMj_MagicType==MagicType_OneMagic) { BYTE cbCount = cbCardIndex[m_cbMagicIndexFirst]; cbCardIndex[m_cbMagicIndexFirst] = 0; return cbCount; } if (m_BaoMj_MagicType==MagicType_TwoMagic) { BYTE cbCardData[2] = { 0 }; BYTE cbCount = cbCardIndex[m_cbMagicIndexFirst] + cbCardIndex[m_cbMagicIndexSecond]; cbCardIndex[m_cbMagicIndexFirst] = 0; cbCardIndex[m_cbMagicIndexSecond] = 0; return cbCount; } return 0; } BYTE CGameLogic::DeleteMagicCards(BYTE cbCardIndex[MAX_INDEX], int nDeleteCount) { int HaveMagicCount = GetMaigcCardCount(cbCardIndex); if (nDeleteCount>HaveMagicCount || HaveMagicCount>8) { CString strInfo; strInfo.Format(_T("DeleteMagicCards Have Magic=%d Delete=%d"), HaveMagicCount, nDeleteCount); //OutputDebugString(strInfo); return 0; } if (m_BaoMj_MagicType==MagicType_NoMagic) { return 0; } if (m_BaoMj_MagicType == MagicType_OneMagic) { if ((cbCardIndex[m_cbMagicIndexFirst] - nDeleteCount)>4 || (cbCardIndex[m_cbMagicIndexFirst] - nDeleteCount )<0) { return 0; } cbCardIndex[m_cbMagicIndexFirst] = cbCardIndex[m_cbMagicIndexFirst] - nDeleteCount; return nDeleteCount; } if (m_BaoMj_MagicType==MagicType_TwoMagic) { BYTE nConut = 0; int nFirstMagicCount = cbCardIndex[m_cbMagicIndexFirst]; int nSecondMagicCount = cbCardIndex[m_cbMagicIndexSecond]; if (nDeleteCount > (nFirstMagicCount + nSecondMagicCount)) { return 0; } for (int i = 0; i < nDeleteCount; i++) { if (cbCardIndex[m_cbMagicIndexFirst] > 0) { cbCardIndex[m_cbMagicIndexFirst]--; nConut++; } else if (cbCardIndex[m_cbMagicIndexSecond] > 0) { cbCardIndex[m_cbMagicIndexSecond]--; nConut++; } } return nConut; } return 0; } //获取牌值需要财神牌个数nNeedNum，组成扑（扑指的是顺子或者三重牌（比如 一饼二饼三饼 或者东风东风东风）） int CGameLogic::GetOneColorNeedMagicCards(const BYTE cbCardData[MAX_COUNT], int DataCount, int nNeedNum, bool isShun) { //CString strTmpPrint; //strTmpPrint = _T("GetOneColorNeedMagicCards 分析 "); //{ // for (int i = 0; i < DataCount; i++) // { // CString tmp; // tmp.Format(_T(" %02x"), cbCardData[i]); // strTmpPrint.Append(tmp); // } // strTmpPrint.Append(_T("\r\n")); // //OutputDebugString(strTmpPrint); //} if (mNeedMinMagicNum == 0) { return -1; } if (nNeedNum >= mNeedMinMagicNum) { return -1; } switch (DataCount) { case 0:{//cbCardData内没有同一花色的牌不需要财神牌变 mNeedMinMagicNum = min(nNeedNum, mNeedMinMagicNum);//0 break; } case 1:{ mNeedMinMagicNum = min(nNeedNum + 2, mNeedMinMagicNum); CString strTmp; strTmp.Format(_T("财神充当碰牌 需要2财神 %02X\r\n "), cbCardData[0]); ////OutputDebugString(strTmp); //mMagicData[mMagicDataCount++] = cbCardData[0]; break; } case 2:{ BYTE cbFirst = cbCardData[0]; BYTE cbSecend = cbCardData[1]; //花色是3 为 东南西北中发白 不可能出现顺子 if (GetCardColor(cbSecend) == 3) { if (cbFirst == cbSecend&&!isShun) { //DebugLog(_T("GetOneColorNeedMagicCards 风牌只有刻字 %02x %02x %02x\r\n"),cbFirst,cbSecend,cbFirst); mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 1); ////OutputDebugString(_T("财神是风牌的碰\r\n")); mMagicData[mMagicDataCount++] = cbFirst; } else { mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 4); } } else if (cbSecend - cbFirst < 3)//判断相差两个顺序牌需要财神mMagicData变能“碰”、“吃”（左、中、右） { //DebugLog(_T("GetOneColorNeedMagicCards 顺子/刻字 %02x %02x magic\r\n"), cbFirst, cbSecend); if (cbSecend-cbFirst==0) { CString strTmp; strTmp.Format(_T("财神充当碰牌 %02X\r\n "), cbFirst); ////OutputDebugString(strTmp); mMagicData[mMagicDataCount++] = cbFirst; } else if (cbSecend-cbFirst==1) { if (GetCardValue(cbFirst)==1) { CString strTmp; strTmp.Format(_T("财神充当 右吃 %02X\r\n "), cbSecend + 1); ////OutputDebugString(strTmp); mMagicData[mMagicDataCount++] = cbSecend+1; } else { CString strTmp; strTmp.Format(_T("财神充当 左吃 %02X\r\n "), cbFirst - 1); ////OutputDebugString(strTmp); mMagicData[mMagicDataCount++] = cbFirst - 1; } } else if (cbSecend-cbFirst==2) { CString strTmp; strTmp.Format(_T("财神充当 中吃 %02X\r\n "), cbFirst+1); ////OutputDebugString(strTmp); mMagicData[mMagicDataCount++] = cbFirst+1; } if (isShun&&cbSecend - cbFirst == 0) { mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 4); } else { mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 1); } } else { if (isShun) { mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 4); } else{ mNeedMinMagicNum = min(mNeedMinMagicNum, nNeedNum + 4); } } break; } default: { //取前三张 BYTE cbFirst = cbCardData[0]; BYTE cbSecend = cbCardData[1]; BYTE cbThree = cbCardData[2]; //第一个自己一扑 if (nNeedNum + 2 < mNeedMinMagicNum) { GetOneColorNeedMagicCards(cbCardData + 1, DataCount - 1, nNeedNum + 2, isShun);//从cbCardData一个一个元素开始，所以DataCount - 1，需要两个财神才能成（扑） } //第一个跟其它的一个一扑 if (nNeedNum + 1 < mNeedMinMagicNum){ if (GetCardColor(cbFirst) == 3){//东南西北中发白牌型 if (cbFirst == cbSecend) { GetOneColorNeedMagicCards(cbCardData + 2, DataCount - 2, nNeedNum + 1, isShun);//如果是刻字（两两相等），则需要+1财神牌变，才能碰（即成扑） } } else { for (int i = 1; i < DataCount; i++) { if (nNeedNum + 1 >= mNeedMinMagicNum)//财神数最多7个，还有一个是第一次摸牌显示在台桌上无效 { break; } cbSecend = cbCardData[i]; if (i + 1 != DataCount){ cbThree = cbCardData[i + 1]; if (cbThree == cbSecend){ continue; } } if (GetCardValue(cbSecend) - GetCardValue(cbFirst) < 3) { //删除 此时的 p1 p2 /*BYTE *pTmpData = new BYTE[DataCount]; ZeroMemory(pTmpData, DataCount); int nCount = 0; for (int j = 0; j < DataCount; j++) { if (j == i || j == 0) { continue; } pTmpData[nCount++] = cbCardData[j]; }*/ if (isShun&&GetCardValue(cbSecend) - GetCardValue(cbFirst)==0) { BYTE delCards[2] = { 0 }; delCards[0] = cbFirst; delCards[1] = cbSecend; BYTE outCards[14] = { 0 }; DeleteCards(cbCardData, 14, delCards, 2, outCards); GetOneColorNeedMagicCards(outCards, DataCount - 2, nNeedNum + 4, isShun); } else { BYTE delCards[2] = { 0 }; delCards[0] = cbFirst; delCards[1] = cbSecend; BYTE outCards[14] = { 0 }; DeleteCards(cbCardData, 14, delCards, 2, outCards); GetOneColorNeedMagicCards(outCards, DataCount - 2, nNeedNum + 1, isShun); } } else { break; } } } } //第一个和其它两个一扑 //后面间隔两张张不跟前面一张相同222234 //可能性为222 234 for (int i = 1; i < DataCount; i++){ if (nNeedNum >= mNeedMinMagicNum){ break; } cbSecend = cbCardData[i]; if (i + 2 < DataCount) { if (cbCardData[i + 2] == cbSecend) { continue; } } for (unsigned int j = i + 1; j < DataCount; j++) { if (nNeedNum >= mNeedMinMagicNum) { break; } cbThree = cbCardData[j]; if (cbFirst == cbThree) { //不处理 } if (j + 1 < DataCount) { if (cbThree == cbCardData[j + 1]) { continue; } } if (isShun) { if (test3combineToShun(cbFirst, cbSecend, cbThree)) { //删除 1 2 3 BYTE delCards[3] = { 0 }; delCards[0] = cbFirst; delCards[1] = cbSecend; delCards[2] = cbThree; BYTE outCards[14] = { 0 }; DeleteCards(cbCardData, 14, delCards, 3, outCards); CString strDeletecards; CString strout = _T("删除 "); for (int i = 0; i < 3; i++) { strDeletecards.Format(_T("%02x "), delCards[i]); strout += strDeletecards; } ////OutputDebugString(strout); GetOneColorNeedMagicCards(outCards, DataCount - 3, nNeedNum, isShun); } } else { if (test3Combine(cbFirst, cbSecend, cbThree)) { //删除 1 2 3 BYTE delCards[3] = { 0 }; delCards[0] = cbFirst; delCards[1] = cbSecend; delCards[2] = cbThree; BYTE outCards[14] = { 0 }; DeleteCards(cbCardData, 14, delCards, 3, outCards); CString strDeletecards; CString strout = _T("删除 "); for (int i = 0; i < 3; i++) { strDeletecards.Format(_T("%02x "), delCards[i]); strout += strDeletecards; } ////OutputDebugString(strout); GetOneColorNeedMagicCards(outCards, DataCount - 3, nNeedNum, isShun); } } } } } break; } } //钻牌 bool CGameLogic::IsMagicCard( BYTE cbCardData ) { if (m_BaoMj_MagicType==MagicType_NoMagic) { return false; } if (m_BaoMj_MagicType==MagicType_OneMagic) { if (SwitchToCardIndex(cbCardData)==m_cbMagicIndexFirst) { return true; } } if (m_BaoMj_MagicType==MagicType_TwoMagic) { if (SwitchToCardIndex(cbCardData) == m_cbMagicIndexFirst || SwitchToCardIndex(cbCardData) == m_cbMagicIndexSecond) return true; } return false; } //test3 bool CGameLogic::test3Combine(const BYTE cbCard1, const BYTE cbCard2, const BYTE cbCard3) { //花色不同 不能组合 if (GetCardColor(cbCard1) != GetCardColor(cbCard2) || GetCardColor(cbCard1) != GetCardColor(cbCard3)) { return false; } //刻字 if (cbCard1 == cbCard2&& cbCard2 == cbCard3) { // DebugLog(_T("test3Combine 刻字 %02x %02x %02x\r\n"), cbCard1, cbCard2, cbCard3); return true; } //风牌不能组成顺子 if (GetCardColor(cbCard3) == 3) { return false; } if (cbCard1 + 1 == cbCard2&& cbCard2 + 1 == cbCard3) { // DebugLog(_T("test3Combine 顺子 %02x %02x %02x\r\n"), cbCard1, cbCard2, cbCard3); return true; } return false; } bool CGameLogic::test3combineToShun(const BYTE cbCard1, const BYTE cbCard2, const BYTE cbCard3) { //花色不同 不能组合 if (GetCardColor(cbCard1) != GetCardColor(cbCard2) || GetCardColor(cbCard1) != GetCardColor(cbCard3)) { return false; } //风牌不能组成顺子 if (GetCardColor(cbCard3) == 3) { return false; } if (cbCard1 + 1 == cbCard2&& cbCard2 + 1 == cbCard3) { // DebugLog(_T("test3Combine 顺子 %02x %02x %02x\r\n"), cbCard1, cbCard2, cbCard3); return true; } return false; } //test2 bool CGameLogic::test2Combine(const BYTE cbCard1, const BYTE cbCard2) { if (cbCard1 == cbCard2) { // DebugLog(_T("test3Combine peng %02x %02x \r\n"), cbCard1, cbCard2); return true; } return false; } //排序,根据牌值排序 bool CGameLogic::SortCardList( BYTE cbCardData[MAX_COUNT], BYTE cbCardCount ) { //数目过虑 if (cbCardCount==0||cbCardCount>MAX_COUNT) return false; //排序操作 bool bSorted=true; BYTE cbSwitchData=0,cbLast=cbCardCount-1; do { bSorted=true; for (BYTE i=0;icbCardData[i+1]) { //设置标志 bSorted=false; //扑克数据 cbSwitchData=cbCardData[i]; cbCardData[i]=cbCardData[i+1]; cbCardData[i+1]=cbSwitchData; } } cbLast--; } while(bSorted==false); return true; } //编码 //WORD占两个字节， //num占高三位，剩下给倍数 //uFangShu 7位 //PaiZhi 占用低六位， WORD CGameLogic::GetValue(BYTE uNum, BYTE uFangShu, WORD PaiZhi) { WORD mcd = PaiZhi | (uFangShu << 6) | (uNum << 13); return mcd; } //解码 BYTE CGameLogic::DeCodeCard(const WORD cbCardData) { BYTE TempCardData = cbCardData & 0x003F; return TempCardData; } //解码番薯 BYTE CGameLogic::DeCodeFanshu(const WORD cbCardData) { //BYTE num = (cbCardData & 0x3800) >> 11; BYTE fanshu = (cbCardData & 0x07C0) >> 6; //BYTE TempCardData = cbCardData & 0x003F; return fanshu; } bool CGameLogic::PeiPai(BYTE ParZhi[MAX_REPERTORY_ZJ]) { std::ifstream in; std::string filename = "zuopai.dat"; in.open(filename); if (!in.is_open()) { return false; } static BYTE TempCardData[MAX_REPERTORY_ZJ]; ZeroMemory(TempCardData, sizeof(TempCardData)); BYTE tempCount = 0; char ch[1]; while (!in.eof()) { in.read(ch, 1); TempCardData[tempCount++] = ch[0]; } in.close(); if (tempCount= 0; i--) { if (cbCardIndex[i] > 0 && !IsMagicCard(SwitchToCardData(i))) { return SwitchToCardData(i); } } if (m_BaoMj_MagicType==MagicType_OneMagic) { return SwitchToCardData(m_cbMagicIndexFirst); } if (m_BaoMj_MagicType==MagicType_TwoMagic) { if (m_cbMagicIndexFirst > m_cbMagicIndexSecond) { return SwitchToCardData(m_cbMagicIndexFirst); } return SwitchToCardData(m_cbMagicIndexSecond); } } /* // 胡法分析函数 */ //大对子 bool CGameLogic::IsPengPeng(const BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], const BYTE cbItemCount) { for (BYTE i = 0; i < cbItemCount; i++) { if (WeaveItem[i].cbWeaveKind&(WIK_LEFT | WIK_RIGHT | WIK_CENTER)) return false; } BYTE cbCardCount = GetCardCount(cbCardIndex); BYTE DanCount = 0; BYTE DuiZiCount = 0; for (BYTE i = 0; i0 ) { return false; } } if (cbItemColor != -1) { for (BYTE i = 0; i < 27; i++){ if (TmpcbCardIndex[i] != 0) { if (GetCardColor(SwitchToCardData(i)) != cbItemColor) { return false; } } } } else { BYTE cbFirst = 0; //遍历前 27张0-26 //得到第一张颜色 如果后面的颜色与第一个不一样，返回false for (BYTE i = 0; i < 27; i++){ if (TmpcbCardIndex[i] != 0) { if (cbFirst == 0) { cbFirst = SwitchToCardData(i); continue; } if (GetCardColor(cbFirst) != GetCardColor(SwitchToCardData(i))) { return false; } } } } return true; } //门前清 bool CGameLogic::IsMenQianQing(const tagWeaveItem WeaveItem[], const BYTE cbWeaveCount) { for (int i = 0; i < cbWeaveCount; i++) { if (WeaveItem[i].cbWeaveKind & (WIK_LEFT|WIK_RIGHT|WIK_CENTER|WIK_PENG|WIK_MING_GANG|WIK_BU_GANG)) { return false; } } return true; } bool CGameLogic::HaveFengKe(BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE& cbItemCount,int nCardIndex) { if (cbCardIndex[nCardIndex] + GetMaigcCardCount(cbCardIndex)<3) { return false; } //手牌已经有3个或以上 东风，则不需要计算了，有 BYTE cbCardTmpIndex[MAX_INDEX]; ZeroMemory(cbCardTmpIndex, MAX_INDEX); CopyMemory(cbCardTmpIndex, cbCardIndex, MAX_INDEX); if (cbCardTmpIndex[nCardIndex] >= 3 && !IsMagicCard(SwitchToCardData(nCardIndex))){ //手牌减去3个东风 cbCardTmpIndex[nCardIndex] -= 3; WeaveItem[cbItemCount].cbCenterCard = SwitchToCardData(nCardIndex); WeaveItem[cbItemCount].cbWeaveKind = WIK_PENG; CopyMemory(cbCardIndex, cbCardTmpIndex, MAX_INDEX); cbItemCount = cbItemCount + 1; return true; } int nCountGang=0; BYTE cbIndex[4] = { 0 }; for (int i = 0; i < MAX_INDEX;i++) { if (cbCardTmpIndex[i]==0) { continue; } if (cbCardTmpIndex[i]==4&&!IsMagicCard(SwitchToCardData(i))) { cbIndex[nCountGang++]=i; } } if (nCountGang>=2) { BYTE cbCardTmp2Index[MAX_INDEX]; ZeroMemory(cbCardTmp2Index, MAX_INDEX); CopyMemory(cbCardTmp2Index, cbCardTmpIndex, MAX_INDEX); int nMagicTmpCount = DeleteMagicCards(cbCardTmp2Index); for (int i = 0; i < nCountGang; i++) { cbCardTmp2Index[cbIndex[i]] = 1; } if (nMagicTmpCount>3) { nMagicTmpCount -= 3; } if (!TestHu(cbCardTmp2Index, nMagicTmpCount, WeaveItem, cbItemCount)) { return false; } } //如果手牌有 1/2 东风，怎计算一下 拿财神配合一下 剩下的牌胡不胡 // if (cbCardIndex[nCardIndex]>0) // { int nMagic = GetMaigcCardCount(cbCardIndex); if (cbCardIndex[nCardIndex] !=0&& IsMagicCard(SwitchToCardData(nCardIndex)))// { if (nMagic<3) { return false; } //减去三个财神 判断能不能胡 if (DeleteMagicCards(cbCardTmpIndex, 3) != 3){ return false; } { tagWeaveItem TmpWeaveItem[7]; ZeroMemory(TmpWeaveItem, sizeof(TmpWeaveItem)); CopyMemory(TmpWeaveItem, WeaveItem, sizeof(tagWeaveItem)*cbItemCount); int cbItemCountTmp = cbItemCount; TmpWeaveItem[cbItemCountTmp].cbCenterCard = SwitchToCardData(nCardIndex); TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SHUANG_PENG; if (AnalyseCardNew(cbCardTmpIndex, TmpWeaveItem, cbItemCountTmp)) { cbItemCount = cbItemCountTmp + 1; CopyMemory(cbCardIndex, cbCardTmpIndex, MAX_INDEX); CopyMemory(WeaveItem, TmpWeaveItem, sizeof(tagWeaveItem)*cbItemCount); return true; } } ////////////////////////////////////////////////////////////////////////////// //减去4个财神 判断能不能胡 ZeroMemory(cbCardTmpIndex, MAX_INDEX); CopyMemory(cbCardTmpIndex, cbCardIndex, MAX_INDEX); if (GetMaigcCardCount(cbCardIndex)>=4) { if (DeleteMagicCards(cbCardTmpIndex, 4) != 4){ return false; } { tagWeaveItem TmpWeaveItem[7]; ZeroMemory(TmpWeaveItem, sizeof(TmpWeaveItem)); CopyMemory(TmpWeaveItem, WeaveItem, sizeof(tagWeaveItem)*cbItemCount); int cbItemCountTmp = cbItemCount; TmpWeaveItem[cbItemCountTmp].cbCenterCard = SwitchToCardData(nCardIndex); TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SAN_MING_GANG; if (AnalyseCardNew(cbCardTmpIndex, TmpWeaveItem, cbItemCountTmp)) { cbItemCount = cbItemCountTmp + 1; CopyMemory(cbCardIndex, cbCardTmpIndex, MAX_INDEX); CopyMemory(WeaveItem, TmpWeaveItem, sizeof(tagWeaveItem)*cbItemCount); return true; } } } } else { if (nMagic + cbCardIndex[nCardIndex] < 3) { return false; } } //组成3张刻字 int nDeleteMagic = 0; if (cbCardIndex[nCardIndex]<4) { nDeleteMagic = 3 - cbCardIndex[nCardIndex]; cbCardTmpIndex[nCardIndex] = 0; if (DeleteMagicCards(cbCardTmpIndex, nDeleteMagic) == nDeleteMagic) { tagWeaveItem TmpWeaveItem[7]; ZeroMemory(TmpWeaveItem, sizeof(TmpWeaveItem)); CopyMemory(TmpWeaveItem, WeaveItem, sizeof(tagWeaveItem)*cbItemCount); int cbItemCountTmp = cbItemCount; TmpWeaveItem[cbItemCountTmp].cbCenterCard = SwitchToCardData(nCardIndex); if (nDeleteMagic == 1) { TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_DAN_PENG; } else if (nDeleteMagic == 2) { TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SHUANG_PENG; } else { TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SHUANG_PENG; } if (AnalyseCardNew(cbCardTmpIndex, TmpWeaveItem, cbItemCountTmp)) { cbItemCount = cbItemCountTmp + 1; CopyMemory(cbCardIndex, cbCardTmpIndex, MAX_INDEX); CopyMemory(WeaveItem, TmpWeaveItem, sizeof(tagWeaveItem)*cbItemCount); return true; } } } //组成4张杠 { ZeroMemory(cbCardTmpIndex, MAX_INDEX); CopyMemory(cbCardTmpIndex, cbCardIndex, MAX_INDEX); if (nMagic + cbCardIndex[nCardIndex]<4) { return false; } int nDeleteMagic = 4 - cbCardIndex[nCardIndex]; cbCardTmpIndex[nCardIndex] = 0; if (DeleteMagicCards(cbCardTmpIndex, nDeleteMagic) == nDeleteMagic) { tagWeaveItem TmpWeaveItem[7]; CopyMemory(TmpWeaveItem, WeaveItem, sizeof(WeaveItem)); int cbItemCountTmp = cbItemCount; TmpWeaveItem[cbItemCountTmp].cbCenterCard = SwitchToCardData(nCardIndex); if (nDeleteMagic == 1) { TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_DAN_MING_GANG; } else if (nDeleteMagic == 2) { TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SHUANG_PENG; } else{ TmpWeaveItem[cbItemCountTmp].cbWeaveKind = WIK_SAN_MING_GANG; } if (AnalyseCardNew(cbCardTmpIndex, TmpWeaveItem, cbItemCountTmp)) { CopyMemory(cbCardIndex, cbCardTmpIndex, MAX_INDEX); CopyMemory(WeaveItem, TmpWeaveItem, sizeof(TmpWeaveItem)); cbItemCount = cbItemCountTmp+1; return true; } } } // } return false; } //获取癞子个数 BYTE CGameLogic::GetMaigcCardCount(const BYTE cbCardIndex[MAX_INDEX]) { if (m_BaoMj_MagicType==MagicType_NoMagic) { return 0; } if (m_BaoMj_MagicType==MagicType_OneMagic) { return cbCardIndex[m_cbMagicIndexFirst]; } if (m_BaoMj_MagicType==MagicType_TwoMagic) { return cbCardIndex[m_cbMagicIndexFirst] + cbCardIndex[m_cbMagicIndexSecond]; } return 0; } //对财神牌可变牌判断 void CGameLogic::IsCanChangCardAndCount(const BYTE cbCardIndex[MAX_INDEX], BYTE Fanhui[MAX_INDEX]) { //目的 减少后续的计算里量 //遍历手牌，将包含的牌 附近的2张牌 设置为1，因为只有相关的牌才可能产生影响，不产生影响的牌 不必要计算 //如果手牌没有万字 则可以在后续计算时 排除万字计算 ZeroMemory(Fanhui, MAX_INDEX); for (int UserCardIndex = 0; UserCardIndex < MAX_INDEX; UserCardIndex++) { if (UserCardIndex>31||UserCardIndex==27) { Fanhui[UserCardIndex] = 1; continue; } if (cbCardIndex[UserCardIndex] != 0) { if (UserCardIndex < 27) { if ((UserCardIndex % 9) > 2 && (UserCardIndex % 9) < 7) { //如果有 3-7 的手牌 则把前后2张牌 都设置为 有用的牌，留下来计算 for (int j = UserCardIndex - 2; j <= UserCardIndex + 2; j++) { Fanhui[j] = 1; } } else if ((UserCardIndex % 9) <= 2) { //如水果是1-2 则把后两张设置为可用 BYTE GaoWei = UserCardIndex / 9; for (int j = 9 * GaoWei; j <= UserCardIndex + 2; j++) { Fanhui[j] = 1; } } else { //如水果是8-9 则把前两张设置为可用 for (int j = UserCardIndex - 2; j < (1 + UserCardIndex / 9) * 9; j++) { Fanhui[j] = 1; } } } else { //风牌都设置为1 Fanhui[UserCardIndex] = 1; } } } } void CGameLogic::ShowMagicData() { if (mMagicDataCount==0) { return; } CString strData; strData = _T("财神充当以下牌 "); for (int i = 0; i < mMagicDataCount;i++) { mMagicReplaceCard[SwitchToCardIndex(mMagicData[i])] = 1; CString strTmpData; strTmpData.Format(_T(" %02x "), mMagicData[i]); strData.Append(strTmpData); } strData.Append(_T("\r\n")); ////OutputDebugString(strData); } void CGameLogic::ShowMagicReplaceData() { CString strData; strData = _T("ShowMagicReplaceData 财神充当以下牌 ----------\r\n"); for (int n = 0; n < MAX_INDEX;n++) { if (mMagicReplaceCard[n]>0) { CString strTmpData; strTmpData.Format(_T(" %02x "), SwitchToCardData(n)); strData.Append(strTmpData); } } strData.Append(_T("\r\n")); ////OutputDebugString(strData); } //删掉pSrc数组中有和pDeleteCards中的nDelCount个元素相等的元素，再将删了元素的数组pSrc，重新按序放入一个新的数组中Cards void CGameLogic::DeleteCards(const BYTE* pSrc, int nCount, const BYTE* pDeleteCards, int nDelCount, BYTE Cards[14]) { BYTE * pTmpSrc = new BYTE[nCount]; ZeroMemory(pTmpSrc, nCount); CopyMemory(pTmpSrc, pSrc, nCount); for (int i = 0; i < nDelCount; i++) { for (int nSrc = 0; nSrc < nCount; nSrc++) { if (pDeleteCards[i]== pTmpSrc[nSrc]) { pTmpSrc[nSrc] = 0; break; } } } int nCountOut = 0; ZeroMemory(Cards, 14); for (int i = 0; i < nCount; i++) { if (pTmpSrc[i]!=0) { Cards[nCountOut++] = pTmpSrc[i]; } } delete pTmpSrc; pTmpSrc = NULL; } BOOL CGameLogic::IsCanHuAllCards(BYTE cbCardIndex[MAX_INDEX], const tagWeaveItem WeaveItem[], BYTE cbWeaveCount) { for (int i = 0; i < MAX_INDEX; i++) { if (cbCardIndex[i]==4) { continue; } cbCardIndex[i]++; if (!AnalyseCardNew(cbCardIndex, WeaveItem,cbWeaveCount)) { cbCardIndex[i]--; return FALSE; } //CChiHuRight cht; //BYTE cbData; //if (AnalyseChiHuCard(cbCardIndex,WeaveItem,cbWeaveCount,SwitchToCardData(i),cht,cbData)==WIK_NULL) //{ // return FALSE; //} cbCardIndex[i]--; } return TRUE; } //////////////////////////////////////////////////////////////////////////