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

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

模拟服务器

开发平台：

C/C++

KSG_RoleProcess.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  FileName    :   KSG_RoleProcess.cpp
  4. //  Version     :   1.0
  5. //  Creater     :   Freeway Chen
  6. //  Date        :   2003-9-15 7:45:21
  7. //  Comment     :   
  8. //
  9. //////////////////////////////////////////////////////////////////////////////////////
  11. #include "StdAfx.h"
  13. #pragma warning( disable : 4786 ) 
  15. #include "winsock2.h"
  16. #include "CriticalSection.h"
  17. #include "KSG_RoleProcess.h"
  19. #include <vector>
  20. #include <map>
  21. #include <algorithm>
  23. using namespace std;
  24. using namespace OnlineGameLib::Win32;
  26. #include "kprotocoldef.h"
  27. #include "KProtocol.h"
  28. #include "../../../../Headers/KGmProtocol.h"
  30. #include "IDBRoleServer.h"
  32. #include "Macro.h"
  34. #include "RoleNameFilter.h"
  37. #define _NAME_LENGTH 64
  41. typedef struct _THREAD_PARAM
  42. {
  43.     HANDLE          hThread;
  44.     SOCKET          hSocket;
  45.     long            lID;
  46.     HWND            hMainWnd;
  48.     unsigned char   InBuffer [64 * 1024];
  49.     unsigned char   OutBuffer[64 * 1024];
  51. } THREAD_PARAM;
  53. typedef void (*ProcessArray[c2s_end])(THREAD_PARAM *pParam,  const void *pData, size_t dataLength);
  55. ProcessArray g_theProcessArray;
  57. void _QueryRoleList(THREAD_PARAM *pParam, const void *pData, size_t dataLength);
  58. void _CreateRole(THREAD_PARAM *pParam, const void *pData, size_t dataLength);
  59. void _SaveRoleInfo(THREAD_PARAM *pParam, const void *pData, size_t dataLength);
  60. void _DelRole(THREAD_PARAM *pParam, const void *pData, size_t dataLength);
  61. void _GetRoleInfo(THREAD_PARAM *pParam, const void *pData, size_t dataLength);
  62. void _RelayExtend(THREAD_PARAM *pParam, const void *pData, size_t dataLength);
  63. void _GetGameStat(THREAD_PARAM *pParam, const void *pData, size_t dataLength);//发送游戏统计数据(By Fellow,2003.7.22)
  64. void _LockOrUnlockRole(THREAD_PARAM *pParam, const void *pData, size_t dataLength);
  66. bool IsRoleLock(char* szRole);
  67. bool IsRoleLockBySelf(size_t ID, char* szRole);
  68. bool UnlockRoleSelf(size_t ID, char* szRole);
  69. void UnlockAllRole(size_t ID);
  73. static int gs_nWSAStartupFlag = false;
  75. static SOCKET gs_sckListen = INVALID_SOCKET;
  76. static int    gs_nExitFlag = false;
  78. static long g_lID = 0;
  80. static CCriticalSection     gs_ThreadsLock;
  82. typedef vector<THREAD_PARAM *>  ThreadsType; 
  83. static  ThreadsType             gs_Threads;
  85. HWND    g_hMainWnd = NULL;
  87. #define SOCKET_VERSION_REQUIRED     0x202
  89. int KSG_RoleProcess_Init(int nPort, HWND hMainWnd)
  90. {
  91.     int nResult  = false;
  92.     int nRetCode = false;
  93.     int nWSAStartupFlag = false;
  96.     memset(&g_theProcessArray, 0, sizeof(g_theProcessArray));
  98. g_theProcessArray[c2s_roleserver_getrolelist] = _QueryRoleList;
  99. g_theProcessArray[c2s_roleserver_createroleinfo] = _CreateRole;
  100. g_theProcessArray[c2s_roleserver_saveroleinfo] = _SaveRoleInfo;
  101. g_theProcessArray[c2s_roleserver_deleteplayer] = _DelRole;
  102. g_theProcessArray[c2s_roleserver_getroleinfo] = _GetRoleInfo;
  103.     //g_theProcessArray[c2s_extend] = _RelayExtend;
  104. g_theProcessArray[c2s_gamestatistic] = _GetGameStat;
  105. g_theProcessArray[c2s_roleserver_lock] = _LockOrUnlockRole;
  107.     g_hMainWnd = hMainWnd;
  109.     WSADATA WSAData = { 0 };
  110.     struct sockaddr_in addr = { 0 };
  112.     nRetCode = WSAStartup(SOCKET_VERSION_REQUIRED, &WSAData);
  113.     if (nRetCode != 0)
  114.         goto Exit0;
  115.     
  116.     gs_nWSAStartupFlag = true;
  118.     gs_Threads.reserve(256);
  120.     gs_sckListen = socket(AF_INET, SOCK_STREAM, 0);
  121.     if (gs_sckListen == INVALID_SOCKET)
  122.         goto Exit0;
  124.     addr.sin_family = AF_INET;
  125.     addr.sin_addr.s_addr = INADDR_ANY;
  126.     addr.sin_port = htons(nPort);
  128.     nRetCode = bind(gs_sckListen, (struct sockaddr *)&addr, sizeof(addr));
  129.     if (nRetCode == SOCKET_ERROR)
  130.         goto Exit0;
  132.     nRetCode = listen(gs_sckListen, 5);
  133.     if (nRetCode == SOCKET_ERROR)
  134.         goto Exit0;
  136.     nResult = true;
  137. Exit0:
  138.     if (!nResult)
  139.     {
  140.         if (gs_sckListen != INVALID_SOCKET)
  141.         {
  142.             closesocket(gs_sckListen);
  143.             gs_sckListen = INVALID_SOCKET;
  144.         }
  145.         
  147.         if (gs_nWSAStartupFlag)
  148.         {
  149.             WSACleanup();
  150.             gs_nWSAStartupFlag = false; 
  151.         }
  152.     }
  153.     return nResult;
  154. }
  156. int KSG_RoleProcess_UnInit()
  157. {
  158.     int nResult  = false;
  159.     int nRetCode = false;
  160.     
  161.     {
  162.         CCriticalSection::Owner lock(gs_ThreadsLock);
  163.         
  164.         gs_nExitFlag = true;    // 设置退出标志
  166.         ThreadsType::iterator pPos;
  167.         for (pPos = gs_Threads.begin(); pPos != gs_Threads.end(); ++pPos)
  168.         {
  169.             if (((*pPos)->hSocket) != INVALID_SOCKET)
  170.             {
  171.         LINGER lingerStruct;
  172.     
  173.         lingerStruct.l_onoff = 1;
  174.         lingerStruct.l_linger = 0;
  175.     
  176.                 setsockopt( 
  177.                     (*pPos)->hSocket, 
  178.     SOL_SOCKET, 
  179.     SO_LINGER, 
  180.     (char *)&lingerStruct, 
  181.     sizeof(lingerStruct)
  182.                 );
  184.                 closesocket((*pPos)->hSocket);
  185.             }
  186.         }
  189.         if (gs_sckListen != INVALID_SOCKET)
  190.         {
  191.     LINGER lingerStruct;
  193.     lingerStruct.l_onoff = 1;
  194.     lingerStruct.l_linger = 0;
  196.             // notify accept thread to exit
  197.             setsockopt( 
  198.                 gs_sckListen, 
  199. SOL_SOCKET, 
  200. SO_LINGER, 
  201. (char *)&lingerStruct, 
  202. sizeof(lingerStruct)
  203.             );
  204.         
  205.             closesocket(gs_sckListen);
  206.             gs_sckListen = INVALID_SOCKET;
  207.         }
  208.     }
  210.     while (true)
  211.     {
  212.         {
  213.             CCriticalSection::Owner lock(gs_ThreadsLock);
  215.             if (gs_Threads.empty())
  216.                 break;
  217.         }
  219.         Sleep(250);
  220.     }
  222.     nRetCode = WSACleanup();
  223.     if (nRetCode != 0)
  224.         goto Exit0;
  226.     nResult = true;
  227. Exit0:
  228.     return nResult;
  229. }
  232. static inline int _RecvBuffer(SOCKET sckSocket, int nBufferSize, unsigned char *pbyBuffer)
  233. {
  234.     int nResult  = false;
  235.     int nRetCode = false;
  237.     ASSERT(sckSocket != INVALID_SOCKET);
  238.     ASSERT(nBufferSize > 0);
  239.     ASSERT(pbyBuffer != NULL);
  241.     while (nBufferSize > 0)
  242.     {
  243.         nRetCode = recv(sckSocket, (char *)pbyBuffer, nBufferSize, 0);
  244.         if (
  245.             (nRetCode == SOCKET_ERROR) ||
  246.             (nRetCode == 0)
  247.         )
  248.             goto Exit0;
  250.         pbyBuffer += nRetCode;
  251.         nBufferSize -= nRetCode;
  252.     }
  255.     nResult = true;
  256. Exit0:
  257.     return nResult;
  258. }
  260. static inline int _SendBuffer(SOCKET sckSocket, int nBufferSize, unsigned char *pbyBuffer)
  261. {
  262.     int nResult  = false;
  263.     int nRetCode = false;
  265.     ASSERT(sckSocket != INVALID_SOCKET);
  266.     ASSERT(nBufferSize > 0);
  267.     ASSERT(pbyBuffer != NULL);
  269.     while (nBufferSize > 0)
  270.     {
  271.         nRetCode = send(sckSocket, (char *)pbyBuffer, nBufferSize, 0);
  272.         if (nRetCode == SOCKET_ERROR)
  273.             goto Exit0;
  275.         pbyBuffer += nRetCode;
  276.         nBufferSize -= nRetCode;
  277.     }
  280.     nResult = true;
  281. Exit0:
  282.     return nResult;
  283. }
  285. static DWORD WINAPI KSG_RoleProcessThread(LPVOID lpParam)
  286. {
  287.     int nResult  = false;
  288.     int nRetCode = false;
  289.     struct sockaddr_in addr_from = { 0 };
  290.     int addr_from_len = sizeof(addr_from);
  292.     unsigned uProcessDataSize     = 0;
  293.     unsigned char *pbyProcessData = NULL;
  294.     int  nNotifyAddClientFlag = false;
  296.     SOCKET sckSocketProcess = INVALID_SOCKET;
  297.     THREAD_PARAM *pThreadParam = (THREAD_PARAM *)lpParam;
  299.     if (!pThreadParam)
  300.         goto Exit0;
  302.     if (gs_nExitFlag)
  303.         goto Exit1;
  305.     pThreadParam->lID = InterlockedIncrement(&g_lID);
  307.     sckSocketProcess = accept(gs_sckListen, (struct sockaddr *)&addr_from, &addr_from_len);
  308.     if (sckSocketProcess == INVALID_SOCKET)
  309.         goto Exit0;
  311.     pThreadParam->hSocket = sckSocketProcess;
  313.     if (gs_nExitFlag)
  314.         goto Exit0;
  316.     // notfiy Add Client
  317.     if (pThreadParam->hMainWnd)
  318.     {
  319.         ::SendMessage(pThreadParam->hMainWnd, WM_ADD_CLIENT, (WPARAM)addr_from_len, (LPARAM)&addr_from);
  320.         nNotifyAddClientFlag = true;
  321.     }
  323.     nRetCode = KSG_RoleProcess_Start();
  324.     if (!nRetCode)
  325.         goto Exit0;
  327.     
  328.     while (true)
  329.     {
  330.         if (gs_nExitFlag)
  331.             goto Exit0;
  333.         nRetCode = _RecvBuffer(sckSocketProcess, sizeof(WORD), pThreadParam->InBuffer);
  334.         if (!nRetCode)
  335.             goto Exit0;
  337.         uProcessDataSize = *((WORD *)pThreadParam->InBuffer);
  338.         uProcessDataSize -= sizeof(WORD);
  340.         pbyProcessData = (pThreadParam->InBuffer) + sizeof(WORD);
  342.         nRetCode = _RecvBuffer(sckSocketProcess, uProcessDataSize, pbyProcessData);
  343.         if (!nRetCode)
  344.             goto Exit0;
  347. BYTE cProtocol;
  349.         cProtocol = *pbyProcessData;
  351. if ( 
  352.             (cProtocol < c2s_end) && 
  353.             (g_theProcessArray[cProtocol]) 
  354.         )
  355. {
  356. (*g_theProcessArray[cProtocol])(pThreadParam, (const void *)pbyProcessData, uProcessDataSize);
  357. }
  358.     }
  361. Exit1:
  362.     nResult = true;
  363. Exit0:
  365.     if (nNotifyAddClientFlag)
  366.     {
  367.         if (!gs_nExitFlag)
  368.         {
  369.             if (pThreadParam->hMainWnd)
  370.             {
  371.                 ::SendMessage(pThreadParam->hMainWnd, WM_DEL_CLIENT, (WPARAM)addr_from_len, (LPARAM)&addr_from);
  372.             }
  373.         }
  375.         nNotifyAddClientFlag = false;
  376.     }
  379.     UnlockAllRole(pThreadParam->lID);
  381.     {
  382.         CCriticalSection::Owner lock(gs_ThreadsLock);
  384.         ThreadsType::iterator pPos;
  385.         
  386.         pPos = find(gs_Threads.begin(), gs_Threads.end(), pThreadParam);
  387.         if (pPos != gs_Threads.end())
  388.         {
  389.             CloseHandle((*pPos)->hThread);
  390.             *pPos = NULL;
  391.     
  392.             gs_Threads.erase(pPos);
  393.         }
  394.    
  395.         if (sckSocketProcess != INVALID_SOCKET)
  396.         {
  397.     LINGER lingerStruct;
  398.     
  399.     lingerStruct.l_onoff = 1;
  400.     lingerStruct.l_linger = 0;
  401.     
  402.             // notify accept thread to exit
  403.             setsockopt( 
  404.                 gs_sckListen, 
  405.     SOL_SOCKET, 
  406.     SO_LINGER, 
  407.     (char *)&lingerStruct, 
  408.     sizeof(lingerStruct)
  409.             );
  411.             closesocket(sckSocketProcess);
  412.             sckSocketProcess = INVALID_SOCKET;
  413.         }
  414.     }
  416.     if (pThreadParam)
  417.     {
  418.         delete pThreadParam;
  419.         pThreadParam = NULL;
  420.     }
  422.     return nResult;
  423. }
  426. int KSG_RoleProcess_Start()
  427. {
  428.     int nResult  = false;
  429.     int nRetCode = false;
  430.     HANDLE hThread = NULL;
  431.     DWORD dwThreadID = 0;
  433.     THREAD_PARAM *pThreadParam = NULL;
  435.     pThreadParam = new THREAD_PARAM;
  436.     if (!pThreadParam)
  437.         goto Exit0;
  439.     pThreadParam->hMainWnd = g_hMainWnd;
  440.     pThreadParam->hSocket  = INVALID_SOCKET;
  442.     hThread = CreateThread(
  443.         NULL, 
  444.         0,
  445.         KSG_RoleProcessThread,
  446.         (LPVOID)pThreadParam,
  447.         CREATE_SUSPENDED,
  448.         &dwThreadID
  449.     );
  450.     if (!hThread)
  451.         goto Exit0;
  453.     {
  454.         CCriticalSection::Owner lock(gs_ThreadsLock);
  456.         pThreadParam->hThread = hThread;
  457.         gs_Threads.push_back(pThreadParam);
  459.         ResumeThread(hThread);
  461.         hThread = NULL;
  462.         dwThreadID = 0;
  463.     }
  465.     nResult = true;
  466. Exit0:
  467.     if (!nResult)
  468.     {
  469.         if (pThreadParam)
  470.         {
  471.             delete pThreadParam;
  472.             pThreadParam = NULL;
  473.         }
  474.     }
  476.     return nResult;
  477. }
  480. /////////////////////////////////////////////////////////////////////////////////
  482. // 处理角色锁定
  483. typedef map< std::string, size_t > stdRoleLockMap;
  485. stdRoleLockMap      gs_csRoleLock;
  486. CCriticalSection gs_csCR;
  488. void _LockOrUnlockRole(THREAD_PARAM *pParam, const void *pData, size_t dataLength) //强行加解锁
  489. {
  490. CCriticalSection::Owner lock( gs_csCR );
  491. if (pData && dataLength == sizeof(tagRoleEnterGame))
  492. {
  493. tagRoleEnterGame* pRole = (tagRoleEnterGame*)pData;
  494. char szRole[32];
  495. strncpy(szRole, pRole->Name, 31);
  496. szRole[31] = 0;
  497. bool bLock = pRole->bLock;
  499. if (szRole && szRole[0] != 0)
  500. {
  501. if (bLock)
  502. gs_csRoleLock[szRole] = pParam->lID;
  503. else
  504. {
  505. stdRoleLockMap::iterator it = gs_csRoleLock.find(szRole);
  506. if (it != gs_csRoleLock.end())
  507. gs_csRoleLock.erase(it);
  508. }
  509. }
  510. }
  511. }
  513. bool IsRoleLock(char* szRole)
  514. {
  515. CCriticalSection::Owner lock( gs_csCR );
  516. if (szRole && szRole[0] != 0)
  517. {
  518. stdRoleLockMap::iterator it = gs_csRoleLock.find(szRole);
  519. if (it != gs_csRoleLock.end() && it->second != -1)
  520. return true;
  521. }
  522. return false;
  523. }
  525. bool IsRoleLockBySelf(size_t ID, char* szRole)
  526. {
  527. CCriticalSection::Owner lock( gs_csCR );
  528. if (szRole && szRole[0] != 0)
  529. {
  530. stdRoleLockMap::iterator it = gs_csRoleLock.find(szRole);
  531. if (it != gs_csRoleLock.end() && it->second == ID)
  532. return true;
  533. }
  534. return false;
  535. }
  537. bool UnlockRoleSelf(size_t ID, char* szRole)
  538. {
  539. CCriticalSection::Owner lock( gs_csCR );
  540. if (szRole && szRole[0] != 0)
  541. {
  542. stdRoleLockMap::iterator it = gs_csRoleLock.find(szRole);
  543. if (it != gs_csRoleLock.end() && it->second == ID)
  544. {
  545. gs_csRoleLock.erase(it);
  546. return true;
  547. }
  548. }
  549. return false;
  550. }
  552. void UnlockAllRole(size_t ID)
  553. {
  554. CCriticalSection::Owner lock( gs_csCR );
  555. stdRoleLockMap::iterator it = gs_csRoleLock.begin();
  556. while (it != gs_csRoleLock.end())
  557. {
  558. if (it->second == ID)
  559. it->second = -1;
  560. it++;
  561. }
  562. }
  564. /////////////////////////////////////////////////////////////////////////////////
  565.     
  566. //============= Process Data =======================
  568. void _QueryRoleList(THREAD_PARAM *pParam, const void *pData, size_t dataLength)
  569. {
  570. char szAccountName[_NAME_LENGTH];
  572. ASSERT( pParam && pData && dataLength);
  574.     #ifdef CONSOLE_DEBUG
  575. cout << "_QueryRoleList::Begin" << endl;
  576.     #endif
  578. TProcessData *pPlayerList = ( TProcessData * )pData;
  580. int nRoleListCount = pPlayerList->pDataBuffer[0];
  581. int nLen = pPlayerList->nDataLen;
  582. unsigned long ulIdentity = pPlayerList->ulIdentity;
  584. if ( nLen <= 1 || nLen >= _NAME_LENGTH )
  585. {
  586.         #ifdef CONSOLE_DEBUG
  587. cout << "_QueryRoleList::Name is invalid" << endl;
  588.         #endif
  590. return;
  591. }
  593. memcpy( szAccountName, ( const char * )( &pPlayerList->pDataBuffer[1] ), nLen - 1 );
  594. szAccountName[nLen - 1] = '';
  596. /*
  597.  * Database
  598.  */
  599. S3DBI_RoleBaseInfo DBI[4];
  600. const size_t s_nStructSize = sizeof( S3DBI_RoleBaseInfo );
  602.     #ifdef CONSOLE_DEBUG
  603. cout << "_QueryRoleList::GetRoleListOfAccount " << szAccountName << endl;
  604.     #endif
  606. int nCount = GetRoleListOfAccount( szAccountName, &DBI[0], nRoleListCount );
  608. TProcessData *pListData = (TProcessData *)((pParam->OutBuffer) + sizeof(WORD));
  610. pListData->nProtoId = s2c_roleserver_getrolelist_result;
  611. pListData->ulIdentity = ulIdentity;
  613. int nDataLen = nCount * s_nStructSize + 1;
  614. pListData->nDataLen = nDataLen;
  616. pListData->pDataBuffer[0] = nCount;
  617. memcpy( &pListData->pDataBuffer[1], &DBI[0], nDataLen );
  619. int nUsedLen = sizeof( TProcessData ) - 1 + nDataLen;
  621.     *((WORD *)pParam->OutBuffer) = ((WORD)nUsedLen) + sizeof(WORD);
  623.     _SendBuffer(pParam->hSocket, *((WORD *)pParam->OutBuffer), pParam->OutBuffer);
  625.     #ifdef CONSOLE_DEBUG
  626. cout << "_QueryRoleList::end" << endl;
  627.     #endif
  628. }
  630. void _CreateRole(THREAD_PARAM *pParam, const void *pData, size_t dataLength)
  631. {
  632. ASSERT( pParam && pData && dataLength);
  634.     #ifdef CONSOLE_DEBUG
  635. cout << "_CreateRole::Begin" << endl;
  636.     #endif
  638. TProcessData *pPD = ( TProcessData * )pData;
  640. int nResult = 0;
  642. {{
  643. extern CRoleNameFilter g_fltRoleName;
  645. TRoleData* pRoleData = (TRoleData*)(pPD->pDataBuffer + 1);
  647. if (pRoleData->BaseInfo.szName[0])
  648. {
  649. for (size_t pos = sizeof(pRoleData->BaseInfo.szName) - 1; pos >= 1; pos--)
  650. {
  651. if (!pRoleData->BaseInfo.szName[pos])
  652. break;
  653. }
  654. if (pos >= 1)
  655. {
  656. if (g_fltRoleName.IsTextPass(pRoleData->BaseInfo.szName))
  657. nResult = SaveRoleInfo( &pPD->pDataBuffer[1], NULL, TRUE );
  658. else
  659. nResult = -1;
  660. }
  661. }
  662. }}
  664. TProcessData *pInfo = (TProcessData *)(pParam->OutBuffer + sizeof(WORD));
  666. pInfo->nProtoId = s2c_roleserver_createrole_result;
  667. pInfo->ulIdentity = pPD->ulIdentity;
  668. pInfo->nDataLen = 1;
  669. pInfo->pDataBuffer[0] = ( nResult == 1 ) ? 1 : -1;
  671.     int nUsedLen = sizeof(TProcessData);
  673.     *((WORD *)pParam->OutBuffer) = ((WORD)nUsedLen) + sizeof(WORD);
  675.     _SendBuffer(pParam->hSocket, *((WORD *)pParam->OutBuffer), pParam->OutBuffer);
  677.     #ifdef CONSOLE_DEBUG
  678. cout << "_CreateRole::End" << endl;
  679.     #endif
  680. }
  682. void _SaveRoleInfo(THREAD_PARAM *pParam, const void *pData, size_t dataLength)
  683. {
  684. ASSERT( pParam && pData && dataLength);
  685.     
  686.     #ifdef CONSOLE_DEBUG
  687. cout << "_SaveRoleInfo::Begin" << endl;
  688.     #endif
  690. TProcessData *pPD = ( TProcessData * )pData;
  692. int nResult = 0;
  693. TRoleData* pRole = (TRoleData*)(&pPD->pDataBuffer[0]);
  694. char szName[32];
  695. int len = strlen( pRole->BaseInfo.szName );
  696. ASSERT( len > 0 );
  697. len = len > 31 ? 31 : len;
  698. memcpy( szName, pRole->BaseInfo.szName, len );
  699. szName[len] = '';
  701. if (IsRoleLockBySelf(pParam->lID, szName))
  702. {
  703. nResult = SaveRoleInfo( &pPD->pDataBuffer[0], NULL, FALSE );
  704. if (pPD->bLeave)
  705. {
  706. UnlockRoleSelf(pParam->lID, szName);
  707. }
  708. }
  709. else
  710. nResult = 0;
  712. if ( pPD->ulIdentity >= 0 )
  713. {
  714.      TProcessData *pInfo = (TProcessData *)(pParam->OutBuffer + sizeof(WORD));
  716. pInfo->nProtoId = s2c_roleserver_saverole_result;
  717. pInfo->ulIdentity = pPD->ulIdentity;
  718. pInfo->nDataLen = 1;
  719. pInfo->pDataBuffer[0] = ( nResult == 1 ) ? 1 : -1;
  722.         int nUsedLen = sizeof(TProcessData);
  724.         *((WORD *)pParam->OutBuffer) = ((WORD)nUsedLen) + sizeof(WORD);
  726.         _SendBuffer(pParam->hSocket, *((WORD *)pParam->OutBuffer), pParam->OutBuffer);
  727. }
  729.     #ifdef CONSOLE_DEBUG
  730. cout << "_SaveRoleInfo::End" << endl;
  731.     #endif
  732. }
  734. void _DelRole(THREAD_PARAM *pParam, const void *pData, size_t dataLength)
  735. {
  736. ASSERT( pParam && pData && dataLength);
  738.     #ifdef CONSOLE_DEBUG
  739. cout << "_DelRole::Begin" << endl;
  740.     #endif
  742. TProcessData *pRoleInfo = ( TProcessData * )pData;
  744. char szRoleName[_NAME_LENGTH];
  746. int nDataLen = pRoleInfo->nDataLen;
  747. nDataLen = ( nDataLen > _NAME_LENGTH ) ? _NAME_LENGTH : nDataLen;
  749. int result = -1;
  751. if ( nDataLen > 0 )
  752. {
  753. memcpy( szRoleName, &pRoleInfo->pDataBuffer[0], nDataLen );
  754. szRoleName[nDataLen] = '';
  756.         #ifdef CONSOLE_DEBUG
  757. cout << "_DelRole::DeleteRole " << szRoleName << endl;
  758.         #endif
  760. if ( DeleteRole( szRoleName ) )
  761. {
  762. result = 1;
  763. }
  764. else
  765. {
  766. result = -1;
  767. }
  768. }
  770. if ( pRoleInfo->ulIdentity >= 0 )
  771. {
  772.      TProcessData *pInfo = (TProcessData *)(pParam->OutBuffer + sizeof(WORD));
  774. pInfo->nProtoId = s2c_roleserver_deleterole_result;
  775. pInfo->ulIdentity = pRoleInfo->ulIdentity;
  776. pInfo->nDataLen = 1;
  777. pInfo->pDataBuffer[0] = result;
  779.         int nUsedLen = sizeof(TProcessData);
  781.         *((WORD *)pParam->OutBuffer) = ((WORD)nUsedLen) + sizeof(WORD);
  783.         _SendBuffer(pParam->hSocket, *((WORD *)pParam->OutBuffer), pParam->OutBuffer);
  784. }
  786.     #ifdef CONSOLE_DEBUG
  787. cout << "_DelRole::End" << endl;
  788.     #endif
  789. }
  791. void _GetRoleInfo(THREAD_PARAM *pParam, const void *pData, size_t dataLength)
  792. {
  793. ASSERT( pParam && pData && dataLength);
  795.     #ifdef CONSOLE_DEBUG
  796. cout << "_GetRoleInfo::Begin" << endl;
  797.     #endif
  799. TProcessData *pRoleInfo = ( TProcessData * )pData;
  801. char szRoleName[_NAME_LENGTH];
  803. int nDataLen = pRoleInfo->nDataLen;
  804. nDataLen = ( nDataLen > _NAME_LENGTH ) ? _NAME_LENGTH : nDataLen;
  806.     TProcessData *pRoleData = (TProcessData *)(pParam->OutBuffer + sizeof(WORD));
  808. int nUsedLen = sizeof( TProcessData );
  810. size_t nIdentity = pRoleInfo->ulIdentity;
  812. pRoleData->nProtoId = s2c_roleserver_getroleinfo_result;
  813. pRoleData->pDataBuffer[0] = -1;
  814. pRoleData->nDataLen = 1;
  815. pRoleData->ulIdentity = nIdentity;
  817. if ( nDataLen > 0 )
  818. {
  819. memcpy( szRoleName, &pRoleInfo->pDataBuffer[0], nDataLen );
  820. szRoleName[nDataLen] = '';
  822. int result = -1;
  824.         #ifdef CONSOLE_DEBUG
  825. cout << "_GetRoleInfo::GetRoleInfo " << szRoleName << endl;
  826.         #endif
  828. int nRoleInfoLen = 0;
  830. if (!IsRoleLock(szRoleName))
  831.         {
  832. GetRoleInfo( &pRoleData->pDataBuffer[1], szRoleName, nRoleInfoLen );
  833.         }
  835. if ( nRoleInfoLen > 0 )
  836. {
  837. pRoleData->pDataBuffer[0] = 1;
  838. pRoleData->nDataLen = nRoleInfoLen + 1;
  840. nUsedLen = sizeof( TProcessData ) + nRoleInfoLen;
  841. }
  842. }
  844.     *((WORD *)pParam->OutBuffer) = ((WORD)nUsedLen) + sizeof(WORD);
  846.     _SendBuffer(pParam->hSocket, *((WORD *)pParam->OutBuffer), pParam->OutBuffer);
  848.     #ifdef CONSOLE_DEBUG
  849. cout << "_GetRoleInfo::End" << endl;
  850.     #endif
  851. }
  853. void _GetGameStat(THREAD_PARAM *pParam, const void *pData, size_t dataLength)
  854. {
  855.     //发送游戏统计数据(By Fellow,2003.7.22)
  856. ASSERT( pParam && pData && dataLength);
  858.     #ifdef CONSOLE_DEBUG
  859. cout << "_GetGameStat::Begin" << endl;
  860.     #endif
  862. //收到的数据包，只有控制字没有数据
  863. TProcessData *pProData = ( TProcessData * )pData;
  864. size_t nIdentity = pProData->ulIdentity;
  866. //取得统计数据
  867. TProcessData *pStatData = (TProcessData *)(pParam->OutBuffer + sizeof(WORD));
  868. pStatData->nProtoId = s2c_gamestatistic;
  869. pStatData->ulIdentity = nIdentity;
  871.     TGAME_STAT_DATA *pGameStatData = (TGAME_STAT_DATA *)(&pStatData->pDataBuffer[0]);
  873.     GetGameStat(pGameStatData);
  875. int nDataLen = sizeof(TGAME_STAT_DATA);
  877. pStatData->nDataLen = nDataLen;
  879. int nUsedLen = sizeof( TProcessData ) - 1 + nDataLen;
  881.     *((WORD *)pParam->OutBuffer) = ((WORD)nUsedLen) + sizeof(WORD);
  883.     _SendBuffer(pParam->hSocket, *((WORD *)pParam->OutBuffer), pParam->OutBuffer);
  885.     #ifdef CONSOLE_DEBUG
  886. cout << "_GetGameStat::End" << endl;
  887.     #endif
  888. }
  891. //for Relay System and GM [wxb 2003-7-22]
  892. //void _RelayExtend(THREAD_PARAM *pParam, const void *pData, size_t dataLength)
  893. //{
  894. // ASSERT(c2s_extend == *((unsigned char *)pData));
  895. // char* pNewData = ((char *)pData) + 1;
  896. // switch (*((WORD*)pNewData))
  897. // {
  898. // case MAKEWORD(pf_gamemaster, gm_c2s_getrole):
  899. // {
  900. // ASSERT(dataLength == 1 + sizeof(GM_GET_ROLE_DATA_COMMAND));
  901. // GM_GET_ROLE_DATA_COMMAND* pGMData = (GM_GET_ROLE_DATA_COMMAND*)pNewData;
  902. // int nResultBuflen = 0;
  903. // switch(pGMData->wGetID)
  904. // {
  905. // case gm_role_entergame_position:
  906. // {
  907. // ASSERT(0 == pGMData->wLength);
  908. // char* pReturnBuffer = (char*)_alloca(1 + sizeof(GM_GET_ROLE_DATA_SYNC) + sizeof(GM_ROLE_DATA_SUB_ENTER_POS));
  909. //
  910. // *pReturnBuffer = (char)s2c_extend;
  911. //
  912. // GM_GET_ROLE_DATA_SYNC* pGMReturn = (GM_GET_ROLE_DATA_SYNC*)(pReturnBuffer + 1);
  913. // strncpy(pGMReturn->AccountName, pGMData->AccountName, sizeof(pGMData->AccountName));
  914. // pGMReturn->ProtocolFamily = pf_gamemaster;
  915. // pGMReturn->ProtocolType = gm_s2c_getrole;
  916. // pGMReturn->wGetID = gm_role_entergame_position;
  917. // pGMReturn->wLength = sizeof(GM_ROLE_DATA_SUB_ENTER_POS);
  918. //
  919. // GetRoleInfoForGM(pGMData->wGetID, (char*)(pGMReturn + 1), pGMData->AccountName, nResultBuflen);
  920. // ASSERT(pGMReturn->wLength == nResultBuflen);
  921. // m_pServer->SendData( m_nIndentity, pReturnBuffer, 1 + sizeof(GM_GET_ROLE_DATA_SYNC) + sizeof(GM_ROLE_DATA_SUB_ENTER_POS) );
  922. // }
  923. // break;
  924. // default:
  925. // ASSERT(0);
  926. // break;
  927. // }
  928. // }
  929. // break;
  930. //
  931. // case MAKEWORD(pf_gamemaster, gm_c2s_setrole):
  932. // {
  933. // ASSERT(dataLength >= 1 + sizeof(GM_SET_ROLE_DATA_COMMAND));
  934. // GM_SET_ROLE_DATA_COMMAND* pGMData = (GM_SET_ROLE_DATA_COMMAND*)pNewData;
  935. // SetRoleInfoForGM(pGMData->wSetID, (char*)(pGMData + 1), pGMData->AccountName, pGMData->wLength);
  936. // }
  937. // break;
  938. // default:
  939. // ASSERT(0);
  940. // break;
  941. // }
  942. //}