servermanage1.cpp

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

#include "StdAfx.h"
#include "ServerManage.h"


//构造函数
CServerGameDesk::CServerGameDesk(void):CGameDesk(FULL_BEGIN)
{
	m_iEnableWatch=0;
	m_iLeaveArgee=0;
	m_iNtCardCount=0;
	m_iLessCount=0;
	m_iPlayCardCount=0;
	m_iBeginStation=0;
	m_iEndStation=0;
	m_iBaseOutCount=0;
	m_iNtPeople=-1;
	m_iFirstOutPeople=-1;
	m_iOutCardPeople=-1;
	m_iUpGradePeople=-1;
	m_iBeenPlayGame=0;
	m_iGamePoint=0;
	m_bGameStation=GS_WAIT_SETGAME;
	m_CardCount=PLAY_TWO_CARD;
	::memset(&m_PunishPoint,0,sizeof(m_PunishPoint));
	::memset(m_iPlayNTNum,0,sizeof(m_iPlayNTNum));
	::memset(m_iDeskCardCount,0,sizeof(m_iDeskCardCount));
}

//析构函数
CServerGameDesk::~CServerGameDesk(void)
{
}

//定时器消息
bool CServerGameDesk::OnTimer(UINT uTimerID)
{
	if (uTimerID==TIME_SEND_CARD)	//发牌定时器
	{
		if (m_bGameStation==GS_SEND_CARD) SendCard();
		else KillTimer(TIME_SEND_CARD);
		return TRUE;
	}
	if (uTimerID==TIME_WAIT_NT)		//反牌定时器
	{
		if (m_bGameStation==GS_SEND_CARD) SendBackCard();
		KillTimer(TIME_WAIT_NT);
		return TRUE;
	}
	if (uTimerID==TIME_GAME_FINISH)	//结束定时器
	{
		KillTimer(TIME_GAME_FINISH);
		if (m_bGameStation==GS_PLAY_GAME) GameFinish(0,GF_NORMAL);
	}
	return __super::OnTimer(uTimerID);
}

