servermanage.cpp

添七,棋牌游戏源代码,功能齐全,稳定,适合用于棋牌游戏开发

//是否拖拉机逻辑
BOOL CUpGradeGameLogic::IsTrackorRule(BYTE iFirstCard, BYTE iNextCard)
{
	int iCardBulk=GetCardBulk(iFirstCard,FALSE);//得到扑克大小
	//如果主占了当中的位置
	if(GetNTCardNum()!=0 && (iCardBulk==GetNTCardNum()-1 || iCardBulk==GetNTCardNum()+1) && 
		(GetCardBulk(iNextCard,FALSE)==GetNTCardNum()-1 || GetCardBulk(iNextCard,FALSE)==GetNTCardNum()+1))
	{
		return true;	
	}
	//如果是主牌拖拉机（如打J，是副JJAA也属于拖拉机）
	int m1,m2;
	m1=iFirstCard&0xf0;	m2=iNextCard&0xf0;
	if(	GetNTHuaKind()==m1 || GetNTHuaKind()==m2)
	{
		if(	(iCardBulk==15 && GetCardBulk(iNextCard,FALSE)==14) ||
			(iCardBulk==14 && GetCardBulk(iNextCard,FALSE)==15))
		{
			return true;
		}
	}
	if ((iFirstCard>iNextCard && GetCardBulk(iNextCard,FALSE)!=(iCardBulk-1)) ||
		(iFirstCard<iNextCard && GetCardBulk(iNextCard,FALSE)!=(iCardBulk+1))) 
	{
		return FALSE;
	}
	return TRUE;
}

//是否拖拉机（两条）
BOOL CUpGradeGameLogic::IsDoubleTrackor(BYTE iCardList[], int iCardCount)
{
	if ((iCardCount<4)||((iCardCount%2)!=0)) return FALSE;

	BYTE iCard=iCardList[0];
	if (!IsDouble(iCardList,2)) return FALSE;
	for (int i=2;i<iCardCount;i+=2)
	{
		if (!IsDouble(&iCardList[i],2)||!IsTrackorRule(iCard,iCardList[i])) return FALSE;
		iCard=iCardList[i];
	}
	return TRUE;
}

//是否拖拉机（三条）
BOOL CUpGradeGameLogic::IsThreeTrackor(BYTE iCardList[], int iCardCount)
{
	if ((iCardCount<6)||((iCardCount%3)!=0)) return FALSE;

	BYTE iCard=iCardList[0];
	if (!IsThree(iCardList,3)) return FALSE;
	for (int i=3;i<iCardCount;i+=3)
	{
		if (!IsThree(&iCardList[i],3)||!IsTrackorRule(iCard,iCardList[i])) return FALSE;
		iCard=iCardList[i];
	}
	return TRUE;
}

//是否甩牌
BOOL CUpGradeGameLogic::IsShowCard(BYTE iCardList[], int iCardCount)
{
	return (GetCardListHua(iCardList,iCardCount)!=UG_ERROR_HUA);
}

//得到牌列花色
BYTE CUpGradeGameLogic::GetCardListHua(BYTE iCardList[], int iCardCount)
{
	int iHuaKind=GetCardHuaKind(iCardList[0],FALSE);
	if (GetCardHuaKind(iCardList[iCardCount-1],FALSE)!=iHuaKind) return UG_ERROR_HUA;
	return iHuaKind;
}

//获取牌型
BYTE CUpGradeGameLogic::GetCardShape(BYTE iCardList[], int iCardCount)
{
	if (GetCardListHua(iCardList,iCardCount)!=UG_ERROR_HUA)
	{
		if (IsOnlyOne(iCardList,iCardCount)) return UG_ONLY_ONE;
		if (IsDouble(iCardList,iCardCount)) return UG_DOUBLE;
		if (IsThree(iCardList,iCardCount)) return UG_THREE;
		if (IsDoubleTrackor(iCardList,iCardCount)) return UG_DOUBLE_TRACKOR;
		if (IsThreeTrackor(iCardList,iCardCount)) return UG_THREE_TARCKOR;
		if (IsShowCard(iCardList,iCardCount)) return UG_SHOW_CARD;
	}
	return UG_ERROR_KIND;
}

