servermanage1.cpp

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

	}

	//调整三条
	if (BaseAnalyse.iThreeCount!=0)
	{
		iTempCount=TackOutThree(iSoureCard,iSoureCardCount,iTempCard,FALSE);
		if (BaseAnalyse.iThreeCount>iTempCount) return FALSE;
		OutAnalyse.iThreeCount=BaseAnalyse.iThreeCount;
		::CopyMemory(OutAnalyse.iThreeArray,iTempCard,sizeof(BYTE)*BaseAnalyse.iThreeCount);
		iSoureCardCount-=RemoveCard(iTempCard,BaseAnalyse.iThreeCount,iSoureCard,iSoureCardCount);
	}

	//调整两条拖拉机
	if (BaseAnalyse.iDoubleTractorCount!=0)
	{
		iTempCount=TackOutDoubleTrackor(iSoureCard,iSoureCardCount,iTempCard,TRUE);
		iSoureCardCount-=iTempCount;
		if (BaseAnalyse.iDoubleTractorCount>iTempCount) return FALSE;
		int iOutPos=0,iTempPos=0,iNeedLength=0,iCopyLength=0;
		do
		{
			iNeedLength=BaseAnalyse.iDoubleTractorCount-OutAnalyse.iDoubleTractorCount;
			if (iNeedLength<4) return FALSE;
			iCopyLength=__min(iTempCard[iTempPos+1],iNeedLength);
			::CopyMemory(&OutAnalyse.iDoubleTractorArray[iOutPos+2],&iTempCard[iTempPos+2],sizeof(BYTE)*iCopyLength);
			OutAnalyse.iDoubleTractorArray[iOutPos]=0;
			OutAnalyse.iDoubleTractorArray[iOutPos+1]=iCopyLength;
			OutAnalyse.iDoubleTractorCount+=iCopyLength;
			if (iCopyLength==iTempCard[iTempPos+1])
			{
				iTempCount-=iTempCard[iTempPos+1];
				iTempPos+=iTempCard[iTempPos+1]+2;
				iOutPos+=OutAnalyse.iDoubleTractorArray[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.iDoubleTractorCount)<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.iDoubleTractorCount>=OutAnalyse.iDoubleTractorCount);
	}

	//调整对牌
	if (BaseAnalyse.iDoubleCount!=0)
	{
		iTempCount=TackOutDouble(iSoureCard,iSoureCardCount,iTempCard,FALSE);
		if (BaseAnalyse.iDoubleCount>iTempCount) return FALSE;
		OutAnalyse.iDoubleCount=BaseAnalyse.iDoubleCount;
		::CopyMemory(OutAnalyse.iDoubleArray,iTempCard,sizeof(BYTE)*BaseAnalyse.iDoubleCount);
		iSoureCardCount-=RemoveCard(iTempCard,BaseAnalyse.iDoubleCount,iSoureCard,iSoureCardCount);
	}

	//调整单牌
	if (iSoureCardCount>0)
	{
		OutAnalyse.iSignedCount=iSoureCardCount;
		OutAnalyse.iBigSignedCard=iSoureCard[0];
		OutAnalyse.iLessSignedCard=iSoureCard[iSoureCardCount-1];
	}

	return TRUE;
}

//提取对牌函数
int CUpGradeGameLogic::TackOutDouble(BYTE iCardList[], int iCardCount, BYTE iDoubleBuffer[], BOOL bRemoveCard)
{
	int iCount=0;
	for (int i=0;i<iCardCount-1;i++)
	{
		if (iCardList[i]==iCardList[i+1])
		{
			iDoubleBuffer[iCount+1]=iDoubleBuffer[iCount]=iCardList[i];
			iCount+=2;
			if (bRemoveCard) iCardList[i]=iCardList[i+1]=0;
			i++;
		}
	}
	if (iCount && bRemoveCard) RemoveNummCard(iCardList,iCardCount);

	return iCount;
}