//获取游戏状态信息
bool CServerGameDesk::OnGetGameStation(BYTE bDeskStation, UINT uSocketID, bool bWatchUser)
{
	switch (m_bGameStation)
	{
	case GS_WAIT_SETGAME:		//游戏没有开始状态
		{
			GameStation_1 GameStation;
			::memset(&GameStation,0,sizeof(GameStation));
			GameStation.iCardCount=m_CardCount;

			//发送数据
			SendGameStation(bDeskStation,uSocketID,bWatchUser,&GameStation,sizeof(GameStation));

			return TRUE;
		}
	case GS_WAIT_ARGEE:			//等待玩家开始状态
		{
			GameStation_2 GameStation;
			::memset(&GameStation,0,sizeof(GameStation));
			GameStation.iPlayCount=m_iLessCount;
			GameStation.iCardCount=m_iPlayCardCount;
			GameStation.iBeginStation=m_iBeginStation;
			GameStation.iEndStation=m_iEndStation;

			//发送数据
			SendGameStation(bDeskStation,uSocketID,bWatchUser,&GameStation,sizeof(GameStation));
			return TRUE;
		}
	case GS_SEND_CARD:		//发牌状态
	case GS_WAIT_BACK:		//等待埋底牌状态
		{
			GameStation_3 GameStation;
			::memset(&GameStation,0,sizeof(GameStation));
			GameStation.iPlayCount=m_iLessCount;
			GameStation.iCardCount=m_iPlayCardCount;
			GameStation.iBeginStation=m_iBeginStation;
			GameStation.iEndStation=m_iEndStation;
			GameStation.iWinPoint=m_iPlayNTNum[bDeskStation%2]-m_iBeginStation;			
			GameStation.iPunishPoint=m_PunishPoint[bDeskStation];			
			GameStation.iUpGradePeople=m_iUpGradePeople;		
			GameStation.iPlayNTNum[0]=m_iPlayNTNum[0];		
			GameStation.iPlayNTNum[1]=m_iPlayNTNum[1];		
			GameStation.iBeenPlayGame=m_iBeenPlayGame;		
			GameStation.iNtPeople=m_iNtPeople;			
			GameStation.iNtCardCount=m_iNtCardCount;			
			GameStation.iNtHua=m_Logic.GetNTHuaKind();
			GameStation.iUserCardCount=m_iUserCardCount[bDeskStation];		
			::CopyMemory(GameStation.iUserCard,m_iUserCard[bDeskStation],sizeof(BYTE)*m_iUserCardCount[bDeskStation]);

			//发送数据
			int iSendSize=sizeof(GameStation)-sizeof(GameStation.iUserCard)+sizeof(BYTE)*m_iUserCardCount[bDeskStation];
			SendGameStation(bDeskStation,uSocketID,bWatchUser,&GameStation,iSendSize);
			return TRUE;
		}
	case GS_PLAY_GAME:	//游戏中状态
		{
			GameStation_4 GameStation;
			::memset(&GameStation,0,sizeof(GameStation));
			GameStation.iPlayCount=m_iLessCount;
			GameStation.iCardCount=m_iPlayCardCount;
			GameStation.iBeginStation=m_iBeginStation;
			GameStation.iEndStation=m_iEndStation;
			GameStation.iWinPoint=m_iPlayNTNum[bDeskStation%2]-m_iBeginStation;			
			GameStation.iPunishPoint=m_PunishPoint[bDeskStation];			
			GameStation.iUpGradePeople=m_iUpGradePeople;		
			GameStation.iPlayNTNum[0]=m_iPlayNTNum[0];		
			GameStation.iPlayNTNum[1]=m_iPlayNTNum[1];		
			GameStation.iBeenPlayGame=m_iBeenPlayGame;		
			GameStation.iNtPeople=m_iNtPeople;			
			GameStation.iNtCardCount=m_iNtCardCount;			
			GameStation.iNtHua=m_Logic.GetNTHuaKind();
			GameStation.iGamePoint=m_iGamePoint;
			GameStation.iOutCardPeople=m_iOutCardPeople;	
			GameStation.iFirstOutPeople=m_iFirstOutPeople;	
			GameStation.iBaseOutCount=m_iBaseOutCount;	
			GameStation.iUserCardCount=m_iUserCardCount[bDeskStation];
			::CopyMemory(GameStation.iUserCardList,m_iUserCard[bDeskStation],sizeof(BYTE)*m_iUserCardCount[bDeskStation]);
			int iPos=GameStation.iUserCardCount;
			for (int i=0;i<4;i++)
			{
				GameStation.iDeskCardCount[i]=m_iDeskCardCount[i];
				::CopyMemory(&GameStation.iUserCardList[iPos],m_iDeskCard[i],sizeof(BYTE)*m_iDeskCardCount[i]);
				iPos+=m_iDeskCardCount[i];
			}

			//发送数据
			int iSendSize=sizeof(GameStation)-sizeof(GameStation.iUserCardList)+sizeof(BYTE)+iPos;
			SendGameStation(bDeskStation,uSocketID,bWatchUser,&GameStation,iSendSize);
			return TRUE;
		}
	case GS_WAIT_NEXT:		//等待下一盘游戏开始
		{
			GameStation_5 GameStation;
			::memset(&GameStation,0,sizeof(GameStation));
			GameStation.iPlayCount=m_iLessCount;
			GameStation.iCardCount=m_iPlayCardCount;
			GameStation.iBeginStation=m_iBeginStation;
			GameStation.iEndStation=m_iEndStation;
			GameStation.iWinPoint=m_iPlayNTNum[bDeskStation%2]-m_iBeginStation;			
			GameStation.iPunishPoint=m_PunishPoint[bDeskStation];			
			GameStation.iUpGradePeople=m_iUpGradePeople;		
			GameStation.iPlayNTNum[0]=m_iPlayNTNum[0];		
			GameStation.iPlayNTNum[1]=m_iPlayNTNum[1];		
			GameStation.iBeenPlayGame=m_iBeenPlayGame;		

			//发送数据
			SendGameStation(bDeskStation,uSocketID,bWatchUser,&GameStation,sizeof(GameStation));
			return TRUE;
		}
	}
	return false;
}

