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

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

模拟服务器

开发平台：

C/C++

GamePlayer.cpp：源码内容
  1. #include "StdAfx.h"
  2. #include "GamePlayer.h"
  4. #include "....s3clientloginLoginDef.h"
  5. #include "....coresrcKProtocol.h"
  7. #include "Macro.h"
  8. #include "define.h"
  9. #include "ICommand.h"
  11. #include "KRoleDBHeader.h"
  12. #include "KRoleBlockProcess.h"
  14. #include "Utils.h"
  15. #include "Macro.h"
  16. #include "Exception.h"
  17. #include "Buffer.h"
  19. using OnlineGameLib::Win32::Output;
  20. using OnlineGameLib::Win32::CException;
  21. using OnlineGameLib::Win32::CCriticalSection;
  22. using OnlineGameLib::Win32::ToString;
  23. using OnlineGameLib::Win32::Trace;
  24. using OnlineGameLib::Win32::_tstring;
  25. using OnlineGameLib::Win32::CBuffer;
  27. static const size_t g_scNetworkBlockSize = 1000;
  28. OnlineGameLib::Win32::CBuffer::Allocator CGamePlayer::m_theGlobalAllocator( 1024, 10 );
  30. LONG CGamePlayer::m_slnIdentityCounts = 0L;
  32. /*
  33.  * CGamePlayer Global Function
  34.  */
  35. bool CGamePlayer::SetupGlobalAllocator( size_t bufferSize, size_t maxFreeBuffers )
  36. {
  37. return CGamePlayer::m_theGlobalAllocator.ReSet( bufferSize, maxFreeBuffers );
  38. }
  40. /*
  41.  * CGamePlayer::CTask
  42.  */
  43. CGamePlayer::CTask::CTask()
  44. {
  45. ASSERT( FALSE );
  46. }
  48. CGamePlayer::CTask::~CTask()
  49. {
  50. CCriticalSection::Owner lock( m_cs );
  52. stdVector::iterator theIterator;
  54. for ( theIterator = m_stdCommand.begin(); theIterator != m_stdCommand.end(); theIterator ++ )
  55. {
  56. ICommand *pCmd = reinterpret_cast< ICommand* >( *theIterator );
  58. SAFE_DELETE( pCmd );
  59. }
  61. m_stdCommand.clear();
  62. }
  64. CGamePlayer::CTask::CTask( CGamePlayer *pReceiver, UINT nTaskID, UINT nNextTaskID /*enumComplete*/ )
  65. : m_pReceiver( pReceiver )
  66. , m_indexCmd( 0 )
  67. , m_nTaskProgID( nTaskID )
  68. , m_nNextTaskID( nNextTaskID )
  69. {
  70. }
  72. size_t CGamePlayer::CTask::AddCmd( Action pFun, UINT unFaildValue /*enumNone*/ )
  73. {
  74. CCriticalSection::Owner lock( m_cs );
  76. /*
  77.  * Convert a status to the other status
  78.  */
  79. UINT unFaildTaskID = unFaildValue;
  81. switch ( unFaildValue )
  82. {
  83. case enumRepeat:
  84. unFaildTaskID = m_nTaskProgID;
  85. break;
  87. default:
  88. unFaildTaskID = unFaildValue;
  89. break;
  90. }
  92. /*
  93.  * Generate a command and push it into the task queue
  94.  */
  95. ICommand *pCmd = new CTaskCommand< CGamePlayer >( m_pReceiver, pFun, unFaildTaskID );
  97. m_stdCommand.push_back( reinterpret_cast< void* >( pCmd ) );
  99. size_t id = m_stdCommand.size();
  101. return id;
  102. }
  104. UINT CGamePlayer::CTask::Execute()
  105. {
  106. CCriticalSection::Owner lock( m_cs );
  108. if ( m_indexCmd < m_stdCommand.size() )
  109. {
  110. ICommand *pCmd = reinterpret_cast< ICommand * >( m_stdCommand[m_indexCmd] );
  112. ASSERT( pCmd );
  114. if ( !pCmd->Execute() )
  115. {
  116. return pCmd->GetFaildValue();
  117. }
  119. m_indexCmd ++;
  120. return m_nTaskProgID;
  121. }
  123. Reset();
  125. return m_nNextTaskID;
  126. }
  128. /*
  129.  * CGamePlayer class
  130.  */
  131. CGamePlayer::CDataQueue::~CDataQueue()
  132. {
  133. CCriticalSection::Owner locker( m_csQueue );
  135. m_theData.erase( m_theData.begin(), m_theData.end() );
  136. }
  138. void CGamePlayer::CDataQueue::Empty()
  139. {
  140. CCriticalSection::Owner locker( m_csQueue );
  142. m_theData.erase( m_theData.begin(), m_theData.end() );
  143. }
  145. size_t CGamePlayer::CDataQueue::Push( LONG lnID, const void *pData )
  146. {
  147. CCriticalSection::Owner locker( m_csQueue );
  149. m_theData.insert( stdMap::value_type( lnID, pData ) );
  150. //m_theData[lnID] = pData;
  152. return m_theData.size();
  153. }
  155. const void *CGamePlayer::CDataQueue::Top( LONG lnID )
  156. {
  157. CCriticalSection::Owner locker( m_csQueue );
  159. stdMap::iterator it;
  161. if ( m_theData.end() != ( it = m_theData.find( lnID ) ) )
  162. {
  163. return m_theData[lnID];
  164. }
  166. return NULL;
  167. }
  169. size_t CGamePlayer::CDataQueue::Pop( LONG lnID )
  170. {
  171. CCriticalSection::Owner locker( m_csQueue );
  173. size_t size = m_theData.size();
  175. stdMap::iterator it;
  177. if ( m_theData.end() != ( it = m_theData.find( lnID ) ) )
  178. {
  179. m_theData.erase( lnID );
  181. size = m_theData.size();
  182. }
  184. return size;
  185. }
  187. /*
  188.  * CGamePlayer class
  189.  */
  190. CGamePlayer::CGamePlayer( IServer *pPlayerSender, IClient *pRoleDBSender, LONG nIdentityID /*-1*/ )
  191. : m_lnIdentityID( nIdentityID )
  192. , m_theLoginTask( this, enumLogin )
  193. , m_theLogoutTask( this, enumLogOut )
  194. , m_theExchangeReginTask( this, enumExchangeRegin )
  195. , m_pRoleDBSender( pRoleDBSender )
  196. , m_pPlayerServer( pPlayerSender )
  197. {
  198. ASSERT( m_pRoleDBSender );
  200. /*
  201.  * Resize block buffer
  202.  */
  203. m_sBlockBuffer.resize( g_scNetworkBlockSize );
  205. SetCurrentTask( enumNone );
  207. LONG lnID = ::InterlockedExchangeAdd( &m_slnIdentityCounts, 1 );
  209. m_lnIdentityID = ( m_lnIdentityID < 0 ) ? lnID : m_lnIdentityID;
  211. InitEventProcessor();
  213. InitTaskProcessor();
  214. }
  216. CGamePlayer::~CGamePlayer()
  217. {
  218. SAFE_RELEASE( m_pRoleDBSender );
  220. ::InterlockedExchangeAdd( &m_slnIdentityCounts, -1 );
  221. }
  223. bool CGamePlayer::DispatchTask( LONG lnTaskID )
  224. {
  225. if ( IsWorking() )
  226. {
  227. /*
  228.  * This player is processing a special tasks
  229.  */
  231. return false;
  232. }
  234. SetCurrentTask( lnTaskID );
  236. return true;
  237. }
  239. void CGamePlayer::InitTaskProcessor()
  240. {
  241. m_theLoginTask.AddCmd( &CGamePlayer::QueryAccPwd );
  242. m_theLoginTask.AddCmd( &CGamePlayer::VerifyAccount );
  243. m_theLoginTask.AddCmd( &CGamePlayer::QueryRoleList );
  244. m_theLoginTask.AddCmd( &CGamePlayer::GetRoleListInfo, enumRepeat );
  245. m_theLoginTask.AddCmd( &CGamePlayer::QueryRoleInfo );
  246. m_theLoginTask.AddCmd( &CGamePlayer::ProcessRoleInfo, enumRepeat );
  247. }
  249. int CGamePlayer::Run()
  250. {
  251. (this->*EventProcessor[enumWorkEvent])();
  253. return 0;
  254. }
  256. bool CGamePlayer::AppendData( const void *pData )
  257. {
  258. TProcessData *pBlock = m_theRoleStreamVein.Block_IN( reinterpret_cast< const KBlock * >( pData ) );
  260. if ( pBlock )
  261. {
  262. switch ( pBlock->nProtoId )
  263. {
  264. case PROTOL_GETROLELIST:
  265. m_theDataQueue.Push( PROTOL_GETROLELIST, reinterpret_cast< const void * >( pBlock->pDataBuffer ) );
  266. break;
  268. case PROTOL_LOADROLE:
  269. m_theDataQueue.Push( PROTOL_LOADROLE, reinterpret_cast< const void * >( pBlock->pDataBuffer ) );
  270. break;
  272. default:
  273. break;
  274. }
  275. }
  277. return true;
  278. }
  280. bool CGamePlayer::Create( const char * const pName, const char * const pPassword )
  281. {
  282. if ( NULL == pName )
  283. {
  284. return false;
  285. }
  287. m_sAccountName = pName;
  288. m_sPassword = pPassword ? pPassword : "";
  290. return true;
  291. }
  293. bool CGamePlayer::Destroy( const char * const pPassword )
  294. {
  295. _tstring sPassword;
  297. sPassword = pPassword ? pPassword : "";
  299. if ( m_sPassword.compare( sPassword ) )
  300. {
  301. return false;
  302. }
  304. return true;
  305. }
  307. void CGamePlayer::InitEventProcessor()
  308. {
  309. ZeroMemory( EventProcessor, sizeof(EventProcessor) );
  311. EventProcessor[enumQuitEvent] = Quit;
  312. EventProcessor[enumWorkEvent] = Work;
  313. }
  315. bool CGamePlayer::Quit()
  316. {
  317. return true;
  318. }
  320. bool CGamePlayer::Work()
  321. {
  322. LONG lnNextTask = enumNone;
  324. switch ( GetCurrentTask() )
  325. {
  326. case enumLogin:
  327. lnNextTask = m_theLoginTask.Execute();
  328. SetCurrentTask( lnNextTask );
  329. break;
  331. case enumLogOut:
  332. lnNextTask = m_theLogoutTask.Execute();
  333. SetCurrentTask( lnNextTask );
  334. break;
  336. case enumExchangeRegin:
  337. lnNextTask = m_theExchangeReginTask.Execute();
  338. SetCurrentTask( lnNextTask );
  339. break;
  341. case enumComplete:
  342. lnNextTask = TaskCompleted() ? enumNone : enumComplete;
  343. SetCurrentTask( lnNextTask );
  344. break;
  346. case enumNone:
  347. default:
  348. break;
  349. }
  351. return true;
  352. }
  354. bool CGamePlayer::TaskCompleted()
  355. {
  356. Trace( ToString( m_lnIdentityID ), "CGamePlayer::TaskCompleted" );
  358. m_theDataQueue.Empty();
  360. /*
  361.  * Clear some role data
  362.  */
  363. m_theRoleStreamVein.ClearINStream( ( size_t )( -1 ) );
  365. return true;
  366. }
  368. /*
  369.  * Task function
  370.  */
  371. bool CGamePlayer::QueryAccPwd()
  372. {
  373. Trace( ToString( m_lnIdentityID ), "CGamePlayer::QueryAccPwd -> Begin" );
  375. Trace( ToString( m_lnIdentityID ), "CGamePlayer::QueryAccPwd -> End" );
  377. return true;
  378. }
  380. bool CGamePlayer::VerifyAccount()
  381. {
  382. Trace( ToString( m_lnIdentityID ), "CGamePlayer::VerifyAccount -> Begin" );
  384. KLoginAccountInfo lai;
  386. ZeroMemory( &lai, sizeof( KLoginAccountInfo ) );
  388. /*
  389.  * Account
  390.  */
  391. size_t used = sizeof( lai.Account );
  392. used = ( used > m_sAccountName.length() ) ? m_sAccountName.length() : used;
  394. memcpy( lai.Account, m_sAccountName.c_str(), used );
  396. /*
  397.  * Password
  398.  */
  399. used = sizeof( lai.Password );
  400. used = ( used > m_sPassword.length() ) ? m_sPassword.length() : used;
  402. memcpy( lai.Password, m_sPassword.c_str(), used );
  404. /*
  405.  * The other info
  406.  */
  407. lai.Param = LOGIN_A_LOGIN | LOGIN_R_SUCCESS; /* LOGIN_R_FAILED | LOGIN_R_ACCOUNT_OR_PASSWORD_ERROR */
  409. lai.Size = sizeof( lai );
  411. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  413. BYTE *pData = const_cast< BYTE * >( pBuffer->GetBuffer() );
  415. BYTE bProtocol = s2c_login;
  416. size_t sizeProtocol = sizeof( BYTE );
  417. memcpy( pData, &bProtocol, sizeProtocol );
  418. memcpy( pData + sizeProtocol, ( BYTE * )( &lai ), sizeof( lai ) );
  420. pBuffer->Use( lai.Size + sizeof( BYTE )/* protocol id */ );
  422. m_pPlayerServer->PreparePackSink();
  424. m_pPlayerServer->PackDataToClient( m_lnIdentityID, pBuffer->GetBuffer(), pBuffer->GetUsed() );
  426. m_pPlayerServer->SendPackToClient();
  428. pBuffer->Release();
  430. Trace( ToString( m_lnIdentityID ), "CGamePlayer::VerifyAccount -> End" );
  432. return true;
  433. }
  435. bool CGamePlayer::QueryRoleList()
  436. {
  437. Trace( ToString( m_lnIdentityID ), "CGamePlayer::QueryRoleList -> Begin" );
  439. const size_t lenAN = m_sAccountName.length();
  440. const size_t lenPL = lenAN + sizeof( TStreamData );
  442. /*
  443.  * Require to get rolelist from the role-db server.
  444.  */
  445. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  447. TStreamData *pPlayerList = reinterpret_cast< TStreamData * >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  449. ASSERT( pPlayerList );
  451. pPlayerList->nProtoId = PROTOL_GETROLELIST;
  452. pPlayerList->nDataLen = lenAN + 1;
  453. pPlayerList->ulNetId = 0;
  454. pPlayerList->ulIdentity = m_lnIdentityID;
  456. pPlayerList->pDataBuffer[0] = enumRoleListCount;
  457. memcpy( &pPlayerList->pDataBuffer[1], m_sAccountName.c_str(), lenAN );
  459. pBuffer->Use( lenPL );
  461. /*
  462.  * Send this information to role database server
  463.  */
  464. KRoleBlockProcess theRoleBlocks( pPlayerList, lenPL );
  466. for ( size_t block = 0; block < theRoleBlocks.GetBlockCount( g_scNetworkBlockSize ); block ++ )
  467. {
  468. KBlock *pBlock = reinterpret_cast< KBlock * >( const_cast< char * >( m_sBlockBuffer.c_str() ) );
  470. size_t sizeBlock = theRoleBlocks.GetBlockPtr( pBlock, block, g_scNetworkBlockSize );
  472. m_pRoleDBSender->SendPackToServer( pBlock, sizeBlock );
  473. }
  475. pBuffer->Release();
  477. Trace( ToString( m_lnIdentityID ), "CGamePlayer::QueryRoleList -> End" );
  479. return true;
  480. }
  482. bool CGamePlayer::GetRoleListInfo()
  483. {
  484. Trace( ToString( m_lnIdentityID ), "CGamePlayer::GetRoleListInfo -> Begin" );
  486. bool ok = false;
  488. const void *pData = NULL;
  490. if ( NULL != ( pData = m_theDataQueue.Top( PROTOL_GETROLELIST ) ) )
  491. {
  492. int nRoleCount = *( char * )pData;
  493. const S3DBI_RoleBaseInfo *pRoleList = ( const S3DBI_RoleBaseInfo * )( ( const char * )pData + 1/* sizeof( char ) */ );
  495. const size_t datalength = sizeof( S3DBI_RoleBaseInfo ) * nRoleCount;
  497. if ( nRoleCount > 0 && nRoleCount <= enumRoleListCount && pRoleList )
  498. {
  499. ZeroMemory ( m_theRoleDBList, sizeof( S3DBI_RoleBaseInfo ) * enumRoleListCount );
  501. for ( int no = 0; no < nRoleCount; no ++ )
  502. {
  503. memcpy( &m_theRoleDBList[no], &pRoleList[no], sizeof( S3DBI_RoleBaseInfo ) );
  505. Trace( ToString( m_lnIdentityID ), m_theRoleDBList[no].szRoleName );
  506. }
  508. /*
  509.  * Send this info to player
  510.  */
  511. KRoleBlockProcess theRoleBlocks( ( const TStreamData * )pData, datalength );
  513. for ( size_t block = 0; block < theRoleBlocks.GetBlockCount( g_scNetworkBlockSize ); block ++ )
  514. {
  515. m_pPlayerServer->PreparePackSink();
  517. KBlock *pBlock = reinterpret_cast< KBlock * >( const_cast< char * >( m_sBlockBuffer.c_str() ) );
  519. size_t sizeBlock = theRoleBlocks.GetBlockPtr( pBlock, block, g_scNetworkBlockSize );
  521. m_pPlayerServer->PackDataToClient( m_lnIdentityID, pBlock, sizeBlock );
  523. m_pPlayerServer->SendPackToClient();
  524. }
  526. ok = true;
  527. }
  529. m_theDataQueue.Pop( PROTOL_GETROLELIST );
  530. }
  532. Trace( ToString( m_lnIdentityID ), "CGamePlayer::GetRoleListInfo -> End" );
  534. return ok;
  535. }
  537. bool CGamePlayer::QueryRoleInfo()
  538. {
  539. Trace( ToString( m_lnIdentityID ), "CGamePlayer::QueryRoleInfo -> Begin" );
  541. enum enumProcessRoleInfo
  542. {
  543. enumCreateRole,
  544. enumQueryRoleInfo,
  545. enumError
  546. };
  548. ZeroMemory( &m_theRoleInfomation, sizeof( tagRoleInfomation ) );
  550. // TEMPORAL
  551. m_theRoleInfomation.nIndexInList = 0;
  553. UINT nProcessor = enumQueryRoleInfo;
  555. switch ( nProcessor )
  556. {
  557. case enumQueryRoleInfo:
  558. {
  559. /*
  560.  * Query player information
  561.  */
  563. // TEMPORAL
  564. _tstring  sRoleName = m_theRoleDBList[ m_theRoleInfomation.nIndexInList ].szRoleName;
  566. const size_t lenRN = sRoleName.length();
  567. const size_t lenRI = sizeof( TStreamData ) - 1 + lenRN;
  569. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  571. TStreamData *pRoleInfo = reinterpret_cast< TStreamData * >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  573. ASSERT( pRoleInfo );
  575. pRoleInfo->nProtoId = PROTOL_LOADROLE;
  576. pRoleInfo->nDataLen = lenRN;
  577. pRoleInfo->ulNetId = 0;
  578. pRoleInfo->ulIdentity = m_lnIdentityID;
  579. memcpy( &pRoleInfo->pDataBuffer[0], sRoleName.c_str(), lenRN );
  581. pBuffer->Use( lenRI );
  583. /*
  584.  * Send this information to role database server
  585.  */
  586. KRoleBlockProcess theRoleInfo( pRoleInfo, lenRI );
  588. for ( size_t block = 0; block < theRoleInfo.GetBlockCount( g_scNetworkBlockSize ); block ++ )
  589. {
  590. KBlock *pBlock = reinterpret_cast< KBlock * >( const_cast< char * >( m_sBlockBuffer.c_str() ) );
  592. size_t sizeBlock = theRoleInfo.GetBlockPtr( pBlock, block, g_scNetworkBlockSize );
  594. m_pRoleDBSender->SendPackToServer( pBlock, sizeBlock );
  595. }
  597. pBuffer->Release();
  599. }
  601. break;
  602. }
  604. Trace( ToString( m_lnIdentityID ), "CGamePlayer::QueryRoleInfo -> End" );
  606. return true;
  607. }
  609. bool CGamePlayer::ProcessRoleInfo()
  610. {
  611. Trace( ToString( m_lnIdentityID ), "CGamePlayer::ProcessRoleInfo -> Begin" );
  613. bool ok = false;
  615. const void *pData = NULL;
  617. if ( NULL != ( pData = m_theDataQueue.Top( PROTOL_LOADROLE ) ) )
  618. {
  619. const TRoleData *pRoleData = ( const TRoleData * )( ( const char * )( pData ) );
  621. if ( pRoleData )
  622. {
  623. memcpy( &m_theRoleInfomation.theRoleData, pRoleData, sizeof( TRoleData ) );
  625. Trace( ToString( m_lnIdentityID ), m_theRoleInfomation.theRoleData.BaseInfo.caccname );
  627. ok = true;
  628. }
  630. m_theDataQueue.Pop( PROTOL_LOADROLE );
  631. }
  633. Trace( ToString( m_lnIdentityID ), "CGamePlayer::ProcessRoleInfo -> End" );
  635. return ok;
  636. }