//对比单牌
BOOL CUpGradeGameLogic::CompareOnlyOne(BYTE iFirstCard, BYTE iNextCard)
{
	int iFristHua=GetCardHuaKind(iFirstCard,FALSE);
	int iNextHua=GetCardHuaKind(iNextCard,FALSE);
	if (iFristHua!=iNextHua)
	{
		//不同花色对比
		if (iFristHua==UG_NT_CARD) return TRUE;
		return (iNextHua!=UG_NT_CARD);
	}
	
	//同花色对比
	return GetCardBulk(iFirstCard,FALSE)>=GetCardBulk(iNextCard,FALSE);
}

//自动出牌函数
BOOL CUpGradeGameLogic::AutoOutCard(BYTE iHandCard[], int iHandCardCount, BYTE iBaseCard[], int iBaseCardCount,
									BYTE iResultCard[], int & iResultCardCount, BOOL bFirstOut)
{
	if (bFirstOut==FALSE)	//跟随出牌者
	{
		int iSameHuaCount=0,iTempCount=0;
		BYTE iSameHuaCard[39],iTempCard[54];
		BYTE iBaseHuaKind=GetCardHuaKind(iBaseCard[0],FALSE);
		BYTE iBaseCardKind=GetCardShape(iBaseCard,iBaseCardCount);

		//提取扑克
		iSameHuaCount=TackOutCardByHua(iHandCard,iHandCardCount,iBaseHuaKind,iSameHuaCard,FALSE);

		if (iSameHuaCount<=iBaseCardCount)	//没有了同色扑克
		{
			int iCardPos=iHandCardCount-1;
			iResultCardCount=iSameHuaCount;
			::CopyMemory(iResultCard,iSameHuaCard,sizeof(BYTE)*iSameHuaCount);
			while (iResultCardCount<iBaseCardCount)
			{
				if (GetCardHuaKind(iHandCard[iCardPos],FALSE)!=iBaseHuaKind)
					iResultCard[iResultCardCount++]=iHandCard[iCardPos];
				iCardPos--;
			}
			return TRUE;
		}
		else	//分析扑克
		{
			iResultCardCount=0;
			int iStationPos=0,iTakeCount=0;
			CardAnalyseStruct AnalyseBase;
			AnalyseCard(iBaseCard,iBaseCardCount,AnalyseBase);

			//三条拖拉机分析
			if (AnalyseBase.iThreeTractorCount>0)
			{
				//提出三条拖拉机
				iTakeCount=0,iStationPos=0;
				iTempCount=TackOutThreeTrackor(iSameHuaCard,iSameHuaCount,iTempCard,TRUE);
				iSameHuaCount-=iTempCount;
				while ((iTakeCount<iTempCount)&&(iTakeCount<iBaseCardCount))
				{
					::CopyMemory(&iResultCard[iResultCardCount],&iTempCard[iStationPos+2],sizeof(BYTE)*iTempCard[iStationPos+1]);
					iResultCardCount+=iTempCard[iStationPos+1];
					iTakeCount+=iTempCard[iStationPos+1];
					iStationPos+=iTempCard[iStationPos+1]+2;
				}
				iResultCardCount=__min(iBaseCardCount,iResultCardCount+iTakeCount);
				if (iResultCardCount==iBaseCardCount) return TRUE;
				if (AnalyseBase.iThreeTractorCount>iTempCount)
				{	
					AnalyseBase.iThreeCount+=(AnalyseBase.iThreeTractorCount-iTempCount);
					AnalyseBase.iThreeTractorCount=iTempCount;
				}
			}

			//三条分析
			if (AnalyseBase.iThreeCount>0)
			{
				//提出三条
				iTakeCount=0,iStationPos=0;
				iTempCount=TackOutThree(iSameHuaCard,iSameHuaCount,iTempCard,TRUE);
				iSameHuaCount-=iTempCount;
				::CopyMemory(&iResultCard[iResultCardCount],iTempCard,sizeof(BYTE)*iTempCount);
				iResultCardCount=__min(iBaseCardCount,iResultCardCount+iTempCount);
				if (iResultCardCount==iBaseCardCount) return TRUE;
				if (AnalyseBase.iThreeCount>iTempCount)
				{	
					AnalyseBase.iDoubleCount+=(AnalyseBase.iThreeCount-iTempCount)/3*2;
					AnalyseBase.iSignedCount+=(AnalyseBase.iThreeCount-iTempCount)/3;
					AnalyseBase.iThreeTractorCount=iTempCount;
				}
			}

			//两条拖拉机分析
			if (AnalyseBase.iDoubleTractorCount>0)
			{
				//提出两条拖拉机
				iTakeCount=0,iStationPos=0;
				iTempCount=TackOutDoubleTrackor(iSameHuaCard,iSameHuaCount,iTempCard,TRUE);
				iSameHuaCount-=iTempCount;
				while ((iTakeCount<iTempCount)&&(iTakeCount<iBaseCardCount))
				{
					::CopyMemory(&iResultCard[iResultCardCount],&iTempCard[iStationPos+2],sizeof(BYTE)*iTempCard[iStationPos+1]);
					iResultCardCount+=iTempCard[iStationPos+1];
					iTakeCount+=iTempCard[iStationPos+1];
					iStationPos+=iTempCard[iStationPos+1]+2;
				}
				iResultCardCount=__min(iBaseCardCount,iResultCardCount+iTakeCount);
				if (iResultCardCount==iBaseCardCount) return TRUE;
				if (AnalyseBase.iDoubleTractorCount>iTempCount)
				{	
					AnalyseBase.iDoubleCount+=(AnalyseBase.iDoubleTractorCount-iTempCount);
					AnalyseBase.iDoubleTractorCount=iTempCount;
				}
			}

			//对牌分析
			if (AnalyseBase.iDoubleCount>0)
			{
				//提出对牌
				iTakeCount=0,iStationPos=0;
				iTempCount=TackOutDouble(iSameHuaCard,iSameHuaCount,iTempCard,TRUE);
				iSameHuaCount-=iTempCount;
				::CopyMemory(&iResultCard[iResultCardCount],iTempCard,sizeof(BYTE)*iTempCount);
				iResultCardCount=__min(iBaseCardCount,iResultCardCount+iTempCount);
				if (iResultCardCount==iBaseCardCount) return TRUE;
				if (AnalyseBase.iDoubleCount>iTempCount)
				{	
					AnalyseBase.iSignedCount+=AnalyseBase.iDoubleCount-iTempCount;
					AnalyseBase.iDoubleCount=iTempCount;
				}
			}

			//提出单牌
			::CopyMemory(&iResultCard[iResultCardCount],&iSameHuaCard[iSameHuaCount+iResultCardCount-iBaseCardCount],
						 sizeof(BYTE)*(iBaseCardCount-iResultCardCount));
			iResultCardCount=iBaseCardCount;

			return TRUE;
		}
	}
	else //第一个出牌者
	{
		iResultCardCount=1;
		iResultCard[0]=iHandCard[iHandCardCount-1];
	}

	return TRUE;
}

