servermanage1.cpp

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

					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+1]<=iTempCard[iOtherStation+1])
							&&(CompareOnlyOne(AnalyseOut.iDoubleTractorArray[iOutStation+2],iTempCard[0])==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].iDoubleArray[2],AnalyseResul[i].iDoubleArray[2])==TRUE)
	            continue;
		}

		//分析三条
		if (AnalyseResul[0].iThreeCount!=0)
		{
			if (AnalyseResul[i].iThreeCount!=AnalyseResul[iWiner].iThreeCount) continue;
			if (CompareOnlyOne(AnalyseResul[iWiner].iThreeArray[0],AnalyseResul[i].iThreeArray[0])==TRUE)
				continue;
		}

		//分析对牌
		if (AnalyseResul[0].iDoubleCount!=0)
		{
			if (AnalyseResul[i].iDoubleCount!=AnalyseResul[iWiner].iDoubleCount) continue;
			if (CompareOnlyOne(AnalyseResul[iWiner].iDoubleArray[0],AnalyseResul[i].iDoubleArray[0])==TRUE)
				continue;
		}

		//分析单牌
		if (AnalyseResul[i].iSignedCount!=0)
		{
			if (AnalyseResul[i].iSignedCount!=AnalyseResul[iWiner].iSignedCount) continue;
			if (CompareOnlyOne(AnalyseResul[iWiner].iBigSignedCard,AnalyseResul[i].iBigSignedCard)==TRUE)
				continue;
		}

		//对比成功
		iWiner=i;
	}

	//考虑追杀的情况
	if(iWiner!=0 && iCardCount>=3)
	{
		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])==FALSE)
				{
					iWiner=i;
					break;
				}
			}

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

			//分析三条
			if (AnalyseResul[0].iThreeCount!=0)
			{
				if (AnalyseResul[i].iThreeCount!=AnalyseResul[iWiner].iThreeCount) continue;
				if (CompareOnlyOne(AnalyseResul[iWiner].iThreeArray[0],AnalyseResul[i].iThreeArray[0])==FALSE)
				{
					iWiner=i;
					break;
				}
			}

			//分析对牌
			if (AnalyseResul[0].iDoubleCount!=0)
			{
				if (AnalyseResul[i].iDoubleCount!=AnalyseResul[iWiner].iDoubleCount) continue;
				if (CompareOnlyOne(AnalyseResul[iWiner].iDoubleArray[0],AnalyseResul[i].iDoubleArray[0])==FALSE)
				{
					iWiner=i;
					break;
				}
			}

			//分析单牌
			if (AnalyseResul[i].iSignedCount!=0)
			{
				if (AnalyseResul[i].iSignedCount!=AnalyseResul[iWiner].iSignedCount) continue;
				if (CompareOnlyOne(AnalyseResul[iWiner].iBigSignedCard,AnalyseResul[i].iBigSignedCard)==FALSE)
				{
					iWiner=i;
					break;
				}
			}
		}
	}
	return iWiner;
}

//分析函数
BOOL CUpGradeGameLogic::AnalyseCard(BYTE iCardList[], int iCardCount, CardAnalyseStruct & Analyse)
{
	//初始化数据
	::memset(&Analyse,0,sizeof(Analyse));

	//判断是否同花色
	Analyse.iCardHuaKind=GetCardListHua(iCardList,iCardCount);
	if (Analyse.iCardHuaKind==UG_ERROR_HUA) return FALSE;

	//分析临时数据
	BYTE iTempCard[39];
	::CopyMemory(iTempCard,iCardList,sizeof(BYTE)*iCardCount);

	//去除一张扑克的分析过程
	if (iCardCount==1) 
	{
		Analyse.iSignedCount=1;
		Analyse.iLessSignedCard=iCardList[0];
		return TRUE;
	}

	//提取三条
	Analyse.iThreeCount=TackOutThree(iTempCard,iCardCount,Analyse.iThreeArray,TRUE);
	iCardCount-=Analyse.iThreeCount;
	
	//提取三条拖拉机
	Analyse.iThreeTractorCount=TackOutThreeTrackor(Analyse.iThreeArray,Analyse.iThreeCount,
							   Analyse.iThreeTractorArray,TRUE);
	Analyse.iThreeCount-=Analyse.iThreeTractorCount;

	//提取对牌
	Analyse.iDoubleCount=TackOutDouble(iTempCard,iCardCount,Analyse.iDoubleArray,TRUE);
	iCardCount-=Analyse.iDoubleCount;

	//提取两条拖拉机
	Analyse.iDoubleTractorCount=TackOutDoubleTrackor(Analyse.iDoubleArray,Analyse.iDoubleCount,
							    Analyse.iDoubleTractorArray,TRUE);
	Analyse.iDoubleCount-=Analyse.iDoubleTractorCount;

	//提取单牌
	if (iCardCount>0)
	{
		Analyse.iSignedCount=iCardCount;
		Analyse.iBigSignedCard=iTempCard[0];
		Analyse.iLessSignedCard=iTempCard[iCardCount-1];
	}

	return TRUE;
}

