servermanage1.cpp

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

	}

	return TRUE;
}

//新一轮开始
BOOL CServerGameDesk::NewPlayTurn(int iWiner)
{
	m_iBaseOutCount=0;
	m_iOutCardPeople=iWiner;
	m_iFirstOutPeople=iWiner;
	::memset(m_iDeskCardCount,0,sizeof(m_iDeskCardCount));
	for (int i=0;i<m_bMaxPeople;i++) SendGameData(i,MDM_GM_GAME_NOTIFY,ASS_NEW_TURN,iWiner);
	SendWatchData(m_bMaxPeople,MDM_GM_GAME_NOTIFY,ASS_NEW_TURN,iWiner);
	return TRUE;
}

//用户请求离开
BOOL CServerGameDesk::UserHaveThing(BYTE bDeskStation, TCHAR * szMessage, int iLength)
{
	//if (m_bGameStation<GS_SEND_CARD) return TRUE;

	//m_iLeaveArgee|=1<<bDeskStation;
	//if (m_iLeaveArgee!=15)
	//{
	//	HaveThingStruct HaveThing;
	//	HaveThing.bDeskStation=bDeskStation;
	//	HaveThing.iMsgLength=iLength;
	//	::CopyMemory(HaveThing.szMessage,szMessage,iLength*sizeof(BYTE));
	//	int iSendSize=sizeof(HaveThing)-sizeof(HaveThing.szMessage)+sizeof(BYTE)*(HaveThing.iMsgLength);
	//	for (int i=0;i<m_bMaxPeople;i++) 
	//		if (i!=bDeskStation) SendGameData(i,&HaveThing,iSendSize,MDM_GM_GAME_NOTIFY,ASS_HAVE_THING,0);
	//}
	//else GameFinish(bDeskStation,GF_SALE);

	return TRUE;
}

//同意用户离开
BOOL CServerGameDesk::ArgeeUserLeft(BYTE bDeskStation, BOOL bArgee)
{
	//if (bArgee) m_iLeaveArgee|=1<<bDeskStation;
	//else m_iLeaveArgee&=~1<<bDeskStation;
	//if (m_iLeaveArgee!=15)
	//{
	//	LeaveResultStruct Leave;
	//	Leave.bDeskStation=bDeskStation;
	//	Leave.bArgeeLeave=bArgee;
	//	for (int i=0;i<m_bMaxPeople;i++) 
	//		if (i!=bDeskStation) SendGameData(i,&Leave,sizeof(Leave),MDM_GM_GAME_NOTIFY,ASS_LEFT_RESULT,0);
	//}
	//else GameFinish(bDeskStation,GF_SALE);

	return TRUE;
}

//BYTE CServerGameDesk::UserLeftDesk(BYTE bDeskStation, CGameUserInfo * pUserInfo)
//{
//	if ((m_pUserInfo[bDeskStation]!=NULL)&&(m_bGameStation==GS_WAIT_ARGEE)&&(bDeskStation==0))
//	{
//		//更改数据
//		m_iDeskFlags=0;
//		m_bGameStation=GS_WAIT_SETGAME;
//
//		//发送大厅取消同意消息
//		RoomArgeeStruct RoomArgee;
//		RoomArgee.bDeskNO=m_iDeskIndex;
//		RoomArgee.bDeskStation=255;
//		m_pDataManage->m_SocketManage.BatchSendData(&RoomArgee,sizeof(RoomArgee),TRUE,MDM_ROOM_INFO,ASS_UNARGEE_INFO,0);
//	}
//}
/******************************************************************************************************/
/***********************************************************************************************************/

// 升级逻辑类

/***********************************************************************************************************/

//构造函数
CUpGradeGameLogic::CUpGradeGameLogic(void)
{
	m_iNTNum=0;
	m_iNTHuaKind=UG_ERROR_HUA;
	m_iStation[4]=500;
	for (int i=0;i<4;i++) m_iStation[i]=100*i;
}

