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

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

模拟服务器

开发平台：

C/C++

PlayerManager.cpp：源码内容
  1. #include "StdAfx.h"
  2. #include <objbase.h>
  3. #include <initguid.h>
  4. #include <process.h> //Thread define
  6. #include "....s3clientloginLoginDef.h"
  7. #include "....coresrcKProtocol.h"
  9. #include "MGateWay.h"
  10. #include "PlayerManager.h"
  11. #include "define.h"
  13. #include "KRoleDBHeader.h"
  14. #include "KRoleBlockProcess.h"
  16. #include "tstring.h"
  17. #include "Utils.h"
  18. #include "Macro.h"
  19. #include "Exception.h"
  21. using OnlineGameLib::Win32::Output;
  22. using OnlineGameLib::Win32::CException;
  23. using OnlineGameLib::Win32::CCriticalSection;
  24. using OnlineGameLib::Win32::_tstring;
  25. using OnlineGameLib::Win32::ToString;
  27. OnlineGameLib::Win32::CLibrary CPlayerManager::m_sHeavenLib( "heaven.dll" );
  28. OnlineGameLib::Win32::CLibrary CPlayerManager::m_sRainbowLib( "rainbow.dll" );
  30. /*
  31.  * Player server
  32.  */
  33. static const int g_snPSMaxPlayerCount = 5000;
  34. static const int g_snPSPrecision = 10;
  35. static const int g_snPSMaxBuffer = 2000;
  36. static const int g_snPSBufferSize = 1024;
  38. /*
  39.  * Database client
  40.  */
  41. static const int g_scnDBRoleMaxFreeBuffers = 50;
  42. static const int g_scnDBRoleBufferSize = 1024 * 32;
  44. static const size_t g_snPlayerExchangeMemory = 48 * 1024;
  45. #define CALC_MAXFREEBUFFER_BY_COUNT( x ) ( ( ( x ) * 2 / 3 + 3 ) & ~3 );
  47. CPlayerManager::CPlayerManager( ENVIRONMENT &theEnviroment )
  48. : m_hHelperThread( NULL )
  49. , m_theEnviroment( theEnviroment )
  50. , m_pDBRoleClient( NULL )
  51. , m_pPlayerServer( NULL )
  52. {
  53. m_hQuitEvent = ::CreateEvent( NULL, TRUE, FALSE, "PMThread_QuitEvent" );
  54. }
  56. CPlayerManager::~CPlayerManager()
  57. {
  58. SAFE_CLOSEHANDLE( m_hQuitEvent );
  59. SAFE_CLOSEHANDLE( m_hHelperThread );
  60. }
  62. bool CPlayerManager::Create()
  63. {
  64. bool ret = false;
  66. /*
  67.  * Startup thread
  68.  */
  69. try
  70. {
  71. Start();
  73. ret = true;
  74. }
  75. catch( const CException &e )
  76. {
  77. /*
  78.  * Call to unqualified virtual function
  79.  */
  80. Output( _T("CGamePlayer::CGamePlayer() - Exception: ") + e.GetWhere() + _T(" - ") + e.GetMessage() );
  81. }
  82. catch(...)
  83. {
  84. /*
  85.  * Call to unqualified virtual function
  86.  */
  87. Output( _T("CGamePlayer::CGamePlayer() - Unexpected exception") );
  88. }
  90. ret &= StartupNetwork();
  92. return ret;
  93. }
  95. void CPlayerManager::Destroy()
  96. {
  97. ::SetEvent( m_hQuitEvent );
  99. CleanNetwork();
  101. try
  102. {
  103. if ( !Wait( THREAD_TERMINATE_TIMEROUT ) )
  104. {
  105. Terminate( -1 );
  106. }
  108. if ( WAIT_TIMEOUT != ::WaitForSingleObject( m_hHelperThread, THREAD_TERMINATE_TIMEROUT ) )
  109. {
  110. ::TerminateThread( m_hHelperThread, -1 );
  111. }
  112. }
  113. catch( const CException &e )
  114. {
  115. /*
  116.  * Call to unqualified virtual function
  117.  */
  118. Output( _T("CPlayerManager::Run() - Exception: ") + e.GetWhere() + _T(" - ") + e.GetMessage() );
  119. }
  120. catch(...)
  121. {
  122. /*
  123.  * Call to unqualified virtual function
  124.  */
  125. Output( _T("CPlayerManager::Run() - Unexpected exception") );
  126. }
  127. }
  129. int CPlayerManager::Run()
  130. {
  131. while ( WAIT_OBJECT_0 != ::WaitForSingleObject( m_hQuitEvent, 0L ) )
  132. {
  134. CCriticalSection::Owner locker( m_csUsedClientList );
  136. LIST::iterator it;
  137. for ( it = m_usedClientNode.begin(); it != m_usedClientNode.end(); it ++ )
  138. {
  139. size_t index = *it;
  141. /*
  142.  * Get data from player
  143.  */
  144. size_t datalength = 0;
  146. const void *pData = m_pPlayerServer->GetPackFromClient( index, datalength );
  148. while ( pData && datalength )
  149. {
  150. AnalyzePlayerRequire( index, pData, datalength );
  152. pData = m_pPlayerServer->GetPackFromClient( index, datalength );
  153. }
  155. /*
  156.  * Execute work
  157.  */
  158. IPlayer *pPlayer = m_thePlayers[index];
  160. ASSERT( pPlayer );
  162. pPlayer->Run();
  163. }
  165. Sleep( 1 );
  166. }
  168. return 0;
  169. }
  171. void __stdcall CPlayerManager::DBRoleEventNotify( LPVOID lpParam, 
  172. const unsigned long &ulnEventType )
  173. {
  174. CPlayerManager *pPM = reinterpret_cast< CPlayerManager * >( lpParam );
  176. switch( ulnEventType )
  177. {
  178. case enumServerConnectCreate:
  179. SetShowInfo( "RoleDB Connection", "OK", SIF_COLON );
  181. break;
  182. case enumServerConnectClose:
  183. SetShowInfo( "RoleDB Connection", "" );
  185. break;
  186. }
  187. }
  189. void __stdcall CPlayerManager::AccountEventNotify( LPVOID lpParam, 
  190. const unsigned long &ulnEventType )
  191. {
  192. CPlayerManager *pPM = reinterpret_cast< CPlayerManager * >( lpParam );
  194. switch( ulnEventType )
  195. {
  196. case enumServerConnectCreate:
  198. break;
  199. case enumServerConnectClose:
  201. break;
  202. }
  203. }
  205. void __stdcall CPlayerManager::PlayerEventNotify( LPVOID lpParam,
  206. const unsigned long &ulnID,
  207. const unsigned long &ulnEventType )
  208. {
  209. CPlayerManager *pPM = ( CPlayerManager * )( lpParam );
  211. ASSERT( pPM );
  213. pPM->_PlayerEventNotify( ulnID, ulnEventType );
  214. }
  216. void __stdcall CPlayerManager::GameSvrEventNotify( LPVOID lpParam,
  217. const unsigned long &ulnID,
  218. const unsigned long &ulnEventType )
  219. {
  220. switch( ulnEventType )
  221. {
  222. case enumClientConnectCreate:
  225. break;
  226. case enumClientConnectClose:
  228. break;
  229. }
  230. }
  232. void CPlayerManager::_PlayerEventNotify( const unsigned long &ulnID,
  233. const unsigned long &ulnEventType )
  234. {
  235. CCriticalSection::Owner locker( m_csUsedClientList );
  237. switch( ulnEventType )
  238. {
  239. case enumClientConnectCreate:
  241. m_usedClientNode.push_back( ulnID );
  243. break;
  245. case enumClientConnectClose:
  247. PLAYER_MAP::iterator it;
  249. if ( m_thePlayers.end() != ( it = m_thePlayers.find( ulnID ) ) )
  250. {
  251. IPlayer *pPlayer = m_thePlayers[ulnID];
  253. ASSERT( pPlayer );
  255. pPlayer->Destroy( NULL );
  256. }
  258. m_usedClientNode.remove( ulnID );
  260. break;
  261. }
  262. }
  264. bool CPlayerManager::StartupNetwork()
  265. {
  266. bool bDBRoleOK = false;
  267. bool bPlayerServerOK = false;
  269. /*
  270.  * There is connectted the heaven by the rainbow
  271.  */
  272. pfnCreateClientInterface pClientFactroyFun = ( pfnCreateClientInterface )( m_sRainbowLib.GetProcAddress( _T( "CreateInterface" ) ) );
  274. IClientFactory *pClientFactory = NULL;
  276. if ( pClientFactroyFun && SUCCEEDED( pClientFactroyFun( IID_IClientFactory, reinterpret_cast< void ** >( &pClientFactory ) ) ) )
  277. {
  278. pClientFactory->SetEnvironment( g_scnDBRoleMaxFreeBuffers, g_scnDBRoleBufferSize );
  280. pClientFactory->CreateClientInterface( IID_IESClient, reinterpret_cast< void ** >( &m_pDBRoleClient ) );
  282. SAFE_RELEASE( pClientFactory );
  283. }
  285. if ( m_pDBRoleClient )
  286. {
  287. m_pDBRoleClient->Startup();
  289. m_pDBRoleClient->RegisterMsgFilter( reinterpret_cast< void * >( this ), DBRoleEventNotify );
  291. if ( SUCCEEDED( m_pDBRoleClient->ConnectTo( m_theEnviroment.sRoleDBServerIP.c_str(), m_theEnviroment.usRoleDBSvrPort ) ) )
  292. {
  293. bDBRoleOK = true;
  294. }
  295. }
  297. /*
  298.  * We open the heaven to wait for the rainbow
  299.  */
  301. pfnCreateServerInterface pServerFactroyFun = ( pfnCreateServerInterface )( m_sHeavenLib.GetProcAddress( _T( "CreateInterface" ) ) );
  303. IServerFactory *pServerFactory = NULL;
  305. if ( pServerFactroyFun && SUCCEEDED( pServerFactroyFun( IID_IServerFactory, reinterpret_cast< void ** >( &pServerFactory ) ) ) )
  306. {
  307. pServerFactory->SetEnvironment( g_snPSMaxPlayerCount, g_snPSPrecision, g_snPSMaxBuffer, g_snPSBufferSize  );
  309. pServerFactory->CreateServerInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &m_pPlayerServer ) );
  311. pServerFactory->Release();
  312. }
  314. if ( m_pPlayerServer )
  315. {
  316. m_pPlayerServer->Startup();
  318. m_pPlayerServer->RegisterMsgFilter( reinterpret_cast< void * >( this ), PlayerEventNotify );
  320. if ( SUCCEEDED( m_pPlayerServer->OpenService( INADDR_ANY, m_theEnviroment.usClientOpenPort ) ) )
  321. {
  322. bPlayerServerOK = true;
  323. }
  324. }
  326. _tstring msg;
  328. if ( !bDBRoleOK )
  329. {
  330. msg += _T( "It's failed to connect the RoleDB servern" );
  331. }
  333. if ( !bPlayerServerOK )
  334. {
  335. msg += _T( "It's failed to create server for playern" );
  336. }
  338. if ( !msg.empty() )
  339. {
  340. ::MessageBox( NULL, msg.c_str(), "StartupNetwork", MB_ICONSTOP );
  341. }
  343. if ( bDBRoleOK && bPlayerServerOK )
  344. {
  345. CCriticalSection::Owner lock( m_csSystemAction );
  347. /*
  348.  * Setup the Global Allocator
  349.  */
  350. const size_t buffersize = g_snPlayerExchangeMemory;
  351. const size_t maxfreebuffer = CALC_MAXFREEBUFFER_BY_COUNT( m_theEnviroment.lnPlayerMaxCount );
  352. CGamePlayer::SetupGlobalAllocator( buffersize, maxfreebuffer );
  354. /*
  355.  * Initialize all of player
  356.  */
  357. for ( size_t index = 0; index < m_theEnviroment.lnPlayerMaxCount; index ++ )
  358. {
  359. m_freeClientNode.push( index );
  361. IClient *pRoleDBClone = NULL;
  362. m_pDBRoleClient->QueryInterface( IID_IESClient, reinterpret_cast< void ** >( &pRoleDBClone ) );
  364. IServer *pPlayerSvrClone = NULL;
  365. m_pPlayerServer->QueryInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &pPlayerSvrClone ) );
  366. /*
  367.  * Create a player node and add it into list
  368.  */
  369. IPlayer *pPlayer = new CGamePlayer( pPlayerSvrClone, pRoleDBClone, index );
  371. m_thePlayers[index] = pPlayer;
  372. }
  374. /*
  375.  * Initialize a helper thread for network
  376.  */
  377. if ( NULL == m_hHelperThread )
  378. {
  379. unsigned int threadID = 0;
  381. m_hHelperThread = (HANDLE)::_beginthreadex(0,
  382. 0, 
  383. HelperThreadFunction,
  384. ( void * )this,
  385. 0, 
  386. &threadID );
  388. if ( m_hHelperThread == INVALID_HANDLE_VALUE )
  389. {
  390. return false;
  391. }
  392. }
  393. }
  395. return ( bDBRoleOK & bPlayerServerOK );
  396. }
  398. void CPlayerManager::CleanNetwork()
  399. {
  400. if ( m_pDBRoleClient )
  401. {
  402. m_pDBRoleClient->Shutdown();
  404. m_pDBRoleClient->Cleanup();
  406. SAFE_RELEASE( m_pDBRoleClient );
  407. }
  409. if ( m_pPlayerServer )
  410. {
  411. /* CCriticalSection::Owner locker( m_csUsedClientList );
  413. LIST::iterator it;
  414. for ( it = m_usedClientNode.begin(); it != m_usedClientNode.end(); it ++ )
  415. {
  416. size_t index = *it;
  418. m_pPlayerServer->ShutdownClient( index );
  419. }
  420. */
  421. m_pPlayerServer->CloseService();
  423. m_pPlayerServer->Cleanup();
  425. SAFE_RELEASE( m_pPlayerServer );
  426. }
  428. CCriticalSection::Owner lock( m_csSystemAction );
  430. /*
  431.      * Repeat until stack is empty
  432.  */
  433. while ( !m_freeClientNode.empty() )
  434. {
  435. m_freeClientNode.pop();
  436. }
  438. CCriticalSection::Owner locker( m_csUsedClientList );
  440. m_usedClientNode.erase( m_usedClientNode.begin(), m_usedClientNode.end() );
  442. PLAYER_MAP::iterator it;
  443. for ( it = m_thePlayers.begin(); it != m_thePlayers.end(); it ++ )
  444. {
  445. IPlayer *pPlayer = ( IPlayer * )( ( *it ).second );
  447. ASSERT( pPlayer );
  449. pPlayer->Destroy( NULL );
  451. SAFE_DELETE( pPlayer );
  452. }
  454. m_thePlayers.erase( m_thePlayers.begin(), m_thePlayers.end() );
  455. }
  457. unsigned int __stdcall CPlayerManager::HelperThreadFunction( void *pV )
  458. {
  459. int result = 0;
  461. CPlayerManager* pThis = ( CPlayerManager * )pV;
  462.    
  463. if ( pThis )
  464. {
  465. try
  466. {
  467. result = pThis->Helper();
  468. }
  469. catch( ... )
  470. {
  471. }
  472. }
  474. return result;
  475. }
  477. int CPlayerManager::Helper()
  478. {
  479. while ( WAIT_OBJECT_0 != ::WaitForSingleObject( m_hQuitEvent, 0L ) )
  480. {
  481. /*
  482.  * Get data from role-database
  483.  */
  484. size_t dataLength = 0;
  485. const void *pData = m_pDBRoleClient->GetPackFromServer( dataLength );
  487. while( pData && dataLength )
  488. {
  489. KBlock *pBlock = ( KBlock * )( pData );
  491. UINT uID = pBlock->ulIdentity;
  493. if ( uID < m_theEnviroment.lnPlayerMaxCount )
  494. {
  495. IPlayer *pPlayer = m_thePlayers[uID];
  497. ASSERT( pPlayer );
  499. pPlayer->AppendData( pData );
  500. }
  502. pData = m_pDBRoleClient->GetPackFromServer( dataLength );
  503. }
  505. Sleep( 1 );
  506. }
  508. return 0;
  509. }
  511. bool CPlayerManager::AnalyzePlayerRequire( size_t index, const void *pData, size_t datalength )
  512. {
  513. ASSERT( pData && datalength );
  515. BYTE cProtocol = *( const BYTE * )pData;
  517. const BYTE *pBuffer = ( const BYTE * )pData + 1;
  519. ASSERT( pBuffer );
  521. switch ( cProtocol )
  522. {
  523. case c2s_login:
  524. {
  525. KLoginAccountInfo *pLAI = ( KLoginAccountInfo * )pBuffer;
  527. m_thePlayers[index]->Create( pLAI->Account, pLAI->Password );
  528. m_thePlayers[index]->DispatchTask( CGamePlayer::enumLogin );
  529. }
  531. break;
  533. default:
  534. break;
  535. }
  537. return true;
  538. }