#include "StdAfx.h"
#include "LockTimeMatch.h"
#include "..\游戏服务器\DataBasePacket.h"

////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


////////////////////////////////////////////////////////////////////////////////////////////////////////////

#define INVALID_VALUE				0xFFFF								//无效值

//////////////////////////////////////////////////////////////////////////

//时钟定义
#define IDI_DISTRIBUTE_USER		    (IDI_MATCH_MODULE_START+50)			//分配用户

////////////////////////////////////////////////////////////////////////////////////////////////////////////
//构造函数
CLockTimeMatch::CLockTimeMatch()
{
	//状态变量
	m_MatchStatus=MS_NULL;

	//比赛配置
	m_pMatchOption=NULL;
	m_pGameServiceOption=NULL;
	m_pGameServiceAttrib=NULL;

	//内核接口
	m_ppITableFrame=NULL;
	m_pITimerEngine=NULL;
	m_pIDataBaseEngine=NULL;
	m_pITCPNetworkEngineEvent=NULL;

	//服务接口
	m_pIGameServiceFrame=NULL;
	m_pIServerUserManager=NULL;
	m_pAndroidUserManager=NULL;

	m_AllMatchScorePtrMap.clear();
	m_AllMatchScorePtrVector.clear();
}

CLockTimeMatch::~CLockTimeMatch(void)
{
	//释放资源
	SafeDeleteArray(m_ppITableFrame);

	//关闭定时器
	m_pITimerEngine->KillTimer(IDI_CHECK_END_MATCH);
	m_pITimerEngine->KillTimer(IDI_DISTRIBUTE_USER);

	//移除元素
	m_DistributeManage.RemoveAll();

	ReleaseMatchScore();
}

//接口查询
VOID* CLockTimeMatch::QueryInterface(REFGUID Guid, DWORD dwQueryVer)
{	
	QUERYINTERFACE(IGameMatchItem,Guid,dwQueryVer);
	QUERYINTERFACE(IMatchEventSink,Guid,dwQueryVer);
	QUERYINTERFACE(IServerUserItemSink,Guid,dwQueryVer);	
	QUERYINTERFACE_IUNKNOWNEX(IGameMatchItem,Guid,dwQueryVer);
	return NULL;
}

//绑定桌子
bool CLockTimeMatch::BindTableFrame(ITableFrame * pTableFrame,WORD wTableID)
{
	if(pTableFrame==NULL || wTableID>m_pGameServiceOption->wTableCount)
	{
		ASSERT(false);
		return false;
	}

	//创建钩子
	CTableFrameHook * pTableFrameHook=new CTableFrameHook();
	pTableFrameHook->InitTableFrameHook(QUERY_OBJECT_PTR_INTERFACE(pTableFrame,IUnknownEx));
	pTableFrameHook->SetMatchEventSink(QUERY_OBJECT_PTR_INTERFACE(this,IUnknownEx));

	//设置接口
	pTableFrame->SetTableFrameHook(QUERY_OBJECT_PTR_INTERFACE(pTableFrameHook,IUnknownEx));
	m_ppITableFrame[wTableID]=pTableFrame;

	return true;
}

//初始化接口
bool CLockTimeMatch::InitMatchInterface(tagMatchManagerParameter & MatchManagerParameter)
{
	//服务配置
	m_pMatchOption=MatchManagerParameter.pGameMatchOption;
	m_pGameServiceOption=MatchManagerParameter.pGameServiceOption;
	m_pGameServiceAttrib=MatchManagerParameter.pGameServiceAttrib;

	//内核组件
	m_pITimerEngine=MatchManagerParameter.pITimerEngine;
	m_pIDataBaseEngine=MatchManagerParameter.pICorrespondManager;
	m_pITCPNetworkEngineEvent=MatchManagerParameter.pTCPNetworkEngine;

	//服务组件		
	m_pIGameServiceFrame=MatchManagerParameter.pIMainServiceFrame;		
	m_pIServerUserManager=MatchManagerParameter.pIServerUserManager;
	m_pAndroidUserManager=MatchManagerParameter.pIAndroidUserManager;
	m_pIServerUserItemSink=MatchManagerParameter.pIServerUserItemSink;

	//分组设置
	m_DistributeManage.SetDistributeRule(m_pGameServiceOption->cbDistributeRule);

	//创建桌子
	if (m_ppITableFrame==NULL)
	{
		m_ppITableFrame=new ITableFrame*[m_pGameServiceOption->wTableCount];
	}

	//计算场次;
	m_pMatchOption->dwMatchNO = CalcMatchNo();
	if (m_pMatchOption->MatchType.LockTime.dwEndDelayTime == 0)
		m_pMatchOption->MatchType.LockTime.dwEndDelayTime = 600;
	//设置状态;
	m_TimeLastMatch = CTime::GetCurrentTime();

	//开始间隔
	DWORD dwStartInterval = GetMatchStartInterval();
	if(dwStartInterval>0)
	{
		//开始检测;	
		m_pITimerEngine->SetTimer(IDI_CHECK_START_MATCH,dwStartInterval*1000L,TIMES_INFINITY,NULL);
	}
	else
	{
		//提示信息;
		LPCTSTR pszDescribe = TEXT("定局赛时间配置错误!");
		CTraceService::TraceString(pszDescribe, TraceLevel_Warning);
		return false;
	}

	//加载排行耪数据(防止游戏崩溃，这个是崩溃后启动用的);
	m_pITimerEngine->SetTimer(IDI_LOAD_RANKDATA, 10000L, 1, NULL);

	return true;
}