//是否可以甩牌
BOOL CUpGradeGameLogic::CanShowCard(BYTE iOutCard[], int iOutCardCount, int iOutStation, 
									BYTE * iCardArray[], int iCardArrayCount, 
									BYTE iResultCard[], int & iResultCardCount)
{
	CardAnalyseStruct AnalyseOut;
	BYTE iTempCard[54],iSameHuaCard[39];
	int iTempCount=0,iOtherSameCount=0;

	AnalyseCard(iOutCard,iOutCardCount,AnalyseOut);
	for (int i=0;i<4;i++)
	{
		if (iOutStation==i) continue;

		//提取扑克
		iOtherSameCount=TackOutCardByHua(iCardArray[i],iCardArrayCount,AnalyseOut.iCardHuaKind,iSameHuaCard,FALSE);

		//分析三条拖拉机
		if (AnalyseOut.iThreeTractorCount!=0)
		{
			int iOutStation=0,iOtherStation=0,iCompOutCount=0,iCompOtherCount=0;
			iTempCount=TackOutThreeTrackor(iSameHuaCard,iOtherSameCount,iTempCard,FALSE);
			if (iTempCount!=0)
			{
				do
				{
					iOtherStation=0;
					iCompOtherCount=0;
					while (iCompOtherCount<iTempCount)
					{
						if ((AnalyseOut.iThreeTractorArray[iOutStation+1]<=iTempCard[iOtherStation+1])
							&&(CompareOnlyOne(AnalyseOut.iThreeTractorArray[iOutStation+2],iTempCard[0])==FALSE))
						{
							//甩牌失败
							iResultCardCount=AnalyseOut.iThreeTractorArray[iOutStation+1];
							::CopyMemory(iResultCard,&AnalyseOut.iThreeTractorArray[iOutStation+2],sizeof(BYTE)*iResultCardCount);
							return FALSE;
						}
						iCompOtherCount+=iTempCard[iOtherStation+1];
						iOtherStation+=iTempCard[iOtherStation+1]+2;
					}
					iCompOutCount+=AnalyseOut.iThreeTractorArray[iOutStation+1];
					iOutStation+=AnalyseOut.iThreeTractorArray[iOutStation+1]+2;
				} while (iCompOutCount<AnalyseOut.iThreeTractorCount);
			}
		}

		//分析两条拖拉机
		if (AnalyseOut.iDoubleTractorCount!=0)
		{
			int iOutStation=0,iOtherStation=0,iCompOutCount=0,iCompOtherCount=0;
			iTempCount=TackOutDoubleTrackor(iSameHuaCard,iOtherSameCount,iTempCard,FALSE);
			if (iTempCount!=0)
			{
				do
				{
					iOtherStation=0;
					iCompOtherCount=0;
					while (iCompOtherCount<iTempCount)
					{
						if ((AnalyseOut.iDoubleTractorArray[iOutStation+2]<=iTempCard[iOtherStation+2])
							&&(CompareOnlyOne(AnalyseOut.iDoubleTractorArray[iOutStation+2],iTempCard[2])==FALSE))
						{
							//甩牌失败
							iResultCardCount=AnalyseOut.iDoubleTractorArray[iOutStation+1];
							::CopyMemory(iResultCard,&AnalyseOut.iDoubleTractorArray[iOutStation+2],sizeof(BYTE)*iResultCardCount);
							return FALSE;
						}
						iCompOtherCount+=iTempCard[iOtherStation+1];
						iOtherStation+=iTempCard[iOtherStation+1]+2;
					}
					iCompOutCount+=AnalyseOut.iDoubleTractorArray[iOutStation+1];
					iOutStation+=AnalyseOut.iDoubleTractorArray[iOutStation+1]+2;
				} while (iCompOutCount<AnalyseOut.iDoubleTractorCount);
			}
		}
		
		//分析三条
		if (AnalyseOut.iThreeCount!=0)
		{
			iTempCount=TackOutThree(iSameHuaCard,iOtherSameCount,iTempCard,FALSE);
			if ((iTempCount!=0)&&(CompareOnlyOne(AnalyseOut.iThreeArray[AnalyseOut.iThreeCount-3],iTempCard[0])==FALSE))
			{
				//甩牌失败
				iResultCardCount=3;
				::CopyMemory(iResultCard,&AnalyseOut.iThreeArray[AnalyseOut.iThreeCount-3],sizeof(BYTE)*iResultCardCount);
				return FALSE;
			}
		}

		//分析对牌
		if (AnalyseOut.iDoubleCount!=0)
		{
			iTempCount=TackOutDouble(iSameHuaCard,iOtherSameCount,iTempCard,FALSE);
			if ((iTempCount!=0)&&(CompareOnlyOne(AnalyseOut.iDoubleArray[AnalyseOut.iDoubleCount-2],iTempCard[0])==FALSE))
			{
				//甩牌失败
				iResultCardCount=2;
				::CopyMemory(iResultCard,&AnalyseOut.iDoubleArray[AnalyseOut.iDoubleCount-2],sizeof(BYTE)*iResultCardCount);
				return FALSE;
			}
		}

		//分析单牌
		if ((AnalyseOut.iSignedCount!=0)&&(iOtherSameCount>0)&&
			(CompareOnlyOne(AnalyseOut.iLessSignedCard,iSameHuaCard[0])==FALSE))
		{
			//甩牌失败
			iResultCardCount=1;
			iResultCard[0]=AnalyseOut.iLessSignedCard;
			return FALSE;
		}
	}

	//甩牌成功
	iResultCardCount=iOutCardCount;
	::CopyMemory(iResultCard,iOutCard,sizeof(BYTE)*iResultCardCount);

	return TRUE;
}

