2136 lines
62 KiB
C++
2136 lines
62 KiB
C++
#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));
|
||
}
|
||
|
||
////////////////////////////////////////////////////////////////////////////////////////////////////////////
|