zhaobu
/
zhujimajiang_redis
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
诸暨麻将添加redis
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7 Commits
2 Branches
57 MiB
 
 
 
 
 
 
Tree: acf5e4d482
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'acf5e4d482'
${ noResults }
zhujimajiang_redis/俱乐部/Source/ServerControl/MatchService/ImmediateMatch.cpp

1392 lines
58 KiB
Raw Blame History 

  1. #include "StdAfx.h"

  2. #include "ImmediateMatch.h"

  3. #include "..\GameServer\DataBasePacket.h"

  4. 

  5. #ifdef _DEBUG

  6. #define new DEBUG_NEW

  7. #undef THIS_FILE

  8. static char THIS_FILE[] = __FILE__;

  9. #endif

  10. 

  11. ////////////////////////////////////////////////////////////////////////////////////////////////////////////

  12. 

  13. #define INVALID_VALUE				0xFFFF								//无效值

  14. 

  15. //////////////////////////////////////////////////////////////////////////

  16. 

  17. //时钟定义

  18. #define IDI_DISTRIBUTE_USER		    (IDI_MATCH_MODULE_START+100)		//分配用户

  19. 

  20. ////////////////////////////////////////////////////////////////////////////////////////////////////////////

  21. //构造函数

  22. CImmediateMatch::CImmediateMatch()

  23. {

  24.     //比赛配置

  25.     m_pMatchOption = NULL;

  26.     m_pGameServiceOption = NULL;

  27.     m_pGameServiceAttrib = NULL;

  28. 

  29.     //设置指针

  30.     m_ppITableFrame = NULL;

  31.     m_pCurMatchGroup = NULL;

  32. 

  33.     //内核接口

  34.     m_pITimerEngine = NULL;

  35.     m_pIDataBaseEngine = NULL;

  36.     m_pITCPNetworkEngineEvent = NULL;

  37. 

  38.     //服务接口

  39.     m_pIGameServiceFrame = NULL;

  40.     m_pIServerUserManager = NULL;

  41.     m_pAndroidUserManager = NULL;

  42.     m_pIServerUserItemSink = NULL;

  43. }

  44. 

  45. CImmediateMatch::~CImmediateMatch(void)

  46. {

  47.     SafeDeleteArray(m_ppITableFrame);

  48. 

  49.     m_LoopTimer.RemoveAll();

  50.     SafeDelete(m_pCurMatchGroup);

  51.     m_MatchGroup.Append(m_OverMatchGroup);

  52.     for (int i = 0; i<m_MatchGroup.GetCount(); i++)

  53.     {

  54.         SafeDelete(m_MatchGroup[i]);

  55.     }

  56. 

  57.     m_MatchGroup.RemoveAll();

  58.     m_OverMatchGroup.RemoveAll();

  59. }

  60. 

  61. //接口查询

  62. VOID* CImmediateMatch::QueryInterface(REFGUID Guid, DWORD dwQueryVer)

  63. {

  64.     QUERYINTERFACE(IGameMatchItem, Guid, dwQueryVer);

  65.     QUERYINTERFACE(IServerUserItemSink, Guid, dwQueryVer);

  66.     QUERYINTERFACE_IUNKNOWNEX(IGameMatchItem, Guid, dwQueryVer);

  67.     return NULL;

  68. }

  69. 

  70. //启动通知

  71. void CImmediateMatch::OnStartService()

  72. {

  73.     //创建分组

  74.     if (m_pCurMatchGroup == NULL)

  75.     {

  76.         m_pCurMatchGroup = new CImmediateGroup((DWORD)time(NULL), m_pMatchOption, this);

  77.     }

  78. 

  79.     //最多同时9组编号

  80.     for (int i = 0; i<79; i++)

  81.     {

  82.         m_LoopTimer.Add(i);

  83.     }

  84.     m_pITimerEngine->SetTimer(IDI_CHECK_OVER_MATCH, 60000L, TIMES_INFINITY, 0);

  85.     m_pITimerEngine->SetTimer(IDI_DELETE_OVER_MATCH, 6000, TIMES_INFINITY, 0);

  86.     //#ifdef _DEBUG

  87.     //	m_pITimerEngine->SetTimer(IDI_ANDROID_SIGNUP,1000,TIMES_INFINITY,0);

  88.     //#else

  89.     //	m_pITimerEngine->SetTimer(IDI_ANDROID_SIGNUP,3000,TIMES_INFINITY,0);

  90.     //#endif

  91. 

  92.     InsertNullTable();

  93. }

  94. 

  95. //绑定桌子

  96. bool CImmediateMatch::BindTableFrame(ITableFrame * pTableFrame, WORD wTableID)

  97. {

  98.     if (pTableFrame == NULL || wTableID>m_pGameServiceOption->wTableCount)

  99.     {

  100.         ASSERT(false);

  101.         return false;

  102.     }

  103. 

  104.     //创建钩子

  105.     CTableFrameHook * pTableFrameHook = new CTableFrameHook();

  106.     pTableFrameHook->InitTableFrameHook(QUERY_OBJECT_PTR_INTERFACE(pTableFrame, IUnknownEx));

  107.     pTableFrameHook->SetMatchEventSink(QUERY_OBJECT_PTR_INTERFACE(this, IUnknownEx));

  108. 

  109.     //设置接口

  110.     pTableFrame->SetTableFrameHook(QUERY_OBJECT_PTR_INTERFACE(pTableFrameHook, IUnknownEx));

  111.     m_ppITableFrame[wTableID] = pTableFrame;

  112. 

  113.     return true;

  114. }

  115. 

  116. //初始化接口

  117. bool CImmediateMatch::InitMatchInterface(tagMatchManagerParameter & MatchManagerParameter)

  118. {

  119.     //服务配置

  120.     m_pMatchOption = MatchManagerParameter.pGameMatchOption;

  121.     m_pGameServiceOption = MatchManagerParameter.pGameServiceOption;

  122.     m_pGameServiceAttrib = MatchManagerParameter.pGameServiceAttrib;

  123. 

  124.     //内核组件

  125.     m_pITimerEngine = MatchManagerParameter.pITimerEngine;

  126.     m_pIDataBaseEngine = MatchManagerParameter.pICorrespondManager;

  127.     m_pITCPNetworkEngineEvent = MatchManagerParameter.pTCPNetworkEngine;

  128. 

  129.     //服务组件		

  130.     m_pIGameServiceFrame = MatchManagerParameter.pIMainServiceFrame;

  131.     m_pIServerUserManager = MatchManagerParameter.pIServerUserManager;

  132.     m_pAndroidUserManager = MatchManagerParameter.pIAndroidUserManager;

  133.     m_pIServerUserItemSink = MatchManagerParameter.pIServerUserItemSink;

  134. 

  135.     //创建桌子数组

  136.     CImmediateGroup::m_wChairCount = m_pGameServiceAttrib->wChairCount;

  137.     if (m_ppITableFrame == NULL)

  138.     {

  139.         m_ppITableFrame = new ITableFrame*[m_pGameServiceOption->wTableCount];

  140.     }

  141. 

  142.     return true;

  143. }

  144. 

  145. //时间事件

  146. bool CImmediateMatch::OnEventTimer(DWORD dwTimerID, WPARAM dwBindParameter)

  147. {

  148.     if (dwTimerID >= IDI_GROUP_TIMER_START)

  149.     {

  150.         for (INT_PTR i = m_MatchGroup.GetCount() - 1; i >= 0; i--)

  151.         {

  152.             //查看是哪场比赛的定时器

  153.             if (m_MatchGroup[i]->m_LoopTimer == ((dwTimerID - IDI_GROUP_TIMER_START) / 10))

  154.             {

  155.                 m_MatchGroup[i]->OnTimeMessage(dwTimerID - (m_MatchGroup[i]->m_LoopTimer * 10), dwBindParameter);

  156.             }

  157.         }

  158.         return true;

  159.     }

  160. 

  161.     switch (dwTimerID)

  162.     {

  163.     case IDI_CHECK_OVER_MATCH:

  164.     {

  165.                                  //定时检测一下 那些比赛人数不够被卡的问题

  166.                                  for (INT_PTR i = m_MatchGroup.GetCount() - 1; i >= 0; i--)

  167.                                  {

  168.                                      //参赛用户小于椅子数量 就要结束

  169.                                      m_MatchGroup[i]->CheckMatchUser();

  170.                                  }

  171.                                  return true;

  172.     }

  173.     case IDI_DELETE_OVER_MATCH:

  174.     {

  175.                                   for (int i = 0; m_OverMatchGroup.GetCount(); i++)

  176.                                   {

  177.                                       CImmediateGroup * pOverMatch = m_OverMatchGroup[i];

  178.                                       m_OverMatchGroup.RemoveAt(i--);

  179.                                       SafeDelete(pOverMatch);

  180.                                   }

  181.                                   return true;

  182.     }

  183.     }

  184. 

  185.     return true;

  186. }

  187. 

  188. 

  189. //数据库事件

  190. bool CImmediateMatch::OnEventDataBase(WORD wRequestID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)

  191. {

  192.     switch (wRequestID)

  193.     {

  194.     case DBO_GR_MATCH_SIGNUP_RESULT:		//报名结果

  195.     {

  196.                                                 //参数效验

  197.                                                 if (pIServerUserItem == NULL) return true;

  198.                                                 if (wDataSize>sizeof(DBO_GR_MatchSingupResult)) return false;

  199. 

  200.                                                 //提取数据

  201.                                                 DBO_GR_MatchSingupResult * pMatchSignupResult = (DBO_GR_MatchSingupResult*)pData;

  202. 

  203.                                                 //报名失败

  204.                                                 if (pMatchSignupResult->bResultCode == false)

  205.                                                 {

  206.                                                     m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, pMatchSignupResult->szDescribeString, SMT_EJECT);

  207. 

  208.                                                     return true;

  209.                                                 }

  210. 

  211.                                                 //加入比赛

  212.                                                 if (m_pCurMatchGroup->OnUserSignUpMatch(pIServerUserItem) == false)

  213.                                                 {

  214.                                                     SendRoomMessage(pIServerUserItem, TEXT("报名失败"), SMT_CHAT);

  215.                                                     return false;

  216.                                                 }

  217. 

  218.                                                 //报名成功

  219.                                                 m_OnMatchUserItem.Add(pIServerUserItem);

  220.                                                 SendMatchInfo(NULL);

  221.                                                 if (m_pIGameServiceFrame != NULL)

  222.                                                 {

  223.                                                     SendRoomMessage(pIServerUserItem, TEXT("恭喜，报名成功，请等待系统为您安排座位！"), SMT_CHAT);

  224.                                                 }

  225. 

  226.                                                 //金币更新

  227.                                                 if (pIServerUserItem->IsAndroidUser() == false)

  228.                                                 {

  229.                                                     //构造结构

  230.                                                     CMD_GR_MatchGoldUpdate MatchGoldUpdate;

  231. 

  232.                                                     //设置变量

  233.                                                     MatchGoldUpdate.lCurrGold = pMatchSignupResult->lCurrGold;

  234.                                                     MatchGoldUpdate.lCurrIngot = pMatchSignupResult->lCurrIngot;

  235.                                                     MatchGoldUpdate.dwCurrExprience = pIServerUserItem->GetUserInfo()->dwExperience;

  236. 

  237.                                                     //发送数据

  238.                                                     return SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_GOLDUPDATE, &MatchGoldUpdate, sizeof(MatchGoldUpdate));

  239.                                                 }

  240. 

  241.                                                 break;

  242.     }

  243.     case DBO_GR_MATCH_UNSIGNUP_RESULT:		//退赛结果

  244.     {

  245.                                                 //参数效验

  246.                                                 if (pIServerUserItem == NULL) return true;

  247.                                                 if (wDataSize>sizeof(DBO_GR_MatchSingupResult)) return false;

  248. 

  249.                                                 //提取数据

  250.                                                 DBO_GR_MatchSingupResult * pMatchSignupResult = (DBO_GR_MatchSingupResult*)pData;

  251. 

  252.                                                 //退费失败

  253.                                                 if (pMatchSignupResult->bResultCode == false)

  254.                                                 {

  255.                                                     m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, pMatchSignupResult->szDescribeString, SMT_EJECT);

  256. 

  257.                                                     return true;

  258.                                                 }

  259. 

  260.                                                 //设置状态

  261.                                                 pIServerUserItem->SetSignUpStatus(MatchStatus_Null);

  262. 

  263.                                                 //变量定义

  264.                                                 LPCTSTR pszMatchFeeType[] = { TEXT("游戏币"), TEXT("元宝") };

  265.                                                 if (m_pMatchOption->cbMatchFeeType<CountArray(pszMatchFeeType))

  266.                                                 {

  267.                                                     //退费通知

  268.                                                     TCHAR szDescribe[128] = TEXT("");

  269.                                                     _sntprintf(szDescribe, CountArray(szDescribe), TEXT("退赛成功，退还报名费%I64d%s！"), m_pMatchOption->lMatchFee, pszMatchFeeType[m_pMatchOption->cbMatchFeeType]);

  270.                                                     m_pIGameServiceFrame->SendRoomMessage(pIServerUserItem, szDescribe, SMT_EJECT);

  271.                                                 }

  272. 

  273.                                                 //金币更新

  274.                                                 if (pIServerUserItem->IsAndroidUser() == false)

  275.                                                 {

  276.                                                     //构造结构

  277.                                                     CMD_GR_MatchGoldUpdate MatchGoldUpdate;

  278. 

  279.                                                     //设置变量

  280.                                                     MatchGoldUpdate.lCurrGold = pMatchSignupResult->lCurrGold;

  281.                                                     MatchGoldUpdate.lCurrIngot = pMatchSignupResult->lCurrIngot;

  282.                                                     MatchGoldUpdate.dwCurrExprience = pIServerUserItem->GetUserInfo()->dwExperience;

  283. 

  284.                                                     //发送数据

  285.                                                     return SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_GOLDUPDATE, &MatchGoldUpdate, sizeof(MatchGoldUpdate));

  286.                                                 }

  287. 

  288.                                                 break;

  289.     }

  290.     case DBO_GR_MATCH_RANK_LIST:			//比赛排行

  291.     {

  292.                                                 //参数校验

  293.                                                 ASSERT(wDataSize <= sizeof(DBO_GR_MatchRankList));

  294.                                                 if (wDataSize>sizeof(DBO_GR_MatchRankList)) return false;

  295. 

  296.                                                 //提取数据

  297.                                                 DBO_GR_MatchRankList * pMatchRankList = (DBO_GR_MatchRankList*)pData;

  298. 

  299.                                                 //变量定义

  300.                                                 IServerUserItem * pIRewardUserItem = NULL;

  301.                                                 tagMatchRankInfo * pMatchRankInfo = NULL;

  302. 

  303.                                                 //发放奖励

  304.                                                 for (WORD wIndex = 0; wIndex<pMatchRankList->wUserCount; wIndex++)

  305.                                                 {

  306.                                                     //查找玩家

  307.                                                     pMatchRankInfo = &pMatchRankList->MatchRankInfo[wIndex];

  308.                                                     pIRewardUserItem = m_pIServerUserManager->SearchUserItem(pMatchRankInfo->dwUserID);

  309.                                                     if (pIRewardUserItem == NULL || pIRewardUserItem->IsAndroidUser() == true) continue;

  310. 

  311.                                                     //写入奖励

  312.                                                     WriteUserAward(pIRewardUserItem, pMatchRankInfo);

  313.                                                 }

  314. 

  315.                                                 //变量定义

  316.                                                 CImmediateGroup * pImmediateGroup = NULL;

  317. 

  318.                                                 //查找分组

  319.                                                 for (int i = 0; i<m_MatchGroup.GetCount(); i++)

  320.                                                 {

  321.                                                     if (m_MatchGroup[i]->m_dwMatchNO == pMatchRankList->dwMatchNO)

  322.                                                     {

  323.                                                         pImmediateGroup = m_MatchGroup[i];

  324. 

  325.                                                         if (pImmediateGroup != NULL)

  326.                                                         {

  327.                                                             //全部起立

  328.                                                             pImmediateGroup->RearrangeUserSeat();

  329. 

  330.                                                             //发送可报名状态

  331.                                                             BYTE cbMatchStatus = MatchStatus_Null;

  332.                                                             SendGroupData(MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &cbMatchStatus, sizeof(cbMatchStatus), pImmediateGroup);

  333. 

  334.                                                             //还原编号

  335.                                                             m_LoopTimer.Add(pImmediateGroup->m_LoopTimer);

  336. 

  337.                                                             //参赛玩家退赛

  338.                                                             POSITION pos = pImmediateGroup->m_OnMatchUserMap.GetStartPosition();

  339.                                                             IServerUserItem *pITempUserItem = NULL;

  340.                                                             DWORD dwUserID = 0;

  341.                                                             WORD wQuitUserCount = 0;

  342.                                                             WORD wMatchUserCount = (WORD)pImmediateGroup->m_OnMatchUserMap.GetCount();

  343.                                                             while (pos != NULL)

  344.                                                             {

  345.                                                                 pImmediateGroup->m_OnMatchUserMap.GetNextAssoc(pos, dwUserID, pITempUserItem);

  346.                                                                 if (pITempUserItem != NULL)

  347.                                                                 {

  348.                                                                     pITempUserItem->SetSignUpStatus(MatchStatus_Null);

  349.                                                                     if (true == OnEventUserQuitMatch(pITempUserItem, 0))

  350.                                                                         wQuitUserCount++;

  351. 

  352.                                                                     //比赛结束后代打玩家未返回，则踢出房间

  353.                                                                     bool bAndroidUser = pITempUserItem->IsAndroidUser();

  354.                                                                     bool bTrusteeUser = pITempUserItem->IsTrusteeUser();

  355.                                                                     bool bClientReady = pITempUserItem->IsClientReady();

  356.                                                                     if (bAndroidUser == false && bTrusteeUser == true && bClientReady == false)

  357.                                                                     {

  358.                                                                         //离开桌子

  359.                                                                         WORD wTableID = pITempUserItem->GetTableID();

  360.                                                                         if (wTableID != INVALID_TABLE)

  361.                                                                         {

  362.                                                                             //状态判断

  363.                                                                             ASSERT(pITempUserItem->GetUserStatus() != US_PLAYING);

  364.                                                                             SendGameMessage(pITempUserItem, TEXT(""), SMT_CLOSE_GAME);

  365. 

  366.                                                                             //查找桌子并弹起

  367.                                                                             for (int m = 0; m<pImmediateGroup->m_MatchTableArray.GetCount(); m++)

  368.                                                                             {

  369.                                                                                 if (pITempUserItem->GetTableID() == pImmediateGroup->m_MatchTableArray[m]->wTableID)

  370.                                                                                 {

  371.                                                                                     pImmediateGroup->m_MatchTableArray[m]->pTableFrame->PerformStandUpAction(pITempUserItem);

  372.                                                                                     break;

  373.                                                                                 }

  374.                                                                             }

  375.                                                                         }

  376. 

  377.                                                                         //离开房间

  378.                                                                         if (pITempUserItem->GetBindIndex() == INVALID_WORD)

  379.                                                                         {

  380.                                                                             pITempUserItem->SetUserStatus(US_NULL, INVALID_TABLE, INVALID_CHAIR);

  381.                                                                         }

  382.                                                                     }

  383.                                                                 }

  384.                                                             }

  385. 

  386.                                                             //校验退赛结果

  387.                                                             ASSERT(wQuitUserCount == wMatchUserCount);

  388.                                                             if (wQuitUserCount != wMatchUserCount)

  389.                                                             {

  390.                                                                 CTraceService::TraceString(TEXT("比赛结束后，退赛人数异常"), TraceLevel_Exception);

  391.                                                             }

  392. 

  393.                                                             //回收全部桌子

  394.                                                             for (int j = 0; pImmediateGroup->m_MatchTableArray.GetCount();)

  395.                                                             {

  396.                                                                 tagTableFrameInfo* pTempTable = pImmediateGroup->m_MatchTableArray[j];

  397.                                                                 pImmediateGroup->m_MatchTableArray.RemoveAt(j);

  398.                                                                 SafeDelete(pTempTable);

  399.                                                             }

  400.                                                         }

  401.                                                         //移除对象

  402.                                                         m_MatchGroup.RemoveAt(i);

  403.                                                         m_OverMatchGroup.Add(pImmediateGroup);

  404. 

  405.                                                         break;

  406.                                                     }

  407.                                                 }

  408. 

  409. 

  410.                                                 break;

  411.     }

  412.     case DBO_GR_MATCH_REWARD_RESULT:		//奖励结果

  413.     {

  414.                                                 //参数效验

  415.                                                 if (pIServerUserItem == NULL) return true;

  416.                                                 if (wDataSize>sizeof(DBR_GR_MatchRewardResult)) return false;

  417. 

  418.                                                 //提取数据

  419.                                                 DBR_GR_MatchRewardResult * pMatchRewardResult = (DBR_GR_MatchRewardResult*)pData;

  420. 

  421.                                                 //奖励成功

  422.                                                 if (pMatchRewardResult->bResultCode == true)

  423.                                                 {

  424.                                                     //构造结构

  425.                                                     CMD_GR_MatchGoldUpdate MatchGoldUpdate;

  426. 

  427.                                                     //设置变量

  428.                                                     MatchGoldUpdate.lCurrGold = pMatchRewardResult->lCurrGold;

  429.                                                     MatchGoldUpdate.lCurrIngot = pMatchRewardResult->lCurrIngot;

  430.                                                     MatchGoldUpdate.dwCurrExprience = pMatchRewardResult->dwCurrExperience;

  431. 

  432.                                                     //发送数据

  433.                                                     SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_GOLDUPDATE, &MatchGoldUpdate, sizeof(MatchGoldUpdate));

  434.                                                 }

  435. 

  436.                                                 break;

  437.     }

  438.     }

  439.     return true;

  440. }

  441. 

  442. //命令消息

  443. bool CImmediateMatch::OnEventSocketMatch(WORD wSubCmdID, VOID * pData, WORD wDataSize, IServerUserItem * pIServerUserItem, DWORD dwSocketID)

  444. {

  445.     switch (wSubCmdID)

  446.     {

  447.     case SUB_GR_MATCH_FEE:	//比赛费用

  448.     {

  449.                                 //参数效验

  450.                                 ASSERT(wDataSize == sizeof(SCORE));

  451.                                 if (wDataSize != sizeof(SCORE)) return false;

  452. 

  453.                                 //提取数据

  454.                                 SCORE lMatchFee = *(SCORE*)pData;

  455.                                 if (lMatchFee != m_pMatchOption->lMatchFee)return false;

  456. 

  457.                                 //变量定义

  458.                                 DBR_GR_MatchSignup MatchSignup;

  459.                                 ZeroMemory(&MatchSignup, sizeof(MatchSignup));

  460. 

  461.                                 //构造结构

  462.                                 MatchSignup.dwUserID = pIServerUserItem->GetUserID();

  463.                                 MatchSignup.lMatchFee = m_pMatchOption->lMatchFee;

  464.                                 MatchSignup.dwInoutIndex = pIServerUserItem->GetInoutIndex();

  465.                                 MatchSignup.dwClientAddr = pIServerUserItem->GetClientAddr();

  466.                                 MatchSignup.dwMatchID = m_pMatchOption->dwMatchID;

  467.                                 MatchSignup.dwMatchNO = m_pCurMatchGroup->m_dwMatchNO;

  468.                                 lstrcpyn(MatchSignup.szMachineID, pIServerUserItem->GetMachineID(), CountArray(MatchSignup.szMachineID));

  469. 

  470.                                 //投递数据

  471.                                 m_pIDataBaseEngine->PostDataBaseRequest(MatchSignup.dwUserID, DBR_GR_MATCH_SIGNUP, dwSocketID, &MatchSignup, sizeof(MatchSignup));

  472. 

  473.                                 return true;

  474.     }

  475.     case SUB_GR_LEAVE_MATCH:	//退出比赛

  476.     {

  477.                                     //参数效验

  478.                                     ASSERT(pIServerUserItem != NULL);

  479.                                     if (pIServerUserItem == NULL) return false;

  480. 

  481.                                     OnEventUserQuitMatch(pIServerUserItem, 0, 0, dwSocketID);

  482. 

  483.                                     return true;

  484.     }

  485.     }

  486.     return true;

  487. }

  488. 

  489. //用户登录

  490. bool CImmediateMatch::OnEventUserLogon(IServerUserItem * pIServerUserItem)

  491. {

  492.     return SendMatchInfo(pIServerUserItem);

  493. }

  494. 

  495. //用户登出

  496. bool CImmediateMatch::OnEventUserLogout(IServerUserItem * pIServerUserItem)

  497. {

  498.     return true;

  499. }

  500. 

  501. //进入事件

  502. bool CImmediateMatch::OnEventEnterMatch(DWORD dwSocketID, VOID* pData, DWORD dwUserIP, bool bIsMobile)

  503. {

  504.     //手机用户

  505.     if (bIsMobile == true)

  506.     {

  507.         //处理消息

  508.         CMD_GR_LogonMobile * pLogonMobile = (CMD_GR_LogonMobile *)pData;

  509.         pLogonMobile->szPassword[CountArray(pLogonMobile->szPassword) - 1] = 0;

  510.         pLogonMobile->szMachineID[CountArray(pLogonMobile->szMachineID) - 1] = 0;

  511. 

  512.         //变量定义

  513.         DBR_GR_LogonMobile LogonMobile;

  514.         ZeroMemory(&LogonMobile, sizeof(LogonMobile));

  515. 

  516.         //构造数据

  517.         LogonMobile.dwUserID = pLogonMobile->dwUserID;

  518.         LogonMobile.dwClientAddr = dwUserIP;

  519.         LogonMobile.dwMatchID = m_pMatchOption->dwMatchID;

  520.         LogonMobile.dwMatchNO = m_pMatchOption->dwMatchNO;

  521.         LogonMobile.cbDeviceType = pLogonMobile->cbDeviceType;

  522.         LogonMobile.wBehaviorFlags = pLogonMobile->wBehaviorFlags;

  523.         LogonMobile.wPageTableCount = pLogonMobile->wPageTableCount;

  524.         lstrcpyn(LogonMobile.szPassword, pLogonMobile->szPassword, CountArray(LogonMobile.szPassword));

  525.         lstrcpyn(LogonMobile.szMachineID, pLogonMobile->szMachineID, CountArray(LogonMobile.szMachineID));

  526. 

  527.         //投递请求

  528.         m_pIDataBaseEngine->PostDataBaseRequest(LogonMobile.dwUserID, DBR_GR_LOGON_MOBILE, dwSocketID, &LogonMobile, sizeof(LogonMobile));

  529.     }

  530.     else

  531.     {

  532.         //处理消息

  533.         CMD_GR_LogonUserID * pLogonUserID = (CMD_GR_LogonUserID *)pData;

  534.         pLogonUserID->szPassword[CountArray(pLogonUserID->szPassword) - 1] = 0;

  535.         pLogonUserID->szMachineID[CountArray(pLogonUserID->szMachineID) - 1] = 0;

  536. 

  537.         //变量定义

  538.         DBR_GR_LogonUserID LogonUserID;

  539.         ZeroMemory(&LogonUserID, sizeof(LogonUserID));

  540. 

  541.         //构造数据

  542.         LogonUserID.dwClientAddr = dwUserIP;

  543.         LogonUserID.dwUserID = pLogonUserID->dwUserID;

  544.         LogonUserID.dwMatchID = m_pMatchOption->dwMatchID;

  545.         LogonUserID.dwMatchNO = m_pMatchOption->dwMatchNO;

  546.         lstrcpyn(LogonUserID.szPassword, pLogonUserID->szPassword, CountArray(LogonUserID.szPassword));

  547.         lstrcpyn(LogonUserID.szMachineID, pLogonUserID->szMachineID, CountArray(LogonUserID.szMachineID));

  548. 

  549.         //投递请求

  550.         m_pIDataBaseEngine->PostDataBaseRequest(LogonUserID.dwUserID, DBR_GR_LOGON_USERID, dwSocketID, &LogonUserID, sizeof(LogonUserID));

  551.     }

  552. 

  553.     return true;

  554. }

  555. 

  556. //用户参赛

  557. bool CImmediateMatch::OnEventUserJoinMatch(IServerUserItem * pIServerUserItem, BYTE cbReason, DWORD dwSocketID)

  558. {

  559.     ASSERT(pIServerUserItem != NULL);

  560.     if (pIServerUserItem == NULL)

  561.     {

  562.         CTraceService::TraceString(TEXT("用户指针为空!"), TraceLevel_Warning);

  563.         return true;

  564.     }

  565. 

  566.     if (CServerRule::IsForfendRoomEnter(m_pGameServiceOption->dwServerRule))

  567.     {

  568.         SendRoomMessage(pIServerUserItem, TEXT("抱歉，由于系统维护，该房间禁止用户报名比赛！。"), SMT_CHAT | SMT_EJECT);

  569.         return true;

  570.     }

  571.     WORD wTableCount = GetNullTable();

  572.     if (wTableCount<m_pMatchOption->MatchType.Immediate.wStartUserCount / CImmediateGroup::m_wChairCount)

  573.     {

  574.         CString str;

  575.         str.Format(TEXT("抱歉，当前桌子不够请等待。还差 %d 张桌子可以报名"), m_pMatchOption->MatchType.Immediate.wStartUserCount / CImmediateGroup::m_wChairCount - wTableCount);

  576.         SendRoomMessage(pIServerUserItem, str, SMT_CHAT);

  577.         return true;

  578.     }

  579.     if (m_pCurMatchGroup == NULL || m_pCurMatchGroup->m_enMatchStatus == MatchStatus_Wait)

  580.     {

  581.         SendRoomMessage(pIServerUserItem, TEXT("抱歉，该房间参赛人数已满，请稍后再报名或者进入另一房间比赛。"), SMT_CHAT);

  582.         return true;

  583.     }

  584. 

  585.     INT_PTR dwUserCount = m_OnMatchUserItem.GetCount();

  586.     for (INT_PTR i = 0; i<dwUserCount; i++)

  587.     {

  588.         if (m_OnMatchUserItem[i]->GetUserID() == pIServerUserItem->GetUserID())

  589.         {

  590.             SendRoomMessage(pIServerUserItem, TEXT("您已经成功报名，不能重复报名！"), SMT_CHAT | SMT_EJECT);

  591.             return true;

  592.         }

  593.     }

  594. 

  595.     if (m_LoopTimer.GetCount() == 0)

  596.     {

  597.         SendRoomMessage(pIServerUserItem, TEXT("抱歉，比赛编号不够请稍等。"), SMT_CHAT);

  598.         return true;

  599.     }

  600. 

  601.     if (pIServerUserItem->GetUserStatus() != US_FREE || pIServerUserItem->GetTableID() != INVALID_TABLE)

  602.     {

  603.         SendRoomMessage(pIServerUserItem, TEXT("对不起，您当前的状态不允许参加比赛！"), SMT_CHAT);

  604.         return true;

  605.     }

  606. 

  607.     if (m_pMatchOption->MatchType.Immediate.dwInitalScore == 0 && pIServerUserItem->GetUserScore()<m_pMatchOption->MatchType.Immediate.dwInitalBase*m_pMatchOption->MatchType.Immediate.wMinEnterGold + m_pMatchOption->lMatchFee)

  608.     {

  609.         TCHAR szMsg[256] = TEXT("");

  610.         _sntprintf(szMsg, CountArray(szMsg), TEXT("对不起，您当前的金币低于了%d，不能参加比赛！"),

  611.             m_pMatchOption->MatchType.Immediate.dwInitalBase*m_pMatchOption->MatchType.Immediate.wMinEnterGold + m_pMatchOption->lMatchFee);

  612.         SendRoomMessage(pIServerUserItem, szMsg, SMT_CHAT | SMT_EJECT);

  613.         return true;

  614.     }

  615. 

  616.     //真人扣报名费

  617.     if (m_pMatchOption->lMatchFee>0 && pIServerUserItem->IsAndroidUser() == false)

  618.     {

  619.         ASSERT(m_pIGameServiceFrame != NULL);

  620.         if (m_pIGameServiceFrame == NULL)

  621.         {

  622.             CTraceService::TraceString(TEXT("服务框架指针为空!"), TraceLevel_Warning);

  623.             return true;

  624.         }

  625. 

  626.         //构造结构

  627.         CMD_GR_Match_Fee MatchFee;

  628.         MatchFee.lMatchFee = m_pMatchOption->lMatchFee;

  629. 

  630.         //构造提示

  631.         if (MatchFee.lMatchFee>0)

  632.         {

  633.             //变量定义

  634.             LPCTSTR pszMatchFeeType[] = { TEXT("游戏币"), TEXT("元宝") };

  635.             if (m_pMatchOption->cbMatchFeeType<CountArray(pszMatchFeeType))

  636.             {

  637.                 _sntprintf(MatchFee.szNotifyContent, CountArray(MatchFee.szNotifyContent), TEXT("参赛将扣除报名费 %I64d %s，确认要参赛吗？"), m_pMatchOption->lMatchFee, pszMatchFeeType[m_pMatchOption->cbMatchFeeType]);

  638.             }

  639.         }

  640. 

  641.         //发送消息

  642.         WORD wDataSize = sizeof(MatchFee)-sizeof(MatchFee.szNotifyContent);

  643.         wDataSize += CountStringBuffer(MatchFee.szNotifyContent);

  644.         m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_FEE, &MatchFee, wDataSize);

  645. 

  646.         return true;

  647.     }

  648. 

  649.     //机器人报名

  650.     if (m_pMatchOption->lMatchFee == 0 || pIServerUserItem->IsAndroidUser() == true)

  651.     {

  652.         //机器数判断

  653.         if (pIServerUserItem->IsAndroidUser() == true && (m_pCurMatchGroup->m_wAndroidUserCount >=

  654.             m_pMatchOption->MatchType.Immediate.wAndroidUserCount))

  655.         {

  656.             return true;

  657.         }

  658. 

  659.         return OnEventSocketMatch(SUB_GR_MATCH_FEE, &m_pMatchOption->lMatchFee, sizeof(SCORE), pIServerUserItem, dwSocketID);

  660.     }

  661. 

  662.     //报名成功

  663.     m_OnMatchUserItem.Add(pIServerUserItem);

  664.     SendMatchInfo(NULL);

  665.     if (m_pIGameServiceFrame != NULL)

  666.     {

  667.         SCORE lScore = SCORE(m_pMatchOption->lMatchFee)*-1;

  668.         /*if(m_pMatchOption->MatchType.Immediate.dwInitalScore==0)

  669.         {

  670.         pIServerUserItem->GetUserInfo()->lScore+=lScore;

  671.         m_pIServerUserItemSink->OnEventUserItemScore(pIServerUserItem,SCORE_REASON_MATCH_FEE);

  672.         }*/

  673.         SendRoomMessage(pIServerUserItem, TEXT("恭喜，报名成功，请等待系统为您安排座位！"), SMT_CHAT);

  674.     }

  675. 

  676.     return true;

  677. }

  678. 

  679. //用户退赛

  680. bool CImmediateMatch::OnEventUserQuitMatch(IServerUserItem * pIServerUserItem, BYTE cbReason, WORD *pBestRank, DWORD dwContextID)

  681. {

  682.     ASSERT(pIServerUserItem != NULL);

  683.     if (pIServerUserItem == NULL) return false;

  684. 

  685.     //正在游戏状态

  686.     if (pIServerUserItem->GetUserStatus() >= US_PLAYING)

  687.     {

  688.         return true;

  689.     }

  690. 

  691.     //正在比赛阶段

  692.     BYTE cbUserEnlist = pIServerUserItem->GetSignUpStatus();

  693.     if (cbUserEnlist == MS_MATCHING)

  694.     {

  695.         return true;

  696.     }

  697. 

  698.     //否则玩家退赛

  699.     if (RemoveMatchUserItem(pIServerUserItem))

  700.     {

  701.         //从正在比赛的组中删除该玩家

  702.         INT_PTR nGroupCount = m_MatchGroup.GetCount();

  703.         for (INT_PTR i = 0; i<nGroupCount; i++)

  704.         {

  705.             CImmediateGroup *pMatch = m_MatchGroup[i];

  706.             if (pMatch->OnUserQuitMatch(pIServerUserItem))

  707.             {

  708.                 //if(pMatch->m_enMatchStatus!=MatchStatus_Signup && pMatch->m_enMatchStatus!=MatchStatus_Wait)

  709.                 //{

  710.                 //	SendRoomMessage(pIServerUserItem, TEXT("退赛成功，欢迎您继续参加其他比赛！"), SMT_CHAT|SMT_EJECT);

  711.                 //}

  712.                 if (pMatch->m_enMatchStatus != MatchStatus_Null)

  713.                 {

  714.                     SendRoomMessage(pIServerUserItem, TEXT("退赛成功，欢迎您继续参加其他比赛！"), SMT_CHAT | SMT_EJECT);

  715.                 }

  716.                 return true;

  717.             }

  718.         }

  719. 

  720.         //从正在报名的组中删除该玩家

  721.         if (m_pCurMatchGroup->OnUserQuitMatch(pIServerUserItem))

  722.         {

  723.             //退还报名费

  724.             if (m_pMatchOption->lMatchFee>0 && !pIServerUserItem->IsAndroidUser())

  725.             {

  726.                 //变量定义

  727.                 DBR_GR_MatchSignup MatchSignup;

  728.                 MatchSignup.dwUserID = pIServerUserItem->GetUserID();

  729. 

  730.                 //构造结构

  731.                 MatchSignup.lMatchFee = m_pMatchOption->lMatchFee;

  732.                 MatchSignup.dwInoutIndex = pIServerUserItem->GetInoutIndex();

  733.                 MatchSignup.dwClientAddr = pIServerUserItem->GetClientAddr();

  734.                 MatchSignup.dwMatchID = m_pMatchOption->dwMatchID;

  735.                 MatchSignup.dwMatchNO = m_pCurMatchGroup->m_dwMatchNO;

  736.                 lstrcpyn(MatchSignup.szMachineID, pIServerUserItem->GetMachineID(), CountArray(MatchSignup.szMachineID));

  737. 

  738.                 //投递数据

  739.                 m_pIDataBaseEngine->PostDataBaseRequest(MatchSignup.dwUserID, DBR_GR_MATCH_UNSIGNUP, dwContextID, &MatchSignup, sizeof(MatchSignup));

  740.             }

  741. 

  742.             if (m_pCurMatchGroup->m_enMatchStatus != MatchStatus_Null)

  743.             {

  744.                 SendRoomMessage(pIServerUserItem, TEXT("退赛成功，欢迎您继续参加其他比赛！"), SMT_CHAT | SMT_EJECT);

  745.             }

  746. 

  747.             SendMatchInfo(NULL);

  748.             return true;

  749.         }

  750.         SendMatchInfo(NULL);

  751.     }

  752. 

  753.     return false;

  754. }

  755. 

  756. //用户积分

  757. bool CImmediateMatch::OnEventUserItemScore(IServerUserItem * pIServerUserItem, BYTE cbReason)

  758. {

  759.     //效验参数

  760.     ASSERT(pIServerUserItem != NULL);

  761.     if (pIServerUserItem == NULL) return false;

  762. 

  763.     //获取对象

  764.     CImmediateGroup * pImmediateGroup = static_cast<CImmediateGroup *>(pIServerUserItem->GetMatchData());

  765.     if (pImmediateGroup == NULL)

  766.     {

  767.         return m_pIServerUserItemSink->OnEventUserItemScore(pIServerUserItem, cbReason);

  768.     }

  769. 

  770.     //发送分数

  771.     SendGroupUserScore(pIServerUserItem, pImmediateGroup);

  772. 

  773.     //变量定义

  774.     tagUserInfo * pUserInfo = pIServerUserItem->GetUserInfo();

  775. 

  776.     //变量定义

  777.     CMD_GR_MobileUserScore MobileUserScore;

  778. 

  779.     //构造数据

  780.     MobileUserScore.dwUserID = pUserInfo->dwUserID;

  781.     MobileUserScore.UserScore.dwWinCount = pUserInfo->dwWinCount;

  782.     MobileUserScore.UserScore.dwLostCount = pUserInfo->dwLostCount;

  783.     MobileUserScore.UserScore.dwDrawCount = pUserInfo->dwDrawCount;

  784.     MobileUserScore.UserScore.dwFleeCount = pUserInfo->dwFleeCount;

  785.     MobileUserScore.UserScore.dwExperience = pUserInfo->dwExperience;

  786. 

  787.     //构造积分

  788.     MobileUserScore.UserScore.lScore = pUserInfo->lScore;

  789.     MobileUserScore.UserScore.lScore += pIServerUserItem->GetTrusteeScore();

  790.     MobileUserScore.UserScore.lScore += pIServerUserItem->GetFrozenedScore();

  791. 

  792.     //发送数据

  793.     m_pIGameServiceFrame->SendDataBatchToMobileUser(pIServerUserItem->GetTableID(), MDM_GR_USER, SUB_GR_USER_SCORE, &MobileUserScore, sizeof(MobileUserScore));

  794. 

  795.     //即时写分

  796.     if ((CServerRule::IsImmediateWriteScore(m_pGameServiceOption->dwServerRule) == true) && (pIServerUserItem->IsVariation() == true))

  797.     {

  798.         //变量定义

  799.         DBR_GR_WriteGameScore WriteGameScore;

  800.         ZeroMemory(&WriteGameScore, sizeof(WriteGameScore));

  801. 

  802.         //用户信息

  803.         WriteGameScore.dwUserID = pIServerUserItem->GetUserID();

  804.         WriteGameScore.dwDBQuestID = pIServerUserItem->GetDBQuestID();

  805.         WriteGameScore.dwClientAddr = pIServerUserItem->GetClientAddr();

  806.         WriteGameScore.dwInoutIndex = pIServerUserItem->GetInoutIndex();

  807. 

  808.         //提取积分

  809.         pIServerUserItem->DistillVariation(WriteGameScore.VariationInfo);

  810. 

  811.         //比赛信息

  812.         WriteGameScore.dwMatchID = m_pMatchOption->dwMatchID;

  813.         WriteGameScore.dwMatchNO = pImmediateGroup->m_dwMatchNO;

  814. 

  815.         //投递请求

  816.         m_pIDataBaseEngine->PostDataBaseRequest(WriteGameScore.dwUserID, DBR_GR_WRITE_GAME_SCORE, 0L, &WriteGameScore, sizeof(WriteGameScore), TRUE);

  817.     }

  818. 

  819.     return true;

  820. }

  821. 

  822. //用户状态

  823. bool CImmediateMatch::OnEventUserItemStatus(IServerUserItem * pIServerUserItem, WORD wOldTableID, WORD wOldChairID, bool bSendState)

  824. {

  825.     //清除数据

  826.     if (pIServerUserItem->GetUserStatus() == US_FREE) pIServerUserItem->SetMatchData(NULL);

  827. 

  828.     //回调接口

  829.     if (m_pIServerUserItemSink != NULL)

  830.     {

  831.         return m_pIServerUserItemSink->OnEventUserItemStatus(pIServerUserItem, wOldTableID, wOldChairID);

  832.     }

  833. 

  834.     return true;

  835. }

  836. 

  837. //用户权限

  838. bool CImmediateMatch::OnEventUserItemRight(IServerUserItem *pIServerUserItem, DWORD dwAddRight, DWORD dwRemoveRight, BYTE cbRightKind)

  839. {

  840.     if (m_pIServerUserItemSink != NULL)

  841.     {

  842.         return m_pIServerUserItemSink->OnEventUserItemRight(pIServerUserItem, dwAddRight, dwRemoveRight, cbRightKind);

  843.     }

  844. 

  845.     return true;

  846. }

  847. 

  848. //报名人满，开始比赛

  849. bool CImmediateMatch::OnEventMatchStart(CImmediateGroup *pMatch)

  850. {

  851.     ASSERT(pMatch == m_pCurMatchGroup&&m_LoopTimer.GetCount()>0);

  852. 

  853.     //编号不够 不能报名的

  854.     pMatch->m_LoopTimer = m_LoopTimer[0];

  855.     m_LoopTimer.RemoveAt(0);

  856.     m_MatchGroup.Add(pMatch);

  857. 

  858.     //准备新的一组比赛

  859.     m_pCurMatchGroup = new CImmediateGroup((DWORD)time(NULL), m_pMatchOption, this);

  860. 

  861.     SendMatchInfo(NULL);

  862.     BYTE cbMatchStatus = MS_MATCHING;

  863.     SendGroupData(MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &cbMatchStatus, sizeof(cbMatchStatus), pMatch);

  864. 

  865.     return true;

  866. }

  867. 

  868. 

  869. //比赛结束

  870. bool CImmediateMatch::OnEventMatchOver(CImmediateGroup *pMatch)

  871. {

  872.     //比赛结束

  873.     if (pMatch != NULL)

  874.     {

  875.         DBR_GR_MatchOver MatchOver;

  876.         ZeroMemory(&MatchOver, sizeof(MatchOver));

  877. 

  878.         //构造数据						

  879.         MatchOver.dwMatchID = m_pMatchOption->dwMatchID;

  880.         MatchOver.dwMatchNO = pMatch->m_dwMatchNO;

  881.         MatchOver.cbMatchType = MATCH_TYPE_IMMEDIATE;

  882.         MatchOver.wServerID = m_pGameServiceOption->wServerID;

  883. 

  884.         //获取时间

  885.         MatchOver.MatchStartTime = pMatch->m_MatchStartTime;

  886.         CTime::GetCurrentTime().GetAsSystemTime(MatchOver.MatchEndTime);

  887. 

  888.         //投递请求

  889.         m_pIDataBaseEngine->PostDataBaseRequest(0, DBR_GR_MATCH_OVER, 0, &MatchOver, sizeof(MatchOver));

  890.     }

  891. 

  892.     return true;

  893. }

  894. 

  895. //关闭定时器

  896. bool CImmediateMatch::KillGameTimer(DWORD dwTimerID, CImmediateGroup *pMatch)

  897. {

  898.     m_pITimerEngine->KillTimer(dwTimerID);

  899. 

  900.     return false;

  901. }

  902. 

  903. //设置定时器

  904. bool CImmediateMatch::SetGameTimer(DWORD dwTimerID, DWORD dwElapse, DWORD dwRepeat, WPARAM dwBindParameter, CImmediateGroup *pMatch)

  905. {

  906.     return m_pITimerEngine->SetTimer(dwTimerID, dwElapse, dwRepeat, dwBindParameter);

  907. }

  908. 

  909. 

  910. //发送数据

  911. bool CImmediateMatch::SendMatchInfo(IServerUserItem * pIServerUserItem)

  912. {

  913.     CMD_GR_Match_Num MatchNum;

  914.     MatchNum.dwWaitting = (DWORD)m_pCurMatchGroup->m_OnMatchUserMap.GetCount();

  915.     MatchNum.dwTotal = m_pMatchOption->MatchType.Immediate.wStartUserCount;

  916.     if (pIServerUserItem == NULL)

  917.     {

  918.         m_pIGameServiceFrame->SendData(BG_ALL_CLIENT, MDM_GR_MATCH, SUB_GR_MATCH_NUM, &MatchNum, sizeof(MatchNum));

  919.         return true;

  920.     }

  921. 

  922.     m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_NUM, &MatchNum, sizeof(MatchNum));

  923.     m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_DESC, &m_MatchDesc, sizeof(m_MatchDesc));

  924.     INT_PTR dwUserCount = m_OnMatchUserItem.GetCount();

  925.     for (INT_PTR i = 0; i<dwUserCount; i++)

  926.     {

  927.         if (m_OnMatchUserItem[i] == pIServerUserItem)

  928.         {

  929.             BYTE cbMatchStatus = pIServerUserItem->GetSignUpStatus();

  930.             m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &cbMatchStatus, sizeof(cbMatchStatus));

  931.             return true;

  932.         }

  933.     }

  934. 

  935.     tagUserInfo *pUserScore = pIServerUserItem->GetUserInfo();

  936.     pUserScore->dwWinCount = pUserScore->dwLostCount = pUserScore->dwFleeCount = pUserScore->dwDrawCount = pUserScore->cbGender = 0;

  937.     if ((SCORE)m_pMatchOption->MatchType.Immediate.dwInitalScore != 0)

  938.     {

  939.         pUserScore->lScore = (LONG)m_pMatchOption->MatchType.Immediate.dwInitalScore;

  940.     }

  941. 

  942.     return SendGroupUserScore(pIServerUserItem, NULL);

  943. }

  944. 

  945. 

  946. //发送信息

  947. bool CImmediateMatch::SendGroupUserMessage(LPCTSTR pStrMessage, CImmediateGroup *pMatch)

  948. {

  949.     POSITION pos = pMatch->m_OnMatchUserMap.GetStartPosition();

  950.     IServerUserItem *pUserItem = NULL;

  951.     DWORD dwUserID = 0;

  952.     while (pos != NULL)

  953.     {

  954.         pMatch->m_OnMatchUserMap.GetNextAssoc(pos, dwUserID, pUserItem);

  955.         SendGameMessage(pUserItem, pStrMessage, SMT_CHAT | SMT_TABLE_ROLL);

  956.     }

  957.     return true;

  958. }

  959. 

  960. 

  961. //发送用户分数

  962. bool CImmediateMatch::SendGroupUserScore(IServerUserItem * pIServerUserItem, CImmediateGroup *pMatch)

  963. {

  964.     //发送数据

  965.     CMD_GR_UserScore UserScore;

  966.     ZeroMemory(&UserScore, sizeof(UserScore));

  967. 

  968.     tagUserInfo * pUserInfo = pIServerUserItem->GetUserInfo();

  969. 

  970.     //构造数据

  971.     UserScore.dwUserID = pUserInfo->dwUserID;

  972.     UserScore.UserScore.dwWinCount = pUserInfo->dwWinCount;

  973.     UserScore.UserScore.dwLostCount = pUserInfo->dwLostCount;

  974.     UserScore.UserScore.dwDrawCount = pUserInfo->dwDrawCount;

  975.     UserScore.UserScore.dwFleeCount = pUserInfo->dwFleeCount;

  976.     UserScore.UserScore.dwExperience = pUserInfo->dwExperience;

  977.     UserScore.UserScore.lLoveLiness = pUserInfo->lLoveLiness;

  978. 

  979.     //构造积分

  980. 	UserScore.UserScore.lIngot = 0;// pUserInfo->lIngot;

  981.     UserScore.UserScore.lGrade = pUserInfo->lGrade;

  982.     UserScore.UserScore.lInsure = pUserInfo->lInsure;

  983. 

  984.     //构造积分

  985.     UserScore.UserScore.lScore = pUserInfo->lScore;

  986. 

  987.     if (pMatch != NULL)

  988.     {

  989.         POSITION pos = pMatch->m_OnMatchUserMap.GetStartPosition();

  990.         IServerUserItem *pUserItem = NULL;

  991.         DWORD dwUserID = 0;

  992.         while (pos != NULL)

  993.         {

  994.             pMatch->m_OnMatchUserMap.GetNextAssoc(pos, dwUserID, pUserItem);

  995.             m_pIGameServiceFrame->SendData(pUserItem, MDM_GR_USER, SUB_GR_USER_SCORE, &UserScore, sizeof(UserScore));

  996.         }

  997.         return true;

  998.     }

  999. 

  1000.     return m_pIGameServiceFrame->SendData(BG_COMPUTER, MDM_GR_USER, SUB_GR_USER_SCORE, &UserScore, sizeof(UserScore));

  1001. }

  1002. 

  1003. 

  1004. //发送状态

  1005. bool  CImmediateMatch::SendGroupUserStatus(IServerUserItem * pIServerUserItem, CImmediateGroup *pMatch)

  1006. {

  1007.     //效验参数

  1008.     ASSERT(pIServerUserItem != NULL);

  1009.     ASSERT(pIServerUserItem->IsClientReady() == true);

  1010.     if (pIServerUserItem->IsClientReady() == false) return false;

  1011. 

  1012.     //变量定义

  1013.     CMD_GR_UserStatus UserStatus;

  1014.     ZeroMemory(&UserStatus, sizeof(UserStatus));

  1015. 

  1016.     tagUserInfo * pUserData = pIServerUserItem->GetUserInfo();

  1017. 

  1018.     //构造数据

  1019.     UserStatus.dwUserID = pUserData->dwUserID;

  1020.     UserStatus.UserStatus.wTableID = pUserData->wTableID;

  1021.     UserStatus.UserStatus.wChairID = pUserData->wChairID;

  1022.     UserStatus.UserStatus.cbUserStatus = pUserData->cbUserStatus;

  1023. 

  1024.     POSITION pos = pMatch->m_OnMatchUserMap.GetStartPosition();

  1025.     IServerUserItem *pUserItem = NULL;

  1026.     DWORD dwUserID = 0;

  1027.     while (pos != NULL)

  1028.     {

  1029.         pMatch->m_OnMatchUserMap.GetNextAssoc(pos, dwUserID, pUserItem);

  1030.         if (pUserItem->IsClientReady())

  1031.             m_pIGameServiceFrame->SendData(pUserItem, MDM_GR_USER, SUB_GR_USER_STATUS, &UserStatus, sizeof(UserStatus));

  1032.     }

  1033.     return true;

  1034. }

  1035. 

  1036. 

  1037. //发送游戏消息

  1038. bool CImmediateMatch::SendGameMessage(IServerUserItem * pIServerUserItem, LPCTSTR lpszMessage, WORD wMessageType)

  1039. {

  1040.     ASSERT(pIServerUserItem != -NULL);

  1041.     if (pIServerUserItem == NULL) return false;

  1042. 

  1043.     //发送数据

  1044.     if ((pIServerUserItem->GetBindIndex() != INVALID_WORD) && (pIServerUserItem->IsClientReady() == true) && (pIServerUserItem->IsAndroidUser() == false))

  1045.     {

  1046.         //构造数据包

  1047.         CMD_CM_SystemMessage Message;

  1048.         Message.wType = wMessageType;

  1049.         lstrcpyn(Message.szString, lpszMessage, CountArray(Message.szString));

  1050.         Message.wLength = CountStringBuffer(Message.szString);

  1051. 

  1052.         //发送数据

  1053.         WORD wSendSize = sizeof(Message)-sizeof(Message.szString) + Message.wLength*sizeof(TCHAR);

  1054.         return m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GF_FRAME, SUB_GF_SYSTEM_MESSAGE, &Message, wSendSize);

  1055.     }

  1056. 

  1057.     return true;

  1058. }

  1059. 

  1060. 

  1061. //发送消息

  1062. bool CImmediateMatch::SendRoomMessage(IServerUserItem * pIServerUserItem, LPCTSTR lpszMessage, WORD wMessageType)

  1063. {

  1064.     ASSERT(pIServerUserItem != -NULL);

  1065.     if (pIServerUserItem == NULL) return false;

  1066. 

  1067.     //发送数据

  1068.     if (pIServerUserItem->GetBindIndex() != INVALID_WORD && false == pIServerUserItem->IsAndroidUser())

  1069.     {

  1070.         //构造数据包

  1071.         CMD_CM_SystemMessage Message;

  1072.         Message.wType = wMessageType;

  1073. 

  1074.         lstrcpyn(Message.szString, lpszMessage, CountArray(Message.szString));

  1075.         Message.wLength = CountStringBuffer(Message.szString);

  1076. 

  1077.         //发送数据

  1078.         WORD wSendSize = sizeof(Message)-sizeof(Message.szString) + Message.wLength*sizeof(TCHAR);

  1079.         return m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_CM_SYSTEM, SUB_CM_SYSTEM_MESSAGE, &Message, wSendSize);

  1080.     }

  1081. 

  1082.     return true;

  1083. }

  1084. 

  1085. //发送数据到一组用户

  1086. bool CImmediateMatch::SendGroupData(WORD wMainCmdID, WORD wSubCmdID, void * pData, WORD wDataSize, CImmediateGroup *pMatch)

  1087. {

  1088.     POSITION pos = pMatch->m_OnMatchUserMap.GetStartPosition();

  1089.     IServerUserItem *pUserItem = NULL;

  1090.     DWORD dwUserID = 0;

  1091.     while (pos != NULL)

  1092.     {

  1093.         pMatch->m_OnMatchUserMap.GetNextAssoc(pos, dwUserID, pUserItem);

  1094.         m_pIGameServiceFrame->SendData(pUserItem, wMainCmdID, wSubCmdID, pData, wDataSize);

  1095.     }

  1096.     return true;

  1097. }

  1098. 

  1099. //发送数据

  1100. bool CImmediateMatch::SendData(IServerUserItem * pIServerUserItem, WORD wMainCmdID, WORD wSubCmdID, VOID * pData, WORD wDataSize)

  1101. {

  1102.     if (pIServerUserItem != NULL)

  1103.         return m_pIGameServiceFrame->SendData(pIServerUserItem, wMainCmdID, wSubCmdID, pData, wDataSize);

  1104.     else

  1105.         return m_pIGameServiceFrame->SendData(BG_ALL_CLIENT, wMainCmdID, wSubCmdID, pData, wDataSize);

  1106. 

  1107.     return true;

  1108. }

  1109. 

  1110. //为首轮插入空桌子

  1111. void CImmediateMatch::InsertNullTable()

  1112. {

  1113.     for (int i = 0; i<m_pGameServiceOption->wTableCount; i++)

  1114.     {

  1115.         //超过就退出

  1116.         WORD nCurTableCount = (WORD)m_pCurMatchGroup->m_MatchTableArray.GetCount();

  1117.         if (nCurTableCount >= m_pMatchOption->MatchType.Immediate.wStartUserCount / m_pGameServiceAttrib->wChairCount)break;

  1118. 

  1119.         BOOL bIsInsert = true;

  1120.         for (int j = 0; j<m_MatchGroup.GetCount(); j++)

  1121.         {

  1122.             WORD wMatchGroupTableCount = (WORD)m_MatchGroup[j]->m_MatchTableArray.GetCount();

  1123.             for (int k = 0; k<wMatchGroupTableCount; k++)

  1124.             {

  1125.                 WORD wTableID = m_MatchGroup[j]->m_MatchTableArray[k]->wTableID;

  1126.                 if (i == wTableID){ bIsInsert = false; break; }//其他组已经分配了该桌

  1127.             }

  1128.         }

  1129.         //插入桌子

  1130.         if (bIsInsert&&m_ppITableFrame[i]->GetNullChairCount() == m_pGameServiceAttrib->wChairCount)

  1131.         {

  1132.             tagTableFrameInfo * pTableFrameInfo = new tagTableFrameInfo;

  1133.             ZeroMemory(pTableFrameInfo, sizeof(tagTableFrameInfo));

  1134.             pTableFrameInfo->wTableID = i;

  1135.             pTableFrameInfo->pTableFrame = m_ppITableFrame[i];

  1136.             pTableFrameInfo->dwBaseScore = m_pMatchOption->MatchType.Immediate.dwInitalBase;

  1137.             ITableFrameHook * pFrameHook = QUERY_OBJECT_PTR_INTERFACE(m_ppITableFrame[i]->GetTableFrameHook(), ITableFrameHook);

  1138.             pFrameHook->SetMatchEventSink(QUERY_OBJECT_PTR_INTERFACE(m_pCurMatchGroup, IUnknownEx));

  1139.             m_pCurMatchGroup->AddMatchTable(pTableFrameInfo);

  1140.         }

  1141.     }

  1142. }

  1143. 

  1144. //获取一个空闲的机器人

  1145. IAndroidUserItem * CImmediateMatch::GetFreeAndroidUserItem()

  1146. {

  1147. 

  1148.     if (m_pAndroidUserManager->GetAndroidCount() == 0) return NULL;

  1149. 

  1150.     //机器状态

  1151.     tagAndroidUserInfo AndroidSimulate;

  1152.     m_pAndroidUserManager->GetAndroidUserInfo(AndroidSimulate, ANDROID_SIMULATE | ANDROID_PASSIVITY | ANDROID_INITIATIVE);

  1153. 

  1154.     if (AndroidSimulate.wFreeUserCount == 0)

  1155.         return NULL;

  1156.     else

  1157.     {

  1158.         //避免已报名的机器人重复安排

  1159.         for (WORD i = 0; i<AndroidSimulate.wFreeUserCount; i++)

  1160.         {

  1161.             if (AndroidSimulate.pIAndroidUserFree[i]->GetMeUserItem()->GetSignUpStatus() == MatchStatus_Null)

  1162.             {

  1163.                 ASSERT(AndroidSimulate.pIAndroidUserFree[i]->GetUserID() == AndroidSimulate.pIAndroidUserFree[i]->GetMeUserItem()->GetUserID());

  1164.                 return AndroidSimulate.pIAndroidUserFree[i];

  1165.             }

  1166.         }

  1167.     }

  1168. 

  1169.     return NULL;

  1170. }

  1171. 

  1172. //用户淘汰

  1173. bool CImmediateMatch::OnUserOut(IServerUserItem *pUserItem, LPCTSTR szReason, WORD wLen, WORD wRank, CImmediateGroup *pMatch)

  1174. {

  1175.     if (pUserItem == NULL)

  1176.         return false;

  1177. 

  1178.     pUserItem->SetSignUpStatus(MatchStatus_Null);

  1179. 

  1180.     //清除比赛后的一些用户

  1181.     for (INT_PTR i = 0; i<pMatch->m_FreeUserArray.GetCount(); i++)

  1182.     {

  1183.         if (pMatch->m_FreeUserArray[i]->GetUserID() == pUserItem->GetUserID())

  1184.         {

  1185.             pMatch->m_FreeUserArray.RemoveAt(i);

  1186.             break;

  1187.         }

  1188.     }

  1189. 

  1190.     if (wLen>0 && szReason != NULL)

  1191.     {

  1192.         CString str(szReason, wLen);

  1193.         SendGameMessage(pUserItem, str, SMT_EJECT | SMT_CHAT | SMT_CLOSE_GAME);

  1194.     }

  1195. 

  1196.     //移除参赛用户

  1197.     RemoveMatchUserItem(pUserItem);

  1198. 

  1199.     BYTE cbMatchStatus = MatchStatus_Null;

  1200.     m_pIGameServiceFrame->SendData(pUserItem, MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &cbMatchStatus, sizeof(cbMatchStatus));

  1201. 

  1202.     if (pMatch == m_pCurMatchGroup)

  1203.     {

  1204.         if (pUserItem != NULL && !pUserItem->IsAndroidUser())

  1205.         {

  1206.             if (m_pMatchOption->lMatchFee>0)

  1207.             {

  1208.                 //变量定义

  1209.                 DBR_GR_MatchSignup MatchSignup;

  1210.                 ZeroMemory(&MatchSignup, sizeof(MatchSignup));

  1211. 

  1212.                 //构造结构

  1213.                 MatchSignup.dwUserID = pUserItem->GetUserID();

  1214.                 MatchSignup.lMatchFee = m_pMatchOption->lMatchFee;

  1215.                 MatchSignup.dwInoutIndex = pUserItem->GetInoutIndex();

  1216.                 MatchSignup.dwClientAddr = pUserItem->GetClientAddr();

  1217.                 MatchSignup.dwMatchID = m_pMatchOption->dwMatchID;

  1218.                 MatchSignup.dwMatchNO = m_pCurMatchGroup->m_dwMatchNO;

  1219.                 lstrcpyn(MatchSignup.szMachineID, pUserItem->GetMachineID(), CountArray(MatchSignup.szMachineID));

  1220. 

  1221.                 //投递数据

  1222.                 m_pIDataBaseEngine->PostDataBaseRequest(MatchSignup.dwUserID, DBR_GR_MATCH_UNSIGNUP, 0, &MatchSignup, sizeof(MatchSignup));

  1223. 

  1224.                 //发送消息				

  1225.                 LPCTSTR pszMatchFeeType[] = { TEXT("游戏币"), TEXT("元宝") };

  1226.                 if (m_pMatchOption->cbMatchFeeType<CountArray(pszMatchFeeType))

  1227.                 {

  1228.                     //构造消息

  1229.                     TCHAR szMessage[128] = TEXT("");

  1230.                     _sntprintf(szMessage, CountArray(szMessage), TEXT("该房间即将关闭，请到其他房间报名参赛。退还报名费 %I64d %s。"), m_pMatchOption->lMatchFee, pszMatchFeeType[m_pMatchOption->cbMatchFeeType]);

  1231. 

  1232.                     //发送消息

  1233.                     m_pIGameServiceFrame->SendRoomMessage(pUserItem, szMessage, SMT_EJECT | SMT_CHAT | SMT_CLOSE_ROOM);

  1234.                 }

  1235.             }

  1236.         }

  1237.         CServerRule::SetForfendRoomEnter(static_cast<DWORD>(m_pGameServiceOption->dwServerRule), true);

  1238.     }

  1239.     else if (m_pIDataBaseEngine != NULL)

  1240.     {

  1241.         /*DBR_GR_MatchReward MatchReward;

  1242.         ZeroMemory(&MatchReward,sizeof(MatchReward));

  1243. 

  1244.         MatchReward.dwMatchID=m_pMatchOption->dwMatchID;

  1245.         MatchReward.dwUserID=pUserItem->GetUserID();

  1246.         MatchReward.dwMatchNO=pMatch->m_dwMatchNO;

  1247.         MatchReward.wRank=wRank;

  1248.         MatchReward.lMatchScore=pUserItem->GetUserScore();

  1249.         MatchReward.dwClientAddr=pUserItem->GetClientAddr();

  1250. 

  1251.         m_pIDataBaseEngine->PostDataBaseRequest(MatchReward.dwUserID,DBR_GR_MATCH_REWARD, 0, &MatchReward, sizeof(MatchReward));*/

  1252. 

  1253.     }

  1254.     return true;

  1255. }

  1256. 

  1257. //写入奖励

  1258. bool CImmediateMatch::WriteUserAward(IServerUserItem *pIServerUserItem, tagMatchRankInfo * pMatchRankInfo)

  1259. {

  1260.     //参数效验

  1261.     ASSERT(pIServerUserItem != NULL && pMatchRankInfo != NULL);

  1262.     if (pIServerUserItem == NULL || pMatchRankInfo == NULL) return false;

  1263. 

  1264.     //写入判断

  1265.     bool bWriteReward = (pMatchRankInfo->lRewardGold + pMatchRankInfo->dwRewardIngot + pMatchRankInfo->dwRewardExperience)>0;

  1266. 

  1267.     //写入奖励

  1268.     if (bWriteReward == true)

  1269.     {

  1270.         //变量定义

  1271.         CMD_GR_MatchResult MatchResult;

  1272.         ZeroMemory(&MatchResult, sizeof(MatchResult));

  1273. 

  1274.         //比赛奖励

  1275.         MatchResult.lGold += pMatchRankInfo->lRewardGold;

  1276.         MatchResult.dwIngot += pMatchRankInfo->dwRewardIngot;

  1277.         MatchResult.dwExperience += pMatchRankInfo->dwRewardExperience;

  1278. 

  1279.         //获奖提示

  1280.         _sntprintf(MatchResult.szDescribe, CountArray(MatchResult.szDescribe), TEXT("%s, 恭喜您在%s中获得第%d名,奖励如下："),

  1281.             pIServerUserItem->GetNickName(), m_pMatchOption->szMatchName, pMatchRankInfo->wRankID);

  1282. 

  1283.         //更新用户信息

  1284.         tagUserInfo * pUserInfo = pIServerUserItem->GetUserInfo();

  1285. 		//pUserInfo->lIngot = 0;//+= pMatchRankInfo->dwRewardIngot;

  1286.         pUserInfo->dwExperience += pMatchRankInfo->dwRewardExperience;

  1287.         SendGroupUserScore(pIServerUserItem, NULL);

  1288. 

  1289.         //发送数据

  1290.         if (pIServerUserItem->IsAndroidUser() == false)

  1291.         {

  1292.             m_pIGameServiceFrame->SendData(pIServerUserItem, MDM_GF_FRAME, SUB_GR_MATCH_RESULT, &MatchResult, sizeof(MatchResult));

  1293.         }

  1294.     }

  1295.     else

  1296.     {

  1297.         TCHAR szMessage[256] = TEXT("");

  1298.         _sntprintf(szMessage, CountArray(szMessage), TEXT("比赛已结束，恭喜您获得第%d名，欢迎您参加其他场次的比赛！"), pMatchRankInfo->wRankID);

  1299.         SendGameMessage(pIServerUserItem, szMessage, SMT_CLOSE_GAME);

  1300.         SendRoomMessage(pIServerUserItem, szMessage, SMT_CHAT | SMT_EJECT);

  1301. 

  1302.         return true;

  1303.     }

  1304. 

  1305.     //写入记录

  1306.     if (m_pIDataBaseEngine != NULL)

  1307.     {

  1308.         //变量定义

  1309.         DBR_GR_MatchReward MatchReward;

  1310.         ZeroMemory(&MatchReward, sizeof(MatchReward));

  1311. 

  1312.         //构造结构

  1313.         MatchReward.dwUserID = pIServerUserItem->GetUserID();

  1314.         MatchReward.lRewardGold = pMatchRankInfo->lRewardGold;

  1315.         MatchReward.dwRewardIngot = pMatchRankInfo->dwRewardIngot;

  1316.         MatchReward.dwRewardExperience = pMatchRankInfo->dwRewardExperience;

  1317.         MatchReward.dwClientAddr = pIServerUserItem->GetClientAddr();

  1318. 

  1319.         //投递数据

  1320.         m_pIDataBaseEngine->PostDataBaseRequest(MatchReward.dwUserID, DBR_GR_MATCH_REWARD, 0, &MatchReward, sizeof(MatchReward));

  1321.     }

  1322. 

  1323.     return true;

  1324. }

  1325. 

  1326. //获取空桌子

  1327. WORD CImmediateMatch::GetNullTable()

  1328. {

  1329.     WORD wTableCount = 0;

  1330.     for (int i = 0; i<m_pGameServiceOption->wTableCount; i++)

  1331.     {

  1332.         BOOL bIsInsert = true;

  1333.         for (int j = 0; j<m_MatchGroup.GetCount(); j++)

  1334.         {

  1335.             WORD wMatchGroupTableCount = (WORD)m_MatchGroup[j]->m_MatchTableArray.GetCount();

  1336.             for (int k = 0; k<wMatchGroupTableCount; k++)

  1337.             {

  1338.                 WORD wTableID = m_MatchGroup[j]->m_MatchTableArray[k]->wTableID;

  1339.                 if (i == wTableID){ bIsInsert = false; break; }//其他组已经分配了该桌

  1340.             }

  1341.         }

  1342.         //插入桌子

  1343.         if (bIsInsert&&m_ppITableFrame[i]->GetNullChairCount() == m_pGameServiceAttrib->wChairCount)

  1344.         {

  1345.             wTableCount++;

  1346.         }

  1347.     }

  1348.     return wTableCount;

  1349. }

  1350. 

  1351. //删除用户

  1352. bool CImmediateMatch::DeleteUserItem(DWORD dwUserIndex)

  1353. {

  1354.     try

  1355.     {

  1356.         if (m_pITCPNetworkEngineEvent == NULL)

  1357.         {

  1358.             throw 0;

  1359.         }

  1360.         m_pITCPNetworkEngineEvent->OnEventTCPNetworkShut(dwUserIndex, 0, 0L);

  1361.     }

  1362.     catch (...)

  1363.     {

  1364.         //错误断言

  1365.         ASSERT(FALSE);

  1366.         return false;

  1367.     }

  1368.     return true;

  1369. }

  1370. 

  1371. //移除参赛用户

  1372. bool CImmediateMatch::RemoveMatchUserItem(IServerUserItem *pIServerUserItem)

  1373. {

  1374.     for (INT_PTR i = 0; i<m_OnMatchUserItem.GetCount(); i++)

  1375.     {

  1376.         //获取用户

  1377.         IServerUserItem * pOnLineUserItem = m_OnMatchUserItem[i];

  1378. 

  1379.         //用户判断

  1380.         if (pOnLineUserItem == pIServerUserItem)

  1381.         {

  1382.             ASSERT(pOnLineUserItem->GetUserID() == pIServerUserItem->GetUserID());

  1383. 

  1384.             m_OnMatchUserItem.RemoveAt(i);

  1385.             return true;

  1386.         }

  1387.     }

  1388. 

  1389.     return false;

  1390. }

  1391. ////////////////////////////////////////////////////////////////////////////////////////////////////////////