//重置游戏状态
bool CServerGameDesk::ReSetGameState(BYTE bLastStation)
{
	KillTimer(TIME_SEND_CARD);
	KillTimer(TIME_WAIT_NT);
	KillTimer(TIME_GAME_FINISH);

	if ((bLastStation==GFF_FORCE_FINISH)||(bLastStation==GF_SALE))
	{
		m_iLessCount=0;
		m_iPlayCardCount=0;
		m_iBeginStation=0;
		m_iEndStation=0;
		m_iBeenPlayGame=0;
		m_iUpGradePeople=-1;
		m_Logic.SetNTCardNum(0);
		::memset(m_iPlayNTNum,0,sizeof(m_iPlayNTNum));
		::memset(m_PunishPoint,0,sizeof(m_PunishPoint));
	}

	m_iLeaveArgee=0;
	m_iGamePoint=0;
	m_iBaseOutCount=0;
	m_iFirstOutPeople=-1;
	m_iOutCardPeople=-1;
	m_iNtPeople=-1;
	m_iNtCardCount=0;
	m_iSendCardPos=0;
	m_Logic.SetNTHuaKind(UG_ERROR_HUA);
	memset(m_iDeskCardCount,0,sizeof(m_iDeskCardCount));
	memset(m_iUserCardCount,0,sizeof(m_iUserCardCount));

	return TRUE;
}

//游戏开始
bool CServerGameDesk::GameBegin(BYTE bBeginFlag)
{
	if (__super::GameBegin(bBeginFlag)==false) return false;

	//设置状态
	m_iNtPeople=-1;
	m_iNtCardCount=0;
	m_iSendCardPos=0;
	m_iBeenPlayGame++;
	m_Logic.SetNTHuaKind(UG_ERROR_HUA);
	m_bGameStation=GS_SEND_CARD;
	::memset(m_iDeskCardCount,0,sizeof(m_iDeskCardCount));
	::memset(m_iUserCardCount,0,sizeof(m_iUserCardCount));

	//发送开始消息
	BeginUpgradeStruct BeginMessage;
	BeginMessage.iNtStation=m_Logic.GetNTCardNum();
	BeginMessage.iStation[0]=m_iPlayNTNum[0];
	BeginMessage.iStation[1]=m_iPlayNTNum[1];
	BeginMessage.iPlayCount=m_iBeenPlayGame;
	BeginMessage.iUpgradeStation=m_iUpGradePeople;
	for (int i=0;i<4;i++) SendGameData(i,&BeginMessage,sizeof(BeginMessage),MDM_GM_GAME_NOTIFY,ASS_BEGIN_UPGRADE,0);
	SendWatchData(m_bMaxPeople,&BeginMessage,sizeof(BeginMessage),MDM_GM_GAME_NOTIFY,ASS_BEGIN_UPGRADE,0);

	//分发扑克
	BYTE iCardArray[162];
	m_Logic.RandCard(iCardArray,(m_iPlayCardCount==2)?108:162);
	for (int i=0;i<4;i++)
		::CopyMemory(m_iUserCard[i],&iCardArray[((m_iPlayCardCount==2)?25:39)*i],sizeof(BYTE)*((m_iPlayCardCount==2)?25:39));
	::CopyMemory(m_iBackCard,&iCardArray[(m_iPlayCardCount==2)?100:156],sizeof(BYTE)*((m_iPlayCardCount==2)?8:6));

	//发牌消息
	SetTimer(TIME_SEND_CARD,200);

	return TRUE;
}