//提取两条拖拉机函数
int CUpGradeGameLogic::TackOutDoubleTrackor(BYTE iCardList[], int iCardCount, BYTE iDoubleBuffer[], BOOL bRemoveCard)
{
	BOOL bEndFind=FALSE;
	int iCount=0,iRecordPos=0,iDataPos=0,iTrackorLen=0;

	for (int i=0;i<iCardCount-3;i++)
	{
		if (IsDouble(&iCardList[i],2))
		{
			iDataPos=i;
			iTrackorLen=2;
			bEndFind=FALSE;
			do
			{
				if ((IsDouble(&iCardList[i+2],2))&&(IsTrackorRule(iCardList[i],iCardList[i+2])))
				{
					//是拖拉机
					i+=2;
					iTrackorLen+=2;
				}
				else bEndFind=TRUE;
			} while ((bEndFind==FALSE)&&(i<iCardCount-3));

			//记录数据
			if (iTrackorLen>=4)
			{
				iCount+=iTrackorLen;
				iDoubleBuffer[iRecordPos]=0;
				iDoubleBuffer[iRecordPos+1]=iTrackorLen;
				for (int j=0;j<iTrackorLen;j++)
				{
					iDoubleBuffer[iRecordPos+j+2]=iCardList[iDataPos+j];
					if (bRemoveCard) iCardList[iDataPos+j]=0;
				}
				iRecordPos+=(iTrackorLen+2);
			}
		}
	}
	if (iCount && bRemoveCard) RemoveNummCard(iCardList,iCardCount);

	return iCount;
}

//提取三条函数
int CUpGradeGameLogic::TackOutThree(BYTE iCardList[], int iCardCount, BYTE iThreeBuffer[], BOOL bRemoveCard)
{
	int iCount=0;
	for (int i=0;i<iCardCount-2;i++)
	{
		if ((iCardList[i]==iCardList[i+1])&&(iCardList[i]==iCardList[i+2]))
		{
			iThreeBuffer[iCount]=iThreeBuffer[iCount+1]=iThreeBuffer[iCount+2]=iCardList[i];
			iCount+=3;
			if (bRemoveCard) iCardList[i]=iCardList[i+1]=iCardList[i+2]=0;
			i+=2;
		}
	}
	if (iCount && bRemoveCard) RemoveNummCard(iCardList,iCardCount);

	return iCount;
}

//提取三条拖拉机函数
int CUpGradeGameLogic::TackOutThreeTrackor(BYTE iCardList[], int iCardCount, BYTE iThreeBuffer[], BOOL bRemoveCard)
{
	BOOL bEndFind=FALSE;
	int iCount=0,iRecordPos=0,iDataPos=0,iTrackorLen=0;

	for (int i=0;i<iCardCount-5;i++)
	{
		if (IsThree(&iCardList[i],3))
		{
			iDataPos=i;
			iTrackorLen=3;
			bEndFind=FALSE;
			do
			{
				if ((IsThree(&iCardList[i+3],3))&&(IsTrackorRule(iCardList[i],iCardList[i+3])))
				{
					//是拖拉机
					i+=3;
					iTrackorLen+=3;
				}
				else bEndFind=TRUE;
			} while ((bEndFind==FALSE)&&(i<iCardCount-5));

			//记录数据
			if (iTrackorLen>=6)
			{
				iCount+=iTrackorLen;
				iThreeBuffer[iRecordPos]=0;
				iThreeBuffer[iRecordPos+1]=iTrackorLen;
				for (int j=0;j<iTrackorLen;j++)
				{
					iThreeBuffer[iRecordPos+j+2]=iCardList[iDataPos+j];
					if (bRemoveCard) iCardList[iDataPos+j]=0;
				}
				iRecordPos+=(iTrackorLen+2);
			}
		}
	}
	if (iCount && bRemoveCard) RemoveNummCard(iCardList,iCardCount);

	return iCount;
}

//提取同一花色扑克
int CUpGradeGameLogic::TackOutCardByHua(BYTE iCardList[], int iCardCount, BYTE iHuaKind, BYTE iCardBuffer[], BOOL bRemoveCard)
{
	for (int iBeginPos=0;iBeginPos<iCardCount;iBeginPos++)
	{
		if (GetCardHuaKind(iCardList[iBeginPos],FALSE)==iHuaKind) break;
	}
	if (iBeginPos==iCardCount) return 0;
	for (int iEndPos=iCardCount-1;iEndPos>=0;iEndPos--)
	{
		if (GetCardHuaKind(iCardList[iEndPos],FALSE)==iHuaKind) break;
	}
	::CopyMemory(iCardBuffer,&iCardList[iBeginPos],sizeof(BYTE)*(iEndPos-iBeginPos+1));
	if (bRemoveCard) RemoveNummCard(iCardList,iCardCount);
	return (iEndPos-iBeginPos+1);
}

