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

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

模拟服务器

开发平台：

C/C++

KSOServer.cpp：源码内容
  1. #include "StdAfx.h"
  2. #ifdef _STANDALONE
  3. #ifndef __linux
  4. #include <winsock2.h>
  5. #include <malloc.h>
  6. #else
  7. #include <unistd.h>
  8. #include <netdb.h>
  9. #include <sys/time.h>
  10. #endif
  11. #include "KWin32.h"
  12. #include "package.h"
  13. #endif
  15. #include "CRC32.h"
  16. #ifdef _STANDALONE
  17. #include "KCore.h"
  18. #include "KPlayerSet.h"
  19. #include "CRC32.c"
  20. #endif
  22. #ifndef WIN32
  23. #include <sys/types.h>
  24. #include <sys/socket.h>
  25. #include <sys/ioctl.h>
  26. #include <netinet/in.h>
  27. #include <net/if.h>
  28. #include <arpa/inet.h>
  29. #include <stdio.h>
  30. #include <string.h>
  31. #endif
  33. #define _SERVER
  35. #ifdef _STANDALONE
  36. // #ifdef WIN32
  37. // #define FAILED(x) ((x) != S_OK)
  38. // #else
  39. #define FAILED(x) ((x) <= 0)
  40. // #endif
  41. #endif
  43. #ifndef _STANDALONE
  44. #include <crtdbg.h>
  45. #include <objbase.h>
  46. #include <initguid.h>
  47. #include "Library.h"
  48. #include "inoutmac.h"
  49. #endif
  51. #include <iostream>
  52. //#include <strstream>
  54. #include "S3DBInterface.h"
  55. #include "KProtocolDef.h"
  56. #include "KProtocol.h"
  57. #include "KRelayProtocol.h"
  58. #include "KTongProtocol.h"
  60. #include "KSOServer.h"
  62. #ifndef _STANDALONE
  63. using OnlineGameLib::Win32::CBuffer;
  64. using OnlineGameLib::Win32::CLibrary;
  65. using OnlineGameLib::Win32::CCriticalSection;
  67. CLibrary g_theHeavenLibrary( "heaven.dll" );
  68. CLibrary g_theRainbowLibrary( "rainbow.dll" );
  70. OnlineGameLib::Win32::CUsesWinsock  g_SocketInit;
  71. CCriticalSection g_csFlow;
  73. #else
  75. ZMutex g_mutexFlow;
  77. #endif
  79. CPackager m_theRecv;
  80. CPackager m_theSend;
  82. #define GAME_FPS 18
  83. using namespace std;
  85. //const int KSwordOnLineSever::m_snMaxPlayerCount = 500;
  86. //const int KSwordOnLineSever::m_snPrecision = 10;
  87. const int KSwordOnLineSever::m_snMaxBuffer = 10;
  88. const int KSwordOnLineSever::m_snBufferSize = 1024 * 16;
  90. KSwordOnLineSever g_SOServer;
  92. enum PLAYER_GAME_STATUS
  93. {
  94. enumPlayerBegin = 0,
  95. enumPlayerSyncEnd,
  96. enumPlayerPlaying,
  97. enumPlayerExchangingServer,
  98. };
  100. enum PLAYER_EXCHANGE_STATUS
  101. {
  102. enumExchangeBegin = 0,
  103. enumExchangeSearchingWay,
  104. enumExchangeWaitForGameSvrRespone,
  105. enumExchangeCleaning,
  106. };
  109. int g_nTongPCSize[defTONG_PROTOCOL_CLIENT_NUM] = 
  110. {
  111. -1, // enumS2C_TONG_CREATE_SUCCESS
  112. sizeof(STONG_CREATE_FAIL_SYNC), // enumS2C_TONG_CREATE_FAIL
  113. sizeof(STONG_ADD_MEMBER_SUCCESS_SYNC), // enumS2C_TONG_ADD_MEMBER_SUCCESS
  114. sizeof(STONG_ADD_MEMBER_FAIL_SYNC), // enumS2C_TONG_ADD_MEMBER_FAIL
  115. -1, // enumS2C_TONG_HEAD_INFO
  116. -1, // enumS2C_TONG_MANAGER_INFO
  117. -1, // enumS2C_TONG_MEMBER_INFO
  118. sizeof(STONG_BE_INSTATED_SYNC), // enumS2C_TONG_BE_INSTATED
  119. sizeof(STONG_INSTATE_SYNC), // enumS2C_TONG_INSTATE
  120. sizeof(STONG_KICK_SYNC), // enumS2C_TONG_KICK
  121. sizeof(STONG_BE_KICKED_SYNC), // enumS2C_TONG_BE_KICKED
  122. sizeof(STONG_LEAVE_SYNC), // enumS2C_TONG_LEAVE
  123. sizeof(STONG_CHECK_GET_MASTER_POWER_SYNC), // enumS2C_TONG_CHECK_CHANGE_MASTER_POWER
  124. sizeof(STONG_CHANGE_MASTER_FAIL_SYNC), // enumS2C_TONG_CHANGE_MASTER_FAIL
  125. sizeof(STONG_CHANGE_AS_SYNC), // enumS2C_TONG_CHANGE_AS
  126. sizeof(STONG_CHANGE_MASTER_SYNC), // enumS2C_TONG_CHANGE_MASTER
  127. sizeof(STONG_LOGIN_DATA_SYNC), // enumS2C_TONG_LOGIN_DATA
  128. };
  132. #ifndef _STANDALONE
  133. typedef HRESULT ( __stdcall * pfnCreateClientInterface )( 
  134. REFIID riid, 
  135. void **ppv 
  136. );
  138. typedef HRESULT ( __stdcall * pfnCreateServerInterface )(
  139. REFIID riid,
  140. void **ppv
  141. );
  142. #endif
  144. #ifndef _STANDALONE
  145. void __stdcall ServerEventNotify(
  146. #else
  147. void ServerEventNotify(  
  148. #endif
  149. LPVOID lpParam,
  150. const unsigned long &ulnID,
  151. const unsigned long &ulnEventType )
  152. {
  153. #ifndef _STANDALONE
  154. CCriticalSection::Owner locker( g_csFlow );
  155. #else
  156. g_mutexFlow.lock();
  157. #endif
  158. switch( ulnEventType )
  159. {
  160. case enumClientConnectCreate:
  161. g_SOServer.SetNetStatus(ulnID, enumNetConnected);
  162. break;
  163. case enumClientConnectClose:
  164. g_SOServer.SetNetStatus(ulnID, enumNetUnconnect);
  165. break;
  166. }
  167. #ifdef _STANDALONE
  168. g_mutexFlow.unlock();
  169. #endif
  170. }
  172. #ifndef _STANDALONE
  173. void __stdcall GatewayClientEventNotify(
  174. #else
  175. void GatewayClientEventNotify(
  176. #endif
  177. LPVOID lpParam,
  178. const unsigned long &ulnEventType )
  179. {
  180. switch( ulnEventType )
  181. {
  182. case enumServerConnectCreate:
  183. break;
  184. case enumServerConnectClose:
  185. printf("GateWay lostn");
  186. g_SOServer.SetRunningStatus(FALSE);
  187. break;
  188. }
  189. }
  191. #ifndef _STANDALONE
  192. void __stdcall ChatClientEventNotify(
  193. #else
  194. void ChatClientEventNotify(
  195. #endif
  196. LPVOID lpParam,
  197. const unsigned long &ulnEventType )
  198. {
  199. switch( ulnEventType )
  200. {
  201. case enumServerConnectCreate:
  202. break;
  203. case enumServerConnectClose:
  204. printf("Chat disconnectn");
  205. break;
  206. }
  207. }
  209. #ifndef _STANDALONE
  210. void __stdcall TongClientEventNotify(
  211. #else
  212. void TongClientEventNotify(
  213. #endif
  214. LPVOID lpParam,
  215. const unsigned long &ulnEventType )
  216. {
  217. switch( ulnEventType )
  218. {
  219. case enumServerConnectCreate: // 连接建立时候的处理
  220. break;
  221. case enumServerConnectClose: // 连接段开时候的处理
  222. printf("Tong disconnectn");
  223. break;
  224. }
  225. }
  227. #ifndef _STANDALONE
  228. void __stdcall DatabaseClientEventNotify(
  229. #else
  230. void DatabaseClientEventNotify(
  231. #endif
  232. LPVOID lpParam,
  233. const unsigned long &ulnEventType )
  234. {
  235. switch( ulnEventType )
  236. {
  237. case enumServerConnectCreate:
  238. break;
  239. case enumServerConnectClose:
  240. printf("DataBase lostn");
  241. g_SOServer.SetRunningStatus(FALSE);
  242. break;
  243. }
  244. }
  246. #ifndef _STANDALONE
  247. void __stdcall TransferClientEventNotify(
  248. #else
  249. void TransferClientEventNotify(
  250. #endif
  251. LPVOID lpParam,
  252. const unsigned long &ulnEventType )
  253. {
  254. switch( ulnEventType )
  255. {
  256. case enumServerConnectCreate:
  257. break;
  258. case enumServerConnectClose:
  259. /// g_SOServer.SetRunningStatus(FALSE);
  260. break;
  261. }
  262. }
  265. KSwordOnLineSever::KSwordOnLineSever()
  266. {
  267. m_nGameLoop = 0;
  268. m_bIsRunning = TRUE;
  269. m_nServerPort = 6666;
  270. m_nGatewayPort = 5632;
  271. m_nDatabasePort = 5001;
  272. m_nTransferPort = 5003;
  273. m_nChatPort = 5004;
  274. m_nTongPort = 5005;
  275. ZeroMemory(m_szGatewayIP, sizeof(m_szGatewayIP));
  276. ZeroMemory(m_szDatabaseIP, sizeof(m_szDatabaseIP));
  277. ZeroMemory(m_szTransferIP, sizeof(m_szTransferIP));
  278. ZeroMemory(m_szChatIP, sizeof(m_szChatIP));
  279. ZeroMemory(m_szTongIP, sizeof(m_szTongIP));
  280. m_pServer = NULL;
  281. m_pGatewayClient = NULL;
  282. m_pDatabaseClient = NULL;
  283. m_pTransferClient = NULL;
  284. m_pChatClient = NULL;
  285. m_pTongClient = NULL;
  286. m_pCoreServerShell = NULL;
  287. m_pGameStatus = NULL;
  288. }
  290. KSwordOnLineSever::~KSwordOnLineSever()
  291. {
  292. }
  294. BOOL KSwordOnLineSever::Init()
  295. {
  296. /*
  297.  * Initialize class member
  298.  */
  299. m_bIsRunning = TRUE;
  300. g_SetRootPath(NULL);
  302. g_SetFilePath("\");
  303. KIniFile iniFile;
  305. iniFile.Load("ServerCfg.ini");
  306. iniFile.GetInteger("GameServer", "Port", 6666, &m_nServerPort);
  307. extern int g_nPort;
  308. if (g_nPort)
  309. m_nServerPort = g_nPort;
  310. iniFile.GetString("Gateway", "Ip", "192.168.26.1", m_szGatewayIP, sizeof(m_szGatewayIP));
  311. iniFile.GetInteger("Gateway", "Port", 5632, &m_nGatewayPort);
  312. iniFile.GetString("Database", "Ip", "192.168.22.104", m_szDatabaseIP, sizeof(m_szDatabaseIP));
  313. iniFile.GetInteger("Database", "Port", 5001, &m_nDatabasePort);
  314. iniFile.GetString("Transfer", "Ip", "192.168.22.105", m_szTransferIP, sizeof(m_szTransferIP));
  315. iniFile.GetInteger("Transfer", "Port", 5003, &m_nTransferPort);
  316. iniFile.GetString("Chat", "Ip", "192.168.22.105", m_szChatIP, sizeof(m_szChatIP));
  317. iniFile.GetInteger("Chat", "Port", 5004, &m_nChatPort);
  318. iniFile.GetString("Tong", "Ip", "192.168.22.105", m_szTongIP, sizeof(m_szTongIP));
  319. iniFile.GetInteger("Tong", "Port", 5005, &m_nTongPort);
  320. #ifdef WIN32
  321. iniFile.GetInteger("Overload", "MaxPlayer", 450, &m_nMaxPlayerCount);
  322. iniFile.GetInteger("Overload", "Precision", 20, &m_nPrecision);
  323. #else
  324. iniFile.GetInteger("Overload", "MaxPlayer", 1000, &m_nMaxPlayerCount);
  325. iniFile.GetInteger("Overload", "Precision", 200, &m_nPrecision);
  326. #endif
  328. m_nMaxPlayer = m_nMaxPlayerCount + m_nPrecision;
  330. if (m_nMaxPlayer <= 0)
  331. {
  332. cout << "Maximal player number <= 0!" << endl;
  333. return FALSE;
  334. }
  336. if (!m_pGameStatus)
  337. {
  338. m_pGameStatus = new GameStatus[m_nMaxPlayer];
  339. }
  341. // strcpy(m_szGameSvrIP, OnlineGameLib::Win32::net_ntoa(dwIp));
  343. /*
  344.  * Open this server to player
  345.  */
  346. #ifndef _STANDALONE
  347. pfnCreateServerInterface pFactroyFun = ( pfnCreateServerInterface )( g_theHeavenLibrary.GetProcAddress( "CreateInterface" ) );
  349. IServerFactory *pServerFactory = NULL;
  351. if ( pFactroyFun && SUCCEEDED( pFactroyFun( IID_IServerFactory, reinterpret_cast< void ** >( &pServerFactory ) ) ) )
  352. {
  353. pServerFactory->SetEnvironment( m_nMaxPlayer, m_nPrecision, m_snMaxBuffer, m_snBufferSize  );
  355. pServerFactory->CreateServerInterface( IID_IIOCPServer, reinterpret_cast< void ** >( &m_pServer ) );
  357. pServerFactory->Release();
  358. }
  359. else
  360. {
  361. return FALSE;
  362. }
  363. #else
  364. m_pServer = new IServer(m_nMaxPlayer, 4, 200 * 1024);
  365. #endif
  367. if (!m_pServer)
  368. {
  369. cout << "Initialization failed! Don't find a correct heaven.dll" << endl;
  370. return FALSE;
  371. }
  373. m_pServer->Startup();
  375. m_pServer->RegisterMsgFilter( reinterpret_cast< void * >( m_pServer ), ServerEventNotify );
  377. if ( FAILED( m_pServer->OpenService( INADDR_ANY, m_nServerPort ) ) )
  378. {
  379. return FALSE;
  380. }
  382. if (!GetLocalIpAddress(&m_dwIntranetIp, &m_dwInternetIp))
  383. {
  384. cout << "Can't get server ip" << endl;
  385. return FALSE;
  386. }
  387. cout << m_dwIntranetIp << " : " << m_dwInternetIp << endl;
  389. #ifndef _STANDALONE
  390. IServer *pCloneServer = NULL;
  391. m_pServer->QueryInterface( IID_IIOCPServer, ( void ** )&pCloneServer );
  392. #else 
  393. IServer *pCloneServer = m_pServer;
  394. #endif
  395. /*
  396.  * Init GameWorld
  397.  */
  398. if (m_pCoreServerShell == NULL)
  399. m_pCoreServerShell = ::CoreGetServerShell();
  401. if (m_pCoreServerShell == NULL)
  402. {
  403. cout << "Failed to Create CoreShell." << endl;
  404. return FALSE;
  405. }
  407. m_pCoreServerShell->OperationRequest(SSOI_LAUNCH, (unsigned int)pCloneServer, 0);
  409. /*
  410.  * Connect to database
  411.  */
  412. #ifndef _STANDALONE
  413. pfnCreateClientInterface pClientFactroyFun = ( pfnCreateClientInterface )( g_theRainbowLibrary.GetProcAddress( "CreateInterface" ) );
  415. IClientFactory *pClientFactory = NULL;
  417. if ( pClientFactroyFun && SUCCEEDED( pClientFactroyFun( IID_IClientFactory, reinterpret_cast< void ** >( &pClientFactory ) ) ) )
  418. {
  419. pClientFactory->SetEnvironment( 1024 * 128 );
  421. pClientFactory->CreateClientInterface( IID_IESClient, reinterpret_cast< void ** >( &m_pDatabaseClient ) );
  423. pClientFactory->Release();
  424. }
  425. else
  426. {
  427. return FALSE;
  428. }
  429. #else
  430. // net_buffer = new ZBuffer(20240000, 400);
  431. m_pDatabaseClient = new IClient(6000*1024, 6000*1024);
  432. #endif
  433. if ( !m_pDatabaseClient )
  434. {
  435. cout << "Initialization failed! Don't find a correct rainbow.dll" << endl;
  437. return FALSE;
  438. }
  439. if (FAILED(m_pDatabaseClient->Startup()))
  440. {
  441. cout << "Can't not startup database client service!" << endl;
  442. return FALSE;
  443. }
  444. cout << "Database IP : " << m_szDatabaseIP << " - Port : " << m_nDatabasePort << endl;
  446. m_pDatabaseClient->RegisterMsgFilter( reinterpret_cast< void * >( m_pDatabaseClient ), DatabaseClientEventNotify );
  448. if ( FAILED( m_pDatabaseClient->ConnectTo( m_szDatabaseIP, m_nDatabasePort ) ) )
  449. {
  450. cout << "Connect to database is failed!" << endl;
  451. return FALSE;
  452. }
  454. cout << "Connect database successful!" << endl;
  456. /*
  457.  * Connect to transfer
  458.  */
  459. #ifndef _STANDALONE
  460. pClientFactroyFun = ( pfnCreateClientInterface )( g_theRainbowLibrary.GetProcAddress( "CreateInterface" ) );
  462. pClientFactory = NULL;
  464. if ( pClientFactroyFun && SUCCEEDED( pClientFactroyFun( IID_IClientFactory, reinterpret_cast< void ** >( &pClientFactory ) ) ) )
  465. {
  466. pClientFactory->SetEnvironment( 1024 * 512 );
  468. pClientFactory->CreateClientInterface( IID_IESClient, reinterpret_cast< void ** >( &m_pTransferClient ) );
  470. pClientFactory->Release();
  471. }
  472. else
  473. {
  474. return FALSE;
  475. }
  476. #else
  477. m_pTransferClient = new IClient(6000*1024, 6000*1024);
  478. #endif
  479. if ( !m_pTransferClient )
  480. {
  481. cout << "Initialization failed! Don't find a correct rainbow.dll" << endl;
  483. return FALSE;
  484. }
  486. if (FAILED(m_pTransferClient->Startup()))
  487. {
  488. cout << "Can't not startup transfer client service!" << endl;
  489. return FALSE;
  490. }
  492. cout << "Transfer IP : " << m_szTransferIP << " - Port : " << m_nTransferPort << endl;
  494. m_pTransferClient->RegisterMsgFilter( reinterpret_cast< void * >( m_pTransferClient ), TransferClientEventNotify );
  496. if ( FAILED( m_pTransferClient->ConnectTo( m_szTransferIP, m_nTransferPort ) ) )
  497. {
  498. cout << "Connect to transfer is failed!" << endl;
  499. if (m_pTransferClient)
  500. {
  501. m_pTransferClient->Shutdown();
  502. m_pTransferClient->Cleanup();
  503. m_pTransferClient->Release();
  504. m_pTransferClient = NULL;
  505. }
  506. }
  507. else
  508. {
  509. cout << "Connect transfer successful!" << endl;
  510. }
  512. /*
  513.  * Connect to chat
  514.  */
  515. #ifndef _STANDALONE
  516. pClientFactroyFun = ( pfnCreateClientInterface )( g_theRainbowLibrary.GetProcAddress( "CreateInterface" ) );
  518. pClientFactory = NULL;
  520. if ( pClientFactroyFun && SUCCEEDED( pClientFactroyFun( IID_IClientFactory, reinterpret_cast< void ** >( &pClientFactory ) ) ) )
  521. {
  522. pClientFactory->SetEnvironment( 1024 * 1024 * 4 );
  524. pClientFactory->CreateClientInterface( IID_IESClient, reinterpret_cast< void ** >( &m_pChatClient ) );
  526. pClientFactory->Release();
  527. }
  528. else
  529. {
  530. return FALSE;
  531. }
  532. #else
  533. m_pChatClient = new IClient(6000*1024, 6000*1024);
  534. #endif
  536. if ( !m_pChatClient )
  537. {
  538. cout << "Initialization failed! Don't find a correct rainbow.dll" << endl;
  540. return FALSE;
  541. }
  543. if (FAILED(m_pChatClient->Startup()))
  544. {
  545. cout << "Can't not startup chat client service!" << endl;
  546. return FALSE;
  547. }
  549. cout << "Chat IP : " << m_szChatIP << " - Port : " << m_nChatPort << endl;
  551. m_pChatClient->RegisterMsgFilter( reinterpret_cast< void * >( m_pChatClient ), ChatClientEventNotify );
  553. if ( FAILED( m_pChatClient->ConnectTo( m_szChatIP, m_nChatPort ) ) )
  554. {
  555. cout << "Connect to chat is failed!" << endl;
  556. if (m_pChatClient)
  557. {
  558. m_pChatClient->Shutdown();
  559. m_pChatClient->Cleanup();
  560. m_pChatClient->Release();
  561. m_pChatClient = NULL;
  562. }
  563. }
  564. else
  565. {
  566. cout << "Connect chat successful!" << endl;
  567. }
  569. //------------------------ Connect to tong ----------------------------
  570. #ifndef _STANDALONE
  571. pClientFactroyFun = ( pfnCreateClientInterface )( g_theRainbowLibrary.GetProcAddress( "CreateInterface" ) );
  572. pClientFactory = NULL;
  573. if ( pClientFactroyFun && SUCCEEDED( pClientFactroyFun( IID_IClientFactory, reinterpret_cast< void ** >( &pClientFactory ) ) ) )
  574. {
  575. pClientFactory->SetEnvironment( 1024 * 1024 * 4 );
  576. pClientFactory->CreateClientInterface( IID_IESClient, reinterpret_cast< void ** >( &m_pTongClient ) );
  577. pClientFactory->Release();
  578. }
  579. else
  580. {
  581. return FALSE;
  582. }
  583. #else
  584. m_pTongClient = new IClient(6000*1024, 6000*1024);
  585. #endif
  587. if ( !m_pTongClient )
  588. {
  589. cout << "Initialization failed! Don't find a correct rainbow.dll" << endl;
  590. return FALSE;
  591. }
  593. if (FAILED(m_pTongClient->Startup()))
  594. {
  595. cout << "Can't not startup tong client service!" << endl;
  596. return FALSE;
  597. }
  599. cout << "Tong IP : " << m_szTongIP << " - Port : " << m_nTongPort << endl;
  601. m_pTongClient->RegisterMsgFilter( reinterpret_cast< void * >( m_pTongClient ), TongClientEventNotify );
  603. if ( FAILED( m_pTongClient->ConnectTo( m_szTongIP, m_nTongPort ) ) )
  604. {
  605. cout << "Connect to tong is failed!" << endl;
  606. if (m_pTongClient)
  607. {
  608. m_pTongClient->Shutdown();
  609. m_pTongClient->Cleanup();
  610. m_pTongClient->Release();
  611. m_pTongClient = NULL;
  612. }
  613. }
  614. else
  615. {
  616. cout << "Connect tong successful!" << endl;
  617. }
  618. //------------------------ Connect to tong end ----------------------------
  620. /*
  621.  * Connect to gateway
  622.  */
  623. #ifndef _STANDALONE
  624. pClientFactroyFun = ( pfnCreateClientInterface )( g_theRainbowLibrary.GetProcAddress( "CreateInterface" ) );
  626. pClientFactory = NULL;
  628. if ( pClientFactroyFun && SUCCEEDED( pClientFactroyFun( IID_IClientFactory, reinterpret_cast< void ** >( &pClientFactory ) ) ) )
  629. {
  630. pClientFactory->SetEnvironment( 1024 * 1024 );
  632. pClientFactory->CreateClientInterface( IID_IESClient, reinterpret_cast< void ** >( &m_pGatewayClient ) );
  634. pClientFactory->Release();
  635. }
  636. else
  637. {
  638. return FALSE;
  639. }
  640. #else
  641. m_pGatewayClient = new IClient(6000*1024, 6000*1024);
  642. #endif
  643. if ( !m_pGatewayClient )
  644. {
  645. cout << "Initialization failed! Don't find a correct rainbow.dll" << endl;
  647. return FALSE;
  648. }
  650. if ( FAILED(m_pGatewayClient->Startup()))
  651. {
  652. cout << "Can't not startup gateway client service!" << endl;
  653. return FALSE;
  654. }
  656. cout << "Gateway IP : " << m_szGatewayIP << " - Port : " << m_nGatewayPort << endl;
  658. m_pGatewayClient->RegisterMsgFilter( reinterpret_cast< void * >( m_pGatewayClient ), GatewayClientEventNotify );
  660. if ( FAILED( m_pGatewayClient->ConnectTo( m_szGatewayIP, m_nGatewayPort ) ) )
  661. {
  662. cout << "Connect to gateway is failed!" << endl;
  663. return FALSE;
  664. }
  666. cout << "Connect gateway successful!" << endl;
  668. /*
  669.  * Game timer start
  670.  */
  671. m_Timer.Start();
  672. m_nGameLoop = 0;
  673. return TRUE;
  674. }
  676. void KSwordOnLineSever::Release()
  677. {
  678. #ifndef _STANDALONE
  679. CCriticalSection::Owner locker( g_csFlow );
  680. #else
  681. g_mutexFlow.lock();
  682. #endif
  683. if (m_pServer)
  684. {
  685. // Close service for no one can login again
  686. m_pServer->CloseService();
  687. // Regist callback function to null
  688. m_pServer->RegisterMsgFilter( reinterpret_cast< void * >( m_pServer ), NULL );
  689. // Shut down all client and save their data.
  690. const char *pChar = NULL;
  692. ExitAllPlayer();
  693. }
  695. if (m_pCoreServerShell)
  696. {
  697. m_pCoreServerShell->Release();
  698. m_pCoreServerShell = NULL;
  699. }
  701. if (m_pGameStatus)
  702. {
  703. delete [] m_pGameStatus;
  704. m_pGameStatus = NULL;
  705. }
  707. if (m_pServer)
  708. {
  709. m_pServer->Cleanup();
  710. m_pServer->Release();
  711. #ifndef _STANDALONE
  712. m_pServer = NULL;
  713. #else
  714. delete m_pServer; m_pServer = NULL;
  715. #endif
  716. }
  718. if (m_pGatewayClient)
  719. {
  720. m_pGatewayClient->Shutdown();
  721. m_pGatewayClient->Cleanup();
  722. m_pGatewayClient->Release();
  723. m_pGatewayClient = NULL;
  724. }
  726. if (m_pDatabaseClient)
  727. {
  728. m_pDatabaseClient->Shutdown();
  729. m_pDatabaseClient->Cleanup();
  730. m_pDatabaseClient->Release();
  731. m_pDatabaseClient = NULL;
  732. }
  734. if (m_pTransferClient)
  735. {
  736. m_pTransferClient->Shutdown();
  737. m_pTransferClient->Cleanup();
  738. m_pTransferClient->Release();
  739. m_pTransferClient = NULL;
  740. }
  742. if (m_pChatClient)
  743. {
  744. m_pChatClient->Shutdown();
  745. m_pChatClient->Cleanup();
  746. m_pChatClient->Release();
  747. m_pChatClient = NULL;
  748. }
  750. if (m_pTongClient)
  751. {
  752. m_pTongClient->Shutdown();
  753. m_pTongClient->Cleanup();
  754. m_pTongClient->Release();
  755. m_pTongClient = NULL;
  756. }
  758. IP2CONNECTUNIT::iterator it;
  759. for (it = m_mapIp2TransferUnit.begin(); it != m_mapIp2TransferUnit.end(); it++)
  760. {
  761. KTransferUnit* pUnit = (*it).second;
  762. if (pUnit)
  763. {
  764. delete pUnit;
  765. pUnit = NULL;
  766. }
  767. }
  768. m_mapIp2TransferUnit.clear();
  769. #ifdef _STANDALONE
  770. // delete net_buffer;
  771. delete m_pTransferClient; m_pTransferClient = NULL;
  772. delete m_pDatabaseClient; m_pDatabaseClient = NULL;
  773. delete m_pGatewayClient; m_pGatewayClient = NULL;
  774. #endif
  775. #ifdef _STANDALONE
  776. g_mutexFlow.unlock();
  777. #endif
  778. }
  780. BOOL KSwordOnLineSever::Breathe()
  781. {
  782. if (m_pCoreServerShell && m_bIsRunning)
  783. {
  784. MessageLoop();
  785. //printf("breathe..%un", m_Timer.GetElapse());
  786. if (m_nGameLoop * 1000 <= m_Timer.GetElapse() * GAME_FPS)
  787. {
  788. MainLoop();
  789. #ifdef WIN32
  790. Sleep(0);
  791. #else
  792. usleep(0);
  793. #endif
  795. #ifdef _STANDALONE
  796. if (m_nGameLoop % (GAME_FPS * 60) == 0) //一分钟一次
  797. {
  798. extern ZPerf g_sendPerf;
  799. extern ZPerf g_recvPerf;
  800. DWORD dwElapse = m_Timer.GetElapse();
  801. printf("GameLoop= %06d, Time= %02d:%02d:%02d, Svr(S: %dK R: %dK), Clt(S: %dK R: %dK), Online= %dn",
  802. m_nGameLoop,
  803. dwElapse / (1000 * 3600),
  804. (dwElapse / (1000 * 60)) % 60,
  805. (dwElapse / 1000) % 60,
  806. m_pServer->sendPerf.total_size / 1024,
  807. m_pServer->recvPerf.total_size / 1024,
  808. g_sendPerf.total_size / 1024,
  809. g_recvPerf.total_size / 1024,
  810. PlayerSet.GetOnlinePlayerCount());
  811. }
  812. #endif
  813. }
  814. else
  815. {
  816. #ifndef __linux //SwitchToThread();
  817. Sleep(1);
  818. #else
  819. usleep(1000);
  820. #endif
  821. #ifdef _STANDALONE
  822. void DoEveryThing(IServer* pIServer);
  823. DoEveryThing(m_pServer);
  824. #endif
  825. }
  826. return TRUE;
  827. }
  828. printf("main thread exitn");
  829. return FALSE;
  830. }
  832. void KSwordOnLineSever::MessageLoop()
  833. {
  834. int i;
  835. const char* pChar = NULL;
  836. unsigned int uSize = 0;
  838. #ifndef _STANDALONE
  839. CCriticalSection::Owner locker( g_csFlow );
  840. #else
  841. g_mutexFlow.lock();
  842. #endif
  844. while(m_pGatewayClient)
  845. {
  846. pChar = (const char*)m_pGatewayClient->GetPackFromServer(uSize);
  847. if (!pChar || 0 == uSize)
  848. break;
  849. GatewayMessageProcess(pChar, uSize);
  850. }
  852. while(m_pDatabaseClient)
  853. {
  854. pChar = (const char*)m_pDatabaseClient->GetPackFromServer(uSize);
  855. if (!pChar || 0 == uSize)
  856. break;
  857. DatabaseMessageProcess(pChar, uSize);
  858. }
  860. m_pCoreServerShell->SendNetMsgToTransfer(m_pTransferClient);
  862. while(m_pTransferClient)
  863. {
  864. pChar = (const char*)m_pTransferClient->GetPackFromServer(uSize);
  865. if (!pChar || 0 == uSize)
  866. break;
  867. TransferMessageProcess(pChar, uSize);
  868. }
  870. m_pCoreServerShell->SendNetMsgToChat(m_pChatClient);
  871. while(m_pChatClient)
  872. {
  873. pChar = (const char*)m_pChatClient->GetPackFromServer(uSize);
  874. if (!pChar || 0 == uSize)
  875. break;
  876. ChatMessageProcess(pChar, uSize);
  877. }
  879. m_pCoreServerShell->SendNetMsgToTong(m_pTongClient);
  880. while(m_pTongClient)
  881. {
  882. pChar = (const char*)m_pTongClient->GetPackFromServer(uSize);
  883. if (!pChar || 0 == uSize)
  884. break;
  885. TongMessageProcess(pChar, uSize);
  886. }
  888. pChar = NULL;
  889. uSize = 0;
  890. for (i = 0; i < m_nMaxPlayer; i++)
  891. {
  892. if (enumNetUnconnect == GetNetStatus(i))
  893. continue;
  895. while(m_pServer)
  896. {
  897. pChar = (const char*)m_pServer->GetPackFromClient(i, uSize);
  898. if (!pChar || 0 == uSize)
  899. break;
  901. //printf("player msg..n");
  902. PlayerMessageProcess(i, pChar, uSize);
  903. }
  904. }
  905. #ifdef _STANDALONE
  906. g_mutexFlow.unlock();
  907. #endif
  908. }
  910. void KSwordOnLineSever::ChatMessageProcess(const char *pChar, size_t nSize)
  911. {
  912. _ASSERT( pChar && nSize);
  913. #ifndef _STANDALONE
  914. BYTE cProtocol = CPackager::Peek( pChar );
  915. #else
  916. BYTE cProtocol = *(BYTE *)pChar;
  917. #endif
  919. switch (cProtocol)
  920. {
  921. case chat_relegate:
  922. {
  923. CHAT_RELEGATE* pCR = (CHAT_RELEGATE*)pChar;
  925. DWORD theID = 0;
  926. switch (pCR->TargetCls)
  927. {
  928. case tgtcls_team:
  929. case tgtcls_fac:
  930. theID = pCR->TargetID;
  931. break;
  932. case tgtcls_scrn:
  933. theID = m_pGameStatus[pCR->TargetID].nPlayerIndex;
  934. break;
  935. default: 
  936. return;
  937. }
  938. m_pCoreServerShell->GroupChat(
  939. m_pChatClient,
  940. pCR->nFromIP,
  941. pCR->nFromRelayID,
  942. pCR->channelid,
  943. pCR->TargetCls,
  944. theID,
  945. pCR + 1,
  946. pCR->routeDateLength);
  947. }
  948. break;
  949. case chat_groupman:
  950. ChatGroupMan(pChar, nSize);
  951. break;
  952. case chat_specman:
  953. ChatSpecMan(pChar, nSize);
  954. break;
  955. case chat_everyone:
  956. {{
  957. CHAT_EVERYONE* pCeo = (CHAT_EVERYONE*)pChar;
  958. m_pCoreServerShell->OperationRequest(SSOI_BROADCASTING, (unsigned int)(pCeo + 1), pCeo->wChatLength);
  959. }}
  960. break;
  961. default:
  962. break;
  963. }
  965. }
  967. void KSwordOnLineSever::TongMessageProcess(const char *pChar, size_t nSize)
  968. {
  969. if (!pChar)
  970. return;
  972. EXTEND_HEADER* pHeader = (EXTEND_HEADER*)pChar;
  974. if (pHeader->ProtocolFamily == pf_extend)
  975. {
  976. if (pHeader->ProtocolID == extend_s2c_passtosomeone)
  977. {
  978. EXTEND_PASSTOSOMEONE* pEps = (EXTEND_PASSTOSOMEONE*)pChar;
  980. if (CheckPlayerID(pEps->lnID ,pEps->nameid))
  981. {
  982. _ASSERT(sizeof(tagExtendProtoHeader) <= sizeof(EXTEND_PASSTOSOMEONE));
  983. unsigned long lnID = pEps->lnID;
  984. size_t pckgsize = sizeof(tagExtendProtoHeader) + pEps->datasize;
  985. tagExtendProtoHeader* pExHdr = (tagExtendProtoHeader*)(pEps + 1) - 1;
  986. pExHdr->ProtocolType = s2c_extendfriend;
  987. pExHdr->wLength = pckgsize - 1;
  989. m_pServer->PackDataToClient(lnID, pExHdr, pckgsize);
  990. }
  991. }
  992. else if (pHeader->ProtocolID == extend_s2c_passtobevy)
  993. {
  994. EXTEND_PASSTOBEVY* pEpb = (EXTEND_PASSTOBEVY*)pChar;
  996. if (pEpb->playercount > 0)
  997. {
  998. _ASSERT(sizeof(tagExtendProtoHeader) <= sizeof(EXTEND_PASSTOBEVY));
  999. void* pExPckg = pEpb + 1;
  1000. WORD playercount = pEpb->playercount;
  1001. tagPlusSrcInfo* pPlayers = (tagPlusSrcInfo*)((BYTE*)pExPckg + pEpb->datasize);
  1002. size_t pckgsize = sizeof(tagExtendProtoHeader) + pEpb->datasize;
  1003. tagExtendProtoHeader* pExHdr = (tagExtendProtoHeader*)pExPckg - 1;
  1004. pExHdr->ProtocolType = s2c_extendfriend;
  1005. pExHdr->wLength = pckgsize - 1;
  1007. for (WORD i = 0; i < playercount; i++)
  1008. {
  1009. if (CheckPlayerID(pPlayers[i].lnID, pPlayers[i].nameid))
  1010. m_pServer->PackDataToClient(pPlayers[i].lnID, pExHdr, pckgsize);
  1011. }
  1012. }
  1013. }
  1014. }
  1015. else if (pHeader->ProtocolFamily == pf_tong)
  1016. {
  1017. // 协议长度检测
  1018. if (nSize < sizeof(EXTEND_HEADER))
  1019. return;
  1020. if (pHeader->ProtocolID >= enumS2C_TONG_NUM)
  1021. return;
  1022. if (g_nTongPCSize[pHeader->ProtocolID] < 0)
  1023. {
  1024. if (nSize <= sizeof(EXTEND_HEADER) + 2)
  1025. return;
  1026. WORD wLength = *((WORD*)((BYTE*)pChar + sizeof(EXTEND_HEADER)));
  1027. if (wLength != nSize)
  1028. return;
  1029. }
  1030. else if (g_nTongPCSize[pHeader->ProtocolID] != nSize)
  1031. {
  1032. return;
  1033. }
  1035. switch (pHeader->ProtocolID)
  1036. {
  1037. case enumS2C_TONG_CREATE_SUCCESS:
  1038. {
  1039. STONG_CREATE_SUCCESS_SYNC *pSync = (STONG_CREATE_SUCCESS_SYNC*)pChar;
  1040. STONG_SERVER_TO_CORE_CREATE_SUCCESS sSuccess;
  1042. sSuccess.m_nCamp = pSync->m_btCamp;
  1043. sSuccess.m_dwPlayerNameID = pSync->m_dwPlayerNameID;
  1044. sSuccess.m_nPlayerIdx = pSync->m_dwParam;
  1045. memcpy(sSuccess.m_szTongName, pSync->m_szTongName, pSync->m_btTongNameLength);
  1046. sSuccess.m_szTongName[pSync->m_btTongNameLength] = 0;
  1048. if (m_pCoreServerShell->OperationRequest(SSOI_TONG_CREATE, (unsigned int)&sSuccess, 0))
  1049. {
  1050. }
  1051. else
  1052. {
  1053. }
  1054. }
  1055. break;
  1056. case enumS2C_TONG_CREATE_FAIL:
  1057. {
  1058. STONG_CREATE_FAIL_SYNC *pFail = (STONG_CREATE_FAIL_SYNC*)pChar;
  1059. int nNetID;
  1060. TONG_CREATE_FAIL_SYNC sFail;
  1062. sFail.ProtocolType = s2c_extendtong;
  1063. sFail.m_btMsgId = enumTONG_SYNC_ID_CREATE_FAIL;
  1064. sFail.m_btFailId = pFail->m_btFailID;
  1065. sFail.m_wLength = sizeof(sFail) - 1;
  1066. nNetID = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NETID, pFail->m_dwParam, 0);
  1067. if (m_pServer)
  1068. m_pServer->PackDataToClient(nNetID, &sFail, sFail.m_wLength + 1);
  1069. }
  1070. break;
  1071. case enumS2C_TONG_ADD_MEMBER_SUCCESS:
  1072. {
  1073. STONG_ADD_MEMBER_SUCCESS_SYNC *pSync = (STONG_ADD_MEMBER_SUCCESS_SYNC*)pChar;
  1074. STONG_SERVER_TO_CORE_ADD_SUCCESS sAdd;
  1076. sAdd.m_nCamp = pSync->m_btCamp;
  1077. sAdd.m_dwPlayerNameID = pSync->m_dwPlayerNameID;
  1078. sAdd.m_nPlayerIdx = pSync->m_dwParam;
  1079. memcpy(sAdd.m_szMasterName, pSync->m_szMasterName, sizeof(sAdd.m_szMasterName));
  1080. memcpy(sAdd.m_szTitleName, pSync->m_szTitleName, sizeof(sAdd.m_szTitleName));
  1081. memcpy(sAdd.m_szTongName, pSync->m_szTongName, sizeof(sAdd.m_szTongName));
  1083. if (m_pCoreServerShell->OperationRequest(SSOI_TONG_ADD, (unsigned int)&sAdd, 0))
  1084. {
  1085. }
  1086. else
  1087. {
  1088. }
  1089. }
  1090. break;
  1091. case enumS2C_TONG_ADD_MEMBER_FAIL:
  1092. {
  1093. STONG_ADD_MEMBER_FAIL_SYNC *pSync = (STONG_ADD_MEMBER_FAIL_SYNC*)pChar;
  1094. }
  1095. break;
  1097. case enumS2C_TONG_HEAD_INFO:
  1098. {
  1099. STONG_HEAD_INFO_SYNC *pInfo = (STONG_HEAD_INFO_SYNC*)pChar;
  1100. if ((int)pInfo->m_dwParam <= 0 || (int)pInfo->m_dwParam >= MAX_PLAYER)
  1101. break;
  1103. int nNetID = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NETID, pInfo->m_dwParam, 0);
  1104. if (nNetID < 0)
  1105. break;
  1107. TONG_HEAD_INFO_SYNC sInfo;
  1108. sInfo.ProtocolType = s2c_extendtong;
  1109. sInfo.m_btMsgId = enumTONG_SYNC_ID_HEAD_INFO;
  1110. sInfo.m_dwNpcID = pInfo->m_dwNpcID;
  1111. sInfo.m_dwMoney = pInfo->m_dwMoney;
  1112. sInfo.m_nCredit = pInfo->m_nCredit;
  1113. sInfo.m_btCamp = pInfo->m_btCamp;
  1114. sInfo.m_btLevel = pInfo->m_btLevel;
  1115. sInfo.m_btDirectorNum = pInfo->m_btDirectorNum;
  1116. sInfo.m_btManagerNum = pInfo->m_btManagerNum;
  1117. sInfo.m_dwMemberNum = pInfo->m_dwMemberNum;
  1118. memcpy(sInfo.m_szTongName, pInfo->m_szTongName, sizeof(pInfo->m_szTongName));
  1119. memset(sInfo.m_sMember, 0, sizeof(sInfo.m_sMember));
  1120. memcpy(sInfo.m_sMember, pInfo->m_sMember, sizeof(TONG_ONE_LEADER_INFO) * (1 + sInfo.m_btDirectorNum));
  1121. sInfo.m_wLength = sizeof(sInfo) - 1 - sizeof(sInfo.m_sMember) + sizeof(TONG_ONE_LEADER_INFO) * (1 + sInfo.m_btDirectorNum);
  1122. if (m_pServer)
  1123. m_pServer->PackDataToClient(nNetID, &sInfo, sInfo.m_wLength + 1);
  1124. }
  1125. break;
  1127. case enumS2C_TONG_MANAGER_INFO:
  1128. {
  1129. STONG_MANAGER_INFO_SYNC *pInfo = (STONG_MANAGER_INFO_SYNC*)pChar;
  1130. if ((int)pInfo->m_dwParam <= 0 || (int)pInfo->m_dwParam >= MAX_PLAYER)
  1131. break;
  1133. int nNetID = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NETID, pInfo->m_dwParam, 0);
  1134. if (nNetID < 0)
  1135. break;
  1137. TONG_MANAGER_INFO_SYNC sInfo;
  1138. sInfo.ProtocolType = s2c_extendtong;
  1139. sInfo.m_btMsgId = enumTONG_SYNC_ID_MANAGER_INFO;
  1140. sInfo.m_dwMoney = pInfo->m_dwMoney;
  1141. sInfo.m_nCredit = pInfo->m_nCredit;
  1142. sInfo.m_btCamp = pInfo->m_btCamp;
  1143. sInfo.m_btLevel = pInfo->m_btLevel;
  1144. sInfo.m_btDirectorNum = pInfo->m_btDirectorNum;
  1145. sInfo.m_btManagerNum = pInfo->m_btManagerNum;
  1146. sInfo.m_dwMemberNum = pInfo->m_dwMemberNum;
  1147. sInfo.m_btStateNo = pInfo->m_btStartNo;
  1148. sInfo.m_btCurNum = pInfo->m_btCurNum;
  1149. memcpy(sInfo.m_szTongName, pInfo->m_szTongName, sizeof(pInfo->m_szTongName));
  1150. memset(sInfo.m_sMember, 0, sizeof(sInfo.m_sMember));
  1151. memcpy(sInfo.m_sMember, pInfo->m_sMember, sizeof(TONG_ONE_LEADER_INFO) * sInfo.m_btCurNum);
  1152. sInfo.m_wLength = sizeof(sInfo) - 1 - sizeof(TONG_ONE_LEADER_INFO) * (defTONG_ONE_PAGE_MAX_NUM - sInfo.m_btCurNum);
  1153. if (m_pServer)
  1154. m_pServer->PackDataToClient(nNetID, &sInfo, sInfo.m_wLength + 1);
  1155. }
  1156. break;
  1158. case enumS2C_TONG_MEMBER_INFO:
  1159. {
  1160. STONG_MEMBER_INFO_SYNC *pInfo = (STONG_MEMBER_INFO_SYNC*)pChar;
  1161. if ((int)pInfo->m_dwParam <= 0 || (int)pInfo->m_dwParam >= MAX_PLAYER)
  1162. break;
  1164. int nNetID = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NETID, pInfo->m_dwParam, 0);
  1165. if (nNetID < 0)
  1166. break;
  1168. TONG_MEMBER_INFO_SYNC sInfo;
  1169. sInfo.ProtocolType = s2c_extendtong;
  1170. sInfo.m_btMsgId = enumTONG_SYNC_ID_MEMBER_INFO;
  1171. sInfo.m_dwMoney = pInfo->m_dwMoney;
  1172. sInfo.m_nCredit = pInfo->m_nCredit;
  1173. sInfo.m_btCamp = pInfo->m_btCamp;
  1174. sInfo.m_btLevel = pInfo->m_btLevel;
  1175. sInfo.m_btDirectorNum = pInfo->m_btDirectorNum;
  1176. sInfo.m_btManagerNum = pInfo->m_btManagerNum;
  1177. sInfo.m_dwMemberNum = pInfo->m_dwMemberNum;
  1178. sInfo.m_btStateNo = pInfo->m_btStartNo;
  1179. sInfo.m_btCurNum = pInfo->m_btCurNum;
  1180. memcpy(sInfo.m_szTitle, pInfo->m_szTitle, sizeof(pInfo->m_szTitle));
  1181. memcpy(sInfo.m_szTongName, pInfo->m_szTongName, sizeof(pInfo->m_szTongName));
  1182. memset(sInfo.m_sMember, 0, sizeof(sInfo.m_sMember));
  1183. memcpy(sInfo.m_sMember, pInfo->m_sMember, sizeof(TONG_ONE_MEMBER_INFO) * sInfo.m_btCurNum);
  1184. sInfo.m_wLength = sizeof(sInfo) - 1 - sizeof(TONG_ONE_MEMBER_INFO) * (defTONG_ONE_PAGE_MAX_NUM - sInfo.m_btCurNum);
  1185. if (m_pServer)
  1186. m_pServer->PackDataToClient(nNetID, &sInfo, sInfo.m_wLength + 1);
  1187. }
  1188. break;
  1190. case enumS2C_TONG_BE_INSTATED:
  1191. {
  1192. STONG_BE_INSTATED_SYNC *pSync = (STONG_BE_INSTATED_SYNC*)pChar;
  1193. if (m_pGameStatus[pSync->m_dwParam].nPlayerIndex <= 0)
  1194. break;
  1195. STONG_SERVER_TO_CORE_BE_INSTATED sInstated;
  1196. sInstated.m_nPlayerIdx = m_pGameStatus[pSync->m_dwParam].nPlayerIndex;
  1197. sInstated.m_btFigure = pSync->m_btFigure;
  1198. sInstated.m_btPos = pSync->m_btPos;
  1199. memcpy(sInstated.m_szName, pSync->m_szName, sizeof(pSync->m_szName));
  1200. memcpy(sInstated.m_szTitle, pSync->m_szTitle, sizeof(pSync->m_szTitle));
  1201. m_pCoreServerShell->GetGameData(SGDI_TONG_BE_INSTATED, (unsigned int)&sInstated, 0);
  1202. }
  1203. break;
  1205. case enumS2C_TONG_INSTATE:
  1206. {
  1207. STONG_INSTATE_SYNC *pSync = (STONG_INSTATE_SYNC*)pChar;
  1208. TONG_INSTATE_SYNC sInstate;
  1210. if ((int)pSync->m_dwParam <= 0 || (int)pSync->m_dwParam >= MAX_PLAYER)
  1211. break;
  1213. int nNetID = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NETID, pSync->m_dwParam, 0);
  1214. if (nNetID < 0)
  1215. break;
  1217. sInstate.ProtocolType = s2c_extendtong;
  1218. sInstate.m_btMsgId = enumTONG_SYNC_ID_INSTATE;
  1219. sInstate.m_wLength = sizeof(sInstate) - 1;
  1220. sInstate.m_dwTongNameID = pSync->m_dwTongNameID;
  1221. sInstate.m_btSuccessFlag = pSync->m_btSuccessFlag;
  1222. sInstate.m_btOldFigure = pSync->m_btOldFigure;
  1223. sInstate.m_btOldPos = pSync->m_btOldPos;
  1224. sInstate.m_btNewFigure = pSync->m_btNewFigure;
  1225. sInstate.m_btNewPos = pSync->m_btNewPos;
  1226. memcpy(sInstate.m_szTitle, pSync->m_szTitle, sizeof(pSync->m_szTitle));
  1227. memcpy(sInstate.m_szName, pSync->m_szName, sizeof(pSync->m_szName));
  1229. if (m_pServer)
  1230. m_pServer->PackDataToClient(nNetID, &sInstate, sInstate.m_wLength + 1);
  1231. }
  1232. break;
  1234. case enumS2C_TONG_KICK:
  1235. {
  1236. STONG_KICK_SYNC *pSync = (STONG_KICK_SYNC*)pChar;
  1237. TONG_KICK_SYNC sKick;
  1239. if ((int)pSync->m_dwParam <= 0 || (int)pSync->m_dwParam >= MAX_PLAYER)
  1240. break;
  1242. int nNetID = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NETID, pSync->m_dwParam, 0);
  1243. if (nNetID < 0)
  1244. break;
  1246. sKick.ProtocolType = s2c_extendtong;
  1247. sKick.m_btMsgId = enumTONG_SYNC_ID_KICK;
  1248. sKick.m_wLength = sizeof(sKick) - 1;
  1249. sKick.m_dwTongNameID = pSync->m_dwTongNameID;
  1250. sKick.m_btSuccessFlag = pSync->m_btSuccessFlag;
  1251. sKick.m_btFigure = pSync->m_btFigure;
  1252. sKick.m_btPos = pSync->m_btPos;
  1253. memcpy(sKick.m_szName, pSync->m_szName, sizeof(pSync->m_szName));
  1255. if (m_pServer)
  1256. m_pServer->PackDataToClient(nNetID, &sKick, sKick.m_wLength + 1);
  1257. }
  1258. break;
  1260. case enumS2C_TONG_BE_KICKED:
  1261. {
  1262. STONG_BE_KICKED_SYNC *pSync = (STONG_BE_KICKED_SYNC*)pChar;
  1263. if (m_pGameStatus[pSync->m_dwParam].nPlayerIndex <= 0)
  1264. break;
  1265. STONG_SERVER_TO_CORE_BE_KICKED sKicked;
  1266. sKicked.m_nPlayerIdx = m_pGameStatus[pSync->m_dwParam].nPlayerIndex;
  1267. sKicked.m_btFigure = pSync->m_btFigure;
  1268. sKicked.m_btPos = pSync->m_btPos;
  1269. memcpy(sKicked.m_szName, pSync->m_szName, sizeof(pSync->m_szName));
  1270. m_pCoreServerShell->GetGameData(SGDI_TONG_BE_KICKED, (unsigned int)&sKicked, 0);
  1271. }
  1272. break;
  1274. case enumS2C_TONG_LEAVE:
  1275. {
  1276. STONG_LEAVE_SYNC *pSync = (STONG_LEAVE_SYNC*)pChar;
  1277. STONG_SERVER_TO_CORE_LEAVE sLeave;
  1278. sLeave.m_nPlayerIdx = pSync->m_dwParam;
  1279. sLeave.m_bSuccessFlag = pSync->m_btSuccessFlag;
  1280. memcpy(sLeave.m_szName, pSync->m_szName, sizeof(pSync->m_szName));
  1281. m_pCoreServerShell->GetGameData(SGDI_TONG_LEAVE, (unsigned int)&sLeave, 0);
  1282. }
  1283. break;
  1285. case enumS2C_TONG_CHECK_CHANGE_MASTER_POWER:
  1286. {
  1287. STONG_CHECK_GET_MASTER_POWER_SYNC *pSync = (STONG_CHECK_GET_MASTER_POWER_SYNC*)pChar;
  1288. if (m_pGameStatus[pSync->m_dwParam].nPlayerIndex <= 0)
  1289. break;
  1290. STONG_SERVER_TO_CORE_CHECK_GET_MASTER_POWER sCheck;
  1291. sCheck.m_dwTongNameID = pSync->m_dwTongNameID;
  1292. sCheck.m_btFigure = pSync->m_btFigure;
  1293. sCheck.m_btPos = pSync->m_btPos;
  1294. sCheck.m_nPlayerIdx = m_pGameStatus[pSync->m_dwParam].nPlayerIndex;
  1295. memcpy(sCheck.m_szName, pSync->m_szName, sizeof(pSync->m_szName));
  1297. int nRet = 0;
  1298. if (m_pCoreServerShell)
  1299. nRet = m_pCoreServerShell->GetGameData(SGDI_TONG_GET_MASTER_POWER, (unsigned int)&sCheck, 0);
  1301. STONG_ACCEPT_MASTER_COMMAND sAccept;
  1303. sAccept.ProtocolFamily = pf_tong;
  1304. sAccept.ProtocolID = enumC2S_TONG_ACCEPT_MASTER;
  1305. sAccept.m_dwParam = m_pGameStatus[pSync->m_dwParam].nPlayerIndex;
  1306. sAccept.m_dwTongNameID = pSync->m_dwTongNameID;
  1307. sAccept.m_btFigure = pSync->m_btFigure;
  1308. sAccept.m_btPos = pSync->m_btPos;
  1309. if (nRet)
  1310. sAccept.m_btAcceptFalg = 1;
  1311. else
  1312. sAccept.m_btAcceptFalg = 0;
  1313. memcpy(sAccept.m_szName, pSync->m_szName, sizeof(pSync->m_szName));
  1315. if (m_pTongClient)
  1316. m_pTongClient->SendPackToServer((const void*)&sAccept, sizeof(sAccept));
  1317. }
  1318. break;
  1320. case enumS2C_TONG_CHANGE_MASTER_FAIL:
  1321. {
  1322. STONG_CHANGE_MASTER_FAIL_SYNC *pFail = (STONG_CHANGE_MASTER_FAIL_SYNC*)pChar;
  1323. int nPlayer = pFail->m_dwParam;
  1324. switch (pFail->m_btFailID)
  1325. {
  1326. case 0:
  1327. break;
  1328. case 1:
  1329. nPlayer = m_pGameStatus[pFail->m_dwParam].nPlayerIndex;
  1330. break;
  1331. default:
  1332. break;
  1333. }
  1335. if (nPlayer <= 0 || nPlayer >= MAX_PLAYER)
  1336. break;
  1337. int nNetID = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NETID, nPlayer, 0);
  1338. if (nNetID < 0)
  1339. break;
  1341. TONG_CHANGE_MASTER_FAIL_SYNC sFail;
  1342. sFail.ProtocolType = s2c_extendtong;
  1343. sFail.m_btMsgId = enumTONG_SYNC_ID_CHANGE_MASTER_FAIL;
  1344. sFail.m_wLength = sizeof(sFail) - 1;
  1345. sFail.m_dwTongNameID = pFail->m_dwTongNameID;
  1346. sFail.m_btFailID = pFail->m_btFailID;
  1347. memcpy(sFail.m_szName, pFail->m_szName, sizeof(pFail->m_szName));
  1348. if (m_pServer)
  1349. m_pServer->PackDataToClient(nNetID, &sFail, sFail.m_wLength + 1);
  1350. }
  1351. break;
  1353. case enumS2C_TONG_CHANGE_AS:
  1354. {
  1355. STONG_CHANGE_AS_SYNC *pAs = (STONG_CHANGE_AS_SYNC*)pChar;
  1356. if (m_pGameStatus[pAs->m_dwParam].nPlayerIndex <= 0)
  1357. break;
  1358. STONG_SERVER_TO_CORE_CHANGE_AS sChange;
  1359. sChange.m_nPlayerIdx = m_pGameStatus[pAs->m_dwParam].nPlayerIndex;
  1360. sChange.m_dwTongNameID = pAs->m_dwTongNameID;
  1361. sChange.m_btFigure = pAs->m_btFigure;
  1362. sChange.m_btPos = pAs->m_btPos;
  1363. // 自己的新头衔
  1364. memcpy(sChange.m_szTitle, pAs->m_szTitle, sizeof(pAs->m_szTitle));
  1365. // 新帮主的名字
  1366. memcpy(sChange.m_szName, pAs->m_szName, sizeof(pAs->m_szName));
  1367. m_pCoreServerShell->GetGameData(SGDI_TONG_CHANGE_AS, (unsigned int)&sChange, 0);
  1368. }
  1369. break;
  1371. case enumS2C_TONG_CHANGE_MASTER:
  1372. {
  1373. STONG_CHANGE_MASTER_SYNC *pMaster = (STONG_CHANGE_MASTER_SYNC*)pChar;
  1374. STONG_SERVER_TO_CORE_CHANGE_MASTER sChange;
  1375. sChange.m_dwTongNameID = pMaster->m_dwTongNameID;
  1376. memcpy(sChange.m_szName, pMaster->m_szName, sizeof(pMaster->m_szName));
  1377. m_pCoreServerShell->GetGameData(SGDI_TONG_CHANGE_MASTER, (unsigned int)&sChange, 0);
  1378. }
  1379. break;
  1381. case enumS2C_TONG_LOGIN_DATA:
  1382. {
  1383. STONG_LOGIN_DATA_SYNC *pLogin = (STONG_LOGIN_DATA_SYNC*)pChar;
  1384. STONG_SERVER_TO_CORE_LOGIN sLogin;
  1385. sLogin.m_dwParam = pLogin->m_dwParam;
  1386. sLogin.m_nFlag = pLogin->m_btFlag;
  1387. sLogin.m_nCamp = pLogin->m_btCamp;
  1388. sLogin.m_nFigure = pLogin->m_btFigure;
  1389. sLogin.m_nPos = pLogin->m_btPos;
  1390. memcpy(sLogin.m_szTongName, pLogin->m_szTongName, sizeof(pLogin->m_szTongName));
  1391. memcpy(sLogin.m_szTitle, pLogin->m_szTitle, sizeof(pLogin->m_szTitle));
  1392. memcpy(sLogin.m_szMaster, pLogin->m_szMaster, sizeof(pLogin->m_szMaster));
  1393. memcpy(sLogin.m_szName, pLogin->m_szName, sizeof(pLogin->m_szName));
  1394. m_pCoreServerShell->GetGameData(SGDI_TONG_LOGIN, (unsigned int)&sLogin, 0);
  1395. }
  1396. break;
  1398. default:
  1399. break;
  1400. }
  1401. }
  1402. else if (pHeader->ProtocolFamily == pf_friend)
  1403. {
  1404. }
  1405. }
  1407. void KSwordOnLineSever::ChatGroupMan(const void *pData, size_t dataLength)
  1408. {
  1409. _ASSERT(pData && dataLength);
  1411. CHAT_GROUPMAN* pCgc = (CHAT_GROUPMAN *)pData;
  1412. _ASSERT(pCgc->wSize + 1 == dataLength);
  1414. _ASSERT(sizeof(tagExtendProtoHeader) <= sizeof(CHAT_GROUPMAN));
  1415. void* pExPckg = pCgc + 1;
  1416. BYTE hasIdentify = pCgc->byHasIdentify;
  1417. WORD playercount = pCgc->wPlayerCount;
  1418. void* pPlayersData = (tagPlusSrcInfo*)((BYTE*)pExPckg + pCgc->wChatLength);
  1419. size_t pckgsize = sizeof(tagExtendProtoHeader) + pCgc->wChatLength;
  1420. tagExtendProtoHeader* pExHdr = (tagExtendProtoHeader*)pExPckg - 1;
  1421. pExHdr->ProtocolType = s2c_extendchat;
  1422. pExHdr->wLength = pckgsize - 1;
  1424. if (hasIdentify)
  1425. {
  1426. tagPlusSrcInfo* pPlayers = (tagPlusSrcInfo*)pPlayersData;
  1427. for (int i = 0; i < playercount; i++)
  1428. {
  1429. //TODO: 要加检验NameID和lnID的一致性
  1430. if (CheckPlayerID(pPlayers[i].lnID, pPlayers[i].nameid))
  1431. m_pServer->PackDataToClient(pPlayers[i].lnID, pExHdr, pckgsize);
  1432. }
  1433. }
  1434. else
  1435. {
  1436. WORD* pPlayers = (WORD*)pPlayersData;
  1437. for (int i = 0; i < playercount; i++)
  1438. {
  1439. //TODO: 不需要加检验NameID和lnID的一致性
  1440. //if (pPlayers[i] >= 0)
  1441. m_pServer->PackDataToClient((unsigned long)pPlayers[i], pExHdr, pckgsize);
  1442. }
  1443. }
  1444. }
  1446. void KSwordOnLineSever::ChatSpecMan(const void *pData, size_t dataLength)
  1447. {
  1448. _ASSERT(pData && dataLength);
  1450. CHAT_SPECMAN* pCsm = (CHAT_SPECMAN *)pData;
  1451. _ASSERT(pCsm->wSize + 1 == dataLength);
  1453. if (!CheckPlayerID(pCsm->lnID, pCsm->nameid))
  1454. return;
  1456. _ASSERT(sizeof(tagExtendProtoHeader) <= sizeof(CHAT_SPECMAN));
  1457. void* pExPckg = pCsm + 1;
  1459. unsigned long lnID = pCsm->lnID;
  1460. size_t pckgsize = sizeof(tagExtendProtoHeader) + pCsm->wChatLength;
  1462. tagExtendProtoHeader* pExHeader = (tagExtendProtoHeader*)(pCsm + 1) - 1;
  1463. pExHeader->ProtocolType = s2c_extendchat;
  1464. pExHeader->wLength = pckgsize - 1;
  1466. m_pServer->PackDataToClient(lnID, pExHeader, pckgsize);
  1467. }
  1470. void KSwordOnLineSever::DatabaseMessageProcess(const char* pData, size_t dataLength)
  1471. {
  1472. _ASSERT( pData && dataLength );
  1474. #ifndef _STANDALONE
  1475. BYTE cProtocol = CPackager::Peek( pData );
  1476. #else
  1477. BYTE cProtocol = *(BYTE *)pData;
  1478. #endif
  1480. // 大包处理（用于排名的数据）
  1481. if ( cProtocol < s2c_micropackbegin )
  1482. {
  1483. DatabaseLargePackProcess(pData, dataLength);
  1484. return;
  1485. }
  1487. switch ( cProtocol )
  1488. {
  1489. case s2c_roleserver_saverole_result:
  1490. //m_bSaveFlag = TRUE;
  1491. {
  1492. TProcessData* pPD = (TProcessData *)pData;
  1493. int nIndex = pPD->ulIdentity;
  1494. m_pCoreServerShell->SetSaveStatus(nIndex, SAVE_IDLE);
  1495. printf("  Save Player Data finished(%d)!n", nIndex);
  1496. }
  1497. break;
  1498. default:
  1499. printf("Protocol:(%d) -- database error", cProtocol);
  1500. break;
  1501. }
  1502. }
  1504. void KSwordOnLineSever::DatabaseLargePackProcess(const char* pData, size_t dataLength)
  1505. {
  1506. _ASSERT( pData && dataLength );
  1508. #ifndef _STANDALONE
  1509. CBuffer *pBuffer = m_theRecv.PackUp( pData, dataLength );
  1510. #else
  1511. char *pBuffer = m_theRecv.PackUp( pData, dataLength );
  1512. #endif
  1514. if ( pBuffer )
  1515. {
  1516. #ifndef _STANDALONE
  1517. BYTE cProtocol = CPackager::Peek( pBuffer->GetBuffer() );
  1518. #else
  1519. BYTE cProtocol = *(BYTE *)pBuffer;
  1520. #endif
  1521. // BYTE cProtocol = CPackager::Peek( pBuffer->GetBuffer() );
  1523. switch ( cProtocol )
  1524. {
  1525. case s2c_gamestatistic:
  1526. {
  1527. #ifndef _STANDALONE
  1528. TProcessData* pRD = (TProcessData *)pBuffer->GetBuffer();
  1529. #else
  1530. TProcessData* pRD = (TProcessData *)pBuffer;
  1531. #endif
  1532. _ASSERT( pRD->nDataLen == sizeof(TGAME_STAT_DATA) );
  1534. if (m_pCoreServerShell)
  1535. {
  1536. m_pCoreServerShell->SetLadder((void *)pRD->pDataBuffer, pRD->nDataLen);
  1537. }
  1538. }
  1539. break;
  1541. default:
  1542. break;
  1543. }
  1545. #ifndef _STANDALONE
  1546. try
  1547. {
  1548. if( pBuffer != NULL )
  1549. {
  1550. pBuffer->Release();
  1551. pBuffer = NULL; 
  1552. }
  1553. }
  1554. catch(...) 
  1555. {
  1556. //TRACE("SAFE_RELEASE errorn");
  1557. }
  1558. #endif
  1559. }
  1560. }
  1562. void KSwordOnLineSever::TransferMessageProcess(const char* pChar, size_t nSize)
  1563. {
  1564. //#ifndef _STANDALONE
  1565. _ASSERT(pChar && nSize && nSize < 1024);
  1567. EXTEND_HEADER *pEH = (EXTEND_HEADER *)pChar;
  1569. if (nSize < sizeof(EXTEND_HEADER))
  1570. return;
  1572. // 是否寻路包？
  1573. if (pEH->ProtocolID == relay_c2c_askwaydata && pEH->ProtocolFamily == pf_relay)
  1574. {
  1575. TransferAskWayMessageProcess(pChar, nSize);
  1576. return;
  1577. }
  1579. RELAY_DATA *pRD = (RELAY_DATA *)pEH;
  1580. if (nSize <= sizeof(RELAY_DATA) || nSize != pRD->routeDateLength + sizeof(RELAY_DATA))
  1581. return;
  1583. // 是否寻路失败包
  1584. if (pEH->ProtocolID == relay_s2c_loseway && pEH->ProtocolFamily == pf_relay)
  1585. {
  1586. TransferLoseWayMessageProcess(pChar + sizeof(RELAY_DATA), nSize - sizeof(RELAY_DATA));
  1587. return;
  1588. }
  1590. if (pEH->ProtocolID != relay_c2c_data && pEH->ProtocolFamily != pf_relay)
  1591. return;
  1593. KTransferUnit* pUnit = NULL;
  1594. IP2CONNECTUNIT::iterator it = m_mapIp2TransferUnit.find(pRD->nFromRelayID);
  1596. if (it != m_mapIp2TransferUnit.end())
  1597. {
  1598. pUnit = (*it).second;
  1599. _ASSERT(pUnit);
  1600. }
  1601. else
  1602. {
  1603. pUnit = new KTransferUnit(pRD->nFromIP, pRD->nFromRelayID);
  1604. m_mapIp2TransferUnit.insert(IP2CONNECTUNIT::value_type(pRD->nFromRelayID, pUnit));
  1605. }
  1607. #ifndef _STANDALONE
  1608. BYTE cProtocol = CPackager::Peek(pChar, sizeof(RELAY_DATA));
  1609. #else
  1610. BYTE cProtocol = *(BYTE *)(pChar + sizeof(RELAY_DATA));
  1611. #endif
  1613. if ( cProtocol < c2c_micropackbegin )
  1614. {
  1615. TransferLargePackProcess(pChar + sizeof(RELAY_DATA), pRD->routeDateLength, pUnit);
  1616. }
  1617. else if ( cProtocol > c2c_micropackbegin )
  1618. {
  1619. TransferSmallPackProcess(pChar + sizeof(RELAY_DATA), pRD->routeDateLength, pUnit);
  1620. }
  1621. else
  1622. {
  1623. _ASSERT( FALSE && "Error!" );
  1624. }
  1625. //#endif
  1626. }
  1628. void KSwordOnLineSever::TransferLargePackProcess(const void *pData, size_t dataLength, KTransferUnit *pUnit)
  1629. {
  1630. _ASSERT(pData && dataLength);
  1631. if (!pData || !dataLength)
  1632. return;
  1634. #ifndef _STANDALONE
  1635. CBuffer *pBuffer = pUnit->m_RecvData.PackUp( pData, dataLength );
  1636. #else
  1637. char *pBuffer = pUnit->m_RecvData.PackUp( pData, dataLength );
  1638. #endif
  1639. char szChar[1024];
  1641. if ( pBuffer )
  1642. {
  1643. #ifndef _STANDALONE
  1644. BYTE cProtocol = CPackager::Peek( pBuffer->GetBuffer() );
  1645. #else
  1646. BYTE cProtocol = *(BYTE *)pBuffer;
  1647. #endif
  1649. switch ( cProtocol )
  1650. {
  1651. case c2c_transferroleinfo:
  1652. {
  1653. #ifndef _STANDALONE
  1654. tagGuidableInfo *pGI = (tagGuidableInfo *)pBuffer->GetBuffer();
  1655. #else
  1656. tagGuidableInfo *pGI = (tagGuidableInfo *)pBuffer;
  1657. #endif
  1659. GUID guid;
  1660. memcpy( &guid, &( pGI->guid ), sizeof( GUID ) );
  1662. if ( pGI->datalength > 0 )
  1663. {
  1664. const TRoleData *pRoleData = ( const TRoleData * )( pGI->szData );
  1665. DWORD dwCRC = 0;
  1666. dwCRC = CRC32(dwCRC, pRoleData, pRoleData->dwDataLen - 4);
  1667. DWORD dwCheck = *(DWORD *)(pGI->szData + pRoleData->dwDataLen - 4);
  1668. BOOL bCRC = (dwCheck == dwCRC);
  1670. int nIdx = 0;
  1671. if (bCRC)
  1672. {
  1673. nIdx = m_pCoreServerShell->AddCharacter(pGI->nExtPoint, pGI->nChangePoint, (void *)pRoleData, &guid);
  1674. }
  1675. else
  1676. {
  1677. FILE *fLog = fopen("crc_transfer_error", "a+b");
  1678. if(fLog) 
  1679. {
  1680. char buffer[255];
  1681. sprintf(buffer, "----rn%srb%srn", pRoleData->BaseInfo.szName, pRoleData->BaseInfo.caccname);
  1682. fwrite(buffer, 1, strlen(buffer), fLog);
  1683. fwrite(pRoleData, 1, pRoleData->dwDataLen, fLog);
  1684. fclose(fLog);
  1685. }
  1686. }
  1688. RELAY_DATA* pRD = (RELAY_DATA *)szChar;
  1689. pRD->ProtocolFamily = pf_relay;
  1690. pRD->ProtocolID = relay_c2c_data;
  1691. pRD->nFromIP = 0;
  1692. pRD->nFromRelayID = 0;
  1693. pRD->nToIP = pUnit->GetIp();
  1694. pRD->nToRelayID = pUnit->GetRelayID();
  1695. pRD->routeDateLength = sizeof(tagPermitPlayerExchange);
  1697. tagPermitPlayerExchange *pPPEO = (tagPermitPlayerExchange *)(szChar + sizeof(RELAY_DATA));
  1699. pPPEO->cProtocol = c2c_permitplayerexchangein;
  1700. memcpy(&pPPEO->guid, &guid, sizeof(GUID));
  1702. pPPEO->dwIp = m_dwInternetIp;//OnlineGameLib::Win32::net_aton(m_szGameSvrIP);
  1703. pPPEO->wPort = m_nServerPort;
  1705. if (nIdx)
  1706. {
  1707. pPPEO->bPermit = true;
  1708. tagRegisterAccount ra;
  1709. ra.cProtocol = c2s_registeraccount;
  1710. strcpy((char *)ra.szAccountName, pRoleData->BaseInfo.caccname);
  1711. m_pGatewayClient->SendPackToServer(&ra, sizeof(tagRegisterAccount));
  1712. }
  1713. else
  1714. {
  1715. pPPEO->bPermit = false;
  1716. }
  1717. m_pTransferClient->SendPackToServer(pRD, sizeof(RELAY_DATA) + sizeof(tagPermitPlayerExchange));
  1719. }
  1720. else
  1721. {
  1722. // cout << "Don't find any valid data!" << endl;
  1723. }
  1724. }
  1725. break;
  1726. default:
  1727. break;
  1728. }
  1730. #ifndef _STANDALONE
  1731. try
  1732. {
  1733. if( pBuffer != NULL )
  1734. {
  1735. pBuffer->Release();
  1736. pBuffer = NULL; 
  1737. }
  1738. }
  1739. catch(...) 
  1740. {
  1741. //TRACE("SAFE_RELEASE errorn");
  1742. }
  1743. #endif
  1744. }
  1745. }
  1747. void KSwordOnLineSever::TransferSmallPackProcess(const void *pData, size_t dataLength, KTransferUnit* pUnit)
  1748. {
  1749. //#ifndef _STANDALONE
  1750. _ASSERT(pUnit && pData && dataLength);
  1751. if (!pUnit || !pData || !dataLength)
  1752. return;
  1754. #ifndef _STANDALONE
  1755. BYTE cProtocol = CPackager::Peek( pData );
  1756. #else
  1757. BYTE cProtocol = *(BYTE *)pData;
  1758. #endif
  1760. switch ( cProtocol )
  1761. {
  1762. case s2s_broadcast:
  1763. {
  1764. BYTE* pS = (BYTE *)pData;
  1765. m_pCoreServerShell->ProcessBroadcastMessage((const char *)(pS + 1), dataLength - 1);
  1766. }
  1767. break;
  1768. case s2s_execute:
  1769. {
  1770. BYTE* pS = (BYTE *)pData;
  1771. m_pCoreServerShell->ProcessExecuteMessage((const char *)(pS + 1), dataLength - 1);
  1772. }
  1773. break;
  1774. case c2c_permitplayerexchangein:
  1775. {
  1776. tagPermitPlayerExchange* pPermit = (tagPermitPlayerExchange *)pData;
  1777. int nIndex, lnID;
  1778. m_pCoreServerShell->GetPlayerIndexByGuid(&pPermit->guid, &nIndex, &lnID);
  1779. if (nIndex == 0 || lnID == -1)
  1780. break;
  1782. if (m_pGameStatus[lnID].nExchangeStatus != enumExchangeWaitForGameSvrRespone)
  1783. break;
  1785. tagNotifyPlayerExchange npe;
  1786. if (pPermit->bPermit)
  1787. {
  1788. // SavePlayerData(nIndex);
  1789. m_pCoreServerShell->RemovePlayerForExchange(nIndex);
  1790. npe.cProtocol = s2c_notifyplayerexchange;
  1791. memcpy(&npe.guid, &pPermit->guid, sizeof(GUID));
  1792. npe.nIPAddr = pPermit->dwIp;
  1793. npe.nPort = pPermit->wPort;
  1794. m_pServer->SendData(lnID, &npe, sizeof(tagNotifyPlayerExchange));
  1796. tagLeaveGame sLeaveGame;
  1797. sLeaveGame.cProtocol = c2s_leavegame;
  1798. sLeaveGame.cCmdType = HOLDACC_LEAVEGAME;
  1799. char szName[32];
  1800. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ACCOUNT, (unsigned int)szName, nIndex);
  1801. sLeaveGame.nExtPoint = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_EXTPOINTCHANGED, nIndex, 0);
  1803. strcpy((char *)sLeaveGame.szAccountName, (char *)szName);
  1804. m_pGatewayClient->SendPackToServer(&sLeaveGame, sizeof(tagLeaveGame));
  1806. tagLeaveGame2 lg2;
  1808. lg2.ProtocolFamily = pf_normal;
  1809. lg2.ProtocolID = c2s_leavegame;
  1810. lg2.cCmdType = HOLDACC_LEAVEGAME;
  1811. strcpy((char *)lg2.szAccountName, (char *)szName);
  1813. if (m_pTransferClient)
  1814. m_pTransferClient->SendPackToServer(&lg2, sizeof(tagLeaveGame2));
  1815. // cout << sLeaveGame.szAccountName << " leave game!" << endl;
  1816. m_pGameStatus[lnID].nExchangeStatus = enumExchangeCleaning;
  1817. m_pGameStatus[lnID].nPlayerIndex = 0;
  1818. }
  1819. else
  1820. {
  1821. npe.cProtocol = s2c_notifyplayerexchange;
  1822. memset(&npe.guid, 0, sizeof(GUID));
  1823. // if false, ip to 0
  1824. npe.nIPAddr = 0;
  1825. npe.nPort = 0;
  1826. m_pServer->SendData(lnID, &npe, sizeof(tagNotifyPlayerExchange));
  1828. // TODO: Recover player to old game
  1829. m_pCoreServerShell->RecoverPlayerExchange(nIndex);
  1831. tagRoleEnterGame reg;
  1832. reg.ProtocolType = c2s_roleserver_lock;
  1833. reg.bLock = true;
  1834. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NAME, (unsigned int)reg.Name, nIndex);
  1835. if (m_pDatabaseClient)
  1836. m_pDatabaseClient->SendPackToServer((const void *)&reg, sizeof(tagRoleEnterGame));
  1838. m_pGameStatus[lnID].nGameStatus = enumPlayerPlaying;
  1839. m_pGameStatus[lnID].nExchangeStatus = enumExchangeBegin;
  1840. }
  1841. }
  1842. break;
  1843. case c2c_notifyexchange:
  1844. {
  1845. tagSearchWay *pSW = (tagSearchWay *)pData;
  1847. if (pSW->lnID < 0 || pSW->lnID >= m_nMaxPlayer)
  1848. {
  1849. printf("break 1n");
  1850. break;
  1851. }
  1853. if (m_pGameStatus[pSW->lnID].nExchangeStatus != enumExchangeSearchingWay)
  1854. {
  1855. printf("break 2n");
  1856. break;
  1857. }
  1859. int nIndex = m_pGameStatus[pSW->lnID].nPlayerIndex;
  1861. if (nIndex <= 0 || nIndex > m_nMaxPlayer || nIndex != pSW->nIndex)
  1862. {
  1863. printf("break 3n");
  1864. break;
  1865. }
  1867. if (pSW->dwPlayerID != m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ID, nIndex, 0))
  1868. {
  1869. printf("break 4n");
  1870. break;
  1871. }
  1873. char szData[1024];
  1875. RELAY_DATA *pRD = (RELAY_DATA *)szData;
  1877. pRD->ProtocolFamily = pf_relay;
  1878. pRD->ProtocolID = relay_c2c_data;
  1879. pRD->nToIP = pUnit->GetIp();
  1880. pRD->nToRelayID = pUnit->GetRelayID();
  1881. pRD->nFromIP = 0;
  1882. pRD->nFromRelayID = 0;
  1884. tagGuidableInfo gi;
  1886. TRoleData* pData = (TRoleData *)m_pCoreServerShell->PreparePlayerForExchange(nIndex);
  1888. if (!pData)
  1889. {
  1890. printf("break 5n");
  1891. break;
  1892. }
  1894. gi.cProtocol = c2c_transferroleinfo;
  1895. m_pCoreServerShell->GetGuid(nIndex, &gi.guid);
  1897. gi.nExtPoint = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_EXTPOINT, nIndex, 0);
  1898. gi.nChangePoint = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_EXTPOINTCHANGED, nIndex, 0);
  1900. pData->dwDataLen += 4;
  1901. gi.datalength = pData->dwDataLen;
  1902. DWORD dwCRC = 0;
  1903. dwCRC = CRC32(dwCRC, pData, pData->dwDataLen - 4);
  1905. m_theSend.AddData(c2c_transferroleinfo, (const char*)&gi, sizeof(tagGuidableInfo));
  1906. m_theSend.AddData(c2c_transferroleinfo, (const char*)pData, gi.datalength - 4);
  1907. m_theSend.AddData(c2c_transferroleinfo, (const char*)&dwCRC, 4);
  1909. #ifndef _STANDALONE
  1910. CBuffer* pBuffer = m_theSend.GetHeadPack(c2c_transferroleinfo, 512);
  1911. #else
  1912. size_t actLen = 0;
  1913. char* pBuffer = m_theSend.GetHeadPack(c2c_transferroleinfo, actLen, 512);
  1914. #endif
  1917. while(pBuffer)
  1918. {
  1920. #ifndef _STANDALONE
  1921. pRD->routeDateLength = pBuffer->GetUsed();
  1922. #else
  1923. pRD->routeDateLength = actLen;
  1924. #endif
  1925. _ASSERT(pRD->routeDateLength + sizeof(RELAY_DATA) < 1024);
  1927. #ifndef _STANDALONE
  1928. memcpy(szData + sizeof(RELAY_DATA), pBuffer->GetBuffer(), pBuffer->GetUsed());
  1929. #else
  1930. memcpy(szData + sizeof(RELAY_DATA), pBuffer, actLen);
  1931. #endif
  1933. m_pTransferClient->SendPackToServer(szData, pRD->routeDateLength + sizeof(RELAY_DATA));
  1934. #ifndef _STANDALONE
  1935. try
  1936. {
  1937. if (pBuffer)
  1938. {
  1939. pBuffer->Release();
  1940. pBuffer = NULL;
  1941. }
  1942. }
  1943. catch(...) 
  1944. {
  1945. //TRACE("SAFE_RELEASE errorn");
  1946. }
  1947. #endif
  1949. #ifndef _STANDALONE
  1950. pBuffer = m_theSend.GetNextPack(c2c_transferroleinfo);
  1951. #else
  1952. pBuffer = m_theSend.GetNextPack(c2c_transferroleinfo, actLen);
  1953. #endif
  1954. }
  1955. m_theSend.DelData(c2c_transferroleinfo);
  1956. #ifndef _STANDALONE
  1957. try
  1958. {
  1959. if (pBuffer)
  1960. {
  1961. pBuffer->Release();
  1962. pBuffer = NULL;
  1963. }
  1964. }
  1965. catch(...) 
  1966. {
  1967. //TRACE("SAFE_RELEASE errorn");
  1968. }
  1969. #endif
  1970. m_pGameStatus[pSW->lnID].nExchangeStatus = enumExchangeWaitForGameSvrRespone;
  1971. }
  1972. break;
  1973. }
  1974. //#endif
  1975. }
  1977. void KSwordOnLineSever::PlayerMessageProcess(const unsigned long lnID, const char* pData, size_t dataLength)
  1978. {
  1979. //#ifndef _STANDALONE
  1980. _ASSERT(pData && dataLength);
  1982. #ifndef _STANDALONE
  1983. BYTE cProtocol = CPackager::Peek( pData );
  1984. #else
  1985. BYTE cProtocol = *(BYTE *)pData;
  1986. #endif
  1988. int nGameStatus = m_pGameStatus[lnID].nGameStatus;
  1989. int nIndex = m_pGameStatus[lnID].nPlayerIndex;
  1991. BYTE protocoltype = *(BYTE*)pData;
  1992. if (protocoltype >= _c2s_begin_relay && protocoltype <= _c2s_end_relay)
  1993. {
  1994. IClient* pClient = NULL;
  1995. switch (protocoltype)
  1996. {
  1997. case c2s_extend: pClient = m_pTransferClient; break;
  1998. case c2s_extendchat: pClient = m_pChatClient; break;
  1999. case c2s_extendfriend: pClient = m_pTongClient; break;
  2000. default:
  2001. return;
  2002. };
  2004. if (pClient && nIndex && dataLength > sizeof(tagExtendProtoHeader))
  2005. {
  2006. size_t exsize = dataLength - sizeof(tagExtendProtoHeader);
  2007. const void* pExPckg = pData + sizeof(tagExtendProtoHeader);
  2009. if (protocoltype == c2s_extendchat)
  2010. {
  2011. CHAT_CHANNELCHAT_CMD* pEh = (CHAT_CHANNELCHAT_CMD*)pExPckg;
  2012. if (pEh->ProtocolType == chat_channelchat && pEh->channelid != 0) //非GM频道要过滤和付钱
  2013. {
  2014. if (!m_pCoreServerShell->PayForSpeech(nIndex, pEh->cost))
  2015. return;
  2016. }
  2017. }
  2019. size_t pckgsize = exsize + sizeof(tagPlusSrcInfo);
  2020. #ifdef WIN32
  2021. void* pPckg2 = _alloca(pckgsize);
  2022. #else
  2023. void* pPckg2 = (new char[pckgsize]);
  2024. #endif
  2025. memcpy(pPckg2, pExPckg, exsize);
  2026. tagPlusSrcInfo* pSrcInfo = (tagPlusSrcInfo*)((BYTE*)pPckg2 + exsize);
  2027. pSrcInfo->nameid = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ID, nIndex, 0);
  2028. pSrcInfo->lnID = lnID;
  2030. pClient->SendPackToServer(pPckg2, pckgsize);
  2031. #ifndef WIN32
  2032. delete (char*)pPckg2;
  2033. #endif
  2034. }
  2035. return;
  2036. }
  2037. if (!m_pCoreServerShell->CheckProtocolSize(pData, dataLength))
  2038. return;
  2040. //printf("player msg arrived...%dn", nGameStatus); //[wxb 2003-7-28]
  2041. switch(nGameStatus)
  2042. {
  2043. case enumPlayerPlaying:
  2044. if (nIndex)
  2045. {
  2046. if (*(BYTE*)pData == c2s_ping)
  2047. {
  2048. ProcessPingReply(lnID, pData, dataLength);
  2049. }
  2050. else if (*(BYTE*)pData == c2s_extendtong)
  2051. {
  2052. ProcessPlayerTongMsg(nIndex, pData, dataLength);
  2053. }
  2054. else
  2055. {
  2056. m_pCoreServerShell->ProcessClientMessage(nIndex, pData, dataLength);
  2057. }
  2058. }
  2059. break;
  2060. case enumPlayerExchangingServer:
  2061. break;
  2062. case enumPlayerSyncEnd:
  2063. if (ProcessSyncReplyProtocol(lnID, pData, dataLength))
  2064. {
  2065. m_pCoreServerShell->AddPlayerToWorld(nIndex);
  2066. m_pGameStatus[lnID].nGameStatus = enumPlayerPlaying;
  2067. PingClient(lnID);
  2069. tagEnterGame eg;
  2070. eg.cProtocol = c2s_entergame;
  2072. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ACCOUNT, (unsigned int)eg.szAccountName, nIndex);
  2074. if (m_pGatewayClient)
  2075. m_pGatewayClient->SendPackToServer( ( const void * )&eg, sizeof( tagEnterGame ) );
  2077. tagEnterGame2 eg2;
  2078. eg2.ProtocolFamily = pf_normal;
  2079. eg2.ProtocolID = c2s_entergame;
  2080. strcpy(( char * )eg2.szAccountName, (char *)eg.szAccountName);
  2081. eg2.dwNameID = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ID, nIndex, 0);
  2082. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NAME, (unsigned int)eg2.szCharacterName, nIndex);
  2083. eg2.lnID = lnID;
  2084. if (m_pTransferClient)
  2085. m_pTransferClient->SendPackToServer( (const void *)&eg2, sizeof(tagEnterGame2) );
  2087. //锁定角色数据库
  2088. tagRoleEnterGame reg;
  2089. reg.ProtocolType = c2s_roleserver_lock;
  2090. reg.bLock = true;
  2091. strcpy((char *)reg.Name, (char *)eg2.szCharacterName);
  2092. if (m_pDatabaseClient)
  2093. m_pDatabaseClient->SendPackToServer((const void *)&reg, sizeof(tagRoleEnterGame));
  2095. // 获取帮会信息
  2096. int nPlayerIdx = m_pGameStatus[lnID].nPlayerIndex;
  2097. if (nPlayerIdx > 0 && nPlayerIdx < MAX_PLAYER)
  2098. {
  2099. DWORD dwTongNameID = m_pCoreServerShell->GetGameData(SGDI_TONG_GET_TONG_NAMEID, 0, nPlayerIdx);
  2100. char szName[32];
  2101. szName[0] = 0;
  2102. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NAME, (unsigned int)szName, nPlayerIdx);
  2103. if (dwTongNameID > 0 && szName[0])
  2104. {
  2105. STONG_GET_LOGIN_DATA_COMMAND sLogin;
  2106. sLogin.ProtocolFamily = pf_tong;
  2107. sLogin.ProtocolID = enumC2S_TONG_GET_LOGIN_DATA;
  2108. sLogin.m_dwParam = nPlayerIdx;
  2109. sLogin.m_dwTongNameID = dwTongNameID;
  2110. strcpy(sLogin.m_szName, szName);
  2111. if (m_pTongClient)
  2112. m_pTongClient->SendPackToServer((const void*)&sLogin, sizeof(sLogin));
  2113. }
  2114. m_pCoreServerShell->GetGameData(SGDI_TONG_SEND_SELF_INFO, 0, nPlayerIdx);
  2115. }
  2116. }
  2117. break;
  2118. case enumPlayerBegin:
  2119. {
  2120. int nIndex = ProcessLoginProtocol(lnID, pData, dataLength);
  2121. //printf("process login %d...n", nIndex);
  2122. if (nIndex)
  2123. {
  2124. if (SendGameDataToClient(lnID, nIndex))
  2125. {
  2126. //printf("process login %d ok...n", nIndex);
  2127. m_pGameStatus[lnID].nGameStatus = enumPlayerSyncEnd;
  2128. m_pGameStatus[lnID].nPlayerIndex = nIndex;
  2129. }
  2131. else
  2132. {
  2133. //printf("process login %d fail...n", nIndex);
  2134. m_pGameStatus[lnID].nGameStatus = enumPlayerBegin;
  2135. m_pGameStatus[lnID].nPlayerIndex = nIndex;
  2136. #ifndef _STANDALONE
  2137. m_pServer->ShutdownClient(lnID);
  2138. #endif
  2139. }
  2140. }
  2141. }
  2142. break;
  2143. }
  2144. //printf("player msg over..n");
  2145. //#endif
  2146. }
  2148. void KSwordOnLineSever::GatewayMessageProcess(const char* pData, size_t dataLength)
  2149. {
  2150. _ASSERT(pData && dataLength);
  2152. #ifndef _STANDALONE
  2153. BYTE cProtocol = CPackager::Peek( pData );
  2154. #else
  2155. BYTE cProtocol = *(unsigned char *)pData;
  2156. #endif
  2158. if ( cProtocol < s2c_micropackbegin )
  2159. {
  2160. GatewayLargePackProcess(pData, dataLength);
  2161. }
  2162. else if ( cProtocol > s2c_micropackbegin )
  2163. {
  2164. GatewaySmallPackProcess(pData, dataLength);
  2165. }
  2166. else
  2167. {
  2168. _ASSERT( FALSE && "Error!" );
  2169. }
  2170. }
  2172. void KSwordOnLineSever::GatewayLargePackProcess(const void *pData, size_t dataLength)
  2173. {
  2174. #ifndef _STANDALONE
  2175. _ASSERT( pData && dataLength );
  2177. CBuffer *pBuffer = m_theRecv.PackUp( pData, dataLength );
  2178. #else
  2179. char *pBuffer = m_theRecv.PackUp( pData, dataLength );
  2180. #endif
  2181. if ( pBuffer )
  2182. {
  2183. #ifndef _STANDALONE
  2184. BYTE cProtocol = CPackager::Peek( pBuffer->GetBuffer() );
  2185. #else
  2186. BYTE cProtocol = *(BYTE *)pBuffer;
  2187. #endif
  2188. switch ( cProtocol )
  2189. {
  2190. case s2c_syncgamesvr_roleinfo_cipher:
  2191. {
  2192. #ifndef _STANDALONE
  2193. tagGuidableInfo *pGI = ( tagGuidableInfo * )pBuffer->GetBuffer();
  2194. #else
  2195. tagGuidableInfo *pGI = ( tagGuidableInfo * )pBuffer;
  2196. #endif
  2197. GUID guid;
  2198. memcpy( &guid, &( pGI->guid ), sizeof( GUID ) );
  2200. if ( pGI->datalength > 0 )
  2201. {
  2202. const TRoleData *pRoleData = ( const TRoleData * )( pGI->szData );
  2204. BOOL bCRCCheck = TRUE;
  2205. if (pRoleData->dwFriendOffset == pRoleData->dwDataLen - 4 && pRoleData->nFriendCount == 0)
  2206. {
  2207. // 说明是加过校验的，所以好友的偏移比长度少了4个字节
  2208. DWORD dwCRC = 0;
  2209. dwCRC = CRC32(dwCRC, pRoleData, pRoleData->dwDataLen - 4);
  2210. DWORD dwCheck = *(DWORD *)(pGI->szData + pRoleData->dwDataLen - 4);
  2211. if (dwCheck != dwCRC)
  2212. {
  2213. FILE *fLog = fopen("crc_db_error", "a+b");
  2214. if(fLog) 
  2215. {
  2216. char buffer[255];
  2217. sprintf(buffer, "----rn%srb%srn", pRoleData->BaseInfo.szName, pRoleData->BaseInfo.caccname);
  2218. fwrite(buffer, 1, strlen(buffer), fLog);
  2219. fwrite(pRoleData, 1, pRoleData->dwDataLen, fLog);
  2220. fclose(fLog);
  2221. }
  2222. bCRCCheck = FALSE;
  2223. }
  2224. }
  2225. // cout << "AccName : " << pRoleData->BaseInfo.caccname;
  2226. // cout << " - Name : " << pRoleData->BaseInfo.szName << endl;
  2227. tagPermitPlayerLogin ppl;
  2228. ppl.cProtocol = c2s_permitplayerlogin;
  2229. memcpy( &( ppl.guid ), &guid, sizeof( GUID ) );
  2230. strcpy( ( char * )( ppl.szRoleName ), ( const char * )( pRoleData->BaseInfo.szName ) );
  2231. ppl.bPermit = false;
  2233. KCoreConnectInfo Info;
  2234. int nCurrentPlayerCount = m_pCoreServerShell->GetConnectInfo(&Info);
  2236. if (Info.nNumPlayer < m_nMaxPlayer && bCRCCheck ) // 去掉注释CRC错的用户就无法进入游戏了
  2237. {
  2238. int nIdx = m_pCoreServerShell->AddCharacter(pGI->nExtPoint, pGI->nChangePoint, (void *)pRoleData, &guid);
  2240. if (nIdx > 0)
  2241. {
  2242. ppl.bPermit = true;
  2243. }
  2245. }
  2246. m_pGatewayClient->SendPackToServer( ( const void * )&ppl, sizeof( tagPermitPlayerLogin ) );
  2247. }
  2248. }
  2249. break;
  2251. default:
  2252. break;
  2253. }
  2255. #ifndef _STANDALONE
  2256. try
  2257. {
  2258. if( pBuffer != NULL )
  2259. {
  2260. pBuffer->Release();
  2261. pBuffer = NULL; 
  2262. }
  2263. }
  2264. catch(...) 
  2265. {
  2266. //TRACE("SAFE_RELEASE errorn");
  2267. }
  2268. #endif
  2269. }
  2270. }
  2272. void KSwordOnLineSever::GatewaySmallPackProcess(const void *pData, size_t dataLength)
  2273. {
  2274. _ASSERT( pData && dataLength );
  2276. #ifndef _STANDALONE
  2277. BYTE cProtocol = CPackager::Peek( pData );
  2278. #else 
  2279. BYTE cProtocol = *(BYTE *)pData;
  2280. #endif
  2281. /* printf("-----REALndatalen = %u, data = ", dataLength);
  2282. for (int i = 0; i < 32; i++)
  2283. printf("[%02X] ", ((BYTE *)pData)[i]);
  2284. printf("n");*/
  2285. switch ( cProtocol )
  2286. {
  2287. case s2c_querymapinfo:
  2288. {
  2289. tagUpdateMapID *pUMI;
  2290. char sMapID[80];
  2292. int nMapCount = m_pCoreServerShell->GetGameData(SGDI_LOADEDMAP_ID, (unsigned int)&sMapID, sizeof(sMapID));
  2293. pUMI = ( tagUpdateMapID * )new BYTE[ nMapCount * sizeof(char) + sizeof( tagUpdateMapID ) ];
  2294. memset( pUMI, 0, nMapCount * sizeof(char) + sizeof( tagUpdateMapID ) );
  2296. pUMI->cProtocol = c2s_updatemapinfo;
  2297. pUMI->cMapCount = nMapCount;
  2298. memcpy( pUMI->szMapID, sMapID, nMapCount * sizeof(char));
  2300. /* printf("-----Send ndatalen = %u, data = ", nMapCount * sizeof(char) + sizeof( tagUpdateMapID ));
  2301. for (int i = 0; i < 32; i++)
  2302. printf("[%02X] ", ((BYTE *)pUMI)[i]);
  2303. printf("n");*/
  2304. m_pGatewayClient->SendPackToServer( ( const void * )pUMI, nMapCount * sizeof(char) + sizeof( tagUpdateMapID ) );
  2306. if(pUMI)
  2307. {
  2308. delete pUMI;
  2309. pUMI = NULL;
  2310. }
  2311. }
  2312. break;
  2314. case s2c_querygameserverinfo:
  2315. {
  2316. tagGameSvrInfo ni;
  2318. ni.cProtocol = c2s_updategameserverinfo;
  2320. ni.nIPAddr_Internet = m_dwInternetIp;
  2321. ni.nIPAddr_Intraner = m_dwIntranetIp;
  2322. ni.nPort = m_nServerPort;
  2323. ni.wCapability = m_nMaxPlayerCount;
  2325. m_pGatewayClient->SendPackToServer( ( const void * )&ni, sizeof( tagGameSvrInfo ) );
  2327. }
  2328. break;
  2329. case s2c_gateway_broadcast:
  2330. GatewayBoardCastProcess((const char*)pData, dataLength);
  2331. break;
  2332. }
  2333. }
  2335. void KSwordOnLineSever::GatewayBoardCastProcess(const char* pData, size_t dataLength)
  2336. {
  2337. //#ifndef _STANDALONE
  2338. if (dataLength != sizeof(tagGatewayBroadCast))
  2339. return;
  2341. tagGatewayBroadCast *pGatewayBroadCast;
  2342. pGatewayBroadCast = (tagGatewayBroadCast *)pData;
  2343. //printf("BroadCast type = %d, %08x, %08x, %dn",pGatewayBroadCast->uCmdType, (unsigned int)pGatewayBroadCast->szData, pGatewayBroadCast->szData, strlen(pGatewayBroadCast->szData));
  2344. switch(pGatewayBroadCast->uCmdType)
  2345. {
  2346. case AP_WARNING_ALL_PLAYER_QUIT:
  2347. {
  2348. m_pCoreServerShell->OperationRequest(SSOI_BROADCASTING, (unsigned int)pGatewayBroadCast->szData, strlen(pGatewayBroadCast->szData));
  2349. // TODO: Save Player and ExitGame when time out
  2350. printf("ALL_PLAYER_QUITn");
  2351. SetRunningStatus(FALSE);
  2352. // ExitAllPlayer();
  2353. }
  2354. break;
  2355. case AP_NOTIFY_GAMESERVER_SAFECLOSE:
  2356. {
  2357. m_pCoreServerShell->OperationRequest(SSOI_BROADCASTING, (unsigned int)pGatewayBroadCast->szData, strlen(pGatewayBroadCast->szData));
  2358. printf("Safe close servern");
  2359. SetRunningStatus(FALSE);
  2360. }
  2361. break;
  2362. case AP_NOTIFY_ALL_PLAYER:
  2363. {
  2364. m_pCoreServerShell->OperationRequest(SSOI_BROADCASTING, (unsigned int)pGatewayBroadCast->szData, strlen(pGatewayBroadCast->szData));
  2365. }
  2366. break;
  2367. default:
  2368. break;
  2369. }
  2370. //#endif
  2371. }
  2373. void KSwordOnLineSever::MainLoop()
  2374. {
  2375. #ifndef _STANDALONE
  2376. CCriticalSection::Owner locker( g_csFlow );
  2377. #else
  2378. g_mutexFlow.lock();
  2379. #endif
  2382. SavePlayerData();
  2383. PlayerLogoutGateway();
  2384. PlayerExchangeServer();
  2385. // m_pServer->PreparePackSink(); 空函数，没有调用的必要
  2386. m_pCoreServerShell->Breathe();
  2388. // 定期向数据库查询排名情况
  2389. #define defMAX_STAT_QUERY_TIME 18000 * 20 // 5小时查询
  2391. if ( 0 == ( m_nGameLoop % defMAX_STAT_QUERY_TIME ) )
  2392. {
  2393. if (m_pDatabaseClient)
  2394. {
  2395. TProcessData ProcessData;
  2397. ProcessData.nProtoId = c2s_gamestatistic;
  2398. ProcessData.nDataLen = 1;
  2399. ProcessData.ulIdentity = -1;
  2400. ProcessData.pDataBuffer[0] = 0;
  2401. m_pDatabaseClient->SendPackToServer(&ProcessData, sizeof(TProcessData));
  2402. }
  2403. }
  2405. // 检查玩家是否很长时间没有发PING值了（1min）
  2406. int lnID = m_nGameLoop % m_nMaxPlayer;
  2407. int nIndex = m_pGameStatus[lnID].nPlayerIndex;
  2408. if (nIndex > 0 && nIndex <= m_nMaxPlayer && m_pGameStatus[lnID].nGameStatus == enumPlayerPlaying)
  2409. {
  2410. #define defMAX_PING_TIMEOUT 60 * 20 // 60sec
  2411. #define defMAX_PING_INTERVAL 5 * 20
  2413. if (m_pGameStatus[lnID].nReplyPingTime != 0)
  2414. {
  2415. if (m_nGameLoop - m_pGameStatus[lnID].nSendPingTime > defMAX_PING_INTERVAL)
  2416. {
  2417. //printf("Send ping to client....n");
  2418. PingClient(lnID);
  2419. }
  2420. }
  2421. else if (m_nGameLoop - m_pGameStatus[lnID].nSendPingTime > defMAX_PING_TIMEOUT)
  2422. {
  2423. printf("no response from client(%d, %d), kill it...n", m_nGameLoop, m_pGameStatus[lnID].nSendPingTime);
  2424. m_pServer->ShutdownClient(lnID);
  2425. }
  2426. }
  2428. if (m_nGameLoop & 0x01)
  2429. {
  2430. m_pServer->SendPackToClient(-1);
  2431. }
  2432. m_nGameLoop++;
  2433. #ifdef _STANDALONE
  2434. g_mutexFlow.unlock();
  2435. #endif
  2436. }
  2438. void KSwordOnLineSever::PingClient(const unsigned long lnID)
  2439. {
  2440. _ASSERT(lnID < m_nMaxPlayer);
  2441. _ASSERT(m_pGameStatus[lnID].nPlayerIndex > 0 && m_pGameStatus[lnID].nPlayerIndex <= m_nMaxPlayer);
  2443. //printf("PingClient(%d) calledn", lnID);
  2444. PING_COMMAND pc;
  2445. pc.m_dwTime = m_nGameLoop;
  2446. pc.ProtocolType = s2c_ping;
  2447. m_pServer->PackDataToClient(lnID, &pc, sizeof(PING_COMMAND));
  2448. m_pGameStatus[lnID].nReplyPingTime = 0;
  2449. m_pGameStatus[lnID].nSendPingTime = m_nGameLoop;
  2450. }
  2452. void KSwordOnLineSever::ProcessPingReply(const unsigned long lnID, const char* pData, size_t dataLength)
  2453. {
  2454. _ASSERT(lnID < m_nMaxPlayer);
  2455. _ASSERT(m_pGameStatus[lnID].nPlayerIndex > 0 && m_pGameStatus[lnID].nPlayerIndex <= m_nMaxPlayer);
  2457. //printf("receive ping from client...n");
  2458. if (dataLength != sizeof(PING_CLIENTREPLY_COMMAND))
  2459. {
  2460. printf("ping cmd size not correct, may be Non-offical Client...n");
  2461. m_pServer->ShutdownClient(lnID);
  2462. return;
  2463. }
  2465. PING_CLIENTREPLY_COMMAND* pPC = (PING_CLIENTREPLY_COMMAND *)pData;
  2466. if (pPC->m_dwReplyServerTime != m_pGameStatus[lnID].nSendPingTime)
  2467. {
  2468. printf("wrong time in ping cmd content, kill it...n");
  2469. m_pServer->ShutdownClient(lnID);
  2470. return;
  2471. }
  2472. m_pGameStatus[lnID].nReplyPingTime = m_nGameLoop;
  2473. // reply client ping to client to announce ping interval;
  2474. PING_COMMAND pc;
  2475. pc.ProtocolType = s2c_replyclientping;
  2476. pc.m_dwTime = pPC->m_dwClientTime;
  2477. m_pServer->PackDataToClient(lnID, &pc, sizeof(PING_COMMAND));
  2478. }
  2480. // 保持连接的玩家自动存盘
  2481. void KSwordOnLineSever::SavePlayerData()
  2482. {
  2483. if (!m_pDatabaseClient)
  2484. return;
  2486. int i = 0;
  2488. TProcessData sProcessData;
  2490. sProcessData.nProtoId = c2s_roleserver_saveroleinfo;
  2491. sProcessData.ulIdentity = -1;
  2493. // 遍历网络连接
  2494. for (i = 0; i < m_nMaxPlayer; i++)
  2495. {
  2496. if (GetNetStatus(i) == enumNetUnconnect)
  2497. continue;
  2499. int nIndex = m_pGameStatus[i].nPlayerIndex;
  2501. if (nIndex <= 0 ||nIndex > m_nMaxPlayer)
  2502. continue;
  2504. //TRoleData* pData = (TRoleData *)m_pCoreServerShell->SavePlayerData(nIndex); 
  2505. if (m_pCoreServerShell->GetSaveStatus(nIndex) == SAVE_REQUEST)
  2506. {
  2507. SavePlayerData(nIndex, false);
  2508. }
  2509. }
  2510. }
  2512. BOOL KSwordOnLineSever::SavePlayerData(int nIndex, bool bUnLock)
  2513. {
  2514. if (!m_pDatabaseClient)
  2515. return FALSE;
  2517. if (nIndex <= 0 ||nIndex > m_nMaxPlayer)
  2518. return FALSE;
  2520. TProcessData sProcessData;
  2522. sProcessData.nProtoId = c2s_roleserver_saveroleinfo;
  2523. sProcessData.ulIdentity = nIndex;
  2524. sProcessData.bLeave = bUnLock;
  2526. TRoleData* pData = (TRoleData *)m_pCoreServerShell->SavePlayerDataAtOnce(nIndex);
  2527. if (pData && pData->dwDataLen)
  2528. {
  2529. sProcessData.nDataLen = pData->dwDataLen + sizeof(TProcessData) - 1;
  2530. pData->dwDataLen += 4;
  2531. // CRC
  2532. DWORD dwCRC = 0;
  2533. dwCRC = CRC32(dwCRC, pData, pData->dwDataLen - 4);
  2534. // CRC END
  2536. m_theSend.AddData(c2s_roleserver_saveroleinfo, (const char*)&sProcessData, sizeof(TProcessData) - 1);
  2537. m_theSend.AddData(c2s_roleserver_saveroleinfo, (const char*)pData, pData->dwDataLen - 4);
  2538. m_theSend.AddData(c2s_roleserver_saveroleinfo, (const char*)&dwCRC, 4);
  2540. #ifndef _STANDALONE
  2541. CBuffer* pBuffer = m_theSend.GetHeadPack(c2s_roleserver_saveroleinfo);
  2542. #else
  2543. size_t actLen = 0;
  2544. char* pBuffer = m_theSend.GetHeadPack(c2s_roleserver_saveroleinfo, actLen);
  2545. #endif
  2547. while(pBuffer)
  2548. {
  2549. #ifndef _STANDALONE
  2550. m_pDatabaseClient->SendPackToServer(pBuffer->GetBuffer(), pBuffer->GetUsed());
  2551. #else
  2552. m_pDatabaseClient->SendPackToServer(pBuffer, actLen);
  2553. #endif
  2554. // cout << "Save small package:" << pBuffer->GetUsed() << endl;
  2555. #ifndef _STANDALONE
  2556. try
  2557. {
  2558. if (pBuffer)
  2559. {
  2560. pBuffer->Release();
  2561. pBuffer = NULL;
  2562. }
  2563. }
  2564. catch(...) 
  2565. {
  2566. //TRACE("SAFE_RELEASE errorn");
  2567. }
  2568. #endif
  2570. #ifndef _STANDALONE
  2571. pBuffer = m_theSend.GetNextPack(c2s_roleserver_saveroleinfo);
  2572. #else
  2573. pBuffer = m_theSend.GetNextPack(c2s_roleserver_saveroleinfo, actLen);
  2574. #endif
  2575. }
  2576. m_theSend.DelData(c2s_roleserver_saveroleinfo);
  2577. #ifndef _STANDALONE
  2578. try
  2579. {
  2580. if (pBuffer)
  2581. {
  2582. pBuffer->Release();
  2583. pBuffer = NULL;
  2584. }
  2585. }
  2586. catch(...) 
  2587. {
  2588. //TRACE("SAFE_RELEASE errorn");
  2589. }
  2590. #endif
  2591. //printf("Saving %s(%d)'s data, size:(%d)...n", pData->BaseInfo.szName, nIndex, sProcessData.nDataLen);
  2592. m_pCoreServerShell->SetSaveStatus(nIndex, SAVE_DOING);
  2593. //printf("Save Player %d data ok.....n", nIndex);
  2594. return TRUE;
  2595. }
  2596. //printf("Save Player %d data failed.....n", nIndex);
  2597. return FALSE;
  2598. }
  2600. void KSwordOnLineSever::PlayerExchangeServer()
  2601. {
  2602. if (!m_pGatewayClient || !m_pCoreServerShell)
  2603. return;
  2605. int i;
  2607. char szChar[1024];
  2608. // 遍历网络连接
  2609. for (i = 0; i < m_nMaxPlayer; i++)
  2610. {
  2611. int nIndex = m_pGameStatus[i].nPlayerIndex;
  2612. if (nIndex <= 0 || nIndex > m_nMaxPlayer)
  2613. continue;
  2614. if (m_pCoreServerShell->IsPlayerExchangingServer(nIndex))
  2615. {
  2616. if (!m_pTransferClient)
  2617. {
  2618. tagNotifyPlayerExchange npe;
  2619. npe.cProtocol = s2c_notifyplayerexchange;
  2620. memset(&npe.guid, 0, sizeof(GUID));
  2621. // if false, ip to 0
  2622. npe.nIPAddr = 0;
  2623. npe.nPort = 0;
  2624. m_pServer->SendData(i, &npe, sizeof(tagNotifyPlayerExchange));
  2626. m_pCoreServerShell->RecoverPlayerExchange(nIndex);
  2628. tagRoleEnterGame reg;
  2629. reg.ProtocolType = c2s_roleserver_lock;
  2630. reg.bLock = true;
  2631. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NAME, (unsigned int)reg.Name, nIndex);
  2632. if (m_pDatabaseClient)
  2633. m_pDatabaseClient->SendPackToServer((const void *)&reg, sizeof(tagRoleEnterGame));
  2635. m_pGameStatus[i].nGameStatus = enumPlayerPlaying;
  2636. m_pGameStatus[i].nExchangeStatus = enumExchangeBegin;
  2637. continue;
  2638. }
  2639. m_pGameStatus[i].nGameStatus = enumPlayerExchangingServer;
  2640. switch (m_pGameStatus[i].nExchangeStatus)
  2641. {
  2642. case enumExchangeBegin:
  2643. {
  2644. if (!SavePlayerData(nIndex, true))
  2645. continue;
  2646. RELAY_ASKWAY_DATA *pRAD = (RELAY_ASKWAY_DATA *)szChar;
  2648. pRAD->ProtocolFamily = pf_relay;
  2649. pRAD->ProtocolID = relay_c2c_askwaydata;
  2651. pRAD->nFromIP = 0; // 0.0.0.0
  2652. pRAD->nFromRelayID = 0;
  2653. pRAD->seekRelayCount = 0;
  2654. // 利用地图ID找SERVER
  2655. pRAD->seekMethod = rm_map_id;
  2656. pRAD->wMethodDataLength = 4;
  2657. pRAD->routeDateLength = sizeof(tagSearchWay);
  2659. *(DWORD *)(szChar + sizeof(RELAY_ASKWAY_DATA)) = m_pCoreServerShell->GetExchangeMap(nIndex);
  2661. tagSearchWay *pSW = (tagSearchWay *)(szChar + sizeof(RELAY_ASKWAY_DATA) + pRAD->wMethodDataLength);
  2662. // pSW->ProtocolFamily = pf_gameworld;
  2663. // pSW->ProtocolID = c2c_notifyexchange;
  2664. pSW->cProtocol = c2c_notifyexchange;
  2665. pSW->lnID = i;
  2666. pSW->nIndex = m_pGameStatus[i].nPlayerIndex;
  2667. pSW->dwPlayerID = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ID, pSW->nIndex, 0);
  2668. // ask another game svr ip
  2669. m_pTransferClient->SendPackToServer(pRAD, sizeof(RELAY_ASKWAY_DATA) + pRAD->wMethodDataLength + pRAD->routeDateLength);
  2670. m_pGameStatus[i].nExchangeStatus = enumExchangeSearchingWay;
  2671. }
  2672. break;
  2673. case enumExchangeSearchingWay:
  2674. break;
  2675. case enumExchangeWaitForGameSvrRespone:
  2676. {
  2677. }
  2678. break;
  2679. case enumExchangeCleaning:
  2680. {
  2681. }
  2682. break;
  2683. }
  2684. }
  2685. }
  2686. }
  2688. void KSwordOnLineSever::PlayerLogoutGateway()
  2689. {
  2690. if (!m_pGatewayClient || !m_pCoreServerShell)
  2691. return;
  2693. tagLeaveGame sLeaveGame;
  2694. sLeaveGame.cProtocol = c2s_leavegame;
  2695. sLeaveGame.cCmdType = NORMAL_LEAVEGAME;
  2697. tagLeaveGame2 lg2;
  2699. lg2.ProtocolFamily = pf_normal;
  2700. lg2.ProtocolID = c2s_leavegame;
  2701. lg2.cCmdType = NORMAL_LEAVEGAME;
  2703. // 遍历玩家（不能遍历连接，因为Timeout部分的玩家没有连接）
  2704. for (int nIndex = 1; nIndex < MAX_PLAYER; nIndex++)
  2705. {
  2706. // Clear player which connect to gateway but not connect to gamesvr
  2707. if (m_pCoreServerShell->IsPlayerLoginTimeOut(nIndex))
  2708. {
  2709. char szName[32];
  2710. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ACCOUNT, (unsigned int)szName, nIndex);
  2711. sLeaveGame.nExtPoint = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_EXTPOINTCHANGED, nIndex, 0);
  2712. strcpy((char *)sLeaveGame.szAccountName, (char *)szName);
  2713. m_pGatewayClient->SendPackToServer(&sLeaveGame, sizeof(tagLeaveGame));
  2715. strcpy((char *)lg2.szAccountName, (char *)szName);
  2717. if (m_pTransferClient)
  2718. m_pTransferClient->SendPackToServer(&lg2, sizeof(tagLeaveGame2));
  2719. // cout << sLeaveGame.szAccountName << " leave game!" << endl;
  2720. m_pCoreServerShell->RemovePlayerLoginTimeOut(nIndex);
  2721. }
  2722. else if (m_pCoreServerShell->IsCharacterQuiting(nIndex))
  2723. {
  2724. SavePlayerData(nIndex, true);
  2725. // if (!SavePlayerData(nIndex))
  2726. // continue;
  2728. char szName[32];
  2729. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ACCOUNT, (unsigned int)szName, nIndex);
  2731. sLeaveGame.nExtPoint = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_EXTPOINTCHANGED, nIndex, 0);
  2733. strcpy((char *)sLeaveGame.szAccountName, (char *)szName);
  2734. m_pGatewayClient->SendPackToServer(&sLeaveGame, sizeof(tagLeaveGame));
  2736. strcpy((char *)lg2.szAccountName, (char *)szName);
  2738. if (m_pTransferClient)
  2739. m_pTransferClient->SendPackToServer(&lg2, sizeof(tagLeaveGame2));
  2740. // cout << sLeaveGame.szAccountName << " leave game!" << endl;
  2741. /*
  2742. m_pGameStatus[lnID].nExchangeStatus = enumExchangeBegin;
  2743. m_pGameStatus[lnID].nGameStatus = enumPlayerBegin;
  2744. m_pGameStatus[lnID].nPlayerIndex = 0;
  2745. */
  2746. m_pCoreServerShell->RemoveQuitingPlayer(nIndex);
  2747. }
  2749. }
  2750. }
  2752. int KSwordOnLineSever::GetNetStatus(const unsigned long lnID)
  2753. {
  2754. if (lnID >= m_nMaxPlayer)
  2755. return enumNetUnconnect;
  2757. return m_pGameStatus[lnID].nNetStatus;
  2758. }
  2760. void KSwordOnLineSever::SetNetStatus(const unsigned long lnID, NetStatus nStatus)
  2761. {
  2762. if (lnID >= m_nMaxPlayer)
  2763. return;
  2765. if (nStatus == enumNetUnconnect)
  2766. {
  2767. if (m_pGameStatus[lnID].nGameStatus == enumPlayerPlaying
  2768. || (m_pGameStatus[lnID].nGameStatus == enumPlayerExchangingServer 
  2769. && m_pGameStatus[lnID].nExchangeStatus != enumExchangeCleaning)) // 跨服务器时自己处理
  2770. {
  2771. int nIndex = m_pGameStatus[lnID].nPlayerIndex;
  2772. m_pCoreServerShell->ClientDisconnect(nIndex);
  2773. }
  2774. else
  2775. {
  2776. int nIndex = m_pGameStatus[lnID].nPlayerIndex;
  2777. m_pCoreServerShell->PreparePlayerForLoginFailed(nIndex);
  2778. }
  2779. m_pGameStatus[lnID].nGameStatus = enumPlayerBegin;
  2780. m_pGameStatus[lnID].nPlayerIndex = 0;
  2781. m_pGameStatus[lnID].nExchangeStatus = enumExchangeBegin;
  2782. m_pGameStatus[lnID].nReplyPingTime = 0;
  2783. m_pGameStatus[lnID].nSendPingTime = 0;
  2784. }
  2785. if (nStatus == enumNetConnected)
  2786. {
  2787. m_pGameStatus[lnID].nGameStatus = enumPlayerBegin;
  2788. m_pGameStatus[lnID].nPlayerIndex = 0;
  2789. m_pGameStatus[lnID].nExchangeStatus = enumExchangeBegin;
  2790. m_pGameStatus[lnID].nReplyPingTime = 0;
  2791. m_pGameStatus[lnID].nSendPingTime = 0;
  2792. }
  2793. m_pGameStatus[lnID].nNetStatus = nStatus;
  2794. }
  2796. int KSwordOnLineSever::ProcessLoginProtocol(const unsigned long lnID, const char* pData, size_t dataLength)
  2797. {
  2798. const char* pBuffer = pData;
  2800. if (*pBuffer != c2s_logiclogin)
  2801. {
  2802. return 0;
  2803. }
  2804. else
  2805. {
  2806. tagLogicLogin *pLL = ( tagLogicLogin * )pData;
  2807. // cout << "A client try to login..." << endl;
  2809. int nIdx = m_pCoreServerShell->AttachPlayer(lnID, &pLL->guid);
  2810. if (nIdx)
  2811. {
  2812. // cout << "Found player " << nIdx << " is logging in system!" << endl;
  2813. return nIdx;
  2814. }
  2815. else
  2816. {
  2817. // 非法的玩家，该怎么处理怎么处理
  2818. return 0;
  2819. }
  2820. }
  2821. return 0;
  2822. }
  2824. BOOL KSwordOnLineSever::SendGameDataToClient(const unsigned long lnID, const int nPlayerIndex)
  2825. {
  2826. BOOL bRet = FALSE;
  2827. //#ifndef _STANDALONE
  2828. _ASSERT(m_pServer);
  2830. int nStep = 0;
  2831. unsigned int nParam = 0;
  2832. int bSyncEnd = 0;
  2834. m_pServer->PreparePackSink();
  2835. while(true)
  2836. {
  2837. bSyncEnd = (nStep == STEP_SYNC_END);
  2838. bRet = m_pCoreServerShell->PlayerDbLoading(nPlayerIndex, bSyncEnd, nStep, nParam);
  2839. if (!bRet)
  2840. {
  2841. printf("PlayerDbLoading failed.n"); //[wxb 2003-7-28]
  2842. break;
  2843. }
  2844. if (bSyncEnd)
  2845. {
  2846. m_pGameStatus[lnID].nGameStatus = enumPlayerSyncEnd;
  2848. BYTE SyncEnd;
  2849. SyncEnd = s2c_syncend;
  2850. #ifndef _STANDALONE
  2851. if (FAILED(m_pServer->PackDataToClient(lnID, &SyncEnd, sizeof(BYTE))))
  2852. #else
  2853. if (!SUCCEEDED(m_pServer->PackDataToClient(lnID, &SyncEnd, sizeof(BYTE))))
  2854. #endif
  2855. {
  2856. printf("Packing failed. %d, %d, %dn", lnID); //[wxb 2003-7-28]
  2857. bRet = FALSE;
  2858. break;
  2859. }
  2860. g_DebugLog("[TRACE]SyncEnd:%d", lnID);
  2861. break;
  2862. }
  2863. }
  2865. #ifdef WIN32
  2866. if (FAILED(m_pServer->SendPackToClient(lnID)))
  2867. {
  2868. bRet = FALSE;
  2869. }
  2870. #else
  2871. if (m_pServer->SendPackToClient(lnID) <= 0)
  2872. bRet = FALSE;
  2873. #endif
  2874. return bRet;
  2875. }
  2877. BOOL KSwordOnLineSever::ProcessSyncReplyProtocol(const unsigned long lnID, const char* pData, size_t dataLength)
  2878. {
  2879. const char* pBuffer = pData;
  2881. if (*pBuffer != c2s_syncend)
  2882. {
  2883. return FALSE;
  2884. }
  2885. else
  2886. {
  2887. return TRUE;
  2888. }
  2889. return FALSE;
  2890. }
  2892. void KSwordOnLineSever::ExitAllPlayer()
  2893. {
  2894. #ifndef __linux //SwitchToThread();
  2895. Sleep(4000);
  2896. #else
  2897. usleep(4000000);
  2898. #endif
  2900. int lnID;
  2901. const char* pData;
  2902. unsigned int uSize;
  2903. tagLeaveGame sLeaveGame;
  2905. sLeaveGame.cProtocol = c2s_leavegame;
  2906. sLeaveGame.cCmdType = NORMAL_LEAVEGAME;
  2908. for (lnID = 0; lnID < m_nMaxPlayer; lnID++)
  2909. {
  2910. int nIndex = m_pGameStatus[lnID].nPlayerIndex;
  2911. if (nIndex == 0)
  2912. continue;
  2913. BOOL bSave = SavePlayerData(nIndex, true);
  2914. int nCount = 0;
  2915. while(bSave)
  2916. {
  2917. nCount++;
  2918. pData = (const char *)m_pDatabaseClient->GetPackFromServer(uSize);
  2919. if (pData && uSize)
  2920. {
  2921. DatabaseMessageProcess(pData, uSize);
  2922. if (m_pCoreServerShell->GetSaveStatus(nIndex) == SAVE_IDLE)
  2923. break;
  2924. }
  2925. if (nCount > 1000)
  2926. break;
  2927. #ifdef WIN32
  2928. Sleep(1);
  2929. #else
  2930. usleep(1000);
  2931. #endif
  2932. }
  2934. m_pCoreServerShell->ClientDisconnect(nIndex);
  2935. if (m_pCoreServerShell->IsCharacterQuiting(nIndex))
  2936. {
  2937. char szName[32];
  2939. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ACCOUNT, (unsigned int)szName, nIndex);
  2940. sLeaveGame.nExtPoint = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_EXTPOINTCHANGED, nIndex, 0);
  2942. strcpy((char *)sLeaveGame.szAccountName, (char *)szName);
  2943. m_pGatewayClient->SendPackToServer(&sLeaveGame, sizeof(tagLeaveGame));
  2944. if (m_pTransferClient)
  2945. m_pTransferClient->SendPackToServer(&sLeaveGame, sizeof(tagLeaveGame));
  2946. m_pCoreServerShell->RemoveQuitingPlayer(nIndex);
  2947. }
  2948. #ifdef WIN32
  2949. Sleep(1);
  2950. #else
  2951. usleep(1000);
  2952. #endif
  2953. }
  2954. }
  2956. void KSwordOnLineSever::SetRunningStatus(BOOL bStatus)
  2957. {
  2958. m_bIsRunning = bStatus;
  2959. }
  2961. BOOL KSwordOnLineSever::ConformAskWay(const void* pData, int nSize, DWORD *lpnNetID)
  2962. {
  2963. BOOL bRet = FALSE;
  2964. RELAY_ASKWAY_DATA* pRAD = (RELAY_ASKWAY_DATA *)pData;
  2966. // TODO: 检查是否寻路正确
  2967. int nMethod = pRAD->seekMethod;
  2968. switch(nMethod)
  2969. {
  2970. case rm_role_id:
  2971. case rm_account_id:
  2972. {
  2973. DWORD dwNameID;
  2974. DWORD lnID;
  2975. LPDWORD lpdwPTR = (DWORD *)(((char *)pData) + sizeof(RELAY_ASKWAY_DATA) + pRAD->wMethodDataLength - sizeof(DWORD)*2);
  2976. dwNameID = *lpdwPTR;
  2977. lnID = *(lpdwPTR + 1);
  2978. if (lnID >= m_nMaxPlayer || m_pGameStatus[lnID].nPlayerIndex <= 0 || m_pGameStatus[lnID].nPlayerIndex > m_nMaxPlayer)
  2979. {
  2980. bRet = FALSE;
  2981. break;
  2982. }
  2983. DWORD dwNameIDbyIndex = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ID, m_pGameStatus[lnID].nPlayerIndex, 0);
  2984. if (dwNameIDbyIndex != dwNameID)
  2985. {
  2986. bRet = FALSE;
  2987. break;
  2988. }
  2989. *lpnNetID = lnID;
  2990. bRet = TRUE;
  2991. }
  2992. break;
  2993. case rm_map_id:
  2994. {
  2995. DWORD dwMapID;
  2997. dwMapID = *(DWORD *)(((char *)pData) + sizeof(RELAY_ASKWAY_DATA));
  2999. if (0) // TODO:check mapid here
  3000. {
  3001. bRet = FALSE;
  3002. break;
  3003. }
  3004. bRet = TRUE;
  3005. }
  3006. break;
  3007. }
  3008. return bRet;
  3009. }
  3011. BOOL KSwordOnLineSever::GetLocalIpAddress(DWORD *pIntranetAddr, DWORD *pInternetAddr)
  3012. {
  3013. #ifndef _STANDALONE
  3014. return gGetMacAndIPAddress(NULL, pIntranetAddr, NULL, pInternetAddr);
  3015. #else
  3016. char szIp[16];
  3017. DWORD dwAddr1, dwAddr2;
  3018. dwAddr1 = dwAddr2 = 0;
  3020. char strHost[MAX_PATH];
  3021. strHost[0] = 0;
  3022. if(SOCKET_ERROR != gethostname(strHost, sizeof(strHost))) {
  3023. struct hostent* hp;
  3024. hp = gethostbyname( strHost );
  3025. #ifndef WIN32
  3026. if (!hp ||
  3027. hp && hp->h_addr_list[0] && *(unsigned long *)hp->h_addr_list[0] == 0x0100007f)
  3028. {
  3029. int sock;
  3030. struct ifreq ifr;
  3031. char* ip = NULL;
  3032. int err = -1;
  3034. sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
  3035. if (sock >= 0) {
  3036. strcpy(ifr.ifr_name, "eth0");
  3037. ifr.ifr_addr.sa_family = AF_INET;
  3039. err = ioctl(sock, SIOCGIFADDR, &ifr);
  3040. if (err == 0) {
  3041. dwAddr1 = (((struct sockaddr_in*) &(ifr.ifr_addr))->sin_addr).s_addr;
  3042. ip =  inet_ntoa(((struct sockaddr_in*) &(ifr.ifr_addr))->sin_addr);
  3043. printf("IP-addr1: %sn", ip);
  3044. }
  3046. strcpy(ifr.ifr_name, "eth1");
  3047. ifr.ifr_addr.sa_family = AF_INET;
  3049. err = ioctl(sock, SIOCGIFADDR, &ifr);
  3050. if (err == 0) {
  3051. dwAddr2 = (((struct sockaddr_in*) &(ifr.ifr_addr))->sin_addr).s_addr;
  3052. ip =  inet_ntoa(((struct sockaddr_in*) &(ifr.ifr_addr))->sin_addr);
  3053. printf("IP-addr2: %sn", ip);
  3054. }
  3055. else
  3056. dwAddr2 = dwAddr1;
  3057. closesocket(sock);
  3058. }
  3059. }
  3060. else
  3061. #endif
  3062. {
  3063. if(hp && hp->h_addr_list[0]) {
  3064. dwAddr1 = *(unsigned long *)hp->h_addr_list[0];
  3065. if (!dwAddr1)
  3066. dwAddr1 = *(unsigned long *)hp->h_addr_list[1];
  3067. /* *((char *)&dwAddr1) = hp->h_addr_list[0][3];
  3068. *((char *)&dwAddr1 + 1) = hp->h_addr_list[0][2];
  3069. *((char *)&dwAddr1 + 2) = hp->h_addr_list[0][1];
  3070. *((char *)&dwAddr1 + 3) = hp->h_addr_list[0][0];*/
  3071. // dwAddr1 = hp->h_addr_list[0];
  3072. }
  3073. if(hp && hp->h_addr_list[1]) {
  3074. dwAddr2 = *(unsigned long *)hp->h_addr_list[1];
  3075. if (!dwAddr2)
  3076. dwAddr2 = *(unsigned long *)hp->h_addr_list[0];
  3077. // dwAddr2 = hp->h_addr_list[1];
  3078. /* *((char *)&dwAddr2) = hp->h_addr_list[1][3];
  3079. *((char *)&dwAddr2 + 1) = hp->h_addr_list[1][2];
  3080. *((char *)&dwAddr2 + 2) = hp->h_addr_list[1][1];
  3081. *((char *)&dwAddr2 + 3) = hp->h_addr_list[1][0];*/
  3082. }
  3083. else
  3084. dwAddr2 = dwAddr1;
  3085. }
  3086. }
  3088. if ((dwAddr1 & 0x0000FFFF) == 0x0000a8c0) // intranet
  3089. {
  3090. *pIntranetAddr = dwAddr1;
  3091. *pInternetAddr = dwAddr2;
  3092. }
  3093. else
  3094. {
  3095. *pIntranetAddr = dwAddr2;
  3096. *pInternetAddr = dwAddr1;
  3097. }
  3098. return TRUE;
  3099. #endif
  3100. }
  3102. void KSwordOnLineSever::TransferAskWayMessageProcess(const char *pData, size_t dataLength)
  3103. {
  3104. char szChar[1024];
  3106. EXTEND_HEADER *pEH = (EXTEND_HEADER *)pData;
  3107. RELAY_ASKWAY_DATA *pRAD = (RELAY_ASKWAY_DATA *)pData;
  3109. RELAY_DATA *pRD = (RELAY_DATA *)szChar;
  3110. pRD->ProtocolFamily = pEH->ProtocolFamily;
  3111. pRD->nToIP = pRAD->nFromIP;
  3112. pRD->nToRelayID = pRAD->nFromRelayID;
  3113. pRD->nFromIP = 0;
  3114. pRD->nFromRelayID = 0;
  3115. pRD->routeDateLength = pRAD->routeDateLength;
  3117. DWORD lnID;
  3118. // TODO: check routeDataLength
  3119. if (!ConformAskWay(pRAD, dataLength, &lnID))
  3120. {
  3121. pRD->ProtocolID = relay_s2c_loseway;
  3122. memcpy(szChar + sizeof(RELAY_DATA), pData, dataLength);
  3123. m_pTransferClient->SendPackToServer(pRD, sizeof(RELAY_DATA) + dataLength);
  3124. }
  3125. else
  3126. {
  3127. pRD->ProtocolID = relay_c2c_data;
  3128. switch(pRAD->seekMethod)
  3129. {
  3130. case rm_map_id:
  3131. memcpy(szChar + sizeof(RELAY_DATA), pData + sizeof(RELAY_ASKWAY_DATA) + pRAD->wMethodDataLength, pRD->routeDateLength);
  3132. m_pTransferClient->SendPackToServer(pRD, sizeof(RELAY_DATA) + pRD->routeDateLength);
  3133. break;
  3134. case rm_role_id:
  3135. case rm_account_id:
  3136. {
  3137. if (pf_normal != *(pData + sizeof(RELAY_ASKWAY_DATA) + pRAD->wMethodDataLength))
  3138. {
  3139. m_pCoreServerShell->ProcessNewClientMessage(
  3140. m_pTransferClient,
  3141. pRAD->nFromIP,
  3142. pRAD->nFromRelayID,
  3143. m_pGameStatus[lnID].nPlayerIndex, 
  3144. (pData + sizeof(RELAY_ASKWAY_DATA) + pRAD->wMethodDataLength), 
  3145. pRAD->routeDateLength);
  3146. }
  3147. else
  3148. {
  3149. m_pCoreServerShell->ProcessClientMessage(
  3150. m_pGameStatus[lnID].nPlayerIndex, 
  3151. (pData + sizeof(RELAY_ASKWAY_DATA) + pRAD->wMethodDataLength + 1), 
  3152. pRAD->routeDateLength - 1);
  3153. }
  3154. }
  3155. break;
  3156. default:
  3157. break;
  3158. }
  3159. }
  3160. }
  3162. void KSwordOnLineSever::TransferLoseWayMessageProcess(const char *pData, size_t dataLength)
  3163. {
  3164. if (!m_pCoreServerShell || !m_pServer)
  3165. return;
  3167. EXTEND_HEADER* pInHeader = (EXTEND_HEADER*)pData;
  3169. if (pInHeader->ProtocolFamily == pf_relay)
  3170. {
  3171. tagSearchWay *pSW = NULL;
  3173. switch (pInHeader->ProtocolID)
  3174. {
  3175. case relay_c2c_data:
  3176. pSW = (tagSearchWay *)(pData + sizeof(RELAY_DATA));
  3177. break;
  3178. case relay_c2c_askwaydata:
  3179. pSW = (tagSearchWay *)(pData + sizeof(RELAY_ASKWAY_DATA) + ((RELAY_ASKWAY_DATA*)pData)->wMethodDataLength);
  3180. break;
  3181. default:
  3182. return;
  3183. }
  3185. int lnID, nIndex;
  3187. lnID = pSW->lnID;
  3188. if (lnID < 0 || lnID >= m_nMaxPlayer)
  3189. return;
  3190. if (m_pGameStatus[lnID].nExchangeStatus != enumExchangeSearchingWay)
  3191. return;
  3193. if (m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ID, pSW->nIndex, 0) != pSW->dwPlayerID)
  3194. return;
  3196. nIndex = m_pGameStatus[lnID].nPlayerIndex;
  3198. tagNotifyPlayerExchange npe;
  3199. npe.cProtocol = s2c_notifyplayerexchange;
  3200. memset(&npe.guid, 0, sizeof(GUID));
  3201. // if false, ip to 0
  3202. npe.nIPAddr = 0;
  3203. npe.nPort = 0;
  3204. m_pServer->SendData(lnID, &npe, sizeof(tagNotifyPlayerExchange));
  3206. m_pCoreServerShell->RecoverPlayerExchange(nIndex);
  3208. tagRoleEnterGame reg;
  3209. reg.ProtocolType = c2s_roleserver_lock;
  3210. reg.bLock = true;
  3211. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NAME, (unsigned int)reg.Name, nIndex);
  3212. if (m_pDatabaseClient)
  3213. m_pDatabaseClient->SendPackToServer((const void *)&reg, sizeof(tagRoleEnterGame));
  3215. m_pGameStatus[lnID].nExchangeStatus = enumExchangeBegin;
  3216. m_pGameStatus[lnID].nGameStatus = enumPlayerPlaying;
  3217. }
  3218. }
  3221. void KSwordOnLineSever::ProcessPlayerTongMsg(const unsigned long nPlayerIdx, const char* pData, size_t dataLength)
  3222. {
  3223. if (nPlayerIdx <= 0 || nPlayerIdx >= MAX_PLAYER)
  3224. return;
  3225. if (!pData)
  3226. return;
  3227. if (dataLength < sizeof(STONG_PROTOCOL_HEAD))
  3228. return;
  3229. int nPLength = ((STONG_PROTOCOL_HEAD*)pData)->m_wLength;
  3230. if (nPLength + 1 > dataLength)
  3231. return;
  3233. switch (((STONG_PROTOCOL_HEAD*)pData)->m_btMsgId)
  3234. {
  3235. // 申请创建帮会
  3236. case enumTONG_COMMAND_ID_APPLY_CREATE:
  3237. {
  3238. TONG_APPLY_CREATE_COMMAND *pApply = (TONG_APPLY_CREATE_COMMAND*)pData;
  3239. STONG_SERVER_TO_CORE_APPLY_CREATE sApply;
  3241. sApply.m_nCamp = pApply->m_btCamp;
  3242. sApply.m_nPlayerIdx = nPlayerIdx;
  3243. memcpy(sApply.m_szTongName, pApply->m_szName, sizeof(pApply->m_szName));
  3245. // 创建帮会条件检测
  3246. int nRet = 0xff;
  3247. if (m_pCoreServerShell)
  3248. nRet = m_pCoreServerShell->GetGameData(SGDI_TONG_APPLY_CREATE, (unsigned int)&sApply, 0);
  3249. // 创建帮会条件成立
  3250. if (nRet == 0)
  3251. {
  3252. char szPlayerName[32];
  3253. STONG_CREATE_COMMAND sCreate;
  3255. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NAME, (unsigned int)szPlayerName, nPlayerIdx);
  3256. sCreate.ProtocolFamily = pf_tong;
  3257. sCreate.ProtocolID = enumC2S_TONG_CREATE;
  3258. sCreate.m_btCamp = pApply->m_btCamp;
  3259. sCreate.m_dwParam = nPlayerIdx;
  3260. sCreate.m_dwPlayerNameID = g_FileName2Id(szPlayerName);
  3261. sCreate.m_btPlayerNameLength = strlen(szPlayerName);
  3262. sCreate.m_btTongNameLength = strlen(sApply.m_szTongName);
  3263. memcpy(sCreate.m_szBuffer, sApply.m_szTongName, sCreate.m_btTongNameLength);
  3264. memcpy(&sCreate.m_szBuffer[sCreate.m_btTongNameLength], szPlayerName, sCreate.m_btPlayerNameLength);
  3265. sCreate.m_wLength = sizeof(STONG_CREATE_COMMAND) - sizeof(sCreate.m_szBuffer) + sCreate.m_btTongNameLength + sCreate.m_btPlayerNameLength;
  3266. if (m_pTongClient)
  3267. m_pTongClient->SendPackToServer((const void*)&sCreate, sCreate.m_wLength);
  3268. break;
  3269. }
  3270. // 创建帮会条件不成立
  3271. else
  3272. {
  3273. int nNetID;
  3274. TONG_CREATE_FAIL_SYNC sFail;
  3275. sFail.ProtocolType = s2c_extendtong;
  3276. sFail.m_btMsgId = enumTONG_SYNC_ID_CREATE_FAIL;
  3277. sFail.m_btFailId = nRet;
  3278. sFail.m_wLength = sizeof(sFail) - 1;
  3279. nNetID = m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NETID, nPlayerIdx, 0);
  3280. if (m_pServer)
  3281. m_pServer->PackDataToClient(nNetID, &sFail, sFail.m_wLength + 1);
  3283. break;
  3284. }
  3285. }
  3286. break;
  3287. case enumTONG_COMMAND_ID_APPLY_ADD:
  3288. {
  3289. TONG_APPLY_ADD_COMMAND *pApply = (TONG_APPLY_ADD_COMMAND*)pData;
  3290. if (pApply->m_wLength != sizeof(TONG_APPLY_ADD_COMMAND) - 1)
  3291. break;
  3292. STONG_SERVER_TO_CORE_APPLY_ADD sAdd;
  3293. sAdd.m_nPlayerIdx = nPlayerIdx;
  3294. sAdd.m_dwNpcID = pApply->m_dwNpcID;
  3295. if (m_pCoreServerShell)
  3296. m_pCoreServerShell->GetGameData(SGDI_TONG_APPLY_ADD, (unsigned int)&sAdd, 0);
  3297. }
  3298. break;
  3299. case enumTONG_COMMAND_ID_ACCEPT_ADD:
  3300. {
  3301. TONG_ACCEPT_MEMBER_COMMAND *pAccept = (TONG_ACCEPT_MEMBER_COMMAND*)pData;
  3302. if (pAccept->m_wLength != sizeof(TONG_ACCEPT_MEMBER_COMMAND) - 1)
  3303. break;
  3304. if (pAccept->m_btFlag == 0)
  3305. {
  3306. STONG_SERVER_TO_CORE_REFUSE_ADD sRefuse;
  3307. sRefuse.m_nSelfIdx = nPlayerIdx;
  3308. sRefuse.m_nTargetIdx = pAccept->m_nPlayerIdx;
  3309. sRefuse.m_dwNameID = pAccept->m_dwNameID;
  3310. m_pCoreServerShell->OperationRequest(SSOI_TONG_REFUSE_ADD, (unsigned int)&sRefuse, 0);
  3311. break;
  3312. }
  3313. else
  3314. {
  3315. char szTongName[32];
  3316. STONG_SERVER_TO_CORE_CHECK_ADD_CONDITION sAdd;
  3317. sAdd.m_nSelfIdx = nPlayerIdx;
  3318. sAdd.m_nTargetIdx = pAccept->m_nPlayerIdx;
  3319. sAdd.m_dwNameID = pAccept->m_dwNameID;
  3321. int nRet = FALSE;
  3322. if (m_pCoreServerShell)
  3323. nRet = m_pCoreServerShell->GetGameData(SGDI_TONG_CHECK_ADD_CONDITION, (unsigned int)szTongName, (unsigned int)&sAdd);
  3324. // 向 relay 申请添加帮众
  3325. if (nRet)
  3326. {
  3327. char szPlayerName[32];
  3328. STONG_ADD_MEMBER_COMMAND sTong;
  3330. szPlayerName[0] = 0;
  3331. m_pCoreServerShell->GetGameData(SGDI_CHARACTER_NAME, (unsigned int)szPlayerName, sAdd.m_nTargetIdx);
  3333. sTong.ProtocolFamily = pf_tong;
  3334. sTong.ProtocolID = enumC2S_TONG_ADD_MEMBER;
  3335. sTong.m_dwParam = sAdd.m_nTargetIdx;
  3336. sTong.m_dwPlayerNameID = sAdd.m_dwNameID;
  3337. sTong.m_btPlayerNameLength = strlen(szPlayerName);
  3338. sTong.m_btTongNameLength = strlen(szTongName);
  3339. memcpy(sTong.m_szBuffer, szTongName, sTong.m_btTongNameLength);
  3340. memcpy(&sTong.m_szBuffer[sTong.m_btTongNameLength], szPlayerName, sTong.m_btPlayerNameLength);
  3341. sTong.m_wLength = sizeof(STONG_ADD_MEMBER_COMMAND) - sizeof(sTong.m_szBuffer) + sTong.m_btTongNameLength + sTong.m_btPlayerNameLength;
  3342. if (m_pTongClient)
  3343. m_pTongClient->SendPackToServer((const void*)&sTong, sTong.m_wLength);
  3345. }
  3346. else
  3347. {
  3348. break;
  3349. }
  3350. }
  3351. }
  3352. break;
  3353. case enumTONG_COMMAND_ID_APPLY_INFO:
  3354. {
  3355. TONG_APPLY_INFO_COMMAND *pInfo = (TONG_APPLY_INFO_COMMAND*)pData;
  3356. if (pInfo->m_wLength < sizeof(TONG_APPLY_INFO_COMMAND) - 1 - sizeof(pInfo->m_szBuf))
  3357. break;
  3358. STONG_SERVER_TO_CORE_GET_INFO sGet;
  3359. switch (pInfo->m_btInfoID)
  3360. {
  3361. case enumTONG_APPLY_INFO_ID_SELF:
  3362. sGet.m_nSelfIdx = nPlayerIdx;
  3363. sGet.m_nInfoID = pInfo->m_btInfoID;
  3364. sGet.m_nParam1 = pInfo->m_nParam1;
  3365. sGet.m_nParam2 = pInfo->m_nParam2;
  3366. sGet.m_nParam3 = pInfo->m_nParam3;
  3367. sGet.m_szName[0] = 0;
  3368. if (m_pCoreServerShell)
  3369. m_pCoreServerShell->GetGameData(SGDI_TONG_GET_INFO, (unsigned int)&sGet, 0);
  3370. break;
  3371. case enumTONG_APPLY_INFO_ID_MASTER:
  3372. break;
  3373. case enumTONG_APPLY_INFO_ID_DIRECTOR:
  3374. break;
  3375. case enumTONG_APPLY_INFO_ID_MANAGER:
  3376. {
  3377. int nRet = 0;
  3378. sGet.m_nSelfIdx = nPlayerIdx;
  3379. sGet.m_nInfoID = pInfo->m_btInfoID;
  3380. sGet.m_nParam1 = pInfo->m_nParam1;
  3381. sGet.m_nParam2 = pInfo->m_nParam2;
  3382. sGet.m_nParam3 = pInfo->m_nParam3;
  3383. sGet.m_szName[0] = 0;
  3384. if (m_pCoreServerShell)
  3385. nRet = m_pCoreServerShell->GetGameData(SGDI_TONG_GET_INFO, (unsigned int)&sGet, 0);
  3386. if (nRet == 0)
  3387. break;
  3389. STONG_GET_MANAGER_INFO_COMMAND sGet;
  3390. sGet.ProtocolFamily = pf_tong;
  3391. sGet.ProtocolID = enumC2S_TONG_GET_MANAGER_INFO;
  3392. sGet.m_dwParam = nPlayerIdx;
  3393. sGet.m_nParam1 = pInfo->m_nParam1;
  3394. sGet.m_nParam2 = pInfo->m_nParam2;
  3395. sGet.m_nParam3 = pInfo->m_nParam3;
  3396. if (m_pTongClient)
  3397. m_pTongClient->SendPackToServer((const void*)&sGet, sizeof(sGet));
  3398. }
  3399. break;
  3400. case enumTONG_APPLY_INFO_ID_MEMBER:
  3401. {
  3402. int nRet = 0;
  3403. sGet.m_nSelfIdx = nPlayerIdx;
  3404. sGet.m_nInfoID = pInfo->m_btInfoID;
  3405. sGet.m_nParam1 = pInfo->m_nParam1;
  3406. sGet.m_nParam2 = pInfo->m_nParam2;
  3407. sGet.m_nParam3 = pInfo->m_nParam3;
  3408. sGet.m_szName[0] = 0;
  3409. if (m_pCoreServerShell)
  3410. nRet = m_pCoreServerShell->GetGameData(SGDI_TONG_GET_INFO, (unsigned int)&sGet, 0);
  3411. if (nRet == 0)
  3412. break;
  3414. STONG_GET_MEMBER_INFO_COMMAND sGet;
  3415. sGet.ProtocolFamily = pf_tong;
  3416. sGet.ProtocolID = enumC2S_TONG_GET_MEMBER_INFO;
  3417. sGet.m_dwParam = nPlayerIdx;
  3418. sGet.m_nParam1 = pInfo->m_nParam1;
  3419. sGet.m_nParam2 = pInfo->m_nParam2;
  3420. sGet.m_nParam3 = pInfo->m_nParam3;
  3421. if (m_pTongClient)
  3422. m_pTongClient->SendPackToServer((const void*)&sGet, sizeof(sGet));
  3423. }
  3424. break;
  3425. case enumTONG_APPLY_INFO_ID_ONE:
  3426. break;
  3427. case enumTONG_APPLY_INFO_ID_TONG_HEAD:
  3428. {
  3429. DWORD dwTongNameID = 0;
  3431. sGet.m_nSelfIdx = nPlayerIdx;
  3432. sGet.m_nInfoID = pInfo->m_btInfoID;
  3433. sGet.m_nParam1 = pInfo->m_nParam1;
  3434. sGet.m_nParam2 = pInfo->m_nParam2;
  3435. sGet.m_nParam3 = pInfo->m_nParam3;
  3436. sGet.m_szName[0] = 0;
  3438. if (m_pCoreServerShell)
  3439. dwTongNameID = m_pCoreServerShell->GetGameData(SGDI_TONG_GET_INFO, (unsigned int)&sGet, 0);
  3440. if (dwTongNameID == 0)
  3441. break;
  3443. STONG_GET_TONG_HEAD_INFO_COMMAND sGet;
  3444. sGet.ProtocolFamily = pf_tong;
  3445. sGet.ProtocolID = enumC2S_TONG_GET_HEAD_INFO;
  3446. sGet.m_dwParam = nPlayerIdx;
  3447. sGet.m_dwNpcID = pInfo->m_nParam1;
  3448. sGet.m_dwTongNameID = dwTongNameID;
  3449. if (m_pTongClient)
  3450. m_pTongClient->SendPackToServer((const void*)&sGet, sizeof(sGet));
  3451. }
  3452. break;
  3453. }
  3454. }
  3455. break;
  3456. case enumTONG_COMMAND_ID_APPLY_INSTATE:
  3457. {
  3458. TONG_APPLY_INSTATE_COMMAND *pApply = (TONG_APPLY_INSTATE_COMMAND*)pData;
  3459. if (pApply->m_wLength + 1 != sizeof(TONG_APPLY_INSTATE_COMMAND))
  3460. break;
  3461. int nRet = 0;
  3462. if (m_pCoreServerShell)
  3463. nRet = m_pCoreServerShell->GetGameData(SGDI_TONG_INSTATE_POWER, (unsigned int)pApply, nPlayerIdx);
  3464. if (nRet == 0)
  3465. break;
  3467. STONG_INSTATE_COMMAND sInstate;
  3468. sInstate.ProtocolFamily = pf_tong;
  3469. sInstate.ProtocolID = enumC2S_TONG_INSTATE;
  3470. sInstate.m_btCurFigure = pApply->m_btCurFigure;
  3471. sInstate.m_btCurPos = pApply->m_btCurPos;
  3472. sInstate.m_btNewFigure = pApply->m_btNewFigure;
  3473. sInstate.m_btNewPos = pApply->m_btNewPos;
  3474. sInstate.m_dwParam = nPlayerIdx;
  3475. sInstate.m_dwTongNameID = pApply->m_dwTongNameID;
  3476. memset(sInstate.m_szName, 0, sizeof(sInstate.m_szName));
  3477. memcpy(sInstate.m_szName, pApply->m_szName, pApply->m_wLength + 1 + sizeof(pApply->m_szName) - sizeof(TONG_APPLY_INSTATE_COMMAND));
  3479. if (m_pTongClient)
  3480. m_pTongClient->SendPackToServer((const void*)&sInstate, sizeof(sInstate));
  3481. }
  3482. break;
  3484. case enumTONG_COMMAND_ID_APPLY_KICK:
  3485. {
  3486. TONG_APPLY_KICK_COMMAND *pKick = (TONG_APPLY_KICK_COMMAND*)pData;
  3487. if (pKick->m_wLength + 1 != sizeof(TONG_APPLY_KICK_COMMAND))
  3488. break;
  3489. int nRet = 0;
  3490. if (m_pCoreServerShell)
  3491. nRet = m_pCoreServerShell->GetGameData(SGDI_TONG_KICK_POWER, (unsigned int)pKick, nPlayerIdx);
  3492. if (nRet == 0)
  3493. break;
  3495. STONG_KICK_COMMAND sKick;
  3496. sKick.ProtocolFamily = pf_tong;
  3497. sKick.ProtocolID = enumC2S_TONG_KICK;
  3498. sKick.m_dwParam = nPlayerIdx;
  3499. sKick.m_dwTongNameID = pKick->m_dwTongNameID;
  3500. sKick.m_btFigure = pKick->m_btFigure;
  3501. sKick.m_btPos = pKick->m_btPos;
  3502. memcpy(sKick.m_szName, pKick->m_szName, sizeof(pKick->m_szName));
  3504. if (m_pTongClient)
  3505. m_pTongClient->SendPackToServer((const void*)&sKick, sizeof(sKick));
  3506. }
  3507. break;
  3508. case enumTONG_COMMAND_ID_APPLY_LEAVE:
  3509. {
  3510. TONG_APPLY_LEAVE_COMMAND *pLeave = (TONG_APPLY_LEAVE_COMMAND*)pData;
  3511. if (pLeave->m_wLength + 1 != sizeof(TONG_APPLY_LEAVE_COMMAND))
  3512. break;
  3513. int nRet = 0;
  3514. if (m_pCoreServerShell)
  3515. nRet = m_pCoreServerShell->GetGameData(SGDI_TONG_LEAVE_POWER, (unsigned int)pLeave, nPlayerIdx);
  3516. if (nRet == 0)
  3517. break;
  3519. STONG_LEAVE_COMMAND sLeave;
  3520. sLeave.ProtocolFamily = pf_tong;
  3521. sLeave.ProtocolID = enumC2S_TONG_LEAVE;
  3522. sLeave.m_dwParam = nPlayerIdx;
  3523. sLeave.m_dwTongNameID = pLeave->m_dwTongNameID;
  3524. sLeave.m_btFigure = pLeave->m_btFigure;
  3525. sLeave.m_btPos = pLeave->m_btPos;
  3526. memcpy(sLeave.m_szName, pLeave->m_szName, sizeof(pLeave->m_szName));
  3528. if (m_pTongClient)
  3529. m_pTongClient->SendPackToServer((const void*)&sLeave, sizeof(sLeave));
  3530. }
  3531. break;
  3532. case enumTONG_COMMAND_ID_APPLY_CHANGE_MASTER:
  3533. {
  3534. TONG_APPLY_CHANGE_MASTER_COMMAND *pChange = (TONG_APPLY_CHANGE_MASTER_COMMAND*)pData;
  3535. if (pChange->m_wLength + 1 != sizeof(TONG_APPLY_CHANGE_MASTER_COMMAND))
  3536. break;
  3537. int nRet = 0;
  3538. if (m_pCoreServerShell)
  3539. nRet = m_pCoreServerShell->GetGameData(SGDI_TONG_CHANGE_MASTER_POWER, (unsigned int)pChange, nPlayerIdx);
  3540. if (nRet == 0)
  3541. break;
  3543. STONG_CHANGE_MASTER_COMMAND sChange;
  3544. sChange.ProtocolFamily = pf_tong;
  3545. sChange.ProtocolID = enumC2S_TONG_CHANGE_MASTER;
  3546. sChange.m_btFigure = pChange->m_btFigure;
  3547. sChange.m_btPos = pChange->m_btPos;
  3548. sChange.m_dwParam = nPlayerIdx;
  3549. sChange.m_dwTongNameID = pChange->m_dwTongNameID;
  3550. memcpy(sChange.m_szName, pChange->m_szName, sizeof(pChange->m_szName));
  3551. if (m_pTongClient)
  3552. m_pTongClient->SendPackToServer((const void*)&sChange, sizeof(sChange));
  3553. }
  3554. break;
  3555. default:
  3556. break;
  3557. }
  3558. }
  3560. BOOL KSwordOnLineSever::CheckPlayerID(unsigned long netidx, DWORD nameid)
  3561. {
  3562. if (netidx < 0 || netidx >= m_nMaxPlayer)
  3563. return FALSE;
  3565. int idx = m_pGameStatus[netidx].nPlayerIndex;
  3566. if (idx <= 0 || idx >= MAX_PLAYER)
  3567. return FALSE;
  3569. if (nameid != m_pCoreServerShell->GetGameData(SGDI_CHARACTER_ID, idx, 0))
  3570. return FALSE;
  3572. return TRUE;
  3573. }