//设置主牌花色
void CUpGradeGameLogic::SetNTHuaKind(BYTE iNTHuaKind)
{
	//设置数据
	m_iNTHuaKind=iNTHuaKind & UG_HUA_MASK;
	
	//调整相对位置
	for (int i=0;i<4;i++) m_iStation[i]=100*i;
	if (m_iNTHuaKind!=UG_ERROR_HUA) m_iStation[m_iNTHuaKind>>4]=400;
	if (m_iNTHuaKind==UG_MEI_HUA)
	{
		m_iStation[3]=200;
		m_iStation[2]=300;
	}
	else if (m_iNTHuaKind==UG_HONG_TAO)
	{
		m_iStation[0]=100;
		m_iStation[1]=0;
	}

	return;
}

//获取扑克花色
BYTE CUpGradeGameLogic::GetCardHuaKind(BYTE iCard, BOOL bTrueHua)
{ 
	int iHuaKind=(iCard&UG_HUA_MASK);
	if (!bTrueHua)
	{
		if ((iHuaKind==m_iNTHuaKind)||(GetCardNum(iCard)==m_iNTNum)) 
			return iHuaKind=UG_NT_CARD;
	}
	return iHuaKind; 
}

//获取扑克大小 （2 - 18 ， 15 以上是主牌 ： 2 - 21 ， 15 以上是主）
int CUpGradeGameLogic::GetCardBulk(BYTE iCard, BOOL bExtVol)
{
	if ((iCard==0x4E)||(iCard==0x4F))
	{
		return bExtVol?(iCard-58):(iCard-61);	//大小鬼
	}

	int iCardNum=GetCardNum(iCard);
	if (iCardNum==m_iNTNum)
	{
		int iHuaKind=GetCardHuaKind(iCard,TRUE);
		if (bExtVol)
		{
			if (iHuaKind==m_iNTHuaKind) return 19;
			return (iHuaKind>>4)+15;
		}
		return (iHuaKind==m_iNTHuaKind)?16:15;
	}

	return iCardNum;
}

//排列扑克
BOOL CUpGradeGameLogic::SortCard(BYTE iCardList[], BOOL bUp[], int iCardCount)
{
	BOOL bSorted=TRUE,bTempUp;
	int iTemp,iLast=iCardCount-1,iStationVol[45];

	//获取位置数值
	for (int i=0;i<iCardCount;i++)
	{
		iStationVol[i]=GetCardBulk(iCardList[i],TRUE);
		if (iStationVol[i]>=15) iStationVol[i]+=m_iStation[4];
		else iStationVol[i]+=m_iStation[GetCardHuaKind(iCardList[i],FALSE)>>4];
	}

	//排序操作
	do
	{
		bSorted=TRUE;
		for (int i=0;i<iLast;i++)
		{
			if (iStationVol[i]<iStationVol[i+1])
			{	
				//交换位置
				iTemp=iCardList[i];
				iCardList[i]=iCardList[i+1];
				iCardList[i+1]=iTemp;
				iTemp=iStationVol[i];
				iStationVol[i]=iStationVol[i+1];
				iStationVol[i+1]=iTemp;
				if (bUp!=NULL)
				{
					bTempUp=bUp[i];
					bUp[i]=bUp[i+1];
					bUp[i+1]=bTempUp;
				}
				bSorted=FALSE;
			}	
		}
		iLast--;
	} while(!bSorted);
		
	return TRUE;
}

//获取扑克
BYTE CUpGradeGameLogic::GetCardFromHua(int iHuaKind, int iNum)
{
	if (iHuaKind!=UG_ERROR_HUA) return (iHuaKind+iNum-1);
	return 0;
}

//是否对牌
BOOL CUpGradeGameLogic::IsDouble(BYTE iCardList[], int iCardCount)
{
	if (iCardCount!=2) return FALSE;
	return (iCardList[0]==iCardList[1]);
}

//是否三条
BOOL CUpGradeGameLogic::IsThree(BYTE iCardList[], int iCardCount)
{
	if (iCardCount!=3) return FALSE;
	return ((iCardList[0]==iCardList[1])&&(iCardList[0]==iCardList[2]));
}

//是否拖拉机逻辑
BOOL CUpGradeGameLogic::IsTrackorRule(BYTE iFirstCard, BYTE iNextCard)
{
	int iCardBulk=GetCardBulk(iFirstCard,FALSE);//得到扑克大小
	if (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;