//时间事件
bool CLockTimeMatch::OnEventTimer(DWORD dwTimerID, WPARAM dwBindParameter)
{	
	switch(dwTimerID)
	{
	case IDI_DISTRIBUTE_USER:				//分配用户
		{
			//执行分组
			PerformDistribute();

			return true;
		}
	case IDI_CHECK_START_MATCH:				//开始比赛
		{
			//变量定义;
			BYTE cbMatchStatus = m_MatchStatus;

			//更新状态;
			UpdateMatchStatus();

			//等待比赛;
			if (m_MatchStatus == MS_WAITPLAY)
			{
				m_pITimerEngine->SetTimer(IDI_CHECK_START_MATCH, 2000L, TIMES_INFINITY, NULL);

				if (cbMatchStatus != m_MatchStatus)
				{
					m_pIGameServiceFrame->SendData(BG_COMPUTER, MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &m_MatchStatus, sizeof(m_MatchStatus));
					SendMatchInfo(NULL);
				}
			}
			//比赛开始;
			else if (m_MatchStatus == MS_MATCHING)
			{
				//关闭定时器;
				m_pITimerEngine->KillTimer(IDI_CHECK_START_MATCH);

				//检测比赛结束;
				m_pITimerEngine->SetTimer(IDI_CHECK_END_MATCH, 5000, TIMES_INFINITY, 0);

				//执行分组;
				m_pITimerEngine->SetTimer(IDI_DISTRIBUTE_USER, m_pGameServiceOption->wDistributeTimeSpace * 1000, TIMES_INFINITY, NULL);

				//发送状态;
				m_pIGameServiceFrame->SendData(BG_ALL_CLIENT, MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &m_MatchStatus, sizeof(m_MatchStatus));


				//变量定义;
				DBR_GR_MatchStart MatchStart;

				//构造结构;
				MatchStart.dwMatchID = m_pMatchOption->dwMatchID;
				MatchStart.dwMatchNO = m_pMatchOption->dwMatchNO;
				MatchStart.cbMatchType = m_pMatchOption->cbMatchType;
				MatchStart.wServerID = m_pGameServiceOption->wServerID;

				//投递请求;
				m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_MATCH_START, 0, &MatchStart, sizeof(MatchStart));

				//SendMatchInfo(NULL);
			}

			return true;
		}
	case IDI_CHECK_END_MATCH:				//结束比赛
		{
			//变量定义
			BYTE cbMatchStatus = m_MatchStatus;

			//更新状态;
			UpdateMatchStatus();

			//比赛结束
			if (m_MatchStatus == MS_WAITEND)
			{
				if (cbMatchStatus != MS_WAITEND)
				{
					//发送状态
					BYTE cbMatchStatus = MS_WAITEND;
					m_pIGameServiceFrame->SendData(BG_ALL_CLIENT, MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &cbMatchStatus, sizeof(cbMatchStatus));

					//获取时间
					CTime CurTime = CTime::GetCurrentTime();
					CTime MatchEndTime(m_pMatchOption->MatchType.LockTime.MatchEndTime);

					//比赛结束
					bool bMatchOver = (CurTime >= MatchEndTime);

					//变量定义;
					WORD wUserIndex = 0;
					TCHAR szMessage[128];
					IServerUserItem *pIServerUserItem = NULL;
					DWORD dwEndDelayMinutes = m_pMatchOption->MatchType.LockTime.dwEndDelayTime / 60;

					do
					{
						pIServerUserItem = m_pIServerUserManager->EnumUserItem(wUserIndex++);
						if (pIServerUserItem == NULL)
						{
							break;
						}

						//比赛中用户;
						if (pIServerUserItem->GetUserStatus() == US_PLAYING)
						{
							if (bMatchOver == false)
							{
								_sntprintf(szMessage, CountArray(szMessage), TEXT("今天的比赛结束时间已到，请尽快在 %d 分钟内结束本局游戏。"), dwEndDelayMinutes);
								//m_pIGameServiceFrame->SendGameMessage(pIServerUserItem, szMessage, SMT_CHAT | SMT_GLOBAL);
								m_pIGameServiceFrame->SendGameMessage(pIServerUserItem, szMessage, SMT_TABLE_ROLL);
							}
							else
							{
								_sntprintf(szMessage, CountArray(szMessage), TEXT("本场比赛结束时间已到，请尽快在 %d 分钟内结束当前比赛。否则系统将会自动解散本回合并不计入成绩。"), dwEndDelayMinutes);
								//m_pIGameServiceFrame->SendGameMessage(pIServerUserItem, szMessage, SMT_CHAT | SMT_GLOBAL);
								m_pIGameServiceFrame->SendGameMessage(pIServerUserItem, szMessage, SMT_TABLE_ROLL);
							}
						}
						else
						{
							if (bMatchOver == false)
							{
								_sntprintf(szMessage, CountArray(szMessage), TEXT("今天的比赛到此结束，请您明天再来参加！"));
								m_pIGameServiceFrame->SendGameMessage(pIServerUserItem, szMessage, SMT_CHAT | SMT_EJECT | SMT_GLOBAL | SMT_CLOSE_GAME);
							}
							else
							{
								//发送结束消息;
								_sntprintf(szMessage, CountArray(szMessage), TEXT("本场比赛结束时间已到，感谢您的参与；请在 %d 分钟后前往相关页面查询您的本场比赛成绩。"), dwEndDelayMinutes);
								m_pIGameServiceFrame->SendGameMessage(pIServerUserItem, szMessage, SMT_CHAT | SMT_EJECT | SMT_GLOBAL | SMT_CLOSE_GAME);
							}
						}

					} while (true);
				}
			}

			//比赛完成
			if (m_MatchStatus == MS_MATCHEND)
			{
				//关闭定时器
				m_pITimerEngine->KillTimer(IDI_CHECK_END_MATCH);
				m_pITimerEngine->KillTimer(IDI_DISTRIBUTE_USER);	

				//发送状态
				BYTE cbMatchStatus=MS_MATCHEND;
				m_pIGameServiceFrame->SendData(BG_ALL_CLIENT,MDM_GR_MATCH,SUB_GR_MATCH_STATUS,&cbMatchStatus,sizeof(cbMatchStatus));

				//解散游戏;
				for(INT i=0; i<m_pGameServiceOption->wTableCount; i++)
				{
					//获取对象;
					ITableFrame * pITableFrame=m_ppITableFrame[i];					
					ASSERT(pITableFrame!=NULL);
					if (pITableFrame==NULL) continue;

					//解散游戏;
					if(pITableFrame->IsGameStarted())
					{
						pITableFrame->DismissGame();
					}
					//执行起立;
					PerformAllUserStandUp(pITableFrame);
				}

				//移除所有玩家;
				m_DistributeManage.RemoveAll();

				//获取时间
				CTime CurTime = CTime::GetCurrentTime();
				CTime MatchEndTime(m_pMatchOption->MatchType.LockTime.MatchEndTime);
				//比赛结束
				if( IsRoundMatchMode() || CurTime >= MatchEndTime)
				{
					//比赛结束;
					DBR_GR_MatchOver MatchOver;
					ZeroMemory(&MatchOver,sizeof(MatchOver));

					//构造数据;				
					MatchOver.cbMatchType=MATCH_TYPE_LOCKTIME;
					MatchOver.dwMatchID=m_pMatchOption->dwMatchID;
					MatchOver.dwMatchNO=m_pMatchOption->dwMatchNO;
					MatchOver.wServerID=m_pGameServiceOption->wServerID;
					MatchOver.wPlayCount = m_pMatchOption->MatchType.LockTime.wMatchPlayCount;
					MatchOver.bMatchFinish = (CurTime >= MatchEndTime) ? TRUE : FALSE;

					//常规开赛;
					if (IsNormalMatchMode())
					{
						MatchOver.MatchEndTime		= m_pMatchOption->MatchType.LockTime.MatchEndTime;
						MatchOver.MatchStartTime	= m_pMatchOption->MatchType.LockTime.MatchStartTime;
					}

					//循环开赛;
					if (IsRoundMatchMode())
					{
						//变量定义;
						SYSTEMTIME SystemTimeCurr;
						CurTime.GetAsSystemTime(SystemTimeCurr);

						//设置时间;
						SystemTimeCurr.wHour	= m_pMatchOption->MatchType.LockTime.MatchStartTime.wHour;
						SystemTimeCurr.wMinute	= m_pMatchOption->MatchType.LockTime.MatchStartTime.wMinute;
						SystemTimeCurr.wSecond	= m_pMatchOption->MatchType.LockTime.MatchStartTime.wSecond;

						//开始时间;
						MatchOver.MatchStartTime = SystemTimeCurr;

						//设置时间;
						SystemTimeCurr.wHour	= m_pMatchOption->MatchType.LockTime.MatchEndTime.wHour;
						SystemTimeCurr.wMinute	= m_pMatchOption->MatchType.LockTime.MatchEndTime.wMinute;
						SystemTimeCurr.wSecond	= m_pMatchOption->MatchType.LockTime.MatchEndTime.wSecond;

						//结束时间;
						MatchOver.MatchEndTime = SystemTimeCurr;
					}

					//投递请求;
					m_pIDataBaseEngine->PostDataBaseRequest(0,DBR_GR_MATCH_OVER,0,&MatchOver,sizeof(MatchOver));
					
					//切换时钟;
					if (IsRoundMatchMode() && CurTime < MatchEndTime)
					{
						//发送结束消息;
						TCHAR szMessage[128] = TEXT("今天的比赛到此结束，请您明天再来参加！");
						m_pIGameServiceFrame->SendGameMessage(szMessage, SMT_CHAT | SMT_EJECT | SMT_GLOBAL | SMT_CLOSE_GAME);

						//切换状态;
						m_pITimerEngine->SetTimer(IDI_SWITCH_STATUS, 2000, TIMES_INFINITY, NULL);
					}

					return true;
				}
			}
			return true;
		}
	case IDI_SWITCH_STATUS:
		{
			//判断状态;
			if (m_MatchStatus != MS_MATCHEND)	return true;
			if (!IsRoundMatchMode())				return true;
			//判断日期;
			CTime curTime = CTime::GetCurrentTime();

			if (m_TimeLastMatch.GetDay() == curTime.GetDay())	return true;

			//计算场次;
			m_pMatchOption->dwMatchNO = CalcMatchNo();

			//设置变量;
			m_MatchStatus	= MS_NULL;
			m_TimeLastMatch = curTime;

			//比赛检测;
			DWORD dwStartInterval = GetMatchStartInterval();
			if (dwStartInterval > 0)
			{
				m_pITimerEngine->SetTimer(IDI_CHECK_START_MATCH, dwStartInterval * 1000L, TIMES_INFINITY, NULL);
			}

			//关闭定时器;
			m_pITimerEngine->KillTimer(IDI_SWITCH_STATUS);

			//发送状态;
			BYTE cbMatchStatus = MS_NULL;
			m_pIGameServiceFrame->SendData(BG_COMPUTER, MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &cbMatchStatus, sizeof(cbMatchStatus));

			return true;
		}
	case IDI_LOAD_RANKDATA:
		{
			DBR_GR_MatchLoadRankData loadRankData;
			ZeroMemory(&loadRankData, sizeof(DBR_GR_MatchLoadRankData));

			loadRankData.dwMatchID = m_pMatchOption->dwMatchID;
			loadRankData.dwMatchNO = m_pMatchOption->dwMatchNO;

			//投递请求;
			m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_MATCH_LOADRANKDATA, 0, &loadRankData, sizeof(loadRankData));
		}
	}
	return true;
}

//数据库事件
bool CLockTimeMatch::OnEventDataBase(WORD wRequestID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{
	switch(wRequestID)
	{
	case DBO_GR_MATCH_SIGNUP_RESULT:		//报名结果;
	{
		//参数效验;
		if (pIServerUserItem == NULL) return true;
		if (wDataSize > sizeof(DBO_GR_MatchSingupResult)) return false;

		//提取数据;
		DBO_GR_MatchSingupResult * pMatchSignupResult = (DBO_GR_MatchSingupResult*)pData;

		//报名失败;
		if (pMatchSignupResult->bResultCode == false)
		{
			//提示消息不为空;
			if (pMatchSignupResult->szDescribeString[0] != '\0')
			{
				//m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, pMatchSignupResult->szDescribeString, SMT_EJECT);
				SendMatchJoinResult(pIServerUserItem, 0, pMatchSignupResult->szDescribeString);
			}

			return true;
		}

		//报名成功;
		//if (m_MatchStatus == MS_NULL)
		//{
		//	//消息通知;
		//	m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("恭喜您，报名成功，请届时前来参加比赛！"), SMT_CHAT);
		//}
		//else
		//{
		//	//加入分组;
		//	if (InsertDistribute(pIServerUserItem) == false) return true;

		//	//发送分数;
		//	SendMatchUserInitScore(pIServerUserItem);

		//	//发送消息;
		//	m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("系统正在努力为您分配座位，请稍后。。。"), SMT_CHAT);

		//	SendMatchInfo(NULL);
		//}

		//发送分数;
		SendMatchUserInitScore(pIServerUserItem);

		pIServerUserItem->SetUserMatchStatus(MUS_SIGNUP);

		if (pIServerUserItem->IsAndroidUser() == false)
		{
			//构造结构;
			CMD_GR_MatchGoldUpdate MatchGoldUpdate;

			//设置变量;
			MatchGoldUpdate.lCurrGold = pMatchSignupResult->lCurrGold;
			MatchGoldUpdate.lCurrIngot = pMatchSignupResult->lCurrIngot;

			//发送数据;
			m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_GOLDUPDATE, &MatchGoldUpdate, sizeof(MatchGoldUpdate));
		}

		if (m_MatchStatus == MS_NULL)
		{
			SendMatchJoinResult(pIServerUserItem, 2, TEXT("恭喜您，报名成功，请届时前来参加比赛！"));
		}
		else
		{
			SendMatchJoinResult(pIServerUserItem, 1, TEXT("系统正在努力为您分配座位，请稍后。。。"));
		}

		tagMatchScore* pMatchScore = FindMatchScore(pIServerUserItem);
		if (NULL != pMatchScore)
		{
			pMatchScore->pUserItem = pIServerUserItem;
		}
		else
		{
			InsertAllMatchScoreMap(pIServerUserItem);
		}

		SendMatchWaitTip(pIServerUserItem);

		break;
	}
	case DBO_GR_MATCH_RANK_LIST:			//比赛排行
		{
			//参数校验
			ASSERT(wDataSize<=sizeof(DBO_GR_MatchRankList));
			if(wDataSize>sizeof(DBO_GR_MatchRankList)) return false;

			//提取数据
			DBO_GR_MatchRankList * pMatchRankList = (DBO_GR_MatchRankList*)pData;

			//变量定义
			bool bRewardUser=true;
			tagMatchRankInfo * pMatchRankInfo=NULL;
			IServerUserItem * pIRewardUserItem=NULL;

			//发放奖励
			for(WORD wIndex=0;wIndex<pMatchRankList->wUserCount;wIndex++)
			{
				//查找玩家
				pMatchRankInfo=&pMatchRankList->MatchRankInfo[wIndex];
				pIRewardUserItem=m_pIServerUserManager->SearchUserItem(pMatchRankInfo->dwUserID);
				if (pIRewardUserItem!=NULL && pIRewardUserItem->IsAndroidUser()==true) continue;

				//写入奖励
				WriteUserAward(pIRewardUserItem,pMatchRankInfo);

				//设置标识
				if (pIRewardUserItem)
					pIRewardUserItem->SetMatchData(&bRewardUser);
			}

			//在线用户
			WORD wUserIndex=0;			
			while (true)
			{
				pIRewardUserItem=m_pIServerUserManager->EnumUserItem(wUserIndex++);
				if (pIRewardUserItem==NULL) break;
				if (pIRewardUserItem->IsAndroidUser()==true) continue;
				if (pIRewardUserItem->GetMatchData()==&bRewardUser)
				{
					pIRewardUserItem->SetMatchData(NULL);
					continue;
				}

				//发送结束消息
				TCHAR szMessage[128]=TEXT("本次比赛到此结束，请您前往网站查看系统排名或移驾其他比赛房间参与比赛！");
				m_pIGameServiceFrame->SendGameMessage(pIRewardUserItem,szMessage,SMT_CHAT|SMT_EJECT|SMT_GLOBAL|SMT_CLOSE_GAME);	
			}			

			break;
		}
	case DBO_GR_MATCH_REWARD_RESULT:	//奖励结果
		{
			//参数效验
			if(pIServerUserItem==NULL) return true;
			if(wDataSize>sizeof(DBR_GR_MatchRewardResult)) return false;

			//提取数据
			DBR_GR_MatchRewardResult * pMatchRewardResult = (DBR_GR_MatchRewardResult*)pData;

			//奖励成功
			if(pMatchRewardResult->bResultCode==true)
			{
				//构造结构
				CMD_GR_MatchGoldUpdate MatchGoldUpdate;

				//设置变量
				MatchGoldUpdate.lCurrGold=pMatchRewardResult->lCurrGold;
				MatchGoldUpdate.lCurrIngot=pMatchRewardResult->lCurrIngot;
				MatchGoldUpdate.dwCurrExprience=pMatchRewardResult->dwCurrExperience;
				MatchGoldUpdate.lInsureSocre = pMatchRewardResult->lInsureSocre;

				//发送数据
				m_pIGameServiceFrame->SendData(pIServerUserItem,MDM_GR_MATCH,SUB_GR_MATCH_GOLDUPDATE,&MatchGoldUpdate,sizeof(MatchGoldUpdate));
			}

			break;
		}
	case DBO_GR_MATCH_RANKDATA_LIST:
		{
			//参数校验;
			ASSERT(wDataSize <= sizeof(DBO_GR_MatchRankDataList));
			int nSize = sizeof(DBO_GR_MatchRankDataList);
			if (wDataSize > sizeof(DBO_GR_MatchRankDataList)) return false;

			//提取数据
			DBO_GR_MatchRankDataList * pMatchRankDataList = (DBO_GR_MatchRankDataList*)pData;

			//变量定义;
			tagMatchRankDataInfo * pMatchRankDataInfo = NULL;

			for (WORD wIndex = 0; wIndex < pMatchRankDataList->wUserCount; wIndex++)
			{
				//查找玩家;
				pMatchRankDataInfo = &pMatchRankDataList->MatchRankInfo[wIndex];
				InsertAllMatchScoreMap(pMatchRankDataInfo);
			}
			break;
		}
	}
	return true;
}

