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

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

模拟服务器

开发平台：

C/C++

GameServer.cpp：源码内容
  1. #include "Stdafx.h"
  2. #include "GameServer.h"
  3. #include "IPlayer.h"
  4. #include "GamePlayer.h"
  6. #include "msg_define.h"
  8. #include <process.h>
  10. #include "AccountLoginDef.h"
  12. #include "Macro.h"
  13. #include "SmartClient.h"
  15. using OnlineGameLib::Win32::CCriticalSection;
  16. using OnlineGameLib::Win32::CEvent;
  17. using OnlineGameLib::Win32::CBuffer;
  18. using OnlineGameLib::Win32::CPackager;
  19. using OnlineGameLib::Win32::ToString;
  20. using OnlineGameLib::Win32::_tstring;
  22. CBuffer::Allocator CGameServer::m_theGlobalAllocator( 1024 * 96, 200 );
  24. CCriticalSection CGameServer::m_csMapIDAction;
  25. CGameServer::stdMapIDConvert CGameServer::m_theMapIDConvert;
  27. CEvent CGameServer::m_shQuitEvent( NULL, true, false, NULL/*"GS_QUIT_EVENT"*/ );
  28. CEvent CGameServer::m_shStartupManagerThreadEvent( NULL, false, false, NULL/*"GS_MANAGER_EVENT"*/ );
  30. HANDLE CGameServer::m_shManagerThread = NULL;
  32. CGameServer::stdGameSvr CGameServer::m_theGameServers;
  33. CCriticalSection CGameServer::m_csGameSvrAction;
  35. /*
  36.  * CGamePlayer Global Function
  37.  */
  38. bool CGameServer::SetupGlobalAllocator( size_t bufferSize, size_t maxFreeBuffers )
  39. {
  40. return CGameServer::m_theGlobalAllocator.ReSet( bufferSize, maxFreeBuffers );
  41. }
  43. LONG CGameServer::m_slnIdentityCounts = 0L;
  45. /*
  46.  * A generator of guid
  47.  */
  48. static void GenGuid( GUID *guid )
  49. {
  50. ASSERT( guid );
  52. static char szData[9] = { 0 };
  53. static DWORD dwBase = 0;
  55. if ( FAILED( ::CoCreateGuid( guid ) ) )
  56. {
  57. if ( ( dwBase >> 31 ) & 0x1 )
  58. {
  59. dwBase = 0;
  60. }
  62. /*
  63.  * Make a 128 bits cipher
  64.  */
  65. guid->Data1 = dwBase++;
  66. guid->Data2 = ( DWORD )rand() & 0xFFFF;
  67. guid->Data3 = ( ( DWORD )rand() >> 16 ) & 0xFFFF ;
  69. sprintf( ( char * )szData, "%d%d", ( ( DWORD )rand() + dwBase++ ), ( DWORD )rand() );
  70. memcpy( guid->Data4, szData, 8 );
  71. }
  72. }
  74. /*
  75.  * class CGameServer
  76.  */
  77. CGameServer::CGameServer( IServer *pGameSvrServer,
  78.  IClient *pAccountClient,
  79.  UINT nIdentityID /* = -1 */ )
  80. : m_lnIdentityID( nIdentityID )
  81. , m_pGameSvrServer( pGameSvrServer )
  82. // , m_pAccountClient( pAccountClient )
  83. , m_nServerIP_Internet( 0 )
  84. , m_nServerIP_Intraner( 0 )
  85. , m_nServerPort( 0 )
  86. , m_dwCapability( -1 )
  88. {
  89. LONG lnID = ::InterlockedExchangeAdd( &m_slnIdentityCounts, 1 );
  91. m_lnIdentityID = ( ( UINT )( -1 ) == m_lnIdentityID ) ? lnID : m_lnIdentityID;
  92. }
  94. CGameServer::~CGameServer()
  95. {
  96. // SAFE_RELEASE( m_pGameSvrServer );
  97. // SAFE_RELEASE( m_pAccountClient );
  99. m_thePackager.Empty();
  101. ::InterlockedExchangeAdd( &m_slnIdentityCounts, -1 );
  102. }
  104. bool CGameServer::Create()
  105. {
  106. ZeroMemory( m_theProcessProtocolFun, sizeof( m_theProcessProtocolFun ) );
  108. m_theProcessProtocolFun[c2s_registeraccount]  = _RegisterAccount;
  109. m_theProcessProtocolFun[c2s_entergame] = _NotifyEnterGame;
  110. m_theProcessProtocolFun[c2s_leavegame] = _NotifyLeaveGame;
  111. m_theProcessProtocolFun[c2s_permitplayerlogin] = _NotifyPlayerLogin;
  112. m_theProcessProtocolFun[c2s_updatemapinfo] = _UpdateMapID;
  113. m_theProcessProtocolFun[c2s_updategameserverinfo] = _UpdateGameSvrInfo;
  114. m_theProcessProtocolFun[c2s_requestsvrip] = _RequestSvrIP;
  116. /*
  117.  * Query gameserver information
  118.  */
  119. _QueryGameSvrInfo();
  121. return _QueryMapID();
  122. }
  124. bool CGameServer::Destroy()
  125. {
  126. {
  127. CCriticalSection::Owner lock( m_csAITS );
  129. stdAccountAttachIn::iterator it;
  131. for ( it = m_theAccountInThisServer.begin(); it != m_theAccountInThisServer.end(); it ++ )
  132. {
  133. string sAccountName = ( *it ).first;
  135. FreezeMoney( sAccountName.c_str(), 0);
  136. }
  137. }
  139. m_dwCapability = 0;
  140. m_nServerPort = 0;
  141. m_nServerIP_Intraner = 0;
  142. m_nServerIP_Internet = 0;
  143. m_sServerIPAddr_Internet = "";
  144. m_sServerIPAddr_Intraner = "";
  146. {
  147. CCriticalSection::Owner locker( m_csMapIDAction );
  149. stdMapIDConvert::iterator itM2C;
  151. for ( itM2C = m_theMapIDConvert.begin(); itM2C != m_theMapIDConvert.end(); itM2C ++ )
  152. {
  153. stdServerList &sl = ( *itM2C ).second;
  155. if ( !sl.empty() )
  156. {
  157. sl.remove( this );
  158. }
  159. }
  160. }
  162. return true;
  163. }
  165. void __stdcall CGameServer::GameSvrEventNotify( LPVOID lpParam,
  166. const unsigned long &ulnID,
  167. const unsigned long &ulnEventType )
  168. {
  169. CGameServer::LPNI pNI = reinterpret_cast< CGameServer::NI * >( lpParam );
  171. ASSERT( pNI );
  173. CCriticalSection::Owner locker( CGameServer::m_csGameSvrAction );
  175. switch ( ulnEventType )
  176. {
  177. case enumClientConnectCreate:
  178. {
  179. IGServer *pGServer = new CGameServer( pNI->pServer, pNI->pClient, ulnID );
  181. ASSERT( pGServer );
  183. pGServer->Create();
  185. std::pair< CGameServer::stdGameSvr::iterator, bool > result = 
  186. CGameServer::m_theGameServers.insert( CGameServer::stdGameSvr::value_type( ulnID, pGServer ) );
  188. if ( result.second && pNI->hwndContainer && ::IsWindow( pNI->hwndContainer ) )
  189. {
  190. ::PostMessage( pNI->hwndContainer, WM_GAMESERVER_EXCHANGE, ADD_GAMESERVER_ACTION, ulnID );
  191. }
  192. }
  193. break;
  195. case enumClientConnectClose:
  196. {
  197. stdGameSvr::iterator it;
  199. if ( CGameServer::m_theGameServers.end() != 
  200. ( it = CGameServer::m_theGameServers.find( ulnID ) ) )
  201. {
  202. if ( pNI->hwndContainer && ::IsWindow( pNI->hwndContainer ) )
  203. {
  204. ::PostMessage( pNI->hwndContainer, WM_GAMESERVER_EXCHANGE, DEL_GAMESERVER_ACTION, ulnID );
  205. }
  207. IGServer *pGServer = ( *it ).second;
  209. ASSERT( pGServer );
  211. CGameServer::m_theGameServers.erase( it );
  213. pGServer->Destroy();
  215. SAFE_DELETE( pGServer );
  216. }
  217. }
  218. break;
  219. }
  220. }
  222. bool CGameServer::Begin( IServer *pGameSvrServer )
  223. {
  224. /*
  225.  * Startup a manager thread
  226.  */
  227. DWORD dwThreadID = 0;
  229. m_shManagerThread = ::CreateThread( NULL, 
  230. 0, 
  231. ManagerThreadFunction, 
  232. ( void * )pGameSvrServer,
  233. 0, 
  234. &dwThreadID );
  236. if ( m_shManagerThread == INVALID_HANDLE_VALUE )
  237. {
  238. return false;
  239. }
  241. m_shStartupManagerThreadEvent.Set();
  243. return true;
  244. }
  246. void CGameServer::End()
  247. {
  248. m_shQuitEvent.Set();
  250. m_shStartupManagerThreadEvent.Set();
  252. if ( WAIT_TIMEOUT == ::WaitForSingleObject( m_shManagerThread, 5000 ) )
  253. {
  254. ::TerminateThread( m_shManagerThread, 0 );
  255. }
  257. SAFE_CLOSEHANDLE( m_shManagerThread );
  260. /*
  261.  * MapID & GameServer
  262.  */
  263. {
  264. CCriticalSection::Owner locker( m_csMapIDAction );
  266. stdMapIDConvert::iterator itM2C;
  268. for ( itM2C = m_theMapIDConvert.begin(); itM2C != m_theMapIDConvert.end(); itM2C ++ )
  269. {
  270. stdServerList &SL = ( *itM2C ).second;
  272. SL.clear();
  273. }
  275. m_theMapIDConvert.erase( m_theMapIDConvert.begin(), m_theMapIDConvert.end() );
  276. }
  278. /*
  279.  * Clear gameserver information
  280.  */
  281. {
  282. CCriticalSection::Owner locker( m_csGameSvrAction );
  284. m_theGameServers.erase( m_theGameServers.begin(), m_theGameServers.end() );
  285. }
  286. }
  288. DWORD WINAPI CGameServer::ManagerThreadFunction( void *pParam )
  289. {
  290. IServer *pGameSvrServer = ( IServer * )pParam;
  292. ASSERT( pGameSvrServer );
  294. m_shStartupManagerThreadEvent.Wait();
  296. stdGameSvr::iterator it;
  298. while ( !m_shQuitEvent.Wait( 0 ) )
  299. {
  300. CCriticalSection::Owner locker( CGameServer::m_csGameSvrAction );
  302. for ( it = CGameServer::m_theGameServers.begin(); 
  303. it != CGameServer::m_theGameServers.end(); 
  304. it ++ )
  305. {
  306. UINT nlnID = ( *it ).first;
  308. size_t datalength = 0;
  310. const void *pData = pGameSvrServer->GetPackFromClient( nlnID, datalength );
  312. if ( 0 == datalength || NULL == pData )
  313. {
  314. continue;
  315. }
  317. IGServer *pGServer = ( *it ).second;
  319. if ( pGServer )
  320. {
  321. pGServer->AnalyzeRequire( pData, datalength );
  322. }
  323. }
  325. ::Sleep( 1 );
  326. }
  328. SAFE_RELEASE( pGameSvrServer );
  330. return 0;
  331. }
  333. bool CGameServer::AnalyzeRequire( const void *pData, size_t datalength )
  334. {
  335. bool ok = true;
  337. BYTE cProtocol = CPackager::Peek( pData );
  339. if ( cProtocol < g_nGlobalProtocolType )
  340. {
  341. return LargePackProcess( cProtocol, pData, datalength );
  342. }
  343. else if ( cProtocol > g_nGlobalProtocolType )
  344. {
  345. return SmallPackProcess( cProtocol, pData, datalength );
  346. }
  348. return false;
  349. }
  351. bool CGameServer::LargePackProcess( BYTE cProtocol, const void *pData, size_t datalength )
  352. {
  353. return true;
  354. }
  356. bool CGameServer::SmallPackProcess( BYTE cProtocol, const void *pData, size_t datalength )
  357. {
  358. if ( cProtocol < c2s_end && m_theProcessProtocolFun[cProtocol] )
  359. {
  360. return ( this->*m_theProcessProtocolFun[cProtocol] )( ( const void * )pData, datalength );
  361. }
  363. return false;
  364. }
  366. bool CGameServer::DispatchTask( UINT nTask, const void *pData, size_t datalength, WORD nData )
  367. {
  368. bool ok = true;
  370. switch ( nTask )
  371. {
  372. case enumSyncRoleInfo:
  374. ok = _SyncRoleInfo( pData, datalength, nData);
  376. break;
  378. case enumPlayerLogicLogout:
  380. ok = _PlayerLogicLogout( pData, datalength );
  382. break;
  384. case enumTaskProtocol:
  385. default:
  386. break;
  387. }
  389. return true;
  390. }
  392. bool CGameServer::_QueryMapID()
  393. {
  394. tagQueryMapInfo qmi;
  396. qmi.cProtocol = s2c_querymapinfo;
  398. m_pGameSvrServer->SendData( m_lnIdentityID, ( const void * )&qmi, sizeof( tagQueryMapInfo ) );
  400. return true;
  401. }
  403. bool CGameServer::_QueryGameSvrInfo()
  404. {
  405. tagQueryGameSvrInfo qgsi;
  407. qgsi.cProtocol = s2c_querygameserverinfo;
  409. m_pGameSvrServer->SendData( m_lnIdentityID, ( const void * )&qgsi, sizeof( tagQueryGameSvrInfo ) );
  411. return true;
  412. }
  414. bool CGameServer::_UpdateMapID( const void *pData, size_t datalength )
  415. {
  416. tagUpdateMapID *pUMI = ( tagUpdateMapID * )pData;
  418. int  nMapCount = pUMI->cMapCount;
  419. BYTE *pMapID = pUMI->szMapID;
  421. while ( --nMapCount >= 0 )
  422. {
  423. RegisterServer( pMapID[nMapCount], ( IGServer * )this );
  424. }
  426. return true;
  427. }
  429. bool CGameServer::_UpdateGameSvrInfo( const void *pData, size_t datalength )
  430. {
  431. ASSERT( sizeof( tagGameSvrInfo ) == datalength );
  433. tagGameSvrInfo *pGSI = ( tagGameSvrInfo * )pData;
  435. m_dwCapability = pGSI->wCapability;
  437. m_nServerPort = pGSI->nPort;
  439. m_nServerIP_Internet = pGSI->nIPAddr_Internet;
  440. m_nServerIP_Intraner = pGSI->nIPAddr_Intraner;
  442. m_sServerIPAddr_Intraner = OnlineGameLib::Win32::net_ntoa( m_nServerIP_Intraner );
  443. m_sServerIPAddr_Internet = OnlineGameLib::Win32::net_ntoa( m_nServerIP_Internet );
  445. return true;
  446. }
  448. bool CGameServer::_RequestSvrIP( const void *pData, size_t datalength )
  449. {
  450. tagRequestSvrIp *pRSI = ( tagRequestSvrIp * )pData;
  452. ASSERT( sizeof( tagRequestSvrIp ) == datalength );
  454. DWORD dwIP = 0;
  455. IGServer *pGServer = CGameServer::QueryServer( pRSI->dwMapID );
  457. if ( pGServer )
  458. {
  459. dwIP = pGServer->GetIP( pRSI->cIPType );
  460. }
  462. tagNotifySvrIp nsi;
  464. nsi.cProtocol = s2c_notifysvrip;
  466. nsi.pckgID = pRSI->pckgID;
  467. nsi.dwMapID = pRSI->dwMapID;
  468. nsi.cIPType = pRSI->cIPType;
  469. nsi.dwSvrIP = dwIP;
  471. m_pGameSvrServer->SendData( m_lnIdentityID, ( const void * )&nsi, sizeof( tagNotifySvrIp ) );
  473. return true;
  474. }
  476. bool CGameServer::_NotifyPlayerLogin( const void *pData, size_t datalength )
  477. {
  478. tagPermitPlayerLogin *pPPL = ( tagPermitPlayerLogin * )pData;
  480. ASSERT( sizeof( tagPermitPlayerLogin ) == datalength );
  482. bool ok = false;
  484. IPlayer *pPlayer = CGamePlayer::Get( ( const char * )( pPPL->szRoleName ) );
  486. if ( pPlayer )
  487. {
  488. tagNotifyPlayerLogin npl;
  490. npl.cProtocol = s2c_notifyplayerlogin;
  492. int nMinLen = strlen( ( const char * )pPPL->szRoleName );
  493. nMinLen = nMinLen > sizeof( npl.szRoleName ) ? sizeof( npl.szRoleName ) : nMinLen;
  494. memcpy( ( char * )npl.szRoleName, ( const char * )pPPL->szRoleName, nMinLen );
  495. npl.szRoleName[nMinLen] = '';
  497. memcpy( &( npl.guid ), &( pPPL->guid ), sizeof( GUID ) );
  499. npl.bPermit = pPPL->bPermit; 
  501. npl.nIPAddr = m_nServerIP_Internet;
  502. npl.nPort = m_nServerPort;
  504. ok = pPlayer->AppendData( CGamePlayer::enumOwnerPlayer, ( const void * )&npl, sizeof( tagNotifyPlayerLogin ) );
  505. }
  507. return ok;
  508. }
  510. bool CGameServer::_RegisterAccount( const void *pData, size_t datalength )
  511. {
  512. ASSERT( pData && datalength );
  514. tagRegisterAccount *pRA = ( tagRegisterAccount * )pData;
  516. if ( sizeof( tagRegisterAccount ) != datalength )
  517. {
  518. return false;
  519. }
  521. AttatchAccountToGameServer( ( const char * )pRA->szAccountName );
  523. return true;
  524. }
  526. bool CGameServer::_NotifyEnterGame( const void *pData, size_t datalength )
  527. {
  528. ASSERT( pData && datalength );
  530. tagEnterGame *pEG = ( tagEnterGame * )pData;
  532. if ( sizeof( tagEnterGame ) != datalength )
  533. {
  534. return false;
  535. }
  537. BYTE *pAccountName = ( BYTE * )( pEG->szAccountName );
  539. PushAccount( ( const char * )pAccountName );
  541. return true;
  542. }
  544. bool CGameServer::_NotifyLeaveGame( const void *pData, size_t datalength )
  545. {
  546. ASSERT( pData && datalength );
  548. tagLeaveGame *pLG = ( tagLeaveGame * )pData;
  550. ASSERT( sizeof( tagLeaveGame ) == datalength );
  552. BYTE *pAccountName = ( BYTE * )( pLG->szAccountName );
  554. return PopAccount( ( const char * )pAccountName, ( pLG->cCmdType != HOLDACC_LEAVEGAME ), pLG->nExtPoint);
  555. }
  557. bool CGameServer::PushAccount( const char *pAccountName )
  558. {
  559. ASSERT( pAccountName );
  561. return ConsumeMoney( pAccountName );
  562. }
  564. bool CGameServer::PopAccount( const char *pAccountName, bool bUnlockAccount, WORD nExtPoint )
  565. {
  566. ASSERT( pAccountName );
  568. if ( HaveAccountInGameServer( pAccountName ) )
  569. {
  570. if ( bUnlockAccount )
  571. {
  572. FreezeMoney( pAccountName, nExtPoint);
  573. }
  575. DetachAccountFromGameServer( pAccountName );
  577. return true;
  578. }
  580. return false;
  581. }
  583. bool CGameServer::Attach( const char *pAccountName )
  584. {
  585. return AttatchAccountToGameServer( pAccountName );
  586. }
  588. bool CGameServer::AttatchAccountToGameServer( const char *pAccountName )
  589. {
  590. if ( !pAccountName || !pAccountName[0] )
  591. {
  592. return false;
  593. }
  595. if ( _NAME_LEN > strlen( pAccountName ) )
  596. {
  597. CCriticalSection::Owner lock( m_csAITS );
  599. std::pair< stdAccountAttachIn::iterator, bool > result = 
  600. m_theAccountInThisServer.insert( stdAccountAttachIn::value_type( pAccountName, 
  601. reinterpret_cast< void * >( this ) ) );
  603. return result.second;
  604. }
  606. return false;
  607. }
  609. bool CGameServer::HaveAccountInGameServer( const char *pAccountName )
  610. {
  611. if ( !pAccountName || !pAccountName[0] )
  612. {
  613. return false;
  614. }
  616. if ( _NAME_LEN > strlen( pAccountName ) )
  617. {
  618. CCriticalSection::Owner lock( m_csAITS );
  620. stdAccountAttachIn::iterator it;
  622. if ( m_theAccountInThisServer.end() != 
  623. ( it = m_theAccountInThisServer.find( pAccountName ) ) )
  624. {
  625. return true;
  626. }
  627. }
  629. return false;
  630. }
  632. bool CGameServer::DetachAccountFromGameServer( const char *pAccountName )
  633. {
  634. if ( !pAccountName || !pAccountName[0] )
  635. {
  636. return false;
  637. }
  639. if ( _NAME_LEN > strlen( pAccountName ) )
  640. {
  641. CCriticalSection::Owner lock( m_csAITS );
  643. stdAccountAttachIn::iterator it;
  645. if ( m_theAccountInThisServer.end() != 
  646. ( it = m_theAccountInThisServer.find( pAccountName ) ) )
  647. {
  648. CGameServer *pThis = reinterpret_cast< CGameServer * >( ( *it ).second );
  650. ASSERT( pThis && pThis == this );
  652. m_theAccountInThisServer.erase( it );
  654. return true;
  655. }
  656. }
  658. return false;
  659. }
  661. bool CGameServer::ConsumeMoney( const char *pAccountName )
  662. {
  663. if ( !pAccountName || !pAccountName[0] )
  664. {
  665. return false;
  666. }
  668. if ( _NAME_LEN <= strlen( pAccountName ) )
  669. {
  670. return false;
  671. }
  673. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  675. BYTE *pContext = const_cast< BYTE * >( pBuffer->GetBuffer() );
  677. const size_t len = sizeof( KAccountUser ) + 1;
  679. KAccountUser user;
  681. user.Size = sizeof( KAccountUser );
  682. user.Type = AccountUser;
  683. user.Version = ACCOUNT_CURRENT_VERSION;
  685. size_t length = strlen( pAccountName );
  686. length = ( length > LOGIN_USER_ACCOUNT_MAX_LEN ) ? LOGIN_USER_ACCOUNT_MAX_LEN : length;
  687. memcpy( user.Account, pAccountName, length );
  688. user.Account[length] = '';
  690. *pContext = c2s_gamelogin;
  691. memcpy( pContext + 1, &user, sizeof( KAccountUser ) );
  693. g_theSmartClient.Send( pContext, len );
  694. //m_pAccountClient->SendPackToServer( pContext, len );
  696. SAFE_RELEASE( pBuffer );
  698. return true;
  699. }
  701. bool CGameServer::FreezeMoney( const char *pAccountName, WORD nExtPoint )
  702. {
  703. if ( !pAccountName || !pAccountName[0] )
  704. {
  705. return false;
  706. }
  708. if ( _NAME_LEN <= strlen( pAccountName ) )
  709. {
  710. return false;
  711. }
  713. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  715. BYTE *pData = const_cast< BYTE * >( pBuffer->GetBuffer() );
  717. const size_t datalength = sizeof( KAccountUserLogout ) + 1;
  719. KAccountUserLogout user;
  721. user.Size = sizeof( KAccountUserLogout );
  722. user.Type = AccountUserLogout;
  723. user.Version = ACCOUNT_CURRENT_VERSION;
  724. user.nExtPoint = nExtPoint;
  726. size_t length = strlen( pAccountName );
  727. length = ( length > LOGIN_USER_ACCOUNT_MAX_LEN ) ? LOGIN_USER_ACCOUNT_MAX_LEN : length;
  728. memcpy( user.Account, pAccountName, length );
  729. user.Account[length] = '';
  731. *pData = c2s_accountlogout;
  732. memcpy( pData + 1, &user, sizeof( KAccountUserLogout ) );
  734. g_theSmartClient.Send( ( const void * )pData, datalength );
  735. //m_pAccountClient->SendPackToServer( ( const void * )pData, datalength );
  737. SAFE_RELEASE( pBuffer );
  739. return true;
  740. }
  742. bool CGameServer::_PlayerLogicLogout( const void *pData, size_t datalength )
  743. {
  744. tagLogicLogout ll;
  746. if ( sizeof( ll.szRoleName ) < datalength )
  747. {
  748. return false;
  749. }
  751. ll.cProtocol = s2c_logiclogout;
  752. memcpy( ll.szRoleName, pData, datalength );
  754. m_pGameSvrServer->SendData( m_lnIdentityID, ( const void * )&ll, sizeof( tagLogicLogout ) );
  756. return true;
  757. }
  759. bool CGameServer::_SyncRoleInfo( const void *pData, size_t datalength, WORD nData )
  760. {
  761. /*
  762.  * Send role data to the game server
  763.  */
  764. tagGuidableInfo ginfo;
  766. ginfo.cProtocol = s2c_syncgamesvr_roleinfo_cipher;
  768. GenGuid( &( ginfo.guid ) );
  770. ginfo.nExtPoint = nData;
  771. ginfo.nChangePoint = 0;
  773. ginfo.datalength = datalength;
  775. m_thePackager.AddData( s2c_syncgamesvr_roleinfo_cipher, ( const char * )&ginfo, sizeof( tagGuidableInfo ) );
  776. m_thePackager.AddData( s2c_syncgamesvr_roleinfo_cipher, ( const char * )pData, datalength );
  778. /*
  779.  * Begin to split this buffer
  780.  */
  781. CBuffer *pBuffer = m_thePackager.GetHeadPack( s2c_syncgamesvr_roleinfo_cipher );
  783. while ( pBuffer )
  784. {
  785. m_pGameSvrServer->SendData( m_lnIdentityID, pBuffer->GetBuffer(), pBuffer->GetUsed() );
  787. /*
  788.  * Your must relase this buffer
  789.  */
  790. SAFE_RELEASE( pBuffer );
  792. /*
  793.  * Get next package
  794.  */
  795. pBuffer = m_thePackager.GetNextPack( s2c_syncgamesvr_roleinfo_cipher );
  796. }
  798. SAFE_RELEASE( pBuffer );
  800. m_thePackager.DelData( s2c_syncgamesvr_roleinfo_cipher );
  802. return true;
  803. }
  805. bool CGameServer::RegisterServer( UINT nID, IGServer *pGServer )
  806. {
  807. ASSERT( pGServer );
  809. CCriticalSection::Owner locker( m_csMapIDAction );
  811. stdMapIDConvert::iterator it;
  813. /*
  814.  * Append this sever information into table
  815.  */
  816. if ( m_theMapIDConvert.end() != ( it = m_theMapIDConvert.find( nID ) ) )
  817. {
  818. stdServerList& sl = ( *it ).second;
  820. sl.push_back( pGServer );
  821. }
  822. else
  823. {
  824. /*
  825.  * Insert this server information into table
  826.  */
  827. stdServerList sl;
  829. sl.push_back( pGServer );
  831. std::pair< stdMapIDConvert::iterator, bool > result =
  832. m_theMapIDConvert.insert( stdMapIDConvert::value_type( nID, sl ) );
  834. return result.second;
  835. }
  837. return true;
  838. }
  840. IGServer *CGameServer::QueryServer( UINT nMapID )
  841. {
  842. CCriticalSection::Owner locker( m_csMapIDAction );
  844. stdMapIDConvert::iterator it;
  846. if ( m_theMapIDConvert.end() != ( it = m_theMapIDConvert.find( nMapID ) ) )
  847. {
  848. stdServerList& sl = ( *it ).second;
  850. /*
  851.  * TODO : Don't get the server when it can't carry anyone
  852.  */
  853. if ( !sl.empty() )
  854. {
  855. IGServer *pGServer = NULL;
  857. stdServerList::iterator it;
  858. for ( it = sl.begin(); it != sl.end(); it ++ )
  859. {
  860. pGServer = ( IGServer * )( *it );
  862. ASSERT( pGServer );
  864. if ( NULL == pGServer )
  865. {
  866. continue;
  867. }
  869. if ( pGServer->GetContent() < pGServer->GetCapability() )
  870. {
  871. return pGServer;
  872. }
  873. }
  874. }
  875. }
  877. return NULL;
  878. }
  880. IGServer *CGameServer::GetServer( size_t nID )
  881. {
  882. CCriticalSection::Owner locker( CGameServer::m_csGameSvrAction );
  884. stdGameSvr::iterator it;
  886. if ( CGameServer::m_theGameServers.end() != 
  887. ( it = CGameServer::m_theGameServers.find( nID ) ) )
  888. {
  889. IGServer *pGServer = ( *it ).second;
  891. ASSERT( pGServer );
  893. return pGServer;
  894. }
  896. return NULL;
  897. }
  899. size_t CGameServer::GetContent()
  900. {
  901. CCriticalSection::Owner lock( m_csAITS );
  903. return m_theAccountInThisServer.size();
  904. }
  906. void CGameServer::SendToAll( const char *pText, int nLength, UINT uOption )
  907. {
  908. stdGameSvr::iterator it;
  910. CCriticalSection::Owner locker( CGameServer::m_csGameSvrAction );
  912. for ( it = CGameServer::m_theGameServers.begin(); 
  913. it != CGameServer::m_theGameServers.end(); 
  914. it ++ )
  915. {
  916. IGServer *pGServer = ( *it ).second;
  918. if ( pGServer )
  919. {
  920. pGServer->SendText( pText, nLength, uOption );
  921. }
  922. }
  923. }
  925. void CGameServer::SendText( const char *pText, int nLength, UINT uOption )
  926. {
  927. if ( !pText || 0 == nLength || !m_pGameSvrServer )
  928. {
  929. return;
  930. }
  932. tagGatewayBroadCast gbc;
  934. gbc.cProtocol = s2c_gateway_broadcast;
  935. gbc.uCmdType = uOption;
  937. int nLen = 0;
  938. if ( sizeof( gbc.szData ) > nLength )
  939. {
  940. strcpy( gbc.szData, pText );
  942. nLen = nLength;
  943. }
  945. gbc.szData[nLen] = '';
  947. m_pGameSvrServer->SendData( m_lnIdentityID, ( const void * )&gbc, sizeof( tagGatewayBroadCast ) );
  948. }