//清除 0 位扑克
int CUpGradeGameLogic::RemoveNummCard(BYTE iCardList[], int iCardCount)
{
	int iRemoveCount=0;
	for (int i=0;i<iCardCount;i++)
	{
		if (iCardList[i]!=0) iCardList[i-iRemoveCount]=iCardList[i];
		else iRemoveCount++;
	}
	return iRemoveCount;
}

//混乱扑克
BYTE CUpGradeGameLogic::RandCard(BYTE iCard[], int iCardCount)
{
	static const BYTE m_CardArray[54]={
			0x01, 0x02 ,0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D,		//方块 2 - A
			0x11, 0x12 ,0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,		//梅花 2 - A
			0x21, 0x22 ,0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D,		//红桃 2 - A
			0x31, 0x32 ,0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D,		//黑桃 2 - A
			0x4E, 0x4F};																		//小鬼，大鬼

	BYTE iSend=0,iStation=0,iCardList[162];
	srand((unsigned)time(NULL));
	
	for (int i=0;i<iCardCount;i+=54)
		::CopyMemory(&iCardList[i],m_CardArray,sizeof(m_CardArray));
	do
	{
		iStation=rand()%(iCardCount-iSend);
		iCard[iSend]=iCardList[iStation];
		iSend++;
		iCardList[iStation]=iCardList[iCardCount-iSend];
	} while (iSend<iCardCount);

	return iCardCount;
}

//删除扑克
int CUpGradeGameLogic::RemoveCard(BYTE iRemoveCard[], int iRemoveCount, BYTE iCardList[], int iCardCount)
{
	//检验数据
	if ((iRemoveCount>iCardCount)) return 0;

	//把要删除的牌置零
	int iDeleteCount=0;
	for (int i=0;i<iRemoveCount;i++)
	{
		for (int j=0;j<iCardCount;j++)
		{
			if (iRemoveCard[i]==iCardList[j])
			{
				iDeleteCount++;
				iCardList[j]=0;
				break;
			}
		}
	}
	RemoveNummCard(iCardList,iCardCount);
	if (iDeleteCount!=iRemoveCount) return 0;

	return iDeleteCount;
}

//查找分数
int CUpGradeGameLogic::FindPoint(BYTE iCardList[], int iCardCount)
{
	int iPoint=0,iNum=0;
	for (int i=0;i<iCardCount;i++)
	{
		iNum=GetCardNum(iCardList[i]);
		if (iNum==5) iPoint+=5;
		else if ((iNum==10)||(iNum==13)) iPoint+=10;
	}
	return iPoint;
}

//查找最长的拖拉机
int	CUpGradeGameLogic::MaxThreeTractorLong(BYTE iCardList[], int iCardCount, BYTE iTrackorBuffer[])
{
	int iMaxPos=0,iMaxCount=0,i=0;
	BYTE iTempThreeTrackor[48];
	int iCount=TackOutThreeTrackor(iCardList,iCardCount,iTempThreeTrackor,FALSE);
	while (i<iCount)
	{
		if (iTempThreeTrackor[i+1]>iMaxCount)
		{
			iMaxPos=i;
			iMaxCount=iTrackorBuffer[i+1];
		}
		i+=(iTempThreeTrackor[i+1]+2);
	}
	if ((iMaxCount!=0)&&(iTrackorBuffer!=NULL)) 
		::CopyMemory(iTrackorBuffer,&iTempThreeTrackor[iMaxPos],sizeof(BYTE)*(iMaxCount+2));

	return iMaxCount;
}