//比赛事件
bool CLockTimeMatch::OnEventSocketMatch(WORD wSubCmdID, VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)
{
	switch (wSubCmdID)
	{
		case SUB_GR_MATCH_FEE:  //比赛费用
		{
			//参数效验
			ASSERT(wDataSize == sizeof(CMD_GR_C_Match_Fee));
			if (wDataSize != sizeof(CMD_GR_C_Match_Fee)) return false;

			//提取数据
			CMD_GR_C_Match_Fee* pMatchFee = (CMD_GR_C_Match_Fee*)pData;
			if (pMatchFee->dwChannelID != 0 && pMatchFee->dwChannelID != m_pMatchOption->MatchType.LockTime.dwChannelID)
			{	//渠道ID不对;
				//m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("渠道ID错误"), SMT_EJECT);
				SendMatchJoinResult(pIServerUserItem, 0, TEXT("渠道ID错误"));
				return false;//先设置成false客户端短线重现链接;
				//return true;
			}
			if (pMatchFee->dwInviteCode != 0 && pMatchFee->dwInviteCode != m_pMatchOption->MatchType.LockTime.dwInviteCode)
			{	//邀请码不对;
				//m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("邀请码错误"), SMT_EJECT);
				SendMatchJoinResult(pIServerUserItem, 0, TEXT("邀请码错误"));
				return false;//先设置成false客户端短线重现链接;
				//return true;
			}

			//判断时间;
			TCHAR szDescribe[256];
			WORD wMessageType;
			if (VerifySignupMatchTime(szDescribe, CountArray(szDescribe), wMessageType) == false)
			{
				SendMatchJoinResult(pIServerUserItem, 0, szDescribe);
				return true;
			}

			//变量定义;
			DBR_GR_MatchSignup MatchSignup;
			ZeroMemory(&MatchSignup, sizeof(MatchSignup));

			//构造结构
			MatchSignup.dwUserID		= pIServerUserItem->GetUserID();
			MatchSignup.lMatchFee		= m_pMatchOption->lMatchFee;
			MatchSignup.dwInoutIndex	= pIServerUserItem->GetInoutIndex();
			MatchSignup.dwClientAddr	= pIServerUserItem->GetClientAddr();
			MatchSignup.dwMatchID		= m_pMatchOption->dwMatchID;
			MatchSignup.dwMatchNO		= m_pMatchOption->dwMatchNO;
			MatchSignup.cbMatchType		= m_pMatchOption->cbMatchType;

			//拷贝机器码
			lstrcpyn(MatchSignup.szMachineID, pIServerUserItem->GetMachineID(), CountArray(MatchSignup.szMachineID));

			//投递数据
			m_pIDataBaseEngine->PostDataBaseRequest(MatchSignup.dwUserID, DBR_GR_MATCH_SIGNUP, dwSocketID, &MatchSignup, sizeof(MatchSignup));

			return true;
		}
		case SUB_GR_LEAVE_MATCH:  //退出比赛;
		{
			//参数效验
			ASSERT(pIServerUserItem != NULL);
			if (pIServerUserItem == NULL)
			{
				return false;
			}

			OnEventUserQuitMatch(pIServerUserItem, UNSIGNUP_REASON_PLAYER, 0, dwSocketID);

			return true;
		}
		case SUB_GR_MATCH_CONTINUE:
		{
			//参数效验;
			ASSERT(pIServerUserItem != NULL);
			if (pIServerUserItem == NULL)
			{
				return false;
			}
			OnEventUserJoinMatch(pIServerUserItem, 1, dwSocketID);
			return true;
		}
	}
	return true;
}
//用户积分
bool CLockTimeMatch::OnEventUserItemScore(IServerUserItem * pIServerUserItem, BYTE cbReason)
{
	//效验参数
	ASSERT(pIServerUserItem!=NULL);
	if (pIServerUserItem==NULL) return false;

	//变量定义
	CMD_GR_UserScore UserScore;
	tagUserInfo * pUserInfo=pIServerUserItem->GetUserInfo();

	//构造数据
	UserScore.dwUserID=pUserInfo->dwUserID;
	UserScore.UserScore.dwWinCount=pUserInfo->dwWinCount;
	UserScore.UserScore.dwLostCount=pUserInfo->dwLostCount;
	UserScore.UserScore.dwDrawCount=pUserInfo->dwDrawCount;
	UserScore.UserScore.dwFleeCount=pUserInfo->dwFleeCount;	
	UserScore.UserScore.dwExperience=pUserInfo->dwExperience;
	UserScore.UserScore.lLoveLiness=pUserInfo->lLoveLiness;

	//构造积分
	UserScore.UserScore.lGrade=pUserInfo->lGrade;
	UserScore.UserScore.lInsure=pUserInfo->lInsure;

	//构造积分
	UserScore.UserScore.lScore=pUserInfo->lScore;
	UserScore.UserScore.lScore+=pIServerUserItem->GetTrusteeScore();
	UserScore.UserScore.lScore+=pIServerUserItem->GetFrozenedScore();

	//发送数据
	m_pIGameServiceFrame->SendData(BG_COMPUTER,MDM_GR_USER,SUB_GR_USER_SCORE,&UserScore,sizeof(UserScore));

	//积分倍数同步;
	CMD_GF_S_ScoreMultiple ScoreMultiple;
	ZeroMemory(&ScoreMultiple, sizeof(ScoreMultiple));
	ScoreMultiple.dwUserID = pUserInfo->dwUserID;
	ScoreMultiple.cbScoreMultiple = pUserInfo->cbScoreMultiple;
	m_pIGameServiceFrame->SendData(BG_COMPUTER, MDM_GR_USER, SUB_GR_USER_SCOREMULTIPLE, &ScoreMultiple, sizeof(ScoreMultiple));

	//变量定义
	CMD_GR_MobileUserScore MobileUserScore;

	//构造数据
	MobileUserScore.dwUserID=pUserInfo->dwUserID;
	MobileUserScore.UserScore.dwWinCount=pUserInfo->dwWinCount;
	MobileUserScore.UserScore.dwLostCount=pUserInfo->dwLostCount;
	MobileUserScore.UserScore.dwDrawCount=pUserInfo->dwDrawCount;
	MobileUserScore.UserScore.dwFleeCount=pUserInfo->dwFleeCount;
	MobileUserScore.UserScore.dwExperience=pUserInfo->dwExperience;

	//构造积分
	MobileUserScore.UserScore.lScore=pUserInfo->lScore;
	MobileUserScore.UserScore.lScore+=pIServerUserItem->GetTrusteeScore();
	MobileUserScore.UserScore.lScore+=pIServerUserItem->GetFrozenedScore();

	//发送数据
	m_pIGameServiceFrame->SendDataBatchToMobileUser(pIServerUserItem->GetTableID(),MDM_GR_USER,SUB_GR_USER_SCORE,&MobileUserScore,sizeof(MobileUserScore));

	//即时写分
	if ((CServerRule::IsImmediateWriteScore(m_pGameServiceOption->dwServerRule)==true)&&(pIServerUserItem->IsVariation()==true))
	{
		//变量定义
		DBR_GR_WriteGameScore WriteGameScore;
		ZeroMemory(&WriteGameScore,sizeof(WriteGameScore));

		//用户信息
		WriteGameScore.dwUserID=pIServerUserItem->GetUserID();
		WriteGameScore.dwDBQuestID=pIServerUserItem->GetDBQuestID();
		WriteGameScore.dwClientAddr=pIServerUserItem->GetClientAddr();
		WriteGameScore.dwInoutIndex=pIServerUserItem->GetInoutIndex();

		//提取积分
		pIServerUserItem->DistillVariation(WriteGameScore.VariationInfo);

		//比赛信息
		WriteGameScore.dwMatchID=m_pMatchOption->dwMatchID;
		WriteGameScore.dwMatchNO=m_pMatchOption->dwMatchNO;

		//投递请求
		m_pIDataBaseEngine->PostDataBaseRequest(WriteGameScore.dwUserID,DBR_GR_WRITE_GAME_SCORE,0L,&WriteGameScore,sizeof(WriteGameScore), TRUE);
	}

	return true;
}

//用户状态
bool CLockTimeMatch::OnEventUserItemStatus(IServerUserItem * pIServerUserItem, WORD wOldTableID, WORD wOldChairID)
{
	if(m_pIServerUserItemSink!=NULL)
	{
		return m_pIServerUserItemSink->OnEventUserItemStatus(pIServerUserItem,wOldTableID,wOldChairID);
	}

	return true;
}

