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

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

模拟服务器

开发平台：

C/C++

GamePlayer.cpp：源码内容
  1. #include "Stdafx.h"
  2. #include "GamePlayer.h"
  4. #include "....Sword3PaySysS3AccServerAccountLoginDef.h"
  5. #include "....s3clientloginLoginDef.h"
  7. #include "....RoleDBManagerkroledbheader.h"
  8. #include "S3DBInterface.h"
  9. #include "KProtocolDef.h"
  10. #include "....coreSrcKProtocol.h"
  12. #include "Utils.h"
  13. #include "Macro.h"
  14. #include "Exception.h"
  15. #include "Buffer.h"
  17. using OnlineGameLib::Win32::Output;
  18. using OnlineGameLib::Win32::CException;
  19. using OnlineGameLib::Win32::CCriticalSection;
  20. using OnlineGameLib::Win32::ToString;
  21. using OnlineGameLib::Win32::Trace;
  22. using OnlineGameLib::Win32::_tstring;
  23. using OnlineGameLib::Win32::CBuffer;
  24. using OnlineGameLib::Win32::CPackager;
  26. OnlineGameLib::Win32::CBuffer::Allocator CGamePlayer::m_theGlobalAllocator( 1024 * 64, 20 );
  28. LONG CGamePlayer::m_slnIdentityCounts = 0L;
  29. const int CGamePlayer::s_nRoleListCount = 3;
  31. /*
  32.  * CGamePlayer Global Function
  33.  */
  34. bool CGamePlayer::SetupGlobalAllocator( size_t bufferSize, size_t maxFreeBuffers )
  35. {
  36. return CGamePlayer::m_theGlobalAllocator.ReSet( bufferSize, maxFreeBuffers );
  37. }
  40. /*
  41.  * CGamePlayer::CTask
  42.  */
  43. CGamePlayer::CTask::CTask()
  44. {
  45. ASSERT( FALSE );
  46. }
  48. CGamePlayer::CTask::~CTask()
  49. {
  50. CCriticalSection::Owner lock( m_csTask );
  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 )
  65. : m_pReceiver( pReceiver )
  66. , m_indexCmd( 0 )
  67. , m_nTaskProgID( nTaskID )
  68. {
  69. }
  71. size_t CGamePlayer::CTask::AddCmd( Action pFun )
  72. {
  73. CCriticalSection::Owner lock( m_csTask );
  75. /*
  76.  * Convert a status to the other status
  77.  */
  79. /*
  80.  * Generate a command and push it into the task queue
  81.  */
  82. ICommand *pCmd = new CTaskCommand< CGamePlayer >( m_pReceiver, pFun );
  84. m_stdCommand.push_back( pCmd );
  86. size_t id = m_stdCommand.size();
  88. return id;
  89. }
  91. UINT CGamePlayer::CTask::Execute()
  92. {
  93. CCriticalSection::Owner lock( m_csTask );
  95. if ( m_indexCmd < m_stdCommand.size() )
  96. {
  97. ICommand *pCmd = m_stdCommand[ m_indexCmd ];
  99. ASSERT( pCmd );
  101. UINT nResult = pCmd->Execute();
  103. switch ( nResult )
  104. {
  105. case enumCompleted:
  106. Reset();
  108. case enumError:
  109. case enumNone:
  111. return nResult;
  112. break;
  114. case enumRepeat:
  116. return m_nTaskProgID;
  117. break;
  119. case enumToNextTask:
  120. default:
  121. break;
  122. }
  124. m_indexCmd ++;
  125. return m_nTaskProgID;
  126. }
  128. Reset();
  129. return enumCompleted;
  130. }
  132. /*
  133.  * CGamePlayer class
  134.  */
  135. CGamePlayer::CDataQueue::CDataQueue( size_t bufferSize /*= sizeof( DQ )*/, size_t maxFreeBuffers /*= 3*/ )
  136. : m_theDQAllocator( bufferSize, maxFreeBuffers )
  137. {
  139. }
  141. CGamePlayer::CDataQueue::~CDataQueue()
  142. {
  143. Empty();
  144. }
  146. void CGamePlayer::CDataQueue::Empty()
  147. {
  148. CCriticalSection::Owner locker( m_csQueue );
  150. stdDataMap::iterator it;
  151. for ( it = m_theData.begin(); it != m_theData.end(); it ++ )
  152. {
  153. CBuffer *pBuffer = (*it).second;
  155. SAFE_RELEASE( pBuffer );
  156. }
  158. m_theData.erase( m_theData.begin(), m_theData.end() );
  159. }
  161. void CGamePlayer::CDataQueue::Clear( LONG lnID )
  162. {
  163. CCriticalSection::Owner locker( m_csQueue );
  165. stdDataMap::iterator it;
  166. if ( m_theData.end() != ( it = m_theData.find( lnID ) ) )
  167. {
  168. CBuffer *pBuffer = (*it).second;
  170. SAFE_RELEASE( pBuffer );
  172. m_theData.erase( it );
  173. }
  174. }
  176. bool CGamePlayer::CDataQueue::Set( LONG lnID, WPARAM wParam, LPARAM lParam )
  177. {
  178. CCriticalSection::Owner locker( m_csQueue );
  180. CBuffer *pBuffer = m_theDQAllocator.Allocate();
  182. /*
  183.  * Format this buffer
  184.  */
  185. LPDQ lpDQ = reinterpret_cast< LPDQ >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  187. lpDQ->wParam = wParam;
  188. lpDQ->lParam = lParam;
  190. m_theData.insert( stdDataMap::value_type( lnID, pBuffer ) );
  192. return true;
  193. }
  195. bool CGamePlayer::CDataQueue::Peek( LONG lnID, LPDQ lpDQ )
  196. {
  197. ASSERT( lpDQ );
  199. CCriticalSection::Owner locker( m_csQueue );
  201. stdDataMap::iterator it;
  202. if ( m_theData.end() != ( it = m_theData.find( lnID ) ) )
  203. {
  204. CBuffer *pBuffer = (*it).second;
  206. const DQ *lpSrcDQ = ( const DQ * )( pBuffer->GetBuffer() );
  208. memcpy( lpDQ, lpSrcDQ, sizeof( DQ ) );
  210. return true;
  211. }
  213. return false;
  214. }
  216. bool CGamePlayer::CDataQueue::Get( LONG lnID, LPDQ lpDQ )
  217. {
  218. ASSERT( lpDQ );
  220. CCriticalSection::Owner locker( m_csQueue );
  222. stdDataMap::iterator it;
  223. if ( m_theData.end() != ( it = m_theData.find( lnID ) ) )
  224. {
  225. CBuffer *pBuffer = (*it).second;
  227. const DQ *lpSrcDQ = ( const DQ * )( pBuffer->GetBuffer() );
  229. memcpy( lpDQ, lpSrcDQ, sizeof( DQ ) );
  231. /*
  232.  * Clear the buffer and delete it from map
  233.  */
  234. SAFE_RELEASE( pBuffer );
  236. m_theData.erase( it );
  238. return true;
  239. }
  241. return false;
  242. }
  244. /*
  245.  * CGamePlayer class
  246.  */
  247. CGamePlayer::CGamePlayer( IClient *pAccSvrClient, 
  248.  IServer *pPlayerServer, 
  249.  IClient *pDBRoleClient, 
  250.  UINT nIdentityID /*  = ( UINT )( -1 ) */ )
  252. : m_lnIdentityID( nIdentityID )
  253. , m_theLoginTask( this, enumLogin )
  254. , m_theLogoutTask( this, enumLogOut )
  255. , m_theExchangeReginTask( this, enumExchangeRegin )
  256. , m_dwAccountID( ( DWORD )-1 )
  257. , m_pAccSvrClient( pAccSvrClient )
  258. , m_pPlayerServer( pPlayerServer )
  259. , m_pDBRoleClient( pDBRoleClient )
  260. {
  261. SetCurrentTask( enumNone );
  263. LONG lnID = ::InterlockedExchangeAdd( &m_slnIdentityCounts, 1 );
  265. m_lnIdentityID = ( ( UINT )( -1 ) == m_lnIdentityID ) ? lnID : m_lnIdentityID;
  267. InitTaskProcessor();
  268. }
  270. CGamePlayer::~CGamePlayer()
  271. {
  272. SAFE_RELEASE( m_pAccSvrClient );
  273. SAFE_RELEASE( m_pPlayerServer );
  274. SAFE_RELEASE( m_pDBRoleClient );
  276. ::InterlockedExchangeAdd( &m_slnIdentityCounts, -1 );
  277. }
  279. bool CGamePlayer::DispatchTask( UINT nTaskID )
  280. {
  281. if ( IsWorking() )
  282. {
  283. /*
  284.  * This player is processing a special tasks
  285.  */
  287. return false;
  288. }
  290. SetCurrentTask( nTaskID );
  292. return true;
  293. }
  295. bool CGamePlayer::IsWorking()
  296. {
  297. return ( GetCurrentTask() != enumNone );
  298. }
  300. int CGamePlayer::Run()
  301. {
  302. LONG lnNextTask = enumNone;
  304. switch ( GetCurrentTask() )
  305. {
  306. case enumLogin:
  307. lnNextTask = m_theLoginTask.Execute();
  308. SetCurrentTask( lnNextTask );
  309. break;
  311. case enumLogOut:
  312. lnNextTask = m_theLogoutTask.Execute();
  313. SetCurrentTask( lnNextTask );
  314. break;
  316. case enumExchangeRegin:
  317. lnNextTask = m_theExchangeReginTask.Execute();
  318. SetCurrentTask( lnNextTask );
  319. break;
  321. case enumCompleted:
  322. lnNextTask = TaskCompleted() ? enumNone : enumCompleted;
  323. SetCurrentTask( lnNextTask );
  324. break;
  326. case enumError:
  327. SetCurrentTask( enumNone );
  329. case enumNone:
  330. default:
  331. break;
  332. }
  334. return true;
  335. }
  337. bool CGamePlayer::AppendData( UINT nOwner, const void *pData, size_t dataLength )
  338. {
  339. if ( nOwner >= enumOwnerTotal )
  340. {
  341. return false;
  342. }
  344. BYTE cProtocol = CPackager::Peek( pData );
  346. if ( cProtocol < s2c_micropackbegin )
  347. {
  348. return LargePackProcess( nOwner, pData, dataLength );
  349. }
  350. else if ( cProtocol > s2c_micropackbegin )
  351. {
  352. return SmallPackProcess( nOwner, pData, dataLength );
  353. }
  355. return true;
  356. }
  358. bool CGamePlayer::SmallPackProcess( UINT nOwner, const void *pData, size_t dataLength )
  359. {
  360. switch ( nOwner )
  361. {
  362. case enumOwnerAccSvr:
  364. return DispatchTaskForAccount( pData, dataLength );
  365. break;
  367. case enumOwnerRoleSvr:
  369. return DispatchTaskForDBRole( pData ,dataLength );
  370. break;
  372. case enumOwnerPlayer:
  374. return DispatchTaskForPlayer( pData, dataLength );
  375. break;
  377. default:
  378. break;
  379. }
  381. return false;
  382. }
  384. bool CGamePlayer::LargePackProcess( UINT nOwner, const void *pData, size_t dataLength )
  385. {
  386. switch ( nOwner )
  387. {
  388. case enumOwnerAccSvr:
  390. ASSERT( FALSE );
  392. break;
  394. case enumOwnerRoleSvr:
  395. {
  396. bool ok = true;
  397. CBuffer *pBuffer = m_thePackReceiver.PackUp( pData, dataLength );
  399. if ( pBuffer )
  400. {
  401. ok = DispatchTaskForDBRole( pBuffer->GetBuffer(), pBuffer->GetUsed() );
  403. SAFE_RELEASE( pBuffer );
  404. }
  406. return ok;
  407. }
  408. break;
  410. case enumOwnerPlayer:
  412. ASSERT( FALSE );
  413. break;
  415. default:
  416. break;
  417. }
  419. return false;
  420. }
  422. bool CGamePlayer::DispatchTaskForAccount( const void *pData, size_t dataLength )
  423. {
  424. if ( NULL == pData || 0 == dataLength )
  425. {
  426. return false;
  427. }
  429. BYTE cProtocol = CPackager::Peek( pData );
  431. m_theDataQueue[enumOwnerAccSvr].Set( cProtocol, ( WPARAM )pData, dataLength );
  433. return true;
  434. }
  436. bool CGamePlayer::DispatchTaskForDBRole( const void *pData, size_t dataLength )
  437. {
  438. if ( NULL == pData || 0 == dataLength )
  439. {
  440. return false;
  441. }
  443. BYTE cProtocol = CPackager::Peek( pData );
  445. m_theDataQueue[enumOwnerRoleSvr].Set( cProtocol, ( WPARAM )pData, dataLength );
  447. return true;
  448. }
  450. bool CGamePlayer::DispatchTaskForPlayer( const void *pData, size_t dataLength )
  451. {
  452. if ( NULL == pData || 0 == dataLength )
  453. {
  454. return false;
  455. }
  457. BYTE cProtocol = CPackager::Peek( pData );
  459. m_theDataQueue[enumOwnerPlayer].Set( cProtocol, ( WPARAM )pData, dataLength );
  461. return true;
  462. }
  464. bool CGamePlayer::Create( const char * const pName, const char * const pPassword )
  465. {
  466. if ( NULL == pName )
  467. {
  468. return false;
  469. }
  471. m_sAccountName = pName;
  472. m_sPassword = pPassword ? pPassword : "";
  474. return true;
  475. }
  477. bool CGamePlayer::Destroy( const char * const /*pPassword*/ )
  478. {
  479. SetCurrentTask( enumNone );
  481. m_sAccountName.empty();
  482. m_sPassword.empty();
  484. m_dwAccountID = ( DWORD )-1;
  486. for ( int i=0; i<enumOwnerTotal; i++ )
  487. {
  488. m_theDataQueue[i].Empty();
  489. }
  491. m_thePackReceiver.Empty();
  493. return true;
  494. }
  496. void CGamePlayer::InitTaskProcessor()
  497. {
  498. m_theLoginTask.AddCmd( &CGamePlayer::QueryAccPwd );
  499. m_theLoginTask.AddCmd( &CGamePlayer::VerifyAccount );
  500. m_theLoginTask.AddCmd( &CGamePlayer::QueryRoleList );
  501. m_theLoginTask.AddCmd( &CGamePlayer::ProcessRoleList );
  502. m_theLoginTask.AddCmd( &CGamePlayer::SelectRole );
  503. m_theLoginTask.AddCmd( &CGamePlayer::ProcessRoleInfo );
  504. }
  506. bool CGamePlayer::TaskCompleted()
  507. {
  508. Trace( ToString( m_lnIdentityID ), "CGamePlayer::TaskCompleted" );
  510. /*
  511.  * Clear some data
  512.  */
  514. return true;
  515. }
  517. UINT CGamePlayer::QueryAccPwd()
  518. {
  519. if ( !m_pAccSvrClient )
  520. {
  521. return enumError;
  522. }
  524. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  526. BYTE *pData = const_cast< BYTE * >( pBuffer->GetBuffer() );
  528. const size_t datalength = sizeof( KAccountUserLoginInfo ) + 1;
  530. KAccountUserLoginInfo userlogin;
  531. userlogin.Size = sizeof( KAccountUserLoginInfo );
  533. userlogin.Type = AccountUserLoginInfo;
  534. userlogin.Version = ACCOUNT_CURRENT_VERSION;
  535. userlogin.Operate = m_lnIdentityID;
  537. strcpy( userlogin.Account, m_sAccountName.c_str() );
  538. strcpy( userlogin.Password, m_sPassword.c_str() );
  540. *pData = c2s_accountlogin;
  541. memcpy( pData + 1, &userlogin, sizeof( KAccountUserLoginInfo ) );
  543. pBuffer->Use( datalength );
  545. m_pAccSvrClient->SendPackToServer( ( const void * )pData, datalength );
  547. SAFE_RELEASE( pBuffer );
  549. return enumToNextTask;
  550. }
  552. UINT CGamePlayer::VerifyAccount()
  553. {
  554. CDataQueue::DQ dq;
  556. if ( m_theDataQueue[enumOwnerAccSvr].Get( s2c_accountlogin, &dq ) )
  557. {
  558. const void *pData = ( const void * )( dq.wParam );
  560. KAccountUserLoginReturn* pReturn = ( KAccountUserLoginReturn * )( ( ( char * )pData ) + 1/* size of a protocol byte */ );
  562. int nResult = pReturn->nReturn;
  564. UINT nQueryResult = LOGIN_A_LOGIN;
  565. UINT nNextTask = enumError;
  567. switch ( nResult )
  568. {
  569. case ACTION_SUCCESS: /* Login Success ! */
  571. m_dwAccountID = pReturn->AccountID;
  573. nQueryResult |= LOGIN_R_SUCCESS;
  575. nNextTask = enumToNextTask;
  577. break;
  579. case E_ACCOUNT_OR_PASSWORD: /* Login Failed ! --- Name, Password */
  581. nQueryResult |= LOGIN_R_ACCOUNT_OR_PASSWORD_ERROR;
  583. break;
  585. case E_ACCOUNT_EXIST: /* Login Failed ! --- Already login */
  587. nQueryResult |= LOGIN_R_ACCOUNT_EXIST;
  589. break;
  591. case E_ACCOUNT_NODEPOSIT: /* Login Failed ! --- No Money */
  593. nQueryResult |= LOGIN_R_TIMEOUT;
  595. break;
  597. default: /* Login Failed ! */
  599. nQueryResult |= LOGIN_R_FAILED;
  601. break;
  603. }
  605. /*
  606.  * Notify the result to player
  607.  */
  608. _VerifyAccount_ToPlayer( nQueryResult );
  610. return nNextTask;
  611. }
  613. return enumRepeat;
  614. }
  616. bool CGamePlayer::_VerifyAccount_ToPlayer( UINT nQueryResult )
  617. {
  618. KLoginAccountInfo lai;
  620. ZeroMemory( &lai, sizeof( KLoginAccountInfo ) );
  622. /*
  623.  * Account
  624.  */
  625. size_t used = sizeof( lai.Account );
  626. used = ( used > m_sAccountName.length() ) ? m_sAccountName.length() : used;
  628. memcpy( lai.Account, m_sAccountName.c_str(), used );
  630. /*
  631.  * Password
  632.  */
  633. used = sizeof( lai.Password );
  634. used = ( used > m_sPassword.length() ) ? m_sPassword.length() : used;
  636. memcpy( lai.Password, m_sPassword.c_str(), used );
  638. /*
  639.  * The other info
  640.  */
  641. lai.Param = nQueryResult;
  643. lai.Size = sizeof( lai );
  645. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  647. BYTE *pData = const_cast< BYTE * >( pBuffer->GetBuffer() );
  649. BYTE bProtocol = s2c_login;
  650. size_t sizeProtocol = sizeof( BYTE );
  651. memcpy( pData, &bProtocol, sizeProtocol );
  652. memcpy( pData + sizeProtocol, ( BYTE * )( &lai ), sizeof( lai ) );
  654. pBuffer->Use( lai.Size + sizeof( BYTE )/* protocol id */ );
  656. m_pPlayerServer->SendData( m_lnIdentityID, pBuffer->GetBuffer(), pBuffer->GetUsed() );
  658. pBuffer->Release();
  660. return true;
  661. }
  663. UINT CGamePlayer::QueryRoleList()
  664. {
  665. const size_t lenAN = strlen( m_sAccountName.c_str() );
  666. const size_t lenPL = lenAN + sizeof( TStreamData );
  668. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  670. TStreamData *pPlayerList = reinterpret_cast< TStreamData * >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  672. ASSERT( pPlayerList );
  674. pPlayerList->nProtoId = c2s_roleserver_getrolelist;
  675. pPlayerList->nDataLen = lenAN + 1;
  676. pPlayerList->ulIdentity = m_lnIdentityID;
  678. pPlayerList->pDataBuffer[0] = s_nRoleListCount;
  679. memcpy( &pPlayerList->pDataBuffer[1], m_sAccountName.c_str(), lenAN );
  681. pBuffer->Use( lenPL );
  683. m_pDBRoleClient->SendPackToServer( ( const void * )pPlayerList, lenPL );
  685. SAFE_RELEASE( pBuffer );
  687. return enumToNextTask;
  688. }
  690. UINT CGamePlayer::ProcessRoleList()
  691. {
  692. CDataQueue::DQ dq;
  694. if ( m_theDataQueue[enumOwnerRoleSvr].Get( s2c_roleserver_getrolelist_result, &dq ) )
  695. {
  696. UINT nNextTask = enumError;
  698. const void *pData = ( const void * )( dq.wParam );
  700. const TProcessData *pPD = ( const TProcessData * )pData;
  702. int nRoleCount = *( char * )( pPD->pDataBuffer );
  704. // const S3DBI_RoleBaseInfo *pRoleList = ( const S3DBI_RoleBaseInfo * )( ( const char * )( pPA->pDataBuffer ) + 1/* sizeof( char ) */ );
  705. // const size_t datalength = sizeof( S3DBI_RoleBaseInfo ) * nRoleCount;
  707. if ( nRoleCount > 0 )
  708. {
  709. m_pPlayerServer->SendData( m_lnIdentityID, pData, dq.lParam );
  711. nNextTask = enumToNextTask;
  712. }
  714. return nNextTask;
  715. }
  717. return enumRepeat;
  718. }
  720. UINT CGamePlayer::SelectRole()
  721. {
  722. CDataQueue::DQ dq;
  724. if ( m_theDataQueue[enumOwnerPlayer].Get( c2s_dbplayerselect, &dq ) )
  725. {
  726. UINT nNextTask = enumError;
  728. const void *pData = ( const void * )( dq.wParam );
  730. const tagDBSelPlayer *pDSPC = ( const tagDBSelPlayer * )pData;
  732. _QueryRoleInfo_ToDBRole( pDSPC->szRoleName );
  734. nNextTask = enumToNextTask;
  736. return nNextTask;
  737. }
  739. return enumRepeat;
  740. }
  742. bool CGamePlayer::_QueryRoleInfo_ToDBRole( const char *pRoleName )
  743. {
  744. if ( NULL == pRoleName || '' == pRoleName[0] )
  745. {
  746. return false;
  747. }
  749. const size_t lenRN = strlen( pRoleName );
  750. const size_t lenRI = sizeof( TStreamData ) - 1 + lenRN;
  752. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  754. TStreamData *pRoleInfo = reinterpret_cast< TStreamData * >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  756. ASSERT( pRoleInfo );
  758. pRoleInfo->nProtoId = c2s_roleserver_getroleinfo;
  759. pRoleInfo->nDataLen = lenRN;
  760. pRoleInfo->ulIdentity = m_lnIdentityID;
  761. memcpy( &pRoleInfo->pDataBuffer[0], pRoleName, lenRN );
  763. pBuffer->Use( lenRI );
  765. m_pDBRoleClient->SendPackToServer( ( const void * )pRoleInfo, lenRI );
  767. SAFE_RELEASE( pBuffer );
  769. return true;
  770. }
  772. UINT CGamePlayer::ProcessRoleInfo()
  773. {
  774. CDataQueue::DQ dq;
  776. if ( m_theDataQueue[enumOwnerRoleSvr].Get( s2c_roleserver_getroleinfo_result, &dq ) )
  777. {
  778. UINT nNextTask = enumError;
  780. const void *pData = ( const void * )( dq.wParam );
  782. TProcessData *pPA = ( TProcessData * )( pData );
  784. ASSERT( m_lnIdentityID == pPA->ulIdentity );
  786. const TRoleData *pRoleData = ( const TRoleData * )( ( const char * )( pPA->pDataBuffer ) );
  788. ::MessageBox( NULL, pRoleData->BaseInfo.szName, "Info", MB_OK );
  790. if ( _SyncRoleInfo_ToGameServer( ( const void * )pRoleData, pPA->nDataLen ) )
  791. {
  792. nNextTask = enumToNextTask;
  793. }
  795. return nNextTask;
  796. }
  798. return enumRepeat;
  799. }
  801. bool CGamePlayer::_SyncRoleInfo_ToGameServer( const void *pData, size_t dataLength )
  802. {
  805. return true;
  806. }