//游戏结束
bool CServerGameDesk::GameFinish(BYTE bDeskStation, BYTE bCloseFlag)
{
	//编写代码
	switch (bCloseFlag)
	{
	case GF_NORMAL:		//游戏正常结束
		{
			//计算得分
			int iTurePoint=GetUpGrade(m_iGamePoint,m_iPlayCardCount);

			//计算胜利
			if (iTurePoint>0) m_iPlayNTNum[m_iUpGradePeople%2]+=iTurePoint;
			else if (iTurePoint<=-1) m_iPlayNTNum[(m_iUpGradePeople+1)%2]+=(-iTurePoint-1);

			//游戏结束
			GameEndStruct GameEnd;
			::memset(&GameEnd,0,sizeof(GameEnd));
			GameEnd.iUpGradeStation=m_iUpGradePeople;
			GameEnd.iGamePoint=m_iGamePoint;
			::CopyMemory(GameEnd.iBackList,m_iBackCard,sizeof(m_iBackCard));

			if ((m_iBeenPlayGame>=m_iLessCount)||(m_iPlayNTNum[0]>m_iEndStation)||(m_iPlayNTNum[1]>m_iEndStation))
			{
				//设置数据
				bCloseFlag=GFF_FORCE_FINISH;
				m_bGameStation=GS_WAIT_SETGAME;

				//计算总得分
				int iWinPoint[2];
				iWinPoint[0]=(m_iPlayNTNum[0]-m_iBeginStation)+(m_iPlayNTNum[0]-m_iPlayNTNum[1])*2;
				iWinPoint[1]=(m_iPlayNTNum[1]-m_iBeginStation)+(m_iPlayNTNum[1]-m_iPlayNTNum[0])*2;

				//写入数据库				
				for (int i=0;i<4;i++)
					ChangeUserPoint(m_pUserInfo[i],iWinPoint[i%2],iWinPoint[i%2]>0,iWinPoint[i%2]<0,iWinPoint[i%2]==0,false);

				//发送消息
				for (int i=0;i<m_bMaxPeople;i++) SendGameData(i,&GameEnd,sizeof(GameEnd),MDM_GM_GAME_NOTIFY,ASS_NO_CONTINUE_END,0);
				SendWatchData(m_bMaxPeople,&GameEnd,sizeof(GameEnd),MDM_GM_GAME_NOTIFY,ASS_NO_CONTINUE_END,0);
			}
			else	//继续下一盘
			{
				//设置数据 
				m_bGameStation=GS_WAIT_NEXT;
				if (iTurePoint>0) m_iUpGradePeople=(m_iUpGradePeople+2)%4;
				else m_iUpGradePeople=(m_iUpGradePeople+1)%4;
				m_Logic.SetNTCardNum(m_iPlayNTNum[m_iUpGradePeople%2]);

				//设置分数
				GameEnd.iTurePoint[0]=GameEnd.iTurePoint[2]=(m_iPlayNTNum[m_iUpGradePeople%2]-m_iBeginStation)+(m_iPlayNTNum[m_iUpGradePeople%2]-m_iPlayNTNum[(m_iUpGradePeople+1)%2])*2;
				GameEnd.iTurePoint[1]=GameEnd.iTurePoint[3]=(m_iPlayNTNum[(m_iUpGradePeople+1)%2]-m_iBeginStation)+(m_iPlayNTNum[(m_iUpGradePeople+1)%2]-m_iPlayNTNum[m_iUpGradePeople%2])*2;
			
				//发送数据
				for (int i=0;i<m_bMaxPeople;i++) SendGameData(i,&GameEnd,sizeof(GameEnd),MDM_GM_GAME_NOTIFY,ASS_CONTINUE_END,0);
				SendWatchData(m_bMaxPeople,&GameEnd,sizeof(GameEnd),MDM_GM_GAME_NOTIFY,ASS_CONTINUE_END,0);
			}

			break;
		}
	case GF_SALE:			//游戏安全结束
	case GFF_FORCE_FINISH:		//用户断线离开
		{
			//设置数据
			m_bGameStation=GS_WAIT_SETGAME;

			//计算总得分
			int iWinPoint[2];
			iWinPoint[0]=m_iPlayNTNum[0]*3-m_iBeginStation-m_iPlayNTNum[1]*2;
			iWinPoint[1]=m_iPlayNTNum[1]*3-m_iBeginStation-m_iPlayNTNum[0]*2;

			GameCutStruct CutEnd;
			CutEnd.bDeskStation=bDeskStation;

			//写入数据库				
			for (int i=0;i<4;i++)
				ChangeUserPoint(m_pUserInfo[i],iWinPoint[i%2],iWinPoint[i%2]>0,iWinPoint[i%2]<0,iWinPoint[i%2]==0,true);

			//发送信息
			if (bCloseFlag==GF_SALE)
			{
				for (int i=0;i<m_bMaxPeople;i++) SendGameData(i,&CutEnd,sizeof(CutEnd),MDM_GM_GAME_NOTIFY,ASS_SALE_END,0);
				SendWatchData(m_bMaxPeople,&CutEnd,sizeof(CutEnd),MDM_GM_GAME_NOTIFY,ASS_SALE_END,0);
			}
			else
			{
				for (int i=0;i<m_bMaxPeople;i++) SendGameData(i,&CutEnd,sizeof(CutEnd),MDM_GM_GAME_NOTIFY,ASS_CUT_END,0);
				SendWatchData(m_bMaxPeople,&CutEnd,sizeof(CutEnd),MDM_GM_GAME_NOTIFY,ASS_CUT_END,0);
			}
			break;
		}
	}

	//重置数据
	ReSetGameState(bCloseFlag);
	__super::GameFinish(bDeskStation,bCloseFlag);
	return true;
}