//用户权限
bool CLockTimeMatch::OnEventUserItemRight(IServerUserItem *pIServerUserItem, DWORD dwAddRight, DWORD dwRemoveRight,bool bGameRight)
{
	if(m_pIServerUserItemSink!=NULL)
	{
		return m_pIServerUserItemSink->OnEventUserItemRight(pIServerUserItem,dwAddRight,dwRemoveRight,bGameRight);
	}

	return true;
}

//用户登录
bool CLockTimeMatch::OnEventUserLogon(IServerUserItem * pIServerUserItem)
{
	//发送状态
	if(m_MatchStatus>MS_NULL)
	{
		//发送状态
		m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &m_MatchStatus, sizeof(m_MatchStatus));

		SendMatchInfo(NULL);
	}

	SendTableUserMatchInfo(pIServerUserItem);

	return true;
}

//用户登出
bool CLockTimeMatch::OnEventUserLogout(IServerUserItem * pIServerUserItem)
{
	//构造结构
	SendMatchInfo(NULL);
	return true;
}

//进入事件
bool CLockTimeMatch::OnEventEnterMatch(DWORD dwSocketID ,VOID* pData,DWORD dwUserIP, bool bIsMobile)
{
	//判断时间
	TCHAR szDescribe[256];
	WORD wMessageType;
	if (VerifyMatchTime(szDescribe,CountArray(szDescribe),wMessageType)==false)
	{
		m_pIGameServiceFrame->SendRoomMessage(dwSocketID,szDescribe,wMessageType|SMT_GLOBAL,dwUserIP==0);
		return true;
	}

	//手机用户
	if(bIsMobile == true)
	{
		//处理消息
		CMD_GR_LogonMobile * pLogonMobile=(CMD_GR_LogonMobile *)pData;
		pLogonMobile->szPassword[CountArray(pLogonMobile->szPassword)-1]=0;
		pLogonMobile->szMachineID[CountArray(pLogonMobile->szMachineID)-1]=0;

		//变量定义
		DBR_GR_LogonMobile LogonMobile;
		ZeroMemory(&LogonMobile,sizeof(LogonMobile));

		//构造数据
		LogonMobile.dwUserID=pLogonMobile->dwUserID;
		LogonMobile.dwClientAddr=dwUserIP;		
		LogonMobile.dwMatchID=m_pMatchOption->dwMatchID;	
		LogonMobile.dwMatchNO=m_pMatchOption->dwMatchNO;
		LogonMobile.cbDeviceType=pLogonMobile->cbDeviceType;
		LogonMobile.wBehaviorFlags=pLogonMobile->wBehaviorFlags;
		LogonMobile.wPageTableCount=pLogonMobile->wPageTableCount;		
		lstrcpyn(LogonMobile.szPassword,pLogonMobile->szPassword,CountArray(LogonMobile.szPassword));
		lstrcpyn(LogonMobile.szMachineID,pLogonMobile->szMachineID,CountArray(LogonMobile.szMachineID));

		//投递请求
		m_pIDataBaseEngine->PostDataBaseRequest(LogonMobile.dwUserID,DBR_GR_LOGON_MOBILE,dwSocketID,&LogonMobile,sizeof(LogonMobile));
	}
	else
	{
		//处理消息
		CMD_GR_LogonUserID * pLogonUserID=(CMD_GR_LogonUserID *)pData;
		pLogonUserID->szPassword[CountArray(pLogonUserID->szPassword)-1]=0;
		pLogonUserID->szMachineID[CountArray(pLogonUserID->szMachineID)-1]=0;

		//变量定义
		DBR_GR_LogonUserID LogonUserID;
		ZeroMemory(&LogonUserID,sizeof(LogonUserID));

		//构造数据
		LogonUserID.dwClientAddr=dwUserIP;
		LogonUserID.dwUserID=pLogonUserID->dwUserID;
		LogonUserID.dwMatchID=m_pMatchOption->dwMatchID;	
		LogonUserID.dwMatchNO=m_pMatchOption->dwMatchNO;	
		lstrcpyn(LogonUserID.szPassword,pLogonUserID->szPassword,CountArray(LogonUserID.szPassword));
		lstrcpyn(LogonUserID.szMachineID,pLogonUserID->szMachineID,CountArray(LogonUserID.szMachineID));

		//投递请求
		m_pIDataBaseEngine->PostDataBaseRequest(LogonUserID.dwUserID,DBR_GR_LOGON_USERID,dwSocketID,&LogonUserID,sizeof(LogonUserID));
	}

	return true;
}

//用户参赛
bool CLockTimeMatch::OnEventUserJoinMatch(IServerUserItem * pIServerUserItem, BYTE cbReason,DWORD dwSocketID)
{
	//参数校验
	ASSERT(pIServerUserItem!=NULL);
	if (pIServerUserItem == NULL) return false;

	//判断状态
	if(pIServerUserItem->GetUserStatus()!=US_FREE || pIServerUserItem->GetTableID()!=INVALID_TABLE)
	{
		return false;
	}

	//比赛未开始
	if(m_MatchStatus==MS_NULL)
	{
		//发送消息
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,TEXT("比赛尚未开始，请稍后再来！"),SMT_EJECT);

		return true;
	}

	//比赛结束
	if(m_MatchStatus==MS_MATCHEND)
	{
		//发送消息
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,TEXT("比赛已经结束，请您移驾至其他比赛房间参与比赛！"),SMT_EJECT);
		return true;
	}

	//加入分组
	if(InsertDistribute(pIServerUserItem)==false) return false;
	
	//设置等待分配状态;
	pIServerUserItem->SetUserStatus(US_WAITDISTRIBUTE);

	//发送成绩
	SendMatchUserScore(pIServerUserItem);

	//发送消息;
	m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, TEXT("系统正在努力为您分配座位，请稍后。。。"), SMT_TABLE_ROLL);
	//发送通知;
	m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GF_FRAME, SUB_GF_WAIT_DISTRIBUTE, NULL, 0);

	if (!pIServerUserItem->IsAndroidUser())
	{
		SendMatchInfo(NULL);
		//SendTableUserMatchInfo(pIServerUserItem);
	}

	//上线后从新赋值;
	tagMatchScore* pMatchScore = FindMatchScore(pIServerUserItem);
	if (NULL != pMatchScore)
	{	
		pMatchScore->pUserItem = pIServerUserItem;
	}
	else
	{
		InsertAllMatchScoreMap(pIServerUserItem);
	}

	return true;
}

//用户退赛
bool CLockTimeMatch::OnEventUserQuitMatch(IServerUserItem * pIServerUserItem, BYTE cbReason, WORD *pBestRank, DWORD dwContextID)
{
	ASSERT(pIServerUserItem!=NULL);
	if (pIServerUserItem==NULL) return false;

	//正在游戏状态;
	if (pIServerUserItem->GetUserStatus() >= US_PLAYING)
	{
		return true;
	}
	//正在比赛阶段;
	BYTE cbUserEnlist = pIServerUserItem->GetUserMatchStatus();
	if (cbUserEnlist == MS_MATCHING)
	{
		return true;
	}

	//移除分组
	m_DistributeManage.RemoveDistributeNode(pIServerUserItem);

	//移除同桌信息
	m_DistributeManage.RemoveUserSameTableInfo(pIServerUserItem->GetUserID());

	return true;
}

//游戏开始
bool CLockTimeMatch::OnEventGameStart(ITableFrame *pITableFrame, WORD wChairCount)
{
	//发送比赛信息
	SendTableUserMatchInfo(pITableFrame, INVALID_CHAIR);

	//构造数据包
	CMD_CM_SystemMessage SystemMessage;
	ZeroMemory(&SystemMessage,sizeof(SystemMessage));

	//变量定义
	IServerUserItem *pIServerUserItem=NULL;
	IServerUserItem *pITableUserItem=NULL;	

	for (INT i=0; i<pITableFrame->GetChairCount(); i++)
	{
		pIServerUserItem=pITableFrame->GetTableUserItem(i);
		ASSERT(pIServerUserItem!=NULL);
		if (pIServerUserItem==NULL) continue;

		//构造提示消息
		TCHAR szMessage[64]=TEXT("");
		_sntprintf_s(szMessage, CountArray(szMessage),TEXT("本局比赛是您的第 %d 局。"),pIServerUserItem->GetUserPlayCount()+1);
		lstrcpyn(SystemMessage.szString,szMessage,CountArray(SystemMessage.szString));
		SystemMessage.wLength=CountStringBuffer(SystemMessage.szString);
		SystemMessage.wType=SMT_CHAT;

		//发送提示数据
		WORD wSendSize=sizeof(SystemMessage)-sizeof(SystemMessage.szString)+SystemMessage.wLength*sizeof(TCHAR);
		pITableFrame->SendTableData(pIServerUserItem->GetChairID(),SUB_GF_SYSTEM_MESSAGE, &SystemMessage,wSendSize,MDM_GF_FRAME);

		pIServerUserItem->SetUserMatchStatus(MUS_MATCHING);

		//清除同桌
		ClearSameTableUser(pIServerUserItem->GetUserID());

		for (INT j=0; j<pITableFrame->GetChairCount(); j++)
		{
			//获取用户
			pITableUserItem=pITableFrame->GetTableUserItem(j);
			if(pITableUserItem==NULL) continue;
			if(pITableUserItem==pIServerUserItem) continue;

			//插入同桌用户
			InserSameTableUser(pIServerUserItem->GetUserID(),pITableUserItem->GetUserID());
		}
	}

	return true;
}