//查找最长的拖拉机
int	CUpGradeGameLogic::MaxDoubleTractorLong(BYTE iCardList[], int iCardCount, BYTE iTrackorBuffer[])
{
	int iMaxPos=0,iMaxCount=0,i=0;
	BYTE iTempDoubleTrackor[54];
	int iCount=TackOutDoubleTrackor(iCardList,iCardCount,iTempDoubleTrackor,FALSE);
	while (i<iCount)
	{
		if (iTempDoubleTrackor[i+1]>iMaxCount)
		{
			iMaxPos=i;
			iMaxCount=iTempDoubleTrackor[i+1];
		}
		i+=(iTempDoubleTrackor[i+1]+2);
	}
	if ((iMaxCount!=0)&&(iTrackorBuffer!=NULL)) 
		::CopyMemory(iTrackorBuffer,&iTempDoubleTrackor[iMaxPos],sizeof(BYTE)*(iMaxCount+2));

	return iMaxCount;
}

//是否可以出牌
BOOL CUpGradeGameLogic::CanOutCard(BYTE iOutCard[], int iOutCount, BYTE iBaseCard[], 
								   int iBaseCount, BYTE iHandCard[], int iHandCount)
{
	//判断数目是否相同
	if (iOutCount!=iBaseCount) return FALSE;

	//得取扑克的基本信息
	int iBaseHua=GetCardListHua(iBaseCard,iBaseCount);
	int iOutHua=GetCardListHua(iOutCard,iOutCount);
	BYTE iBaseKind=GetCardShape(iBaseCard,iBaseCount);
	BYTE iOutKind=GetCardShape(iOutCard,iOutCount);
	BYTE iSameHuaCardBuf[39],iTempCard[54];

	//判断是否与这轮的出牌参数敏合
	if ((iBaseKind==iOutKind)&&(iBaseHua==iOutHua)&&(iBaseKind!=UG_SHOW_CARD))	return TRUE;
	
	int iSameHuaCount=TackOutCardByHua(iHandCard,iHandCount,iBaseHua,iSameHuaCardBuf,FALSE);

	if (iBaseHua!=iOutHua)	//花色不相同
	{
		//花色不相同,判断是否没了这种花色的扑克
		return (TackOutCardByHua(iOutCard,iOutCount,iBaseHua,iTempCard,FALSE)==iSameHuaCount);
	}
	if (iOutKind!=iBaseKind)	//类型不相同
	{
		//类型不相同，判断是否游戏者没有此类型
		switch (iBaseKind)
		{
			//单牌类型的已经在花色判断中过滤掉了
		case UG_DOUBLE:
			{
				//判断是否没有了对牌
				return TackOutDouble(iSameHuaCardBuf,iSameHuaCount,iTempCard,FALSE)==0;
			}
		case UG_THREE:
			{
				//判断是否没有了三条
				if (TackOutThree(iSameHuaCardBuf,iSameHuaCount,iTempCard,FALSE)!=0) return FALSE;

				//判断是否已经尽力出对牌
				BYTE iMeOutLength=TackOutDouble(iOutCard,iOutCount,iTempCard,FALSE);
				BYTE iMeHandLength=TackOutDouble(iSameHuaCardBuf,iSameHuaCount,iTempCard,FALSE);
				if ((iMeHandLength>iMeOutLength)&&(iMeOutLength<(iBaseCount-1))) return FALSE;

				return TRUE;
			}
		case UG_DOUBLE_TRACKOR:
			{
				//判断游戏者是否尽力出拖拉机
				BYTE iMeOutLength=MaxDoubleTractorLong(iOutCard,iOutCount,NULL);
				BYTE iMeHandLength=MaxDoubleTractorLong(iSameHuaCardBuf,iSameHuaCount,NULL);
				if (iMeHandLength>iMeOutLength) return FALSE;
				iBaseCount-=iMeOutLength;

				//判断是否已经尽力出对牌
				iMeOutLength=TackOutDouble(iOutCard,iOutCount,iTempCard,FALSE);
				iMeHandLength=TackOutDouble(iSameHuaCardBuf,iSameHuaCount,iTempCard,FALSE);
				if ((iMeHandLength>iMeOutLength)&&(iMeOutLength<(iBaseCount-1))) return FALSE;

				return TRUE;
			}
		case UG_THREE_TARCKOR:
			{
				//判断游戏者是否尽力出拖拉机
				BYTE iMeOutLength=MaxThreeTractorLong(iOutCard,iOutCount,NULL);
				BYTE iMeHandLength=Ma