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

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

模拟服务器

开发平台：

C/C++

PlayerManager.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "PlayerManager.h"
  4. #include "....Sword3PaySysS3AccServerAccountLoginDef.h"
  5. #include "....s3clientloginLoginDef.h"
  7. #include "....RoleDBManagerkroledbheader.h"
  9. #include "KProtocolDef.h"
  10. #include "....coreSrcKProtocol.h"
  12. #include "Macro.h"
  13. #include "Buffer.h"
  15. using OnlineGameLib::Win32::CEvent;
  16. using OnlineGameLib::Win32::CCriticalSection;
  17. using OnlineGameLib::Win32::CPackager;
  19. OnlineGameLib::Win32::CLibrary CPlayerManager::m_theHeavenLib( "heaven.dll" );
  20. OnlineGameLib::Win32::CLibrary CPlayerManager::m_theRainbowLib( "rainbow.dll" );
  22. CPlayerManager::CPlayerManager( unsigned long lnMaxPlayerCount, CNetwork &theNetworkConfig )
  23. : m_pAccSvrClient( NULL )
  24. , m_pDBRoleClient( NULL )
  25. , m_pGameSvrServer( NULL )
  26. , m_pPlayerServer( NULL )
  27. , m_hWorkingThread( INVALID_HANDLE_VALUE )
  28. , m_hHelperThread( INVALID_HANDLE_VALUE )
  29. , m_hQuitEvent( NULL, true, false, "PM_Quit_Event" )
  30. , m_hStartupWoringThreadEvent( NULL, false, false, "PM_WORKING_EVENT" )
  31. , m_hStartupHelperThreadEvent( NULL, false, false, "PM_HELPER_EVENT" )
  32. , m_theNetworkConfig( theNetworkConfig )
  33. , m_lnMaxPlayerCount( lnMaxPlayerCount )
  34. {
  36. }
  38. CPlayerManager::~CPlayerManager()
  39. {
  41. }
  43. bool CPlayerManager::Create()
  44. {
  45. /*
  46.  * Start a working thread
  47.  */
  48. DWORD dwThreadID = 0;
  50. m_hWorkingThread = ::CreateThread( NULL, 
  51. 0, 
  52. WorkingThreadFunction, 
  53. ( void * )this, 
  54. 0, 
  55. &dwThreadID );
  57. if ( m_hWorkingThread == INVALID_HANDLE_VALUE )
  58. {
  59. return false;
  60. }
  62. /*
  63.  * Startup a helper thread
  64.  */
  65. dwThreadID = 0;
  67. m_hHelperThread = ::CreateThread( NULL, 
  68. 0, 
  69. HelperThreadFunction, 
  70. ( void * )this,
  71. 0, 
  72. &dwThreadID );
  74. if ( m_hHelperThread == INVALID_HANDLE_VALUE )
  75. {
  76. return false;
  77. }
  79. m_pAccSvrClient = m_theNetworkConfig.CreateAccSvrClient( m_theNetworkConfig.GetAccSvrIP(), m_theNetworkConfig.GetAccSvrPort() );
  81. ASSERT( m_pAccSvrClient );
  83. m_pAccSvrClient->RegisterMsgFilter( ( void * )this, AccountEventNotify );
  85. return StartupNetwork();
  86. }
  88. void CPlayerManager::Destroy()
  89. {
  90. m_hStartupWoringThreadEvent.Set();
  91. m_hStartupHelperThreadEvent.Set();
  93. m_hQuitEvent.Set();
  95. SAFE_CLOSEHANDLE( m_hWorkingThread );
  96. SAFE_CLOSEHANDLE( m_hHelperThread );
  98. SAFE_RELEASE( m_pAccSvrClient );
  100. CleanNetwork();
  101. }
  103. void __stdcall CPlayerManager::AccountEventNotify( LPVOID lpParam, 
  104. const unsigned long &ulnEventType )
  105. {
  107. }
  109. void __stdcall CPlayerManager::DBRoleEventNotify( LPVOID lpParam, 
  110. const unsigned long &ulnEventType )
  111. {
  113. }
  115. void __stdcall CPlayerManager::PlayerEventNotify( LPVOID lpParam,
  116. const unsigned long &ulnID,
  117. const unsigned long &ulnEventType )
  118. {
  119. CPlayerManager *pPlayerManager = reinterpret_cast< CPlayerManager * >( lpParam );
  121. ASSERT( pPlayerManager );
  123. try
  124. {
  125. pPlayerManager->_PlayerEventNotify( ulnID, ulnEventType );
  126. }
  127. catch(...)
  128. {}
  129. }
  131. void CPlayerManager::_PlayerEventNotify( const unsigned long &ulnID,
  132. const unsigned long &ulnEventType )
  133. {
  134. CCriticalSection::Owner locker( m_csUsedClientList );
  136. switch ( ulnEventType )
  137. {
  138. case enumClientConnectCreate:
  140. m_usedClientNode.push_back( ulnID );
  142. break;
  144. case enumClientConnectClose:
  146. PLAYER_MAP::iterator it;
  148. if ( m_thePlayers.end() != ( it = m_thePlayers.find( ulnID ) ) )
  149. {
  150. IPlayer *pPlayer = m_thePlayers[ulnID];
  152. ASSERT( pPlayer );
  154. pPlayer->Destroy( NULL );
  155. }
  157. m_usedClientNode.remove( ulnID );
  159. break;
  160. }
  161. }
  163. void __stdcall CPlayerManager::GameSvrEventNotify( LPVOID lpParam,
  164. const unsigned long &ulnID,
  165. const unsigned long &ulnEventType )
  166. {
  167. CPlayerManager *pPlayerManager = reinterpret_cast< CPlayerManager * >( lpParam );
  169. ASSERT( pPlayerManager );
  171. try
  172. {
  173. pPlayerManager->_GameServerEventNotify( ulnID, ulnEventType );
  174. }
  175. catch(...)
  176. {}
  177. }
  179. void CPlayerManager::_GameServerEventNotify( const unsigned long &ulnID,
  180. const unsigned long &ulnEventType )
  181. {
  182. CCriticalSection::Owner locker( m_csGameSvrAction );
  184. switch ( ulnEventType )
  185. {
  186. case enumClientConnectCreate:
  188. break;
  190. case enumClientConnectClose:
  192. break;
  193. }
  194. }
  196. bool CPlayerManager::StartupNetwork()
  197. {
  198. bool bPlayerServerSucceed = false;
  199. bool bDBRoleServerSucceed = false;
  200. bool bGameSvrServerSucceed = false;
  202. /*
  203.  * There is connectted the heaven by the rainbow
  204.  */
  206. /*
  207.  * For the db-role server
  208.  */
  209. pfnCreateClientInterface pClientFactroyFun = ( pfnCreateClientInterface )( m_theRainbowLib.GetProcAddress( _T( "CreateInterface" ) ) );
  211. IClientFactory *pClientFactory = NULL;
  213. if ( pClientFactroyFun && SUCCEEDED( pClientFactroyFun( IID_IClientFactory, reinterpret_cast< void ** >( &pClientFactory ) ) ) )
  214. {
  215. pClientFactory->SetEnvironment( 10, 1024 * 64 );
  217. pClientFactory->CreateClientInterface( IID_IESClient, reinterpret_cast< void ** >( &m_pDBRoleClient ) );
  219. SAFE_RELEASE( pClientFactory );
  220. }
  222. if ( m_pDBRoleClient )
  223. {
  224. m_pDBRoleClient->Startup();
  226. m_pDBRoleClient->RegisterMsgFilter( reinterpret_cast< void * >( this ), DBRoleEventNotify );
  228. if ( SUCCEEDED( m_pDBRoleClient->ConnectTo( m_theNetworkConfig.GetRoleSvrIP(), m_theNetworkConfig.GetRoleSvrPort() ) ) )
  229. {
  230. bDBRoleServerSucceed = true;
  231. }
  232. }
  234. /*
  235.  * We open the heaven to wait for the rainbow
  236.  */
  237. pfnCreateServerInterface pServerFactroyFun = 
  238. ( pfnCreateServerInterface )( m_theHeavenLib.GetProcAddress( _T( "CreateInterface" ) ) );
  240. IServerFactory *pServerFactory = NULL;
  242. if ( pServerFactroyFun && 
  243. SUCCEEDED( pServerFactroyFun( IID_IServerFactory, reinterpret_cast< void ** >( &pServerFactory ) ) ) )
  244. {
  245. pServerFactory->SetEnvironment( m_lnMaxPlayerCount, 10, 1000, 1024 * 8 );
  247. /*
  248.  * For player
  249.  */
  250. pServerFactory->CreateServerInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &m_pPlayerServer ) );
  252. /*
  253.  * For gameserver
  254.  */
  255. pServerFactory->CreateServerInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &m_pGameSvrServer ) );
  257. pServerFactory->Release();
  258. }
  260. if ( m_pGameSvrServer )
  261. {
  262. m_pGameSvrServer->Startup();
  264. m_pGameSvrServer->RegisterMsgFilter( reinterpret_cast< void * >( this ), GameSvrEventNotify );
  266. if ( SUCCEEDED( m_pGameSvrServer->OpenService( INADDR_ANY, m_theNetworkConfig.GetGameSvrOpenPort() ) ) )
  267. {
  268. bGameSvrServerSucceed = true;
  269. }
  270. }
  272. if ( m_pPlayerServer )
  273. {
  274. m_pPlayerServer->Startup();
  276. m_pPlayerServer->RegisterMsgFilter( reinterpret_cast< void * >( this ), PlayerEventNotify );
  278. if ( SUCCEEDED( m_pPlayerServer->OpenService( INADDR_ANY, m_theNetworkConfig.GetClientOpenPort() ) ) )
  279. {
  280. bPlayerServerSucceed = true;
  281. }
  282. }
  284. if ( bPlayerServerSucceed && 
  285. bDBRoleServerSucceed && 
  286. bGameSvrServerSucceed )
  287. {
  288. CCriticalSection::Owner lock( m_csPlayerAction );
  290. /*
  291.  * Initialize all of player
  292.  */
  293. for ( size_t index = 0; index < m_lnMaxPlayerCount; index ++ )
  294. {
  295. IClient *pCloneAcc = NULL;
  296. m_pAccSvrClient->QueryInterface( IID_IESClient, reinterpret_cast< void ** >( &pCloneAcc ) );
  298. IServer *pClonePlayer = NULL;
  299. m_pPlayerServer->QueryInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &pClonePlayer ) );
  301. IClient *pCloneDBRole = NULL;
  302. m_pDBRoleClient->QueryInterface( IID_IESClient, reinterpret_cast< void ** >( &pCloneDBRole ) );
  304. ASSERT( pCloneAcc && pClonePlayer );
  306. /*
  307.  * Create a player node and add it into list
  308.  */
  309. IPlayer *pPlayer = new CGamePlayer( pCloneAcc, pClonePlayer, pCloneDBRole, index );
  311. ASSERT( pPlayer );
  313. m_thePlayers[index] = pPlayer;
  314. }
  316. m_hStartupWoringThreadEvent.Set();
  317. m_hStartupHelperThreadEvent.Set();
  319. }
  321. return ( bPlayerServerSucceed && bDBRoleServerSucceed && bGameSvrServerSucceed );
  322. }
  324. void CPlayerManager::CleanNetwork()
  325. {
  326. /*
  327.  * Disconnect network and relase this resource
  328.  */
  329. if ( m_pPlayerServer )
  330. {
  331. m_pPlayerServer->CloseService();
  333. m_pPlayerServer->Cleanup();
  335. SAFE_RELEASE( m_pPlayerServer );
  336. }
  338. if ( m_pDBRoleClient )
  339. {
  340. m_pDBRoleClient->Cleanup();
  342. SAFE_RELEASE( m_pDBRoleClient );
  343. }
  345. if ( m_pGameSvrServer )
  346. {
  347. m_pGameSvrServer->CloseService();
  349. m_pGameSvrServer->Cleanup();
  351. SAFE_RELEASE( m_pGameSvrServer );
  352. }
  354. /*
  355.  * Clear client node
  356.  */
  357. {
  358. CCriticalSection::Owner locker( m_csUsedClientList );
  360. m_usedClientNode.erase( m_usedClientNode.begin(), m_usedClientNode.end() );
  361. }
  363. /*
  364.  * Clear player info
  365.  */
  366. {
  367. CCriticalSection::Owner locker( m_csPlayerAction );
  369. PLAYER_MAP::iterator it;
  371. for ( it = m_thePlayers.begin(); it != m_thePlayers.end(); it ++ )
  372. {
  373. IPlayer *pPlayer = ( IPlayer * )( ( *it ).second );
  375. ASSERT( pPlayer );
  377. pPlayer->Destroy( NULL );
  379. SAFE_DELETE( pPlayer );
  380. }
  382. m_thePlayers.erase( m_thePlayers.begin(), m_thePlayers.end() );
  383. }
  385. /*
  386.  * MAPID_MAPTO_GAMESVR
  387.  */
  388. {
  389. CCriticalSection::Owner locker( m_csMI2GSAction );
  391. m_theMapIDMapToGameSvr.erase( m_theMapIDMapToGameSvr.begin(), 
  392. m_theMapIDMapToGameSvr.end() );
  393. }
  395. /*
  396.  * PLAYERID_MAPTO_GAMESVR
  397.  */
  398. {
  399. CCriticalSection::Owner locker( m_csPI2GSAction );
  401. m_thePlayerIDMapToGameSvr.erase( m_thePlayerIDMapToGameSvr.begin(), 
  402. m_thePlayerIDMapToGameSvr.end() );
  403. }
  404. }
  406. DWORD WINAPI CPlayerManager::WorkingThreadFunction( void *pV )
  407. {
  408. CPlayerManager *pThis = reinterpret_cast< CPlayerManager * >( pV );
  410. ASSERT( pThis );
  412. try
  413. {
  414. pThis->Working();
  415. }
  416. catch(...)
  417. {
  418. ::MessageBox( NULL, "Startup a working thread is failed!", "CPlayerManager class", MB_OK );
  419. }
  421. return 0;
  422. }
  424. int CPlayerManager::Working()
  425. {
  426. m_hStartupWoringThreadEvent.Wait();
  428. while ( !m_hQuitEvent.Wait( 0 ) )
  429. {
  430. CCriticalSection::Owner locker( m_csUsedClientList );
  432. LIST::iterator it;
  433. for ( it = m_usedClientNode.begin(); it != m_usedClientNode.end(); it ++ )
  434. {
  435. size_t index = *it;
  437. /*
  438.  * Get data from player
  439.  */
  440. size_t datalength = 0;
  442. const void *pData = m_pPlayerServer->GetPackFromClient( index, datalength );
  444. while ( pData && datalength )
  445. {
  446. AnalyzePlayerRequire( index, pData, datalength );
  448. pData = m_pPlayerServer->GetPackFromClient( index, datalength );
  449. }
  451. /*
  452.  * Execute work
  453.  */
  454. IPlayer *pPlayer = m_thePlayers[index];
  456. ASSERT( pPlayer );
  458. pPlayer->Run();
  459. }
  461. ::Sleep( 1 );
  462. }
  464. return 0;
  465. }
  467. DWORD WINAPI CPlayerManager::HelperThreadFunction( void *pV )
  468. {
  469. CPlayerManager *pThis = reinterpret_cast< CPlayerManager * >( pV );
  471. ASSERT( pThis );
  473. try
  474. {
  475. pThis->Helper();
  476. }
  477. catch(...)
  478. {
  479. ::MessageBox( NULL, "Startup a helper thread is failed!", "CPlayerManager class", MB_OK );
  480. }
  482. return 0;
  483. }
  485. int CPlayerManager::Helper()
  486. {
  487. m_hStartupHelperThreadEvent.Wait();
  489. while ( !m_hQuitEvent.Wait( 0 ) )
  490. {
  491. /*
  492.  * Get data from role-database
  493.  */
  494. size_t dataLength = 0;
  495. const void *pData = m_pAccSvrClient->GetPackFromServer( dataLength );
  497. while( pData && dataLength )
  498. {
  499. ASSERT( CPackager::Peek( pData ) > s2c_micropackbegin );
  501. KAccountHead *pAUR = ( KAccountHead * )( ( ( char * )pData ) + 1 );
  503. UINT uID = pAUR->Operate;
  505. if ( uID < m_lnMaxPlayerCount )
  506. {
  507. IPlayer *pPlayer = m_thePlayers[uID];
  509. ASSERT( pPlayer );
  511. pPlayer->AppendData( CGamePlayer::enumOwnerAccSvr, pData, dataLength );
  512. }
  514. pData = m_pAccSvrClient->GetPackFromServer( dataLength );
  515. }
  517. /*
  518.  * Get data from role-database
  519.  */
  520. dataLength = 0;
  521. pData = m_pDBRoleClient->GetPackFromServer( dataLength );
  523. while( pData && dataLength )
  524. {
  525. BYTE cProtocol = CPackager::Peek( pData );
  527. UINT uID = ( UINT )( -1 );
  529. if ( cProtocol < s2c_micropackbegin )
  530. {
  531. uID = *( const unsigned long * )( ( const char * )pData + 2 );
  532. }
  533. else // cProtocol > s2c_micropackbegin
  534. {
  535. TProcessData *pPD = ( TProcessData * )( pData );
  537. uID = pPD->ulIdentity;
  538. }
  540. if ( uID < m_lnMaxPlayerCount )
  541. {
  542. IPlayer *pPlayer = m_thePlayers[uID];
  544. ASSERT( pPlayer );
  546. pPlayer->AppendData( CGamePlayer::enumOwnerRoleSvr, pData, dataLength );
  547. }
  549. pData = m_pDBRoleClient->GetPackFromServer( dataLength );
  550. }
  552. ::Sleep( 1 );
  553. }
  555. return 0;
  556. }
  558. bool CPlayerManager::AnalyzePlayerRequire( size_t index, const void *pData, size_t datalength )
  559. {
  560. ASSERT( pData && datalength );
  562. BYTE cProtocol = *( const BYTE * )pData;
  564. switch ( cProtocol )
  565. {
  566. case c2s_login:
  567. {
  568. const BYTE *pBuffer = ( const BYTE * )pData + 1;
  570. KLoginAccountInfo *pLAI = ( KLoginAccountInfo * )pBuffer;
  572. ASSERT( pLAI );
  574. if ( m_thePlayers[index]->Create( pLAI->Account, pLAI->Password ) )
  575. {
  576. m_thePlayers[index]->DispatchTask( CGamePlayer::enumLogin );
  577. }
  578. }
  580. break;
  582. case c2s_dbplayerselect:
  583. {
  584. if ( index < m_lnMaxPlayerCount )
  585. {
  586. IPlayer *pPlayer = m_thePlayers[index];
  588. ASSERT( pPlayer );
  590. pPlayer->AppendData( CGamePlayer::enumOwnerPlayer, pData, datalength );
  591. }
  592. }
  593. break;
  595. default:
  596. break;
  597. }
  599. return true;
  600. }