//游戏结束
bool CLockTimeMatch::OnEventGameEnd(ITableFrame *pITableFrame,WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason)
{
	ASSERT(pITableFrame!=NULL);
	if (pITableFrame==NULL) return false;

	vector<BYTE> cbFinishVec;
	//结束处理;
	WORD wChairCount = pITableFrame->GetChairCount();
	for (WORD i = 0; i<wChairCount; i++)
	{
		cbFinishVec.push_back(0);	//先插入false标志;

		IServerUserItem *pIUserItem=pITableFrame->GetTableUserItem(i);
		ASSERT(pIUserItem!=NULL);
		if (pIUserItem==NULL) continue;

		//正常结束;
		if(cbReason!=REMOVE_BY_ENDMATCH)
		{
			//达到淘汰线
			if (m_pMatchOption->MatchType.LockTime.lMatchCullScore>0 && pIUserItem->GetUserScore()<m_pMatchOption->MatchType.LockTime.lMatchCullScore)
			{
				//变量定义
				TCHAR szMessage[128]=TEXT("");
				_sntprintf_s(szMessage,CountArray(szMessage),TEXT("由于您的比赛币低于 %d，您将不能继续游戏！"),m_pMatchOption->MatchType.LockTime.lMatchCullScore);

				//发送消息
				m_pIGameServiceFrame->SendGameMessage(pIUserItem,szMessage,SMT_EJECT|SMT_CHAT);

				//构造结构
				DBR_GR_MatchEliminate MatchEliminate;
				MatchEliminate.cbMatchType=MATCH_TYPE_LOCKTIME;
				MatchEliminate.dwMatchID=m_pMatchOption->dwMatchID;
				MatchEliminate.dwMatchNO=m_pMatchOption->dwMatchNO;
				MatchEliminate.dwUserID=pIUserItem->GetUserID();

				//投递请求
				m_pIDataBaseEngine->PostDataBaseRequest(0,DBR_GR_MATCH_ELIMINATE,0,&MatchEliminate,sizeof(MatchEliminate));

				//发送数据
				m_pIGameServiceFrame->SendData(pIUserItem,MDM_GR_MATCH,SUB_GR_MATCH_ELIMINATE,NULL,0);

				continue;
			}

			////插入分组
			//if(InsertDistribute(pIUserItem)==true)
			//{
			//	m_pIGameServiceFrame->SendGameMessage(pIUserItem,TEXT("本局比赛结束，系统正在努力为您分配座位，请稍后..."),SMT_CHAT|SMT_TABLE_ROLL);
			//}
			bool bFinish = false;
			//完成局数
			if(pIUserItem->GetUserPlayCount()-pIUserItem->GetUserInfo()->dwFleeCount >= m_pMatchOption->MatchType.LockTime.wMatchPlayCount)
			{
				bFinish = true;
				cbFinishVec[i] = 1;	//设置成true标志;

				TCHAR szMessage[128]=TEXT("");
				_sntprintf_s(szMessage,CountArray(szMessage),TEXT("您已完成%d局比赛，可以继续当前比赛或选择退出等待本次比赛活动结束后排名！"),m_pMatchOption->MatchType.LockTime.wMatchPlayCount);
				m_pIGameServiceFrame->SendGameMessage(pIUserItem,szMessage,SMT_CHAT|SMT_TABLE_ROLL);

				//构造结构;
				DBR_GR_MatchRecordGrades MatchRecordGrades;

				//设置变量
				MatchRecordGrades.dwUserID	= pIUserItem->GetUserID();
				MatchRecordGrades.dwMatchID = m_pMatchOption->dwMatchID;
				MatchRecordGrades.lMatchNo	= m_pMatchOption->dwMatchNO;
				MatchRecordGrades.wServerID = m_pGameServiceOption->wServerID;
				MatchRecordGrades.lInitScore = m_pMatchOption->MatchType.LockTime.lMatchInitScore;

				//投递数据
				m_pIDataBaseEngine->PostDataBaseRequest(MatchRecordGrades.dwUserID, DBR_GR_MATCH_RECORD_GRADES, 0, &MatchRecordGrades, sizeof(MatchRecordGrades));
			}

			UpdateMatchScore(pIUserItem,bFinish);
		}
	}

	SortMatchScoreVector();

	for (WORD i = 0; i<wChairCount; i++)
	{
		IServerUserItem *pIUserItem = pITableFrame->GetTableUserItem(i);
		ASSERT(pIUserItem != NULL);
		if (pIUserItem == NULL) continue;

		//完成局数打完了;
		if (cbFinishVec[i])
		{
			SendMatchPlayerFinish(pIUserItem);
			//重新设置分数;
			SendMatchUserInitScore(pIUserItem);
		}
	}


	PerformAllUserStandUp(pITableFrame);

	return true;
}

//用户坐下
bool CLockTimeMatch::OnActionUserSitDown(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)
{
	return true; 
}

//用户起立
bool CLockTimeMatch::OnActionUserStandUp(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)
{
	////移除分组;
	//return RemoveDistribute(pIServerUserItem);
	return true;
}

 //用户同意
bool CLockTimeMatch::OnActionUserOnReady(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)
{ 
	return true; 
}

//参赛权限
bool CLockTimeMatch::VerifyUserEnterMatch(IServerUserItem * pIServerUserItem)
{
	ASSERT(pIServerUserItem!=NULL);
	if (pIServerUserItem==NULL) return false;

	//机器人不受限制
	if (pIServerUserItem->IsAndroidUser()==true)
		return true;

	//变量定义
	WORD wMessageType;
	TCHAR szMessage[128]=TEXT("");

	//结束时间已到	
	if (VerifyMatchTime(szMessage,CountArray(szMessage),wMessageType)==false)
	{
		//发送消息
		m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,szMessage,wMessageType);

		return false;
	}

	//达到淘汰线
	if (m_pMatchOption->MatchType.LockTime.lMatchCullScore>0 && pIServerUserItem->GetUserScore()<m_pMatchOption->MatchType.LockTime.lMatchCullScore)
	{
		_sntprintf_s(szMessage,CountArray(szMessage),TEXT("由于您的比赛币低于 %d，您将不能继续游戏！"),m_pMatchOption->MatchType.LockTime.lMatchCullScore);

		//发送消息
		if(pIServerUserItem->GetTableID()==INVALID_TABLE)
		{
			m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem,szMessage,SMT_EJECT|SMT_CHAT);
		}
		else
		{
			m_pIGameServiceFrame->SendGameMessage(pIServerUserItem,szMessage,SMT_EJECT|SMT_CHAT);
		}

		return false;
	}

	return true;
}

//开始间隔
DWORD CLockTimeMatch::GetMatchStartInterval()
{
	//获取时间
	CTime CurTime=CTime::GetCurrentTime();
	CTime MatchStartTime(m_pMatchOption->MatchType.LockTime.MatchStartTime);
	CTime MatchEndTime(m_pMatchOption->MatchType.LockTime.MatchEndTime);

	//变量定义
	LONGLONG dwTimeInterval=1;
	DWORD dwCurrStamp,dwStartStamp,dwEndStamp;

	//比赛未开始
	if(CurTime<MatchStartTime)
	{
		CTimeSpan TimeSpan = MatchStartTime-CurTime;
		dwTimeInterval = TimeSpan.GetTotalSeconds();
	}

	//比赛已结束
	if(CurTime>=MatchEndTime) dwTimeInterval=0;

	//计算时间
	dwCurrStamp = CurTime.GetHour()*3600+CurTime.GetMinute()*60+CurTime.GetSecond();
	dwStartStamp = m_pMatchOption->MatchType.LockTime.MatchStartTime.wHour*3600+m_pMatchOption->MatchType.LockTime.MatchStartTime.wMinute*60+m_pMatchOption->MatchType.LockTime.MatchStartTime.wSecond;
	dwEndStamp = m_pMatchOption->MatchType.LockTime.MatchEndTime.wHour*3600+m_pMatchOption->MatchType.LockTime.MatchEndTime.wMinute*60+m_pMatchOption->MatchType.LockTime.MatchEndTime.wSecond;

	//比赛未开始
	if(dwCurrStamp<dwStartStamp) 
	{
		dwTimeInterval = dwStartStamp-dwCurrStamp;
	}

	if (CurTime < MatchEndTime && IsRoundMatchMode())
	{
		//比赛已结束;
		if (dwCurrStamp >= dwEndStamp)
		{
			dwTimeInterval = 24 * 3600 - (dwCurrStamp - dwStartStamp);
		}
	}


	return (DWORD)dwTimeInterval;
}

//分配用户
bool CLockTimeMatch::PerformDistribute()
{
	//状态判断
	if(m_MatchStatus!=MS_MATCHING) return true;

	//人数校验
	if(m_DistributeManage.GetCount()<m_pGameServiceOption->wMinDistributeUser) return false;

	WORD wChairCount = m_pGameServiceAttrib->wChairCount;

	//分配用户;
	while(true)
	{
		//变量定义;
		CDistributeInfoArray DistributeInfoArray;

        //获取用户;
		WORD wDistributeCount = m_DistributeManage.PerformDistribute(DistributeInfoArray,wChairCount);
		if(wDistributeCount < wChairCount) break;

		//寻找位置;
		ITableFrame * pICurrTableFrame=NULL;
		for (WORD i=0;i<m_pGameServiceOption->wTableCount;i++)
		{
			//获取对象
			ASSERT(m_ppITableFrame[i]!=NULL);
			ITableFrame * pITableFrame=m_ppITableFrame[i];

			//状态判断
			if (pITableFrame->GetNullChairCount()==pITableFrame->GetChairCount())
			{
				pICurrTableFrame=pITableFrame;
				break;
			}
		}

		//桌子判断
		if(pICurrTableFrame==NULL) break;

		//玩家坐下
		bool bSitSuccess=true;
		INT_PTR nSitFailedIndex=INVALID_CHAIR;
		for(INT_PTR nIndex=0;nIndex<DistributeInfoArray.GetCount();nIndex++)
		{
			//变量定义
			WORD wChairID=INVALID_CHAIR;

			//椅子搜索
			for (WORD i=0;i<pICurrTableFrame->GetChairCount();i++)
			{
				if (pICurrTableFrame->GetTableUserItem(i)==NULL)
				{
					wChairID = i;
					break;
				}
			}

			//分配用户
			if (wChairID!=INVALID_CHAIR)
			{
				//获取用户
				IServerUserItem * pIServerUserItem=DistributeInfoArray[nIndex].pIServerUserItem;

				//用户起立
				if (pIServerUserItem->GetTableID()!=INVALID_TABLE)
				{
					WORD wTableID=pIServerUserItem->GetTableID();
					ITableFrame * pITableFrame = m_ppITableFrame[wTableID];
					pITableFrame->PerformStandUpAction(pIServerUserItem);
				}

				//用户坐下
				if(pICurrTableFrame->PerformSitDownAction(wChairID,pIServerUserItem)==false)
				{
					bSitSuccess=false;
					nSitFailedIndex=nIndex;
					break;
				}

				// 日志;
#if _DEBUG
				IServerUserItem* pMeServerUserItem = pIServerUserItem;

				//构造提示;
				TCHAR szDescribe[128] = TEXT("");
				_sntprintf_s(szDescribe, CountArray(szDescribe), TEXT("player [%s] PerformDistribute, GetUserStatus:[%d]."),
					pMeServerUserItem->GetNickName(), pMeServerUserItem->GetUserStatus());
				CTraceService::TraceString(szDescribe, TraceLevel_Warning);
#endif
			}
		}

		//坐下结果
		if(bSitSuccess)
		{
			if (pICurrTableFrame&&pICurrTableFrame->IsGameStarted() == false)
			{
				for (int i = 0; i < wChairCount; i++)
				{
					IServerUserItem * pIServerUserItem = pICurrTableFrame->GetTableUserItem(i);
					if (pIServerUserItem && pIServerUserItem->GetTableID() != INVALID_TABLE)
					{
						if (pIServerUserItem->IsClientReady() == false)
						{
							pICurrTableFrame->ImitateGameOption(pIServerUserItem);
						}
					}
				}
			}

			//移除结点
			while(DistributeInfoArray.GetCount()>0)
			{
				m_DistributeManage.RemoveDistributeNode((tagDistributeNode *)DistributeInfoArray[0].pPertainNode);
				DistributeInfoArray.RemoveAt(0);
			}
		}
		else
		{
			for(INT_PTR nIndex=0;nIndex<DistributeInfoArray.GetCount();nIndex++)
			{
				if(nSitFailedIndex==nIndex)
				{
					m_DistributeManage.RemoveDistributeNode((tagDistributeNode *)DistributeInfoArray[nIndex].pPertainNode);
				}
				else
				{
					//用户起立
					if (DistributeInfoArray[nIndex].pIServerUserItem->GetTableID()!=INVALID_TABLE)
					{
						WORD wTableID=DistributeInfoArray[nIndex].pIServerUserItem->GetTableID();
						m_ppITableFrame[wTableID]->PerformStandUpAction(DistributeInfoArray[nIndex].pIServerUserItem);
					}
				}
			}
		}		
	}

	return true;
}