//对比函数
int CUpGradeGameLogic::CompareCard(BYTE * iCardListArray[], int iCardCount)
{
	//排列扑克
	for (int i=0;i<4;i++) SortCard(iCardListArray[i],NULL,iCardCount);
	
	//对比处理
	int iWinner=0;
	int iCardShape=GetCardShape(iCardListArray[0],iCardCount);
	switch (iCardShape)
	{
		case UG_ONLY_ONE:
		case UG_DOUBLE:
		case UG_THREE: 
		case UG_DOUBLE_TRACKOR:
		case UG_THREE_TARCKOR:
			{
				for (int i=1;i<4;i++)
				{
					if ((GetCardShape(iCardListArray[i],iCardCount)==iCardShape)&&
					   (CompareOnlyOne(iCardListArray[iWinner][0],iCardListArray[i][0])==FALSE))
						iWinner=i;
				}
				return iWinner;
			}
		case UG_SHOW_CARD: return CompareShowCard(iCardListArray,iCardCount);
	}

	return -1;
}

//对比甩牌
int CUpGradeGameLogic::CompareShowCard(BYTE * iCardListArray[], int iCardCount)
{
	CardAnalyseStruct AnalyseResul[4];

	//分析扑克
	AnalyseCard(iCardListArray[0],iCardCount,AnalyseResul[0]);
	if (AnalyseResul[0].iCardHuaKind==UG_NT_CARD) return 0;

	///////////
	//如果是用主杀，别人追杀，就不是按这样的方式比较了，而是比最大的一类牌
	///////////

	//开始对比
	int iWiner=0;
	for (int i=1;i<4;i++)
	{
		if (GetCardListHua(iCardListArray[i],iCardCount)!=UG_NT_CARD) continue;
		if (FixCardType(iCardListArray[i],iCardCount,AnalyseResul[0],AnalyseResul[i])==FALSE) continue;

		//分析三条拖拉机
		if (AnalyseResul[0].iThreeTractorCount!=0)
		{
			if (AnalyseResul[i].iThreeTractorCount!=AnalyseResul[iWiner].iThreeTractorCount) continue;
			if (CompareOnlyOne(AnalyseResul[iWiner].iThreeTractorArray[2],AnalyseResul[i].iThreeTractorArray[2])==TRUE)
				continue;
		}

		//分析两条拖拉机
		if (AnalyseResul[0].iDoubleTractorCount!=0)
		{
			if (AnalyseResul[i].iDoubleTractorCount!=AnalyseResul[iWiner].iDoubleTractorCount) continue;
			if (CompareOnlyOne(AnalyseResul[iWiner].iDoubleTractorArray[2],AnalyseResul[i].iDoubleTractorArray[2])==TRUE)
	            continue;
		}