开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
ClientNode.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：18k
源码类别：

模拟服务器

开发平台：

C/C++

ClientNode.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "ClientNode.h"
  4. #include <process.h>
  5. #include <iostream>
  7. #include "IDBRoleServer.h"
  9. #include "Macro.h"
  11. #include "../../../../Headers/KGmProtocol.h"
  12. #include "RoleNameFilter.h"
  14. using OnlineGameLib::Win32::CCriticalSection;
  15. using OnlineGameLib::Win32::CPackager;
  16. using OnlineGameLib::Win32::CEvent;
  17. using OnlineGameLib::Win32::CBuffer;
  19. HANDLE CClientNode::m_hThread = NULL;
  20. CEvent CClientNode::m_hQuitEvent( NULL, true, false );
  22. extern UINT g_nDBEngineLoop;
  24. CCriticalSection CClientNode::m_csCL;
  26. CClientNode::stdMap CClientNode::m_theClientMap;
  29. CClientNode::CDataQueue::CDataQueue( size_t bufferSize /*= 1024 * 64*/, size_t maxFreeBuffers /*= 160*/ )
  30. : m_theDQAllocator( bufferSize, maxFreeBuffers )
  31. {
  32. }
  34. CClientNode::CDataQueue::~CDataQueue()
  35. {
  36. }
  38. bool CClientNode::CDataQueue::AddData( const BYTE *pData, size_t datalength )
  39. {
  40. CBuffer *pBuffer = m_theDQAllocator.Allocate();
  42. pBuffer->AddData( pData, datalength );
  44. {
  45. CCriticalSection::Owner lock( m_csQueue );
  47. m_theData.push_back( pBuffer );
  48. }
  50. return true;
  51. }
  53. CBuffer *CClientNode::CDataQueue::Get()
  54. {
  55. {
  56. CCriticalSection::Owner lock( m_csQueue );
  58. if ( !m_theData.empty() )
  59. {
  60. CBuffer *pBuffer = m_theData.front();
  62. pBuffer->AddRef();
  64. m_theData.pop_front();
  66. pBuffer->Release();
  68. return pBuffer;
  69. }
  70. }
  72. return NULL;
  73. }
  75. CClientNode::CClientNode( IServer *pServer, size_t id )
  76. : m_nIndentity( id ) 
  77. , m_theAllocator( 1024 * 64, 3 )
  78. , m_pServer( pServer )
  79. {
  80. ZeroMemory( m_theProcessArray, sizeof( m_theProcessArray ) );
  82. m_theProcessArray[c2s_roleserver_getrolelist] = _QueryRoleList;
  83. m_theProcessArray[c2s_roleserver_createroleinfo] = _CreateRole;
  84. m_theProcessArray[c2s_roleserver_saveroleinfo] = _SaveRoleInfo;
  85. m_theProcessArray[c2s_roleserver_deleteplayer] = _DelRole;
  86. m_theProcessArray[c2s_roleserver_getroleinfo] = _GetRoleInfo;
  87. // m_theProcessArray[c2s_extend] = _RelayExtend;
  88. m_theProcessArray[c2s_gamestatistic] = _GetGameStat;
  89. m_theProcessArray[c2s_roleserver_lock] = _LockOrUnlockRole;
  90. }
  92. CClientNode::~CClientNode()
  93. {
  94. UnlockAllRole(m_nIndentity);
  95. SAFE_RELEASE( m_pServer );
  96. }
  98. CClientNode *CClientNode::AddNode( IServer *pServer, size_t id )
  99. {
  100. CCriticalSection::Owner lock( CClientNode::m_csCL );
  102. IServer *pCloneServer = NULL;
  103. pServer->QueryInterface( IID_IIOCPServer, ( void ** )&pCloneServer );
  105. CClientNode *pNode = new CClientNode( pCloneServer, id );
  107. CClientNode::m_theClientMap.insert( stdMap::value_type( id, pNode ) );
  109. return pNode;
  110. }
  112. void CClientNode::DelNode( size_t id )
  113. {
  114. stdMap::iterator it;
  116. if ( CClientNode::m_theClientMap.end() != ( it = CClientNode::m_theClientMap.find( id ) ) )
  117. {
  118. CCriticalSection::Owner lock( CClientNode::m_csCL );
  120. CClientNode *pNode = ( *it ).second;
  122. CClientNode::m_theClientMap.erase( id );
  124. SAFE_DELETE( pNode );
  125. }
  126. }
  128. bool CClientNode::Start( IServer *pServer )
  129. {
  130. if ( CClientNode::m_hThread == NULL )
  131. {
  132. unsigned int threadID = 0;
  133. CClientNode::m_hQuitEvent.Reset();
  134. CClientNode::m_hThread = (HANDLE)::_beginthreadex(0,
  135. 0,
  136. ThreadFunction,
  137. ( void * )pServer,
  138. 0,
  139. &threadID );
  141. if ( CClientNode::m_hThread == NULL )
  142. {
  143. return false;
  144. }
  145. }
  147. return true;
  148. }
  150. void CClientNode::End()
  151. {
  152. CClientNode::m_hQuitEvent.Set();
  154. if ( CClientNode::m_hThread != NULL )
  155. {
  156. DWORD result = ::WaitForSingleObject( CClientNode::m_hThread, 50000 );
  158. if ( result == WAIT_TIMEOUT )
  159. {
  160. ::TerminateThread( CClientNode::m_hThread, ( DWORD )( -2 ) );
  161. }
  163. if ( CClientNode::m_hThread != NULL )
  164. {
  165. ::CloseHandle( CClientNode::m_hThread );
  166. CClientNode::m_hThread = NULL;
  167. }
  168. }
  170. /*
  171.  * Save all
  172.  */
  173. }
  175. unsigned int __stdcall CClientNode::ThreadFunction( void *pV )
  176. {
  177. IServer *pServer = reinterpret_cast< IServer * >( pV );
  179. ASSERT( pServer );
  181. try
  182. {
  183. while ( !CClientNode::m_hQuitEvent.Wait( 0 ) )
  184. {
  185. {
  186. CCriticalSection::Owner lock( CClientNode::m_csCL );
  188. CClientNode::stdMap::iterator it;
  190. for ( it = CClientNode::m_theClientMap.begin();
  191. it != CClientNode::m_theClientMap.end();
  192. it ++ )
  193. {
  194. CClientNode *pNode = ( CClientNode * )( ( *it ).second );
  196. ASSERT( pNode );
  198. pNode->Process();
  199. }
  200. }
  202. if ( ++ g_nDBEngineLoop & 0x80000000 )
  203. {
  204. g_nDBEngineLoop = 0;
  205. }
  207. if ( g_nDBEngineLoop & 0x1 )
  208. {
  209. ::Sleep( 1 );
  210. }
  211. }
  212. }
  213. catch(...)
  214. {
  215. ::MessageBox( NULL, "CClientNode::ThreadFunction was error!", "Warning", MB_OK );
  216. }
  218. return 0L;
  219. }
  221. void CClientNode::AppendData( const void *pData, size_t datalength )
  222. {
  223. if ( pData && datalength )
  224. {
  225. BYTE cProtocol = CPackager::Peek( pData );
  227. if ( cProtocol < s2c_micropackbegin )
  228. {
  229. LargePackProcess( pData, datalength );
  230. }
  231. else if ( cProtocol > s2c_micropackbegin )
  232. {
  233. SmallPackProcess( pData, datalength );
  234. }
  235. else
  236. {
  237. ASSERT( FALSE && "Error!" );
  238. }
  239. }
  240. }
  242. void CClientNode::SmallPackProcess( const void *pData, size_t dataLength )
  243. {
  244. BYTE cProtocol = CPackager::Peek( pData );
  246. ASSERT( cProtocol >= 0 && cProtocol < s2c_end );
  248. m_theDataQueue.AddData( ( const BYTE * )pData, dataLength );
  249. }
  251. void CClientNode::LargePackProcess( const void *pData, size_t dataLength )
  252. {
  253. ASSERT( pData && dataLength );
  255. CBuffer *pBuffer = m_theRecv.PackUp( pData, dataLength );
  257. if ( pBuffer )
  258. {
  259. m_theDataQueue.AddData( pBuffer->GetBuffer(), pBuffer->GetUsed() );
  261. SAFE_RELEASE( pBuffer );
  262. }
  263. }
  265. void CClientNode::Process()
  266. {
  267. CBuffer *pBuffer = m_theDataQueue.Get();
  269. if ( pBuffer )
  270. {
  271. const BYTE *pData = pBuffer->GetBuffer();
  272. const size_t dataLength = pBuffer->GetUsed();
  274. BYTE cProtocol = CPackager::Peek( pData );
  276. if ( cProtocol < c2s_end && m_theProcessArray[cProtocol] )
  277. {
  278. ( this->*m_theProcessArray[cProtocol] )( ( const void * )pData, dataLength );
  279. }
  280. }
  282. SAFE_RELEASE( pBuffer );
  283. }
  285. void CClientNode::_QueryRoleList( const void *pData, size_t dataLength )
  286. {
  287. char szAccountName[_NAME_LENGTH];
  289. ASSERT( m_pServer && pData && dataLength );
  291. #ifdef CONSOLE_DEBUG
  292. cout << "_QueryRoleList::Begin" << endl;
  293. #endif
  295. TProcessData *pPlayerList = ( TProcessData * )pData;
  297. int nRoleListCount = pPlayerList->pDataBuffer[0];
  298. int nLen = pPlayerList->nDataLen;
  299. unsigned long ulIdentity = pPlayerList->ulIdentity;
  301. if ( nLen <= 1 || nLen >= _NAME_LENGTH )
  302. {
  303. #ifdef CONSOLE_DEBUG
  304. cout << "_QueryRoleList::Name is invalid" << endl;
  305. #endif
  307. return;
  308. }
  310. memcpy( szAccountName, ( const char * )( &pPlayerList->pDataBuffer[1] ), nLen - 1 );
  311. szAccountName[nLen - 1] = '';
  313. /*
  314.  * Database
  315.  */
  316. S3DBI_RoleBaseInfo DBI[4];
  317. const size_t s_nStructSize = sizeof( S3DBI_RoleBaseInfo );
  319. #ifdef CONSOLE_DEBUG
  320. cout << "_QueryRoleList::GetRoleListOfAccount " << szAccountName << endl;
  321. #endif
  323. int nCount = GetRoleListOfAccount( szAccountName, &DBI[0], nRoleListCount );
  325. CBuffer *pBuffer = m_theAllocator.Allocate();
  327. TProcessData *pListData = reinterpret_cast< TProcessData * >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  329. pListData->nProtoId = s2c_roleserver_getrolelist_result;
  330. pListData->ulIdentity = ulIdentity;
  332. int nDataLen = nCount * s_nStructSize + 1;
  333. pListData->nDataLen = nDataLen;
  335. pListData->pDataBuffer[0] = nCount;
  336. memcpy( &pListData->pDataBuffer[1], &DBI[0], nDataLen );
  338. int nUsedLen = sizeof( TProcessData ) - 1 + nDataLen;
  339. pBuffer->Use( nUsedLen );
  341. m_pServer->SendData( m_nIndentity, ( const void * )pListData, nUsedLen );
  343. SAFE_RELEASE( pBuffer );
  345. #ifdef CONSOLE_DEBUG
  346. cout << "_QueryRoleList::end" << endl;
  347. #endif
  348. }
  349. void CClientNode::_CreateRole( const void *pData, size_t dataLength )
  350. {
  351. ASSERT( m_pServer && pData && dataLength );
  353. #ifdef CONSOLE_DEBUG
  354. cout << "_CreateRole::Begin" << endl;
  355. #endif
  357. TProcessData *pPD = ( TProcessData * )pData;
  359. int nResult = 0;
  361. {{
  362. extern CRoleNameFilter g_fltRoleName;
  364. TRoleData* pRoleData = (TRoleData*)(pPD->pDataBuffer + 1);
  366. if (pRoleData->BaseInfo.szName[0])
  367. {
  368. for (size_t pos = sizeof(pRoleData->BaseInfo.szName) - 1; pos >= 1; pos--)
  369. {
  370. if (!pRoleData->BaseInfo.szName[pos])
  371. break;
  372. }
  373. if (pos >= 1)
  374. {
  375. if (g_fltRoleName.IsTextPass(pRoleData->BaseInfo.szName))
  376. nResult = SaveRoleInfo( &pPD->pDataBuffer[1], NULL, TRUE );
  377. else
  378. nResult = -1;
  379. }
  380. }
  381. }}
  383. TProcessData Info;
  385. Info.nProtoId = s2c_roleserver_createrole_result;
  386. Info.ulIdentity = pPD->ulIdentity;
  387. Info.nDataLen = 1;
  388. Info.pDataBuffer[0] = ( nResult == 1 ) ? 1 : -1;
  390. m_pServer->SendData( m_nIndentity, ( const void * )&Info, sizeof( Info ) );
  392. #ifdef CONSOLE_DEBUG
  393. cout << "_CreateRole::End" << endl;
  394. #endif
  395. }
  396. void CClientNode::_SaveRoleInfo( const void *pData, size_t dataLength )
  397. {
  398. ASSERT( m_pServer && pData && dataLength );
  399. #ifdef CONSOLE_DEBUG
  400. cout << "_SaveRoleInfo::Begin" << endl;
  401. #endif
  403. TProcessData *pPD = ( TProcessData * )pData;
  405. int nResult = 0;
  406. TRoleData* pRole = (TRoleData*)(&pPD->pDataBuffer[0]);
  407. char szName[32];
  408. int len = strlen( pRole->BaseInfo.szName );
  409. ASSERT( len > 0 );
  410. len = len > 31 ? 31 : len;
  411. memcpy( szName, pRole->BaseInfo.szName, len );
  412. szName[len] = '';
  414. if (IsRoleLockBySelf(szName))
  415. {
  416. nResult = SaveRoleInfo( &pPD->pDataBuffer[0], NULL, FALSE );
  417. if (pPD->bLeave)
  418. {
  419. UnlockRoleSelf(szName);
  420. }
  421. }
  422. else
  423. nResult = 0;
  425. if ( pPD->ulIdentity >= 0 )
  426. {
  427. TProcessData Info;
  429. Info.nProtoId = s2c_roleserver_saverole_result;
  430. Info.ulIdentity = pPD->ulIdentity;
  431. Info.nDataLen = 1;
  432. Info.pDataBuffer[0] = ( nResult == 1 ) ? 1 : -1;
  434. m_pServer->SendData( m_nIndentity, ( const void * )&Info, sizeof( Info ) );
  435. }
  437. #ifdef CONSOLE_DEBUG
  438. cout << "_SaveRoleInfo::End" << endl;
  439. #endif
  440. }
  441. void CClientNode::_DelRole( const void *pData, size_t dataLength )
  442. {
  443. ASSERT( m_pServer && pData && dataLength );
  445. #ifdef CONSOLE_DEBUG
  446. cout << "_DelRole::Begin" << endl;
  447. #endif
  449. TProcessData *pRoleInfo = ( TProcessData * )pData;
  451. char szRoleName[_NAME_LENGTH];
  453. int nDataLen = pRoleInfo->nDataLen;
  454. nDataLen = ( nDataLen > _NAME_LENGTH ) ? _NAME_LENGTH : nDataLen;
  456. int result = -1;
  458. if ( nDataLen > 0 )
  459. {
  460. memcpy( szRoleName, &pRoleInfo->pDataBuffer[0], nDataLen );
  461. szRoleName[nDataLen] = '';
  463. #ifdef CONSOLE_DEBUG
  464. cout << "_DelRole::DeleteRole " << szRoleName << endl;
  465. #endif
  467. if ( DeleteRole( szRoleName ) )
  468. {
  469. result = 1;
  470. }
  471. else
  472. {
  473. result = -1;
  474. }
  475. }
  477. if ( pRoleInfo->ulIdentity >= 0 )
  478. {
  479. TProcessData Info;
  481. Info.nProtoId = s2c_roleserver_deleterole_result;
  482. Info.ulIdentity = pRoleInfo->ulIdentity;
  483. Info.nDataLen = 1;
  484. Info.pDataBuffer[0] = result;
  486. m_pServer->SendData( m_nIndentity, ( const void * )&Info, sizeof( Info ) );
  487. }
  489. #ifdef CONSOLE_DEBUG
  490. cout << "_DelRole::End" << endl;
  491. #endif
  492. }
  494. //for Relay System and GM [wxb 2003-7-22]
  495. void CClientNode::_RelayExtend( const void *pData, size_t dataLength )
  496. {
  497. ASSERT(c2s_extend == *((unsigned char *)pData));
  498. char* pNewData = ((char *)pData) + 1;
  499. switch (*((WORD*)pNewData))
  500. {
  501. case MAKEWORD(pf_gamemaster, gm_c2s_getrole):
  502. {
  503. ASSERT(dataLength == 1 + sizeof(GM_GET_ROLE_DATA_COMMAND));
  504. GM_GET_ROLE_DATA_COMMAND* pGMData = (GM_GET_ROLE_DATA_COMMAND*)pNewData;
  505. int nResultBuflen = 0;
  506. switch(pGMData->wGetID)
  507. {
  508. case gm_role_entergame_position:
  509. {
  510. ASSERT(0 == pGMData->wLength);
  511. char* pReturnBuffer = (char*)_alloca(1 + sizeof(GM_GET_ROLE_DATA_SYNC) + sizeof(GM_ROLE_DATA_SUB_ENTER_POS));
  513. *pReturnBuffer = (char)s2c_extend;
  515. GM_GET_ROLE_DATA_SYNC* pGMReturn = (GM_GET_ROLE_DATA_SYNC*)(pReturnBuffer + 1);
  516. strncpy(pGMReturn->AccountName, pGMData->AccountName, sizeof(pGMData->AccountName));
  517. pGMReturn->ProtocolFamily = pf_gamemaster;
  518. pGMReturn->ProtocolType = gm_s2c_getrole;
  519. pGMReturn->wGetID = gm_role_entergame_position;
  520. pGMReturn->wLength = sizeof(GM_ROLE_DATA_SUB_ENTER_POS);
  522. GetRoleInfoForGM(pGMData->wGetID, (char*)(pGMReturn + 1), pGMData->AccountName, nResultBuflen);
  523. ASSERT(pGMReturn->wLength == nResultBuflen);
  524. m_pServer->SendData( m_nIndentity, pReturnBuffer, 1 + sizeof(GM_GET_ROLE_DATA_SYNC) + sizeof(GM_ROLE_DATA_SUB_ENTER_POS) );
  525. }
  526. break;
  527. default:
  528. ASSERT(0);
  529. break;
  530. }
  531. }
  532. break;
  534. case MAKEWORD(pf_gamemaster, gm_c2s_setrole):
  535. {
  536. ASSERT(dataLength >= 1 + sizeof(GM_SET_ROLE_DATA_COMMAND));
  537. GM_SET_ROLE_DATA_COMMAND* pGMData = (GM_SET_ROLE_DATA_COMMAND*)pNewData;
  538. SetRoleInfoForGM(pGMData->wSetID, (char*)(pGMData + 1), pGMData->AccountName, pGMData->wLength);
  539. }
  540. break;
  541. default:
  542. ASSERT(0);
  543. break;
  544. }
  545. }
  547. void CClientNode::_GetRoleInfo( const void *pData, size_t dataLength )
  548. {
  549. ASSERT( m_pServer && pData && dataLength );
  551. #ifdef CONSOLE_DEBUG
  552. cout << "_GetRoleInfo::Begin" << endl;
  553. #endif
  555. TProcessData *pRoleInfo = ( TProcessData * )pData;
  557. char szRoleName[_NAME_LENGTH];
  559. int nDataLen = pRoleInfo->nDataLen;
  560. nDataLen = ( nDataLen > _NAME_LENGTH ) ? _NAME_LENGTH : nDataLen;
  562. CBuffer *pBuffer = m_theAllocator.Allocate();
  564. TProcessData *pRoleData = reinterpret_cast< TProcessData * >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  566. int nUsedLength = sizeof( TProcessData );
  568. size_t nIdentity = pRoleInfo->ulIdentity;
  570. pRoleData->nProtoId = s2c_roleserver_getroleinfo_result;
  571. pRoleData->pDataBuffer[0] = -1;
  572. pRoleData->nDataLen = 1;
  573. pRoleData->ulIdentity = nIdentity;
  575. if ( nDataLen > 0 )
  576. {
  577. memcpy( szRoleName, &pRoleInfo->pDataBuffer[0], nDataLen );
  578. szRoleName[nDataLen] = '';
  580. int result = -1;
  582. #ifdef CONSOLE_DEBUG
  583. cout << "_GetRoleInfo::GetRoleInfo " << szRoleName << endl;
  584. #endif
  586. int nRoleInfoLen = 0;
  588. if (!IsRoleLock(szRoleName))
  589. GetRoleInfo( &pRoleData->pDataBuffer[1], szRoleName, nRoleInfoLen );
  591. if ( nRoleInfoLen > 0 )
  592. {
  593. pRoleData->pDataBuffer[0] = 1;
  594. pRoleData->nDataLen = nRoleInfoLen + 1;
  596. nUsedLength = sizeof( TProcessData ) + nRoleInfoLen;
  597. }
  598. }
  600. pBuffer->Use( nUsedLength );
  602. m_theSend.AddData( s2c_roleserver_getroleinfo_result, pBuffer->GetBuffer(), nUsedLength, nIdentity );
  604. CBuffer *pPack = m_theSend.GetHeadPack( s2c_roleserver_getroleinfo_result );
  606. while ( pPack )
  607. {
  608. m_pServer->SendData( m_nIndentity, ( const void * )pPack->GetBuffer(), pPack->GetUsed() );
  610. SAFE_RELEASE( pPack );
  612. pPack = m_theSend.GetNextPack( s2c_roleserver_getroleinfo_result );
  613. }
  615. m_theSend.DelData( s2c_roleserver_getroleinfo_result );
  617. SAFE_RELEASE( pPack );
  619. SAFE_RELEASE( pBuffer );
  621. #ifdef CONSOLE_DEBUG
  622. cout << "_GetRoleInfo::End" << endl;
  623. #endif
  624. }
  626. void CClientNode::_GetGameStat( const void *pData, size_t dataLength )
  627. {//发送游戏统计数据(By Fellow,2003.7.22)
  628. ASSERT( m_pServer && pData && dataLength );
  630. #ifdef CONSOLE_DEBUG
  631. cout << "_GetGameStat::Begin" << endl;
  632. #endif
  634. //收到的数据包，只有控制字没有数据
  635. TProcessData *pProData = ( TProcessData * )pData;
  636. size_t nIdentity = pProData->ulIdentity;
  638. //需要发送的数据包
  639. CBuffer *pBuffer = m_theAllocator.Allocate();
  640. TProcessData *pStatData = 
  641. reinterpret_cast< TProcessData * >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  643. int nDataLen = sizeof(TGAME_STAT_DATA);
  645. pStatData->nProtoId = s2c_gamestatistic;
  646. pStatData->ulIdentity = nIdentity;
  648. pStatData->nDataLen = nDataLen;
  649. //取得统计数据
  650. TGAME_STAT_DATA* myGameStatData = (TGAME_STAT_DATA*)pStatData->pDataBuffer;
  651. GetGameStat(myGameStatData);
  653. int nUsedLen = sizeof( TProcessData ) - 1 + nDataLen;
  654. pBuffer->Use( nUsedLen );
  655. //发送
  657. m_theSend.AddData( s2c_gamestatistic_bigpackage, pBuffer->GetBuffer(), nUsedLen );
  659. CBuffer *pPack = m_theSend.GetHeadPack( s2c_gamestatistic_bigpackage );
  661. while ( pPack )
  662. {
  663. m_pServer->SendData( m_nIndentity, ( const void * )pPack->GetBuffer(), pPack->GetUsed() );
  665. SAFE_RELEASE( pPack );
  667. pPack = m_theSend.GetNextPack( s2c_gamestatistic_bigpackage );
  668. }
  670. m_theSend.DelData( s2c_gamestatistic_bigpackage );
  672. SAFE_RELEASE( pPack );
  674. SAFE_RELEASE( pBuffer );
  676. #ifdef CONSOLE_DEBUG
  677. cout << "_GetGameStat::End" << endl;
  678. #endif
  679. }
  681. /////////////////////////////////////////////////////////////////////////////////
  683. CClientNode::stdRoleLockMap CClientNode::m_csRoleLock;
  684. CCriticalSection CClientNode::m_csCR;
  686. void CClientNode::_LockOrUnlockRole( const void *pData, size_t dataLength ) //强行加解锁
  687. {
  688. CCriticalSection::Owner lock( CClientNode::m_csCR );
  689. if (pData && dataLength == sizeof(tagRoleEnterGame))
  690. {
  691. tagRoleEnterGame* pRole = (tagRoleEnterGame*)pData;
  692. char szRole[32];
  693. strncpy(szRole, pRole->Name, 31);
  694. szRole[31] = 0;
  695. bool bLock = pRole->bLock;
  697. if (szRole && szRole[0] != 0)
  698. {
  699. if (bLock)
  700. m_csRoleLock[szRole] = m_nIndentity;
  701. else
  702. {
  703. stdRoleLockMap::iterator it = m_csRoleLock.find(szRole);
  704. if (it != m_csRoleLock.end())
  705. m_csRoleLock.erase(it);
  706. }
  707. }
  708. }
  709. }
  711. bool CClientNode::IsRoleLock(char* szRole)
  712. {
  713. CCriticalSection::Owner lock( CClientNode::m_csCR );
  714. if (szRole && szRole[0] != 0)
  715. {
  716. stdRoleLockMap::iterator it = m_csRoleLock.find(szRole);
  717. if (it != m_csRoleLock.end() && it->second != -1)
  718. return true;
  719. }
  720. return false;
  721. }
  723. bool CClientNode::IsRoleLockBySelf(char* szRole)
  724. {
  725. CCriticalSection::Owner lock( CClientNode::m_csCR );
  726. if (szRole && szRole[0] != 0)
  727. {
  728. stdRoleLockMap::iterator it = m_csRoleLock.find(szRole);
  729. if (it != m_csRoleLock.end() && it->second == m_nIndentity)
  730. return true;
  731. }
  732. return false;
  733. }
  735. bool CClientNode::UnlockRoleSelf(char* szRole)
  736. {
  737. CCriticalSection::Owner lock( CClientNode::m_csCR );
  738. if (szRole && szRole[0] != 0)
  739. {
  740. stdRoleLockMap::iterator it = m_csRoleLock.find(szRole);
  741. if (it != m_csRoleLock.end() && it->second == m_nIndentity)
  742. {
  743. m_csRoleLock.erase(it);
  744. return true;
  745. }
  746. }
  747. return false;
  748. }
  750. void CClientNode::UnlockAllRole(size_t ID)
  751. {
  752. CCriticalSection::Owner lock( CClientNode::m_csCR );
  753. stdRoleLockMap::iterator it = m_csRoleLock.begin();
  754. while (it != m_csRoleLock.end())
  755. {
  756. if (it->second == ID)
  757. it->second = -1;
  758. it++;
  759. }
  760. }
  762. /////////////////////////////////////////////////////////////////////////////////