//插入用户
bool CLockTimeMatch::InsertDistribute(IServerUserItem * pIServerUserItem)
{
	//效验参数
	ASSERT(pIServerUserItem!=NULL);
	if (pIServerUserItem==NULL) return false;

	//比赛状态;
	if ((m_MatchStatus != MS_WAITPLAY) && (m_MatchStatus != MS_MATCHING)) return false;

	//状态判断
	ASSERT(pIServerUserItem->GetUserStatus()<US_PLAYING);
	if (pIServerUserItem->GetUserStatus()>=US_PLAYING) return false;

	//参赛校验
	if(VerifyUserEnterMatch(pIServerUserItem)==false) return false;

	////存在判断;
	//if (m_DistributeManage.SearchNode(pIServerUserItem) != NULL)
	//{
	//	return true;
	//}

	//变量定义
	tagDistributeInfo DistributeInfo;
	ZeroMemory(&DistributeInfo,sizeof(DistributeInfo));

	//设置变量
	DistributeInfo.pPertainNode=NULL;	
	DistributeInfo.dwInsertStamp = (DWORD)time(NULL);
	DistributeInfo.pIServerUserItem=pIServerUserItem;   

	//插入节点
	if(m_DistributeManage.InsertDistributeNode(DistributeInfo)==false)
	{
		return pIServerUserItem->IsAndroidUser()?false:true; 
	}

	//等待开始;
	if (m_MatchStatus == MS_WAITPLAY)
	{
		SendMatchInfo(NULL);
	}

	return true;
}

//清除玩家
void CLockTimeMatch::ClearSameTableUser(DWORD dwUserID)
{
	//变量定义
	tagSameTableInfo * pSameTableInfo = m_DistributeManage.GetUserSameTableInfo(dwUserID);
	if(pSameTableInfo!=NULL)
	{
		pSameTableInfo->wPlayerCount=0;
		ZeroMemory(pSameTableInfo->wPlayerIDSet,sizeof(pSameTableInfo->wPlayerIDSet));
	}
}

//插入用户
void CLockTimeMatch::InserSameTableUser(DWORD dwUserID,DWORD dwTableUserID)
{
	//变量定义
	tagSameTableInfo * pSameTableInfo = m_DistributeManage.GetUserSameTableInfo(dwUserID);
	if(pSameTableInfo!=NULL)
	{
		//添加用户
		pSameTableInfo->wPlayerIDSet[pSameTableInfo->wPlayerCount++] = dwTableUserID;
	}

	return;
}

//事件校验
bool CLockTimeMatch::VerifyMatchTime(LPTSTR pszMessage,WORD wMaxCount,WORD & wMessageType)
{
	//变量定义;
	CTime CurTime=CTime::GetCurrentTime();
	CTime MatchStartTime(m_pMatchOption->MatchType.LockTime.MatchStartTime);
	CTime MatchEndTime(m_pMatchOption->MatchType.LockTime.MatchEndTime);
	CTime SignupStartTime(m_pMatchOption->MatchType.LockTime.SignupStartTime);
	CTime SignupEndTime(m_pMatchOption->MatchType.LockTime.SignupEndTime);

	int nCurrSeconds = CurTime.GetHour() * 3600 + CurTime.GetMinute() * 60 + CurTime.GetSecond();

	//设置类型
	wMessageType = SMT_EJECT|SMT_CHAT;

	//比赛已结束;
	if(CurTime>=MatchEndTime)
	{
		wMessageType |= SMT_CLOSE_ROOM|SMT_CLOSE_GAME;
		_sntprintf(pszMessage,wMaxCount,TEXT("比赛已经结束,请您移驾至其他比赛房间参与比赛吧！"));
		return false;
	}

	//比赛已结束;
	if (nCurrSeconds >= MatchEndTime.GetHour() * 3600 + MatchEndTime.GetMinute() * 60 + MatchEndTime.GetSecond())
	{
		wMessageType |= SMT_CLOSE_ROOM|SMT_CLOSE_GAME;
		_sntprintf(pszMessage,wMaxCount,TEXT("今天的比赛已经结束,请您于明天%d时%d分%d秒前来参加比赛！"),MatchStartTime.GetHour(),MatchStartTime.GetMinute(),MatchStartTime.GetSecond());
		return false;
	}

	//报名未开始;
	if (CurTime < SignupStartTime)
	{
		wMessageType |= SMT_CLOSE_ROOM;
		_sntprintf(pszMessage, wMaxCount, TEXT("比赛报名尚未开始,本场比赛报名时段为：%d-%d-%d %d:%d:%d至%d-%d-%d %d:%d:%d"),
			SignupStartTime.GetYear(), SignupStartTime.GetMonth(), SignupStartTime.GetDay(), SignupStartTime.GetHour(), SignupStartTime.GetMinute(), SignupStartTime.GetSecond(),
			SignupEndTime.GetYear(), SignupEndTime.GetMonth(), SignupEndTime.GetDay(), SignupEndTime.GetHour(), SignupEndTime.GetMinute(), SignupEndTime.GetSecond());
		return false;
	}


	//报名未开始;
	if (IsRoundMatchMode() && nCurrSeconds < (SignupStartTime.GetHour() * 3600 + SignupStartTime.GetMinute() * 60 + SignupStartTime.GetSecond()))
	{
		wMessageType |= SMT_CLOSE_ROOM;
		_sntprintf(pszMessage, wMaxCount, TEXT("比赛报名尚未开始,请您于今天%d时%d分%d秒前来报名参加比赛！"), SignupStartTime.GetHour(), SignupStartTime.GetMinute(), SignupStartTime.GetSecond());
		return false;
	}

	return true;
}

//发送用户分数
bool CLockTimeMatch::SendMatchUserScore(IServerUserItem * pIServerUserItem)
{
	//发送数据
	CMD_GR_UserScore UserScore;
	ZeroMemory(&UserScore,sizeof(UserScore));

	tagUserInfo * pUserInfo=pIServerUserItem->GetUserInfo();

	//构造数据
	UserScore.dwUserID=pUserInfo->dwUserID;
	UserScore.UserScore.dwWinCount=pUserInfo->dwWinCount;
	UserScore.UserScore.dwLostCount=pUserInfo->dwLostCount;
	UserScore.UserScore.dwDrawCount=pUserInfo->dwDrawCount;
	UserScore.UserScore.dwFleeCount=pUserInfo->dwFleeCount;	
	UserScore.UserScore.dwExperience=pUserInfo->dwExperience;
	UserScore.UserScore.lLoveLiness=pUserInfo->lLoveLiness;

	//构造积分
	UserScore.UserScore.lGrade=pUserInfo->lGrade;
	UserScore.UserScore.lInsure=pUserInfo->lInsure;
	UserScore.UserScore.lScore=pUserInfo->lScore;
	UserScore.UserScore.dwUserMedal=pUserInfo->dwUserMedal;

	return m_pIGameServiceFrame->SendData(BG_ALL_CLIENT,MDM_GR_USER,SUB_GR_USER_SCORE,&UserScore,sizeof(UserScore));
}

//移除玩家
bool CLockTimeMatch::RemoveDistribute(IServerUserItem * pIServerUserItem)
{
	//验证参数
	ASSERT(pIServerUserItem!=NULL);
	if (pIServerUserItem==NULL) return false;

	//移除用户
	m_DistributeManage.RemoveDistributeNode(pIServerUserItem);

	return true;
}


//获取名次
WORD CLockTimeMatch::GetUserRank(IServerUserItem *pUserItem, ITableFrame *pITableFrame)
{
	//参数效验
	ASSERT(pUserItem!=NULL);
	if(pUserItem==NULL) return INVALID_WORD;
	if (!pITableFrame)
	{
		return INVALID_WORD;
	}
	//定义变量
	SCORE lUserScore=pUserItem->GetUserScore();
	WORD wRank=1;
	DWORD dwUserID=0;
	IServerUserItem *pLoopUserItem=NULL;

	ASSERT(pUserItem->GetTableID()==pITableFrame->GetTableID());
	if(pUserItem->GetTableID()!=pITableFrame->GetTableID()) return INVALID_WORD;

	for(WORD i=0; i<m_pGameServiceAttrib->wChairCount; i++)
	{
		pLoopUserItem=pITableFrame->GetTableUserItem(i);
		if(pLoopUserItem==NULL) continue;

		if(pLoopUserItem!=pUserItem && pLoopUserItem->GetUserScore()>lUserScore)
			wRank++;
	}
	return wRank;
}

DWORD CLockTimeMatch::GetUserRank(IServerUserItem *pUserItem)
{
	if (NULL == pUserItem)
	{
		return INVALID_DWORD;
	}

	tagMatchScore* pMatchScore = FindMatchScore(pUserItem);
	if (NULL == pMatchScore)
	{
		return INVALID_DWORD;
	}

	tagMatchScorePtrVector::iterator iterFind = std::find(m_AllMatchScorePtrVector.begin(), m_AllMatchScorePtrVector.end(), pMatchScore);
	if ( iterFind == m_AllMatchScorePtrVector.end())
	{
		return INVALID_DWORD;
	}

	return (iterFind - m_AllMatchScorePtrVector.begin() + 1);
}

//发送比赛信息
void CLockTimeMatch::SendTableUserMatchInfo(ITableFrame *pITableFrame, WORD wChairID)
{
	//验证参数
	ASSERT(pITableFrame!=NULL);
	if (pITableFrame==NULL) return;

	//构造数据
	CMD_GR_Match_Info MatchInfo;
	ZeroMemory(&MatchInfo,sizeof(MatchInfo));

	MatchInfo.wTotalCount = m_pMatchOption->MatchType.LockTime.wMatchPlayCount;

	for(WORD i=0; i<pITableFrame->GetChairCount(); i++)
	{
		//获取用户;
		if(wChairID!=INVALID_CHAIR && wChairID!=i) continue;
		IServerUserItem *pIServerUserItem=pITableFrame->GetTableUserItem(i);
		if(pIServerUserItem==NULL) continue;

		//设置局数
		MatchInfo.wGameCount=(WORD)pIServerUserItem->GetUserPlayCount()+1;
		//MatchInfo.wRank=GetUserRank(pIServerUserItem,pITableFrame);
		MatchInfo.wRank = GetUserRank(pIServerUserItem);
		MatchInfo.wRankSize = sizeof(MatchInfo.rankInfo) / sizeof(MatchInfo.rankInfo[0]);
		GetCMDGRMatchRankInfo(MatchInfo.rankInfo, MatchInfo.wRankSize);

		//发送数据
		if (pIServerUserItem->IsAndroidUser()==false)
		{
			pITableFrame->SendTableData(i,SUB_GR_MATCH_INFO,&MatchInfo,sizeof(MatchInfo),MDM_GR_MATCH);
		}
	}

	return;
}

