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

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

模拟服务器

开发平台：

C/C++

Intercessor.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "Intercessor.h"
  4. #include "AccountLoginDef.h"
  5. #include "LoginDef.h"
  7. #include "KProtocolDef.h"
  8. #include "KProtocol.h"
  10. #include "Macro.h"
  11. #include "Buffer.h"
  13. #include "SmartClient.h"
  15. using OnlineGameLib::Win32::CEvent;
  16. using OnlineGameLib::Win32::CCriticalSection;
  17. using OnlineGameLib::Win32::CPackager;
  19. OnlineGameLib::Win32::CLibrary CIntercessor::m_theHeavenLib( "heaven.dll" );
  20. OnlineGameLib::Win32::CLibrary CIntercessor::m_theRainbowLib( "rainbow.dll" );
  22. CIntercessor::CIntercessor( unsigned long lnMaxPlayerCount, CNetwork &theNetworkConfig )
  23. : m_hwndViewer( NULL )
  24. // , m_pAccSvrClient( NULL )
  25. , m_pDBRoleClient( NULL )
  26. , m_pGameSvrServer( NULL )
  27. , m_pPlayerServer( NULL )
  28. , m_hWorkingThread( INVALID_HANDLE_VALUE )
  29. , m_hHelperThread( INVALID_HANDLE_VALUE )
  30. , m_hQuitEvent( NULL, true, false, NULL /*"PM_Quit_Event"*/ )
  31. , m_hStartupWoringThreadEvent( NULL, false, false, NULL /*"PM_WORKING_EVENT"*/ )
  32. , m_hStartupHelperThreadEvent( NULL, false, false, NULL /*"PM_HELPER_EVENT"*/ )
  33. , m_theNetworkConfig( theNetworkConfig )
  34. , m_lnMaxPlayerCount( lnMaxPlayerCount )
  35. {
  37. }
  39. CIntercessor::~CIntercessor()
  40. {
  42. }
  44. bool CIntercessor::Create( HWND hwndViewer /* NULL */ )
  45. {
  46. m_hwndViewer = hwndViewer;
  48. /*
  49.  * Start a working thread
  50.  */
  51. DWORD dwThreadID = 0;
  53. m_hWorkingThread = ::CreateThread( NULL, 
  54. 0, 
  55. WorkingThreadFunction, 
  56. ( void * )this, 
  57. 0, 
  58. &dwThreadID );
  60. if ( m_hWorkingThread == INVALID_HANDLE_VALUE )
  61. {
  62. return false;
  63. }
  65. /*
  66.  * Startup a helper thread
  67.  */
  68. dwThreadID = 0;
  70. m_hHelperThread = ::CreateThread( NULL, 
  71. 0, 
  72. HelperThreadFunction, 
  73. ( void * )this,
  74. 0, 
  75. &dwThreadID );
  77. if ( m_hHelperThread == INVALID_HANDLE_VALUE )
  78. {
  79. return false;
  80. }
  82. // m_pAccSvrClient = m_theNetworkConfig.CreateAccSvrClient( m_theNetworkConfig.GetAccSvrIP(), m_theNetworkConfig.GetAccSvrPort() );
  84. // ASSERT( m_pAccSvrClient );
  86. // m_pAccSvrClient->RegisterMsgFilter( ( void * )this, AccountEventNotify );
  88. return StartupNetwork();
  89. }
  91. void CIntercessor::Destroy()
  92. {
  93. m_hQuitEvent.Set();
  95. m_hStartupWoringThreadEvent.Set();
  96. m_hStartupHelperThreadEvent.Set();
  98. SAFE_CLOSEHANDLE( m_hWorkingThread );
  99. SAFE_CLOSEHANDLE( m_hHelperThread );
  101. // SAFE_RELEASE( m_pAccSvrClient );
  103. CleanNetwork();
  104. }
  105. /*
  106. void __stdcall CIntercessor::AccountEventNotify( LPVOID lpParam, 
  107. const unsigned long &ulnEventType )
  108. {
  109. CIntercessor *pPlayerManager = reinterpret_cast< CIntercessor * >( lpParam );
  111. ASSERT( pPlayerManager );
  113. try
  114. {
  115. pPlayerManager->_AccountEventNotify( ulnEventType );
  116. }
  117. catch(...)
  118. {
  119. TRACE( "CIntercessor::AccountEventNotify exception!" );
  120. }
  121. }
  123. void CIntercessor::_AccountEventNotify( const unsigned long &ulnEventType )
  124. {
  125. switch( ulnEventType )
  126. {
  127. case enumServerConnectCreate:
  129. ::PostMessage( m_hwndViewer, WM_SERVER_STATUS, ACCOUNTSERVER_NOTIFY, CONNECTED );
  131. break;
  133. case enumServerConnectClose:
  135. ::PostMessage( m_hwndViewer, WM_SERVER_STATUS, ACCOUNTSERVER_NOTIFY, DICONNECTED );
  137. break;
  138. }
  139. }
  140. */
  141. void __stdcall CIntercessor::DBRoleEventNotify( LPVOID lpParam, 
  142. const unsigned long &ulnEventType )
  143. {
  144. CIntercessor *pPlayerManager = reinterpret_cast< CIntercessor * >( lpParam );
  146. ASSERT( pPlayerManager );
  148. try
  149. {
  150. pPlayerManager->_DBRoleEventNotify( ulnEventType );
  151. }
  152. catch(...)
  153. {
  154. TRACE( "CIntercessor::DBRoleEventNotify exception!" );
  155. }
  156. }
  158. void CIntercessor::_DBRoleEventNotify( const unsigned long &ulnEventType )
  159. {
  160. switch( ulnEventType )
  161. {
  162. case enumServerConnectCreate:
  164. ::PostMessage( m_hwndViewer, WM_SERVER_STATUS, DBROLESERVER_NOTIFY, CONNECTED );
  166. break;
  168. case enumServerConnectClose:
  170. ::PostMessage( m_hwndViewer, WM_SERVER_STATUS, DBROLESERVER_NOTIFY, DICONNECTED );
  172. break;
  173. }
  174. }
  176. void __stdcall CIntercessor::PlayerEventNotify( LPVOID lpParam,
  177. const unsigned long &ulnID,
  178. const unsigned long &ulnEventType )
  179. {
  180. CIntercessor *pPlayerManager = reinterpret_cast< CIntercessor * >( lpParam );
  182. ASSERT( pPlayerManager );
  184. try
  185. {
  186. pPlayerManager->_PlayerEventNotify( ulnID, ulnEventType );
  187. }
  188. catch(...)
  189. {
  190. TRACE( "CIntercessor::PlayerEventNotify exception!" );
  191. }
  192. }
  194. void CIntercessor::_PlayerEventNotify( const unsigned long &ulnID,
  195. const unsigned long &ulnEventType )
  196. {
  197. //CCriticalSection::Owner locker( m_csPlayerAction );
  199. switch ( ulnEventType )
  200. {
  201. case enumClientConnectCreate:
  202. {
  203. IPlayer *pPlayer = m_thePlayers[ulnID];
  205. ASSERT( pPlayer );
  207. pPlayer->Active();
  208. }
  209. break;
  211. case enumClientConnectClose:
  212. {
  213. PLAYER_MAP::iterator it;
  215. if ( m_thePlayers.end() != ( it = m_thePlayers.find( ulnID ) ) )
  216. {
  217. IPlayer *pPlayer = m_thePlayers[ulnID];
  219. ASSERT( pPlayer );
  221. pPlayer->Inactive();
  222. }
  223. }
  224. break;
  225. }
  226. }
  228. bool CIntercessor::StartupNetwork()
  229. {
  230. bool bPlayerServerSucceed = false;
  231. bool bDBRoleServerSucceed = false;
  232. bool bGameSvrServerSucceed = false;
  234. /*
  235.  * There is connectted the heaven by the rainbow
  236.  */
  238. /*
  239.  * For the db-role server
  240.  */
  241. pfnCreateClientInterface pClientFactroyFun = ( pfnCreateClientInterface )( m_theRainbowLib.GetProcAddress( _T( "CreateInterface" ) ) );
  243. IClientFactory *pClientFactory = NULL;
  245. if ( pClientFactroyFun && SUCCEEDED( pClientFactroyFun( IID_IClientFactory, reinterpret_cast< void ** >( &pClientFactory ) ) ) )
  246. {
  247. pClientFactory->SetEnvironment( 1024 * 1024 );
  249. pClientFactory->CreateClientInterface( IID_IESClient, reinterpret_cast< void ** >( &m_pDBRoleClient ) );
  251. SAFE_RELEASE( pClientFactory );
  252. }
  254. if ( m_pDBRoleClient )
  255. {
  256. m_pDBRoleClient->Startup();
  258. m_pDBRoleClient->RegisterMsgFilter( reinterpret_cast< void * >( this ), DBRoleEventNotify );
  260. if ( SUCCEEDED( m_pDBRoleClient->ConnectTo( m_theNetworkConfig.GetRoleSvrIP(), m_theNetworkConfig.GetRoleSvrPort() ) ) )
  261. {
  262. bDBRoleServerSucceed = true;
  263. }
  264. }
  266. /*
  267.  * We open the heaven to wait for the rainbow
  268.  */
  269. pfnCreateServerInterface pServerFactroyFun = 
  270. ( pfnCreateServerInterface )( m_theHeavenLib.GetProcAddress( _T( "CreateInterface" ) ) );
  272. IServerFactory *pServerFactory = NULL;
  274. if ( pServerFactroyFun && 
  275. SUCCEEDED( pServerFactroyFun( IID_IServerFactory, reinterpret_cast< void ** >( &pServerFactory ) ) ) )
  276. {
  277. pServerFactory->SetEnvironment( m_lnMaxPlayerCount, 10, 1000, 1024 * 8 );
  279. /*
  280.  * For player
  281.  */
  282. pServerFactory->CreateServerInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &m_pPlayerServer ) );
  284. /*
  285.  * For gameserver
  286.  */
  287. pServerFactory->CreateServerInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &m_pGameSvrServer ) );
  289. pServerFactory->Release();
  290. }
  292. if ( m_pGameSvrServer )
  293. {
  294. m_pGameSvrServer->Startup();
  295. /*
  296. IServer *pCloneGameServer = NULL;
  297. m_pGameSvrServer->QueryInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &pCloneGameServer ) );
  299. IClient *pCloneAcc = NULL;
  300. m_pAccSvrClient->QueryInterface( IID_IESClient, reinterpret_cast< void ** >( &pCloneAcc ) );
  301. */
  302. static CGameServer::NI ni;
  303. ni.pServer = m_pGameSvrServer;
  304. ni.pClient = NULL; //m_pAccSvrClient;
  305. ni.hwndContainer = m_hwndViewer;
  307. m_pGameSvrServer->RegisterMsgFilter( reinterpret_cast< void * >( &ni ), CGameServer::GameSvrEventNotify );
  309. if ( SUCCEEDED( m_pGameSvrServer->OpenService( INADDR_ANY, m_theNetworkConfig.GetGameSvrOpenPort() ) ) )
  310. {
  311. bGameSvrServerSucceed = true;
  312. }
  313. }
  315. if ( m_pPlayerServer )
  316. {
  317. m_pPlayerServer->Startup();
  319. m_pPlayerServer->RegisterMsgFilter( reinterpret_cast< void * >( this ), PlayerEventNotify );
  321. if ( SUCCEEDED( m_pPlayerServer->OpenService( INADDR_ANY, m_theNetworkConfig.GetClientOpenPort() ) ) )
  322. {
  323. bPlayerServerSucceed = true;
  324. }
  325. }
  327. if ( bPlayerServerSucceed && 
  328. bDBRoleServerSucceed && 
  329. bGameSvrServerSucceed )
  330. {
  331. // IClient *pCloneAcc = NULL;
  332. // m_pAccSvrClient->QueryInterface( IID_IESClient, reinterpret_cast< void ** >( &pCloneAcc ) );
  334. IServer *pClonePlayer = NULL;
  335. m_pPlayerServer->QueryInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &pClonePlayer ) );
  337. IClient *pCloneDBRole = NULL;
  338. m_pDBRoleClient->QueryInterface( IID_IESClient, reinterpret_cast< void ** >( &pCloneDBRole ) );
  340. ASSERT( /* pCloneAcc && */ pClonePlayer && pCloneDBRole );
  342. CGamePlayer::ATTACH_NETWORK( NULL/* pCloneAcc */, pClonePlayer, pCloneDBRole );
  344. /*
  345.  * Create new player
  346.  */
  347. {
  348. CCriticalSection::Owner lock( m_csPlayerAction );
  350. /*
  351.  * Initialize all of player
  352.  */
  353. for ( size_t index = 0; index < m_lnMaxPlayerCount; index ++ )
  354. {
  355. /*
  356. * Create a player node and add it into list
  357. */
  358. IPlayer *pPlayer = new CGamePlayer( index );
  360. ASSERT( pPlayer );
  362. m_thePlayers[index] = pPlayer;
  363. }
  364. }
  366. IServer *pCloneGameServer = NULL;
  367. m_pGameSvrServer->QueryInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &pCloneGameServer ) );
  369. CGameServer::Begin( pCloneGameServer );
  371. m_hStartupWoringThreadEvent.Set();
  372. m_hStartupHelperThreadEvent.Set();
  374. }
  376. return ( bPlayerServerSucceed && bDBRoleServerSucceed && bGameSvrServerSucceed );
  377. }
  379. void CIntercessor::CleanNetwork()
  380. {
  381. /*
  382.  * Clear player info
  383.  */
  384. {
  385. CCriticalSection::Owner locker( m_csPlayerAction );
  387. PLAYER_MAP::iterator it;
  389. for ( it = m_thePlayers.begin(); it != m_thePlayers.end(); it ++ )
  390. {
  391. IPlayer *pPlayer = ( IPlayer * )( ( *it ).second );
  393. ASSERT( pPlayer );
  395. SAFE_DELETE( pPlayer );
  396. }
  398. m_thePlayers.erase( m_thePlayers.begin(), m_thePlayers.end() );
  399. }
  401. CGameServer::End();
  402. CGamePlayer::DETACH_NETWORK();
  404. /*
  405.  * Disconnect network and relase this resource
  406.  */
  407. if ( m_pPlayerServer )
  408. {
  409. m_pPlayerServer->CloseService();
  411. m_pPlayerServer->Cleanup();
  413. SAFE_RELEASE( m_pPlayerServer );
  414. }
  416. if ( m_pDBRoleClient )
  417. {
  418. m_pDBRoleClient->Cleanup();
  420. SAFE_RELEASE( m_pDBRoleClient );
  421. }
  423. if ( m_pGameSvrServer )
  424. {
  425. m_pGameSvrServer->CloseService();
  427. m_pGameSvrServer->Cleanup();
  429. SAFE_RELEASE( m_pGameSvrServer );
  430. }
  431. }
  433. DWORD WINAPI CIntercessor::WorkingThreadFunction( void *pV )
  434. {
  435. CIntercessor *pThis = reinterpret_cast< CIntercessor * >( pV );
  437. ASSERT( pThis );
  439. try
  440. {
  441. pThis->Working();
  442. }
  443. catch(...)
  444. {
  445. ::MessageBox( NULL, "Run a working thread is failed!", "CIntercessor class", MB_OK );
  446. }
  448. return 0;
  449. }
  451. int CIntercessor::Working()
  452. {
  453. // ::CoInitialize( NULL );
  455. m_hStartupWoringThreadEvent.Wait();
  457. while ( !m_hQuitEvent.Wait( 0 ) )
  458. {
  459. /*
  460.  * For some alive player
  461.  */
  462. {
  463. CCriticalSection::Owner locker( m_csPlayerAction );
  465. for ( size_t index = 0; index < m_lnMaxPlayerCount; index ++ )
  466. {
  467. IPlayer *pPlayer = m_thePlayers[index];
  469. ASSERT( pPlayer );
  471. if ( pPlayer && pPlayer->IsActive() )
  472. {
  473. /*
  474.  * Get data from player
  475.  */
  476. size_t datalength = 0;
  478. const void *pData = m_pPlayerServer->GetPackFromClient( index, datalength );
  480. if ( pData && datalength )
  481. {
  482. AnalyzePlayerRequire( index, pData, datalength );
  483. }
  485. /*
  486. * Execute work
  487. */
  488. pPlayer->Run();
  489. }
  490. }
  491. }
  493. ::Sleep( 1 );
  494. }
  496. // ::CoUninitialize();
  498. return 0;
  499. }
  501. DWORD WINAPI CIntercessor::HelperThreadFunction( void *pV )
  502. {
  503. CIntercessor *pThis = reinterpret_cast< CIntercessor * >( pV );
  505. ASSERT( pThis );
  507. try
  508. {
  509. pThis->Helper();
  510. }
  511. catch(...)
  512. {
  513. ::MessageBox( NULL, "Startup a helper thread is failed!", "CIntercessor class", MB_OK );
  514. }
  516. return 0;
  517. }
  519. int CIntercessor::Helper()
  520. {
  521. m_hStartupHelperThreadEvent.Wait();
  523. static const DWORD dwTimeLimit = 1000 * 10;
  524. DWORD dwStart = ::GetTickCount();
  525. DWORD dwEnd = dwStart;
  527. while ( !m_hQuitEvent.Wait( 0 ) )
  528. {
  529. /*
  530.  * ping account server
  531.  */
  532. if ( ( ( ( dwEnd = ::GetTickCount() ) - dwStart ) > dwTimeLimit ) ||
  533. ( dwStart > dwEnd ) )
  534. {
  535. dwStart = dwEnd;
  537. PING_COMMAND pc;
  538. pc.ProtocolType = c2s_ping;
  539. pc.m_dwTime = dwStart;
  541. g_theSmartClient.Send( &pc, sizeof( PING_COMMAND ) );
  542. // m_pAccSvrClient->SendPackToServer( &pc, sizeof( PING_COMMAND ) );
  543. }
  545. /*
  546.  * Get data from account-server
  547.  */
  548. size_t dataLength = 0;
  549. const void *pData = g_theSmartClient.Recv( dataLength );
  550. // const void *pData = m_pAccSvrClient->GetPackFromServer( dataLength );
  552. while( pData && dataLength )
  553. {
  554. ASSERT( CPackager::Peek( pData ) > g_nGlobalProtocolType );
  556. if ( s2c_accountlogin == *( const char * )pData )
  557. {
  558. const KAccountHead *pAUR = ( KAccountHead * )( ( ( const char * )pData ) + 1 );
  560. UINT uID = pAUR->Operate;
  562. if ( uID < m_lnMaxPlayerCount )
  563. {
  564. IPlayer *pPlayer = m_thePlayers[uID];
  566. ASSERT( pPlayer );
  568. pPlayer->AppendData( CGamePlayer::enumOwnerAccSvr, pData, dataLength );
  569. }
  570. }
  572. /*
  573.  * ping account server
  574.  */
  575. if ( ( ( ( dwEnd = ::GetTickCount() ) - dwStart ) > dwTimeLimit ) ||
  576. ( dwStart > dwEnd ) )
  577. {
  578. dwStart = dwEnd;
  580. PING_COMMAND pc;
  581. pc.ProtocolType = c2s_ping;
  582. pc.m_dwTime = dwStart;
  584. g_theSmartClient.Send( &pc, sizeof( PING_COMMAND ) );
  585. // m_pAccSvrClient->SendPackToServer( &pc, sizeof( PING_COMMAND ) );
  586. }
  588. pData = g_theSmartClient.Recv( dataLength );
  589. // pData = m_pAccSvrClient->GetPackFromServer( dataLength );
  590. }
  592. /*
  593.  * Get data from role-database
  594.  */
  595. dataLength = 0;
  596. pData = m_pDBRoleClient->GetPackFromServer( dataLength );
  598. while( pData && dataLength )
  599. {
  600. BYTE cProtocol = CPackager::Peek( pData );
  602. UINT uID = ( UINT )( -1 );
  604. if ( cProtocol < g_nGlobalProtocolType )
  605. {
  606. uID = *( const unsigned long * )( ( const char * )pData + 2 );
  607. }
  608. else // cProtocol > g_nGlobalProtocolType
  609. {
  610. TProcessData *pPD = ( TProcessData * )( pData );
  612. uID = pPD->ulIdentity;
  613. }
  615. if ( uID < m_lnMaxPlayerCount )
  616. {
  617. IPlayer *pPlayer = m_thePlayers[uID];
  619. ASSERT( pPlayer );
  621. pPlayer->AppendData( CGamePlayer::enumOwnerRoleSvr, pData, dataLength );
  622. }
  624. /*
  625.  * ping account server
  626.  */
  627. if ( ( ( ( dwEnd = ::GetTickCount() ) - dwStart ) > dwTimeLimit ) ||
  628. ( dwStart > dwEnd ) )
  629. {
  630. dwStart = dwEnd;
  632. PING_COMMAND pc;
  633. pc.ProtocolType = c2s_ping;
  634. pc.m_dwTime = dwStart;
  636. g_theSmartClient.Send( &pc, sizeof( PING_COMMAND ) );
  637. // m_pAccSvrClient->SendPackToServer( &pc, sizeof( PING_COMMAND ) );
  638. }
  640. pData = m_pDBRoleClient->GetPackFromServer( dataLength );
  641. }
  643. ::Sleep( 1 );
  644. }
  646. return 0;
  647. }
  649. bool CIntercessor::AnalyzePlayerRequire( size_t index, const void *pData, size_t datalength )
  650. {
  651. ASSERT( pData && datalength );
  653. BYTE cProtocol = *( const BYTE * )pData;
  655. switch ( cProtocol )
  656. {
  657. case c2s_login:
  658. {
  659. const BYTE *pBuffer = ( const BYTE * )pData + 1;
  661. KLoginAccountInfo *pLAI = ( KLoginAccountInfo * )pBuffer;
  663. ASSERT( pLAI );
  665. IPlayer *pPlayer = m_thePlayers[index];
  667. if ( pLAI && pPlayer )
  668. {
  669. pPlayer->AppendData( CGamePlayer::enumOwnerPlayer, pData, datalength );
  671. pPlayer->DispatchTask( CGamePlayer::enumLogin );
  672. }
  673. }
  675. break;
  677. case c2s_dbplayerselect:
  678. case c2s_newplayer:
  679. case c2s_roleserver_deleteplayer:
  680. {
  681. if ( index < m_lnMaxPlayerCount )
  682. {
  683. IPlayer *pPlayer = m_thePlayers[index];
  685. ASSERT( pPlayer );
  687. pPlayer->AppendData( CGamePlayer::enumOwnerPlayer, pData, datalength );
  688. }
  689. }
  690. break;
  692. default:
  693. break;
  694. }
  696. return true;
  697. }
  699. size_t CIntercessor::GetGameServerCount()
  700. {
  701. if ( m_pGameSvrServer )
  702. {
  703. return m_pGameSvrServer->GetClientCount();
  704. }
  706. return 0;
  707. }
  709. const char *CIntercessor::GetGameServerInfo( const unsigned long &ulnID )
  710. {
  711. if ( m_pGameSvrServer )
  712. {
  713. return m_pGameSvrServer->GetClientInfo( ulnID );
  714. }
  716. return NULL;
  717. }