//变化扑克格式
BOOL CUpGradeGameLogic::FixCardType(BYTE iCardList[], int iCardCount, CardAnalyseStruct & BaseAnalyse, CardAnalyseStruct & OutAnalyse)
{
	if (GetCardListHua(iCardList,iCardCount)==UG_ERROR_HUA) return FALSE;

	BYTE iSoureCard[39],iTempCard[39];
	int iSoureCardCount=iCardCount,iTempCount=0;
	::CopyMemory(iSoureCard,iCardList,sizeof(BYTE)*iCardCount);
	::memset(&OutAnalyse,0,sizeof(OutAnalyse));

	//调整三条拖拉机
	if (BaseAnalyse.iThreeTractorCount!=0)
	{
		iTempCount=TackOutThreeTrackor(iSoureCard,iSoureCardCount,iTempCard,TRUE);
		iSoureCardCount-=iTempCount;
		if (BaseAnalyse.iThreeTractorCount>iTempCount) return FALSE;
		int iOutPos=0,iTempPos=0,iNeedLength=0,iCopyLength=0;
		do
		{
			iNeedLength=BaseAnalyse.iThreeTractorCount-OutAnalyse.iThreeTractorCount;
			if (iNeedLength<6) return FALSE;
			iCopyLength=__min(iTempCard[iTempPos+1],iNeedLength);
			::CopyMemory(&OutAnalyse.iThreeTractorArray[iOutPos+2],&iTempCard[iTempPos+2],sizeof(BYTE)*iCopyLength);
			OutAnalyse.iThreeTractorArray[iOutPos]=0;
			OutAnalyse.iThreeTractorArray[iOutPos+1]=iCopyLength;
			OutAnalyse.iThreeTractorCount+=iCopyLength;
			if (iCopyLength==iTempCard[iTempPos+1])
			{
				iTempCount-=iTempCard[iTempPos+1];
				iTempPos+=iTempCard[iTempPos+1]+2;
				iOutPos+=OutAnalyse.iThreeTractorArray[iOutPos+1]+2;
			}
			else
			{
				::CopyMemory(&iSoureCard[iSoureCardCount],&iTempCard[iTempPos+2+iCopyLength],
							 sizeof(BYTE)*(iTempCard[iTempPos+1]-iCopyLength));
				iTempCount-=iTempCard[iTempPos+1];
				iSoureCardCount+=(iTempCard[iTempPos+1]-iCopyLength);
				iTempPos+=iTempCard[iTempPos+1]+2;
				while ((iSoureCardCount+OutAnalyse.iThreeTractorCount)<iCardCount)
				{
					::CopyMemory(&iSoureCard[iSoureCardCount],&iTempCard[iTempPos+2],sizeof(BYTE)*iTempCard[iTempPos+1]);
					iTempCount-=iTempCard[iTempPos+1];
					iSoureCardCount+=iTempCard[iTempPos+1];
					iTempPos+=iTempCard[iTempPos+1]+2;
				}
				SortCard(iSoureCard,NULL,iSoureCardCount);
			}
		} while (BaseAnalyse.iThreeTractorCount>=OutAnalyse.iThreeTractorCount);