void CLockTimeMatch::SendTableUserMatchInfo(IServerUserItem* pIServerUserItem)
{
	if (pIServerUserItem == NULL || pIServerUserItem->IsAndroidUser()) return;

	//构造数据
	CMD_GR_Match_Info MatchInfo;
	ZeroMemory(&MatchInfo, sizeof(MatchInfo));

	//设置局数;
	MatchInfo.wTotalCount = m_pMatchOption->MatchType.LockTime.wMatchPlayCount;
	MatchInfo.wGameCount = (WORD)pIServerUserItem->GetUserPlayCount() + 1;
	MatchInfo.wRank = GetUserRank(pIServerUserItem);
	MatchInfo.wRankSize = sizeof(MatchInfo.rankInfo) / sizeof(MatchInfo.rankInfo[0]);
	GetCMDGRMatchRankInfo(MatchInfo.rankInfo, MatchInfo.wRankSize);

	m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_INFO, &MatchInfo, sizeof(MatchInfo));
}

//写入奖励
bool CLockTimeMatch::WriteUserAward(IServerUserItem *pIServerUserItem,tagMatchRankInfo * pMatchRankInfo)
{
	//参数效验
	ASSERT(pMatchRankInfo!=NULL);
	if(pMatchRankInfo==NULL) return false;

	//在线玩家;
	if (pIServerUserItem != NULL)
	{
		//变量定义
		CMD_GR_MatchResult MatchResult;
		ZeroMemory(&MatchResult, sizeof(MatchResult));

		//比赛奖励
		MatchResult.lGold = pMatchRankInfo->lRewardGold;
		MatchResult.dwIngot = pMatchRankInfo->dwRewardIngot;
		MatchResult.dwExperience = pMatchRankInfo->dwRewardExperience;
		MatchResult.lInsureScore = pMatchRankInfo->lInsureSocre;

		//获奖提示
		_sntprintf_s(MatchResult.szDescribe, CountArray(MatchResult.szDescribe), TEXT("%s, 恭喜您在%s中获得第%d名,奖励如下："),
			pIServerUserItem->GetNickName(), m_pMatchOption->szMatchName, pMatchRankInfo->wRankID);

		////更新用户信息
		//tagUserInfo * pUserInfo = pIServerUserItem->GetUserInfo();
		////pUserInfo->lIngot+=pMatchRankInfo->dwRewardIngot;
		//pUserInfo->dwExperience += pMatchRankInfo->dwRewardExperience;
		//OnEventUserItemScore(pIServerUserItem, 0);

		//发送数据
		if (pIServerUserItem->IsAndroidUser() == false)
		{
			m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_RESULT, &MatchResult, sizeof(MatchResult));
		}
	}


	//写入记录;
	if(m_pIDataBaseEngine!=NULL)
	{
		//变量定义;
		DBR_GR_MatchReward MatchReward;
		ZeroMemory(&MatchReward,sizeof(MatchReward));
		
		//构造结构;
		MatchReward.dwUserID			= pMatchRankInfo->dwUserID;
		MatchReward.lRewardGold			= pMatchRankInfo->lRewardGold;
		MatchReward.dwRewardIngot		= pMatchRankInfo->dwRewardIngot;
		MatchReward.dwRewardExperience	= pMatchRankInfo->dwRewardExperience;
		MatchReward.dwClientAddr		= pIServerUserItem ? pIServerUserItem->GetClientAddr() : 0;
		MatchReward.lInsureSocre		= pMatchRankInfo->lInsureSocre;
		MatchReward.dwGoodsID			= pMatchRankInfo->dwGoodsID;
		MatchReward.dwGoodsNum			= pMatchRankInfo->dwGoodsNum;

		//投递数据
		m_pIDataBaseEngine->PostDataBaseRequest(MatchReward.dwUserID,DBR_GR_MATCH_REWARD,0,&MatchReward,sizeof(MatchReward));
	}

	return true;
}
//发送数据
bool CLockTimeMatch::SendMatchInfo(IServerUserItem * pIServerUserItem)
{
	CMD_GR_Match_Num MatchNum;
	ZeroMemory(&MatchNum,sizeof(MatchNum));

	MatchNum.dwWaitting=m_pIServerUserManager->GetUserItemCount();
	MatchNum.dwTotal=m_pGameServiceAttrib->wChairCount;

	if(pIServerUserItem==NULL)
	{
		m_pIGameServiceFrame->SendData(BG_ALL_CLIENT,MDM_GR_MATCH,SUB_GR_MATCH_NUM,&MatchNum, sizeof(MatchNum));
		return true;
	}

	m_pIGameServiceFrame->SendData(pIServerUserItem,MDM_GR_MATCH,SUB_GR_MATCH_NUM,&MatchNum, sizeof(MatchNum));
	return true;
}

bool CLockTimeMatch::SendMatchUserInitScore(IServerUserItem * pIServerUserItem)
{
	//获取成绩
	tagUserInfo *pUserScore = pIServerUserItem->GetUserInfo();

	//设置成绩
	pUserScore->dwWinCount = 0L;
	pUserScore->dwLostCount = 0L;
	pUserScore->dwFleeCount = 0L;
	pUserScore->dwDrawCount = 0L;
	pUserScore->lGrade = 0L;
	pUserScore->lScore = m_pMatchOption->MatchType.LockTime.lMatchInitScore;

	//特殊需求重新设置;
	pUserScore->cbScoreMultiple = 1;

	//发送分数
	return SendMatchUserScore(pIServerUserItem);
}

bool CLockTimeMatch::IsNormalMatchMode()
{
	return (m_pMatchOption->MatchType.LockTime.cbMatchMode == MATCH_MODE_NORMAL);
}

bool CLockTimeMatch::IsRoundMatchMode()
{
	return (m_pMatchOption->MatchType.LockTime.cbMatchMode == MATCH_MODE_ROUND);
}

void CLockTimeMatch::UpdateMatchStatus()
{
	//变量定义;
	CTime CurTime = CTime::GetCurrentTime();
	CTime MatchEndTime(m_pMatchOption->MatchType.LockTime.MatchEndTime);
	CTime MatchStartTime(m_pMatchOption->MatchType.LockTime.MatchStartTime);

	//比赛未开始;
	BYTE MatchStatus = m_MatchStatus;

	DWORD nCurSeconds			= CurTime.GetHour() * 3600 + CurTime.GetMinute() * 60 + CurTime.GetSecond();
	DWORD nMatchStartSeconds	= MatchStartTime.GetHour() * 3600 + MatchStartTime.GetMinute() * 60 + MatchStartTime.GetSecond();
	DWORD nMatchEndSeconds		= MatchEndTime.GetHour() * 3600 + MatchEndTime.GetMinute() * 60 + MatchEndTime.GetSecond();

	//比赛进行中;
	if (MatchStatus == MS_NULL && nCurSeconds >= nMatchStartSeconds)
	{
		MatchStatus = MS_MATCHING;
	}

	//等待结束;
	if (MatchStatus == MS_MATCHING && nCurSeconds >= nMatchEndSeconds)
	{
		MatchStatus = MS_WAITEND;
	}

	//结束判断;
	if (MatchStatus == MS_WAITEND)
	{
		//变量定义;
		bool bContinueWait = false;

		//解散游戏;
		for (INT i = 0; i < m_pGameServiceOption->wTableCount; i++)
		{
			//获取对象;
			ITableFrame * pITableFrame = m_ppITableFrame[i];
			if (pITableFrame == NULL)
			{
				continue;
			}

			//解散游戏;
			if (pITableFrame->IsGameStarted())
			{
				bContinueWait = true;
				break;
			}
		}

		//无需等待;
		if (bContinueWait == false)
		{
			MatchStatus = MS_MATCHEND;
		}

		//强制结束;
		if (nCurSeconds >= (nMatchEndSeconds + m_pMatchOption->MatchType.LockTime.dwEndDelayTime))
		{
			MatchStatus = MS_MATCHEND;
		}
	}

	//设置状态;
	m_MatchStatus = MatchStatus;
}

VOID CLockTimeMatch::PerformAllUserStandUp(ITableFrame *pITableFrame)
{
	//参数校验;
	ASSERT(pITableFrame != NULL);
	if (pITableFrame == NULL)
	{
		return;
	}

	//处理起立;
	for (int i = 0; i < m_pGameServiceAttrib->wChairCount; i++)
	{
		//获取用户;
		IServerUserItem * pUserServerItem = pITableFrame->GetTableUserItem(i);
		if (pUserServerItem&&pUserServerItem->GetTableID() != INVALID_TABLE)
		{
			//设置状态;
			pUserServerItem->SetUserMatchStatus(MUS_NULL);

			pITableFrame->PerformStandUpAction(pUserServerItem);
		}
	}
}

DWORD CLockTimeMatch::CalcMatchNo()
{
	////循环开赛;
	//if (IsRoundMatchMode())
	//{
	//	//变量定义;
	//	SYSTEMTIME SystemStartTime = m_pMatchOption->MatchType.LockTime.MatchStartTime;

	//	//设置变量;
	//	SystemStartTime.wHour = 0;
	//	SystemStartTime.wMinute = 0;
	//	SystemStartTime.wSecond = 0;
	//	SystemStartTime.wMilliseconds = 0;

	//	//获取时间;
	//	CTime CurTime = CTime::GetCurrentTime();
	//	CTime MatchStartTime(SystemStartTime);

	//	//变量定义;
	//	CTimeSpan TimeSpan = CurTime - MatchStartTime;

	//	return TimeSpan.GetDays() + m_pMatchOption->dwMatchNO;
	//}

	return m_pMatchOption->dwMatchNO;
}

void CLockTimeMatch::ReleaseMatchScore()
{
	tagMatchScorePtrVector::iterator iter		= m_AllMatchScorePtrVector.begin();
	tagMatchScorePtrVector::iterator iterEnd	= m_AllMatchScorePtrVector.end();
	for (; iter != iterEnd; ++iter)
	{
		tagMatchScore* pMatchScore = *iter;
		if (pMatchScore != NULL)
		{
			delete pMatchScore;
			pMatchScore = NULL;
		}
	}
	m_AllMatchScorePtrMap.clear();
	m_AllMatchScorePtrVector.clear();
}

