1. #include "stdafx.h"
  3. #include "../../common/billing.h"
  4. #include "../../common/building.h"
  5. #include "../../common/VnumHelper.h"
  6. #include "../../libgame/include/grid.h"
  7. #include "../../common/service.h"
  9. #include "ClientManager.h"
  11. #include "Main.h"
  12. #include "Config.h"
  13. #include "DBManager.h"
  14. #include "QID.h"
  15. #include "GuildManager.h"
  16. #include "PrivManager.h"
  17. #include "MoneyLog.h"
  18. #include "ItemAwardManager.h"
  19. #include "Marriage.h"
  20. #include "Monarch.h"
  21. #include "BlockCountry.h"
  22. #include "ItemIDRangeManager.h"
  23. #include "Cache.h"
  24. #ifdef __AUCTION__
  25. #include "AuctionManager.h"
  26. #endif
  27. extern int g_iPlayerCacheFlushSeconds;
  28. extern int g_iItemCacheFlushSeconds;
  29. extern int g_test_server;
  30. extern int g_log;
  31. extern std::string g_stLocale;
  32. extern std::string g_stLocaleNameColumn;
  33. bool CreateItemTableFromRes(MYSQL_RES * res, std::vector<TPlayerItem> * pVec, DWORD dwPID);
  35. DWORD g_dwUsageMax = 0;
  36. DWORD g_dwUsageAvg = 0;
  38. CPacketInfo g_query_info;
  39. CPacketInfo g_item_info;
  41. int g_item_count = 0;
  42. int g_query_count[2];
  44. CClientManager::CClientManager() :
  45. m_pkAuthPeer(NULL),
  46. m_iPlayerIDStart(0),
  47. m_iPlayerDeleteLevelLimit(0),
  48. m_iPlayerDeleteLevelLimitLower(0),
  49. m_bChinaEventServer(false),
  50. m_iShopTableSize(0),
  51. m_pShopTable(NULL),
  52. m_iRefineTableSize(0),
  53. m_pRefineTable(NULL),
  54. m_bShutdowned(FALSE),
  55. m_iCacheFlushCount(0),
  56. m_iCacheFlushCountLimit(200)
  57. {
  58. m_itemRange.dwMin = 0;
  59. m_itemRange.dwMax = 0;
  60. m_itemRange.dwUsableItemIDMin = 0;
  62. memset(g_query_count, 0, sizeof(g_query_count));
  63. }
  65. CClientManager::~CClientManager()
  66. {
  67. Destroy();
  68. }
  70. void CClientManager::SetPlayerIDStart(int iIDStart)
  71. {
  72. m_iPlayerIDStart = iIDStart;
  73. }
  75. void CClientManager::Destroy()
  76. {
  77. m_mChannelStatus.clear();
  78. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end(); ++i)
  79. (*i)->Destroy();
  81. m_peerList.clear();
  83. if (m_fdAccept > 0)
  84. {
  85. socket_close(m_fdAccept);
  86. m_fdAccept = -1;
  87. }
  88. }
  90. bool CClientManager::Initialize()
  91. {
  92. int tmpValue;
  94. //BOOT_LOCALIZATION
  95. if (!InitializeLocalization())
  96. {
  97. fprintf(stderr, "Failed Localization Infomation so exit\n");
  98. return false;
  99. }
  101. //END_BOOT_LOCALIZATION
  102. //ITEM_UNIQUE_ID
  104. if (!InitializeNowItemID())
  105. {
  106. fprintf(stderr, " Item range Initialize Failed. Exit DBCache Server\n");
  107. return false;
  108. }
  109. //END_ITEM_UNIQUE_ID
  111. if (!InitializeTables())
  112. {
  113. sys_err("Table Initialize FAILED");
  114. return false;
  115. }
  117. CGuildManager::instance().BootReserveWar();
  119. if (!CConfig::instance().GetValue("BIND_PORT", &tmpValue))
  120. tmpValue = 5300;
  122. char szBindIP[128];
  124. if (!CConfig::instance().GetValue("BIND_IP", szBindIP, 128))
  125. strlcpy(szBindIP, "0", sizeof(szBindIP));
  127. m_fdAccept = socket_tcp_bind(szBindIP, tmpValue);
  129. if (m_fdAccept < 0)
  130. {
  131. perror("socket");
  132. return false;
  133. }
  135. sys_log(0, "ACCEPT_HANDLE: %u", m_fdAccept);
  136. fdwatch_add_fd(m_fdWatcher, m_fdAccept, NULL, FDW_READ, false);
  138. if (!CConfig::instance().GetValue("BACKUP_LIMIT_SEC", &tmpValue))
  139. tmpValue = 600;
  141. m_looping = true;
  143. if (!CConfig::instance().GetValue("PLAYER_DELETE_LEVEL_LIMIT", &m_iPlayerDeleteLevelLimit))
  144. {
  145. sys_err("conf.txt: Cannot find PLAYER_DELETE_LEVEL_LIMIT, use default level %d", PLAYER_MAX_LEVEL_CONST + 1);
  146. m_iPlayerDeleteLevelLimit = PLAYER_MAX_LEVEL_CONST + 1;
  147. }
  149. if (!CConfig::instance().GetValue("PLAYER_DELETE_LEVEL_LIMIT_LOWER", &m_iPlayerDeleteLevelLimitLower))
  150. {
  151. m_iPlayerDeleteLevelLimitLower = 0;
  152. }
  154. sys_log(0, "PLAYER_DELETE_LEVEL_LIMIT set to %d", m_iPlayerDeleteLevelLimit);
  155. sys_log(0, "PLAYER_DELETE_LEVEL_LIMIT_LOWER set to %d", m_iPlayerDeleteLevelLimitLower);
  157. m_bChinaEventServer = false;
  159. int iChinaEventServer = 0;
  161. if (CConfig::instance().GetValue("CHINA_EVENT_SERVER", &iChinaEventServer))
  162. m_bChinaEventServer = (iChinaEventServer);
  164. sys_log(0, "CHINA_EVENT_SERVER %s", CClientManager::instance().IsChinaEventServer()?"true":"false");
  167. LoadEventFlag();
  169. // database character-set을 강제로 맞춤
  170. if (g_stLocale == "big5" || g_stLocale == "sjis")
  171. CDBManager::instance().QueryLocaleSet();
  173. return true;
  174. }
  176. void CClientManager::MainLoop()
  177. {
  178. SQLMsg * tmp;
  180. sys_log(0, "ClientManager pointer is %p", this);
  182. // 메인루프
  183. while (!m_bShutdowned)
  184. {
  185. while ((tmp = CDBManager::instance().PopResult()))
  186. {
  187. AnalyzeQueryResult(tmp);
  188. delete tmp;
  189. }
  191. if (!Process())
  192. break;
  194. log_rotate();
  195. }
  197. //
  198. // 메인루프 종료처리
  199. //
  200. sys_log(0, "MainLoop exited, Starting cache flushing");
  202. signal_timer_disable();
  204. itertype(m_map_playerCache) it = m_map_playerCache.begin();
  206. //플레이어 테이블 캐쉬 플러쉬
  207. while (it != m_map_playerCache.end())
  208. {
  209. CPlayerTableCache * c = (it++)->second;
  211. c->Flush();
  212. delete c;
  213. }
  214. m_map_playerCache.clear();
  217. itertype(m_map_itemCache) it2 = m_map_itemCache.begin();
  218. //아이템 플러쉬
  219. while (it2 != m_map_itemCache.end())
  220. {
  221. CItemCache * c = (it2++)->second;
  223. c->Flush();
  224. delete c;
  225. }
  226. m_map_itemCache.clear();
  228. // MYSHOP_PRICE_LIST
  229. //
  230. // 개인상점 아이템 가격 리스트 Flush
  231. //
  232. for (itertype(m_mapItemPriceListCache) itPriceList = m_mapItemPriceListCache.begin(); itPriceList != m_mapItemPriceListCache.end(); ++itPriceList)
  233. {
  234. CItemPriceListTableCache* pCache = itPriceList->second;
  235. pCache->Flush();
  236. delete pCache;
  237. }
  239. m_mapItemPriceListCache.clear();
  240. // END_OF_MYSHOP_PRICE_LIST
  241. }
  243. void CClientManager::Quit()
  244. {
  245. m_bShutdowned = TRUE;
  246. }
  248. void CClientManager::QUERY_BOOT(CPeer* peer, TPacketGDBoot * p)
  249. {
  250. const BYTE bPacketVersion = 6; // BOOT 패킷이 바뀔때마다 번호를 올리도록 한다.
  252. std::vector<tAdminInfo> vAdmin;
  253. std::vector<std::string> vHost;
  255. __GetHostInfo(vHost);
  256. __GetAdminInfo(p->szIP, vAdmin);
  258. sys_log(0, "QUERY_BOOT : AdminInfo (Request ServerIp %s) ", p->szIP);
  260. DWORD dwPacketSize =
  261. sizeof(DWORD) +
  262. sizeof(BYTE) +
  263. sizeof(WORD) + sizeof(WORD) + sizeof(TMobTable) * m_vec_mobTable.size() +
  264. sizeof(WORD) + sizeof(WORD) + sizeof(TItemTable) * m_vec_itemTable.size() +
  265. sizeof(WORD) + sizeof(WORD) + sizeof(TShopTable) * m_iShopTableSize +
  266. sizeof(WORD) + sizeof(WORD) + sizeof(TSkillTable) * m_vec_skillTable.size() +
  267. sizeof(WORD) + sizeof(WORD) + sizeof(TRefineTable) * m_iRefineTableSize +
  268. sizeof(WORD) + sizeof(WORD) + sizeof(TItemAttrTable) * m_vec_itemAttrTable.size() +
  269. sizeof(WORD) + sizeof(WORD) + sizeof(TItemAttrTable) * m_vec_itemRareTable.size() +
  270. sizeof(WORD) + sizeof(WORD) + sizeof(TBanwordTable) * m_vec_banwordTable.size() +
  271. sizeof(WORD) + sizeof(WORD) + sizeof(building::TLand) * m_vec_kLandTable.size() +
  272. sizeof(WORD) + sizeof(WORD) + sizeof(building::TObjectProto) * m_vec_kObjectProto.size() +
  273. sizeof(WORD) + sizeof(WORD) + sizeof(building::TObject) * m_map_pkObjectTable.size() +
  274. #ifdef __AUCTION__
  275. sizeof(WORD) + sizeof(WORD) + sizeof(TPlayerItem) * AuctionManager::instance().GetAuctionItemSize() +
  276. sizeof(WORD) + sizeof(WORD) + sizeof(TAuctionItemInfo) * AuctionManager::instance().GetAuctionSize() +
  277. sizeof(WORD) + sizeof(WORD) + sizeof(TSaleItemInfo) * AuctionManager::instance().GetSaleSize() +
  278. sizeof(WORD) + sizeof(WORD) + sizeof(TWishItemInfo) * AuctionManager::instance().GetWishSize() +
  279. sizeof(WORD) + sizeof(WORD) + (sizeof(DWORD) + sizeof(DWORD) + sizeof(int)) * AuctionManager::instance().GetMyBidSize() +
  280. #endif
  281. sizeof(time_t) +
  282. sizeof(WORD) + sizeof(WORD) + sizeof(TItemIDRangeTable)*2 +
  283. //ADMIN_MANAGER
  284. sizeof(WORD) + sizeof(WORD) + 16 * vHost.size() +
  285. sizeof(WORD) + sizeof(WORD) + sizeof(tAdminInfo) * vAdmin.size() +
  286. //END_ADMIN_MANAGER
  287. sizeof(WORD) + sizeof(WORD) + sizeof(TMonarchInfo) +
  288. sizeof(WORD) + sizeof(WORD) + sizeof(MonarchCandidacy)* CMonarch::instance().MonarchCandidacySize() +
  289. sizeof(WORD);
  291. peer->EncodeHeader(HEADER_DG_BOOT, 0, dwPacketSize);
  292. peer->Encode(&dwPacketSize, sizeof(DWORD));
  293. peer->Encode(&bPacketVersion, sizeof(BYTE));
  295. sys_log(0, "BOOT: PACKET: %d", dwPacketSize);
  296. sys_log(0, "BOOT: VERSION: %d", bPacketVersion);
  298. sys_log(0, "sizeof(TMobTable) = %d", sizeof(TMobTable));
  299. sys_log(0, "sizeof(TItemTable) = %d", sizeof(TItemTable));
  300. sys_log(0, "sizeof(TShopTable) = %d", sizeof(TShopTable));
  301. sys_log(0, "sizeof(TSkillTable) = %d", sizeof(TSkillTable));
  302. sys_log(0, "sizeof(TRefineTable) = %d", sizeof(TRefineTable));
  303. sys_log(0, "sizeof(TItemAttrTable) = %d", sizeof(TItemAttrTable));
  304. sys_log(0, "sizeof(TItemRareTable) = %d", sizeof(TItemAttrTable));
  305. sys_log(0, "sizeof(TBanwordTable) = %d", sizeof(TBanwordTable));
  306. sys_log(0, "sizeof(TLand) = %d", sizeof(building::TLand));
  307. sys_log(0, "sizeof(TObjectProto) = %d", sizeof(building::TObjectProto));
  308. sys_log(0, "sizeof(TObject) = %d", sizeof(building::TObject));
  309. //ADMIN_MANAGER
  310. sys_log(0, "sizeof(tAdminInfo) = %d * %d ", sizeof(tAdminInfo) * vAdmin.size());
  311. //END_ADMIN_MANAGER
  312. sys_log(0, "sizeof(TMonarchInfo) = %d * %d", sizeof(TMonarchInfo));
  314. peer->EncodeWORD(sizeof(TMobTable));
  315. peer->EncodeWORD(m_vec_mobTable.size());
  316. peer->Encode(&m_vec_mobTable[0], sizeof(TMobTable) * m_vec_mobTable.size());
  318. peer->EncodeWORD(sizeof(TItemTable));
  319. peer->EncodeWORD(m_vec_itemTable.size());
  320. peer->Encode(&m_vec_itemTable[0], sizeof(TItemTable) * m_vec_itemTable.size());
  322. peer->EncodeWORD(sizeof(TShopTable));
  323. peer->EncodeWORD(m_iShopTableSize);
  324. peer->Encode(m_pShopTable, sizeof(TShopTable) * m_iShopTableSize);
  326. peer->EncodeWORD(sizeof(TSkillTable));
  327. peer->EncodeWORD(m_vec_skillTable.size());
  328. peer->Encode(&m_vec_skillTable[0], sizeof(TSkillTable) * m_vec_skillTable.size());
  330. peer->EncodeWORD(sizeof(TRefineTable));
  331. peer->EncodeWORD(m_iRefineTableSize);
  332. peer->Encode(m_pRefineTable, sizeof(TRefineTable) * m_iRefineTableSize);
  334. peer->EncodeWORD(sizeof(TItemAttrTable));
  335. peer->EncodeWORD(m_vec_itemAttrTable.size());
  336. peer->Encode(&m_vec_itemAttrTable[0], sizeof(TItemAttrTable) * m_vec_itemAttrTable.size());
  338. peer->EncodeWORD(sizeof(TItemAttrTable));
  339. peer->EncodeWORD(m_vec_itemRareTable.size());
  340. peer->Encode(&m_vec_itemRareTable[0], sizeof(TItemAttrTable) * m_vec_itemRareTable.size());
  342. peer->EncodeWORD(sizeof(TBanwordTable));
  343. peer->EncodeWORD(m_vec_banwordTable.size());
  344. peer->Encode(&m_vec_banwordTable[0], sizeof(TBanwordTable) * m_vec_banwordTable.size());
  346. peer->EncodeWORD(sizeof(building::TLand));
  347. peer->EncodeWORD(m_vec_kLandTable.size());
  348. peer->Encode(&m_vec_kLandTable[0], sizeof(building::TLand) * m_vec_kLandTable.size());
  350. peer->EncodeWORD(sizeof(building::TObjectProto));
  351. peer->EncodeWORD(m_vec_kObjectProto.size());
  352. peer->Encode(&m_vec_kObjectProto[0], sizeof(building::TObjectProto) * m_vec_kObjectProto.size());
  354. peer->EncodeWORD(sizeof(building::TObject));
  355. peer->EncodeWORD(m_map_pkObjectTable.size());
  357. itertype(m_map_pkObjectTable) it = m_map_pkObjectTable.begin();
  359. while (it != m_map_pkObjectTable.end())
  360. peer->Encode((it++)->second, sizeof(building::TObject));
  362. // Auction Boot
  363. #ifdef __AUCTION__
  364. AuctionManager::instance().Boot (peer);
  365. #endif
  366. time_t now = time(0);
  367. peer->Encode(&now, sizeof(time_t));
  369. TItemIDRangeTable itemRange = CItemIDRangeManager::instance().GetRange();
  370. TItemIDRangeTable itemRangeSpare = CItemIDRangeManager::instance().GetRange();
  372. peer->EncodeWORD(sizeof(TItemIDRangeTable));
  373. peer->EncodeWORD(1);
  374. peer->Encode(&itemRange, sizeof(TItemIDRangeTable));
  375. peer->Encode(&itemRangeSpare, sizeof(TItemIDRangeTable));
  377. peer->SetItemIDRange(itemRange);
  378. peer->SetSpareItemIDRange(itemRangeSpare);
  380. //ADMIN_MANAGER
  381. peer->EncodeWORD(16);
  382. peer->EncodeWORD(vHost.size());
  384. for (size_t n = 0; n < vHost.size(); ++n)
  385. {
  386. peer->Encode(vHost[n].c_str(), 16);
  387. sys_log(0, "GMHosts %s", vHost[n].c_str());
  388. }
  390. peer->EncodeWORD(sizeof(tAdminInfo));
  391. peer->EncodeWORD(vAdmin.size());
  393. for (size_t n = 0; n < vAdmin.size(); ++n)
  394. {
  395. peer->Encode(&vAdmin[n], sizeof(tAdminInfo));
  396. sys_log(0, "Admin name %s ConntactIP %s", vAdmin[n].m_szName, vAdmin[n].m_szContactIP);
  397. }
  398. //END_ADMIN_MANAGER
  400. //MONARCH
  401. peer->EncodeWORD(sizeof(TMonarchInfo));
  402. peer->EncodeWORD(1);
  403. peer->Encode(CMonarch::instance().GetMonarch(), sizeof(TMonarchInfo));
  405. CMonarch::VEC_MONARCHCANDIDACY & rVecMonarchCandidacy = CMonarch::instance().GetVecMonarchCandidacy();
  407. size_t num_monarch_candidacy = CMonarch::instance().MonarchCandidacySize();
  408. peer->EncodeWORD(sizeof(MonarchCandidacy));
  409. peer->EncodeWORD(num_monarch_candidacy);
  410. if (num_monarch_candidacy != 0) {
  411. peer->Encode(&rVecMonarchCandidacy[0], sizeof(MonarchCandidacy) * num_monarch_candidacy);
  412. }
  413. //END_MONARCE
  415. if (g_test_server)
  416. sys_log(0, "MONARCHCandidacy Size %d", CMonarch::instance().MonarchCandidacySize());
  418. peer->EncodeWORD(0xffff);
  419. }
  421. void CClientManager::SendPartyOnSetup(CPeer* pkPeer)
  422. {
  423. TPartyMap & pm = m_map_pkChannelParty[pkPeer->GetChannel()];
  425. for (itertype(pm) it_party = pm.begin(); it_party != pm.end(); ++it_party)
  426. {
  427. sys_log(0, "PARTY SendPartyOnSetup Party [%u]", it_party->first);
  428. pkPeer->EncodeHeader(HEADER_DG_PARTY_CREATE, 0, sizeof(TPacketPartyCreate));
  429. pkPeer->Encode(&it_party->first, sizeof(DWORD));
  431. for (itertype(it_party->second) it_member = it_party->second.begin(); it_member != it_party->second.end(); ++it_member)
  432. {
  433. sys_log(0, "PARTY SendPartyOnSetup Party [%u] Member [%u]", it_party->first, it_member->first);
  434. pkPeer->EncodeHeader(HEADER_DG_PARTY_ADD, 0, sizeof(TPacketPartyAdd));
  435. pkPeer->Encode(&it_party->first, sizeof(DWORD));
  436. pkPeer->Encode(&it_member->first, sizeof(DWORD));
  437. pkPeer->Encode(&it_member->second.bRole, sizeof(BYTE));
  439. pkPeer->EncodeHeader(HEADER_DG_PARTY_SET_MEMBER_LEVEL, 0, sizeof(TPacketPartySetMemberLevel));
  440. pkPeer->Encode(&it_party->first, sizeof(DWORD));
  441. pkPeer->Encode(&it_member->first, sizeof(DWORD));
  442. pkPeer->Encode(&it_member->second.bLevel, sizeof(BYTE));
  443. }
  444. }
  445. }
  447. void CClientManager::QUERY_PLAYER_COUNT(CPeer * pkPeer, TPlayerCountPacket * pPacket)
  448. {
  449. pkPeer->SetUserCount(pPacket->dwCount);
  450. }
  452. void CClientManager::QUERY_QUEST_SAVE(CPeer * pkPeer, TQuestTable * pTable, DWORD dwLen)
  453. {
  454. if (0 != (dwLen % sizeof(TQuestTable)))
  455. {
  456. sys_err("invalid packet size %d, sizeof(TQuestTable) == %d", dwLen, sizeof(TQuestTable));
  457. return;
  458. }
  460. int iSize = dwLen / sizeof(TQuestTable);
  462. char szQuery[1024];
  464. for (int i = 0; i < iSize; ++i, ++pTable)
  465. {
  466. if (pTable->lValue == 0)
  467. {
  468. snprintf(szQuery, sizeof(szQuery),
  469. "DELETE FROM quest%s WHERE dwPID=%d AND szName='%s' AND szState='%s'",
  470. GetTablePostfix(), pTable->dwPID, pTable->szName, pTable->szState);
  471. }
  472. else
  473. {
  474. snprintf(szQuery, sizeof(szQuery),
  475. "REPLACE INTO quest%s (dwPID, szName, szState, lValue) VALUES(%d, '%s', '%s', %ld)",
  476. GetTablePostfix(), pTable->dwPID, pTable->szName, pTable->szState, pTable->lValue);
  477. }
  479. CDBManager::instance().ReturnQuery(szQuery, QID_QUEST_SAVE, pkPeer->GetHandle(), NULL);
  480. }
  481. }
  483. void CClientManager::QUERY_SAFEBOX_LOAD(CPeer * pkPeer, DWORD dwHandle, TSafeboxLoadPacket * packet, bool bMall)
  484. {
  485. ClientHandleInfo * pi = new ClientHandleInfo(dwHandle);
  486. strlcpy(pi->safebox_password, packet->szPassword, sizeof(pi->safebox_password));
  487. pi->account_id = packet->dwID;
  488. pi->account_index = 0;
  489. pi->ip[0] = bMall ? 1 : 0;
  490. strlcpy(pi->login, packet->szLogin, sizeof(pi->login));
  492. char szQuery[QUERY_MAX_LEN];
  493. snprintf(szQuery, sizeof(szQuery),
  494. "SELECT account_id, size, password FROM safebox%s WHERE account_id=%u",
  495. GetTablePostfix(), packet->dwID);
  497. if (g_log)
  498. sys_log(0, "HEADER_GD_SAFEBOX_LOAD (handle: %d account.id %u is_mall %d)", dwHandle, packet->dwID, bMall ? 1 : 0);
  500. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_LOAD, pkPeer->GetHandle(), pi);
  501. }
  503. void CClientManager::RESULT_SAFEBOX_LOAD(CPeer * pkPeer, SQLMsg * msg)
  504. {
  505. CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
  506. ClientHandleInfo * pi = (ClientHandleInfo *) qi->pvData;
  507. DWORD dwHandle = pi->dwHandle;
  509. // 여기에서 사용하는 account_index는 쿼리 순서를 말한다.
  510. // 첫번째 패스워드 알아내기 위해 하는 쿼리가 0
  511. // 두번째 실제 데이터를 얻어놓는 쿼리가 1
  513. if (pi->account_index == 0)
  514. {
  515. char szSafeboxPassword[SAFEBOX_PASSWORD_MAX_LEN + 1];
  516. strlcpy(szSafeboxPassword, pi->safebox_password, sizeof(szSafeboxPassword));
  518. TSafeboxTable * pSafebox = new TSafeboxTable;
  519. memset(pSafebox, 0, sizeof(TSafeboxTable));
  521. SQLResult * res = msg->Get();
  523. if (res->uiNumRows == 0)
  524. {
  525. if (strcmp("000000", szSafeboxPassword))
  526. {
  527. pkPeer->EncodeHeader(HEADER_DG_SAFEBOX_WRONG_PASSWORD, dwHandle, 0);
  528. delete pSafebox;
  529. delete pi;
  530. return;
  531. }
  532. }
  533. else
  534. {
  535. MYSQL_ROW row = mysql_fetch_row(res->pSQLResult);
  537. // 비밀번호가 틀리면..
  538. if (((!row[2] || !*row[2]) && strcmp("000000", szSafeboxPassword)) ||
  539. ((row[2] && *row[2]) && strcmp(row[2], szSafeboxPassword)))
  540. {
  541. pkPeer->EncodeHeader(HEADER_DG_SAFEBOX_WRONG_PASSWORD, dwHandle, 0);
  542. delete pSafebox;
  543. delete pi;
  544. return;
  545. }
  547. if (!row[0])
  548. pSafebox->dwID = 0;
  549. else
  550. str_to_number(pSafebox->dwID, row[0]);
  552. if (!row[1])
  553. pSafebox->bSize = 0;
  554. else
  555. str_to_number(pSafebox->bSize, row[1]);
  556. /*
  557. if (!row[3])
  558. pSafebox->dwGold = 0;
  559. else
  560. pSafebox->dwGold = atoi(row[3]);
  561. */
  562. if (pi->ip[0] == 1)
  563. {
  564. pSafebox->bSize = 1;
  565. sys_log(0, "MALL id[%d] size[%d]", pSafebox->dwID, pSafebox->bSize);
  566. }
  567. else
  568. sys_log(0, "SAFEBOX id[%d] size[%d]", pSafebox->dwID, pSafebox->bSize);
  569. }
  571. if (0 == pSafebox->dwID)
  572. pSafebox->dwID = pi->account_id;
  574. pi->pSafebox = pSafebox;
  576. char szQuery[512];
  577. snprintf(szQuery, sizeof(szQuery),
  578. "SELECT id, window+0, pos, count, vnum, socket0, socket1, socket2, "
  579. "attrtype0, attrvalue0, "
  580. "attrtype1, attrvalue1, "
  581. "attrtype2, attrvalue2, "
  582. "attrtype3, attrvalue3, "
  583. "attrtype4, attrvalue4, "
  584. "attrtype5, attrvalue5, "
  585. "attrtype6, attrvalue6 "
  586. "FROM item%s WHERE owner_id=%d AND window='%s'",
  587. GetTablePostfix(), pi->account_id, pi->ip[0] == 0 ? "SAFEBOX" : "MALL");
  589. pi->account_index = 1;
  591. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_LOAD, pkPeer->GetHandle(), pi);
  592. }
  593. else
  594. {
  596. if (!pi->pSafebox)
  597. {
  598. sys_err("null safebox pointer!");
  599. delete pi;
  600. return;
  601. }
  604. // 쿼리에 에러가 있었으므로 응답할 경우 창고가 비어있는 것 처럼
  605. // 보이기 때문에 창고가 아얘 안열리는게 나음
  606. if (!msg->Get()->pSQLResult)
  607. {
  608. sys_err("null safebox result");
  609. delete pi;
  610. return;
  611. }
  613. static std::vector<TPlayerItem> s_items;
  614. CreateItemTableFromRes(msg->Get()->pSQLResult, &s_items, pi->account_id);
  616. std::set<TItemAward *> * pSet = ItemAwardManager::instance().GetByLogin(pi->login);
  618. if (pSet && !m_vec_itemTable.empty())
  619. {
  621. CGrid grid(5, MAX(1, pi->pSafebox->bSize) * 9);
  622. bool bEscape = false;
  624. for (DWORD i = 0; i < s_items.size(); ++i)
  625. {
  626. TPlayerItem & r = s_items[i];
  628. itertype(m_map_itemTableByVnum) it = m_map_itemTableByVnum.find(r.vnum);
  630. if (it == m_map_itemTableByVnum.end())
  631. {
  632. bEscape = true;
  633. sys_err("invalid item vnum %u in safebox: login %s", r.vnum, pi->login);
  634. break;
  635. }
  637. grid.Put(r.pos, 1, it->second->bSize);
  638. }
  640. if (!bEscape)
  641. {
  642. std::vector<std::pair<DWORD, DWORD> > vec_dwFinishedAwardID;
  644. __typeof(pSet->begin()) it = pSet->begin();
  646. char szQuery[512];
  648. while (it != pSet->end())
  649. {
  650. TItemAward * pItemAward = *(it++);
  651. const DWORD& dwItemVnum = pItemAward->dwVnum;
  653. if (pItemAward->bTaken)
  654. continue;
  656. if (pi->ip[0] == 0 && pItemAward->bMall)
  657. continue;
  659. if (pi->ip[0] == 1 && !pItemAward->bMall)
  660. continue;
  662. itertype(m_map_itemTableByVnum) it = m_map_itemTableByVnum.find(pItemAward->dwVnum);
  664. if (it == m_map_itemTableByVnum.end())
  665. {
  666. sys_err("invalid item vnum %u in item_award: login %s", pItemAward->dwVnum, pi->login);
  667. continue;
  668. }
  670. TItemTable * pItemTable = it->second;
  672. int iPos;
  674. if ((iPos = grid.FindBlank(1, it->second->bSize)) == -1)
  675. break;
  677. TPlayerItem item;
  678. memset(&item, 0, sizeof(TPlayerItem));
  680. DWORD dwSocket2 = 0;
  682. if (pItemTable->bType == ITEM_UNIQUE)
  683. {
  684. if (pItemAward->dwSocket2 != 0)
  685. dwSocket2 = pItemAward->dwSocket2;
  686. else
  687. dwSocket2 = pItemTable->alValues[0];
  688. }
  689. else if ((dwItemVnum == 50300 || dwItemVnum == 70037) && pItemAward->dwSocket0 == 0)
  690. {
  691. DWORD dwSkillIdx;
  692. DWORD dwSkillVnum;
  694. do
  695. {
  696. dwSkillIdx = number(0, m_vec_skillTable.size()-1);
  698. dwSkillVnum = m_vec_skillTable[dwSkillIdx].dwVnum;
  700. if (!dwSkillVnum > 120)
  701. continue;
  703. break;
  704. } while (1);
  706. pItemAward->dwSocket0 = dwSkillVnum;
  707. }
  708. else
  709. {
  710. switch (dwItemVnum)
  711. {
  712. case 72723: case 72724: case 72725: case 72726:
  713. case 72727: case 72728: case 72729: case 72730:
  714. // 무시무시하지만 이전에 하던 걸 고치기는 무섭고...
  715. // 그래서 그냥 하드 코딩. 선물 상자용 자동물약 아이템들.
  716. case 76004: case 76005: case 76021: case 76022:
  717. case 79012: case 79013:
  718. if (pItemAward->dwSocket2 == 0)
  719. {
  720. dwSocket2 = pItemTable->alValues[0];
  721. }
  722. else
  723. {
  724. dwSocket2 = pItemAward->dwSocket2;
  725. }
  726. break;
  727. }
  728. }
  730. if (GetItemID () > m_itemRange.dwMax)
  731. {
  732. sys_err("UNIQUE ID OVERFLOW!!");
  733. break;
  734. }
  736. {
  737. itertype(m_map_itemTableByVnum) it = m_map_itemTableByVnum.find (dwItemVnum);
  738. if (it == m_map_itemTableByVnum.end())
  739. {
  740. sys_err ("Invalid item(vnum : %d). It is not in m_map_itemTableByVnum.", dwItemVnum);
  741. continue;
  742. }
  743. TItemTable* item_table = it->second;
  744. if (item_table == NULL)
  745. {
  746. sys_err ("Invalid item_table (vnum : %d). It's value is NULL in m_map_itemTableByVnum.", dwItemVnum);
  747. continue;
  748. }
  749. if (0 == pItemAward->dwSocket0)
  750. {
  751. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; i++)
  752. {
  753. if (LIMIT_REAL_TIME == item_table->aLimits[i].bType)
  754. {
  755. if (0 == item_table->aLimits[i].lValue)
  756. pItemAward->dwSocket0 = time(0) + 60 * 60 * 24 * 7;
  757. else
  758. pItemAward->dwSocket0 = time(0) + item_table->aLimits[i].lValue;
  760. break;
  761. }
  762. else if (LIMIT_REAL_TIME_START_FIRST_USE == item_table->aLimits[i].bType || LIMIT_TIMER_BASED_ON_WEAR == item_table->aLimits[i].bType)
  763. {
  764. if (0 == item_table->aLimits[i].lValue)
  765. pItemAward->dwSocket0 = 60 * 60 * 24 * 7;
  766. else
  767. pItemAward->dwSocket0 = item_table->aLimits[i].lValue;
  769. break;
  770. }
  771. }
  772. }
  774. snprintf(szQuery, sizeof(szQuery),
  775. "INSERT INTO item%s (id, owner_id, window, pos, vnum, count, socket0, socket1, socket2) "
  776. "VALUES(%u, %u, '%s', %d, %u, %u, %u, %u, %u)",
  777. GetTablePostfix(),
  778. GainItemID(),
  779. pi->account_id,
  780. pi->ip[0] == 0 ? "SAFEBOX" : "MALL",
  781. iPos,
  782. pItemAward->dwVnum, pItemAward->dwCount, pItemAward->dwSocket0, pItemAward->dwSocket1, dwSocket2);
  783. }
  785. std::unique_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery));
  786. SQLResult * pRes = pmsg->Get();
  787. sys_log(0, "SAFEBOX Query : [%s]", szQuery);
  789. if (pRes->uiAffectedRows == 0 || pRes->uiInsertID == 0 || pRes->uiAffectedRows == (uint32_t)-1)
  790. break;
  792. item.id = pmsg->Get()->uiInsertID;
  793. item.window = pi->ip[0] == 0 ? SAFEBOX : MALL,
  794. item.pos = iPos;
  795. item.count = pItemAward->dwCount;
  796. item.vnum = pItemAward->dwVnum;
  797. item.alSockets[0] = pItemAward->dwSocket0;
  798. item.alSockets[1] = pItemAward->dwSocket1;
  799. item.alSockets[2] = dwSocket2;
  800. s_items.push_back(item);
  802. vec_dwFinishedAwardID.push_back(std::make_pair(pItemAward->dwID, item.id));
  803. grid.Put(iPos, 1, it->second->bSize);
  804. }
  806. for (DWORD i = 0; i < vec_dwFinishedAwardID.size(); ++i)
  807. ItemAwardManager::instance().Taken(vec_dwFinishedAwardID[i].first, vec_dwFinishedAwardID[i].second);
  808. }
  809. }
  811. pi->pSafebox->wItemCount = s_items.size();
  813. pkPeer->EncodeHeader(pi->ip[0] == 0 ? HEADER_DG_SAFEBOX_LOAD : HEADER_DG_MALL_LOAD, dwHandle, sizeof(TSafeboxTable) + sizeof(TPlayerItem) * s_items.size());
  815. pkPeer->Encode(pi->pSafebox, sizeof(TSafeboxTable));
  817. if (!s_items.empty())
  818. pkPeer->Encode(&s_items[0], sizeof(TPlayerItem) * s_items.size());
  820. delete pi;
  821. }
  822. }
  824. void CClientManager::QUERY_SAFEBOX_CHANGE_SIZE(CPeer * pkPeer, DWORD dwHandle, TSafeboxChangeSizePacket * p)
  825. {
  826. ClientHandleInfo * pi = new ClientHandleInfo(dwHandle);
  827. pi->account_index = p->bSize; // account_index를 사이즈로 임시로 사용
  829. char szQuery[QUERY_MAX_LEN];
  831. if (p->bSize == 1)
  832. snprintf(szQuery, sizeof(szQuery), "INSERT INTO safebox%s (account_id, size) VALUES(%u, %u)", GetTablePostfix(), p->dwID, p->bSize);
  833. else
  834. snprintf(szQuery, sizeof(szQuery), "UPDATE safebox%s SET size=%u WHERE account_id=%u", GetTablePostfix(), p->bSize, p->dwID);
  836. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_CHANGE_SIZE, pkPeer->GetHandle(), pi);
  837. }
  839. void CClientManager::RESULT_SAFEBOX_CHANGE_SIZE(CPeer * pkPeer, SQLMsg * msg)
  840. {
  841. CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
  842. ClientHandleInfo * p = (ClientHandleInfo *) qi->pvData;
  843. DWORD dwHandle = p->dwHandle;
  844. BYTE bSize = p->account_index;
  846. delete p;
  848. if (msg->Get()->uiNumRows > 0)
  849. {
  850. pkPeer->EncodeHeader(HEADER_DG_SAFEBOX_CHANGE_SIZE, dwHandle, sizeof(BYTE));
  851. pkPeer->EncodeBYTE(bSize);
  852. }
  853. }
  855. void CClientManager::QUERY_SAFEBOX_CHANGE_PASSWORD(CPeer * pkPeer, DWORD dwHandle, TSafeboxChangePasswordPacket * p)
  856. {
  857. ClientHandleInfo * pi = new ClientHandleInfo(dwHandle);
  858. strlcpy(pi->safebox_password, p->szNewPassword, sizeof(pi->safebox_password));
  859. strlcpy(pi->login, p->szOldPassword, sizeof(pi->login));
  860. pi->account_id = p->dwID;
  862. char szQuery[QUERY_MAX_LEN];
  863. snprintf(szQuery, sizeof(szQuery), "SELECT password FROM safebox%s WHERE account_id=%u", GetTablePostfix(), p->dwID);
  865. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_CHANGE_PASSWORD, pkPeer->GetHandle(), pi);
  866. }
  868. void CClientManager::RESULT_SAFEBOX_CHANGE_PASSWORD(CPeer * pkPeer, SQLMsg * msg)
  869. {
  870. CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
  871. ClientHandleInfo * p = (ClientHandleInfo *) qi->pvData;
  872. DWORD dwHandle = p->dwHandle;
  874. if (msg->Get()->uiNumRows > 0)
  875. {
  876. MYSQL_ROW row = mysql_fetch_row(msg->Get()->pSQLResult);
  878. if (row[0] && *row[0] && !strcasecmp(row[0], p->login) || (!row[0] || !*row[0]) && !strcmp("000000", p->login))
  879. {
  880. char szQuery[QUERY_MAX_LEN];
  881. char escape_pwd[64];
  882. CDBManager::instance().EscapeString(escape_pwd, p->safebox_password, strlen(p->safebox_password));
  884. snprintf(szQuery, sizeof(szQuery), "UPDATE safebox%s SET password='%s' WHERE account_id=%u", GetTablePostfix(), escape_pwd, p->account_id);
  886. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_CHANGE_PASSWORD_SECOND, pkPeer->GetHandle(), p);
  887. return;
  888. }
  889. }
  891. delete p;
  893. // Wrong old password
  894. pkPeer->EncodeHeader(HEADER_DG_SAFEBOX_CHANGE_PASSWORD_ANSWER, dwHandle, sizeof(BYTE));
  895. pkPeer->EncodeBYTE(0);
  896. }
  898. void CClientManager::RESULT_SAFEBOX_CHANGE_PASSWORD_SECOND(CPeer * pkPeer, SQLMsg * msg)
  899. {
  900. CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
  901. ClientHandleInfo * p = (ClientHandleInfo *) qi->pvData;
  902. DWORD dwHandle = p->dwHandle;
  903. delete p;
  905. pkPeer->EncodeHeader(HEADER_DG_SAFEBOX_CHANGE_PASSWORD_ANSWER, dwHandle, sizeof(BYTE));
  906. pkPeer->EncodeBYTE(1);
  907. }
  909. // MYSHOP_PRICE_LIST
  910. void CClientManager::RESULT_PRICELIST_LOAD(CPeer* peer, SQLMsg* pMsg)
  911. {
  912. TItemPricelistReqInfo* pReqInfo = (TItemPricelistReqInfo*)static_cast<CQueryInfo*>(pMsg->pvUserData)->pvData;
  914. //
  915. // DB 에서 로드한 정보를 Cache 에 저장
  916. //
  918. TItemPriceListTable table;
  919. table.dwOwnerID = pReqInfo->second;
  920. table.byCount = 0;
  922. MYSQL_ROW row;
  924. while ((row = mysql_fetch_row(pMsg->Get()->pSQLResult)))
  925. {
  926. str_to_number(table.aPriceInfo[table.byCount].dwVnum, row[0]);
  927. str_to_number(table.aPriceInfo[table.byCount].dwPrice, row[1]);
  928. table.byCount++;
  929. }
  931. PutItemPriceListCache(&table);
  933. //
  934. // 로드한 데이터를 Game server 에 전송
  935. //
  937. TPacketMyshopPricelistHeader header;
  939. header.dwOwnerID = pReqInfo->second;
  940. header.byCount = table.byCount;
  942. size_t sizePriceListSize = sizeof(TItemPriceInfo) * header.byCount;
  944. peer->EncodeHeader(HEADER_DG_MYSHOP_PRICELIST_RES, pReqInfo->first, sizeof(header) + sizePriceListSize);
  945. peer->Encode(&header, sizeof(header));
  946. peer->Encode(table.aPriceInfo, sizePriceListSize);
  948. sys_log(0, "Load MyShopPricelist handle[%d] pid[%d] count[%d]", pReqInfo->first, pReqInfo->second, header.byCount);
  950. delete pReqInfo;
  951. }
  953. void CClientManager::RESULT_PRICELIST_LOAD_FOR_UPDATE(SQLMsg* pMsg)
  954. {
  955. TItemPriceListTable* pUpdateTable = (TItemPriceListTable*)static_cast<CQueryInfo*>(pMsg->pvUserData)->pvData;
  957. //
  958. // DB 에서 로드한 정보를 Cache 에 저장
  959. //
  961. TItemPriceListTable table;
  962. table.dwOwnerID = pUpdateTable->dwOwnerID;
  963. table.byCount = 0;
  965. MYSQL_ROW row;
  967. while ((row = mysql_fetch_row(pMsg->Get()->pSQLResult)))
  968. {
  969. str_to_number(table.aPriceInfo[table.byCount].dwVnum, row[0]);
  970. str_to_number(table.aPriceInfo[table.byCount].dwPrice, row[1]);
  971. table.byCount++;
  972. }
  974. PutItemPriceListCache(&table);
  976. // Update cache
  977. GetItemPriceListCache(pUpdateTable->dwOwnerID)->UpdateList(pUpdateTable);
  979. delete pUpdateTable;
  980. }
  981. // END_OF_MYSHOP_PRICE_LIST
  983. void CClientManager::QUERY_SAFEBOX_SAVE(CPeer * pkPeer, TSafeboxTable * pTable)
  984. {
  985. char szQuery[QUERY_MAX_LEN];
  987. snprintf(szQuery, sizeof(szQuery),
  988. "UPDATE safebox%s SET gold='%u' WHERE account_id=%u",
  989. GetTablePostfix(), pTable->dwGold, pTable->dwID);
  991. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_SAVE, pkPeer->GetHandle(), NULL);
  992. }
  994. void CClientManager::QUERY_EMPIRE_SELECT(CPeer * pkPeer, DWORD dwHandle, TEmpireSelectPacket * p)
  995. {
  996. char szQuery[QUERY_MAX_LEN];
  998. snprintf(szQuery, sizeof(szQuery), "UPDATE player_index%s SET empire=%u WHERE id=%u", GetTablePostfix(), p->bEmpire, p->dwAccountID);
  999. delete CDBManager::instance().DirectQuery(szQuery);
  1001. sys_log(0, "EmpireSelect: %s", szQuery);
  1002. {
  1003. snprintf(szQuery, sizeof(szQuery),
  1004. "SELECT pid1, pid2, pid3, pid4 FROM player_index%s WHERE id=%u", GetTablePostfix(), p->dwAccountID);
  1006. std::unique_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery));
  1008. SQLResult * pRes = pmsg->Get();
  1010. if (pRes->uiNumRows)
  1011. {
  1012. sys_log(0, "EMPIRE %lu", pRes->uiNumRows);
  1014. MYSQL_ROW row = mysql_fetch_row(pRes->pSQLResult);
  1015. DWORD pids[3];
  1017. UINT g_start_map[4] =
  1018. {
  1019. 0, // reserved
  1020. 1, // 신수국
  1021. 21, // 천조국
  1022. 41 // 진노국
  1023. };
  1025. // FIXME share with game
  1026. DWORD g_start_position[4][2]=
  1027. {
  1028. { 0, 0 },
  1029. { 469300, 964200 }, // 신수국
  1030. { 55700, 157900 }, // 천조국
  1031. { 969600, 278400 } // 진노국
  1032. };
  1034. for (int i = 0; i < 3; ++i)
  1035. {
  1036. str_to_number(pids[i], row[i]);
  1037. sys_log(0, "EMPIRE PIDS[%d]", pids[i]);
  1039. if (pids[i])
  1040. {
  1041. sys_log(0, "EMPIRE move to pid[%d] to villiage of %u, map_index %d",
  1042. pids[i], p->bEmpire, g_start_map[p->bEmpire]);
  1044. snprintf(szQuery, sizeof(szQuery), "UPDATE player%s SET map_index=%u,x=%u,y=%u WHERE id=%u",
  1045. GetTablePostfix(),
  1046. g_start_map[p->bEmpire],
  1047. g_start_position[p->bEmpire][0],
  1048. g_start_position[p->bEmpire][1],
  1049. pids[i]);
  1051. std::unique_ptr<SQLMsg> pmsg2(CDBManager::instance().DirectQuery(szQuery));
  1052. }
  1053. }
  1054. }
  1055. }
  1057. pkPeer->EncodeHeader(HEADER_DG_EMPIRE_SELECT, dwHandle, sizeof(BYTE));
  1058. pkPeer->EncodeBYTE(p->bEmpire);
  1059. }
  1061. void CClientManager::QUERY_SETUP(CPeer * peer, DWORD dwHandle, const char * c_pData)
  1062. {
  1063. TPacketGDSetup * p = (TPacketGDSetup *) c_pData;
  1064. c_pData += sizeof(TPacketGDSetup);
  1066. if (p->bAuthServer)
  1067. {
  1068. sys_log(0, "AUTH_PEER ptr %p", peer);
  1070. m_pkAuthPeer = peer;
  1071. SendAllLoginToBilling();
  1072. return;
  1073. }
  1075. peer->SetPublicIP(p->szPublicIP);
  1076. peer->SetChannel(p->bChannel);
  1077. peer->SetListenPort(p->wListenPort);
  1078. peer->SetP2PPort(p->wP2PPort);
  1079. peer->SetMaps(p->alMaps);
  1081. //
  1082. // 어떤 맵이 어떤 서버에 있는지 보내기
  1083. //
  1084. TMapLocation kMapLocations;
  1086. strlcpy(kMapLocations.szHost, peer->GetPublicIP(), sizeof(kMapLocations.szHost));
  1087. kMapLocations.wPort = peer->GetListenPort();
  1088. thecore_memcpy(kMapLocations.alMaps, peer->GetMaps(), sizeof(kMapLocations.alMaps));
  1090. BYTE bMapCount;
  1092. std::vector<TMapLocation> vec_kMapLocations;
  1094. if (peer->GetChannel() == 1)
  1095. {
  1096. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end(); ++i)
  1097. {
  1098. CPeer * tmp = *i;
  1100. if (tmp == peer)
  1101. continue;
  1103. if (!tmp->GetChannel())
  1104. continue;
  1106. if (tmp->GetChannel() == GUILD_WARP_WAR_CHANNEL || tmp->GetChannel() == peer->GetChannel())
  1107. {
  1108. TMapLocation kMapLocation2;
  1109. strlcpy(kMapLocation2.szHost, tmp->GetPublicIP(), sizeof(kMapLocation2.szHost));
  1110. kMapLocation2.wPort = tmp->GetListenPort();
  1111. thecore_memcpy(kMapLocation2.alMaps, tmp->GetMaps(), sizeof(kMapLocation2.alMaps));
  1112. vec_kMapLocations.push_back(kMapLocation2);
  1114. tmp->EncodeHeader(HEADER_DG_MAP_LOCATIONS, 0, sizeof(BYTE) + sizeof(TMapLocation));
  1115. bMapCount = 1;
  1116. tmp->EncodeBYTE(bMapCount);
  1117. tmp->Encode(&kMapLocations, sizeof(TMapLocation));
  1118. }
  1119. }
  1120. }
  1121. else if (peer->GetChannel() == GUILD_WARP_WAR_CHANNEL)
  1122. {
  1123. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end(); ++i)
  1124. {
  1125. CPeer * tmp = *i;
  1127. if (tmp == peer)
  1128. continue;
  1130. if (!tmp->GetChannel())
  1131. continue;
  1133. if (tmp->GetChannel() == 1 || tmp->GetChannel() == peer->GetChannel())
  1134. {
  1135. TMapLocation kMapLocation2;
  1136. strlcpy(kMapLocation2.szHost, tmp->GetPublicIP(), sizeof(kMapLocation2.szHost));
  1137. kMapLocation2.wPort = tmp->GetListenPort();
  1138. thecore_memcpy(kMapLocation2.alMaps, tmp->GetMaps(), sizeof(kMapLocation2.alMaps));
  1139. vec_kMapLocations.push_back(kMapLocation2);
  1140. }
  1142. tmp->EncodeHeader(HEADER_DG_MAP_LOCATIONS, 0, sizeof(BYTE) + sizeof(TMapLocation));
  1143. bMapCount = 1;
  1144. tmp->EncodeBYTE(bMapCount);
  1145. tmp->Encode(&kMapLocations, sizeof(TMapLocation));
  1146. }
  1147. }
  1148. else
  1149. {
  1150. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end(); ++i)
  1151. {
  1152. CPeer * tmp = *i;
  1154. if (tmp == peer)
  1155. continue;
  1157. if (!tmp->GetChannel())
  1158. continue;
  1160. if (tmp->GetChannel() == GUILD_WARP_WAR_CHANNEL || tmp->GetChannel() == peer->GetChannel())
  1161. {
  1162. TMapLocation kMapLocation2;
  1164. strlcpy(kMapLocation2.szHost, tmp->GetPublicIP(), sizeof(kMapLocation2.szHost));
  1165. kMapLocation2.wPort = tmp->GetListenPort();
  1166. thecore_memcpy(kMapLocation2.alMaps, tmp->GetMaps(), sizeof(kMapLocation2.alMaps));
  1168. vec_kMapLocations.push_back(kMapLocation2);
  1169. }
  1171. if (tmp->GetChannel() == peer->GetChannel())
  1172. {
  1173. tmp->EncodeHeader(HEADER_DG_MAP_LOCATIONS, 0, sizeof(BYTE) + sizeof(TMapLocation));
  1174. bMapCount = 1;
  1175. tmp->EncodeBYTE(bMapCount);
  1176. tmp->Encode(&kMapLocations, sizeof(TMapLocation));
  1177. }
  1178. }
  1179. }
  1181. vec_kMapLocations.push_back(kMapLocations);
  1183. peer->EncodeHeader(HEADER_DG_MAP_LOCATIONS, 0, sizeof(BYTE) + sizeof(TMapLocation) * vec_kMapLocations.size());
  1184. bMapCount = vec_kMapLocations.size();
  1185. peer->EncodeBYTE(bMapCount);
  1186. peer->Encode(&vec_kMapLocations[0], sizeof(TMapLocation) * vec_kMapLocations.size());
  1188. //
  1189. // 셋업 : 접속한 피어에 다른 피어들이 접속하게 만든다. (P2P 컨넥션 생성)
  1190. //
  1191. sys_log(0, "SETUP: channel %u listen %u p2p %u count %u", peer->GetChannel(), p->wListenPort, p->wP2PPort, bMapCount);
  1193. TPacketDGP2P p2pSetupPacket;
  1194. p2pSetupPacket.wPort = peer->GetP2PPort();
  1195. p2pSetupPacket.bChannel = peer->GetChannel();
  1196. strlcpy(p2pSetupPacket.szHost, peer->GetPublicIP(), sizeof(p2pSetupPacket.szHost));
  1198. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end();++i)
  1199. {
  1200. CPeer * tmp = *i;
  1202. if (tmp == peer)
  1203. continue;
  1205. // 채널이 0이라면 아직 SETUP 패킷이 오지 않은 피어 또는 auth라고 간주할 수 있음
  1206. if (0 == tmp->GetChannel())
  1207. continue;
  1209. tmp->EncodeHeader(HEADER_DG_P2P, 0, sizeof(TPacketDGP2P));
  1210. tmp->Encode(&p2pSetupPacket, sizeof(TPacketDGP2P));
  1211. }
  1213. //
  1214. // 로그인 및 빌링정보 보내기
  1215. //
  1216. TPacketLoginOnSetup * pck = (TPacketLoginOnSetup *) c_pData;;
  1217. std::vector<TPacketBillingRepair> vec_repair;
  1219. for (DWORD c = 0; c < p->dwLoginCount; ++c, ++pck)
  1220. {
  1221. CLoginData * pkLD = new CLoginData;
  1223. pkLD->SetKey(pck->dwLoginKey);
  1224. pkLD->SetClientKey(pck->adwClientKey);
  1225. pkLD->SetIP(pck->szHost);
  1227. TAccountTable & r = pkLD->GetAccountRef();
  1229. r.id = pck->dwID;
  1230. trim_and_lower(pck->szLogin, r.login, sizeof(r.login));
  1231. strlcpy(r.social_id, pck->szSocialID, sizeof(r.social_id));
  1232. strlcpy(r.passwd, "TEMP", sizeof(r.passwd));
  1234. InsertLoginData(pkLD);
  1236. if (InsertLogonAccount(pck->szLogin, peer->GetHandle(), pck->szHost))
  1237. {
  1238. sys_log(0, "SETUP: login %u %s login_key %u host %s", pck->dwID, pck->szLogin, pck->dwLoginKey, pck->szHost);
  1239. pkLD->SetPlay(true);
  1241. if (m_pkAuthPeer)
  1242. {
  1243. TPacketBillingRepair pck_repair;
  1244. pck_repair.dwLoginKey = pkLD->GetKey();
  1245. strlcpy(pck_repair.szLogin, pck->szLogin, sizeof(pck_repair.szLogin));
  1246. strlcpy(pck_repair.szHost, pck->szHost, sizeof(pck_repair.szHost));
  1247. vec_repair.push_back(pck_repair);
  1248. }
  1249. }
  1250. else
  1251. sys_log(0, "SETUP: login_fail %u %s login_key %u", pck->dwID, pck->szLogin, pck->dwLoginKey);
  1252. }
  1254. if (m_pkAuthPeer && !vec_repair.empty())
  1255. {
  1256. sys_log(0, "REPAIR size %d", vec_repair.size());
  1258. m_pkAuthPeer->EncodeHeader(HEADER_DG_BILLING_REPAIR, 0, sizeof(DWORD) + sizeof(TPacketBillingRepair) * vec_repair.size());
  1259. m_pkAuthPeer->EncodeDWORD(vec_repair.size());
  1260. m_pkAuthPeer->Encode(&vec_repair[0], sizeof(TPacketBillingRepair) * vec_repair.size());
  1261. }
  1263. SendPartyOnSetup(peer);
  1264. CGuildManager::instance().OnSetup(peer);
  1265. CPrivManager::instance().SendPrivOnSetup(peer);
  1266. SendEventFlagsOnSetup(peer);
  1267. marriage::CManager::instance().OnSetup(peer);
  1268. }
  1270. void CClientManager::QUERY_ITEM_FLUSH(CPeer * pkPeer, const char * c_pData)
  1271. {
  1272. DWORD dwID = *(DWORD *) c_pData;
  1274. if (g_log)
  1275. sys_log(0, "HEADER_GD_ITEM_FLUSH: %u", dwID);
  1277. CItemCache * c = GetItemCache(dwID);
  1279. if (c)
  1280. c->Flush();
  1281. }
  1283. void CClientManager::QUERY_ITEM_SAVE(CPeer * pkPeer, const char * c_pData)
  1284. {
  1285. TPlayerItem * p = (TPlayerItem *) c_pData;
  1287. // 창고면 캐쉬하지 않고, 캐쉬에 있던 것도 빼버려야 한다.
  1288. // auction은 이 루트를 타지 않아야 한다. EnrollInAuction을 타야한다.
  1290. if (p->window == SAFEBOX || p->window == MALL)
  1291. {
  1292. CItemCache * c = GetItemCache(p->id);
  1294. if (c)
  1295. {
  1296. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(c->Get()->owner);
  1298. if (it != m_map_pkItemCacheSetPtr.end())
  1299. {
  1300. if (g_test_server)
  1301. sys_log(0, "ITEM_CACHE: safebox owner %u id %u", c->Get()->owner, c->Get()->id);
  1303. it->second->erase(c);
  1304. }
  1306. m_map_itemCache.erase(p->id);
  1308. delete c;
  1309. }
  1310. char szQuery[512];
  1312. snprintf(szQuery, sizeof(szQuery),
  1313. "REPLACE INTO item%s (id, owner_id, window, pos, count, vnum, socket0, socket1, socket2, "
  1314. "attrtype0, attrvalue0, "
  1315. "attrtype1, attrvalue1, "
  1316. "attrtype2, attrvalue2, "
  1317. "attrtype3, attrvalue3, "
  1318. "attrtype4, attrvalue4, "
  1319. "attrtype5, attrvalue5, "
  1320. "attrtype6, attrvalue6) "
  1321. "VALUES(%u, %u, %d, %d, %u, %u, %ld, %ld, %ld, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)",
  1322. GetTablePostfix(),
  1323. p->id,
  1324. p->owner,
  1325. p->window,
  1326. p->pos,
  1327. p->count,
  1328. p->vnum,
  1329. p->alSockets[0],
  1330. p->alSockets[1],
  1331. p->alSockets[2],
  1332. p->aAttr[0].bType, p->aAttr[0].sValue,
  1333. p->aAttr[1].bType, p->aAttr[1].sValue,
  1334. p->aAttr[2].bType, p->aAttr[2].sValue,
  1335. p->aAttr[3].bType, p->aAttr[3].sValue,
  1336. p->aAttr[4].bType, p->aAttr[4].sValue,
  1337. p->aAttr[5].bType, p->aAttr[5].sValue,
  1338. p->aAttr[6].bType, p->aAttr[6].sValue);
  1340. CDBManager::instance().ReturnQuery(szQuery, QID_ITEM_SAVE, pkPeer->GetHandle(), NULL);
  1341. }
  1342. #ifdef __AUCTION__
  1343. else if (p->window == AUCTION)
  1344. {
  1345. sys_err("invalid window. how can you enter this route?");
  1346. return ;
  1347. }
  1348. #endif
  1349. else
  1350. {
  1351. if (g_test_server)
  1352. sys_log(0, "QUERY_ITEM_SAVE => PutItemCache() owner %d id %d vnum %d ", p->owner, p->id, p->vnum);
  1354. PutItemCache(p);
  1355. }
  1356. }
  1358. CClientManager::TItemCacheSet * CClientManager::GetItemCacheSet(DWORD pid)
  1359. {
  1360. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(pid);
  1362. if (it == m_map_pkItemCacheSetPtr.end())
  1363. return NULL;
  1365. return it->second;
  1366. }
  1368. void CClientManager::CreateItemCacheSet(DWORD pid)
  1369. {
  1370. if (m_map_pkItemCacheSetPtr.find(pid) != m_map_pkItemCacheSetPtr.end())
  1371. return;
  1373. TItemCacheSet * pSet = new TItemCacheSet;
  1374. m_map_pkItemCacheSetPtr.insert(TItemCacheSetPtrMap::value_type(pid, pSet));
  1376. if (g_log)
  1377. sys_log(0, "ITEM_CACHE: new cache %u", pid);
  1378. }
  1380. void CClientManager::FlushItemCacheSet(DWORD pid)
  1381. {
  1382. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(pid);
  1384. if (it == m_map_pkItemCacheSetPtr.end())
  1385. {
  1386. sys_log(0, "FLUSH_ITEMCACHESET : No ItemCacheSet pid(%d)", pid);
  1387. return;
  1388. }
  1390. TItemCacheSet * pSet = it->second;
  1391. TItemCacheSet::iterator it_set = pSet->begin();
  1393. while (it_set != pSet->end())
  1394. {
  1395. CItemCache * c = *it_set++;
  1396. c->Flush();
  1398. m_map_itemCache.erase(c->Get()->id);
  1399. delete c;
  1400. }
  1402. pSet->clear();
  1403. delete pSet;
  1405. m_map_pkItemCacheSetPtr.erase(it);
  1407. if (g_log)
  1408. sys_log(0, "FLUSH_ITEMCACHESET : Deleted pid(%d)", pid);
  1409. }
  1411. CItemCache * CClientManager::GetItemCache(DWORD id)
  1412. {
  1413. TItemCacheMap::iterator it = m_map_itemCache.find(id);
  1415. if (it == m_map_itemCache.end())
  1416. return NULL;
  1418. return it->second;
  1419. }
  1421. void CClientManager::PutItemCache(TPlayerItem * pNew, bool bSkipQuery)
  1422. {
  1423. CItemCache * c;
  1425. c = GetItemCache(pNew->id);
  1427. // 아이템 새로 생성
  1428. if (!c)
  1429. {
  1430. if (g_log)
  1431. sys_log(0, "ITEM_CACHE: PutItemCache ==> New CItemCache id%d vnum%d new owner%d", pNew->id, pNew->vnum, pNew->owner);
  1433. c = new CItemCache;
  1434. m_map_itemCache.insert(TItemCacheMap::value_type(pNew->id, c));
  1435. }
  1436. // 있을시
  1437. else
  1438. {
  1439. if (g_log)
  1440. sys_log(0, "ITEM_CACHE: PutItemCache ==> Have Cache");
  1441. // 소유자가 틀리면
  1442. if (pNew->owner != c->Get()->owner)
  1443. {
  1444. // 이미 이 아이템을 가지고 있었던 유저로 부터 아이템을 삭제한다.
  1445. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(c->Get()->owner);
  1447. if (it != m_map_pkItemCacheSetPtr.end())
  1448. {
  1449. if (g_log)
  1450. sys_log(0, "ITEM_CACHE: delete owner %u id %u new owner %u", c->Get()->owner, c->Get()->id, pNew->owner);
  1451. it->second->erase(c);
  1452. }
  1453. }
  1454. }
  1456. // 새로운 정보 업데이트
  1457. c->Put(pNew, bSkipQuery);
  1459. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(c->Get()->owner);
  1461. if (it != m_map_pkItemCacheSetPtr.end())
  1462. {
  1463. if (g_log)
  1464. sys_log(0, "ITEM_CACHE: save %u id %u", c->Get()->owner, c->Get()->id);
  1465. else
  1466. sys_log(1, "ITEM_CACHE: save %u id %u", c->Get()->owner, c->Get()->id);
  1467. it->second->insert(c);
  1468. }
  1469. else
  1470. {
  1471. // 현재 소유자가 없으므로 바로 저장해야 다음 접속이 올 때 SQL에 쿼리하여
  1472. // 받을 수 있으므로 바로 저장한다.
  1473. if (g_log)
  1474. sys_log(0, "ITEM_CACHE: direct save %u id %u", c->Get()->owner, c->Get()->id);
  1475. else
  1476. sys_log(1, "ITEM_CACHE: direct save %u id %u", c->Get()->owner, c->Get()->id);
  1478. c->OnFlush();
  1479. }
  1480. }
  1482. bool CClientManager::DeleteItemCache(DWORD dwID)
  1483. {
  1484. CItemCache * c = GetItemCache(dwID);
  1486. if (!c)
  1487. return false;
  1489. c->Delete();
  1490. return true;
  1491. }
  1493. // MYSHOP_PRICE_LIST
  1494. CItemPriceListTableCache* CClientManager::GetItemPriceListCache(DWORD dwID)
  1495. {
  1496. TItemPriceListCacheMap::iterator it = m_mapItemPriceListCache.find(dwID);
  1498. if (it == m_mapItemPriceListCache.end())
  1499. return NULL;
  1501. return it->second;
  1502. }
  1504. void CClientManager::PutItemPriceListCache(const TItemPriceListTable* pItemPriceList)
  1505. {
  1506. CItemPriceListTableCache* pCache = GetItemPriceListCache(pItemPriceList->dwOwnerID);
  1508. if (!pCache)
  1509. {
  1510. pCache = new CItemPriceListTableCache;
  1511. m_mapItemPriceListCache.insert(TItemPriceListCacheMap::value_type(pItemPriceList->dwOwnerID, pCache));
  1512. }
  1514. pCache->Put(const_cast<TItemPriceListTable*>(pItemPriceList), true);
  1515. }
  1517. void CClientManager::UpdatePlayerCache()
  1518. {
  1519. TPlayerTableCacheMap::iterator it = m_map_playerCache.begin();
  1521. while (it != m_map_playerCache.end())
  1522. {
  1523. CPlayerTableCache * c = (it++)->second;
  1525. if (c->CheckTimeout())
  1526. {
  1527. if (g_log)
  1528. sys_log(0, "UPDATE : UpdatePlayerCache() ==> FlushPlayerCache %d %s ", c->Get(false)->id, c->Get(false)->name);
  1530. c->Flush();
  1532. // Item Cache도 업데이트
  1533. UpdateItemCacheSet(c->Get()->id);
  1534. }
  1535. else if (c->CheckFlushTimeout())
  1536. c->Flush();
  1537. }
  1538. }
  1539. // END_OF_MYSHOP_PRICE_LIST
  1541. void CClientManager::SetCacheFlushCountLimit(int iLimit)
  1542. {
  1543. m_iCacheFlushCountLimit = MAX(10, iLimit);
  1544. sys_log(0, "CACHE_FLUSH_LIMIT_PER_SECOND: %d", m_iCacheFlushCountLimit);
  1545. }
  1547. void CClientManager::UpdateItemCache()
  1548. {
  1549. if (m_iCacheFlushCount >= m_iCacheFlushCountLimit)
  1550. return;
  1552. TItemCacheMap::iterator it = m_map_itemCache.begin();
  1554. while (it != m_map_itemCache.end())
  1555. {
  1556. CItemCache * c = (it++)->second;
  1558. // 아이템은 Flush만 한다.
  1559. if (c->CheckFlushTimeout())
  1560. {
  1561. if (g_test_server)
  1562. sys_log(0, "UpdateItemCache ==> Flush() vnum %d id owner %d", c->Get()->vnum, c->Get()->id, c->Get()->owner);
  1564. c->Flush();
  1566. if (++m_iCacheFlushCount >= m_iCacheFlushCountLimit)
  1567. break;
  1568. }
  1569. }
  1570. }
  1572. void CClientManager::UpdateItemPriceListCache()
  1573. {
  1574. TItemPriceListCacheMap::iterator it = m_mapItemPriceListCache.begin();
  1576. while (it != m_mapItemPriceListCache.end())
  1577. {
  1578. CItemPriceListTableCache* pCache = it->second;
  1580. if (pCache->CheckFlushTimeout())
  1581. {
  1582. pCache->Flush();
  1583. m_mapItemPriceListCache.erase(it++);
  1584. }
  1585. else
  1586. ++it;
  1587. }
  1588. }
  1590. void CClientManager::QUERY_ITEM_DESTROY(CPeer * pkPeer, const char * c_pData)
  1591. {
  1592. DWORD dwID = *(DWORD *) c_pData;
  1593. c_pData += sizeof(DWORD);
  1595. DWORD dwPID = *(DWORD *) c_pData;
  1597. if (!DeleteItemCache(dwID))
  1598. {
  1599. char szQuery[64];
  1600. snprintf(szQuery, sizeof(szQuery), "DELETE FROM item%s WHERE id=%u", GetTablePostfix(), dwID);
  1602. if (g_log)
  1603. sys_log(0, "HEADER_GD_ITEM_DESTROY: PID %u ID %u", dwPID, dwID);
  1605. if (dwPID == 0) // 아무도 가진 사람이 없었다면, 비동기 쿼리
  1606. CDBManager::instance().AsyncQuery(szQuery);
  1607. else
  1608. CDBManager::instance().ReturnQuery(szQuery, QID_ITEM_DESTROY, pkPeer->GetHandle(), NULL);
  1609. }
  1610. }
  1612. void CClientManager::QUERY_FLUSH_CACHE(CPeer * pkPeer, const char * c_pData)
  1613. {
  1614. DWORD dwPID = *(DWORD *) c_pData;
  1616. CPlayerTableCache * pkCache = GetPlayerCache(dwPID);
  1618. if (!pkCache)
  1619. return;
  1621. sys_log(0, "FLUSH_CACHE: %u", dwPID);
  1623. pkCache->Flush();
  1624. FlushItemCacheSet(dwPID);
  1626. m_map_playerCache.erase(dwPID);
  1627. delete pkCache;
  1628. }
  1630. void CClientManager::QUERY_SMS(CPeer * pkPeer, TPacketGDSMS * pack)
  1631. {
  1632. char szQuery[QUERY_MAX_LEN];
  1634. char szMsg[256+1];
  1635. //unsigned long len = CDBManager::instance().EscapeString(szMsg, pack->szMsg, strlen(pack->szMsg), SQL_ACCOUNT);
  1636. unsigned long len = CDBManager::instance().EscapeString(szMsg, pack->szMsg, strlen(pack->szMsg));
  1637. szMsg[len] = '\0';
  1639. snprintf(szQuery, sizeof(szQuery),
  1640. "INSERT INTO sms_pool (server, sender, receiver, mobile, msg) VALUES(%d, '%s', '%s', '%s', '%s')",
  1641. (m_iPlayerIDStart + 2) / 3, pack->szFrom, pack->szTo, pack->szMobile, szMsg);
  1643. CDBManager::instance().AsyncQuery(szQuery);
  1644. }
  1646. void CClientManager::QUERY_RELOAD_PROTO()
  1647. {
  1648. if (!InitializeTables())
  1649. {
  1650. sys_err("QUERY_RELOAD_PROTO: cannot load tables");
  1651. return;
  1652. }
  1654. for (TPeerList::iterator i = m_peerList.begin(); i != m_peerList.end(); ++i)
  1655. {
  1656. CPeer * tmp = *i;
  1658. if (!tmp->GetChannel())
  1659. continue;
  1661. tmp->EncodeHeader(HEADER_DG_RELOAD_PROTO, 0,
  1662. sizeof(WORD) + sizeof(TSkillTable) * m_vec_skillTable.size() +
  1663. sizeof(WORD) + sizeof(TBanwordTable) * m_vec_banwordTable.size() +
  1664. sizeof(WORD) + sizeof(TItemTable) * m_vec_itemTable.size() +
  1665. sizeof(WORD) + sizeof(TMobTable) * m_vec_mobTable.size());
  1667. tmp->EncodeWORD(m_vec_skillTable.size());
  1668. tmp->Encode(&m_vec_skillTable[0], sizeof(TSkillTable) * m_vec_skillTable.size());
  1670. tmp->EncodeWORD(m_vec_banwordTable.size());
  1671. tmp->Encode(&m_vec_banwordTable[0], sizeof(TBanwordTable) * m_vec_banwordTable.size());
  1673. tmp->EncodeWORD(m_vec_itemTable.size());
  1674. tmp->Encode(&m_vec_itemTable[0], sizeof(TItemTable) * m_vec_itemTable.size());
  1676. tmp->EncodeWORD(m_vec_mobTable.size());
  1677. tmp->Encode(&m_vec_mobTable[0], sizeof(TMobTable) * m_vec_mobTable.size());
  1678. }
  1679. }
  1681. // ADD_GUILD_PRIV_TIME
  1682. /**
  1683. * @version 05/06/08 Bang2ni - 지속시간 추가
  1684. */
  1685. void CClientManager::AddGuildPriv(TPacketGiveGuildPriv* p)
  1686. {
  1687. CPrivManager::instance().AddGuildPriv(p->guild_id, p->type, p->value, p->duration_sec);
  1688. }
  1690. void CClientManager::AddEmpirePriv(TPacketGiveEmpirePriv* p)
  1691. {
  1692. CPrivManager::instance().AddEmpirePriv(p->empire, p->type, p->value, p->duration_sec);
  1693. }
  1694. // END_OF_ADD_GUILD_PRIV_TIME
  1696. void CClientManager::AddCharacterPriv(TPacketGiveCharacterPriv* p)
  1697. {
  1698. CPrivManager::instance().AddCharPriv(p->pid, p->type, p->value);
  1699. }
  1701. void CClientManager::MoneyLog(TPacketMoneyLog* p)
  1702. {
  1703. CMoneyLog::instance().AddLog(p->type, p->vnum, p->gold);
  1704. }
  1706. CLoginData * CClientManager::GetLoginData(DWORD dwKey)
  1707. {
  1708. TLoginDataByLoginKey::iterator it = m_map_pkLoginData.find(dwKey);
  1710. if (it == m_map_pkLoginData.end())
  1711. return NULL;
  1713. return it->second;
  1714. }
  1716. CLoginData * CClientManager::GetLoginDataByLogin(const char * c_pszLogin)
  1717. {
  1718. char szLogin[LOGIN_MAX_LEN + 1];
  1719. trim_and_lower(c_pszLogin, szLogin, sizeof(szLogin));
  1721. TLoginDataByLogin::iterator it = m_map_pkLoginDataByLogin.find(szLogin);
  1723. if (it == m_map_pkLoginDataByLogin.end())
  1724. return NULL;
  1726. return it->second;
  1727. }
  1729. CLoginData * CClientManager::GetLoginDataByAID(DWORD dwAID)
  1730. {
  1731. TLoginDataByAID::iterator it = m_map_pkLoginDataByAID.find(dwAID);
  1733. if (it == m_map_pkLoginDataByAID.end())
  1734. return NULL;
  1736. return it->second;
  1737. }
  1739. void CClientManager::InsertLoginData(CLoginData * pkLD)
  1740. {
  1741. char szLogin[LOGIN_MAX_LEN + 1];
  1742. trim_and_lower(pkLD->GetAccountRef().login, szLogin, sizeof(szLogin));
  1744. m_map_pkLoginData.insert(std::make_pair(pkLD->GetKey(), pkLD));
  1745. m_map_pkLoginDataByLogin.insert(std::make_pair(szLogin, pkLD));
  1746. m_map_pkLoginDataByAID.insert(std::make_pair(pkLD->GetAccountRef().id, pkLD));
  1747. }
  1749. void CClientManager::DeleteLoginData(CLoginData * pkLD)
  1750. {
  1751. m_map_pkLoginData.erase(pkLD->GetKey());
  1752. m_map_pkLoginDataByLogin.erase(pkLD->GetAccountRef().login);
  1753. m_map_pkLoginDataByAID.erase(pkLD->GetAccountRef().id);
  1755. if (m_map_kLogonAccount.find(pkLD->GetAccountRef().login) == m_map_kLogonAccount.end())
  1756. delete pkLD;
  1757. else
  1758. pkLD->SetDeleted(true);
  1759. }
  1761. void CClientManager::QUERY_AUTH_LOGIN(CPeer * pkPeer, DWORD dwHandle, TPacketGDAuthLogin * p)
  1762. {
  1763. if (g_test_server)
  1764. sys_log(0, "QUERY_AUTH_LOGIN %d %d %s", p->dwID, p->dwLoginKey, p->szLogin);
  1765. CLoginData * pkLD = GetLoginDataByLogin(p->szLogin);
  1767. if (pkLD)
  1768. {
  1769. DeleteLoginData(pkLD);
  1770. }
  1772. BYTE bResult;
  1774. if (GetLoginData(p->dwLoginKey))
  1775. {
  1776. sys_err("LoginData already exist key %u login %s", p->dwLoginKey, p->szLogin);
  1777. bResult = 0;
  1779. pkPeer->EncodeHeader(HEADER_DG_AUTH_LOGIN, dwHandle, sizeof(BYTE));
  1780. pkPeer->EncodeBYTE(bResult);
  1781. }
  1782. else
  1783. {
  1784. CLoginData * pkLD = new CLoginData;
  1786. pkLD->SetKey(p->dwLoginKey);
  1787. pkLD->SetClientKey(p->adwClientKey);
  1788. pkLD->SetBillType(p->bBillType);
  1789. pkLD->SetBillID(p->dwBillID);
  1790. pkLD->SetPremium(p->iPremiumTimes);
  1792. TAccountTable & r = pkLD->GetAccountRef();
  1794. r.id = p->dwID;
  1795. trim_and_lower(p->szLogin, r.login, sizeof(r.login));
  1796. strlcpy(r.social_id, p->szSocialID, sizeof(r.social_id));
  1797. strlcpy(r.passwd, "TEMP", sizeof(r.passwd));
  1799. sys_log(0, "AUTH_LOGIN id(%u) login(%s) social_id(%s) login_key(%u), client_key(%u %u %u %u)",
  1800. p->dwID, p->szLogin, p->szSocialID, p->dwLoginKey,
  1801. p->adwClientKey[0], p->adwClientKey[1], p->adwClientKey[2], p->adwClientKey[3]);
  1803. bResult = 1;
  1805. InsertLoginData(pkLD);
  1807. pkPeer->EncodeHeader(HEADER_DG_AUTH_LOGIN, dwHandle, sizeof(BYTE));
  1808. pkPeer->EncodeBYTE(bResult);
  1809. }
  1810. }
  1812. void CClientManager::BillingExpire(TPacketBillingExpire * p)
  1813. {
  1814. char key[LOGIN_MAX_LEN + 1];
  1815. trim_and_lower(p->szLogin, key, sizeof(key));
  1817. switch (p->bBillType)
  1818. {
  1819. case BILLING_IP_TIME:
  1820. case BILLING_IP_DAY:
  1821. {
  1822. DWORD dwIPID = 0;
  1823. str_to_number(dwIPID, p->szLogin);
  1825. TLogonAccountMap::iterator it = m_map_kLogonAccount.begin();
  1827. while (it != m_map_kLogonAccount.end())
  1828. {
  1829. CLoginData * pkLD = (it++)->second;
  1831. if (pkLD->GetBillID() == dwIPID)
  1832. {
  1833. CPeer * pkPeer = GetPeer(pkLD->GetConnectedPeerHandle());
  1835. if (pkPeer)
  1836. {
  1837. strlcpy(p->szLogin, pkLD->GetAccountRef().login, sizeof(p->szLogin));
  1838. pkPeer->EncodeHeader(HEADER_DG_BILLING_EXPIRE, 0, sizeof(TPacketBillingExpire));
  1839. pkPeer->Encode(p, sizeof(TPacketBillingExpire));
  1840. }
  1841. }
  1842. }
  1843. }
  1844. break;
  1846. case BILLING_TIME:
  1847. case BILLING_DAY:
  1848. {
  1849. TLogonAccountMap::iterator it = m_map_kLogonAccount.find(key);
  1851. if (it != m_map_kLogonAccount.end())
  1852. {
  1853. CLoginData * pkLD = it->second;
  1855. CPeer * pkPeer = GetPeer(pkLD->GetConnectedPeerHandle());
  1857. if (pkPeer)
  1858. {
  1859. pkPeer->EncodeHeader(HEADER_DG_BILLING_EXPIRE, 0, sizeof(TPacketBillingExpire));
  1860. pkPeer->Encode(p, sizeof(TPacketBillingExpire));
  1861. }
  1862. }
  1863. }
  1864. break;
  1865. }
  1866. }
  1868. void CClientManager::BillingCheck(const char * data)
  1869. {
  1870. if (!m_pkAuthPeer)
  1871. return;
  1873. time_t curTime = GetCurrentTime();
  1875. DWORD dwCount = *(DWORD *) data;
  1876. data += sizeof(DWORD);
  1878. std::vector<DWORD> vec;
  1880. sys_log(0, "BillingCheck: size %u", dwCount);
  1882. for (DWORD i = 0; i < dwCount; ++i)
  1883. {
  1884. DWORD dwKey = *(DWORD *) data;
  1885. data += sizeof(DWORD);
  1887. sys_log(0, "BillingCheck: %u", dwKey);
  1889. TLoginDataByLoginKey::iterator it = m_map_pkLoginData.find(dwKey);
  1891. if (it == m_map_pkLoginData.end())
  1892. {
  1893. sys_log(0, "BillingCheck: key not exist: %u", dwKey);
  1894. vec.push_back(dwKey);
  1895. }
  1896. else
  1897. {
  1898. CLoginData * pkLD = it->second;
  1900. if (!pkLD->IsPlay() && curTime - pkLD->GetLastPlayTime() > 180)
  1901. {
  1902. sys_log(0, "BillingCheck: not login: %u", dwKey);
  1903. vec.push_back(dwKey);
  1904. }
  1905. }
  1906. }
  1908. m_pkAuthPeer->EncodeHeader(HEADER_DG_BILLING_CHECK, 0, sizeof(DWORD) + sizeof(DWORD) * vec.size());
  1909. m_pkAuthPeer->EncodeDWORD(vec.size());
  1911. if (!vec.empty())
  1912. m_pkAuthPeer->Encode(&vec[0], sizeof(DWORD) * vec.size());
  1913. }
  1915. void CClientManager::GuildDepositMoney(TPacketGDGuildMoney* p)
  1916. {
  1917. CGuildManager::instance().DepositMoney(p->dwGuild, p->iGold);
  1918. }
  1920. void CClientManager::GuildWithdrawMoney(CPeer* peer, TPacketGDGuildMoney* p)
  1921. {
  1922. CGuildManager::instance().WithdrawMoney(peer, p->dwGuild, p->iGold);
  1923. }
  1925. void CClientManager::GuildWithdrawMoneyGiveReply(TPacketGDGuildMoneyWithdrawGiveReply* p)
  1926. {
  1927. CGuildManager::instance().WithdrawMoneyReply(p->dwGuild, p->bGiveSuccess, p->iChangeGold);
  1928. }
  1930. void CClientManager::GuildWarBet(TPacketGDGuildWarBet * p)
  1931. {
  1932. CGuildManager::instance().Bet(p->dwWarID, p->szLogin, p->dwGold, p->dwGuild);
  1933. }
  1935. void CClientManager::SendAllLoginToBilling()
  1936. {
  1937. if (!m_pkAuthPeer)
  1938. return;
  1940. std::vector<TPacketBillingRepair> vec;
  1941. TPacketBillingRepair p;
  1943. TLogonAccountMap::iterator it = m_map_kLogonAccount.begin();
  1945. while (it != m_map_kLogonAccount.end())
  1946. {
  1947. CLoginData * pkLD = (it++)->second;
  1949. p.dwLoginKey = pkLD->GetKey();
  1950. strlcpy(p.szLogin, pkLD->GetAccountRef().login, sizeof(p.szLogin));
  1951. strlcpy(p.szHost, pkLD->GetIP(), sizeof(p.szHost));
  1952. sys_log(0, "SendAllLoginToBilling %s %s", pkLD->GetAccountRef().login, pkLD->GetIP());
  1953. vec.push_back(p);
  1954. }
  1956. if (!vec.empty())
  1957. {
  1958. m_pkAuthPeer->EncodeHeader(HEADER_DG_BILLING_REPAIR, 0, sizeof(DWORD) + sizeof(TPacketBillingRepair) * vec.size());
  1959. m_pkAuthPeer->EncodeDWORD(vec.size());
  1960. m_pkAuthPeer->Encode(&vec[0], sizeof(TPacketBillingRepair) * vec.size());
  1961. }
  1962. }
  1964. void CClientManager::SendLoginToBilling(CLoginData * pkLD, bool bLogin)
  1965. {
  1966. if (!m_pkAuthPeer)
  1967. return;
  1969. TPacketBillingLogin p;
  1971. p.dwLoginKey = pkLD->GetKey();
  1972. p.bLogin = bLogin ? 1 : 0;
  1974. DWORD dwCount = 1;
  1975. m_pkAuthPeer->EncodeHeader(HEADER_DG_BILLING_LOGIN, 0, sizeof(DWORD) + sizeof(TPacketBillingLogin));
  1976. m_pkAuthPeer->EncodeDWORD(dwCount);
  1977. m_pkAuthPeer->Encode(&p, sizeof(TPacketBillingLogin));
  1978. }
  1980. void CClientManager::CreateObject(TPacketGDCreateObject * p)
  1981. {
  1982. using namespace building;
  1984. char szQuery[512];
  1986. snprintf(szQuery, sizeof(szQuery),
  1987. "INSERT INTO object%s (land_id, vnum, map_index, x, y, x_rot, y_rot, z_rot) VALUES(%u, %u, %d, %d, %d, %f, %f, %f)",
  1988. GetTablePostfix(), p->dwLandID, p->dwVnum, p->lMapIndex, p->x, p->y, p->xRot, p->yRot, p->zRot);
  1990. std::unique_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery));
  1992. if (pmsg->Get()->uiInsertID == 0)
  1993. {
  1994. sys_err("cannot insert object");
  1995. return;
  1996. }
  1998. TObject * pkObj = new TObject;
  2000. memset(pkObj, 0, sizeof(TObject));
  2002. pkObj->dwID = pmsg->Get()->uiInsertID;
  2003. pkObj->dwVnum = p->dwVnum;
  2004. pkObj->dwLandID = p->dwLandID;
  2005. pkObj->lMapIndex = p->lMapIndex;
  2006. pkObj->x = p->x;
  2007. pkObj->y = p->y;
  2008. pkObj->xRot = p->xRot;
  2009. pkObj->yRot = p->yRot;
  2010. pkObj->zRot = p->zRot;
  2011. pkObj->lLife = 0;
  2013. ForwardPacket(HEADER_DG_CREATE_OBJECT, pkObj, sizeof(TObject));
  2015. m_map_pkObjectTable.insert(std::make_pair(pkObj->dwID, pkObj));
  2016. }
  2018. void CClientManager::DeleteObject(DWORD dwID)
  2019. {
  2020. char szQuery[128];
  2022. snprintf(szQuery, sizeof(szQuery), "DELETE FROM object%s WHERE id=%u", GetTablePostfix(), dwID);
  2024. std::unique_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery));
  2026. if (pmsg->Get()->uiAffectedRows == 0 || pmsg->Get()->uiAffectedRows == (uint32_t)-1)
  2027. {
  2028. sys_err("no object by id %u", dwID);
  2029. return;
  2030. }
  2032. itertype(m_map_pkObjectTable) it = m_map_pkObjectTable.find(dwID);
  2034. if (it != m_map_pkObjectTable.end())
  2035. {
  2036. delete it->second;
  2037. m_map_pkObjectTable.erase(it);
  2038. }
  2040. ForwardPacket(HEADER_DG_DELETE_OBJECT, &dwID, sizeof(DWORD));
  2041. }
  2043. void CClientManager::UpdateLand(DWORD * pdw)
  2044. {
  2045. DWORD dwID = pdw[0];
  2046. DWORD dwGuild = pdw[1];
  2048. building::TLand * p = &m_vec_kLandTable[0];
  2050. DWORD i;
  2052. for (i = 0; i < m_vec_kLandTable.size(); ++i, ++p)
  2053. {
  2054. if (p->dwID == dwID)
  2055. {
  2056. char buf[256];
  2057. snprintf(buf, sizeof(buf), "UPDATE land%s SET guild_id=%u WHERE id=%u", GetTablePostfix(), dwGuild, dwID);
  2058. CDBManager::instance().AsyncQuery(buf);
  2060. p->dwGuildID = dwGuild;
  2061. break;
  2062. }
  2063. }
  2065. if (i < m_vec_kLandTable.size())
  2066. ForwardPacket(HEADER_DG_UPDATE_LAND, p, sizeof(building::TLand));
  2067. }
  2069. void CClientManager::VCard(TPacketGDVCard * p)
  2070. {
  2071. sys_log(0, "VCARD: %u %s %s %s %s",
  2072. p->dwID, p->szSellCharacter, p->szSellAccount, p->szBuyCharacter, p->szBuyAccount);
  2074. m_queue_vcard.push(*p);
  2075. }
  2077. void CClientManager::VCardProcess()
  2078. {
  2079. if (!m_pkAuthPeer)
  2080. return;
  2082. while (!m_queue_vcard.empty())
  2083. {
  2084. m_pkAuthPeer->EncodeHeader(HEADER_DG_VCARD, 0, sizeof(TPacketGDVCard));
  2085. m_pkAuthPeer->Encode(&m_queue_vcard.front(), sizeof(TPacketGDVCard));
  2087. m_queue_vcard.pop();
  2088. }
  2089. }
  2091. // BLOCK_CHAT
  2092. void CClientManager::BlockChat(TPacketBlockChat* p)
  2093. {
  2094. char szQuery[256];
  2096. if (g_stLocale == "sjis")
  2097. snprintf(szQuery, sizeof(szQuery), "SELECT id FROM player%s WHERE name = '%s' collate sjis_japanese_ci", GetTablePostfix(), p->szName);
  2098. else
  2099. snprintf(szQuery, sizeof(szQuery), "SELECT id FROM player%s WHERE name = '%s'", GetTablePostfix(), p->szName);
  2100. std::unique_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery));
  2101. SQLResult * pRes = pmsg->Get();
  2103. if (pRes->uiNumRows)
  2104. {
  2105. MYSQL_ROW row = mysql_fetch_row(pRes->pSQLResult);
  2106. DWORD pid = strtoul(row[0], NULL, 10);
  2108. TPacketGDAddAffect pa;
  2109. pa.dwPID = pid;
  2110. pa.elem.dwType = 223;
  2111. pa.elem.bApplyOn = 0;
  2112. pa.elem.lApplyValue = 0;
  2113. pa.elem.dwFlag = 0;
  2114. pa.elem.lDuration = p->lDuration;
  2115. pa.elem.lSPCost = 0;
  2116. QUERY_ADD_AFFECT(NULL, &pa);
  2117. }
  2118. else
  2119. {
  2120. // cannot find user with that name
  2121. }
  2122. }
  2123. // END_OF_BLOCK_CHAT
  2125. void CClientManager::MarriageAdd(TPacketMarriageAdd * p)
  2126. {
  2127. sys_log(0, "MarriageAdd %u %u %s %s", p->dwPID1, p->dwPID2, p->szName1, p->szName2);
  2128. marriage::CManager::instance().Add(p->dwPID1, p->dwPID2, p->szName1, p->szName2);
  2129. }
  2131. void CClientManager::MarriageUpdate(TPacketMarriageUpdate * p)
  2132. {
  2133. sys_log(0, "MarriageUpdate PID:%u %u LP:%d ST:%d", p->dwPID1, p->dwPID2, p->iLovePoint, p->byMarried);
  2134. marriage::CManager::instance().Update(p->dwPID1, p->dwPID2, p->iLovePoint, p->byMarried);
  2135. }
  2137. void CClientManager::MarriageRemove(TPacketMarriageRemove * p)
  2138. {
  2139. sys_log(0, "MarriageRemove %u %u", p->dwPID1, p->dwPID2);
  2140. marriage::CManager::instance().Remove(p->dwPID1, p->dwPID2);
  2141. }
  2143. void CClientManager::WeddingRequest(TPacketWeddingRequest * p)
  2144. {
  2145. sys_log(0, "WeddingRequest %u %u", p->dwPID1, p->dwPID2);
  2146. ForwardPacket(HEADER_DG_WEDDING_REQUEST, p, sizeof(TPacketWeddingRequest));
  2147. //marriage::CManager::instance().RegisterWedding(p->dwPID1, p->szName1, p->dwPID2, p->szName2);
  2148. }
  2150. void CClientManager::WeddingReady(TPacketWeddingReady * p)
  2151. {
  2152. sys_log(0, "WeddingReady %u %u", p->dwPID1, p->dwPID2);
  2153. ForwardPacket(HEADER_DG_WEDDING_READY, p, sizeof(TPacketWeddingReady));
  2154. marriage::CManager::instance().ReadyWedding(p->dwMapIndex, p->dwPID1, p->dwPID2);
  2155. }
  2157. void CClientManager::WeddingEnd(TPacketWeddingEnd * p)
  2158. {
  2159. sys_log(0, "WeddingEnd %u %u", p->dwPID1, p->dwPID2);
  2160. marriage::CManager::instance().EndWedding(p->dwPID1, p->dwPID2);
  2161. }
  2163. //
  2164. // 캐시에 가격정보가 있으면 캐시를 업데이트 하고 캐시에 가격정보가 없다면
  2165. // 우선 기존의 데이터를 로드한 뒤에 기존의 정보로 캐시를 만들고 새로 받은 가격정보를 업데이트 한다.
  2166. //
  2167. void CClientManager::MyshopPricelistUpdate(const TPacketMyshopPricelistHeader* pPacket)
  2168. {
  2169. if (pPacket->byCount > SHOP_PRICELIST_MAX_NUM)
  2170. {
  2171. sys_err("count overflow!");
  2172. return;
  2173. }
  2175. CItemPriceListTableCache* pCache = GetItemPriceListCache(pPacket->dwOwnerID);
  2177. if (pCache)
  2178. {
  2179. TItemPriceListTable table;
  2181. table.dwOwnerID = pPacket->dwOwnerID;
  2182. table.byCount = pPacket->byCount;
  2184. const TItemPriceInfo * pInfo = reinterpret_cast<const TItemPriceInfo*>(pPacket + sizeof(TPacketMyshopPricelistHeader));
  2185. thecore_memcpy(table.aPriceInfo, pInfo, sizeof(TItemPriceInfo) * pPacket->byCount);
  2187. pCache->UpdateList(&table);
  2188. }
  2189. else
  2190. {
  2191. TItemPriceListTable* pUpdateTable = new TItemPriceListTable;
  2193. pUpdateTable->dwOwnerID = pPacket->dwOwnerID;
  2194. pUpdateTable->byCount = pPacket->byCount;
  2196. const TItemPriceInfo * pInfo = reinterpret_cast<const TItemPriceInfo*>(pPacket + sizeof(TPacketMyshopPricelistHeader));
  2197. thecore_memcpy(pUpdateTable->aPriceInfo, pInfo, sizeof(TItemPriceInfo) * pPacket->byCount);
  2199. char szQuery[QUERY_MAX_LEN];
  2200. snprintf(szQuery, sizeof(szQuery), "SELECT item_vnum, price FROM myshop_pricelist%s WHERE owner_id=%u", GetTablePostfix(), pPacket->dwOwnerID);
  2201. CDBManager::instance().ReturnQuery(szQuery, QID_ITEMPRICE_LOAD_FOR_UPDATE, 0, pUpdateTable);
  2202. }
  2203. }
  2205. // MYSHOP_PRICE_LIST
  2206. // 캐시된 가격정보가 있으면 캐시를 읽어 바로 전송하고 캐시에 정보가 없으면 DB 에 쿼리를 한다.
  2207. //
  2208. void CClientManager::MyshopPricelistRequest(CPeer* peer, DWORD dwHandle, DWORD dwPlayerID)
  2209. {
  2210. if (CItemPriceListTableCache* pCache = GetItemPriceListCache(dwPlayerID))
  2211. {
  2212. sys_log(0, "Cache MyShopPricelist handle[%d] pid[%d]", dwHandle, dwPlayerID);
  2214. TItemPriceListTable* pTable = pCache->Get(false);
  2216. TPacketMyshopPricelistHeader header =
  2217. {
  2218. pTable->dwOwnerID,
  2219. pTable->byCount
  2220. };
  2222. size_t sizePriceListSize = sizeof(TItemPriceInfo) * pTable->byCount;
  2224. peer->EncodeHeader(HEADER_DG_MYSHOP_PRICELIST_RES, dwHandle, sizeof(header) + sizePriceListSize);
  2225. peer->Encode(&header, sizeof(header));
  2226. peer->Encode(pTable->aPriceInfo, sizePriceListSize);
  2228. }
  2229. else
  2230. {
  2231. sys_log(0, "Query MyShopPricelist handle[%d] pid[%d]", dwHandle, dwPlayerID);
  2233. char szQuery[QUERY_MAX_LEN];
  2234. snprintf(szQuery, sizeof(szQuery), "SELECT item_vnum, price FROM myshop_pricelist%s WHERE owner_id=%u", GetTablePostfix(), dwPlayerID);
  2235. CDBManager::instance().ReturnQuery(szQuery, QID_ITEMPRICE_LOAD, peer->GetHandle(), new TItemPricelistReqInfo(dwHandle, dwPlayerID));
  2236. }
  2237. }
  2238. // END_OF_MYSHOP_PRICE_LIST
  2240. void CPacketInfo::Add(int header)
  2241. {
  2242. itertype(m_map_info) it = m_map_info.find(header);
  2244. if (it == m_map_info.end())
  2245. m_map_info.insert(std::map<int, int>::value_type(header, 1));
  2246. else
  2247. ++it->second;
  2248. }
  2250. void CPacketInfo::Reset()
  2251. {
  2252. m_map_info.clear();
  2253. }
  2255. void CClientManager::ProcessPackets(CPeer * peer)
  2256. {
  2257. BYTE header;
  2258. DWORD dwHandle;
  2259. DWORD dwLength;
  2260. const char * data = NULL;
  2261. int i = 0;
  2262. int iCount = 0;
  2264. while (peer->PeekPacket(i, header, dwHandle, dwLength, &data))
  2265. {
  2266. // DISABLE_DB_HEADER_LOG
  2267. // sys_log(0, "header %d %p size %d", header, this, dwLength);
  2268. // END_OF_DISABLE_DB_HEADER_LOG
  2269. m_bLastHeader = header;
  2270. ++iCount;
  2272. #ifdef _TEST
  2273. if (header != 10)
  2274. sys_log(0, " ProcessPacket Header [%d] Handle[%d] Length[%d] iCount[%d]", header, dwHandle, dwLength, iCount);
  2275. #endif
  2276. if (g_test_server)
  2277. {
  2278. if (header != 10)
  2279. sys_log(0, " ProcessPacket Header [%d] Handle[%d] Length[%d] iCount[%d]", header, dwHandle, dwLength, iCount);
  2280. }
  2283. // test log by mhh
  2284. {
  2285. if (HEADER_GD_BLOCK_COUNTRY_IP == header)
  2286. sys_log(0, "recved : HEADER_GD_BLOCK_COUNTRY_IP");
  2287. }
  2289. switch (header)
  2290. {
  2291. case HEADER_GD_BOOT:
  2292. QUERY_BOOT(peer, (TPacketGDBoot *) data);
  2293. break;
  2295. case HEADER_GD_HAMMER_OF_TOR:
  2296. break;
  2298. case HEADER_GD_LOGIN_BY_KEY:
  2299. QUERY_LOGIN_BY_KEY(peer, dwHandle, (TPacketGDLoginByKey *) data);
  2300. break;
  2302. case HEADER_GD_LOGOUT:
  2303. //sys_log(0, "HEADER_GD_LOGOUT (handle: %d length: %d)", dwHandle, dwLength);
  2304. QUERY_LOGOUT(peer, dwHandle, data);
  2305. break;
  2307. case HEADER_GD_PLAYER_LOAD:
  2308. sys_log(1, "HEADER_GD_PLAYER_LOAD (handle: %d length: %d)", dwHandle, dwLength);
  2309. QUERY_PLAYER_LOAD(peer, dwHandle, (TPlayerLoadPacket *) data);
  2310. break;
  2312. case HEADER_GD_PLAYER_SAVE:
  2313. sys_log(1, "HEADER_GD_PLAYER_SAVE (handle: %d length: %d)", dwHandle, dwLength);
  2314. QUERY_PLAYER_SAVE(peer, dwHandle, (TPlayerTable *) data);
  2315. break;
  2317. case HEADER_GD_PLAYER_CREATE:
  2318. sys_log(0, "HEADER_GD_PLAYER_CREATE (handle: %d length: %d)", dwHandle, dwLength);
  2319. __QUERY_PLAYER_CREATE(peer, dwHandle, (TPlayerCreatePacket *) data);
  2320. sys_log(0, "END");
  2321. break;
  2323. case HEADER_GD_PLAYER_DELETE:
  2324. sys_log(1, "HEADER_GD_PLAYER_DELETE (handle: %d length: %d)", dwHandle, dwLength);
  2325. __QUERY_PLAYER_DELETE(peer, dwHandle, (TPlayerDeletePacket *) data);
  2326. break;
  2328. case HEADER_GD_PLAYER_COUNT:
  2329. QUERY_PLAYER_COUNT(peer, (TPlayerCountPacket *) data);
  2330. break;
  2332. case HEADER_GD_QUEST_SAVE:
  2333. sys_log(1, "HEADER_GD_QUEST_SAVE (handle: %d length: %d)", dwHandle, dwLength);
  2334. QUERY_QUEST_SAVE(peer, (TQuestTable *) data, dwLength);
  2335. break;
  2337. case HEADER_GD_SAFEBOX_LOAD:
  2338. QUERY_SAFEBOX_LOAD(peer, dwHandle, (TSafeboxLoadPacket *) data, 0);
  2339. break;
  2341. case HEADER_GD_SAFEBOX_SAVE:
  2342. sys_log(1, "HEADER_GD_SAFEBOX_SAVE (handle: %d length: %d)", dwHandle, dwLength);
  2343. QUERY_SAFEBOX_SAVE(peer, (TSafeboxTable *) data);
  2344. break;
  2346. case HEADER_GD_SAFEBOX_CHANGE_SIZE:
  2347. QUERY_SAFEBOX_CHANGE_SIZE(peer, dwHandle, (TSafeboxChangeSizePacket *) data);
  2348. break;
  2350. case HEADER_GD_SAFEBOX_CHANGE_PASSWORD:
  2351. QUERY_SAFEBOX_CHANGE_PASSWORD(peer, dwHandle, (TSafeboxChangePasswordPacket *) data);
  2352. break;
  2354. case HEADER_GD_MALL_LOAD:
  2355. QUERY_SAFEBOX_LOAD(peer, dwHandle, (TSafeboxLoadPacket *) data, 1);
  2356. break;
  2358. case HEADER_GD_EMPIRE_SELECT:
  2359. QUERY_EMPIRE_SELECT(peer, dwHandle, (TEmpireSelectPacket *) data);
  2360. break;
  2362. case HEADER_GD_SETUP:
  2363. QUERY_SETUP(peer, dwHandle, data);
  2364. break;
  2366. case HEADER_GD_GUILD_CREATE:
  2367. GuildCreate(peer, *(DWORD *) data);
  2368. break;
  2370. case HEADER_GD_GUILD_SKILL_UPDATE:
  2371. GuildSkillUpdate(peer, (TPacketGuildSkillUpdate *) data);
  2372. break;
  2374. case HEADER_GD_GUILD_EXP_UPDATE:
  2375. GuildExpUpdate(peer, (TPacketGuildExpUpdate *) data);
  2376. break;
  2378. case HEADER_GD_GUILD_ADD_MEMBER:
  2379. GuildAddMember(peer, (TPacketGDGuildAddMember*) data);
  2380. break;
  2382. case HEADER_GD_GUILD_REMOVE_MEMBER:
  2383. GuildRemoveMember(peer, (TPacketGuild*) data);
  2384. break;
  2386. case HEADER_GD_GUILD_CHANGE_GRADE:
  2387. GuildChangeGrade(peer, (TPacketGuild*) data);
  2388. break;
  2390. case HEADER_GD_GUILD_CHANGE_MEMBER_DATA:
  2391. GuildChangeMemberData(peer, (TPacketGuildChangeMemberData*) data);
  2392. break;
  2394. case HEADER_GD_GUILD_DISBAND:
  2395. GuildDisband(peer, (TPacketGuild*) data);
  2396. break;
  2398. case HEADER_GD_GUILD_WAR:
  2399. GuildWar(peer, (TPacketGuildWar*) data);
  2400. break;
  2402. case HEADER_GD_GUILD_WAR_SCORE:
  2403. GuildWarScore(peer, (TPacketGuildWarScore*) data);
  2404. break;
  2406. case HEADER_GD_GUILD_CHANGE_LADDER_POINT:
  2407. GuildChangeLadderPoint((TPacketGuildLadderPoint*) data);
  2408. break;
  2410. case HEADER_GD_GUILD_USE_SKILL:
  2411. GuildUseSkill((TPacketGuildUseSkill*) data);
  2412. break;
  2414. case HEADER_GD_FLUSH_CACHE:
  2415. QUERY_FLUSH_CACHE(peer, data);
  2416. break;
  2418. case HEADER_GD_ITEM_SAVE:
  2419. QUERY_ITEM_SAVE(peer, data);
  2420. break;
  2422. case HEADER_GD_ITEM_DESTROY:
  2423. QUERY_ITEM_DESTROY(peer, data);
  2424. break;
  2426. case HEADER_GD_ITEM_FLUSH:
  2427. QUERY_ITEM_FLUSH(peer, data);
  2428. break;
  2430. case HEADER_GD_ADD_AFFECT:
  2431. sys_log(1, "HEADER_GD_ADD_AFFECT");
  2432. QUERY_ADD_AFFECT(peer, (TPacketGDAddAffect *) data);
  2433. break;
  2435. case HEADER_GD_REMOVE_AFFECT:
  2436. sys_log(1, "HEADER_GD_REMOVE_AFFECT");
  2437. QUERY_REMOVE_AFFECT(peer, (TPacketGDRemoveAffect *) data);
  2438. break;
  2440. case HEADER_GD_HIGHSCORE_REGISTER:
  2441. QUERY_HIGHSCORE_REGISTER(peer, (TPacketGDHighscore *) data);
  2442. break;
  2444. case HEADER_GD_PARTY_CREATE:
  2445. QUERY_PARTY_CREATE(peer, (TPacketPartyCreate*) data);
  2446. break;
  2448. case HEADER_GD_PARTY_DELETE:
  2449. QUERY_PARTY_DELETE(peer, (TPacketPartyDelete*) data);
  2450. break;
  2452. case HEADER_GD_PARTY_ADD:
  2453. QUERY_PARTY_ADD(peer, (TPacketPartyAdd*) data);
  2454. break;
  2456. case HEADER_GD_PARTY_REMOVE:
  2457. QUERY_PARTY_REMOVE(peer, (TPacketPartyRemove*) data);
  2458. break;
  2460. case HEADER_GD_PARTY_STATE_CHANGE:
  2461. QUERY_PARTY_STATE_CHANGE(peer, (TPacketPartyStateChange*) data);
  2462. break;
  2464. case HEADER_GD_PARTY_SET_MEMBER_LEVEL:
  2465. QUERY_PARTY_SET_MEMBER_LEVEL(peer, (TPacketPartySetMemberLevel*) data);
  2466. break;
  2468. case HEADER_GD_RELOAD_PROTO:
  2469. QUERY_RELOAD_PROTO();
  2470. break;
  2472. case HEADER_GD_CHANGE_NAME:
  2473. QUERY_CHANGE_NAME(peer, dwHandle, (TPacketGDChangeName *) data);
  2474. break;
  2476. case HEADER_GD_SMS:
  2477. QUERY_SMS(peer, (TPacketGDSMS *) data);
  2478. break;
  2480. case HEADER_GD_AUTH_LOGIN:
  2481. QUERY_AUTH_LOGIN(peer, dwHandle, (TPacketGDAuthLogin *) data);
  2482. break;
  2484. case HEADER_GD_REQUEST_GUILD_PRIV:
  2485. AddGuildPriv((TPacketGiveGuildPriv*)data);
  2486. break;
  2488. case HEADER_GD_REQUEST_EMPIRE_PRIV:
  2489. AddEmpirePriv((TPacketGiveEmpirePriv*)data);
  2490. break;
  2492. case HEADER_GD_REQUEST_CHARACTER_PRIV:
  2493. AddCharacterPriv((TPacketGiveCharacterPriv*) data);
  2494. break;
  2496. case HEADER_GD_MONEY_LOG:
  2497. MoneyLog((TPacketMoneyLog*)data);
  2498. break;
  2500. case HEADER_GD_GUILD_DEPOSIT_MONEY:
  2501. GuildDepositMoney((TPacketGDGuildMoney*)data);
  2502. break;
  2504. case HEADER_GD_GUILD_WITHDRAW_MONEY:
  2505. GuildWithdrawMoney(peer, (TPacketGDGuildMoney*)data);
  2506. break;
  2508. case HEADER_GD_GUILD_WITHDRAW_MONEY_GIVE_REPLY:
  2509. GuildWithdrawMoneyGiveReply((TPacketGDGuildMoneyWithdrawGiveReply*)data);
  2510. break;
  2512. case HEADER_GD_GUILD_WAR_BET:
  2513. GuildWarBet((TPacketGDGuildWarBet *) data);
  2514. break;
  2516. case HEADER_GD_SET_EVENT_FLAG:
  2517. SetEventFlag((TPacketSetEventFlag*) data);
  2518. break;
  2520. case HEADER_GD_BILLING_EXPIRE:
  2521. BillingExpire((TPacketBillingExpire *) data);
  2522. break;
  2524. case HEADER_GD_BILLING_CHECK:
  2525. BillingCheck(data);
  2526. break;
  2528. case HEADER_GD_CREATE_OBJECT:
  2529. CreateObject((TPacketGDCreateObject *) data);
  2530. break;
  2532. case HEADER_GD_DELETE_OBJECT:
  2533. DeleteObject(*(DWORD *) data);
  2534. break;
  2536. case HEADER_GD_UPDATE_LAND:
  2537. UpdateLand((DWORD *) data);
  2538. break;
  2540. case HEADER_GD_VCARD:
  2541. VCard((TPacketGDVCard *) data);
  2542. break;
  2544. case HEADER_GD_MARRIAGE_ADD:
  2545. MarriageAdd((TPacketMarriageAdd *) data);
  2546. break;
  2548. case HEADER_GD_MARRIAGE_UPDATE:
  2549. MarriageUpdate((TPacketMarriageUpdate *) data);
  2550. break;
  2552. case HEADER_GD_MARRIAGE_REMOVE:
  2553. MarriageRemove((TPacketMarriageRemove *) data);
  2554. break;
  2556. case HEADER_GD_WEDDING_REQUEST:
  2557. WeddingRequest((TPacketWeddingRequest *) data);
  2558. break;
  2560. case HEADER_GD_WEDDING_READY:
  2561. WeddingReady((TPacketWeddingReady *) data);
  2562. break;
  2564. case HEADER_GD_WEDDING_END:
  2565. WeddingEnd((TPacketWeddingEnd *) data);
  2566. break;
  2568. // BLOCK_CHAT
  2569. case HEADER_GD_BLOCK_CHAT:
  2570. BlockChat((TPacketBlockChat *) data);
  2571. break;
  2572. // END_OF_BLOCK_CHAT
  2574. // MYSHOP_PRICE_LIST
  2575. case HEADER_GD_MYSHOP_PRICELIST_UPDATE:
  2576. MyshopPricelistUpdate((TPacketMyshopPricelistHeader*)data);
  2577. break;
  2579. case HEADER_GD_MYSHOP_PRICELIST_REQ:
  2580. MyshopPricelistRequest(peer, dwHandle, *(DWORD*)data);
  2581. break;
  2582. // END_OF_MYSHOP_PRICE_LIST
  2584. //RELOAD_ADMIN
  2585. case HEADER_GD_RELOAD_ADMIN:
  2586. ReloadAdmin(peer, (TPacketReloadAdmin*)data);
  2587. break;
  2588. //END_RELOAD_ADMIN
  2590. case HEADER_GD_BREAK_MARRIAGE:
  2591. BreakMarriage(peer, data);
  2592. break;
  2594. //MOANRCH
  2595. case HEADER_GD_ELECT_MONARCH:
  2596. Election(peer, dwHandle, data);
  2597. break;
  2599. case HEADER_GD_CANDIDACY:
  2600. Candidacy(peer, dwHandle, data);
  2601. break;
  2603. case HEADER_GD_ADD_MONARCH_MONEY:
  2604. AddMonarchMoney(peer, dwHandle, data);
  2605. break;
  2607. case HEADER_GD_DEC_MONARCH_MONEY:
  2608. DecMonarchMoney(peer, dwHandle, data);
  2609. break;
  2611. case HEADER_GD_TAKE_MONARCH_MONEY:
  2612. TakeMonarchMoney(peer, dwHandle, data);
  2613. break;
  2615. case HEADER_GD_COME_TO_VOTE:
  2616. ComeToVote(peer, dwHandle, data);
  2617. break;
  2619. case HEADER_GD_RMCANDIDACY: //< 후보 제거 (운영자)
  2620. RMCandidacy(peer, dwHandle, data);
  2621. break;
  2623. case HEADER_GD_SETMONARCH: ///<군주설정 (운영자)
  2624. SetMonarch(peer, dwHandle, data);
  2625. break;
  2627. case HEADER_GD_RMMONARCH: ///<군주삭제
  2628. RMMonarch(peer, dwHandle, data);
  2629. break;
  2630. //END_MONARCH
  2632. case HEADER_GD_CHANGE_MONARCH_LORD :
  2633. ChangeMonarchLord(peer, dwHandle, (TPacketChangeMonarchLord*)data);
  2634. break;
  2636. case HEADER_GD_BLOCK_COUNTRY_IP:
  2637. sys_log(0, "HEADER_GD_BLOCK_COUNTRY_IP received");
  2638. CBlockCountry::instance().SendBlockedCountryIp(peer);
  2639. CBlockCountry::instance().SendBlockException(peer);
  2640. break;
  2642. case HEADER_GD_BLOCK_EXCEPTION:
  2643. sys_log(0, "HEADER_GD_BLOCK_EXCEPTION received");
  2644. BlockException((TPacketBlockException*) data);
  2645. break;
  2647. case HEADER_GD_REQ_SPARE_ITEM_ID_RANGE :
  2648. SendSpareItemIDRange(peer);
  2649. break;
  2651. case HEADER_GD_REQ_CHANGE_GUILD_MASTER :
  2652. GuildChangeMaster((TPacketChangeGuildMaster*) data);
  2653. break;
  2655. case HEADER_GD_UPDATE_HORSE_NAME :
  2656. UpdateHorseName((TPacketUpdateHorseName*) data, peer);
  2657. break;
  2659. case HEADER_GD_REQ_HORSE_NAME :
  2660. AckHorseName(*(DWORD*)data, peer);
  2661. break;
  2663. case HEADER_GD_DC:
  2664. DeleteLoginKey((TPacketDC*) data);
  2665. break;
  2667. case HEADER_GD_VALID_LOGOUT:
  2668. ResetLastPlayerID((TPacketNeedLoginLogInfo*)data);
  2669. break;
  2671. #ifdef __SWITCH_CHANNEL_SYSTEM__
  2672. case HEADER_GD_FIND_CHANNEL:
  2673. FindChannel(peer, dwHandle, (TPacketChangeChannel*)data);
  2674. break;
  2675. #endif
  2677. case HEADER_GD_REQUEST_CHARGE_CASH:
  2678. ChargeCash((TRequestChargeCash*)data);
  2679. break;
  2681. //delete gift notify icon
  2683. case HEADER_GD_DELETE_AWARDID:
  2684. DeleteAwardId((TPacketDeleteAwardID*) data);
  2685. break;
  2687. case HEADER_GD_UPDATE_CHANNELSTATUS:
  2688. UpdateChannelStatus((SChannelStatus*) data);
  2689. break;
  2690. case HEADER_GD_REQUEST_CHANNELSTATUS:
  2691. RequestChannelStatus(peer, dwHandle);
  2692. break;
  2693. #ifdef __AUCTION__
  2694. case HEADER_GD_COMMAND_AUCTION:
  2695. {
  2696. TPacketGDCommnadAuction* auction_data = (TPacketGDCommnadAuction*)data;
  2698. switch (auction_data->get_cmd())
  2699. {
  2700. case AUCTION_ENR_AUC:
  2701. EnrollInAuction (peer, dwHandle, (AuctionEnrollProductInfo*)data);
  2702. break;
  2703. case AUCTION_ENR_SALE:
  2704. EnrollInSale (peer, dwHandle, (AuctionEnrollSaleInfo*)data);
  2705. break;
  2706. case AUCTION_ENR_WISH:
  2707. EnrollInWish (peer, dwHandle, (AuctionEnrollWishInfo*)data);
  2708. break;
  2709. case AUCTION_BID:
  2710. AuctionBid (peer, dwHandle, (AuctionBidInfo*)data);
  2711. break;
  2712. case AUCTION_IMME_PUR:
  2713. AuctionImpur (peer, dwHandle, (AuctionImpurInfo*)data);
  2714. break;
  2715. case AUCTION_GET_AUC:
  2716. AuctionGetAuctionedItem (peer, dwHandle, auction_data->get_item());
  2717. break;
  2718. case AUCTION_BUY_SOLD:
  2719. AuctionBuySoldItem (peer, dwHandle, auction_data->get_item());
  2720. break;
  2721. case AUCTION_CANCEL_AUC:
  2722. AuctionCancelAuction (peer, dwHandle, auction_data->get_item());
  2723. break;
  2724. case AUCTION_CANCEL_WISH:
  2725. AuctionCancelWish (peer, dwHandle, auction_data->get_item());
  2726. break;
  2727. case AUCTION_CANCEL_SALE:
  2728. AuctionCancelSale (peer, dwHandle, auction_data->get_item());
  2729. break;
  2730. case AUCTION_DELETE_AUCTION_ITEM:
  2731. AuctionDeleteAuctionItem (peer, dwHandle, auction_data->get_item());
  2732. break;
  2733. case AUCTION_DELETE_SALE_ITEM:
  2734. AuctionDeleteSaleItem (peer, dwHandle, auction_data->get_item());
  2735. break;
  2736. case AUCTION_REBID:
  2737. AuctionReBid (peer, dwHandle, (AuctionBidInfo*)data);
  2738. break;
  2739. // case AUCTION_BID_CANCEL:
  2740. // AuctionBidCancel (peer, dwHandle, data->get_item());
  2741. default :
  2742. break;
  2743. }
  2744. }
  2745. break;
  2746. #endif
  2747. default:
  2748. sys_err("Unknown header (header: %d handle: %d length: %d)", header, dwHandle, dwLength);
  2749. break;
  2750. }
  2751. }
  2753. peer->RecvEnd(i);
  2754. }
  2756. void CClientManager::AddPeer(socket_t fd)
  2757. {
  2758. CPeer * pPeer = new CPeer;
  2760. if (pPeer->Accept(fd))
  2761. m_peerList.push_front(pPeer);
  2762. else
  2763. delete pPeer;
  2764. }
  2766. void CClientManager::RemovePeer(CPeer * pPeer)
  2767. {
  2768. if (m_pkAuthPeer == pPeer)
  2769. {
  2770. m_pkAuthPeer = NULL;
  2771. }
  2772. else
  2773. {
  2774. TLogonAccountMap::iterator it = m_map_kLogonAccount.begin();
  2776. while (it != m_map_kLogonAccount.end())
  2777. {
  2778. CLoginData * pkLD = it->second;
  2780. if (pkLD->GetConnectedPeerHandle() == pPeer->GetHandle())
  2781. {
  2782. if (pkLD->IsPlay())
  2783. {
  2784. pkLD->SetPlay(false);
  2785. SendLoginToBilling(pkLD, false);
  2786. }
  2788. if (pkLD->IsDeleted())
  2789. {
  2790. sys_log(0, "DELETING LoginData");
  2791. delete pkLD;
  2792. }
  2794. m_map_kLogonAccount.erase(it++);
  2795. }
  2796. else
  2797. ++it;
  2798. }
  2799. }
  2801. m_peerList.remove(pPeer);
  2802. delete pPeer;
  2803. }
  2805. CPeer * CClientManager::GetPeer(IDENT ident)
  2806. {
  2807. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end();++i)
  2808. {
  2809. CPeer * tmp = *i;
  2811. if (tmp->GetHandle() == ident)
  2812. return tmp;
  2813. }
  2815. return NULL;
  2816. }
  2818. CPeer * CClientManager::GetAnyPeer()
  2819. {
  2820. if (m_peerList.empty())
  2821. return NULL;
  2823. return m_peerList.front();
  2824. }
  2826. // DB 매니저로 부터 받은 결과를 처리한다.
  2827. //
  2828. // @version 05/06/10 Bang2ni - 가격정보 관련 쿼리(QID_ITEMPRICE_XXX) 추가
  2829. int CClientManager::AnalyzeQueryResult(SQLMsg * msg)
  2830. {
  2831. CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
  2832. CPeer * peer = GetPeer(qi->dwIdent);
  2834. #ifdef _TEST
  2835. if (qi->iType != QID_ITEM_AWARD_LOAD)
  2836. sys_log(0, "AnalyzeQueryResult %d", qi->iType);
  2837. #endif
  2838. switch (qi->iType)
  2839. {
  2840. case QID_ITEM_AWARD_LOAD:
  2841. ItemAwardManager::instance().Load(msg);
  2842. delete qi;
  2843. return true;
  2845. case QID_GUILD_RANKING:
  2846. CGuildManager::instance().ResultRanking(msg->Get()->pSQLResult);
  2847. break;
  2849. // MYSHOP_PRICE_LIST
  2850. case QID_ITEMPRICE_LOAD_FOR_UPDATE:
  2851. RESULT_PRICELIST_LOAD_FOR_UPDATE(msg);
  2852. break;
  2853. // END_OF_MYSHOP_PRICE_LIST
  2854. }
  2856. if (!peer)
  2857. {
  2858. //sys_err("CClientManager::AnalyzeQueryResult: peer not exist anymore. (ident: %d)", qi->dwIdent);
  2859. delete qi;
  2860. return true;
  2861. }
  2863. switch (qi->iType)
  2864. {
  2865. case QID_PLAYER:
  2866. case QID_ITEM:
  2867. case QID_QUEST:
  2868. case QID_AFFECT:
  2869. RESULT_COMPOSITE_PLAYER(peer, msg, qi->iType);
  2870. break;
  2872. case QID_LOGIN:
  2873. RESULT_LOGIN(peer, msg);
  2874. break;
  2876. case QID_SAFEBOX_LOAD:
  2877. sys_log(0, "QUERY_RESULT: HEADER_GD_SAFEBOX_LOAD");
  2878. RESULT_SAFEBOX_LOAD(peer, msg);
  2879. break;
  2881. case QID_SAFEBOX_CHANGE_SIZE:
  2882. sys_log(0, "QUERY_RESULT: HEADER_GD_SAFEBOX_CHANGE_SIZE");
  2883. RESULT_SAFEBOX_CHANGE_SIZE(peer, msg);
  2884. break;
  2886. case QID_SAFEBOX_CHANGE_PASSWORD:
  2887. sys_log(0, "QUERY_RESULT: HEADER_GD_SAFEBOX_CHANGE_PASSWORD %p", msg);
  2888. RESULT_SAFEBOX_CHANGE_PASSWORD(peer, msg);
  2889. break;
  2891. case QID_SAFEBOX_CHANGE_PASSWORD_SECOND:
  2892. sys_log(0, "QUERY_RESULT: HEADER_GD_SAFEBOX_CHANGE_PASSWORD %p", msg);
  2893. RESULT_SAFEBOX_CHANGE_PASSWORD_SECOND(peer, msg);
  2894. break;
  2896. case QID_HIGHSCORE_REGISTER:
  2897. sys_log(0, "QUERY_RESULT: HEADER_GD_HIGHSCORE_REGISTER %p", msg);
  2898. RESULT_HIGHSCORE_REGISTER(peer, msg);
  2899. break;
  2901. case QID_SAFEBOX_SAVE:
  2902. case QID_ITEM_SAVE:
  2903. case QID_ITEM_DESTROY:
  2904. case QID_QUEST_SAVE:
  2905. case QID_PLAYER_SAVE:
  2906. case QID_ITEM_AWARD_TAKEN:
  2907. break;
  2909. // PLAYER_INDEX_CREATE_BUG_FIX
  2910. case QID_PLAYER_INDEX_CREATE:
  2911. RESULT_PLAYER_INDEX_CREATE(peer, msg);
  2912. break;
  2913. // END_PLAYER_INDEX_CREATE_BUG_FIX
  2915. case QID_PLAYER_DELETE:
  2916. __RESULT_PLAYER_DELETE(peer, msg);
  2917. break;
  2919. case QID_LOGIN_BY_KEY:
  2920. RESULT_LOGIN_BY_KEY(peer, msg);
  2921. break;
  2923. // MYSHOP_PRICE_LIST
  2924. case QID_ITEMPRICE_LOAD:
  2925. RESULT_PRICELIST_LOAD(peer, msg);
  2926. break;
  2927. // END_OF_MYSHOP_PRICE_LIST
  2929. default:
  2930. sys_log(0, "CClientManager::AnalyzeQueryResult unknown query result type: %d, str: %s", qi->iType, msg->stQuery.c_str());
  2931. break;
  2932. }
  2934. delete qi;
  2935. return true;
  2936. }
  2938. void UsageLog()
  2939. {
  2940. FILE* fp = NULL;
  2942. time_t ct;
  2943. char *time_s;
  2944. struct tm lt;
  2946. int avg = g_dwUsageAvg / 3600; // 60 초 * 60 분
  2948. fp = fopen("usage.txt", "a+");
  2950. if (!fp)
  2951. return;
  2953. ct = time(0);
  2954. lt = *localtime(&ct);
  2955. time_s = asctime(&lt);
  2957. time_s[strlen(time_s) - 1] = '\0';
  2959. fprintf(fp, "| %4d %-15.15s | %5d | %5u |", lt.tm_year + 1900, time_s + 4, avg, g_dwUsageMax);
  2961. fprintf(fp, "\n");
  2962. fclose(fp);
  2964. g_dwUsageMax = g_dwUsageAvg = 0;
  2965. }
  2967. int CClientManager::Process()
  2968. {
  2969. int pulses;
  2971. if (!(pulses = thecore_idle()))
  2972. return 0;
  2974. while (pulses--)
  2975. {
  2976. ++thecore_heart->pulse;
  2978. /*
  2979. //30분마다 변경
  2980. if (((thecore_pulse() % (60 * 30 * 10)) == 0))
  2981. {
  2982. g_iPlayerCacheFlushSeconds = MAX(60, rand() % 180);
  2983. g_iItemCacheFlushSeconds = MAX(60, rand() % 180);
  2984. sys_log(0, "[SAVE_TIME]Change saving time item %d player %d", g_iPlayerCacheFlushSeconds, g_iItemCacheFlushSeconds);
  2985. }
  2986. */
  2988. if (!(thecore_heart->pulse % thecore_heart->passes_per_sec))
  2989. {
  2990. if (g_test_server)
  2991. {
  2993. if (!(thecore_heart->pulse % thecore_heart->passes_per_sec * 10))
  2995. {
  2996. pt_log("[%9d] return %d/%d/%d/%d async %d/%d/%d/%d",
  2997. thecore_heart->pulse,
  2998. CDBManager::instance().CountReturnQuery(SQL_PLAYER),
  2999. CDBManager::instance().CountReturnResult(SQL_PLAYER),
  3000. CDBManager::instance().CountReturnQueryFinished(SQL_PLAYER),
  3001. CDBManager::instance().CountReturnCopiedQuery(SQL_PLAYER),
  3002. CDBManager::instance().CountAsyncQuery(SQL_PLAYER),
  3003. CDBManager::instance().CountAsyncResult(SQL_PLAYER),
  3004. CDBManager::instance().CountAsyncQueryFinished(SQL_PLAYER),
  3005. CDBManager::instance().CountAsyncCopiedQuery(SQL_PLAYER));
  3007. if ((thecore_heart->pulse % 50) == 0)
  3008. sys_log(0, "[%9d] return %d/%d/%d async %d/%d/%d",
  3009. thecore_heart->pulse,
  3010. CDBManager::instance().CountReturnQuery(SQL_PLAYER),
  3011. CDBManager::instance().CountReturnResult(SQL_PLAYER),
  3012. CDBManager::instance().CountReturnQueryFinished(SQL_PLAYER),
  3013. CDBManager::instance().CountAsyncQuery(SQL_PLAYER),
  3014. CDBManager::instance().CountAsyncResult(SQL_PLAYER),
  3015. CDBManager::instance().CountAsyncQueryFinished(SQL_PLAYER));
  3016. }
  3017. }
  3018. else
  3019. {
  3020. pt_log("[%9d] return %d/%d/%d/%d async %d/%d/%d%/%d",
  3021. thecore_heart->pulse,
  3022. CDBManager::instance().CountReturnQuery(SQL_PLAYER),
  3023. CDBManager::instance().CountReturnResult(SQL_PLAYER),
  3024. CDBManager::instance().CountReturnQueryFinished(SQL_PLAYER),
  3025. CDBManager::instance().CountReturnCopiedQuery(SQL_PLAYER),
  3026. CDBManager::instance().CountAsyncQuery(SQL_PLAYER),
  3027. CDBManager::instance().CountAsyncResult(SQL_PLAYER),
  3028. CDBManager::instance().CountAsyncQueryFinished(SQL_PLAYER),
  3029. CDBManager::instance().CountAsyncCopiedQuery(SQL_PLAYER));
  3031. if ((thecore_heart->pulse % 50) == 0)
  3032. sys_log(0, "[%9d] return %d/%d/%d async %d/%d/%d",
  3033. thecore_heart->pulse,
  3034. CDBManager::instance().CountReturnQuery(SQL_PLAYER),
  3035. CDBManager::instance().CountReturnResult(SQL_PLAYER),
  3036. CDBManager::instance().CountReturnQueryFinished(SQL_PLAYER),
  3037. CDBManager::instance().CountAsyncQuery(SQL_PLAYER),
  3038. CDBManager::instance().CountAsyncResult(SQL_PLAYER),
  3039. CDBManager::instance().CountAsyncQueryFinished(SQL_PLAYER));
  3040. }
  3042. CDBManager::instance().ResetCounter();
  3044. DWORD dwCount = CClientManager::instance().GetUserCount();
  3046. g_dwUsageAvg += dwCount;
  3047. g_dwUsageMax = MAX(g_dwUsageMax, dwCount);
  3049. memset(&thecore_profiler[0], 0, sizeof(thecore_profiler));
  3051. if (!(thecore_heart->pulse % (thecore_heart->passes_per_sec * 3600)))
  3052. UsageLog();
  3054. m_iCacheFlushCount = 0;
  3057. //플레이어 플러쉬
  3058. UpdatePlayerCache();
  3059. //아이템 플러쉬
  3060. UpdateItemCache();
  3061. //로그아웃시 처리- 캐쉬셋 플러쉬
  3062. UpdateLogoutPlayer();
  3064. // MYSHOP_PRICE_LIST
  3065. UpdateItemPriceListCache();
  3066. // END_OF_MYSHOP_PRICE_LIST
  3068. CGuildManager::instance().Update();
  3069. CPrivManager::instance().Update();
  3070. marriage::CManager::instance().Update();
  3071. }
  3073. if (!(thecore_heart->pulse % (thecore_heart->passes_per_sec * 5)))
  3074. {
  3075. ItemAwardManager::instance().RequestLoad();
  3076. }
  3078. if (!(thecore_heart->pulse % (thecore_heart->passes_per_sec * 10)))
  3079. {
  3080. /*
  3081. char buf[4096 + 1];
  3082. int len
  3083. itertype(g_query_info.m_map_info) it;
  3085. /////////////////////////////////////////////////////////////////
  3086. buf[0] = '\0';
  3087. len = 0;
  3089. it = g_query_info.m_map_info.begin();
  3091. int count = 0;
  3093. while (it != g_query_info.m_map_info.end())
  3094. {
  3095. len += snprintf(buf + len, sizeof(buf) - len, "%2d %3d\n", it->first, it->second);
  3096. count += it->second;
  3097. it++;
  3098. }
  3100. pt_log("QUERY:\n%s-------------------- MAX : %d\n", buf, count);
  3101. g_query_info.Reset();
  3102. */
  3103. pt_log("QUERY: MAIN[%d] ASYNC[%d]", g_query_count[0], g_query_count[1]);
  3104. g_query_count[0] = 0;
  3105. g_query_count[1] = 0;
  3106. /////////////////////////////////////////////////////////////////
  3108. /////////////////////////////////////////////////////////////////
  3109. /*
  3110. buf[0] = '\0';
  3111. len = 0;
  3113. it = g_item_info.m_map_info.begin();
  3115. count = 0;
  3116. while (it != g_item_info.m_map_info.end())
  3117. {
  3118. len += snprintf(buf + len, sizeof(buf) - len, "%5d %3d\n", it->first, it->second);
  3119. count += it->second;
  3120. it++;
  3121. }
  3123. pt_log("ITEM:\n%s-------------------- MAX : %d\n", buf, count);
  3124. g_item_info.Reset();
  3125. */
  3126. pt_log("ITEM:%d\n", g_item_count);
  3127. g_item_count = 0;
  3128. /////////////////////////////////////////////////////////////////
  3129. }
  3131. if (!(thecore_heart->pulse % (thecore_heart->passes_per_sec * 60))) // 60초에 한번
  3132. {
  3133. // 유니크 아이템을 위한 시간을 보낸다.
  3134. CClientManager::instance().SendTime();
  3135. }
  3137. if (!(thecore_heart->pulse % (thecore_heart->passes_per_sec * 3600))) // 한시간에 한번
  3138. {
  3139. CMoneyLog::instance().Save();
  3140. }
  3141. }
  3143. int num_events = fdwatch(m_fdWatcher, 0);
  3144. int idx;
  3145. CPeer * peer;
  3147. for (idx = 0; idx < num_events; ++idx) // 인풋
  3148. {
  3149. peer = (CPeer *) fdwatch_get_client_data(m_fdWatcher, idx);
  3151. if (!peer)
  3152. {
  3153. if (fdwatch_check_event(m_fdWatcher, m_fdAccept, idx) == FDW_READ)
  3154. {
  3155. AddPeer(m_fdAccept);
  3156. fdwatch_clear_event(m_fdWatcher, m_fdAccept, idx);
  3157. }
  3158. else
  3159. {
  3160. sys_err("FDWATCH: peer null in event: ident %d", fdwatch_get_ident(m_fdWatcher, idx));
  3161. }
  3163. continue;
  3164. }
  3166. switch (fdwatch_check_event(m_fdWatcher, peer->GetFd(), idx))
  3167. {
  3168. case FDW_READ:
  3169. if (peer->Recv() < 0)
  3170. {
  3171. sys_err("Recv failed");
  3172. RemovePeer(peer);
  3173. }
  3174. else
  3175. {
  3176. if (peer == m_pkAuthPeer)
  3177. if (g_log)
  3178. sys_log(0, "AUTH_PEER_READ: size %d", peer->GetRecvLength());
  3180. ProcessPackets(peer);
  3181. }
  3182. break;
  3184. case FDW_WRITE:
  3185. if (peer == m_pkAuthPeer)
  3186. if (g_log)
  3187. sys_log(0, "AUTH_PEER_WRITE: size %d", peer->GetSendLength());
  3189. if (peer->Send() < 0)
  3190. {
  3191. sys_err("Send failed");
  3192. RemovePeer(peer);
  3193. }
  3195. break;
  3197. case FDW_EOF:
  3198. RemovePeer(peer);
  3199. break;
  3201. default:
  3202. sys_err("fdwatch_check_fd returned unknown result");
  3203. RemovePeer(peer);
  3204. break;
  3205. }
  3206. }
  3208. #ifdef __WIN32__
  3209. if (_kbhit()) {
  3210. int c = _getch();
  3211. switch (c) {
  3212. case 0x1b: // Esc
  3213. return 0; // shutdown
  3214. break;
  3215. default:
  3216. break;
  3217. }
  3218. }
  3219. #endif
  3221. VCardProcess();
  3222. return 1;
  3223. }
  3225. DWORD CClientManager::GetUserCount()
  3226. {
  3227. // 단순히 로그인 카운트를 센다.. --;
  3228. return m_map_kLogonAccount.size();
  3229. }
  3231. void CClientManager::SendAllGuildSkillRechargePacket()
  3232. {
  3233. ForwardPacket(HEADER_DG_GUILD_SKILL_RECHARGE, NULL, 0);
  3234. }
  3236. void CClientManager::SendTime()
  3237. {
  3238. time_t now = GetCurrentTime();
  3239. ForwardPacket(HEADER_DG_TIME, &now, sizeof(time_t));
  3240. }
  3242. void CClientManager::ForwardPacket(BYTE header, const void* data, int size, BYTE bChannel, CPeer* except)
  3243. {
  3244. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
  3245. {
  3246. CPeer * peer = *it;
  3248. if (peer == except)
  3249. continue;
  3251. if (!peer->GetChannel())
  3252. continue;
  3254. if (bChannel && peer->GetChannel() != bChannel)
  3255. continue;
  3257. peer->EncodeHeader(header, 0, size);
  3259. if (size > 0 && data)
  3260. peer->Encode(data, size);
  3261. }
  3262. }
  3264. void CClientManager::SendNotice(const char * c_pszFormat, ...)
  3265. {
  3266. char szBuf[255+1];
  3267. va_list args;
  3269. va_start(args, c_pszFormat);
  3270. int len = vsnprintf(szBuf, sizeof(szBuf), c_pszFormat, args);
  3271. va_end(args);
  3272. szBuf[len] = '\0';
  3274. ForwardPacket(HEADER_DG_NOTICE, szBuf, len + 1);
  3275. }
  3277. time_t CClientManager::GetCurrentTime()
  3278. {
  3279. return time(0);
  3280. }
  3282. // ITEM_UNIQUE_ID
  3283. bool CClientManager::InitializeNowItemID()
  3284. {
  3285. DWORD dwMin, dwMax;
  3287. //아이템 ID를 초기화 한다.
  3288. if (!CConfig::instance().GetTwoValue("ITEM_ID_RANGE", &dwMin, &dwMax))
  3289. {
  3290. sys_err("conf.txt: Cannot find ITEM_ID_RANGE [start_item_id] [end_item_id]");
  3291. return false;
  3292. }
  3294. sys_log(0, "ItemRange From File %u ~ %u ", dwMin, dwMax);
  3296. if (CItemIDRangeManager::instance().BuildRange(dwMin, dwMax, m_itemRange) == false)
  3297. {
  3298. sys_err("Can not build ITEM_ID_RANGE");
  3299. return false;
  3300. }
  3302. sys_log(0, " Init Success Start %u End %u Now %u\n", m_itemRange.dwMin, m_itemRange.dwMax, m_itemRange.dwUsableItemIDMin);
  3304. return true;
  3305. }
  3307. DWORD CClientManager::GainItemID()
  3308. {
  3309. return m_itemRange.dwUsableItemIDMin++;
  3310. }
  3312. DWORD CClientManager::GetItemID()
  3313. {
  3314. return m_itemRange.dwUsableItemIDMin;
  3315. }
  3316. // ITEM_UNIQUE_ID_END
  3317. //BOOT_LOCALIZATION
  3319. bool CClientManager::InitializeLocalization()
  3320. {
  3321. char szQuery[512];
  3322. snprintf(szQuery, sizeof(szQuery), "SELECT mValue, mKey FROM locale");
  3323. SQLMsg * pMsg = CDBManager::instance().DirectQuery(szQuery, SQL_COMMON);
  3325. if (pMsg->Get()->uiNumRows == 0)
  3326. {
  3327. sys_err("InitializeLocalization() ==> DirectQuery failed(%s)", szQuery);
  3328. delete pMsg;
  3329. return false;
  3330. }
  3332. sys_log(0, "InitializeLocalization() - LoadLocaleTable(count:%d)", pMsg->Get()->uiNumRows);
  3334. m_vec_Locale.clear();
  3336. MYSQL_ROW row = NULL;
  3338. for (int n = 0; (row = mysql_fetch_row(pMsg->Get()->pSQLResult)) != NULL; ++n)
  3339. {
  3340. int col = 0;
  3341. tLocale locale;
  3343. strlcpy(locale.szValue, row[col++], sizeof(locale.szValue));
  3344. strlcpy(locale.szKey, row[col++], sizeof(locale.szKey));
  3346. //DB_NAME_COLUMN Setting
  3347. if (strcmp(locale.szKey, "LOCALE") == 0)
  3348. {
  3349. if (strcmp(locale.szValue, "cibn") == 0)
  3350. {
  3351. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3353. if (g_stLocale != locale.szValue)
  3354. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "gb2312");
  3356. g_stLocale = "gb2312";
  3357. g_stLocaleNameColumn = "gb2312name";
  3358. }
  3359. else if (strcmp(locale.szValue, "ymir") == 0)
  3360. {
  3361. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3363. if (g_stLocale != locale.szValue)
  3364. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3366. g_stLocale = "euckr";
  3367. g_stLocaleNameColumn = "name";
  3368. }
  3369. else if (strcmp(locale.szValue, "japan") == 0)
  3370. {
  3371. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3373. if (g_stLocale != locale.szValue)
  3374. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "sjis");
  3376. g_stLocale = "sjis";
  3377. g_stLocaleNameColumn = "locale_name";
  3378. }
  3379. else if (strcmp(locale.szValue, "english") == 0)
  3380. {
  3381. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3383. if (g_stLocale != locale.szValue)
  3384. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3386. g_stLocale = "";
  3387. g_stLocaleNameColumn = "locale_name";
  3388. }
  3389. else if (strcmp(locale.szValue, "germany") == 0)
  3390. {
  3391. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3393. if (g_stLocale != locale.szValue)
  3394. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3396. g_stLocale = "latin1";
  3397. g_stLocaleNameColumn = "locale_name";
  3398. }
  3399. else if (strcmp(locale.szValue, "france") == 0)
  3400. {
  3401. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3403. if (g_stLocale != locale.szValue)
  3404. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3406. g_stLocale = "latin1";
  3407. g_stLocaleNameColumn = "locale_name";
  3408. }
  3409. else if (strcmp(locale.szValue, "italy") == 0)
  3410. {
  3411. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3413. if (g_stLocale != locale.szValue)
  3414. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3416. g_stLocale = "latin1";
  3417. g_stLocaleNameColumn = "locale_name";
  3418. }
  3419. else if (strcmp(locale.szValue, "spain") == 0)
  3420. {
  3421. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3423. if (g_stLocale != locale.szValue)
  3424. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3426. g_stLocale = "latin1";
  3427. g_stLocaleNameColumn = "locale_name";
  3428. }
  3429. else if (strcmp(locale.szValue, "uk") == 0)
  3430. {
  3431. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3433. if (g_stLocale != locale.szValue)
  3434. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3436. g_stLocale = "latin1";
  3437. g_stLocaleNameColumn = "locale_name";
  3438. }
  3439. else if (strcmp(locale.szValue, "turkey") == 0)
  3440. {
  3441. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3443. if (g_stLocale != locale.szValue)
  3444. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3446. g_stLocale = "latin5";
  3447. g_stLocaleNameColumn = "locale_name";
  3448. }
  3449. else if (strcmp(locale.szValue, "poland") == 0)
  3450. {
  3451. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3453. if (g_stLocale != locale.szValue)
  3454. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3456. g_stLocale = "latin2";
  3457. g_stLocaleNameColumn = "locale_name";
  3458. }
  3459. else if (strcmp(locale.szValue, "portugal") == 0)
  3460. {
  3461. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3463. if (g_stLocale != locale.szValue)
  3464. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3466. g_stLocale = "latin1";
  3467. g_stLocaleNameColumn = "locale_name";
  3468. }
  3469. else if (strcmp(locale.szValue, "hongkong") == 0)
  3470. {
  3471. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3473. if (g_stLocale != locale.szValue)
  3474. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "big5");
  3476. g_stLocale = "big5";
  3477. g_stLocaleNameColumn = "locale_name";
  3478. }
  3479. else if (strcmp(locale.szValue, "newcibn") == 0)
  3480. {
  3481. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3483. if (g_stLocale != locale.szValue)
  3484. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "gb2312");
  3486. g_stLocale = "gb2312";
  3487. g_stLocaleNameColumn = "gb2312name";
  3488. }
  3489. else if (strcmp(locale.szValue, "korea") == 0)
  3490. {
  3491. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3493. if (g_stLocale != locale.szValue)
  3494. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3496. g_stLocale = "euckr";
  3497. g_stLocaleNameColumn = "name";
  3498. }
  3499. else if (strcmp(locale.szValue, "canada") == 0)
  3500. {
  3501. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3503. if (g_stLocale != locale.szValue)
  3504. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3506. g_stLocale = "latin1";
  3507. g_stLocaleNameColumn = "gb2312name";
  3508. }
  3509. else if (strcmp(locale.szValue, "brazil") == 0)
  3510. {
  3511. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3513. if (g_stLocale != locale.szValue)
  3514. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3516. g_stLocale = "latin1";
  3517. g_stLocaleNameColumn = "locale_name";
  3518. }
  3519. else if (strcmp(locale.szValue, "greek") == 0)
  3520. {
  3521. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3523. if (g_stLocale != locale.szValue)
  3524. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3526. g_stLocale = "greek";
  3527. g_stLocaleNameColumn = "locale_name";
  3528. }
  3529. else if (strcmp(locale.szValue, "russia") == 0)
  3530. {
  3531. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3533. if (g_stLocale != locale.szValue)
  3534. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3536. g_stLocale = "cp1251";
  3537. g_stLocaleNameColumn = "locale_name";
  3538. }
  3539. else if (strcmp(locale.szValue, "denmark") == 0)
  3540. {
  3541. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3543. if (g_stLocale != locale.szValue)
  3544. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3546. g_stLocale = "latin1";
  3547. g_stLocaleNameColumn = "locale_name";
  3548. }
  3549. else if (strcmp(locale.szValue, "bulgaria") == 0)
  3550. {
  3551. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3553. if (g_stLocale != locale.szValue)
  3554. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3556. g_stLocale = "cp1251";
  3557. g_stLocaleNameColumn = "locale_name";
  3558. }
  3559. else if (strcmp(locale.szValue, "croatia") == 0)
  3560. {
  3561. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3563. if (g_stLocale != locale.szValue)
  3564. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3566. g_stLocale = "cp1251";
  3567. g_stLocaleNameColumn = "locale_name";
  3568. }
  3569. else if (strcmp(locale.szValue, "mexico") == 0)
  3570. {
  3571. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3573. if (g_stLocale != locale.szValue)
  3574. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3576. g_stLocale = "latin1";
  3577. g_stLocaleNameColumn = "locale_name";
  3578. }
  3579. else if (strcmp(locale.szValue, "arabia") == 0)
  3580. {
  3581. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3583. if (g_stLocale != locale.szValue)
  3584. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3586. g_stLocale = "cp1256";
  3587. g_stLocaleNameColumn = "locale_name";
  3588. }
  3589. else if (strcmp(locale.szValue, "czech") == 0)
  3590. {
  3591. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3593. if (g_stLocale != locale.szValue)
  3594. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3596. g_stLocale = "latin2";
  3597. g_stLocaleNameColumn = "locale_name";
  3598. }
  3599. else if (strcmp(locale.szValue, "hungary") == 0)
  3600. {
  3601. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3603. if (g_stLocale != locale.szValue)
  3604. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3606. g_stLocale = "latin2";
  3607. g_stLocaleNameColumn = "locale_name";
  3608. }
  3609. else if (strcmp(locale.szValue, "romania") == 0)
  3610. {
  3611. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3613. if (g_stLocale != locale.szValue)
  3614. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3616. g_stLocale = "latin2";
  3617. g_stLocaleNameColumn = "locale_name";
  3618. }
  3619. else if (strcmp(locale.szValue, "netherlands") == 0)
  3620. {
  3621. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3623. if (g_stLocale != locale.szValue)
  3624. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3626. g_stLocale = "latin1";
  3627. g_stLocaleNameColumn = "locale_name";
  3628. }
  3629. else if (strcmp(locale.szValue, "singapore") == 0)
  3630. {
  3631. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3633. if (g_stLocale != locale.szValue)
  3634. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3636. g_stLocale = "latin1";
  3637. g_stLocaleNameColumn = "locale_name";
  3638. }
  3639. else if (strcmp(locale.szValue, "vietnam") == 0)
  3640. {
  3641. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3643. if (g_stLocale != locale.szValue)
  3644. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3646. g_stLocale = "latin1";
  3647. g_stLocaleNameColumn = "locale_name";
  3648. }
  3649. else if (strcmp(locale.szValue, "thailand") == 0)
  3650. {
  3651. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3653. if (g_stLocale != locale.szValue)
  3654. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3656. g_stLocale = "latin1";
  3657. g_stLocaleNameColumn = "locale_name";
  3658. }
  3659. else if (strcmp(locale.szValue, "usa") == 0)
  3660. {
  3661. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3663. if (g_stLocale != locale.szValue)
  3664. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
  3666. g_stLocale = "latin1";
  3667. g_stLocaleNameColumn = "locale_name";
  3668. }
  3669. else if (strcmp(locale.szValue, "we_korea") == 0)
  3670. {
  3671. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3673. if (g_stLocale != locale.szValue)
  3674. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
  3676. g_stLocale = "euckr";
  3677. g_stLocaleNameColumn = "name";
  3678. }
  3679. else if (strcmp(locale.szValue, "taiwan") == 0)
  3680. {
  3681. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
  3683. if (g_stLocale != locale.szValue)
  3684. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "big5");
  3685. g_stLocale = "big5";
  3686. g_stLocaleNameColumn = "locale_name";
  3687. }
  3688. else
  3689. {
  3690. sys_err("locale[LOCALE] = UNKNOWN(%s)", locale.szValue);
  3691. exit(0);
  3692. }
  3694. CDBManager::instance().SetLocale(g_stLocale.c_str());
  3695. }
  3696. else if (strcmp(locale.szKey, "DB_NAME_COLUMN") == 0)
  3697. {
  3698. sys_log(0, "locale[DB_NAME_COLUMN] = %s", locale.szValue);
  3699. g_stLocaleNameColumn = locale.szValue;
  3700. }
  3701. else
  3702. {
  3703. sys_log(0, "locale[UNKNOWN_KEY(%s)] = %s", locale.szKey, locale.szValue);
  3704. }
  3705. m_vec_Locale.push_back(locale);
  3706. }
  3708. delete pMsg;
  3710. return true;
  3711. }
  3712. //END_BOOT_LOCALIZATION
  3713. //ADMIN_MANAGER
  3715. bool CClientManager::__GetAdminInfo(const char *szIP, std::vector<tAdminInfo> & rAdminVec)
  3716. {
  3717. //szIP == NULL 일경우 모든서버에 운영자 권한을 갖는다.
  3718. char szQuery[512];
  3719. snprintf(szQuery, sizeof(szQuery),
  3720. "SELECT mID,mAccount,mName,mContactIP,mServerIP,mAuthority FROM gmlist WHERE mServerIP='ALL' or mServerIP='%s'",
  3721. szIP ? szIP : "ALL");
  3723. SQLMsg * pMsg = CDBManager::instance().DirectQuery(szQuery, SQL_COMMON);
  3725. if (pMsg->Get()->uiNumRows == 0)
  3726. {
  3727. sys_err("__GetAdminInfo() ==> DirectQuery failed(%s)", szQuery);
  3728. delete pMsg;
  3729. return false;
  3730. }
  3732. MYSQL_ROW row;
  3733. rAdminVec.reserve(pMsg->Get()->uiNumRows);
  3735. while ((row = mysql_fetch_row(pMsg->Get()->pSQLResult)))
  3736. {
  3737. int idx = 0;
  3738. tAdminInfo Info;
  3740. str_to_number(Info.m_ID, row[idx++]);
  3741. trim_and_lower(row[idx++], Info.m_szAccount, sizeof(Info.m_szAccount));
  3742. strlcpy(Info.m_szName, row[idx++], sizeof(Info.m_szName));
  3743. strlcpy(Info.m_szContactIP, row[idx++], sizeof(Info.m_szContactIP));
  3744. strlcpy(Info.m_szServerIP, row[idx++], sizeof(Info.m_szServerIP));
  3745. std::string stAuth = row[idx++];
  3747. if (!stAuth.compare("IMPLEMENTOR"))
  3748. Info.m_Authority = GM_IMPLEMENTOR;
  3749. else if (!stAuth.compare("GOD"))
  3750. Info.m_Authority = GM_GOD;
  3751. else if (!stAuth.compare("HIGH_WIZARD"))
  3752. Info.m_Authority = GM_HIGH_WIZARD;
  3753. else if (!stAuth.compare("LOW_WIZARD"))
  3754. Info.m_Authority = GM_LOW_WIZARD;
  3755. else if (!stAuth.compare("WIZARD"))
  3756. Info.m_Authority = GM_WIZARD;
  3757. else
  3758. continue;
  3760. rAdminVec.push_back(Info);
  3762. sys_log(0, "GM: PID %u Login %s Character %s ContactIP %s ServerIP %s Authority %d[%s]",
  3763. Info.m_ID, Info.m_szAccount, Info.m_szName, Info.m_szContactIP, Info.m_szServerIP, Info.m_Authority, stAuth.c_str());
  3764. }
  3766. delete pMsg;
  3768. return true;
  3769. }
  3771. bool CClientManager::__GetHostInfo(std::vector<std::string> & rIPVec)
  3772. {
  3773. char szQuery[512];
  3774. snprintf(szQuery, sizeof(szQuery), "SELECT mIP FROM gmhost");
  3775. SQLMsg * pMsg = CDBManager::instance().DirectQuery(szQuery, SQL_COMMON);
  3777. if (pMsg->Get()->uiNumRows == 0)
  3778. {
  3779. sys_err("__GetHostInfo() ==> DirectQuery failed(%s)", szQuery);
  3780. delete pMsg;
  3781. return false;
  3782. }
  3784. rIPVec.reserve(pMsg->Get()->uiNumRows);
  3786. MYSQL_ROW row;
  3788. while ((row = mysql_fetch_row(pMsg->Get()->pSQLResult)))
  3789. {
  3790. if (row[0] && *row[0])
  3791. {
  3792. rIPVec.push_back(row[0]);
  3793. sys_log(0, "GMHOST: %s", row[0]);
  3794. }
  3795. }
  3797. delete pMsg;
  3798. return true;
  3799. }
  3800. //END_ADMIN_MANAGER
  3802. void CClientManager::ReloadAdmin(CPeer*, TPacketReloadAdmin* p)
  3803. {
  3804. std::vector<tAdminInfo> vAdmin;
  3805. std::vector<std::string> vHost;
  3807. __GetHostInfo(vHost);
  3808. __GetAdminInfo(p->szIP, vAdmin);
  3810. DWORD dwPacketSize = sizeof(WORD) + sizeof (WORD) + sizeof(tAdminInfo) * vAdmin.size() +
  3811. sizeof(WORD) + sizeof(WORD) + 16 * vHost.size();
  3813. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
  3814. {
  3815. CPeer * peer = *it;
  3817. if (!peer->GetChannel())
  3818. continue;
  3820. peer->EncodeHeader(HEADER_DG_RELOAD_ADMIN, 0, dwPacketSize);
  3822. peer->EncodeWORD(16);
  3823. peer->EncodeWORD(vHost.size());
  3825. for (size_t n = 0; n < vHost.size(); ++n)
  3826. peer->Encode(vHost[n].c_str(), 16);
  3828. peer->EncodeWORD(sizeof(tAdminInfo));
  3829. peer->EncodeWORD(vAdmin.size());
  3831. for (size_t n = 0; n < vAdmin.size(); ++n)
  3832. peer->Encode(&vAdmin[n], sizeof(tAdminInfo));
  3833. }
  3835. sys_log(0, "ReloadAdmin End %s", p->szIP);
  3836. }
  3838. //BREAK_MARRIAGE
  3839. void CClientManager::BreakMarriage(CPeer * peer, const char * data)
  3840. {
  3841. DWORD pid1, pid2;
  3843. pid1 = *(int *) data;
  3844. data += sizeof(int);
  3846. pid2 = *(int *) data;
  3847. data += sizeof(int);
  3849. sys_log(0, "Breaking off a marriage engagement! pid %d and pid %d", pid1, pid2);
  3850. marriage::CManager::instance().Remove(pid1, pid2);
  3851. }
  3852. //END_BREAK_MARIIAGE
  3854. void CClientManager::UpdateItemCacheSet(DWORD pid)
  3855. {
  3856. itertype(m_map_pkItemCacheSetPtr) it = m_map_pkItemCacheSetPtr.find(pid);
  3858. if (it == m_map_pkItemCacheSetPtr.end())
  3859. {
  3860. if (g_test_server)
  3861. sys_log(0, "UPDATE_ITEMCACHESET : UpdateItemCacheSet ==> No ItemCacheSet pid(%d)", pid);
  3862. return;
  3863. }
  3865. TItemCacheSet * pSet = it->second;
  3866. TItemCacheSet::iterator it_set = pSet->begin();
  3868. while (it_set != pSet->end())
  3869. {
  3870. CItemCache * c = *it_set++;
  3871. c->Flush();
  3872. }
  3874. if (g_log)
  3875. sys_log(0, "UPDATE_ITEMCACHESET : UpdateItemCachsSet pid(%d)", pid);
  3876. }
  3878. void CClientManager::Election(CPeer * peer, DWORD dwHandle, const char* data)
  3879. {
  3880. DWORD idx;
  3881. DWORD selectingpid;
  3883. idx = *(DWORD *) data;
  3884. data += sizeof(DWORD);
  3886. selectingpid = *(DWORD *) data;
  3887. data += sizeof(DWORD);
  3889. int Success = 0;
  3891. if (!(Success = CMonarch::instance().VoteMonarch(selectingpid, idx)))
  3892. {
  3893. if (g_test_server)
  3894. sys_log(0, "[MONARCH_VOTE] Failed %d %d", idx, selectingpid);
  3895. peer->EncodeHeader(HEADER_DG_ELECT_MONARCH, dwHandle, sizeof(int));
  3896. peer->Encode(&Success, sizeof(int));
  3897. return;
  3898. }
  3899. else
  3900. {
  3901. if (g_test_server)
  3902. sys_log(0, "[MONARCH_VOTE] Success %d %d", idx, selectingpid);
  3903. peer->EncodeHeader(HEADER_DG_ELECT_MONARCH, dwHandle, sizeof(int));
  3904. peer->Encode(&Success, sizeof(int));
  3905. return;
  3906. }
  3908. }
  3909. void CClientManager::Candidacy(CPeer * peer, DWORD dwHandle, const char* data)
  3910. {
  3911. DWORD pid;
  3913. pid = *(DWORD *) data;
  3914. data += sizeof(DWORD);
  3916. if (!CMonarch::instance().AddCandidacy(pid, data))
  3917. {
  3918. if (g_test_server)
  3919. sys_log(0, "[MONARCH_CANDIDACY] Failed %d %s", pid, data);
  3921. peer->EncodeHeader(HEADER_DG_CANDIDACY, dwHandle, sizeof(int) + 32);
  3922. peer->Encode(0, sizeof(int));
  3923. peer->Encode(data, 32);
  3924. return;
  3925. }
  3926. else
  3927. {
  3928. if (g_test_server)
  3929. sys_log(0, "[MONARCH_CANDIDACY] Success %d %s", pid, data);
  3931. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
  3932. {
  3933. CPeer * p = *it;
  3935. if (!p->GetChannel())
  3936. continue;
  3938. if (0 && p->GetChannel() != 0)
  3939. continue;
  3941. if (p == peer)
  3942. {
  3943. p->EncodeHeader(HEADER_DG_CANDIDACY, dwHandle, sizeof(int) + 32);
  3944. p->Encode(&pid, sizeof(int));
  3945. p->Encode(data, 32);
  3946. }
  3947. else
  3948. {
  3949. p->EncodeHeader(HEADER_DG_CANDIDACY, 0, sizeof(int) + 32);
  3950. p->Encode(&pid, sizeof(int));
  3951. p->Encode(data, 32);
  3952. }
  3953. }
  3954. }
  3955. }
  3957. void CClientManager::AddMonarchMoney(CPeer * peer, DWORD dwHandle, const char * data)
  3958. {
  3959. int Empire = *(int *) data;
  3960. data += sizeof(int);
  3962. int Money = *(int *) data;
  3963. data += sizeof(int);
  3965. if (g_test_server)
  3966. sys_log(0, "[MONARCH] Add money Empire(%d) Money(%d)", Empire, Money);
  3968. CMonarch::instance().AddMoney(Empire, Money);
  3970. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
  3971. {
  3972. CPeer * p = *it;
  3974. if (!p->GetChannel())
  3975. continue;
  3977. if (p == peer)
  3978. {
  3979. p->EncodeHeader(HEADER_DG_ADD_MONARCH_MONEY, dwHandle, sizeof(int) + sizeof(int));
  3980. p->Encode(&Empire, sizeof(int));
  3981. p->Encode(&Money, sizeof(int));
  3982. }
  3983. else
  3984. {
  3985. p->EncodeHeader(HEADER_DG_ADD_MONARCH_MONEY, 0, sizeof(int) + sizeof(int));
  3986. p->Encode(&Empire, sizeof(int));
  3987. p->Encode(&Money, sizeof(int));
  3988. }
  3990. }
  3991. }
  3992. void CClientManager::DecMonarchMoney(CPeer * peer, DWORD dwHandle, const char * data)
  3993. {
  3994. int Empire = *(int *) data;
  3995. data += sizeof(int);
  3997. int Money = *(int *) data;
  3998. data += sizeof(int);
  4000. if (g_test_server)
  4001. sys_log(0, "[MONARCH] Dec money Empire(%d) Money(%d)", Empire, Money);
  4003. CMonarch::instance().DecMoney(Empire, Money);
  4005. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
  4006. {
  4007. CPeer * p = *it;
  4009. if (!p->GetChannel())
  4010. continue;
  4012. if (p == peer)
  4013. {
  4014. p->EncodeHeader(HEADER_DG_DEC_MONARCH_MONEY, dwHandle, sizeof(int) + sizeof(int));
  4015. p->Encode(&Empire, sizeof(int));
  4016. p->Encode(&Money, sizeof(int));
  4017. }
  4018. else
  4019. {
  4020. p->EncodeHeader(HEADER_DG_DEC_MONARCH_MONEY, 0, sizeof(int) + sizeof(int));
  4021. p->Encode(&Empire, sizeof(int));
  4022. p->Encode(&Money, sizeof(int));
  4023. }
  4024. }
  4025. }
  4027. void CClientManager::TakeMonarchMoney(CPeer * peer, DWORD dwHandle, const char * data)
  4028. {
  4029. int Empire = *(int *) data;
  4030. data += sizeof(int);
  4032. DWORD pid = *(DWORD *) data;
  4033. data += sizeof(int);
  4035. int Money = *(int *) data;
  4036. data += sizeof(int);
  4038. if (g_test_server)
  4039. sys_log(0, "[MONARCH] Take money Empire(%d) Money(%d)", Empire, Money);
  4041. if (CMonarch::instance().TakeMoney(Empire, pid, Money) == true)
  4042. {
  4043. peer->EncodeHeader(HEADER_DG_TAKE_MONARCH_MONEY, dwHandle, sizeof(int) + sizeof(int));
  4044. peer->Encode(&Empire, sizeof(int));
  4045. peer->Encode(&Money, sizeof(int));
  4046. }
  4047. else
  4048. {
  4049. Money = 0;
  4050. peer->EncodeHeader(HEADER_DG_TAKE_MONARCH_MONEY, dwHandle, sizeof(int) + sizeof(int));
  4051. peer->Encode(&Empire, sizeof(int));
  4052. peer->Encode(&Money, sizeof(int));
  4053. }
  4054. }
  4056. void CClientManager::ComeToVote(CPeer * peer, DWORD dwHandle, const char * data)
  4057. {
  4058. CMonarch::instance().ElectMonarch();
  4059. }
  4061. void CClientManager::RMCandidacy(CPeer * peer, DWORD dwHandle, const char * data)
  4062. {
  4063. char szName[32];
  4065. strlcpy(szName, data, sizeof(szName));
  4066. sys_log(0, "[MONARCH_GM] Remove candidacy name(%s)", szName);
  4068. int iRet = CMonarch::instance().DelCandidacy(szName) ? 1 : 0;
  4070. if (1 == iRet)
  4071. {
  4072. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
  4073. {
  4074. CPeer * p = *it;
  4076. if (!p->GetChannel())
  4077. continue;
  4079. if (p == peer)
  4080. {
  4081. p->EncodeHeader(HEADER_DG_RMCANDIDACY, dwHandle, sizeof(int) + sizeof(szName));
  4082. p->Encode(&iRet, sizeof(int));
  4083. p->Encode(szName, sizeof(szName));
  4084. }
  4085. else
  4086. {
  4087. p->EncodeHeader(HEADER_DG_RMCANDIDACY, dwHandle, sizeof(int) + sizeof(szName));
  4088. p->Encode(&iRet, sizeof(int));
  4089. p->Encode(szName, sizeof(szName));
  4090. }
  4091. }
  4092. }
  4093. else
  4094. {
  4095. CPeer * p = peer;
  4096. p->EncodeHeader(HEADER_DG_RMCANDIDACY, dwHandle, sizeof(int) + sizeof(szName));
  4097. p->Encode(&iRet, sizeof(int));
  4098. p->Encode(szName, sizeof(szName));
  4099. }
  4100. }
  4102. void CClientManager::SetMonarch(CPeer * peer, DWORD dwHandle, const char * data)
  4103. {
  4104. char szName[32];
  4106. strlcpy(szName, data, sizeof(szName));
  4108. if (g_test_server)
  4109. sys_log(0, "[MONARCH_GM] Set Monarch name(%s)", szName);
  4111. int iRet = CMonarch::instance().SetMonarch(szName) ? 1 : 0;
  4113. if (1 == iRet)
  4114. {
  4115. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
  4116. {
  4117. CPeer * p = *it;
  4119. if (!p->GetChannel())
  4120. continue;
  4122. if (p == peer)
  4123. {
  4124. p->EncodeHeader(HEADER_DG_RMCANDIDACY, dwHandle, sizeof(int) + sizeof(szName));
  4125. p->Encode(&iRet, sizeof(int));
  4126. p->Encode(szName, sizeof(szName));
  4127. }
  4128. else
  4129. {
  4130. p->EncodeHeader(HEADER_DG_RMCANDIDACY, dwHandle, sizeof(int) + sizeof(szName));
  4131. p->Encode(&iRet, sizeof(int));
  4132. p->Encode(szName, sizeof(szName));
  4133. }
  4134. }
  4135. }
  4136. else
  4137. {
  4138. CPeer * p = peer;
  4139. p->EncodeHeader(HEADER_DG_RMCANDIDACY, dwHandle, sizeof(int) + sizeof(szName));
  4140. p->Encode(&iRet, sizeof(int));
  4141. p->Encode(szName, sizeof(szName));
  4142. }
  4143. }
  4145. void CClientManager::RMMonarch(CPeer * peer, DWORD dwHandle, const char * data)
  4146. {
  4147. char szName[32];
  4149. strlcpy(szName, data, sizeof(szName));
  4151. if (g_test_server)
  4152. sys_log(0, "[MONARCH_GM] Remove Monarch name(%s)", szName);
  4154. CMonarch::instance().DelMonarch(szName);
  4156. int iRet = CMonarch::instance().DelMonarch(szName) ? 1 : 0;
  4158. if (1 == iRet)
  4159. {
  4160. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
  4161. {
  4162. CPeer * p = *it;
  4164. if (!p->GetChannel())
  4165. continue;
  4167. if (p == peer)
  4168. {
  4169. p->EncodeHeader(HEADER_DG_RMMONARCH, dwHandle, sizeof(int) + sizeof(szName));
  4170. p->Encode(&iRet, sizeof(int));
  4171. p->Encode(szName, sizeof(szName));
  4172. }
  4173. else
  4174. {
  4175. p->EncodeHeader(HEADER_DG_RMMONARCH, dwHandle, sizeof(int) + sizeof(szName));
  4176. p->Encode(&iRet, sizeof(int));
  4177. p->Encode(szName, sizeof(szName));
  4178. }
  4179. }
  4180. }
  4181. else
  4182. {
  4183. CPeer * p = peer;
  4184. p->EncodeHeader(HEADER_DG_RMCANDIDACY, dwHandle, sizeof(int) + sizeof(szName));
  4185. p->Encode(&iRet, sizeof(int));
  4186. p->Encode(szName, sizeof(szName));
  4187. }
  4188. }
  4190. void CClientManager::ChangeMonarchLord(CPeer * peer, DWORD dwHandle, TPacketChangeMonarchLord* info)
  4191. {
  4192. char szQuery[1024];
  4193. snprintf(szQuery, sizeof(szQuery),
  4194. "SELECT a.name, NOW() FROM player%s AS a, player_index%s AS b WHERE (a.account_id=b.id AND a.id=%u AND b.empire=%u) AND "
  4195. "(b.pid1=%u OR b.pid2=%u OR b.pid3=%u OR b.pid4=%u)",
  4196. GetTablePostfix(), GetTablePostfix(), info->dwPID, info->bEmpire,
  4197. info->dwPID, info->dwPID, info->dwPID, info->dwPID);
  4199. SQLMsg * pMsg = CDBManager::instance().DirectQuery(szQuery, SQL_PLAYER);
  4201. if (pMsg->Get()->uiNumRows != 0)
  4202. {
  4203. TPacketChangeMonarchLordACK ack;
  4204. ack.bEmpire = info->bEmpire;
  4205. ack.dwPID = info->dwPID;
  4207. MYSQL_ROW row = mysql_fetch_row(pMsg->Get()->pSQLResult);
  4208. strlcpy(ack.szName, row[0], sizeof(ack.szName));
  4209. strlcpy(ack.szDate, row[1], sizeof(ack.szDate));
  4211. snprintf(szQuery, sizeof(szQuery), "UPDATE monarch SET pid=%u, windate=NOW() WHERE empire=%d", ack.dwPID, ack.bEmpire);
  4212. SQLMsg* pMsg2 = CDBManager::instance().DirectQuery(szQuery, SQL_PLAYER);
  4214. if (pMsg2->Get()->uiAffectedRows > 0)
  4215. {
  4216. CMonarch::instance().LoadMonarch();
  4218. TMonarchInfo* newInfo = CMonarch::instance().GetMonarch();
  4220. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); it++)
  4221. {
  4222. CPeer* client = *it;
  4224. client->EncodeHeader(HEADER_DG_CHANGE_MONARCH_LORD_ACK, 0, sizeof(TPacketChangeMonarchLordACK));
  4225. client->Encode(&ack, sizeof(TPacketChangeMonarchLordACK));
  4227. client->EncodeHeader(HEADER_DG_UPDATE_MONARCH_INFO, 0, sizeof(TMonarchInfo));
  4228. client->Encode(newInfo, sizeof(TMonarchInfo));
  4229. }
  4230. }
  4232. delete pMsg2;
  4233. }
  4235. delete pMsg;
  4236. }
  4238. void CClientManager::BlockException(TPacketBlockException *data)
  4239. {
  4240. sys_log(0, "[BLOCK_EXCEPTION] CMD(%d) login(%s)", data->cmd, data->login);
  4242. // save sql
  4243. {
  4244. char buf[1024];
  4246. switch (data->cmd)
  4247. {
  4248. case BLOCK_EXCEPTION_CMD_ADD:
  4249. snprintf(buf, sizeof(buf), "INSERT INTO block_exception VALUES('%s')", data->login);
  4250. CDBManager::instance().AsyncQuery(buf, SQL_ACCOUNT);
  4251. CBlockCountry::instance().AddBlockException(data->login);
  4252. break;
  4253. case BLOCK_EXCEPTION_CMD_DEL:
  4254. snprintf(buf, sizeof(buf), "DELETE FROM block_exception VALUES('%s')", data->login);
  4255. CDBManager::instance().AsyncQuery(buf, SQL_ACCOUNT);
  4256. CBlockCountry::instance().DelBlockException(data->login);
  4257. break;
  4258. default:
  4259. return;
  4260. }
  4262. }
  4264. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
  4265. {
  4266. CPeer *peer = *it;
  4268. if (!peer->GetChannel())
  4269. continue;
  4271. CBlockCountry::instance().SendBlockExceptionOne(peer, data->login, data->cmd);
  4272. }
  4273. }
  4275. void CClientManager::SendSpareItemIDRange(CPeer* peer)
  4276. {
  4277. peer->SendSpareItemIDRange();
  4278. }
  4280. //
  4281. // Login Key만 맵에서 지운다.
  4282. //
  4283. void CClientManager::DeleteLoginKey(TPacketDC *data)
  4284. {
  4285. char login[LOGIN_MAX_LEN+1] = {0};
  4286. trim_and_lower(data->login, login, sizeof(login));
  4288. CLoginData *pkLD = GetLoginDataByLogin(login);
  4290. if (pkLD)
  4291. {
  4292. TLoginDataByLoginKey::iterator it = m_map_pkLoginData.find(pkLD->GetKey());
  4294. if (it != m_map_pkLoginData.end())
  4295. m_map_pkLoginData.erase(it);
  4296. }
  4297. }
  4299. // delete gift notify icon
  4300. void CClientManager::DeleteAwardId(TPacketDeleteAwardID *data)
  4301. {
  4302. //sys_log(0,"data from game server arrived %d",data->dwID);
  4303. std::map<DWORD, TItemAward *>::iterator it;
  4304. it = ItemAwardManager::Instance().GetMapAward().find(data->dwID);
  4305. if ( it != ItemAwardManager::Instance().GetMapAward().end() )
  4306. {
  4307. std::set<TItemAward *> & kSet = ItemAwardManager::Instance().GetMapkSetAwardByLogin()[it->second->szLogin];
  4308. if(kSet.erase(it->second))
  4309. sys_log(0,"erase ItemAward id: %d from cache", data->dwID);
  4310. ItemAwardManager::Instance().GetMapAward().erase(data->dwID);
  4311. }
  4312. else
  4313. {
  4314. sys_log(0,"DELETE_AWARDID : could not find the id: %d", data->dwID);
  4315. }
  4317. }
  4319. void CClientManager::UpdateChannelStatus(TChannelStatus* pData)
  4320. {
  4321. TChannelStatusMap::iterator it = m_mChannelStatus.find(pData->nPort);
  4322. if (it != m_mChannelStatus.end()) {
  4323. it->second = pData->bStatus;
  4324. }
  4325. else {
  4326. m_mChannelStatus.insert(TChannelStatusMap::value_type(pData->nPort, pData->bStatus));
  4327. }
  4328. }
  4330. void CClientManager::RequestChannelStatus(CPeer* peer, DWORD dwHandle)
  4331. {
  4332. const int nSize = m_mChannelStatus.size();
  4333. peer->EncodeHeader(HEADER_DG_RESPOND_CHANNELSTATUS, dwHandle, sizeof(TChannelStatus)*nSize+sizeof(int));
  4334. peer->Encode(&nSize, sizeof(int));
  4335. for (TChannelStatusMap::iterator it = m_mChannelStatus.begin(); it != m_mChannelStatus.end(); it++) {
  4336. peer->Encode(&it->first, sizeof(short));
  4337. peer->Encode(&it->second, sizeof(BYTE));
  4338. }
  4339. }
  4341. void CClientManager::ResetLastPlayerID(const TPacketNeedLoginLogInfo* data)
  4342. {
  4343. CLoginData* pkLD = GetLoginDataByAID( data->dwPlayerID );
  4345. if (NULL != pkLD)
  4346. {
  4347. pkLD->SetLastPlayerID( 0 );
  4348. }
  4349. }
  4351. void CClientManager::ChargeCash(const TRequestChargeCash* packet)
  4352. {
  4353. char szQuery[512];
  4355. if (ERequestCharge_Cash == packet->eChargeType)
  4356. sprintf(szQuery, "update account set `cash` = `cash` + %d where id = %d limit 1", packet->dwAmount, packet->dwAID);
  4357. else if(ERequestCharge_Mileage == packet->eChargeType)
  4358. sprintf(szQuery, "update account set `mileage` = `mileage` + %d where id = %d limit 1", packet->dwAmount, packet->dwAID);
  4359. else
  4360. {
  4361. sys_err ("Invalid request charge type (type : %d, amount : %d, aid : %d)", packet->eChargeType, packet->dwAmount, packet->dwAID);
  4362. return;
  4363. }
  4365. sys_err ("Request Charge (type : %d, amount : %d, aid : %d)", packet->eChargeType, packet->dwAmount, packet->dwAID);
  4367. CDBManager::Instance().AsyncQuery(szQuery, SQL_ACCOUNT);
  4368. }
  4370. #ifdef __AUCTION__
  4371. void CClientManager::EnrollInAuction (CPeer * peer, DWORD owner_id, AuctionEnrollProductInfo* data)
  4372. {
  4373. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (owner_id);
  4375. if (it == m_map_playerCache.end())
  4376. {
  4377. sys_err ("Invalid Player id %d. how can you get it?", owner_id);
  4378. return;
  4379. }
  4380. CItemCache* c = GetItemCache (data->get_item_id());
  4382. if (c == NULL)
  4383. {
  4384. sys_err ("Item %d doesn't exist in db cache.", data->get_item_id());
  4385. return;
  4386. }
  4387. TPlayerItem* item = c->Get(false);
  4389. if (item->owner != owner_id)
  4390. {
  4391. sys_err ("Player id %d doesn't have item %d.", owner_id, data->get_item_id());
  4392. return;
  4393. }
  4394. // 현재 시각 + 24시간 후.
  4395. time_t expired_time = time(0) + 24 * 60 * 60;
  4396. TAuctionItemInfo auctioned_item_info (item->vnum, data->get_bid_price(),
  4397. data->get_impur_price(), owner_id, "", expired_time, data->get_item_id(), 0, data->get_empire());
  4399. AuctionResult result = AuctionManager::instance().EnrollInAuction( c, auctioned_item_info );
  4401. if (result <= AUCTION_FAIL)
  4402. {
  4403. TPacketDGResultAuction enroll_result;
  4404. enroll_result.cmd = AUCTION_ENR_AUC;
  4405. enroll_result.target = data->get_item_id();
  4406. enroll_result.result = result;
  4407. peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, owner_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
  4408. peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4409. peer->Encode(c->Get(false), sizeof(TPlayerItem));
  4410. }
  4411. else
  4412. {
  4413. // 아이템 케시를 Auction에 등록 했으니 ClientManager에서는 뺀다.
  4414. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(item->owner);
  4416. if (it != m_map_pkItemCacheSetPtr.end())
  4417. {
  4418. it->second->erase(c);
  4419. }
  4420. m_map_itemCache.erase(item->id);
  4421. sys_log(0, "Enroll In Auction Success. owner_id item_id %d %d", owner_id, item->id);
  4423. TPacketDGResultAuction enroll_result;
  4424. enroll_result.cmd = AUCTION_ENR_AUC;
  4425. enroll_result.target = data->get_item_id();
  4426. enroll_result.result = result;
  4427. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4428. {
  4429. (*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, owner_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem) + sizeof(TAuctionItemInfo));
  4430. (*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4431. (*it)->Encode(c->Get(false), sizeof(TPlayerItem));
  4432. (*it)->Encode(&auctioned_item_info, sizeof(TAuctionItemInfo));
  4433. }
  4434. }
  4436. return;
  4437. }
  4439. void CClientManager::EnrollInSale (CPeer * peer, DWORD owner_id, AuctionEnrollSaleInfo* data)
  4440. {
  4441. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (owner_id);
  4443. if (it == m_map_playerCache.end())
  4444. {
  4445. sys_err ("Invalid Player id %d. how can you get it?", owner_id);
  4446. return;
  4447. }
  4449. CPlayerTableCache* player_cache = it->second;
  4450. TPlayerTable* player = player_cache->Get(false);
  4452. CItemCache* c = GetItemCache (data->get_item_id());
  4454. if (c == NULL)
  4455. {
  4456. sys_err ("Item %d doesn't exist in db cache.", data->get_item_id());
  4457. return;
  4458. }
  4459. TPlayerItem* item = c->Get(false);
  4461. if (item->owner != owner_id)
  4462. {
  4463. sys_err ("Player id %d doesn't have item %d.", owner_id, data->get_item_id());
  4464. return;
  4465. }
  4466. // 현재 시각 + 24시간 후.
  4467. time_t expired_time = time(0) + 24 * 60 * 60;
  4468. TSaleItemInfo sold_item_info (item->vnum, data->get_sale_price(),
  4469. owner_id, player->name, data->get_item_id(), data->get_wisher_id());
  4471. AuctionResult result = AuctionManager::instance().EnrollInSale( c, sold_item_info );
  4473. if (result <= AUCTION_FAIL)
  4474. {
  4475. TPacketDGResultAuction enroll_result;
  4476. enroll_result.cmd = AUCTION_ENR_SALE;
  4477. enroll_result.target = data->get_item_id();
  4478. enroll_result.result = result;
  4479. peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, owner_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
  4480. peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4481. peer->Encode(c->Get(false), sizeof(TPlayerItem));
  4482. }
  4483. else
  4484. {
  4485. // 아이템 케시를 Auction에 등록 했으니 ClientManager에서는 뺀다.
  4486. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(item->owner);
  4488. if (it != m_map_pkItemCacheSetPtr.end())
  4489. {
  4490. it->second->erase(c);
  4491. }
  4492. m_map_itemCache.erase(item->id);
  4493. sys_log(0, "Enroll In Sale Success. owner_id item_id %d %d", owner_id, item->id);
  4495. TPacketDGResultAuction enroll_result;
  4496. enroll_result.cmd = AUCTION_ENR_SALE;
  4497. enroll_result.target = data->get_item_id();
  4498. enroll_result.result = result;
  4500. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4501. {
  4502. (*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, owner_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem) + sizeof(TSaleItemInfo));
  4503. (*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4504. (*it)->Encode(c->Get(false), sizeof(TPlayerItem));
  4505. (*it)->Encode(&sold_item_info, sizeof(TSaleItemInfo));
  4506. }
  4507. }
  4509. return;
  4510. }
  4512. void CClientManager::EnrollInWish (CPeer * peer, DWORD wisher_id, AuctionEnrollWishInfo* data)
  4513. {
  4514. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (wisher_id);
  4516. if (it == m_map_playerCache.end())
  4517. {
  4518. sys_err ("Invalid Player id %d. how can you get it?", wisher_id);
  4519. return;
  4520. }
  4522. CPlayerTableCache* player_cache = it->second;
  4523. TPlayerTable* player = player_cache->Get(false);
  4525. // 현재 시각 + 24시간 후.
  4526. time_t expired_time = time(0) + 24 * 60 * 60;
  4527. TWishItemInfo wished_item_info (data->get_item_num(), data->get_wish_price(), wisher_id, player->name, expired_time, data->get_empire());
  4529. AuctionResult result = AuctionManager::instance().EnrollInWish ( wished_item_info );
  4531. if (result <= AUCTION_FAIL)
  4532. {
  4533. sys_log(0, "Enroll In Wish Success. wisher_id item_num %d %d", wisher_id, data->get_item_num());
  4535. TPacketDGResultAuction enroll_result;
  4536. enroll_result.cmd = AUCTION_ENR_WISH;
  4537. enroll_result.target = data->get_item_num();
  4538. enroll_result.result = result;
  4539. peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, wisher_id, sizeof(TPacketDGResultAuction));
  4540. peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4541. }
  4542. else
  4543. {
  4544. sys_log(0, "Enroll In Wish Fail. wisher_id item_num %d %d", wisher_id, data->get_item_num());
  4546. TPacketDGResultAuction enroll_result;
  4547. enroll_result.cmd = AUCTION_ENR_WISH;
  4548. enroll_result.target = data->get_item_num();
  4549. enroll_result.result = result;
  4551. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4552. {
  4553. (*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, wisher_id, sizeof(TPacketDGResultAuction) + sizeof(TWishItemInfo));
  4554. (*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4555. (*it)->Encode(&wished_item_info, sizeof(TWishItemInfo));
  4556. }
  4557. }
  4559. return;
  4560. }
  4562. void CClientManager::AuctionBid (CPeer * peer, DWORD bidder_id, AuctionBidInfo* data)
  4563. {
  4564. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (bidder_id);
  4566. if (it == m_map_playerCache.end())
  4567. {
  4568. sys_err ("Invalid Player id %d. how can you get it?", bidder_id);
  4569. return;
  4570. }
  4572. CPlayerTableCache* player_cache = it->second;
  4573. TPlayerTable* player = player_cache->Get(false);
  4575. AuctionResult result = AuctionManager::instance().Bid(bidder_id, player->name, data->get_item_id(), data->get_bid_price());
  4577. if (result == AUCTION_FAIL)
  4578. {
  4579. sys_log(0, "Bid Fail. bidder_id item_id %d %d", bidder_id, data->get_item_id());
  4580. }
  4581. else
  4582. {
  4583. sys_log(0, "Bid Success. bidder_id item_id %d %d", bidder_id, data->get_item_id());
  4584. }
  4586. if (result <= AUCTION_FAIL)
  4587. {
  4588. TPacketDGResultAuction enroll_result;
  4589. enroll_result.cmd = AUCTION_BID;
  4590. enroll_result.target = data->get_bid_price();
  4591. enroll_result.result = result;
  4593. peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction) + sizeof(AuctionBidInfo));
  4594. peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4595. }
  4596. else
  4597. {
  4598. TPacketDGResultAuction enroll_result;
  4599. enroll_result.cmd = AUCTION_BID;
  4600. enroll_result.target = data->get_item_id();
  4601. enroll_result.result = result;
  4603. TAuctionItemInfo* auctioned_item_info = AuctionManager::instance().GetAuctionItemInfoCache(data->get_item_id())->Get(false);
  4605. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4606. {
  4607. (*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction) + sizeof(TAuctionItemInfo));
  4608. (*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4609. (*it)->Encode(auctioned_item_info, sizeof(TAuctionItemInfo));
  4610. }
  4612. }
  4613. return;
  4614. }
  4616. void CClientManager::AuctionImpur (CPeer * peer, DWORD purchaser_id, AuctionImpurInfo* data)
  4617. {
  4618. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (purchaser_id);
  4620. if (it == m_map_playerCache.end())
  4621. {
  4622. sys_err ("Invalid Player id %d. how can you get it?", purchaser_id);
  4623. return;
  4624. }
  4626. CPlayerTableCache* player_cache = it->second;
  4627. TPlayerTable* player = player_cache->Get(false);
  4629. AuctionResult result = AuctionManager::instance().Impur(purchaser_id, player->name, data->get_item_id());
  4631. if (result == AUCTION_FAIL)
  4632. {
  4633. sys_log(0, "Impur Fail. purchaser_id item_id %d %d", purchaser_id, data->get_item_id());
  4634. }
  4635. else
  4636. {
  4637. sys_log(0, "Impur Success. purchaser_id item_id %d %d", purchaser_id, data->get_item_id());
  4638. }
  4640. if (result <= AUCTION_FAIL)
  4641. {
  4642. TPacketDGResultAuction enroll_result;
  4643. enroll_result.cmd = AUCTION_IMME_PUR;
  4644. enroll_result.target = data->get_item_id();
  4645. enroll_result.result = result;
  4647. peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, purchaser_id, sizeof(TPacketDGResultAuction));
  4648. peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4649. }
  4650. else
  4651. {
  4652. TPacketDGResultAuction enroll_result;
  4653. enroll_result.cmd = AUCTION_IMME_PUR;
  4654. enroll_result.target = data->get_item_id();
  4655. enroll_result.result = result;
  4657. TAuctionItemInfo* auctioned_item_info = AuctionManager::instance().GetAuctionItemInfoCache(data->get_item_id())->Get(false);
  4658. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4659. {
  4660. (*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, purchaser_id, sizeof(TPacketDGResultAuction) + sizeof(TAuctionItemInfo));
  4661. (*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4662. (*it)->Encode(auctioned_item_info, sizeof(TAuctionItemInfo));
  4663. }
  4664. }
  4665. return;
  4666. }
  4668. void CClientManager::AuctionGetAuctionedItem (CPeer * peer, DWORD actor_id, DWORD item_id)
  4669. {
  4670. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
  4671. AuctionResult result = AUCTION_FAIL;
  4672. if (it == m_map_playerCache.end())
  4673. {
  4674. sys_err ("Invalid Player id %d. how can you get it?", actor_id);
  4675. return;
  4676. }
  4678. TPlayerItem item;
  4679. result = AuctionManager::instance().GetAuctionedItem(actor_id, item_id, item);
  4681. if (result <= AUCTION_FAIL)
  4682. {
  4683. TPacketDGResultAuction enroll_result;
  4684. enroll_result.cmd = AUCTION_GET_AUC;
  4685. enroll_result.target = item_id;
  4686. enroll_result.result = result;
  4688. peer->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
  4689. peer->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
  4690. }
  4691. else
  4692. {
  4693. TPacketDGResultAuction enroll_result;
  4694. enroll_result.cmd = AUCTION_GET_AUC;
  4695. enroll_result.target = item_id;
  4696. enroll_result.result = result;
  4698. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4699. {
  4700. (*it)->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
  4701. (*it)->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
  4702. (*it)->Encode (&item, sizeof(TPlayerItem));
  4703. }
  4704. }
  4705. return;
  4706. }
  4708. void CClientManager::AuctionBuySoldItem (CPeer * peer, DWORD actor_id, DWORD item_id)
  4709. {
  4710. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
  4711. AuctionResult result = AUCTION_FAIL;
  4712. if (it == m_map_playerCache.end())
  4713. {
  4714. sys_err ("Invalid Player id %d. how can you get it?", actor_id);
  4715. return;
  4716. }
  4718. TPlayerItem item;
  4719. result = AuctionManager::instance().BuySoldItem(actor_id, item_id, item);
  4721. if (result <= AUCTION_FAIL)
  4722. {
  4723. TPacketDGResultAuction enroll_result;
  4724. enroll_result.cmd = AUCTION_BUY_SOLD;
  4725. enroll_result.target = item_id;
  4726. enroll_result.result = result;
  4728. peer->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
  4729. peer->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
  4730. }
  4731. else
  4732. {
  4733. TPacketDGResultAuction enroll_result;
  4734. enroll_result.cmd = AUCTION_BUY_SOLD;
  4735. enroll_result.target = item_id;
  4736. enroll_result.result = result;
  4738. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4739. {
  4740. (*it)->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
  4741. (*it)->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
  4742. (*it)->Encode (&item, sizeof(TPlayerItem));
  4743. }
  4744. }
  4745. return;
  4746. }
  4748. void CClientManager::AuctionCancelAuction (CPeer * peer, DWORD actor_id, DWORD item_id)
  4749. {
  4750. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
  4751. AuctionResult result = AUCTION_FAIL;
  4752. if (it == m_map_playerCache.end())
  4753. {
  4754. sys_err ("Invalid Player id %d. how can you get it?", actor_id);
  4755. return;
  4756. }
  4758. TPlayerItem item;
  4759. result = AuctionManager::instance().CancelAuction(actor_id, item_id, item);
  4761. if (result <= AUCTION_FAIL)
  4762. {
  4763. TPacketDGResultAuction enroll_result;
  4764. enroll_result.cmd = AUCTION_CANCEL_AUC;
  4765. enroll_result.target = item_id;
  4766. enroll_result.result = result;
  4768. peer->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
  4769. peer->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
  4770. }
  4771. else
  4772. {
  4773. TPacketDGResultAuction enroll_result;
  4774. enroll_result.cmd = AUCTION_CANCEL_AUC;
  4775. enroll_result.target = item_id;
  4776. enroll_result.result = result;
  4778. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4779. {
  4780. (*it)->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
  4781. (*it)->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
  4782. (*it)->Encode (&item, sizeof(TPlayerItem));
  4783. }
  4784. }
  4785. return;
  4786. }
  4788. void CClientManager::AuctionCancelWish (CPeer * peer, DWORD actor_id, DWORD item_num)
  4789. {
  4790. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
  4791. AuctionResult result = AUCTION_FAIL;
  4792. if (it == m_map_playerCache.end())
  4793. {
  4794. sys_err ("Invalid Player id %d. how can you get it?", actor_id);
  4795. return;
  4796. }
  4798. TPlayerItem item;
  4799. result = AuctionManager::instance().CancelWish(actor_id, item_num);
  4801. if (result <= AUCTION_FAIL)
  4802. {
  4803. TPacketDGResultAuction enroll_result;
  4804. enroll_result.cmd = AUCTION_CANCEL_WISH;
  4805. enroll_result.target = item_num;
  4806. enroll_result.result = result;
  4808. peer->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
  4809. peer->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
  4810. }
  4811. else
  4812. {
  4813. TPacketDGResultAuction enroll_result;
  4814. enroll_result.cmd = AUCTION_CANCEL_WISH;
  4815. enroll_result.target = item_num;
  4816. enroll_result.result = result;
  4818. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4819. {
  4820. (*it)->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
  4821. (*it)->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
  4822. }
  4823. }
  4824. return;
  4825. }
  4827. void CClientManager::AuctionCancelSale (CPeer * peer, DWORD actor_id, DWORD item_id)
  4828. {
  4829. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
  4830. AuctionResult result = AUCTION_FAIL;
  4831. if (it == m_map_playerCache.end())
  4832. {
  4833. sys_err ("Invalid Player id %d. how can you get it?", actor_id);
  4834. return;
  4835. }
  4837. TPlayerItem item;
  4838. result = AuctionManager::instance().CancelSale(actor_id, item_id, item);
  4840. if (result <= AUCTION_FAIL)
  4841. {
  4842. TPacketDGResultAuction enroll_result;
  4843. enroll_result.cmd = AUCTION_CANCEL_SALE;
  4844. enroll_result.target = item_id;
  4845. enroll_result.result = result;
  4847. peer->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction));
  4848. peer->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
  4849. }
  4850. else
  4851. {
  4852. TPacketDGResultAuction enroll_result;
  4853. enroll_result.cmd = AUCTION_CANCEL_SALE;
  4854. enroll_result.target = item_id;
  4855. enroll_result.result = result;
  4857. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4858. {
  4859. (*it)->EncodeHeader (HEADER_DG_AUCTION_RESULT, actor_id, sizeof(TPacketDGResultAuction) + sizeof(TPlayerItem));
  4860. (*it)->Encode (&enroll_result, sizeof(TPacketDGResultAuction));
  4861. (*it)->Encode (&item, sizeof(TPlayerItem));
  4862. }
  4863. }
  4864. return;
  4865. }
  4867. void CClientManager::AuctionDeleteAuctionItem (CPeer * peer, DWORD actor_id, DWORD item_id)
  4868. {
  4869. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
  4870. AuctionResult result = AUCTION_FAIL;
  4871. if (it == m_map_playerCache.end())
  4872. {
  4873. sys_err ("Invalid Player id %d. how can you get it?", actor_id);
  4874. return;
  4875. }
  4877. AuctionManager::instance().DeleteAuctionItem (actor_id, item_id);
  4878. }
  4879. void CClientManager::AuctionDeleteSaleItem (CPeer * peer, DWORD actor_id, DWORD item_id)
  4880. {
  4881. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (actor_id);
  4882. AuctionResult result = AUCTION_FAIL;
  4883. if (it == m_map_playerCache.end())
  4884. {
  4885. sys_err ("Invalid Player id %d. how can you get it?", actor_id);
  4886. return;
  4887. }
  4889. AuctionManager::instance().DeleteSaleItem (actor_id, item_id);
  4890. }
  4892. // ReBid는 이전 입찰금액에 더해서 입찰한다.
  4893. // ReBid에선 data->bid_price가 이전 입찰가에 더해져서
  4894. // 그 금액으로 rebid하는 것.
  4895. // 이렇게 한 이유는 rebid에 실패 했을 때,
  4896. // 유저의 호주머니에서 뺀 돈을 돌려주기 편하게 하기 위함이다.
  4898. void CClientManager::AuctionReBid (CPeer * peer, DWORD bidder_id, AuctionBidInfo* data)
  4899. {
  4900. TPlayerTableCacheMap::iterator it = m_map_playerCache.find (bidder_id);
  4902. if (it == m_map_playerCache.end())
  4903. {
  4904. sys_err ("Invalid Player id %d. how can you get it?", bidder_id);
  4905. return;
  4906. }
  4908. CPlayerTableCache* player_cache = it->second;
  4909. TPlayerTable* player = player_cache->Get(false);
  4911. AuctionResult result = AuctionManager::instance().ReBid(bidder_id, player->name, data->get_item_id(), data->get_bid_price());
  4913. if (result == AUCTION_FAIL)
  4914. {
  4915. sys_log(0, "ReBid Fail. bidder_id item_id %d %d", bidder_id, data->get_item_id());
  4916. }
  4917. else
  4918. {
  4919. sys_log(0, "ReBid Success. bidder_id item_id %d %d", bidder_id, data->get_item_id());
  4920. }
  4921. // 이건 FAIL이 떠서는 안돼.
  4922. // FAIL이 뜰 수가 없는게, MyBid에 있는 bidder_id에 대한 컨텐츠는 bidder_id만이 접근 할 수 있거든?
  4923. // 그러므로 다른 것이 다 정상적으로 작동한다고 가정 한다면
  4924. // 한 게임 서버 내에서 bidder_id로 MyBid를 수정한다 할 지라도, 그건 동기화 문제가 없어.
  4925. // 다른 게임 서버에 똑같은 bidder_id를 가진 놈이 있을 수가 없으니까.
  4926. // 그러므로 그 게임 서버에서 BidCancel 명령을 db에 날렸다는 것은,
  4927. // 이미 그 부분에 대해서는 검사가 완벽하다는 것이야.
  4928. // 그래도 혹시나 싶어서, 디버깅을 위해 fail 코드를 남겨둔다.
  4929. if (result <= AUCTION_FAIL)
  4930. {
  4931. TPacketDGResultAuction enroll_result;
  4932. enroll_result.cmd = AUCTION_REBID;
  4933. enroll_result.target = data->get_item_id();
  4934. enroll_result.result = result;
  4936. peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction) + sizeof(int));
  4937. peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4938. peer->EncodeDWORD(data->get_bid_price());
  4939. }
  4940. else
  4941. {
  4942. TPacketDGResultAuction enroll_result;
  4943. enroll_result.cmd = AUCTION_REBID;
  4944. enroll_result.target = data->get_item_id();
  4945. enroll_result.result = result;
  4947. TAuctionItemInfo* auctioned_item_info = AuctionManager::instance().GetAuctionItemInfoCache(data->get_item_id())->Get(false);
  4949. for (TPeerList::iterator it = m_peerList.begin(); it != m_peerList.end(); it++)
  4950. {
  4951. (*it)->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction) + sizeof(TAuctionItemInfo));
  4952. (*it)->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  4953. (*it)->Encode(auctioned_item_info, sizeof(TAuctionItemInfo));
  4954. }
  4955. }
  4956. return;
  4957. }
  4959. #ifdef __SWITCH_CHANNEL_SYSTEM__
  4960. void CClientManager::FindChannel(CPeer * requestPeer, DWORD dwHandle, TPacketChangeChannel * p)
  4961. {
  4962. if (!p->lMapIndex || !p->channel)
  4963. return;
  4965. long lAddr = 0;
  4966. WORD port = 0;
  4968. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end(); ++i)
  4969. {
  4970. CPeer * peer = *i;
  4971. if (peer->GetChannel() != p->channel)
  4972. continue;
  4974. TMapLocation kMapLocation;
  4975. thecore_memcpy(kMapLocation.alMaps, peer->GetMaps(), sizeof(kMapLocation.alMaps));
  4976. int iLen = sizeof(kMapLocation.alMaps) / sizeof(kMapLocation.alMaps[0]);
  4978. for (int i = 0; i<iLen; ++i)
  4979. {
  4980. if (kMapLocation.alMaps[i] == p->lMapIndex)
  4981. {
  4982. char host[16];
  4983. strlcpy(host, peer->GetPublicIP(), sizeof(kMapLocation.szHost));
  4984. lAddr = inet_addr(host);
  4985. port = peer->GetListenPort();
  4986. break;
  4987. }
  4988. }
  4990. if (lAddr && port) //We already obtained them
  4991. break;
  4992. }
  4994. TPacketReturnChannel r;
  4995. r.lAddr = lAddr;
  4996. r.port = port;
  4998. requestPeer->EncodeHeader(HEADER_DG_CHANNEL_RESULT, dwHandle, sizeof(r));
  4999. requestPeer->Encode(&r, sizeof(r));
  5000. }
  5001. #endif
  5003. void CClientManager::AuctionBidCancel (CPeer * peer, DWORD bidder_id, DWORD item_id)
  5004. {
  5005. AuctionResult result = AuctionManager::instance().BidCancel (bidder_id, item_id);
  5007. // 이건 FAIL이 떠서는 안돼.
  5008. // FAIL이 뜰 수가 없는게, MyBid에 있는 bidder_id에 대한 컨텐츠는 bidder_id만이 접근 할 수 있거든?
  5009. // 그러므로 다른 것이 다 정상적으로 작동한다고 가정 한다면
  5010. // 한 게임 서버 내에서 bidder_id로 MyBid를 수정한다 할 지라도, 그건 동기화 문제가 없어.
  5011. // 다른 게임 서버에 똑같은 bidder_id를 가진 놈이 있을 수가 없으니까.
  5012. // 그러므로 그 게임 서버에서 BidCancel 명령을 db에 날렸다는 것은,
  5013. // 이미 그 부분에 대해서는 검사가 완벽하다는 것이야.
  5014. // 그래도 혹시나 싶어서, 디버깅을 위해 fail 코드를 남겨둔다.
  5015. if (result <= AUCTION_FAIL)
  5016. {
  5017. TPacketDGResultAuction enroll_result;
  5018. enroll_result.cmd = AUCTION_BID_CANCEL;
  5019. enroll_result.target = item_id;
  5020. enroll_result.result = result;
  5022. peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction));
  5023. peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  5024. }
  5025. else
  5026. {
  5027. TPacketDGResultAuction enroll_result;
  5028. enroll_result.cmd = AUCTION_BID_CANCEL;
  5029. enroll_result.target = item_id;
  5030. enroll_result.result = result;
  5032. peer->EncodeHeader(HEADER_DG_AUCTION_RESULT, bidder_id, sizeof(TPacketDGResultAuction));
  5033. peer->Encode(&enroll_result, sizeof(TPacketDGResultAuction));
  5034. }
  5035. }
  5036. #endif

ClientManager.cpp