zhaobu
/
zhujimajiang_redis
1
0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
诸暨麻将添加redis
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
7 提交
2 分支
57 MiB
 
 
 
 
 
 
目录树: acf5e4d482
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 'acf5e4d482'
${ noResults }
zhujimajiang_redis/俱乐部/Source/ServerControl/MatchService/ImmediateGroup.cpp

1077 行
35 KiB
原始文件 Blame 文件历史 

  1. #include "StdAfx.h"

  2. #include "ImmediateGroup.h"

  3. 

  4. #ifdef _DEBUG

  5. #define new DEBUG_NEW

  6. #undef THIS_FILE

  7. static char THIS_FILE[] = __FILE__;

  8. #endif

  9. 

  10. //////////////////////////////////////////////////////////////////////////

  11. //常量定义

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

  13. 

  14. //静态变量

  15. WORD CImmediateGroup::m_wChairCount;									//椅子数目

  16. 

  17. //////////////////////////////////////////////////////////////////////////

  18. //构造函数

  19. CImmediateGroup::CImmediateGroup(DWORD dwMatchNO, tagGameMatchOption * pGameMatchOption, IImmediateGroupSink *pIImmediateGroupSink)

  20. {

  21.     //指针变量

  22.     m_pMatchOption = pGameMatchOption;

  23.     m_pMatchSink = pIImmediateGroupSink;

  24. 

  25.     //状态变量

  26.     m_dwMatchNO = dwMatchNO;

  27.     m_enMatchStatus = MatchStatus_Signup;

  28.     m_dwCurBase = m_pMatchOption->MatchType.Immediate.dwInitalBase;

  29. 

  30.     //设置变量

  31.     ZeroMemory(&m_MatchStartTime, sizeof(m_MatchStartTime));

  32. 

  33.     //移除元素

  34.     m_OnMatchUserMap.RemoveAll();

  35.     m_FreeUserArray.RemoveAll();

  36.     m_MatchTableArray.RemoveAll();

  37. 

  38.     //设置变量

  39.     m_LoopTimer = 0;

  40.     m_wAndroidUserCount = 0;

  41. }

  42. 

  43. //析构函数

  44. CImmediateGroup::~CImmediateGroup()

  45. {

  46.     //杀死定时器

  47.     AllKillMatchTimer();

  48. 

  49.     //设置状态

  50.     m_wAndroidUserCount = 0;

  51.     m_enMatchStatus = MatchStatus_Null;

  52. 

  53.     //释放桌子

  54.     for (int i = 0; i < m_MatchTableArray.GetCount(); i++)

  55.     {

  56.         SafeDelete(m_MatchTableArray[i]);

  57.     }

  58. 

  59.     //移除元素

  60.     m_MatchTableArray.RemoveAll();

  61.     m_OnMatchUserMap.RemoveAll();

  62.     m_FreeUserArray.RemoveAll();

  63. }

  64. 

  65. //接口查询

  66. VOID* CImmediateGroup::QueryInterface(REFGUID Guid, DWORD dwQueryVer)

  67. {

  68.     QUERYINTERFACE(IMatchEventSink, Guid, dwQueryVer);

  69.     QUERYINTERFACE_IUNKNOWNEX(IMatchEventSink, Guid, dwQueryVer);

  70.     return NULL;

  71. }

  72. 

  73. //用户报名

  74. bool CImmediateGroup::OnUserSignUpMatch(IServerUserItem * pUserItem)

  75. {

  76.     //用户判断

  77.     ASSERT(pUserItem != NULL);

  78.     if (pUserItem == NULL) return false;

  79. 

  80.     //查找用户

  81.     IServerUserItem * pIServerUserExist = NULL;

  82.     m_OnMatchUserMap.Lookup(pUserItem->GetUserID(), pIServerUserExist);

  83. 

  84.     //用户判断

  85.     ASSERT(pIServerUserExist == NULL);

  86.     if (pIServerUserExist != NULL) return false;

  87. 

  88.     //人数效验

  89.     ASSERT(m_OnMatchUserMap.GetCount() < m_pMatchOption->MatchType.Immediate.wStartUserCount);

  90.     if (m_OnMatchUserMap.GetCount() >= m_pMatchOption->MatchType.Immediate.wStartUserCount) return false;

  91. 

  92.     //机器判断

  93.     if (pUserItem->IsAndroidUser() == true)

  94.     {

  95.         if (m_wAndroidUserCount >= m_pMatchOption->MatchType.Immediate.wAndroidUserCount)

  96.         {

  97.             return false;

  98.         }

  99.         m_wAndroidUserCount++;

  100.     }

  101. 

  102.     //设置成绩

  103.     tagUserInfo *pUserScore = pUserItem->GetUserInfo();

  104.     pUserScore->dwWinCount = 0L;

  105.     pUserScore->dwLostCount = 0L;

  106.     pUserScore->dwFleeCount = 0L;

  107.     pUserScore->dwDrawCount = 0L;

  108.     pUserScore->lGrade = 0L;

  109.     pUserScore->lScore = (SCORE)m_pMatchOption->MatchType.Immediate.dwInitalScore;

  110. 

  111.     //发送成绩

  112.     m_pMatchSink->SendGroupUserScore(pUserItem, NULL);

  113. 

  114.     //设置用户

  115.     m_OnMatchUserMap[pUserItem->GetUserID()] = pUserItem;

  116. 

  117.     //设置报名状态

  118.     pUserItem->SetSignUpStatus(MS_SIGNUP);

  119. 

  120.     //设置报名时间

  121.     pUserItem->SetSignUpTime(GetTickCount());

  122. 

  123.     //发送报名状态

  124.     BYTE cbMatchStatus = MS_SIGNUP;

  125.     m_pMatchSink->SendData(pUserItem, MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &cbMatchStatus, sizeof(cbMatchStatus));

  126. 

  127.     //报名人满

  128.     if (m_OnMatchUserMap.GetCount() >= m_pMatchOption->MatchType.Immediate.wStartUserCount)

  129.     {

  130.         //事件通知

  131.         ASSERT(m_pMatchSink != NULL);

  132.         if (m_pMatchSink != NULL) m_pMatchSink->SendMatchInfo(NULL);

  133.         EfficacyStartMatch();

  134.     }

  135. 

  136.     return true;

  137. }

  138. //比赛开始

  139. void CImmediateGroup::EfficacyStartMatch()

  140. {

  141.     m_pMatchSink->InsertNullTable();

  142. 

  143.     //没有桌子的情况

  144.     if (m_MatchTableArray.GetCount() < m_pMatchOption->MatchType.Immediate.wStartUserCount / m_wChairCount)

  145.     {

  146.         if (m_OnMatchUserMap.GetCount() < m_wChairCount)

  147.         {

  148.             //构造数据包

  149.             CMD_CM_SystemMessage Message;

  150.             Message.wType = SMT_EJECT | SMT_CHAT | SMT_CLOSE_GAME;

  151.             lstrcpyn(Message.szString, TEXT("抱歉，由于某用户强行退出比赛，该场比赛提前结束。你可以继续等待比赛！"), CountArray(Message.szString));

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

  153.             //发送数据

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

  155.             m_pMatchSink->SendGroupData(MDM_CM_SYSTEM, SUB_CM_SYSTEM_MESSAGE, &Message, wSendSize, this);

  156.             m_enMatchStatus = MatchStatus_Signup;

  157.             return;

  158.         }

  159. 

  160.         m_enMatchStatus = MatchStatus_Wait;

  161.         //3秒后继续调用该函数直到有桌子

  162.         SetMatchGameTimer(IDI_WAITTABLE_FIRST_ROUND, 3000, 1, NULL);

  163. 

  164.         //构造数据包

  165.         CMD_CM_SystemMessage Message;

  166.         Message.wType = SMT_CHAT;

  167.         _sntprintf(Message.szString, CountArray(Message.szString),

  168.             TEXT("抱歉，由于过多用户桌子数量不够！还差 %d 张桌子开赛,请等待。。。"), m_pMatchOption->MatchType.Immediate.wStartUserCount / m_wChairCount - m_MatchTableArray.GetCount());

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

  170. 

  171.         //发送数据

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

  173.         m_pMatchSink->SendGroupData(MDM_CM_SYSTEM, SUB_CM_SYSTEM_MESSAGE, &Message, wSendSize, this);

  174.         return;

  175.     }

  176.     //预赛安排座位

  177.     DWORD dwUserID = 0L;

  178.     IServerUserItem *pIServerUserItem = NULL;

  179.     POSITION pos = m_OnMatchUserMap.GetStartPosition();

  180. 

  181.     WORD wChairID = 0;

  182.     while (pos != NULL)

  183.     {

  184.         //获取用户

  185.         m_OnMatchUserMap.GetNextAssoc(pos, dwUserID, pIServerUserItem);

  186.         ASSERT(pIServerUserItem != NULL);

  187. 

  188.         InsertFreeGroup(pIServerUserItem);

  189. 

  190.         //设置用户比赛中

  191.         pIServerUserItem->SetSignUpStatus(MS_MATCHING);

  192.         pIServerUserItem->SetMatchData(this);

  193.     }

  194. 

  195.     //桌子自动拉人

  196.     TabelRequestUser(false);

  197. 

  198.     //设置状态	

  199.     m_enMatchStatus = MatchStatus_FirstRound;

  200. 

  201.     //记录时间

  202.     CTime::GetCurrentTime().GetAsSystemTime(m_MatchStartTime);

  203. 

  204.     //开始通知

  205.     if (m_pMatchSink != NULL) m_pMatchSink->OnEventMatchStart(this);

  206. 

  207.     //设置定时器

  208.     SetMatchGameTimer(IDI_CHECK_MATCH_GROUP, 1000, TIMES_INFINITY, 0);

  209. }

  210. 

  211. //用户退赛

  212. BOOL CImmediateGroup::OnUserQuitMatch(IServerUserItem *pUserItem)

  213. {

  214.     //用户判断

  215.     ASSERT(pUserItem != NULL);

  216.     if (pUserItem == NULL) return false;

  217. 

  218.     //删除用户

  219.     BOOL bSuccess = m_OnMatchUserMap.RemoveKey(pUserItem->GetUserID());

  220.     if (bSuccess == false)return false;

  221. 

  222.     if (pUserItem->IsAndroidUser())

  223.     {

  224.         ASSERT(m_wAndroidUserCount > 0);

  225.         if (m_wAndroidUserCount > 0) m_wAndroidUserCount--;

  226.     }

  227. 

  228.     //设置状态

  229.     pUserItem->SetSignUpStatus(MatchStatus_Null);

  230.     BYTE cbUserStatus = MatchStatus_Null;

  231.     m_pMatchSink->SendData(pUserItem, MDM_GR_MATCH, SUB_GR_MATCH_STATUS, &cbUserStatus, sizeof(cbUserStatus));

  232. 

  233.     return bSuccess;

  234. }

  235. 

  236. //定时器

  237. bool CImmediateGroup::OnTimeMessage(DWORD dwTimerID, WPARAM dwBindParameter)

  238. {

  239.     //状态校验

  240.     if (m_enMatchStatus == MatchStatus_Null) return true;

  241. 

  242.     switch (dwTimerID)

  243.     {

  244.     case IDI_CHECK_MATCH_GROUP:

  245.     {

  246.                                   CaptureMatchTimer();

  247. 

  248.                                   return true;

  249.     }

  250.     case IDI_WAITTABLE_FIRST_ROUND:

  251.     {

  252.                                       if (m_enMatchStatus == MatchStatus_Wait)

  253.                                       {

  254.                                           EfficacyStartMatch();

  255.                                       }

  256.                                       return true;

  257.     }

  258.     case IDI_SWITCH_WAIT_TIME:

  259.     {

  260.                                  //将空闲用户自动配桌

  261.                                  RearrangeUserSeat();

  262.                                  TabelRequestUser();

  263.                                  //ContinueGame((ITableFrame*)dwBindParameter);

  264.                                  return true;

  265.     }

  266.     case IDI_TABLE_REQUEST_USER:

  267.     {

  268.                                    TabelRequestUser();

  269.                                    return true;

  270.     }

  271.     case IDI_ENTER_NEXT_ROUND:

  272.     {

  273.                                  //if(m_enMatchStatus==MS_START_NEXT_ROUND)

  274.                                  //{

  275.                                  //	//继续下一轮

  276.                                  //	ContinueRound();

  277.                                  //}

  278.                                  return true;

  279.     }

  280.     case IDI_ALL_DISMISS_GAME:

  281.     {

  282.                                  RearrangeUserSeat();

  283.                                  return true;

  284.     }

  285.     case IDI_LASTMATCHRESULT:

  286.     {

  287.                                 //最后结束

  288.                                 MatchOver();

  289. 

  290.                                 return true;

  291.     }

  292.     }

  293. 

  294.     return true;

  295. }

  296. 

  297. WORD CImmediateGroup::SortMapUser(tagMatchScore score[])

  298. {

  299.     INT_PTR nCount = m_OnMatchUserMap.GetCount();

  300.     POSITION pos = m_OnMatchUserMap.GetStartPosition();

  301.     nCount = 0;

  302.     while (pos != NULL)

  303.     {

  304.         m_OnMatchUserMap.GetNextAssoc(pos, score[nCount].dwUserID, score[nCount].pUserItem);

  305.         score[nCount].dwUserID = score[nCount].pUserItem->GetUserID();

  306.         score[nCount].lScore = score[nCount].pUserItem->GetUserScore();

  307.         nCount++;

  308.     }

  309.     for (INT_PTR i = 1; i < nCount; i++)

  310.     {

  311.         INT_PTR left = 0, right = i - 1;

  312.         tagMatchScore  Temp = score[i];

  313.         while (left <= right)

  314.         {

  315.             INT_PTR mid = (left + right) / 2;

  316.             if (score[i].lScore > score[mid].lScore)right = mid - 1;

  317.             else left = mid + 1;

  318.         }

  319.         for (INT_PTR j = i - 1; j >= left; j--)

  320.             score[j + 1] = score[j];

  321.         score[left] = Temp;

  322.     }

  323. 

  324.     return (WORD)nCount;

  325. }

  326. 

  327. //重置桌位

  328. void CImmediateGroup::RearrangeUserSeat(bool bDismissGame)

  329. {

  330.     KillMatchGameTimer(IDI_SWITCH_WAIT_TIME);

  331.     for (WORD i = 0; i < m_MatchTableArray.GetCount(); i++)

  332.     {

  333.         tagTableFrameInfo *ptagTableFrameInfo = m_MatchTableArray[i];

  334.         ASSERT(ptagTableFrameInfo != NULL);

  335.         if (ptagTableFrameInfo == NULL) continue;

  336. 

  337.         ITableFrame* pTableFrame = ptagTableFrameInfo->pTableFrame;

  338.         ASSERT(pTableFrame != NULL);

  339.         if (pTableFrame == NULL) continue;

  340. 

  341.         if (bDismissGame == false)

  342.         {

  343.             ptagTableFrameInfo->cbPlayCount = 0;

  344.             ptagTableFrameInfo->bRoundTableFinish = false;

  345.             ptagTableFrameInfo->bSwtichTableFinish = false;

  346.             ptagTableFrameInfo->bWaitForNextInnings = false;

  347.         }

  348. 

  349.         //强制解散游戏

  350.         if (pTableFrame->IsGameStarted() == true)

  351.         {

  352.             if (bDismissGame == true)

  353.             {

  354.                 bool bSuccess = pTableFrame->DismissGame();

  355.                 if (bSuccess == false)

  356.                     CTraceService::TraceString(TEXT("解散游戏"), TraceLevel_Exception);

  357.             }

  358.             else

  359.             {

  360.                 TCHAR szMessage[64] = TEXT("");

  361.                 _sntprintf(szMessage, CountArray(szMessage), TEXT("重置桌位时,第 %d 桌处于游戏状态"), pTableFrame->GetTableID());

  362.                 CTraceService::TraceString(szMessage, TraceLevel_Exception);

  363.             }

  364.         }

  365. 

  366.         //该桌用户全部离开

  367.         AllUserExitTable(pTableFrame);

  368.     }

  369.     return;

  370. }

  371. 

  372. //游戏开始

  373. bool CImmediateGroup::OnEventGameStart(ITableFrame *pITableFrame, WORD wChairCount)

  374. {

  375.     pITableFrame->SetCellScore(m_dwCurBase);

  376.     KillMatchTimer(IDI_CHECK_TABLE_START, (WPARAM)pITableFrame);

  377. 

  378.     tagTableFrameInfo *pTableFrameInfo = GetTableInterface(pITableFrame);

  379.     pTableFrameInfo->bRoundTableFinish = false;

  380.     pTableFrameInfo->bSwtichTableFinish = false;

  381.     pTableFrameInfo->bWaitForNextInnings = false;

  382. 

  383.     //已完成局数加1

  384.     pTableFrameInfo->cbPlayCount++;

  385. 

  386.     //发送比赛信息给桌子上的用户

  387.     SendTableUserMatchInfo(pITableFrame, INVALID_CHAIR);

  388. 

  389.     //构造数据包

  390.     CMD_CM_SystemMessage SystemMessage;

  391.     ZeroMemory(&SystemMessage, sizeof(SystemMessage));

  392. 

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

  394.     _sntprintf(szMsg, CountArray(szMsg), TEXT("定局排名赛第%d局开始（共%d局）。"), pTableFrameInfo->cbPlayCount, m_pMatchOption->MatchType.Immediate.cbPlayCount);

  395.     lstrcpyn(SystemMessage.szString, szMsg, CountArray(SystemMessage.szString));

  396.     SystemMessage.wLength = CountStringBuffer(SystemMessage.szString);

  397.     SystemMessage.wType = SMT_CHAT;

  398. 

  399.     //发送数据

  400.     WORD wSendSize = sizeof(SystemMessage)-sizeof(SystemMessage.szString) + SystemMessage.wLength*sizeof(TCHAR);

  401.     pITableFrame->SendTableData(INVALID_CHAIR, SUB_GF_SYSTEM_MESSAGE, (void*)&SystemMessage, wSendSize, MDM_GF_FRAME);

  402. 

  403.     return true;

  404. }

  405. 

  406. //游戏结束

  407. bool CImmediateGroup::OnEventGameEnd(ITableFrame *pITableFrame, WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason)

  408. {

  409.     //记录本局和哪些用户玩过

  410.     tagTableFrameInfo * ptagTableFrameInfo = GetTableInterface(pITableFrame);

  411.     ASSERT(ptagTableFrameInfo);

  412.     if (ptagTableFrameInfo == NULL)return false;

  413. 

  414.     if (m_enMatchStatus == MatchStatus_FirstRound)

  415.     {

  416.         FirstRoundRuleInningsGameEnd(pITableFrame);

  417.     }

  418.     //CheckExitMatch();

  419. 

  420.     //比赛结束直接返回

  421.     if (m_enMatchStatus == MatchStatus_Null)return true;

  422. 

  423.     if (m_OnMatchUserMap.GetCount() > 0)

  424.     {

  425.         //分数通知

  426.         tagMatchScore *pScore = new tagMatchScore[m_OnMatchUserMap.GetCount()];

  427.         ZeroMemory(pScore, sizeof(tagMatchScore)*m_OnMatchUserMap.GetCount());

  428.         WORD wCount = SortMapUser(pScore);

  429.         for (WORD i = 0; i < wCount; i++)

  430.         {

  431.             m_pMatchSink->SendGroupUserScore(pScore[i].pUserItem, this);

  432.         }

  433.         SafeDeleteArray(pScore);

  434.     }

  435. 

  436.     return true;

  437. }

  438. 

  439. //用户坐下

  440. bool CImmediateGroup::OnActionUserSitDown(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)

  441. {

  442.     return true;

  443. }

  444. 

  445. //用户起立

  446. bool CImmediateGroup::OnActionUserStandUp(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, bool bLookonUser)

  447. {

  448.     return true;

  449. }

  450. 

  451. //用户同意

  452. bool CImmediateGroup::OnActionUserOnReady(WORD wTableID, WORD wChairID, IServerUserItem * pIServerUserItem, VOID * pData, WORD wDataSize)

  453. {

  454.     return false;

  455. }

  456. 

  457. //获取名次

  458. WORD CImmediateGroup::GetUserRank(IServerUserItem *pUserItem, ITableFrame *pITableFrame)

  459. {

  460.     //参数效验

  461.     ASSERT(pUserItem != NULL);

  462.     if (pUserItem == NULL) return INVALID_WORD;

  463.     //定义变量

  464.     SCORE lUserScore = pUserItem->GetUserScore();

  465.     WORD wRank = 1;

  466.     DWORD dwUserID = 0;

  467.     IServerUserItem *pLoopUserItem = NULL;

  468. 

  469.     if (pITableFrame == NULL)

  470.     {

  471.         //遍历容器

  472.         POSITION pos = m_OnMatchUserMap.GetStartPosition();

  473.         while (pos != NULL)

  474.         {

  475.             m_OnMatchUserMap.GetNextAssoc(pos, dwUserID, pLoopUserItem);

  476.             if (pLoopUserItem != pUserItem && pLoopUserItem->GetUserScore() > lUserScore)

  477.                 wRank++;

  478.         }

  479.     }

  480.     else

  481.     {

  482.         ASSERT(pUserItem->GetTableID() == pITableFrame->GetTableID());

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

  484. 

  485.         for (WORD i = 0; i<m_wChairCount; i++)

  486.         {

  487.             pLoopUserItem = pITableFrame->GetTableUserItem(i);

  488.             if (pLoopUserItem == NULL) continue;

  489. 

  490.             if (pLoopUserItem != pUserItem && pLoopUserItem->GetUserScore()>lUserScore)

  491.                 wRank++;

  492.         }

  493.     }

  494. 

  495.     return wRank;

  496. }

  497. 

  498. //获取桌子专用接口

  499. tagTableFrameInfo* CImmediateGroup::GetTableInterface(ITableFrame* ITable)

  500. {

  501.     for (int i = 0; i < m_MatchTableArray.GetCount(); i++)

  502.     {

  503.         if (m_MatchTableArray[i]->pTableFrame == ITable)return m_MatchTableArray[i];

  504.     }

  505.     return NULL;

  506. }

  507. 

  508. //比赛结束

  509. void CImmediateGroup::MatchOver()

  510. {

  511.     //删除定时器

  512.     AllKillMatchTimer();

  513.     KillMatchGameTimer(IDI_CHECK_MATCH_GROUP);

  514.     KillMatchGameTimer(IDI_WAITTABLE_FIRST_ROUND);

  515.     KillMatchGameTimer(IDI_WAITTABLE_RAND_TABLE);

  516.     KillMatchGameTimer(IDI_SWITCH_WAIT_TIME);

  517.     KillMatchGameTimer(IDI_ALL_DISMISS_GAME);

  518.     KillMatchGameTimer(IDI_LASTMATCHRESULT);

  519.     KillMatchGameTimer(IDI_TABLE_REQUEST_USER);

  520. 

  521.     //设置比赛状态

  522.     ASSERT(m_enMatchStatus == MatchStatus_FirstRound);

  523.     if (m_enMatchStatus == MatchStatus_FirstRound)

  524.     {

  525.         m_enMatchStatus = MatchStatus_Null;

  526.         m_pMatchSink->OnEventMatchOver(this);

  527.     }

  528. }

  529. 

  530. //定局排名游戏结束

  531. void CImmediateGroup::FirstRoundRuleInningsGameEnd(ITableFrame *pITableFrame)

  532. {

  533.     //获取对象

  534.     tagTableFrameInfo * ptagTableFrameInfo = GetTableInterface(pITableFrame);

  535.     ASSERT(ptagTableFrameInfo);

  536.     if (ptagTableFrameInfo == NULL) return;

  537. 

  538.     //设置等待下局标识

  539.     ptagTableFrameInfo->bWaitForNextInnings = true;

  540. 

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

  542. 

  543.     //该桌打完指定局数

  544.     if (ptagTableFrameInfo->cbPlayCount >= m_pMatchOption->MatchType.Immediate.cbPlayCount)

  545.     {

  546.         _sntprintf(szMessage, CountArray(szMessage), TEXT("恭喜您,您已玩满%d局游戏,等其他桌完成后系统将进行排名,请您耐心等待！"), m_pMatchOption->MatchType.Immediate.cbPlayCount);

  547. 

  548.         //发送提示信息

  549.         for (WORD j = 0; j < m_wChairCount; j++)

  550.         {

  551.             IServerUserItem *pIServerUserItem = pITableFrame->GetTableUserItem(j);

  552.             if (pIServerUserItem != NULL)

  553.             {

  554.                 m_pMatchSink->SendGameMessage(pIServerUserItem, szMessage, SMT_CHAT | SMT_TABLE_ROLL);

  555. 

  556.                 //插入空闲列表

  557.                 InsertFreeGroup(pIServerUserItem);

  558.             }

  559.             else

  560.             {

  561.                 ASSERT(FALSE);

  562.                 CTraceService::TraceString(TEXT("玩家信息为空1!"), TraceLevel_Exception);

  563.             }

  564.         }

  565. 

  566.         //设置完成标识

  567.         SetRoundTableFinish(pITableFrame);

  568.         SendWaitTip(pITableFrame);

  569.         ptagTableFrameInfo->cbPlayCount = 0;

  570.     }

  571.     else

  572.     {

  573.         if (m_pMatchOption->MatchType.Immediate.cbSwitchTableCount > 0 && (ptagTableFrameInfo->cbPlayCount%m_pMatchOption->MatchType.Immediate.cbSwitchTableCount) == 0)

  574.             _sntprintf(szMessage, CountArray(szMessage), TEXT("%s"), TEXT("本局已结束，请耐心等待其他桌完成，稍后为您配桌..."));

  575.         else

  576.             _sntprintf(szMessage, CountArray(szMessage), TEXT("%s"), TEXT("本局已结束，请稍候，系统配桌中..."));

  577. 

  578.         //发送提示信息

  579.         for (WORD j = 0; j < m_wChairCount; j++)

  580.         {

  581.             IServerUserItem *pIServerUserItem = pITableFrame->GetTableUserItem(j);

  582.             if (pIServerUserItem != NULL)

  583.             {

  584.                 m_pMatchSink->SendGameMessage(pIServerUserItem, szMessage, SMT_CHAT | SMT_TABLE_ROLL);

  585. 

  586.                 //插入空闲列表

  587.                 InsertFreeGroup(pIServerUserItem);

  588.             }

  589.             else

  590.             {

  591.                 ASSERT(FALSE);

  592.                 CTraceService::TraceString(TEXT("玩家信息为空2!"), TraceLevel_Exception);

  593.             }

  594.         }

  595.     }

  596. 

  597.     //所有桌都完成指定局数

  598.     if (CheckRoundTableFinish())

  599.     {

  600.         SetMatchGameTimer(IDI_LASTMATCHRESULT, 5000, 1, 0);

  601.         return;

  602.     }

  603.     else if (ptagTableFrameInfo->bRoundTableFinish == false)

  604.     {

  605.         //自动换桌的控制

  606.         if (m_pMatchOption->MatchType.Immediate.cbSwitchTableCount > 0 && (ptagTableFrameInfo->cbPlayCount%m_pMatchOption->MatchType.Immediate.cbSwitchTableCount) == 0)

  607.         {

  608.             SetSwitchTableFinish(pITableFrame);

  609.             SendWaitTip(pITableFrame);

  610. 

  611.             //检查该桌子是否可以换桌

  612.             if (CheckSwitchTableFinish())

  613.             {

  614.                 SetMatchGameTimer(IDI_SWITCH_WAIT_TIME, 5000, 1, 0);

  615. 

  616.                 return;

  617.             }

  618.         }

  619.         else //不换桌

  620.         {

  621.             //设置定时器

  622.             PostMatchTimer(IDI_CONTINUE_GAME, 5, (WPARAM)pITableFrame);

  623. 

  624.             return;

  625.         }

  626.     }

  627. }

  628. 

  629. //发送提示

  630. VOID CImmediateGroup::SendWaitTip(ITableFrame *pTableFrame, WORD wChairID/*=INVALID_CHAIR*/)

  631. {

  632.     //状态校验

  633.     if (m_enMatchStatus == MatchStatus_Null || m_enMatchStatus == MatchStatus_Signup)

  634.         return;

  635. 

  636.     tagTableFrameInfo *pITableFameEx = GetTableInterface(pTableFrame);

  637.     ASSERT(pITableFameEx != NULL);

  638.     if (pITableFameEx == NULL) return;

  639. 

  640.     //变量定义

  641.     WORD wPlayingTable = 0;

  642.     for (WORD i = 0; i < m_MatchTableArray.GetCount(); i++)

  643.     {

  644.         if (m_MatchTableArray[i]->pTableFrame->GetGameStatus() >= GAME_STATUS_PLAY)

  645.             wPlayingTable++;

  646.     }

  647. 

  648.     //变量定义

  649.     CMD_GR_Match_Wait_Tip WaitTip;

  650.     ZeroMemory(&WaitTip, sizeof(WaitTip));

  651.     WaitTip.wPlayingTable = wPlayingTable;

  652.     WaitTip.wUserCount = (WORD)m_OnMatchUserMap.GetCount();

  653.     WaitTip.wCurGameCount = pITableFameEx->cbPlayCount;

  654.     WaitTip.wGameCount = m_pMatchOption->MatchType.Immediate.cbPlayCount;

  655. 

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

  657. 

  658.     //发送比赛信息给本桌的玩家

  659.     for (WORD i = 0; i < m_wChairCount; i++)

  660.     {

  661.         if (wChairID != INVALID_CHAIR && wChairID != i) continue;

  662.         IServerUserItem *pTableUserItem = pTableFrame->GetTableUserItem(i);

  663.         if (pTableUserItem == NULL) continue;

  664.         WaitTip.wCurTableRank = GetUserRank(pTableUserItem, pTableFrame);

  665.         if (WaitTip.wCurTableRank == INVALID_WORD) continue;

  666. 

  667. 

  668.         WaitTip.wRank = GetUserRank(pTableUserItem);

  669.         WaitTip.lScore = pTableUserItem->GetUserScore();

  670. 

  671.         m_pMatchSink->SendData(pTableUserItem, MDM_GF_FRAME, SUB_GR_MATCH_WAIT_TIP, &WaitTip, sizeof(WaitTip));

  672.     }

  673. 

  674.     //发送比赛信息给其他桌的玩家

  675.     for (WORD i = 0; i < m_MatchTableArray.GetCount(); i++)

  676.     {

  677.         if (pTableFrame->GetTableID() == m_MatchTableArray[i]->pTableFrame->GetTableID())continue;

  678.         if (m_MatchTableArray[i]->pTableFrame->GetGameStatus() >= GAME_STATUS_PLAY) continue;

  679.         for (WORD j = 0; j < m_wChairCount; j++)

  680.         {

  681.             IServerUserItem *pTableUserItem = m_MatchTableArray[i]->pTableFrame->GetTableUserItem(j);

  682.             if (pTableUserItem == NULL) continue;

  683.             WaitTip.wCurTableRank = GetUserRank(pTableUserItem, m_MatchTableArray[i]->pTableFrame);

  684.             if (WaitTip.wCurTableRank == INVALID_WORD) continue;

  685. 

  686.             WaitTip.wRank = GetUserRank(pTableUserItem);

  687.             WaitTip.lScore = pTableUserItem->GetUserScore();

  688. 

  689.             m_pMatchSink->SendData(pTableUserItem, MDM_GF_FRAME, SUB_GR_MATCH_WAIT_TIP, &WaitTip, sizeof(WaitTip));

  690.         }

  691.     }

  692. }

  693. 

  694. //空闲桌子拉空闲用户

  695. void CImmediateGroup::TabelRequestUser(bool bPrecedeSit)

  696. {

  697.     //参赛用户不够 椅子数量就要终止比赛

  698.     if (CheckMatchUser())

  699.     {

  700.         return;

  701.     }

  702.     CTableFrameMananerArray			FreeTableArray;				//空比赛桌子

  703.     //首先获取空桌子

  704.     for (INT_PTR i = 0; i < m_MatchTableArray.GetCount(); i++)

  705.     {

  706.         if (m_MatchTableArray[i]->pTableFrame->IsGameStarted() == false && m_MatchTableArray[i]->bRoundTableFinish == false)

  707.         {

  708.             //获取数量

  709.             INT_PTR cbTimer = m_MatchTimerArray.GetCount();

  710.             bool cbIsInsert = false;

  711.             for (int j = 0; j < cbTimer; j++)

  712.             {

  713.                 //判断一下有没有卡赛的桌子在等待

  714.                 if ((m_MatchTimerArray[j]->dwTimerID == IDI_CHECK_TABLE_START || m_MatchTimerArray[j]->dwTimerID == IDI_CONTINUE_GAME) && (ITableFrame*)(m_MatchTimerArray[j]->wParam) == m_MatchTableArray[i]->pTableFrame)

  715.                 {

  716.                     cbIsInsert = true;

  717.                     break;

  718.                 }

  719.             }

  720.             if (cbIsInsert == false)

  721.                 FreeTableArray.Add(m_MatchTableArray[i]);

  722.         }

  723.     }

  724. 

  725.     DWORD dwCurTime = (DWORD)time(NULL);

  726. 

  727.     bool bIsContinueCheck = false;//优化优先坐下 原本是true

  728.     for (INT_PTR i = 0; i<FreeTableArray.GetCount(); i++)

  729.     {

  730.         DWORD nCurUserCount = (DWORD)m_FreeUserArray.GetCount();

  731.         //找到一个空桌 空闲用户必须大于等于椅子

  732.         if (nCurUserCount / m_wChairCount>0)

  733.         {

  734.             AllUserExitTable(FreeTableArray[i]->pTableFrame);

  735.             for (int j = 0; j < m_wChairCount; j++)

  736.             {

  737.                 //用户插入该桌

  738.                 WORD wRandID = INVALID_VALUE;

  739.                 if (bPrecedeSit&&bIsContinueCheck)

  740.                 {

  741.                     wRandID = GetPrecedeSitUser(dwCurTime);

  742.                 }

  743.                 if (wRandID == INVALID_VALUE)

  744.                 {

  745.                     bIsContinueCheck = false;//已经没有优先用户了

  746.                     wRandID = rand() % (WORD)m_FreeUserArray.GetCount();

  747.                 }

  748. 

  749.                 IServerUserItem *pIServerUserItem = m_FreeUserArray[wRandID];

  750.                 ASSERT(pIServerUserItem != NULL);

  751.                 if (pIServerUserItem == NULL) continue;

  752. 

  753.                 //先起立在坐下 让该桌的人全部起立

  754.                 if (pIServerUserItem->GetTableID() != INVALID_TABLE)

  755.                 {

  756.                     for (int m = 0; m < m_MatchTableArray.GetCount(); m++)

  757.                     {

  758.                         if (pIServerUserItem->GetTableID() == m_MatchTableArray[m]->wTableID)

  759.                         {

  760.                             m_MatchTableArray[m]->pTableFrame->PerformStandUpAction(pIServerUserItem);

  761.                             break;

  762.                         }

  763.                     }

  764.                 }

  765.                 if (FreeTableArray[i]->pTableFrame->PerformSitDownAction(j, pIServerUserItem))

  766.                 {

  767.                     m_FreeUserArray.RemoveAt(wRandID);

  768.                 }

  769.                 else

  770.                 {

  771.                     CTraceService::TraceString(TEXT("坐下失败？"), TraceLevel_Exception);

  772.                 }

  773.             }

  774.             //30秒后做一个检查 发现该桌还没有开始游戏 说明已经卡掉了

  775.             PostMatchTimer(IDI_CHECK_TABLE_START, 30, (WPARAM)FreeTableArray[i]->pTableFrame);

  776.         }

  777.     }

  778. 

  779.     return;

  780. }

  781. //发送一组信息

  782. void CImmediateGroup::SendGroupBox(LPCTSTR pStrMessage)

  783. {

  784.     //构造数据包

  785.     CMD_CM_SystemMessage Message;

  786.     Message.wType = SMT_EJECT | SMT_CHAT;

  787.     lstrcpyn(Message.szString, pStrMessage, CountArray(Message.szString));

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

  789.     //发送数据

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

  791.     m_pMatchSink->SendGroupData(MDM_CM_SYSTEM, SUB_CM_SYSTEM_MESSAGE, &Message, wSendSize, this);

  792. }

  793. 

  794. //设置一轮完成标记

  795. void CImmediateGroup::SetRoundTableFinish(ITableFrame *pITableFrame)

  796. {

  797.     tagTableFrameInfo * ptagTableFrameInfo = GetTableInterface(pITableFrame);

  798.     ASSERT(ptagTableFrameInfo);

  799.     if (ptagTableFrameInfo)ptagTableFrameInfo->bRoundTableFinish = true;

  800. }

  801. 

  802. //检查一轮是否完成

  803. bool CImmediateGroup::CheckRoundTableFinish()

  804. {

  805.     for (int i = 0; i < m_MatchTableArray.GetCount(); i++)

  806.     {

  807.         if (m_MatchTableArray[i]->bRoundTableFinish == false)return false;

  808.     }

  809.     return true;

  810. }

  811. 

  812. //设置换桌完成标记

  813. void CImmediateGroup::SetSwitchTableFinish(ITableFrame *pITableFrame)

  814. {

  815.     tagTableFrameInfo * ptagTableFrameInfo = GetTableInterface(pITableFrame);

  816.     ASSERT(ptagTableFrameInfo);

  817.     if (ptagTableFrameInfo)ptagTableFrameInfo->bSwtichTableFinish = true;

  818. }

  819. 

  820. //检查换桌是否完成

  821. bool CImmediateGroup::CheckSwitchTableFinish()

  822. {

  823.     for (int i = 0; i < m_MatchTableArray.GetCount(); i++)

  824.     {

  825.         if (m_MatchTableArray[i]->bSwtichTableFinish == false)return false;

  826.     }

  827.     return true;

  828. }

  829. 

  830. //设置所有用户离开

  831. void CImmediateGroup::AllUserExitTable(ITableFrame *pITableFrame)

  832. {

  833.     ASSERT(pITableFrame != NULL);

  834.     if (pITableFrame)

  835.     {

  836.         //该桌用户全部离开

  837.         for (int i = 0; i < m_wChairCount; i++)

  838.         {

  839.             IServerUserItem* pUserItem = pITableFrame->GetTableUserItem(i);

  840.             if (pUserItem&&pUserItem->GetTableID() != INVALID_TABLE)pITableFrame->PerformStandUpAction(pUserItem);

  841.         }

  842.     }

  843. }

  844. //本桌继续游戏

  845. void CImmediateGroup::ContinueGame(ITableFrame *pITableFrame)

  846. {

  847.     if (CheckMatchUser())

  848.     {

  849.         return;

  850.     }

  851. 

  852.     tagTableFrameInfo * ptagTableFrameInfo = GetTableInterface(pITableFrame);

  853.     ASSERT(ptagTableFrameInfo);

  854.     if (ptagTableFrameInfo)

  855.     {

  856.         AllUserExitTable(pITableFrame);

  857.         for (int i = 0; i < m_wChairCount; i++)

  858.         {

  859.             IServerUserItem* pIServerUserItem = m_FreeUserArray[0];

  860.             if (pIServerUserItem == NULL)

  861.             {

  862.                 ASSERT(FALSE);

  863.                 CTraceService::TraceString(TEXT("空的用户存在于等待列表中。"), TraceLevel_Exception);

  864.                 return;

  865.             }

  866. 

  867.             //先起立在坐下 让该桌的人全部起立

  868.             if (pIServerUserItem->GetTableID() != INVALID_TABLE)

  869.             {

  870.                 for (int m = 0; m < m_MatchTableArray.GetCount(); m++)

  871.                 {

  872.                     if (pIServerUserItem->GetTableID() == m_MatchTableArray[m]->wTableID)

  873.                     {

  874.                         m_MatchTableArray[m]->pTableFrame->PerformStandUpAction(pIServerUserItem);

  875. 

  876.                         break;

  877.                     }

  878.                 }

  879.             }

  880. 

  881.             if (pITableFrame->PerformSitDownAction(i, pIServerUserItem))

  882.             {

  883.                 m_FreeUserArray.RemoveAt(0);

  884.             }

  885.             else

  886.             {

  887.                 CTraceService::TraceString(TEXT("坐下失败？1"), TraceLevel_Exception);

  888.             }

  889.         }

  890. 

  891.         //30秒后做一个检查 发现该桌还没有开始游戏 说明已经卡掉了

  892.         PostMatchTimer(IDI_CHECK_TABLE_START, 30, (WPARAM)pITableFrame);

  893.     }

  894. }

  895. 

  896. void CImmediateGroup::SetMatchGameTimer(DWORD dwTimerID, DWORD dwElapse, DWORD dwRepeat, WPARAM dwBindParameter)

  897. {

  898.     if (m_pMatchSink)

  899.         m_pMatchSink->SetGameTimer(dwTimerID + 10 * m_LoopTimer, dwElapse, dwRepeat, dwBindParameter, this);

  900. }

  901. 

  902. //杀死比赛专用定时器

  903. void CImmediateGroup::KillMatchGameTimer(DWORD dwTimerID)

  904. {

  905.     if (m_pMatchSink)

  906.         m_pMatchSink->KillGameTimer(dwTimerID + 10 * m_LoopTimer, this);

  907. }

  908. 

  909. //检测参赛人数

  910. bool CImmediateGroup::CheckMatchUser()

  911. {

  912.     //参赛用户不够 椅子数量就要终止比赛

  913.     DWORD nCurUserCount = (DWORD)m_OnMatchUserMap.GetCount();

  914.     if (nCurUserCount < m_wChairCount)

  915.     {

  916.         ASSERT(FALSE);

  917.         CTraceService::TraceString(TEXT("检查人数..."), TraceLevel_Exception);

  918.         return false;

  919. 

  920.         //构造数据包

  921.         CString szString;

  922.         szString.Format(TEXT("抱歉，由于比赛用户强行退出比赛，人数不足 %d 人，提前结算。欢迎您继续报名参加比赛！"), m_wChairCount);

  923.         SendGroupBox(szString);

  924. 

  925.         MatchOver();

  926. 

  927.         return true;

  928.     }

  929.     return false;

  930. }

  931. 

  932. //获取优先坐下用户

  933. WORD CImmediateGroup::GetPrecedeSitUser(DWORD dwCurTime)

  934. {

  935.     for (int i = 0; i<m_FreeUserArray.GetCount(); i++)

  936.     {

  937.         tagTimeInfo* pTimerInfo = m_FreeUserArray[i]->GetTimeInfo();

  938.         if (dwCurTime - pTimerInfo->dwEndGameTimer>m_pMatchOption->MatchType.Immediate.wPrecedeTimer) return i;

  939.     }

  940.     return INVALID_VALUE;

  941. }

  942. 

  943. //实现该函数可保证Free组唯一

  944. void CImmediateGroup::InsertFreeGroup(IServerUserItem *pUserItem)

  945. {

  946.     if (pUserItem == NULL)return;

  947.     for (int i = 0; i < m_FreeUserArray.GetCount(); i++)

  948.     {

  949.         if (m_FreeUserArray[i] != NULL && m_FreeUserArray[i]->GetUserID() == pUserItem->GetUserID())return;

  950.     }

  951.     m_FreeUserArray.Add(pUserItem);

  952. }

  953. 

  954. //发送比赛信息

  955. void CImmediateGroup::SendTableUserMatchInfo(ITableFrame *pITableFrame, WORD wChairID)

  956. {

  957.     //验证参数

  958.     ASSERT(pITableFrame != NULL);

  959.     if (pITableFrame == NULL) return;

  960. 

  961.     tagTableFrameInfo *ptagTableFrameInfo = GetTableInterface(pITableFrame);

  962.     if (ptagTableFrameInfo == NULL) return;

  963. 

  964.     //变量定义

  965.     WORD wChairCount = pITableFrame->GetChairCount();

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

  967. 

  968.     if (m_enMatchStatus == MatchStatus_FirstRound)

  969.     {

  970.         //构造数据

  971.         CMD_GR_Match_Info MatchInfo;

  972.         ZeroMemory(&MatchInfo, sizeof(MatchInfo));

  973.         _sntprintf(MatchInfo.szTitle[0], CountArray(MatchInfo.szTitle[0]), TEXT("积分方式：累计积分"));

  974.         _sntprintf(MatchInfo.szTitle[1], CountArray(MatchInfo.szTitle[1]), TEXT("游戏基数：%d"), m_dwCurBase);

  975.         _sntprintf(MatchInfo.szTitle[2], CountArray(MatchInfo.szTitle[2]), TEXT("局制名称：定局排名"));

  976.         _sntprintf(MatchInfo.szTitle[3], CountArray(MatchInfo.szTitle[3]), TEXT("需要完成：%d局比赛"), m_pMatchOption->MatchType.Immediate.cbPlayCount);

  977.         MatchInfo.wGameCount = ptagTableFrameInfo->cbPlayCount;

  978. 

  979.         //wChairID为INVALID_CHAIR发给本桌所有玩家，否则只发给指定玩家

  980.         for (WORD i = 0; i < wChairCount; i++)

  981.         {

  982.             //获取用户

  983.             if (wChairID != INVALID_CHAIR && wChairID != i) continue;

  984.             IServerUserItem *pIServerUserItem = pITableFrame->GetTableUserItem(i);

  985.             if (pIServerUserItem == NULL) continue;

  986. 

  987.             //发送数据

  988.             pITableFrame->SendTableData(i, SUB_GR_MATCH_INFO, &MatchInfo, sizeof(MatchInfo), MDM_GF_FRAME);

  989.         }

  990. 

  991.         //发送提示

  992.         if ((wChairID != INVALID_CHAIR) && (ptagTableFrameInfo->bWaitForNextInnings == true))

  993.         {

  994.             SendWaitTip(pITableFrame, wChairID);

  995.         }

  996.     }

  997. 

  998.     return;

  999. }

  1000. 

  1001. //捕获比赛专用定时器

  1002. void CImmediateGroup::CaptureMatchTimer()

  1003. {

  1004.     for (int i = 0; i < m_MatchTimerArray.GetCount(); i++)

  1005.     {

  1006.         if (--m_MatchTimerArray[i]->iElapse <= 0)

  1007.         {

  1008.             if (m_MatchTimerArray[i]->dwTimerID == IDI_CONTINUE_GAME)

  1009.             {

  1010.                 //本桌用户继续游戏

  1011.                 ContinueGame((ITableFrame*)m_MatchTimerArray[i]->wParam);

  1012.             }

  1013.             else if (m_MatchTimerArray[i]->dwTimerID == IDI_LEAVE_TABLE)

  1014.             {

  1015.                 //离开本桌

  1016.                 AllUserExitTable((ITableFrame*)m_MatchTimerArray[i]->wParam);

  1017.             }

  1018.             else if (m_MatchTimerArray[i]->dwTimerID == IDI_CHECK_TABLE_START)

  1019.             {

  1020.                 //检查桌子是否开始游戏

  1021.                 //CheckTableStart((ITableFrame*)m_MatchTimerArray[i]->wParam);

  1022.             }

  1023.             //删除定时器

  1024.             if (KillMatchTimer(i))i--;

  1025.             else ASSERT(false);

  1026.         }

  1027.     }

  1028. }

  1029. //投递比赛专用定时器

  1030. void CImmediateGroup::PostMatchTimer(DWORD dwTimerID, int iElapse, WPARAM wParam, LPARAM lParam)

  1031. {

  1032.     tagMatchTimer* pMatchTimer = new tagMatchTimer;

  1033.     pMatchTimer->dwTimerID = dwTimerID;

  1034.     pMatchTimer->iElapse = iElapse;

  1035.     //pMatchTimer->dwRepeat=dwRepeat;

  1036.     pMatchTimer->wParam = wParam;

  1037.     pMatchTimer->lParam = lParam;

  1038.     m_MatchTimerArray.Add(pMatchTimer);

  1039. }

  1040. //杀死比赛专用定时器

  1041. bool CImmediateGroup::KillMatchTimer(DWORD dwTimerID, WPARAM wParam)

  1042. {

  1043.     for (int i = 0; i < m_MatchTimerArray.GetCount(); i++)

  1044.     {

  1045.         if (m_MatchTimerArray[i]->dwTimerID == dwTimerID&&m_MatchTimerArray[i]->wParam == wParam)

  1046.         {

  1047.             tagMatchTimer* pMatchTimer = m_MatchTimerArray[i];

  1048.             m_MatchTimerArray.RemoveAt(i);

  1049.             SafeDelete(pMatchTimer);

  1050.             return true;

  1051.         }

  1052.     }

  1053.     return false;

  1054. }

  1055. //杀死比赛专用定时器

  1056. bool CImmediateGroup::KillMatchTimer(INT_PTR dwIndexID)

  1057. {

  1058.     ASSERT(dwIndexID >= 0 && dwIndexID < m_MatchTimerArray.GetCount());

  1059.     if (dwIndexID >= 0 && dwIndexID < m_MatchTimerArray.GetCount())

  1060.     {

  1061.         tagMatchTimer* pMatchTimer = m_MatchTimerArray[dwIndexID];

  1062.         m_MatchTimerArray.RemoveAt(dwIndexID);

  1063.         SafeDelete(pMatchTimer);

  1064.         return true;

  1065.     }

  1066.     return false;

  1067. }

  1068. //全部杀死比赛专用定时器

  1069. void CImmediateGroup::AllKillMatchTimer()

  1070. {

  1071.     for (int i = 0; i < m_MatchTimerArray.GetCount();/*i++*/)

  1072.     {

  1073.         tagMatchTimer* pMatchTimer = m_MatchTimerArray[i];

  1074.         m_MatchTimerArray.RemoveAt(i);

  1075.         SafeDelete(pMatchTimer);

  1076.     }

  1077. }