void CLockTimeMatch::CreateNewMatchScore(IServerUserItem *pIServerUserItem)
{
	if (NULL == pIServerUserItem) return;

	tagMatchScore* pMatchScore = new tagMatchScore();
	pMatchScore->dwUserID	= pIServerUserItem->GetUserID();
	pMatchScore->pUserItem	= pIServerUserItem;
	memcpy(pMatchScore->szNickName, pIServerUserItem->GetNickName(), sizeof(pMatchScore->szNickName));

	m_AllMatchScorePtrMap.insert(std::make_pair(pMatchScore->dwUserID, pMatchScore));
	m_AllMatchScorePtrVector.push_back(pMatchScore);
}

void CLockTimeMatch::InsertAllMatchScoreMap(IServerUserItem *pIServerUserItem)
{
	if (NULL == pIServerUserItem) return;
	if (NULL != FindMatchScore(pIServerUserItem)) return;
	
	CreateNewMatchScore(pIServerUserItem);
}

void CLockTimeMatch::InsertAllMatchScoreMap(tagMatchRankDataInfo * pMatchRankDataInfo)
{
	tagMatchScore* pMatchScore = new tagMatchScore();
	pMatchScore->dwUserID			= pMatchRankDataInfo->dwUserID;
	pMatchScore->lScore				= pMatchRankDataInfo->lScore;
	pMatchScore->lFinishMaxScore	= pMatchRankDataInfo->lFinishMaxScore;
	memcpy(pMatchScore->szNickName, pMatchRankDataInfo->szNickName, sizeof(pMatchScore->szNickName));

	m_AllMatchScorePtrMap.insert(std::make_pair(pMatchScore->dwUserID, pMatchScore));
	m_AllMatchScorePtrVector.push_back(pMatchScore);
}

tagMatchScore* CLockTimeMatch::FindMatchScore(IServerUserItem *pIServerUserItem)
{
	if (NULL == pIServerUserItem) return NULL;

	DWORD dwUserID = pIServerUserItem->GetUserID();

	tagMatchScorePtrMap::iterator iterFind = m_AllMatchScorePtrMap.find(dwUserID);
	if (iterFind != m_AllMatchScorePtrMap.end())
	{	
		return iterFind->second;
	}
	return NULL;
}

void CLockTimeMatch::UpdateMatchScore(IServerUserItem *pIServerUserItem, bool bFinish)
{
	if (NULL == pIServerUserItem) return;

	tagMatchScore* pMatchScore = FindMatchScore(pIServerUserItem);
	if (NULL == pMatchScore)
	{
		return;
	}

	SCORE lMatchInitScore = m_pMatchOption->MatchType.LockTime.lMatchInitScore;
	SCORE lUserGetScore = pIServerUserItem->GetUserScore() - lMatchInitScore;
	if (lUserGetScore < 0)
	{
		lUserGetScore = 0;
	}

	if (pMatchScore->lScore < lUserGetScore)
	{
		pMatchScore->lScore = lUserGetScore;
	}

	if (bFinish && (pMatchScore->lFinishMaxScore < lUserGetScore))
	{
		pMatchScore->lFinishMaxScore = lUserGetScore;
	}
}

void CLockTimeMatch::SortMatchScoreVector()
{
	std::make_heap(m_AllMatchScorePtrVector.begin(), m_AllMatchScorePtrVector.end(), ObjGreatCmp<SCORE, tagMatchScore*>(&tagMatchScore::GetCurMaxScore));
	std::sort_heap(m_AllMatchScorePtrVector.begin(), m_AllMatchScorePtrVector.end(), ObjGreatCmp<SCORE, tagMatchScore*>(&tagMatchScore::GetCurMaxScore));
}

void CLockTimeMatch::GetCMDGRMatchRankInfo(CMD_GR_Match_Rank_Info* pRankInfo, WORD&	refRankSize)
{
	int nVectorSize = m_AllMatchScorePtrVector.size();
	if (refRankSize > nVectorSize)
	{
		refRankSize = nVectorSize;
	}

	for (int i = 0; i < refRankSize; ++i)
	{
		tagMatchScore* pMatchScore = m_AllMatchScorePtrVector[i];
		pRankInfo[i].lScore = pMatchScore->GetCurMaxScore();
		memcpy(pRankInfo[i].szNickName, pMatchScore->szNickName, sizeof(pMatchScore->szNickName));
	}
}

void CLockTimeMatch::SendMatchJoinResult(IServerUserItem* pIServerUserItem, WORD wSuccess, LPCTSTR lpszMessage)
{
	CMD_GR_Match_JoinResult kResult;
	kResult.wSucess		= wSuccess;
	kResult.wServerID	= m_pGameServiceOption->wServerID;
	kResult.wLength		= lstrlen(lpszMessage) + 1;
	lstrcpyn(kResult.szString, lpszMessage, CountArray(kResult.szString));
	m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_JOIN_RESULT, &kResult, sizeof(kResult));
}

void CLockTimeMatch::SendMatchPlayerFinish(IServerUserItem* pIServerUserItem)
{
	CMD_GR_Match_PlayerFinish playerFinish;
	memset(&playerFinish, 0, sizeof(playerFinish));

	SCORE lMatchInitScore = m_pMatchOption->MatchType.LockTime.lMatchInitScore;
	playerFinish.lScore = pIServerUserItem->GetUserScore() - lMatchInitScore;
	if (playerFinish.lScore < 0) playerFinish.lScore = 0;

	tagMatchScore* pMatchScore = FindMatchScore(pIServerUserItem);
	if (pMatchScore!=NULL)
	{
		playerFinish.lMaxScore = pMatchScore->lFinishMaxScore;
	}

	playerFinish.wRank = GetUserRank(pIServerUserItem);

	m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_PLAYERFINISH, &playerFinish, sizeof(playerFinish));
}

bool CLockTimeMatch::VerifySignupMatchTime(LPTSTR pszMessage, WORD wMaxCount, WORD & wMessageType)
{
	//变量定义;
	CTime CurTime = CTime::GetCurrentTime();
	CTime MatchStartTime(m_pMatchOption->MatchType.LockTime.MatchStartTime);
	CTime MatchEndTime(m_pMatchOption->MatchType.LockTime.MatchEndTime);
	CTime SignupStartTime(m_pMatchOption->MatchType.LockTime.SignupStartTime);
	CTime SignupEndTime(m_pMatchOption->MatchType.LockTime.SignupEndTime);

	int nCurrSeconds = CurTime.GetHour() * 3600 + CurTime.GetMinute() * 60 + CurTime.GetSecond();

	//设置类型
	wMessageType = SMT_EJECT | SMT_CHAT;

	//报名结束;
	if ((CurTime >= SignupEndTime) && (MatchEndTime.GetMonth() == SignupEndTime.GetMonth()) && (MatchEndTime.GetDay() == SignupEndTime.GetDay()))
	{
		wMessageType |= SMT_CLOSE_ROOM | SMT_CLOSE_GAME;
		_sntprintf(pszMessage, wMaxCount, TEXT("报名已经结束,请您移驾至其他比赛房间参与比赛吧！"));
		return false;
	}
	//报名已结束;
	if (nCurrSeconds >= SignupEndTime.GetHour() * 3600 + SignupEndTime.GetMinute() * 60 + SignupEndTime.GetSecond())
	{
		wMessageType |= SMT_CLOSE_ROOM | SMT_CLOSE_GAME;
		_sntprintf(pszMessage, wMaxCount, TEXT("今天的报名已经结束,请您于明天%d时%d分%d秒前来报名比赛！"), SignupStartTime.GetHour(), SignupStartTime.GetMinute(), SignupStartTime.GetSecond());
		return false;
	}

	//报名未开始;
	if (CurTime < SignupStartTime)
	{
		wMessageType |= SMT_CLOSE_ROOM;
		_sntprintf(pszMessage, wMaxCount, TEXT("比赛报名尚未开始,本场比赛报名时段为：%d-%d-%d %d:%d:%d至%d-%d-%d %d:%d:%d"),
			SignupStartTime.GetYear(), SignupStartTime.GetMonth(), SignupStartTime.GetDay(), SignupStartTime.GetHour(), SignupStartTime.GetMinute(), SignupStartTime.GetSecond(),
			SignupEndTime.GetYear(), SignupEndTime.GetMonth(), SignupEndTime.GetDay(), SignupEndTime.GetHour(), SignupEndTime.GetMinute(), SignupEndTime.GetSecond());
		return false;
	}


	//报名未开始;
	if (IsRoundMatchMode() && nCurrSeconds < (SignupStartTime.GetHour() * 3600 + SignupStartTime.GetMinute() * 60 + SignupStartTime.GetSecond()))
	{
		wMessageType |= SMT_CLOSE_ROOM;
		_sntprintf(pszMessage, wMaxCount, TEXT("比赛报名尚未开始,请您于今天%d时%d分%d秒前来报名参加比赛！"), SignupStartTime.GetHour(), SignupStartTime.GetMinute(), SignupStartTime.GetSecond());
		return false;
	}

	//比赛已结束;
	if (CurTime >= MatchEndTime)
	{
		wMessageType |= SMT_CLOSE_ROOM | SMT_CLOSE_GAME;
		_sntprintf(pszMessage, wMaxCount, TEXT("比赛已经结束,请您移驾至其他比赛房间参与比赛吧！"));
		return false;
	}

	//比赛已结束;
	if (nCurrSeconds >= MatchEndTime.GetHour() * 3600 + MatchEndTime.GetMinute() * 60 + MatchEndTime.GetSecond())
	{
		wMessageType |= SMT_CLOSE_ROOM | SMT_CLOSE_GAME;
		_sntprintf(pszMessage, wMaxCount, TEXT("今天的比赛已经结束,请您于明天%d时%d分%d秒前来参加比赛！"), MatchStartTime.GetHour(), MatchStartTime.GetMinute(), MatchStartTime.GetSecond());
		return false;
	}

	return true;
}

void CLockTimeMatch::SendMatchWaitTip(IServerUserItem* pIServerUserItem)
{
	//变量定义;
	CMD_GR_Match_Wait_Tip WaitTip;
	ZeroMemory(&WaitTip, sizeof(WaitTip));
	WaitTip.wUserCount = (WORD)m_pIServerUserManager->GetUserItemCount();
	WaitTip.wCurGameCount = (WORD)pIServerUserItem->GetUserPlayCount() + 1;
	WaitTip.wGameCount = m_pMatchOption->MatchType.LockTime.wMatchPlayCount;

	lstrcpyn(WaitTip.szMatchName, m_pMatchOption->szMatchName, LEN_SERVER);

	//发送比赛信息给玩家;
	WaitTip.wRank = GetUserRank(pIServerUserItem);
	WaitTip.lScore = pIServerUserItem->GetUserScore();
	WaitTip.cbScoreMultiple = pIServerUserItem->getScoreMultiple();

	m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_WAIT_TIP, &WaitTip, sizeof(WaitTip));
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////