//判断是否正在游戏
bool CServerGameDesk::IsPlayGame(BYTE bDeskStation)
{
	return __super::IsPlayGame(bDeskStation);
}

//游戏数据包处理函数
bool CServerGameDesk::HandleNotifyMessage(BYTE bDeskStation, NetMessageHead * pNetHead, void * pData, UINT uSize, UINT uSocketID, bool bWatchUser)
{
	switch (pNetHead->bAssistantID)
	{
	case ASS_GM_AGREE_GAME:		//用户同意游戏
		{
			if (bWatchUser) return FALSE;
			if ((bDeskStation==0)&&(m_bGameStation==GS_WAIT_SETGAME))	//东家设置
			{
				if (uSize!=sizeof(UserArgeeGame)) return FALSE;
				UserArgeeGame * pGameSet=(UserArgeeGame *)pData;
				if (!UserSetGame(pGameSet)) return FALSE;
				__super::HandleNotifyMessage(bDeskStation,pNetHead,pData,uSize,uSocketID,bWatchUser);
				return TRUE;
			}
			//其他玩家
			if ((m_bGameStation!=GS_WAIT_ARGEE)&&(m_bGameStation!=GS_WAIT_NEXT)) return TRUE;
			return __super::HandleNotifyMessage(bDeskStation,pNetHead,pData,uSize,uSocketID,bWatchUser);
		}
	case ASS_NT_CARD:			//用户反牌消息
		{
			if ((bWatchUser)||(uSize!=sizeof(ClientNtStruct))) return FALSE;
			if (m_bGameStation!=GS_SEND_CARD) return TRUE;
			ClientNtStruct * pNt=(ClientNtStruct *)pData;
			return UserNtCard(bDeskStation,pNt->iHuaKind,pNt->iCardCount);
		}
	case ASS_BACK_CARD:			//用户上交底牌
		{
			if (uSize!=sizeof(BackCardStruct)) return FALSE;
			if (m_bGameStation!=GS_WAIT_BACK) return FALSE;
			BackCardStruct * pBackCard=(BackCardStruct *)pData;
			return UserGiveBackCard(bDeskStation,pBackCard->iBackCard,pBackCard->iBackCardCount);
		}
	case ASS_OUT_CARD:		//用户出牌
		{
			OutCardStruct * pOutCard=(OutCardStruct *)pData;
			if ((uSize<=(sizeof(OutCardStruct)-sizeof(pOutCard->iCardList)))
				||(uSize>sizeof(OutCardStruct))||bWatchUser) return FALSE;
			if (uSize!=(sizeof(OutCardStruct)-sizeof(pOutCard->iCardList)+sizeof(BYTE)*pOutCard->iCardCount)) return FALSE;
			return UserOutCard(bDeskStation,pOutCard->iCardList,pOutCard->iCardCount);
		}
	case ASS_HAVE_THING:	//有事请求离开
		{
			return true;
			//HaveThingStruct * pThing=(HaveThingStruct *)pNetHead;
			//if ((uSize<=(sizeof(HaveThingStruct)-sizeof(pThing->szMessage)))
			//	||(uSize>sizeof(HaveThingStruct))||bWatchUser) return FALSE;
			//if (uSize!=(sizeof(HaveThingStruct)-sizeof(pThing->szMessage)+sizeof(BYTE)*pThing->iMsgLength)) return FALSE;
			//pThing->szMessage[pThing->iMsgLength-1]=0;
			//return UserHaveThing(bDeskStation,pThing->szMessage,pThing->iMsgLength);
		}
	case ASS_LEFT_RESULT: //同意用户离开
		{
			return true;
			//if ((uSize!=sizeof(LeaveResultStruct))||bWatchUser) return FALSE;