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

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

模拟服务器

开发平台：

C/C++

GamePlayer.cpp：源码内容
  1. #include "Stdafx.h"
  2. #include "GamePlayer.h"
  4. #include "AccountLoginDef.h"
  5. #include "LoginDef.h"
  7. #include "S3DBInterface.h"
  9. #include "KProtocol.h"
  10. #include "KProtocolDef.h"
  12. #include "Utils.h"
  13. #include "Macro.h"
  14. #include "Exception.h"
  15. #include "Buffer.h"
  17. #include "SmartClient.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;
  26. using OnlineGameLib::Win32::CPackager;
  27. using OnlineGameLib::Win32::net_aton;
  29. CBuffer::Allocator CGamePlayer::m_theGlobalAllocator( 1024 * 64, 1000 );
  31. LONG CGamePlayer::m_slnIdentityCounts = 0;
  32. LONG CGamePlayer::m_lnWorkingCounts = 0;
  34. const int CGamePlayer::s_nRoleListCount  = 3;
  35. const int CGamePlayer::s_nLoginTimeoutTimer  = 60 * 1000;
  36. const int CGamePlayer::s_nProcessTimeoutTimer  = 200 * 1000;
  38. CCriticalSection CGamePlayer::m_csMapSP;
  39. CGamePlayer::stdMapSP CGamePlayer::m_sthePlayerTable;
  41. CPlayerCreator CGamePlayer::m_thePlayerCreator;
  43. //IClient * CGamePlayer::m_pAccSvrClient = NULL;
  44. IServer * CGamePlayer::m_pPlayerServer = NULL;
  45. IClient * CGamePlayer::m_pDBRoleClient = NULL;
  47. /*
  48.  * CGamePlayer Global Function
  49.  */
  50. bool CGamePlayer::SetupGlobalAllocator( size_t bufferSize, size_t maxFreeBuffers )
  51. {
  52. return CGamePlayer::m_theGlobalAllocator.ReSet( bufferSize, maxFreeBuffers );
  53. }
  55. /*
  56.  * CGamePlayer::CTask
  57.  */
  58. CGamePlayer::CTask::CTask()
  59. {
  60. ASSERT( FALSE );
  61. }
  63. CGamePlayer::CTask::~CTask()
  64. {
  65. //CCriticalSection::Owner lock( m_csTask );
  67. stdVector::iterator theIterator;
  69. for ( theIterator = m_stdCommand.begin(); theIterator != m_stdCommand.end(); theIterator ++ )
  70. {
  71. ICommand *pCmd = reinterpret_cast< ICommand * >( *theIterator );
  73. SAFE_DELETE( pCmd );
  74. }
  76. m_stdCommand.clear();
  77. }
  79. CGamePlayer::CTask::CTask( CGamePlayer *pReceiver, UINT nTaskID )
  80. : m_pReceiver( pReceiver )
  81. , m_indexCmd( 0 )
  82. , m_nTaskProgID( nTaskID )
  83. {
  84. }
  86. size_t CGamePlayer::CTask::AddCmd( Action pFun )
  87. {
  88. //CCriticalSection::Owner lock( m_csTask );
  90. /*
  91.  * Convert a status to the other status
  92.  */
  94. /*
  95.  * Generate a command and push it into the task queue
  96.  */
  97. ICommand *pCmd = new CTaskCommand< CGamePlayer >( m_pReceiver, pFun );
  99. m_stdCommand.push_back( pCmd );
  101. size_t id = m_stdCommand.size();
  103. return id;
  104. }
  106. UINT CGamePlayer::CTask::Execute()
  107. {
  108. //CCriticalSection::Owner lock( m_csTask );
  110. if ( m_indexCmd < m_stdCommand.size() )
  111. {
  112. ICommand *pCmd = m_stdCommand[ m_indexCmd ];
  114. ASSERT( pCmd );
  116. UINT nResult = pCmd->Execute();
  118. switch ( nResult )
  119. {
  120. case enumSelAddDelRole:
  121. case enumLoginCreateRole:
  122. case enumLoginDeleteRole:
  123. case enumLoginSelectRole:
  124. case enumCompleted:
  125. Reset();
  127. case enumError:
  128. case enumNone:
  130. return nResult;
  131. break;
  133. case enumRepeat:
  135. return m_nTaskProgID;
  136. break;
  138. case enumToNextTask:
  139. default:
  140. break;
  141. }
  143. m_indexCmd ++;
  144. return m_nTaskProgID;
  145. }
  147. Reset();
  148. return enumCompleted;
  149. }
  151. /*
  152.  * CGamePlayer class
  153.  */
  154. CGamePlayer::CDataQueue::CDataQueue( size_t bufferSize /*= 1024 * 64*/, size_t maxFreeBuffers /*= 1*/ )
  155. : m_theDQAllocator( bufferSize, maxFreeBuffers )
  156. {
  158. }
  160. CGamePlayer::CDataQueue::~CDataQueue()
  161. {
  162. Empty();
  163. }
  165. void CGamePlayer::CDataQueue::Empty()
  166. {
  167. CCriticalSection::Owner locker( m_csQueue );
  169. stdDataMap::iterator it;
  170. for ( it = m_theData.begin(); it != m_theData.end(); it ++ )
  171. {
  172. LONG id = ( *it ).first;
  174. CBuffer *pBuffer = (*it).second;
  176. SAFE_RELEASE( pBuffer );
  177. }
  179. m_theData.erase( m_theData.begin(), m_theData.end() );
  180. }
  182. bool CGamePlayer::CDataQueue::AddData( LONG lnID, const BYTE *pData, size_t datalength )
  183. {
  184. bool ok = false;
  186. ASSERT( pData && datalength );
  188. CBuffer *pBuffer = m_theDQAllocator.Allocate();
  190. ASSERT( pBuffer );
  192. pBuffer->AddData( pData, datalength );
  194. {
  195. CCriticalSection::Owner locker( m_csQueue );
  197. pBuffer->AddRef();
  199. stdDataMap::iterator it;
  200. if ( m_theData.end() != ( it = m_theData.find( lnID ) ) )
  201. {
  202. CBuffer *pTemp = ( *it ).second;
  204. SAFE_RELEASE( pTemp );
  206. m_theData.erase( it );
  207. }
  209. std::pair< stdDataMap::iterator, bool > result = 
  210. m_theData.insert( stdDataMap::value_type( lnID, pBuffer ) );
  212. if ( !( ok = result.second ) )
  213. {
  214. SAFE_RELEASE( pBuffer );
  215. }
  216. }
  218. SAFE_RELEASE( pBuffer );
  220. return ok;
  221. }
  223. CBuffer *CGamePlayer::CDataQueue::Attach( LONG lnID )
  224. {
  225. CCriticalSection::Owner locker( m_csQueue );
  227. stdDataMap::iterator it;
  229. if ( m_theData.end() != ( it = m_theData.find( lnID ) ) )
  230. {
  231. CBuffer *pBuffer = ( *it ).second;
  233. m_theData.erase( it );
  235. return pBuffer;
  236. }
  238. return NULL;
  239. }
  241. void CGamePlayer::CDataQueue::Detach( LONG lnID )
  242. {
  243. // Clear( lnID );
  244. }
  246. void CGamePlayer::CDataQueue::Clear( LONG lnID )
  247. {
  248. CCriticalSection::Owner locker( m_csQueue );
  250. stdDataMap::iterator it;
  251. if ( m_theData.end() != ( it = m_theData.find( lnID ) ) )
  252. {
  253. CBuffer *pBuffer = ( *it ).second;
  255. SAFE_RELEASE( pBuffer );
  257. m_theData.erase( it );
  258. }
  259. }
  261. /*
  262.  * CGamePlayer class
  263.  */
  264. CGamePlayer::CGamePlayer( UINT nIdentityID /*  = ( UINT )( -1 ) */ )
  265. : m_lnIdentityID( nIdentityID )
  266. , m_theLoginTask( this, enumLogin )
  267. , m_theSelAddDelTask( this, enumSelAddDelRole )
  268. , m_theLoginCreateRoleTask( this, enumLoginCreateRole )
  269. , m_theLoginSelectRoleTask( this, enumLoginSelectRole )
  270. , m_theLoginDeleteRoleTask( this, enumLoginDeleteRole )
  271. , m_theSafeCloseTask( this, enumSafeClose )
  272. , m_nCurrentTaskID( 0 )
  273. , m_nAttachServerID( -1 )
  274. , m_bActiveStatus( false )
  275. , m_dwTaskBeginTimer( 0 )
  276. , m_dwTaskTotalTimer( 0 )
  277. , m_bAutoUnlockAccount( false )
  278.                 , m_bUseSuperPassword( false )
  279. , m_nExtPoint(-1)
  280. {
  281. SetCurrentTask( enumNone );
  283. LONG lnID = ::InterlockedExchangeAdd( &m_slnIdentityCounts, 1 );
  285. m_lnIdentityID = ( ( UINT )( -1 ) == m_lnIdentityID ) ? lnID : m_lnIdentityID;
  287. InitTaskProcessor();
  288. }
  290. CGamePlayer::~CGamePlayer()
  291. {
  292. {
  293. CCriticalSection::Owner locker( CGamePlayer::m_csMapSP );
  295. m_sthePlayerTable.erase( m_sthePlayerTable.begin(), m_sthePlayerTable.end() );
  296. }
  298. ::InterlockedExchangeAdd( &m_slnIdentityCounts, -1 );
  299. }
  301. bool CGamePlayer::Active()
  302. {
  303. SetCurrentTask( enumNone );
  305. m_nAttachServerID = -1;
  307. m_bActiveStatus = true;
  309. m_dwTaskBeginTimer = ::GetTickCount();
  310. m_dwTaskTotalTimer = s_nLoginTimeoutTimer;
  312. ::InterlockedExchangeAdd( &m_lnWorkingCounts, 1 );
  314. return true;
  315. }
  317. bool CGamePlayer::Inactive()
  318. {
  319. m_bActiveStatus = false;
  321. SetCurrentTask( enumNone );
  323. Del( m_sRoleName.c_str() );
  325. m_dwTaskBeginTimer = 0;
  326. m_dwTaskTotalTimer = s_nLoginTimeoutTimer;
  328. if ( m_bAutoUnlockAccount )
  329. {
  330. _UnlockAccount();
  332. m_bAutoUnlockAccount = false;
  333. }
  335. _ClearTaskQueue();
  337. /* IGServer *pGServer = CGameServer::GetServer( m_nAttachServerID );
  339. if ( pGServer )
  340. {
  341. pGServer->DispatchTask( CGameServer::enumPlayerLogicLogout, m_sRoleName.c_str(), m_sRoleName.size() );
  342. }
  343. */
  344. m_nAttachServerID = -1;
  346. /*
  347. * Clear this role info
  348. */
  349. m_sAccountName = "";
  350. m_sPassword = "";
  351.     m_sSuperPassword = "";
  352.     m_sDelRoleName   = "";
  353.     m_bUseSuperPassword = false;
  355. m_sRoleName = "";
  357. ::InterlockedExchangeAdd( &m_lnWorkingCounts, -1 );
  359. return true;
  360. }
  362. UINT CGamePlayer::SafeClose()
  363. {
  364. ASSERT( FALSE );
  366. return enumToNextTask;
  367. }
  369. bool CGamePlayer::_UnlockAccount()
  370. {
  371. const char *pAccountName = m_sAccountName.c_str();
  373. if ( !pAccountName || !pAccountName[0] )
  374. {
  375. return false;
  376. }
  378. if ( _NAME_LEN <= strlen( pAccountName ) )
  379. {
  380. return false;
  381. }
  383. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  385. BYTE *pData = const_cast< BYTE * >( pBuffer->GetBuffer() );
  387. const size_t datalength = sizeof( KAccountUserLogout ) + 1;
  389. KAccountUserLogout user;
  391. user.Size = sizeof( KAccountUserLogout );
  392. user.Type = AccountUserLogout;
  393. user.Version = ACCOUNT_CURRENT_VERSION;
  394. user.nExtPoint = 0;
  396. size_t length = strlen( pAccountName );
  397. length = ( length > LOGIN_USER_ACCOUNT_MAX_LEN ) ? LOGIN_USER_ACCOUNT_MAX_LEN : length;
  398. memcpy( user.Account, pAccountName, length );
  399. user.Account[length] = '';
  401. *pData = c2s_accountlogout;
  402. memcpy( pData + 1, &user, sizeof( KAccountUserLogout ) );
  404. g_theSmartClient.Send( ( const void * )pData, datalength );
  405. // m_pAccSvrClient->SendPackToServer( ( const void * )pData, datalength );
  407. SAFE_RELEASE( pBuffer );
  409. return true;
  410. }
  412. void CGamePlayer::ATTACH_NETWORK( IClient *pAccSvrClient, 
  413. IServer *pPlayerServer, 
  414. IClient *pDBRoleClient )
  415. {
  416. ASSERT( m_slnIdentityCounts == 0 );
  418. // m_pAccSvrClient = pAccSvrClient;
  419. m_pPlayerServer = pPlayerServer;
  420. m_pDBRoleClient = pDBRoleClient;
  421. }
  423. void CGamePlayer::DETACH_NETWORK()
  424. {
  425. ASSERT( m_slnIdentityCounts == 0 );
  427. // SAFE_RELEASE( m_pAccSvrClient );
  428. SAFE_RELEASE( m_pPlayerServer );
  429. SAFE_RELEASE( m_pDBRoleClient );
  430. }
  432. bool CGamePlayer::DispatchTask( UINT nTaskID )
  433. {
  434. /*
  435.  * This player is processing a special tasks
  436.  */
  437. /*
  438. if ( IsWorking() )
  439. {
  440. return false;
  441. }
  442. */
  443. m_theLoginTask.Reset();
  445. m_theSelAddDelTask.Reset();
  447. m_theLoginCreateRoleTask.Reset();
  448. m_theLoginSelectRoleTask.Reset();
  449. m_theLoginDeleteRoleTask.Reset();
  451. SetCurrentTask( nTaskID );
  453. return true;
  454. }
  456. bool CGamePlayer::IsWorking()
  457. {
  458. return ( GetCurrentTask() != enumNone );
  459. }
  461. bool CGamePlayer::Run()
  462. {
  463. LONG lnNextTask = enumNone;
  465. if ( m_bActiveStatus && m_dwTaskBeginTimer )
  466. {
  467. DWORD dwCurTimer = ::GetTickCount();
  469. if ( dwCurTimer - m_dwTaskBeginTimer > m_dwTaskTotalTimer )
  470. {
  471. m_pPlayerServer->ShutdownClient( m_lnIdentityID );
  473. return false;
  474. }
  475. }
  477. switch ( GetCurrentTask() )
  478. {
  479. case enumNone:
  480. return true;
  481. break;
  483. case enumLogin:
  484. lnNextTask = m_theLoginTask.Execute();
  485. SetCurrentTask( lnNextTask );
  486. break;
  488. case enumSelAddDelRole:
  489. lnNextTask = m_theSelAddDelTask.Execute();
  490. SetCurrentTask( lnNextTask );
  491. break;
  493. case enumLoginCreateRole:
  494. lnNextTask = m_theLoginCreateRoleTask.Execute();
  495. SetCurrentTask( lnNextTask );
  496. break;
  498. case enumLoginSelectRole:
  499. lnNextTask = m_theLoginSelectRoleTask.Execute();
  500. SetCurrentTask( lnNextTask );
  501. break;
  503. case enumLoginDeleteRole:
  504. lnNextTask = m_theLoginDeleteRoleTask.Execute();
  505. SetCurrentTask( lnNextTask );
  506. break;
  508. case enumSafeClose:
  509. lnNextTask = m_theSafeCloseTask.Execute();
  510. SetCurrentTask( lnNextTask );
  511. break;
  513. case enumCompleted:
  514. lnNextTask = TaskCompleted() ? enumNone : enumCompleted;
  515. SetCurrentTask( lnNextTask );
  516. break;
  518. case enumError:
  519. SetCurrentTask( enumNone );
  520. break;
  522. default:
  523. break;
  524. }
  526. return true;
  527. }
  529. bool CGamePlayer::AppendData( UINT nOwner, const void *pData, size_t dataLength )
  530. {
  531. if ( nOwner >= enumOwnerTotal || !m_bActiveStatus )
  532. {
  533. return false;
  534. }
  536. BYTE cProtocol = CPackager::Peek( pData );
  538. if ( cProtocol < g_nGlobalProtocolType )
  539. {
  540. return LargePackProcess( nOwner, pData, dataLength );
  541. }
  542. else if ( cProtocol > g_nGlobalProtocolType )
  543. {
  544. return SmallPackProcess( nOwner, pData, dataLength );
  545. }
  547. return true;
  548. }
  550. bool CGamePlayer::SmallPackProcess( UINT nOwner, const void *pData, size_t dataLength )
  551. {
  552. switch ( nOwner )
  553. {
  554. case enumOwnerAccSvr:
  556. return DispatchTaskForAccount( pData, dataLength );
  557. break;
  559. case enumOwnerRoleSvr:
  561. return DispatchTaskForDBRole( pData, dataLength );
  562. break;
  564. case enumOwnerPlayer:
  566. return DispatchTaskForPlayer( pData, dataLength );
  567. break;
  569. default:
  570. break;
  571. }
  573. return false;
  574. }
  576. bool CGamePlayer::LargePackProcess( UINT nOwner, const void *pData, size_t dataLength )
  577. {
  578. switch ( nOwner )
  579. {
  580. case enumOwnerAccSvr:
  582. ASSERT( FALSE );
  584. break;
  586. case enumOwnerRoleSvr:
  587. {
  588. bool ok = true;
  589. CBuffer *pBuffer = m_thePackager.PackUp( pData, dataLength );
  591. if ( pBuffer )
  592. {
  593. ok = DispatchTaskForDBRole( pBuffer->GetBuffer(), pBuffer->GetUsed() );
  595. SAFE_RELEASE( pBuffer );
  596. }
  598. return ok;
  599. }
  600. break;
  602. case enumOwnerPlayer:
  604. ASSERT( FALSE );
  605. break;
  607. default:
  608. break;
  609. }
  611. return false;
  612. }
  614. bool CGamePlayer::DispatchTaskForAccount( const void *pData, size_t dataLength )
  615. {
  616. if ( NULL == pData || 0 == dataLength )
  617. {
  618. return false;
  619. }
  621. BYTE cProtocol = CPackager::Peek( pData );
  623. m_theDataQueue[enumOwnerAccSvr].AddData( cProtocol, ( const BYTE * )pData, dataLength );
  625. return true;
  626. }
  628. bool CGamePlayer::DispatchTaskForDBRole( const void *pData, size_t dataLength )
  629. {
  630. if ( NULL == pData || 0 == dataLength )
  631. {
  632. return false;
  633. }
  635. BYTE cProtocol = CPackager::Peek( pData );
  637. m_theDataQueue[enumOwnerRoleSvr].AddData( cProtocol, ( const BYTE * )pData, dataLength );
  639. return true;
  640. }
  642. bool CGamePlayer::DispatchTaskForPlayer( const void *pData, size_t dataLength )
  643. {
  644. if ( NULL == pData || 0 == dataLength )
  645. {
  646. return false;
  647. }
  649. BYTE cProtocol = CPackager::Peek( pData );
  651. m_theDataQueue[enumOwnerPlayer].AddData( cProtocol, ( const BYTE * )pData, dataLength );
  653. return true;
  654. }
  656. void CGamePlayer::_ClearTaskQueue()
  657. {
  658. for ( int i=0; i<enumOwnerTotal; i++ )
  659. {
  660. m_theDataQueue[i].Empty();
  661. }
  663. m_thePackager.Empty();
  664. }
  666. void CGamePlayer::InitTaskProcessor()
  667. {
  668. /*
  669.  * Login main task
  670.  */
  671. m_theLoginTask.AddCmd( &CGamePlayer::WaitForAccPwd );
  672. m_theLoginTask.AddCmd( &CGamePlayer::QueryAccPwd );
  673. m_theLoginTask.AddCmd( &CGamePlayer::VerifyAccount );
  674. m_theLoginTask.AddCmd( &CGamePlayer::QueryRoleList );
  675. m_theLoginTask.AddCmd( &CGamePlayer::ProcessRoleList );
  677. /*
  678.  * Login branch task
  679.  */
  680. {
  681. /*
  682.  * m_theSelAddDelTask::SelAddDelRole
  683.  *
  684.  * switch( result )
  685.  * case m_theLoginCreateRoleTask
  686.  * case m_theLoginDeleteRoleTask
  687.  * case m_theLoginSelectRoleTask
  688.  */
  689. m_theSelAddDelTask.AddCmd( &CGamePlayer::SelAddDelRole );
  690. m_theSelAddDelTask.AddCmd( &CGamePlayer::QueryAccPwd );
  691. m_theSelAddDelTask.AddCmd( &CGamePlayer::DelRole_WaitForVerify );
  693. /*
  694.  * m_theLoginCreateRoleTask::WaitForCreateResult
  695.  *
  696.  * successed : m_theLoginCreateRoleTask::ProcessRoleInfo
  697.  * failed  : m_theSelAddDelTask::SelAddDelRole
  698.  */
  699. m_theLoginCreateRoleTask.AddCmd( &CGamePlayer::WaitForCreateResult ); 
  700. m_theLoginCreateRoleTask.AddCmd( &CGamePlayer::ProcessRoleInfo );
  701. m_theLoginCreateRoleTask.AddCmd( &CGamePlayer::WaitForGameSvrPermit );
  703. m_theLoginDeleteRoleTask.AddCmd( &CGamePlayer::WaitForDeleteResult );
  705. m_theLoginSelectRoleTask.AddCmd( &CGamePlayer::ProcessRoleInfo );
  706. m_theLoginSelectRoleTask.AddCmd( &CGamePlayer::WaitForGameSvrPermit );
  707. }
  709. m_theSafeCloseTask.AddCmd( &CGamePlayer::SafeClose );
  711. /*
  712.  * Logout
  713.  */
  715. m_nExtPoint = -1;
  716. }
  718. bool CGamePlayer::TaskCompleted()
  719. {
  720. Trace( ToString( m_lnIdentityID ), "CGamePlayer::TaskCompleted" );
  722. /*
  723.  * Clear some data
  724.  */
  726. return true;
  727. }
  729. UINT CGamePlayer::WaitForAccPwd()
  730. {
  731. #ifdef CONSOLE_DEBUG
  732. cprintf( "CGamePlayer::WaitForAccPwd...n" );
  733. #endif
  735. CBuffer *pRetBuffer = m_theDataQueue[enumOwnerPlayer].Attach( c2s_login );
  736.  
  737. if ( pRetBuffer )
  738. {
  739. KLoginAccountInfo* pLAI = ( KLoginAccountInfo * )( pRetBuffer->GetBuffer() + 1/* size of a protocol byte */ );
  741. UINT nNextTask = enumError;
  743. const char *pAccName = pLAI->Account;
  744. const char *pAccPwd = pLAI->Password.szPassword;
  746. #ifdef CONSOLE_DEBUG
  747. cprintf( "CGamePlayer::WaitForAccPwd [AccountName:%s]n", pAccName );
  748. #endif
  749.             
  750.         // modify by Freeway Chen in 2003.7.1
  751.         if (pLAI)
  752.         {
  753.             int nCheckProtocolVersion = true;
  755.             #ifdef USE_KPROTOCOL_VERSION
  756.              nCheckProtocolVersion = (pLAI->ProtocolVersion == KPROTOCOL_VERSION);
  757.             #endif
  759.             if (nCheckProtocolVersion)
  760.             {
  761.                 // 如果协议版本相同，继续判断账号
  762.                 if (pAccName[0]) 
  763.         {
  764.         nNextTask = enumToNextTask;
  765.         
  766.         m_sAccountName = pAccName;
  767.         m_sPassword = pAccPwd ? pAccPwd : "";
  768.                     m_bUseSuperPassword = false;
  769.         }
  770.             }
  771.             else
  772.             {
  773.                 // 如果协议版本不同，就提示用户出错，需要升级到新版本
  774.            UINT nQueryResult = LOGIN_A_LOGIN | LOGIN_R_INVALID_PROTOCOLVERSION;
  776.                 _VerifyAccount_ToPlayer(nQueryResult, 0);
  778.                 // 是否需要玩家断开? 需要进一步确认
  779.      //m_pPlayerServer->ShutdownClient( m_lnIdentityID ); // 断开玩家
  780.             }
  781.         }
  783. SAFE_RELEASE( pRetBuffer );
  784. m_theDataQueue[enumOwnerPlayer].Detach( c2s_login );
  786. return nNextTask;
  787. }
  789. return enumRepeat;
  790. }
  792. UINT CGamePlayer::QueryAccPwd()
  793. {
  794. #ifdef CONSOLE_DEBUG
  795. cprintf( "CGamePlayer::QueryAccPwd...n" );
  796. #endif
  798. /* if ( !m_pAccSvrClient )
  799. {
  800. return enumError;
  801. }
  802. */
  803. m_dwTaskTotalTimer = s_nProcessTimeoutTimer;
  805. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  807. BYTE *pData = const_cast< BYTE * >( pBuffer->GetBuffer() );
  809. const size_t datalength = sizeof( KAccountUserLoginInfo ) + 1;
  811. KAccountUserLoginInfo userlogin;
  812. userlogin.Size = sizeof( KAccountUserLoginInfo );
  814.     if (m_bUseSuperPassword)
  815.     {
  816.      userlogin.Type = AccountUserVerify;
  817.     }
  818.     else
  819.     {
  820.      userlogin.Type = AccountUserLoginInfo;
  821.     }
  823. userlogin.Version = ACCOUNT_CURRENT_VERSION;
  824. userlogin.Operate = m_lnIdentityID;
  826. int nMinLen = sizeof( userlogin.Account );
  827. nMinLen = m_sAccountName.size() > nMinLen ? nMinLen: m_sAccountName.size();
  828. memcpy( userlogin.Account, m_sAccountName.c_str(), nMinLen );
  829. userlogin.Account[nMinLen] = '';
  831.     if (m_bUseSuperPassword)
  832.     {
  833.     nMinLen = sizeof( userlogin.Password );
  834.     nMinLen = m_sSuperPassword.size() > nMinLen ? nMinLen: m_sSuperPassword.size();
  835.     memcpy( userlogin.Password, m_sSuperPassword.c_str(), nMinLen );
  836.     userlogin.Password[nMinLen] = '';
  837.     }
  838.     else
  839.     {
  840.     nMinLen = sizeof( userlogin.Password );
  841.     nMinLen = m_sPassword.size() > nMinLen ? nMinLen: m_sPassword.size();
  842.     memcpy( userlogin.Password, m_sPassword.c_str(), nMinLen );
  843.     userlogin.Password[nMinLen] = '';
  844.     }
  846. *pData = c2s_accountlogin;
  847. memcpy( pData + 1, &userlogin, sizeof( KAccountUserLoginInfo ) );
  849. m_bAutoUnlockAccount = true;
  850. m_theDataQueue[enumOwnerAccSvr].Empty();
  852. g_theSmartClient.Send( ( const void * )pData, datalength );
  853. // m_pAccSvrClient->SendPackToServer( ( const void * )pData, datalength );
  855. SAFE_RELEASE( pBuffer );
  857. return enumToNextTask;
  858. }
  860. UINT CGamePlayer::VerifyAccount()
  861. {
  862. #ifdef CONSOLE_DEBUG
  863. cprintf( "CGamePlayer::VerifyAccount...n" );
  864. #endif
  866. m_nExtPoint = -1;
  868. CBuffer *pRetBuffer = m_theDataQueue[enumOwnerAccSvr].Attach( s2c_accountlogin );
  870. if ( pRetBuffer )
  871. {
  872. KAccountUserReturnExt* pReturn = ( KAccountUserReturnExt * )( pRetBuffer->GetBuffer() + 1/* size of a protocol byte */ );
  874. int nResult = pReturn->nReturn;
  876. UINT nQueryResult = LOGIN_A_LOGIN;
  877. UINT nNextTask = enumError;
  879. switch ( nResult )
  880. {
  881. case ACTION_SUCCESS: /* Login Success ! */
  883. #ifdef CONSOLE_DEBUG
  884. cprintf( "CGamePlayer::VerifyAccount Successful!n" );
  885. #endif
  886. // pReturn->Account;
  887. nQueryResult |= LOGIN_R_SUCCESS;
  889. nNextTask = enumToNextTask;
  891. m_nExtPoint = pReturn->nExtPoint;
  893. break;
  895. case E_ACCOUNT_OR_PASSWORD: /* Login Failed ! --- Name, Password */
  897. #ifdef CONSOLE_DEBUG
  898. cprintf( "CGamePlayer::VerifyAccount Failed! [name or pwd error]n" );
  899. #endif
  900. nQueryResult |= LOGIN_R_ACCOUNT_OR_PASSWORD_ERROR;
  902. m_bAutoUnlockAccount = false;
  904. break;
  906. case E_ACCOUNT_EXIST: /* Login Failed ! --- Already login */
  908. #ifdef CONSOLE_DEBUG
  909. cprintf( "CGamePlayer::VerifyAccount Failed! [Already login]n" );
  910. #endif
  912. nQueryResult |= LOGIN_R_ACCOUNT_EXIST;
  914. m_bAutoUnlockAccount = false;
  916. break;
  918. case E_ACCOUNT_FREEZE: /* Login Failed ! --- Account Freeze */
  920. #ifdef CONSOLE_DEBUG
  921. cprintf( "CGamePlayer::VerifyAccount Failed! [Account Freeze]n" );
  922. #endif
  924. nQueryResult |= LOGIN_R_FREEZE;
  926. m_bAutoUnlockAccount = false;
  928. break;
  930. case E_ACCOUNT_NODEPOSIT: /* Login Failed ! --- No Money */
  932. #ifdef CONSOLE_DEBUG
  933. cprintf( "CGamePlayer::VerifyAccount Failed! [No Money]n" );
  934. #endif
  936. nQueryResult |= LOGIN_R_TIMEOUT;
  938. m_bAutoUnlockAccount = false;
  940. break;
  942. default: /* Login Failed ! */
  944. #ifdef CONSOLE_DEBUG
  945. cprintf( "CGamePlayer::VerifyAccount Failed!n" );
  946. #endif
  948. nQueryResult |= LOGIN_R_FAILED;
  950. m_bAutoUnlockAccount = false;
  952. break;
  954. }
  956. /*
  957.  * Notify the result to player
  958.  */
  959. _VerifyAccount_ToPlayer( nQueryResult, pReturn->nLeftTime );
  961. SAFE_RELEASE( pRetBuffer );
  962. m_theDataQueue[enumOwnerAccSvr].Detach( s2c_accountlogin );
  964. return nNextTask;
  965. }
  967. return enumRepeat;
  968. }
  970. bool CGamePlayer::_VerifyAccount_ToPlayer( UINT nQueryResult, unsigned long nLeftTime)
  971. {
  972. KLoginAccountInfo lai;
  974. ZeroMemory( &lai, sizeof( KLoginAccountInfo ) );
  976. /*
  977.  * Account
  978.  */
  979. size_t used = sizeof( lai.Account );
  980. used = ( used > m_sAccountName.length() ) ? m_sAccountName.length() : ( used - 1 );
  982. memcpy( lai.Account, m_sAccountName.c_str(), used );
  983. lai.Account[used] = '';
  985. /*
  986.  * Password
  987.  */
  988. used = sizeof( lai.Password.szPassword );
  989. used = ( used > m_sPassword.length() ) ? m_sPassword.length() : ( used - 1 );
  991. memcpy( lai.Password.szPassword, m_sPassword.c_str(), used );
  992. lai.Password.szPassword[used] = '';
  994. lai.nLeftTime = nLeftTime;
  996. /*
  997.  * The other info
  998.  */
  999. lai.Param = nQueryResult;
  1001. lai.Size = sizeof( lai );
  1003. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  1005. BYTE *pData = const_cast< BYTE * >( pBuffer->GetBuffer() );
  1007. BYTE bProtocol = s2c_login;
  1008. size_t sizeProtocol = sizeof( BYTE );
  1009. memcpy( pData, &bProtocol, sizeProtocol );
  1010. memcpy( pData + sizeProtocol, ( BYTE * )( &lai ), sizeof( lai ) );
  1012. m_pPlayerServer->SendData( m_lnIdentityID, pData, ( sizeof( KLoginAccountInfo ) + sizeof( BYTE )/* protocol id */ ) );
  1014. pBuffer->Release();
  1016. return true;
  1017. }
  1019. UINT CGamePlayer::QueryRoleList()
  1020. {
  1021. #ifdef CONSOLE_DEBUG
  1022. cprintf( "CGamePlayer::QueryRoleList...n" );
  1023. #endif
  1025. const size_t lenAN = strlen( m_sAccountName.c_str() );
  1026. const size_t lenPL = lenAN + sizeof( TProcessData );
  1028. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  1030. TProcessData *pPlayerList = reinterpret_cast< TProcessData * >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  1032. ASSERT( pPlayerList );
  1034. pPlayerList->nProtoId = c2s_roleserver_getrolelist;
  1035. pPlayerList->nDataLen = lenAN + 1;
  1036. pPlayerList->ulIdentity = m_lnIdentityID;
  1038. pPlayerList->pDataBuffer[0] = s_nRoleListCount;
  1040. memcpy( &pPlayerList->pDataBuffer[1], m_sAccountName.c_str(), lenAN );
  1041. pPlayerList->pDataBuffer[lenAN + 1] = '';
  1043. m_theDataQueue[enumOwnerRoleSvr].Empty();
  1045. m_pDBRoleClient->SendPackToServer( ( const void * )pPlayerList, lenPL );
  1047. SAFE_RELEASE( pBuffer );
  1049. return enumToNextTask;
  1050. }
  1052. UINT CGamePlayer::ProcessRoleList()
  1053. {
  1054. #ifdef CONSOLE_DEBUG
  1055. cprintf( "CGamePlayer::ProcessRoleList...n" );
  1056. #endif
  1058. CBuffer *pRetBuffer = m_theDataQueue[enumOwnerRoleSvr].Attach( s2c_roleserver_getrolelist_result );
  1060. if ( pRetBuffer )
  1061. {
  1062. UINT nNextTask = enumError;
  1064. const TProcessData *pPD = ( const TProcessData * )pRetBuffer->GetBuffer();
  1066. int nRoleCount = CPackager::Peek( ( const char * )pPD->pDataBuffer );
  1068. #ifdef CONSOLE_DEBUG
  1069. cprintf( "CGamePlayer::ProcessRoleList find %d role in listn", nRoleCount );
  1070. #endif
  1072. if ( nRoleCount >= 0 )
  1073. {
  1074. m_theDataQueue[enumOwnerPlayer].Empty();
  1076. m_pPlayerServer->SendData( m_lnIdentityID, pRetBuffer->GetBuffer(), pRetBuffer->GetUsed() );
  1078. nNextTask = enumSelAddDelRole;
  1079. }
  1081. SAFE_RELEASE( pRetBuffer );
  1082. m_theDataQueue[enumOwnerRoleSvr].Detach( s2c_roleserver_getrolelist_result );
  1084. return nNextTask;
  1085. }
  1087. return enumRepeat;
  1088. }
  1090. UINT CGamePlayer::SelAddDelRole()
  1091. {
  1092. CBuffer *pRetBuffer = NULL;
  1094. #ifdef CONSOLE_DEBUG
  1095. cprintf( "CGamePlayer::SelAddDelRole...n" );
  1096. #endif
  1098. /*
  1099.  * Select a role
  1100.  */
  1101. pRetBuffer = m_theDataQueue[enumOwnerPlayer].Attach( c2s_dbplayerselect );
  1103. if ( pRetBuffer )
  1104. {
  1105. UINT nNextTask = enumError;
  1107. const tagDBSelPlayer *pDSPC = ( const tagDBSelPlayer * )pRetBuffer->GetBuffer();
  1109. #ifdef CONSOLE_DEBUG
  1110. cprintf( "CGamePlayer::SelAddDelRole Select a role from listn" );
  1111. #endif
  1113. if ( _QueryRoleInfo_ToDBRole( pDSPC->szRoleName ) )
  1114. {
  1115. nNextTask = enumLoginSelectRole;
  1116. }
  1118. SAFE_RELEASE( pRetBuffer );
  1119. m_theDataQueue[enumOwnerPlayer].Detach( c2s_dbplayerselect );
  1121. return nNextTask;
  1122. }
  1124. /*
  1125.  * Create a role
  1126.  */
  1127. pRetBuffer = m_theDataQueue[enumOwnerPlayer].Attach( c2s_newplayer );
  1129. if ( pRetBuffer )
  1130. {
  1131. UINT nNextTask = enumError;
  1133. const TProcessData *pCRPD = ( const TProcessData * )pRetBuffer->GetBuffer();
  1135. const NEW_PLAYER_COMMAND *pNPC = ( const NEW_PLAYER_COMMAND * )( pCRPD->pDataBuffer );
  1137. ASSERT( pNPC );
  1139. char szRoleName[NAME_LEN];
  1140. size_t namelen = pRetBuffer->GetUsed() - sizeof( TProcessData );
  1142. namelen = ( namelen < 31 ) ? namelen : 31;
  1144. memcpy( szRoleName, pNPC->m_szName, namelen );
  1145. szRoleName[namelen] = '';
  1147. #ifdef CONSOLE_DEBUG
  1148. cprintf( "CGamePlayer::SelAddDelRole Create a role [Name : %s]n", szRoleName );
  1149. #endif
  1150. m_theDataQueue[enumOwnerRoleSvr].Empty();
  1152. if ( _CreateNewPlayer_ToDBRole( ( const char * )szRoleName, 
  1153. pNPC->m_btRoleNo, 
  1154. pNPC->m_btSeries,
  1155. pNPC->m_NativePlaceId ) )
  1156. {
  1157. nNextTask = enumLoginCreateRole;
  1158. }
  1160. SAFE_RELEASE( pRetBuffer );
  1161. m_theDataQueue[enumOwnerPlayer].Detach( c2s_newplayer );
  1163. return nNextTask;
  1164. }
  1166. /*
  1167.  * Delete a role
  1168.  */
  1169. pRetBuffer = m_theDataQueue[enumOwnerPlayer].Attach( c2s_roleserver_deleteplayer );
  1171. if ( pRetBuffer )
  1172. {
  1173. UINT nNextTask = enumError;
  1175. #ifdef CONSOLE_DEBUG
  1176. cprintf( "CGamePlayer::SelAddDelRole Del a role in listn" );
  1177. #endif
  1178. m_theDataQueue[enumOwnerRoleSvr].Empty();
  1180. if ( _DeleteRole_ToDBRole( pRetBuffer->GetBuffer(), pRetBuffer->GetUsed() ) )
  1181. {
  1182.             nNextTask = enumToNextTask;
  1183. }
  1185. SAFE_RELEASE( pRetBuffer );
  1186. m_theDataQueue[enumOwnerPlayer].Detach( c2s_roleserver_deleteplayer );
  1188. if ( enumToNextTask != nNextTask )
  1189. {
  1190. tagNewDelRoleResponse ndrr;
  1191. ndrr.cProtocol = s2c_rolenewdelresponse;
  1192. ndrr.szRoleName[0] = '';
  1193. ndrr.bSucceeded = false;
  1195. m_pPlayerServer->SendData( m_lnIdentityID, ( const void * )&ndrr, sizeof( tagNewDelRoleResponse ) );
  1197. nNextTask = enumSelAddDelRole;
  1198. }
  1200. return nNextTask;
  1201. }
  1203. return enumRepeat;
  1204. }
  1206. UINT CGamePlayer::DelRole_WaitForVerify()
  1207. {
  1208. #ifdef CONSOLE_DEBUG
  1209. cprintf( "CGamePlayer::DelRole_WaitForVerify...n" );
  1210. #endif
  1211. CBuffer *pRetBuffer = m_theDataQueue[enumOwnerAccSvr].Attach( s2c_accountlogin );
  1212.     
  1213.     if (pRetBuffer)
  1214.     {
  1215. UINT nNextTask = enumError;
  1217. KAccountUserReturnExt* pReturn = ( KAccountUserReturnExt * )( pRetBuffer->GetBuffer() + 1/* size of a protocol byte */ );
  1219. int nResult = pReturn->nReturn;
  1221. if (nResult == ACTION_SUCCESS)
  1222.         {
  1223.             const char *pRoleName = m_sDelRoleName.c_str();
  1224.         
  1225.             const size_t lenRN = strlen( pRoleName );
  1226.         const size_t lenRI = sizeof( TProcessData ) - 1 + lenRN;
  1227.         
  1228.         CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  1229.         
  1230.         TProcessData *pRoleInfo = reinterpret_cast< TProcessData * >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  1231.         
  1232.         ASSERT( pRoleInfo );
  1233.         
  1234.         pRoleInfo->nProtoId = c2s_roleserver_deleteplayer;
  1235.         pRoleInfo->nDataLen = lenRN;
  1236.         pRoleInfo->ulIdentity = m_lnIdentityID;
  1237.         
  1238.         memcpy( &pRoleInfo->pDataBuffer[0], pRoleName, lenRN );
  1239.         pRoleInfo->pDataBuffer[lenRN] = '';
  1240.         
  1241.         m_pDBRoleClient->SendPackToServer( ( const void * )pRoleInfo, lenRI );
  1242.         
  1243.         SAFE_RELEASE( pBuffer );
  1244.         
  1245.             nNextTask = enumLoginDeleteRole;
  1246.         }
  1247.         else
  1248.         {
  1249.             tagNewDelRoleResponse ndrr;
  1250.             ndrr.cProtocol = s2c_rolenewdelresponse;
  1251.             ndrr.szRoleName[0] = '';
  1252.             ndrr.bSucceeded = false;
  1254.             m_pPlayerServer->SendData( m_lnIdentityID, ( const void * )&ndrr, sizeof( tagNewDelRoleResponse ) );
  1256.             nNextTask = enumSelAddDelRole;  // 表示这次的动作完成，进入下一个等待流程
  1257.         }
  1259. SAFE_RELEASE( pRetBuffer );
  1260. m_theDataQueue[enumOwnerAccSvr].Detach( s2c_accountlogin );
  1262.         return nNextTask;
  1263.     }
  1264. return enumRepeat;
  1267. }
  1270. UINT CGamePlayer::WaitForCreateResult()
  1271. {
  1272. #ifdef CONSOLE_DEBUG
  1273. cprintf( "CGamePlayer::WaitForCreateResult...n" );
  1274. #endif
  1276. CBuffer *pRetBuffer = m_theDataQueue[enumOwnerRoleSvr].Attach( s2c_roleserver_createrole_result );
  1278. if ( pRetBuffer )
  1279. {
  1280. UINT nNextTask = enumError;
  1282. TProcessData *pPD = ( TProcessData * )pRetBuffer->GetBuffer();
  1284. ASSERT( pPD );
  1286. char cResult = pPD->pDataBuffer[0];
  1288. tagNewDelRoleResponse ndrr;
  1289. ndrr.cProtocol = s2c_rolenewdelresponse;
  1290. ndrr.szRoleName[0] = '';
  1291. ndrr.bSucceeded = false;
  1293. #ifdef CONSOLE_DEBUG
  1294. cprintf( "CGamePlayer::WaitForCreateResult %sn", ( 1 == cResult ) ? "Successful" : "Failed" );
  1295. #endif
  1297. switch ( cResult )
  1298. {
  1299. case 1: // Successed
  1301. ndrr.bSucceeded = true;
  1303. m_pPlayerServer->SendData( m_lnIdentityID, ( const void * )&ndrr, sizeof( tagNewDelRoleResponse ) );
  1305. nNextTask = enumToNextTask;
  1306. break;
  1308. //case -1: // Failed
  1309. //case -2: // Have exist
  1310. default:
  1312. ndrr.bSucceeded = false;
  1314. m_pPlayerServer->SendData( m_lnIdentityID, ( const void * )&ndrr, sizeof( tagNewDelRoleResponse ) );
  1316. nNextTask = enumSelAddDelRole;
  1317. break;
  1318. }
  1320. SAFE_RELEASE( pRetBuffer );
  1321. m_theDataQueue[enumOwnerRoleSvr].Detach( s2c_roleserver_createrole_result );
  1323. return nNextTask;
  1324. }
  1326. return enumRepeat;
  1327. }
  1329. UINT CGamePlayer::WaitForDeleteResult()
  1330. {
  1331. #ifdef CONSOLE_DEBUG
  1332. cprintf( "CGamePlayer::WaitForDeleteResultn" );
  1333. #endif
  1335. CBuffer *pRetBuffer = m_theDataQueue[enumOwnerRoleSvr].Attach( s2c_roleserver_deleterole_result );
  1337. if ( pRetBuffer )
  1338. {
  1339. UINT nNextTask = enumError;
  1341. TProcessData *pPD = ( TProcessData * )pRetBuffer->GetBuffer();
  1343. ASSERT( pPD );
  1345. char cResult = pPD->pDataBuffer[0];
  1347. tagNewDelRoleResponse ndrr;
  1348. ndrr.cProtocol = s2c_rolenewdelresponse;
  1349. ndrr.szRoleName[0] = '';
  1350. ndrr.bSucceeded = false;
  1352. #ifdef CONSOLE_DEBUG
  1353. cprintf( "CGamePlayer::WaitForDeleteResult %sn", ( 1 == cResult ) ? "Successful" : "Failed" );
  1354. #endif
  1356. switch ( cResult )
  1357. {
  1358. case 1: // Successed
  1360. ndrr.bSucceeded = true;
  1362. m_pPlayerServer->SendData( m_lnIdentityID, ( const void * )&ndrr, sizeof( tagNewDelRoleResponse ) );
  1364. nNextTask = enumSelAddDelRole;
  1365. break;
  1367. //case -1: // Failed
  1368. //case -2: // Have exist
  1369. default:
  1371. ndrr.bSucceeded = false;
  1373. m_pPlayerServer->SendData( m_lnIdentityID, ( const void * )&ndrr, sizeof( tagNewDelRoleResponse ) );
  1375. nNextTask = enumSelAddDelRole;
  1376. break;
  1377. }
  1379. SAFE_RELEASE( pRetBuffer );
  1380. m_theDataQueue[enumOwnerRoleSvr].Detach( s2c_roleserver_deleterole_result );
  1382. return nNextTask;
  1383. }
  1385. return enumRepeat;
  1386. }
  1388. bool CGamePlayer::_QueryRoleInfo_ToDBRole( const char *pRoleName )
  1389. {
  1390. if ( NULL == pRoleName || '' == pRoleName[0] )
  1391. {
  1392. return false;
  1393. }
  1395. const size_t lenRN = strlen( pRoleName );
  1396. const size_t lenRI = sizeof( TProcessData ) - 1 + lenRN;
  1398. CBuffer *pBuffer = m_theGlobalAllocator.Allocate();
  1400. TProcessData *pRoleInfo = reinterpret_cast< TProcessData * >( const_cast< BYTE * >( pBuffer->GetBuffer() ) );
  1402. ASSERT( pRoleInfo );
  1404. pRoleInfo->nProtoId = c2s_roleserver_getroleinfo;
  1405. pRoleInfo->nDataLen = lenRN;
  1406. pRoleInfo->ulIdentity = m_lnIdentityID;
  1408. memcpy( &pRoleInfo->pDataBuffer[0], pRoleName, lenRN );
  1409. pRoleInfo->pDataBuffer[lenRN] = '';
  1411. m_pDBRoleClient->SendPackToServer( ( const void * )pRoleInfo, lenRI );
  1413. SAFE_RELEASE( pBuffer );
  1415. return true;
  1416. }
  1418. bool CGamePlayer::_CreateNewPlayer_ToDBRole( const char *pRoleName, 
  1419. int nRoleSex /* male or female */, 
  1420. int nRoleClass,
  1421. unsigned short nMapID )
  1422. {
  1423. if ( NULL == pRoleName || '' == pRoleName[0] )
  1424. {
  1425. return false;
  1426. }
  1428. size_t datalength = 0;
  1430. CPlayerCreator::ROLEPARAM RP;
  1432. int nMinLen = strlen( pRoleName );
  1433. nMinLen = nMinLen > sizeof( RP.szName ) ? sizeof( RP.szName ) : nMinLen;
  1434. memcpy( RP.szName, pRoleName, nMinLen );
  1435. RP.szName[nMinLen] = '';
  1437. nMinLen = m_sAccountName.size();
  1438. nMinLen = nMinLen > sizeof( RP.szAccName ) ? sizeof( RP.szAccName ) : nMinLen;
  1439. memcpy( RP.szAccName, m_sAccountName.c_str(), nMinLen );
  1440. RP.szAccName[nMinLen] = '';
  1442. RP.nSex = nRoleSex;
  1443. RP.nSeries = nRoleClass;
  1444. RP.nMapID = nMapID;
  1446. const TRoleData *pRoleData = m_thePlayerCreator.GetRoleData( datalength, &RP );
  1448. if ( pRoleData && datalength )
  1449. {
  1450. CBuffer *pData = m_theGlobalAllocator.Allocate();
  1452. TProcessData *pPD = reinterpret_cast< TProcessData * >( const_cast< BYTE * >( pData->GetBuffer() ) );
  1454. pPD->nProtoId = c2s_roleserver_createroleinfo;
  1455. pPD->ulIdentity = m_lnIdentityID;
  1457. pPD->pDataBuffer[0] = 1; // Create successed
  1458. pPD->nDataLen = datalength + 1 /* sizeof( pPD->pDataBuffer[0] ) */;
  1459. memcpy( &pPD->pDataBuffer[1], pRoleData, datalength );
  1461. /*
  1462.  * Send a role-info to role dbserver
  1463.  */
  1464. size_t nRoleInfoLength = datalength + sizeof( TProcessData );
  1466. m_thePackager.AddData( c2s_roleserver_createroleinfo,
  1467. ( const BYTE * )pPD,
  1468. nRoleInfoLength );
  1470. /*
  1471.  * For create a role
  1472.  */
  1473. m_theDataQueue[enumOwnerRoleSvr].AddData( s2c_roleserver_getroleinfo_result, 
  1474. ( const BYTE * )pPD,
  1475. nRoleInfoLength );
  1477. SAFE_RELEASE( pData );
  1479. CBuffer *pPack = m_thePackager.GetHeadPack( c2s_roleserver_createroleinfo );
  1481. while ( pPack )
  1482. {
  1483. m_pDBRoleClient->SendPackToServer( pPack->GetBuffer(), pPack->GetUsed() );
  1485. SAFE_RELEASE( pPack );
  1487. pPack = m_thePackager.GetNextPack( c2s_roleserver_createroleinfo );
  1488. }
  1490. SAFE_RELEASE( pPack );
  1492. m_thePackager.DelData( c2s_roleserver_createroleinfo );
  1494. return true;
  1495. }
  1497. return false;
  1498. }
  1500. UINT CGamePlayer::_DeleteRole_ToDBRole( const void *pData, size_t dataLength )
  1501. {
  1502. tagDBDelPlayer *pDBDP = ( tagDBDelPlayer * )pData;
  1504. if ( NULL == pData || 0 == dataLength )
  1505. {
  1506. return false;
  1507. }
  1509. const char *pAccountName = pDBDP->szAccountName;
  1510. const char *pPassword = pDBDP->Password.szPassword;
  1511. const char *pRoleName = pDBDP->szRoleName;
  1513. if ( !pAccountName || !pPassword || !pRoleName )
  1514. {
  1515. return false;
  1516. }
  1518.     
  1519. if (m_sAccountName.compare( pAccountName ) != 0)
  1520.     {
  1521.         return false;
  1522.     }
  1524.     m_sSuperPassword = pPassword ? pPassword : "";
  1525.     m_sDelRoleName   = pRoleName ? pRoleName : ""; 
  1526.     m_bUseSuperPassword = true;
  1527.     
  1528. return true;
  1529. }
  1531. UINT CGamePlayer::ProcessRoleInfo()
  1532. {
  1533. #ifdef CONSOLE_DEBUG
  1534. cprintf( "CGamePlayer::ProcessRoleInfo...n" );
  1535. #endif
  1537. CBuffer *pRetBuffer = m_theDataQueue[enumOwnerRoleSvr].Attach( s2c_roleserver_getroleinfo_result );
  1539. if ( pRetBuffer )
  1540. {
  1541. UINT nNextTask = enumError;
  1543. TProcessData *pPA = ( TProcessData * )pRetBuffer->GetBuffer();
  1545. ASSERT( m_lnIdentityID == pPA->ulIdentity );
  1547. char cResult = pPA->pDataBuffer[0];
  1549. #ifdef CONSOLE_DEBUG
  1550. cprintf( "CGamePlayer::ProcessRoleInfo Send info to gameservern" );
  1551. #endif
  1552. m_nAttachServerID = -1;
  1554. if ( 1 == cResult && _SyncRoleInfo_ToGameServer( ( const void * )( &pPA->pDataBuffer[1] ), pPA->nDataLen-1 ) )
  1555. {
  1556. nNextTask = enumToNextTask;
  1557. }
  1558. else
  1559. {
  1560. tagNotifyPlayerLogin npl;
  1562. memset( &npl, 0, sizeof( tagNotifyPlayerLogin ) );
  1564. npl.cProtocol = s2c_notifyplayerlogin;
  1566. m_pPlayerServer->SendData( m_lnIdentityID, ( const void * )&npl, sizeof( tagNotifyPlayerLogin ) );
  1567. }
  1569. SAFE_RELEASE( pRetBuffer );
  1570. m_theDataQueue[enumOwnerRoleSvr].Detach( s2c_roleserver_getroleinfo_result );
  1572. return nNextTask;
  1573. }
  1575. return enumRepeat;
  1576. }
  1578. bool CGamePlayer::_SyncRoleInfo_ToGameServer( const void *pData, size_t dataLength )
  1579. {
  1580. bool ok = false;
  1582. ASSERT( pData );
  1584. const TRoleData *pRoleData = ( const TRoleData * )( pData );
  1586. IGServer *pGServer = NULL;
  1587. if (pRoleData->BaseInfo.cUseRevive)
  1588. pGServer = CGameServer::QueryServer( pRoleData->BaseInfo.irevivalid );
  1589. else
  1590. pGServer = CGameServer::QueryServer( pRoleData->BaseInfo.ientergameid );
  1592. if ( pGServer )
  1593. {
  1594. ASSERT( pRoleData->BaseInfo.szName[0] != '' );
  1596. CGamePlayer::Add( ( const char * )pRoleData->BaseInfo.szName,
  1597. ( IPlayer * )this );
  1599. pGServer->Attach( m_sAccountName.c_str() );
  1601. m_nAttachServerID = pGServer->GetID();
  1603. m_theDataQueue[enumOwnerPlayer].Empty();
  1605. ok = pGServer->DispatchTask( CGameServer::enumSyncRoleInfo, pData, dataLength, max(m_nExtPoint, 0));
  1606. m_nExtPoint = -1; //用完就清掉
  1607. }
  1609. return ok;
  1610. }
  1612. UINT CGamePlayer::WaitForGameSvrPermit()
  1613. {
  1614. #ifdef CONSOLE_DEBUG
  1615. cprintf( "CGamePlayer::WaitForGameSvrPermit...n" );
  1616. #endif
  1618. CBuffer *pRetBuffer = m_theDataQueue[enumOwnerPlayer].Attach( s2c_notifyplayerlogin );
  1620. if ( pRetBuffer && m_pPlayerServer )
  1621. {
  1622. UINT nNextTask = enumError;
  1624. tagNotifyPlayerLogin *pNPL = ( tagNotifyPlayerLogin * )pRetBuffer->GetBuffer();
  1626. #ifdef CONSOLE_DEBUG
  1627. cprintf( "CGamePlayer::WaitForGameSvrPermit Notify player to login gameservern" );
  1628. #endif
  1630. if ( pNPL->bPermit )
  1631. {
  1632. m_bAutoUnlockAccount = false;
  1634. nNextTask = enumToNextTask;
  1635. }
  1637. m_pPlayerServer->SendData( m_lnIdentityID, pRetBuffer->GetBuffer(), pRetBuffer->GetUsed() );
  1639. SAFE_RELEASE( pRetBuffer );
  1640. m_theDataQueue[enumOwnerPlayer].Detach( s2c_notifyplayerlogin );
  1642. return nNextTask;
  1643. }
  1645. return enumRepeat;
  1646. }
  1648. bool CGamePlayer::Attach( const char *pRoleName )
  1649. {
  1650. if ( pRoleName && pRoleName[0] )
  1651. {
  1652. m_sRoleName = pRoleName;
  1654. return true;
  1655. }
  1657. return false;
  1658. }
  1660. bool CGamePlayer::Add( const char *pRoleName, IPlayer *pPlayer )
  1661. {
  1662. if ( NULL == pRoleName || NULL == pPlayer || !pRoleName[0] )
  1663. {
  1664. ASSERT( FALSE );
  1666. return false;
  1667. }
  1669. if ( pPlayer )
  1670. {
  1671. CCriticalSection::Owner locker( CGamePlayer::m_csMapSP );
  1673. std::pair< stdMapSP::iterator, bool > result = 
  1674. m_sthePlayerTable.insert( stdMapSP::value_type( pRoleName, pPlayer ) );
  1676. if ( result.second )
  1677. {
  1678. return pPlayer->Attach( pRoleName );
  1679. }
  1680. }
  1682. return false;
  1683. }
  1685. bool CGamePlayer::Del( const char *pRoleName )
  1686. {
  1687. if ( !pRoleName || !pRoleName[0] )
  1688. {
  1689. return false;
  1690. }
  1692. {
  1693. CCriticalSection::Owner locker( CGamePlayer::m_csMapSP );
  1695. stdMapSP::iterator it;
  1697. if ( m_sthePlayerTable.end() != ( it = m_sthePlayerTable.find( pRoleName ) ) )
  1698. {
  1699. IPlayer *pPlayer = ( IPlayer * )( ( *it ).second );
  1701. ASSERT( pPlayer );
  1703. m_sthePlayerTable.erase( it );
  1705. return true;
  1706. }
  1707. }
  1709. return false;
  1710. }
  1712. IPlayer *CGamePlayer::Get( const char *pRoleName )
  1713. {
  1714. if ( !pRoleName )
  1715. {
  1716. return NULL;
  1717. }
  1719. CCriticalSection::Owner locker( CGamePlayer::m_csMapSP );
  1721. stdMapSP::iterator it;
  1723. if ( m_sthePlayerTable.end() != ( it = m_sthePlayerTable.find( pRoleName ) ) )
  1724. {
  1725. return ( IPlayer * )( ( *it ).second );
  1726. }
  1728. return NULL;
  1729. }