1. #include "stdafx.h"
2. #include "../../common/building.h"
3. #include "../../common/VnumHelper.h"
4. #include "../../libgame/include/grid.h"
6. #include "ClientManager.h"
8. #include "Main.h"
9. #include "Config.h"
10. #include "DBManager.h"
11. #include "QID.h"
12. #include "GuildManager.h"
13. #include "PrivManager.h"
14. #include "MoneyLog.h"
15. #include "ItemAwardManager.h"
16. #include "Marriage.h"
17. #include "ItemIDRangeManager.h"
18. #include "Cache.h"
20. extern int g_iPlayerCacheFlushSeconds;
21. extern int g_iItemCacheFlushSeconds;
22. extern int g_test_server;
23. extern int g_log;
24. extern std::string g_stLocale;
25. extern std::string g_stLocaleNameColumn;
26. bool CreateItemTableFromRes(MYSQL_RES * res, std::vector<TPlayerItem> * pVec, DWORD dwPID);
28. DWORD g_dwUsageMax = 0;
29. DWORD g_dwUsageAvg = 0;
31. CPacketInfo g_query_info;
32. CPacketInfo g_item_info;
34. int g_item_count = 0;
35. int g_query_count[2];
37. CClientManager::CClientManager() :
38. m_pkAuthPeer(NULL),
39. m_iPlayerIDStart(0),
40. m_iPlayerDeleteLevelLimit(0),
41. m_iPlayerDeleteLevelLimitLower(0),
42. m_bChinaEventServer(false),
43. m_iShopTableSize(0),
44. m_pShopTable(NULL),
45. m_iRefineTableSize(0),
46. m_pRefineTable(NULL),
47. m_bShutdowned(FALSE),
48. m_iCacheFlushCount(0),
49. m_iCacheFlushCountLimit(200)
50. {
51. m_itemRange.dwMin = 0;
52. m_itemRange.dwMax = 0;
53. m_itemRange.dwUsableItemIDMin = 0;
55. memset(g_query_count, 0, sizeof(g_query_count));
56. }
58. CClientManager::~CClientManager()
59. {
60. Destroy();
61. }
63. void CClientManager::SetPlayerIDStart(int iIDStart)
64. {
65. m_iPlayerIDStart = iIDStart;
66. }
68. void CClientManager::Destroy()
69. {
70. m_mChannelStatus.clear();
71. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end(); ++i)
72. (*i)->Destroy();
74. m_peerList.clear();
76. if (m_fdAccept > 0)
77. {
78. socket_close(m_fdAccept);
79. m_fdAccept = -1;
80. }
81. }
83. bool CClientManager::Initialize()
84. {
85. int tmpValue;
87. //BOOT_LOCALIZATION
88. if (!InitializeLocalization())
89. {
90. fprintf(stderr, "Failed Localization Infomation so exit\n");
91. return false;
92. }
94. //END_BOOT_LOCALIZATION
95. //ITEM_UNIQUE_ID
97. if (!InitializeNowItemID())
98. {
99. fprintf(stderr, " Item range Initialize Failed. Exit DBCache Server\n");
100. return false;
101. }
102. //END_ITEM_UNIQUE_ID
104. if (!InitializeTables())
105. {
106. sys_err("Table Initialize FAILED");
107. return false;
108. }
110. CGuildManager::instance().BootReserveWar();
112. if (!CConfig::instance().GetValue("BIND_PORT", &tmpValue))
113. tmpValue = 5300;
115. char szBindIP[128];
117. if (!CConfig::instance().GetValue("BIND_IP", szBindIP, 128))
118. strlcpy(szBindIP, "0", sizeof(szBindIP));
120. m_fdAccept = socket_tcp_bind(szBindIP, tmpValue);
122. if (m_fdAccept < 0)
123. {
124. perror("socket");
125. return false;
126. }
128. sys_log(0, "ACCEPT_HANDLE: %u", m_fdAccept);
129. fdwatch_add_fd(m_fdWatcher, m_fdAccept, NULL, FDW_READ, false);
131. if (!CConfig::instance().GetValue("BACKUP_LIMIT_SEC", &tmpValue))
132. tmpValue = 600;
134. m_looping = true;
136. if (!CConfig::instance().GetValue("PLAYER_DELETE_LEVEL_LIMIT", &m_iPlayerDeleteLevelLimit))
137. {
138. sys_err("conf.txt: Cannot find PLAYER_DELETE_LEVEL_LIMIT, use default level %d", PLAYER_MAX_LEVEL_CONST + 1);
139. m_iPlayerDeleteLevelLimit = PLAYER_MAX_LEVEL_CONST + 1;
140. }
142. if (!CConfig::instance().GetValue("PLAYER_DELETE_LEVEL_LIMIT_LOWER", &m_iPlayerDeleteLevelLimitLower))
143. {
144. m_iPlayerDeleteLevelLimitLower = 0;
145. }
147. sys_log(0, "PLAYER_DELETE_LEVEL_LIMIT set to %d", m_iPlayerDeleteLevelLimit);
148. sys_log(0, "PLAYER_DELETE_LEVEL_LIMIT_LOWER set to %d", m_iPlayerDeleteLevelLimitLower);
150. m_bChinaEventServer = false;
152. int iChinaEventServer = 0;
154. if (CConfig::instance().GetValue("CHINA_EVENT_SERVER", &iChinaEventServer))
155. m_bChinaEventServer = (iChinaEventServer);
157. sys_log(0, "CHINA_EVENT_SERVER %s", CClientManager::instance().IsChinaEventServer()?"true":"false");
160. LoadEventFlag();
162. // database character-setÀ» °­Á¦·Î ¸ÂÃã
163. if (g_stLocale == "big5" || g_stLocale == "sjis")
164. CDBManager::instance().QueryLocaleSet();
166. return true;
167. }
169. void CClientManager::MainLoop()
170. {
171. SQLMsg * tmp;
173. sys_log(0, "ClientManager pointer is %p", this);
175. // ¸ŞÀηçÇÁ
176. while (!m_bShutdowned)
177. {
178. while ((tmp = CDBManager::instance().PopResult()))
179. {
180. AnalyzeQueryResult(tmp);
181. delete tmp;
182. }
184. if (!Process())
185. break;
187. log_rotate();
188. }
190. //
191. // ¸ŞÀηçÇÁ Á¾·áó¸®
192. //
193. sys_log(0, "MainLoop exited, Starting cache flushing");
195. signal_timer_disable();
197. itertype(m_map_playerCache) it = m_map_playerCache.begin();
199. //Ç÷¹À̾î Å×À̺í ij½¬ Ç÷¯½¬
200. while (it != m_map_playerCache.end())
201. {
202. CPlayerTableCache * c = (it++)->second;
204. c->Flush();
205. delete c;
206. }
207. m_map_playerCache.clear();
210. itertype(m_map_itemCache) it2 = m_map_itemCache.begin();
211. //¾ÆÀÌÅÛ Ç÷¯½¬
212. while (it2 != m_map_itemCache.end())
213. {
214. CItemCache * c = (it2++)->second;
216. c->Flush();
217. delete c;
218. }
219. m_map_itemCache.clear();
221. // MYSHOP_PRICE_LIST
222. //
223. // °³ÀλóÁ¡ ¾ÆÀÌÅÛ °¡°İ ¸®½ºÆ® Flush
224. //
225. for (itertype(m_mapItemPriceListCache) itPriceList = m_mapItemPriceListCache.begin(); itPriceList != m_mapItemPriceListCache.end(); ++itPriceList)
226. {
227. CItemPriceListTableCache* pCache = itPriceList->second;
228. pCache->Flush();
229. delete pCache;
230. }
232. m_mapItemPriceListCache.clear();
233. // END_OF_MYSHOP_PRICE_LIST
234. }
236. void CClientManager::Quit()
237. {
238. m_bShutdowned = TRUE;
239. }
241. void CClientManager::QUERY_BOOT(CPeer* peer, TPacketGDBoot * p)
242. {
243. const BYTE bPacketVersion = 6; // BOOT ÆĞŶÀÌ ¹Ù²ğ¶§¸¶´Ù ¹øÈ£¸¦ ¿Ã¸®µµ·Ï ÇÑ´Ù.
245. std::vector<tAdminInfo> vAdmin;
246. std::vector<std::string> vHost;
248. __GetHostInfo(vHost);
249. __GetAdminInfo(p->szIP, vAdmin);
251. sys_log(0, "QUERY_BOOT : AdminInfo (Request ServerIp %s) ", p->szIP);
253. DWORD dwPacketSize =
254. sizeof(DWORD) +
255. sizeof(BYTE) +
256. sizeof(WORD) + sizeof(WORD) + sizeof(TMobTable) * m_vec_mobTable.size() +
257. sizeof(WORD) + sizeof(WORD) + sizeof(TItemTable) * m_vec_itemTable.size() +
258. sizeof(WORD) + sizeof(WORD) + sizeof(TShopTable) * m_iShopTableSize +
259. sizeof(WORD) + sizeof(WORD) + sizeof(TSkillTable) * m_vec_skillTable.size() +
260. sizeof(WORD) + sizeof(WORD) + sizeof(TRefineTable) * m_iRefineTableSize +
261. sizeof(WORD) + sizeof(WORD) + sizeof(TItemAttrTable) * m_vec_itemAttrTable.size() +
262. sizeof(WORD) + sizeof(WORD) + sizeof(TItemAttrTable) * m_vec_itemRareTable.size() +
263. sizeof(WORD) + sizeof(WORD) + sizeof(TBanwordTable) * m_vec_banwordTable.size() +
264. sizeof(WORD) + sizeof(WORD) + sizeof(building::TLand) * m_vec_kLandTable.size() +
265. sizeof(WORD) + sizeof(WORD) + sizeof(building::TObjectProto) * m_vec_kObjectProto.size() +
266. sizeof(WORD) + sizeof(WORD) + sizeof(building::TObject) * m_map_pkObjectTable.size() +
268. sizeof(time_t) +
269. sizeof(WORD) + sizeof(WORD) + sizeof(TItemIDRangeTable)*2 +
270. //ADMIN_MANAGER
271. sizeof(WORD) + sizeof(WORD) + 16 * vHost.size() +
272. sizeof(WORD) + sizeof(WORD) + sizeof(tAdminInfo) * vAdmin.size() +
273. //END_ADMIN_MANAGER
274. sizeof(WORD);
276. peer->EncodeHeader(HEADER_DG_BOOT, 0, dwPacketSize);
277. peer->Encode(&dwPacketSize, sizeof(DWORD));
278. peer->Encode(&bPacketVersion, sizeof(BYTE));
280. sys_log(0, "BOOT: PACKET: %d", dwPacketSize);
281. sys_log(0, "BOOT: VERSION: %d", bPacketVersion);
283. sys_log(0, "sizeof(TMobTable) = %d", sizeof(TMobTable));
284. sys_log(0, "sizeof(TItemTable) = %d", sizeof(TItemTable));
285. sys_log(0, "sizeof(TShopTable) = %d", sizeof(TShopTable));
286. sys_log(0, "sizeof(TSkillTable) = %d", sizeof(TSkillTable));
287. sys_log(0, "sizeof(TRefineTable) = %d", sizeof(TRefineTable));
288. sys_log(0, "sizeof(TItemAttrTable) = %d", sizeof(TItemAttrTable));
289. sys_log(0, "sizeof(TItemRareTable) = %d", sizeof(TItemAttrTable));
290. sys_log(0, "sizeof(TBanwordTable) = %d", sizeof(TBanwordTable));
291. sys_log(0, "sizeof(TLand) = %d", sizeof(building::TLand));
292. sys_log(0, "sizeof(TObjectProto) = %d", sizeof(building::TObjectProto));
293. sys_log(0, "sizeof(TObject) = %d", sizeof(building::TObject));
294. //ADMIN_MANAGER
295. sys_log(0, "sizeof(tAdminInfo) = %d * %d ", sizeof(tAdminInfo) * vAdmin.size());
296. //END_ADMIN_MANAGER
298. peer->EncodeWORD(sizeof(TMobTable));
299. peer->EncodeWORD(m_vec_mobTable.size());
300. peer->Encode(&m_vec_mobTable[0], sizeof(TMobTable) * m_vec_mobTable.size());
302. peer->EncodeWORD(sizeof(TItemTable));
303. peer->EncodeWORD(m_vec_itemTable.size());
304. peer->Encode(&m_vec_itemTable[0], sizeof(TItemTable) * m_vec_itemTable.size());
306. peer->EncodeWORD(sizeof(TShopTable));
307. peer->EncodeWORD(m_iShopTableSize);
308. peer->Encode(m_pShopTable, sizeof(TShopTable) * m_iShopTableSize);
310. peer->EncodeWORD(sizeof(TSkillTable));
311. peer->EncodeWORD(m_vec_skillTable.size());
312. peer->Encode(&m_vec_skillTable[0], sizeof(TSkillTable) * m_vec_skillTable.size());
314. peer->EncodeWORD(sizeof(TRefineTable));
315. peer->EncodeWORD(m_iRefineTableSize);
316. peer->Encode(m_pRefineTable, sizeof(TRefineTable) * m_iRefineTableSize);
318. peer->EncodeWORD(sizeof(TItemAttrTable));
319. peer->EncodeWORD(m_vec_itemAttrTable.size());
320. peer->Encode(&m_vec_itemAttrTable[0], sizeof(TItemAttrTable) * m_vec_itemAttrTable.size());
322. peer->EncodeWORD(sizeof(TItemAttrTable));
323. peer->EncodeWORD(m_vec_itemRareTable.size());
324. peer->Encode(&m_vec_itemRareTable[0], sizeof(TItemAttrTable) * m_vec_itemRareTable.size());
326. peer->EncodeWORD(sizeof(TBanwordTable));
327. peer->EncodeWORD(m_vec_banwordTable.size());
328. peer->Encode(&m_vec_banwordTable[0], sizeof(TBanwordTable) * m_vec_banwordTable.size());
330. peer->EncodeWORD(sizeof(building::TLand));
331. peer->EncodeWORD(m_vec_kLandTable.size());
332. peer->Encode(&m_vec_kLandTable[0], sizeof(building::TLand) * m_vec_kLandTable.size());
334. peer->EncodeWORD(sizeof(building::TObjectProto));
335. peer->EncodeWORD(m_vec_kObjectProto.size());
336. peer->Encode(&m_vec_kObjectProto[0], sizeof(building::TObjectProto) * m_vec_kObjectProto.size());
338. peer->EncodeWORD(sizeof(building::TObject));
339. peer->EncodeWORD(m_map_pkObjectTable.size());
341. itertype(m_map_pkObjectTable) it = m_map_pkObjectTable.begin();
343. while (it != m_map_pkObjectTable.end())
344. peer->Encode((it++)->second, sizeof(building::TObject));
346. // Auction Boot
348. time_t now = time(0);
349. peer->Encode(&now, sizeof(time_t));
351. TItemIDRangeTable itemRange = CItemIDRangeManager::instance().GetRange();
352. TItemIDRangeTable itemRangeSpare = CItemIDRangeManager::instance().GetRange();
354. peer->EncodeWORD(sizeof(TItemIDRangeTable));
355. peer->EncodeWORD(1);
356. peer->Encode(&itemRange, sizeof(TItemIDRangeTable));
357. peer->Encode(&itemRangeSpare, sizeof(TItemIDRangeTable));
359. peer->SetItemIDRange(itemRange);
360. peer->SetSpareItemIDRange(itemRangeSpare);
362. //ADMIN_MANAGER
363. peer->EncodeWORD(16);
364. peer->EncodeWORD(vHost.size());
366. for (size_t n = 0; n < vHost.size(); ++n)
367. {
368. peer->Encode(vHost[n].c_str(), 16);
369. sys_log(0, "GMHosts %s", vHost[n].c_str());
370. }
372. peer->EncodeWORD(sizeof(tAdminInfo));
373. peer->EncodeWORD(vAdmin.size());
375. for (size_t n = 0; n < vAdmin.size(); ++n)
376. {
377. peer->Encode(&vAdmin[n], sizeof(tAdminInfo));
378. sys_log(0, "Admin name %s ConntactIP %s", vAdmin[n].m_szName, vAdmin[n].m_szContactIP);
379. }
380. //END_ADMIN_MANAGER
382. peer->EncodeWORD(0xffff);
383. }
385. void CClientManager::SendPartyOnSetup(CPeer* pkPeer)
386. {
387. TPartyMap & pm = m_map_pkChannelParty[pkPeer->GetChannel()];
389. for (itertype(pm) it_party = pm.begin(); it_party != pm.end(); ++it_party)
390. {
391. sys_log(0, "PARTY SendPartyOnSetup Party [%u]", it_party->first);
392. pkPeer->EncodeHeader(HEADER_DG_PARTY_CREATE, 0, sizeof(TPacketPartyCreate));
393. pkPeer->Encode(&it_party->first, sizeof(DWORD));
395. for (itertype(it_party->second) it_member = it_party->second.begin(); it_member != it_party->second.end(); ++it_member)
396. {
397. sys_log(0, "PARTY SendPartyOnSetup Party [%u] Member [%u]", it_party->first, it_member->first);
398. pkPeer->EncodeHeader(HEADER_DG_PARTY_ADD, 0, sizeof(TPacketPartyAdd));
399. pkPeer->Encode(&it_party->first, sizeof(DWORD));
400. pkPeer->Encode(&it_member->first, sizeof(DWORD));
401. pkPeer->Encode(&it_member->second.bRole, sizeof(BYTE));
403. pkPeer->EncodeHeader(HEADER_DG_PARTY_SET_MEMBER_LEVEL, 0, sizeof(TPacketPartySetMemberLevel));
404. pkPeer->Encode(&it_party->first, sizeof(DWORD));
405. pkPeer->Encode(&it_member->first, sizeof(DWORD));
406. pkPeer->Encode(&it_member->second.bLevel, sizeof(BYTE));
407. }
408. }
409. }
411. void CClientManager::QUERY_PLAYER_COUNT(CPeer * pkPeer, TPlayerCountPacket * pPacket)
412. {
413. pkPeer->SetUserCount(pPacket->dwCount);
414. }
416. void CClientManager::QUERY_QUEST_SAVE(CPeer * pkPeer, TQuestTable * pTable, DWORD dwLen)
417. {
418. if (0 != (dwLen % sizeof(TQuestTable)))
419. {
420. sys_err("invalid packet size %d, sizeof(TQuestTable) == %d", dwLen, sizeof(TQuestTable));
421. return;
422. }
424. int iSize = dwLen / sizeof(TQuestTable);
426. char szQuery[1024];
428. for (int i = 0; i < iSize; ++i, ++pTable)
429. {
430. if (pTable->lValue == 0)
431. {
432. snprintf(szQuery, sizeof(szQuery),
433. "DELETE FROM quest%s WHERE dwPID=%d AND szName='%s' AND szState='%s'",
434. GetTablePostfix(), pTable->dwPID, pTable->szName, pTable->szState);
435. }
436. else
437. {
438. snprintf(szQuery, sizeof(szQuery),
439. "REPLACE INTO quest%s (dwPID, szName, szState, lValue) VALUES(%d, '%s', '%s', %ld)",
440. GetTablePostfix(), pTable->dwPID, pTable->szName, pTable->szState, pTable->lValue);
441. }
443. CDBManager::instance().ReturnQuery(szQuery, QID_QUEST_SAVE, pkPeer->GetHandle(), NULL);
444. }
445. }
447. void CClientManager::QUERY_SAFEBOX_LOAD(CPeer * pkPeer, DWORD dwHandle, TSafeboxLoadPacket * packet, bool bMall)
448. {
449. ClientHandleInfo * pi = new ClientHandleInfo(dwHandle);
450. strlcpy(pi->safebox_password, packet->szPassword, sizeof(pi->safebox_password));
451. pi->account_id = packet->dwID;
452. pi->account_index = 0;
453. pi->ip[0] = bMall ? 1 : 0;
454. strlcpy(pi->login, packet->szLogin, sizeof(pi->login));
456. char szQuery[QUERY_MAX_LEN];
457. snprintf(szQuery, sizeof(szQuery),
458. "SELECT account_id, size, password FROM safebox%s WHERE account_id=%u",
459. GetTablePostfix(), packet->dwID);
461. if (g_log)
462. sys_log(0, "HEADER_GD_SAFEBOX_LOAD (handle: %d account.id %u is_mall %d)", dwHandle, packet->dwID, bMall ? 1 : 0);
464. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_LOAD, pkPeer->GetHandle(), pi);
465. }
467. void CClientManager::RESULT_SAFEBOX_LOAD(CPeer * pkPeer, SQLMsg * msg)
468. {
469. CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
470. ClientHandleInfo * pi = (ClientHandleInfo *) qi->pvData;
471. DWORD dwHandle = pi->dwHandle;
473. // ¿©±â¿¡¼­ »ç¿ëÇÏ´Â account_index´Â Äõ¸® ¼ø¼­¸¦ ¸»ÇÑ´Ù.
474. // ù¹ø° Æнº¿öµå ¾Ë¾Æ³»±â À§ÇØ ÇÏ´Â Äõ¸®°¡ 0
475. // µÎ¹ø° ½ÇÁ¦ µ¥ÀÌÅ͸¦ ¾ò¾î³õ´Â Äõ¸®°¡ 1
477. if (pi->account_index == 0)
478. {
479. char szSafeboxPassword[SAFEBOX_PASSWORD_MAX_LEN + 1];
480. strlcpy(szSafeboxPassword, pi->safebox_password, sizeof(szSafeboxPassword));
482. TSafeboxTable * pSafebox = new TSafeboxTable;
483. memset(pSafebox, 0, sizeof(TSafeboxTable));
485. SQLResult * res = msg->Get();
487. if (res->uiNumRows == 0)
488. {
489. if (strcmp("000000", szSafeboxPassword))
490. {
491. pkPeer->EncodeHeader(HEADER_DG_SAFEBOX_WRONG_PASSWORD, dwHandle, 0);
492. delete pi;
493. return;
494. }
495. }
496. else
497. {
498. MYSQL_ROW row = mysql_fetch_row(res->pSQLResult);
500. // ºñ¹Ğ¹øÈ£°¡ Ʋ¸®¸é..
501. if (((!row[2] || !*row[2]) && strcmp("000000", szSafeboxPassword)) ||
502. ((row[2] && *row[2]) && strcmp(row[2], szSafeboxPassword)))
503. {
504. pkPeer->EncodeHeader(HEADER_DG_SAFEBOX_WRONG_PASSWORD, dwHandle, 0);
505. delete pi;
506. return;
507. }
509. if (!row[0])
510. pSafebox->dwID = 0;
511. else
512. str_to_number(pSafebox->dwID, row[0]);
514. if (!row[1])
515. pSafebox->bSize = 0;
516. else
517. str_to_number(pSafebox->bSize, row[1]);
518. /*
519. if (!row[3])
520. pSafebox->dwGold = 0;
521. else
522. pSafebox->dwGold = atoi(row[3]);
523. */
524. if (pi->ip[0] == 1)
525. {
526. pSafebox->bSize = 1;
527. sys_log(0, "MALL id[%d] size[%d]", pSafebox->dwID, pSafebox->bSize);
528. }
529. else
530. sys_log(0, "SAFEBOX id[%d] size[%d]", pSafebox->dwID, pSafebox->bSize);
531. }
533. if (0 == pSafebox->dwID)
534. pSafebox->dwID = pi->account_id;
536. pi->pSafebox = pSafebox;
538. char szQuery[512];
539. snprintf(szQuery, sizeof(szQuery),
540. "SELECT id, window+0, pos, count, vnum, socket0, socket1, socket2, "
541. "attrtype0, attrvalue0, "
542. "attrtype1, attrvalue1, "
543. "attrtype2, attrvalue2, "
544. "attrtype3, attrvalue3, "
545. "attrtype4, attrvalue4, "
546. "attrtype5, attrvalue5, "
547. "attrtype6, attrvalue6 "
548. "FROM item%s WHERE owner_id=%d AND window='%s'",
549. GetTablePostfix(), pi->account_id, pi->ip[0] == 0 ? "SAFEBOX" : "MALL");
551. pi->account_index = 1;
553. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_LOAD, pkPeer->GetHandle(), pi);
554. }
555. else
556. {
558. if (!pi->pSafebox)
559. {
560. sys_err("null safebox pointer!");
561. delete pi;
562. return;
563. }
566. // Äõ¸®¿¡ ¿¡·¯°¡ ÀÖ¾úÀ¸¹Ç·Î ÀÀ´äÇÒ °æ¿ì â°í°¡ ºñ¾îÀÖ´Â °Í ó·³
567. // º¸À̱⠶§¹®¿¡ â°í°¡ ¾Æ¾ê ¾È¿­¸®´Â°Ô ³ªÀ½
568. if (!msg->Get()->pSQLResult)
569. {
570. sys_err("null safebox result");
571. delete pi;
572. return;
573. }
575. static std::vector<TPlayerItem> s_items;
576. CreateItemTableFromRes(msg->Get()->pSQLResult, &s_items, pi->account_id);
578. std::set<TItemAward *> * pSet = ItemAwardManager::instance().GetByLogin(pi->login);
580. if (pSet && !m_vec_itemTable.empty())
581. {
583. CGrid grid(5, MAX(1, pi->pSafebox->bSize) * 9);
584. bool bEscape = false;
586. for (DWORD i = 0; i < s_items.size(); ++i)
587. {
588. TPlayerItem & r = s_items[i];
590. itertype(m_map_itemTableByVnum) it = m_map_itemTableByVnum.find(r.vnum);
592. if (it == m_map_itemTableByVnum.end())
593. {
594. bEscape = true;
595. sys_err("invalid item vnum %u in safebox: login %s", r.vnum, pi->login);
596. break;
597. }
599. grid.Put(r.pos, 1, it->second->bSize);
600. }
602. if (!bEscape)
603. {
604. std::vector<std::pair<DWORD, DWORD> > vec_dwFinishedAwardID;
606. typeof(pSet->begin()) it = pSet->begin();
608. char szQuery[512];
610. while (it != pSet->end())
611. {
612. TItemAward * pItemAward = *(it++);
613. const DWORD& dwItemVnum = pItemAward->dwVnum;
615. if (pItemAward->bTaken)
616. continue;
618. if (pi->ip[0] == 0 && pItemAward->bMall)
619. continue;
621. if (pi->ip[0] == 1 && !pItemAward->bMall)
622. continue;
624. itertype(m_map_itemTableByVnum) it = m_map_itemTableByVnum.find(pItemAward->dwVnum);
626. if (it == m_map_itemTableByVnum.end())
627. {
628. sys_err("invalid item vnum %u in item_award: login %s", pItemAward->dwVnum, pi->login);
629. continue;
630. }
632. TItemTable * pItemTable = it->second;
634. int iPos;
636. if ((iPos = grid.FindBlank(1, it->second->bSize)) == -1)
637. break;
639. TPlayerItem item;
640. memset(&item, 0, sizeof(TPlayerItem));
642. DWORD dwSocket2 = 0;
644. if (pItemTable->bType == ITEM_UNIQUE)
645. {
646. if (pItemAward->dwSocket2 != 0)
647. dwSocket2 = pItemAward->dwSocket2;
648. else
649. dwSocket2 = pItemTable->alValues[0];
650. }
651. else if ((dwItemVnum == 50300 || dwItemVnum == 70037) && pItemAward->dwSocket0 == 0)
652. {
653. DWORD dwSkillIdx;
654. DWORD dwSkillVnum;
656. do
657. {
658. dwSkillIdx = number(0, m_vec_skillTable.size()-1);
660. dwSkillVnum = m_vec_skillTable[dwSkillIdx].dwVnum;
662. if (!dwSkillVnum > 120)
663. continue;
665. break;
666. } while (1);
668. pItemAward->dwSocket0 = dwSkillVnum;
669. }
670. else
671. {
672. switch (dwItemVnum)
673. {
674. case 72723: case 72724: case 72725: case 72726:
675. case 72727: case 72728: case 72729: case 72730:
676. // ¹«½Ã¹«½ÃÇÏÁö¸¸ ÀÌÀü¿¡ ÇÏ´ø °É °íÄ¡±â´Â ¹«¼·°í...
677. // ±×·¡¼­ ±×³É Çϵå ÄÚµù. ¼±¹° »óÀÚ¿ë ÀÚµ¿¹°¾à ¾ÆÀÌÅÛµé.
678. case 76004: case 76005: case 76021: case 76022:
679. case 79012: case 79013:
680. if (pItemAward->dwSocket2 == 0)
681. {
682. dwSocket2 = pItemTable->alValues[0];
683. }
684. else
685. {
686. dwSocket2 = pItemAward->dwSocket2;
687. }
688. break;
689. }
690. }
692. if (GetItemID () > m_itemRange.dwMax)
693. {
694. sys_err("UNIQUE ID OVERFLOW!!");
695. break;
696. }
698. {
699. itertype(m_map_itemTableByVnum) it = m_map_itemTableByVnum.find (dwItemVnum);
700. if (it == m_map_itemTableByVnum.end())
701. {
702. sys_err ("Invalid item(vnum : %d). It is not in m_map_itemTableByVnum.", dwItemVnum);
703. continue;
704. }
705. TItemTable* item_table = it->second;
706. if (item_table == NULL)
707. {
708. sys_err ("Invalid item_table (vnum : %d). It's value is NULL in m_map_itemTableByVnum.", dwItemVnum);
709. continue;
710. }
711. if (0 == pItemAward->dwSocket0)
712. {
713. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; i++)
714. {
715. if (LIMIT_REAL_TIME == item_table->aLimits[i].bType)
716. {
717. if (0 == item_table->aLimits[i].lValue)
718. pItemAward->dwSocket0 = time(0) + 60 * 60 * 24 * 7;
719. else
720. pItemAward->dwSocket0 = time(0) + item_table->aLimits[i].lValue;
722. break;
723. }
724. else if (LIMIT_REAL_TIME_START_FIRST_USE == item_table->aLimits[i].bType || LIMIT_TIMER_BASED_ON_WEAR == item_table->aLimits[i].bType)
725. {
726. if (0 == item_table->aLimits[i].lValue)
727. pItemAward->dwSocket0 = 60 * 60 * 24 * 7;
728. else
729. pItemAward->dwSocket0 = item_table->aLimits[i].lValue;
731. break;
732. }
733. }
734. }
736. snprintf(szQuery, sizeof(szQuery),
737. "INSERT INTO item%s (id, owner_id, window, pos, vnum, count, socket0, socket1, socket2) "
738. "VALUES(%u, %u, '%s', %d, %u, %u, %u, %u, %u)",
739. GetTablePostfix(),
740. GainItemID(),
741. pi->account_id,
742. pi->ip[0] == 0 ? "SAFEBOX" : "MALL",
743. iPos,
744. pItemAward->dwVnum, pItemAward->dwCount, pItemAward->dwSocket0, pItemAward->dwSocket1, dwSocket2);
745. }
747. std::auto_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery));
748. SQLResult * pRes = pmsg->Get();
749. sys_log(0, "SAFEBOX Query : [%s]", szQuery);
751. if (pRes->uiAffectedRows == 0 || pRes->uiInsertID == 0 || pRes->uiAffectedRows == (uint32_t)-1)
752. break;
754. item.id = pmsg->Get()->uiInsertID;
755. item.window = pi->ip[0] == 0 ? SAFEBOX : MALL,
756. item.pos = iPos;
757. item.count = pItemAward->dwCount;
758. item.vnum = pItemAward->dwVnum;
759. item.alSockets[0] = pItemAward->dwSocket0;
760. item.alSockets[1] = pItemAward->dwSocket1;
761. item.alSockets[2] = dwSocket2;
762. s_items.push_back(item);
764. vec_dwFinishedAwardID.push_back(std::make_pair(pItemAward->dwID, item.id));
765. grid.Put(iPos, 1, it->second->bSize);
766. }
768. for (DWORD i = 0; i < vec_dwFinishedAwardID.size(); ++i)
769. ItemAwardManager::instance().Taken(vec_dwFinishedAwardID[i].first, vec_dwFinishedAwardID[i].second);
770. }
771. }
773. pi->pSafebox->wItemCount = s_items.size();
775. pkPeer->EncodeHeader(pi->ip[0] == 0 ? HEADER_DG_SAFEBOX_LOAD : HEADER_DG_MALL_LOAD, dwHandle, sizeof(TSafeboxTable) + sizeof(TPlayerItem) * s_items.size());
777. pkPeer->Encode(pi->pSafebox, sizeof(TSafeboxTable));
779. if (!s_items.empty())
780. pkPeer->Encode(&s_items[0], sizeof(TPlayerItem) * s_items.size());
782. delete pi;
783. }
784. }
786. void CClientManager::QUERY_SAFEBOX_CHANGE_SIZE(CPeer * pkPeer, DWORD dwHandle, TSafeboxChangeSizePacket * p)
787. {
788. ClientHandleInfo * pi = new ClientHandleInfo(dwHandle);
789. pi->account_index = p->bSize; // account_index¸¦ »çÀÌÁî·Î Àӽ÷Π»ç¿ë
791. char szQuery[QUERY_MAX_LEN];
793. if (p->bSize == 1)
794. snprintf(szQuery, sizeof(szQuery), "INSERT INTO safebox%s (account_id, size) VALUES(%u, %u)", GetTablePostfix(), p->dwID, p->bSize);
795. else
796. snprintf(szQuery, sizeof(szQuery), "UPDATE safebox%s SET size=%u WHERE account_id=%u", GetTablePostfix(), p->bSize, p->dwID);
798. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_CHANGE_SIZE, pkPeer->GetHandle(), pi);
799. }
801. void CClientManager::RESULT_SAFEBOX_CHANGE_SIZE(CPeer * pkPeer, SQLMsg * msg)
802. {
803. CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
804. ClientHandleInfo * p = (ClientHandleInfo *) qi->pvData;
805. DWORD dwHandle = p->dwHandle;
806. BYTE bSize = p->account_index;
808. delete p;
810. if (msg->Get()->uiNumRows > 0)
811. {
812. pkPeer->EncodeHeader(HEADER_DG_SAFEBOX_CHANGE_SIZE, dwHandle, sizeof(BYTE));
813. pkPeer->EncodeBYTE(bSize);
814. }
815. }
817. void CClientManager::QUERY_SAFEBOX_CHANGE_PASSWORD(CPeer * pkPeer, DWORD dwHandle, TSafeboxChangePasswordPacket * p)
818. {
819. ClientHandleInfo * pi = new ClientHandleInfo(dwHandle);
820. strlcpy(pi->safebox_password, p->szNewPassword, sizeof(pi->safebox_password));
821. strlcpy(pi->login, p->szOldPassword, sizeof(pi->login));
822. pi->account_id = p->dwID;
824. char szQuery[QUERY_MAX_LEN];
825. snprintf(szQuery, sizeof(szQuery), "SELECT password FROM safebox%s WHERE account_id=%u", GetTablePostfix(), p->dwID);
827. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_CHANGE_PASSWORD, pkPeer->GetHandle(), pi);
828. }
830. void CClientManager::RESULT_SAFEBOX_CHANGE_PASSWORD(CPeer * pkPeer, SQLMsg * msg)
831. {
832. CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
833. ClientHandleInfo * p = (ClientHandleInfo *) qi->pvData;
834. DWORD dwHandle = p->dwHandle;
836. if (msg->Get()->uiNumRows > 0)
837. {
838. MYSQL_ROW row = mysql_fetch_row(msg->Get()->pSQLResult);
840. if (row[0] && *row[0] && !strcasecmp(row[0], p->login) || (!row[0] || !*row[0]) && !strcmp("000000", p->login))
841. {
842. char szQuery[QUERY_MAX_LEN];
843. char escape_pwd[64];
844. CDBManager::instance().EscapeString(escape_pwd, p->safebox_password, strlen(p->safebox_password));
846. snprintf(szQuery, sizeof(szQuery), "UPDATE safebox%s SET password='%s' WHERE account_id=%u", GetTablePostfix(), escape_pwd, p->account_id);
848. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_CHANGE_PASSWORD_SECOND, pkPeer->GetHandle(), p);
849. return;
850. }
851. }
853. delete p;
855. // Wrong old password
856. pkPeer->EncodeHeader(HEADER_DG_SAFEBOX_CHANGE_PASSWORD_ANSWER, dwHandle, sizeof(BYTE));
857. pkPeer->EncodeBYTE(0);
858. }
860. void CClientManager::RESULT_SAFEBOX_CHANGE_PASSWORD_SECOND(CPeer * pkPeer, SQLMsg * msg)
861. {
862. CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
863. ClientHandleInfo * p = (ClientHandleInfo *) qi->pvData;
864. DWORD dwHandle = p->dwHandle;
865. delete p;
867. pkPeer->EncodeHeader(HEADER_DG_SAFEBOX_CHANGE_PASSWORD_ANSWER, dwHandle, sizeof(BYTE));
868. pkPeer->EncodeBYTE(1);
869. }
871. // MYSHOP_PRICE_LIST
872. void CClientManager::RESULT_PRICELIST_LOAD(CPeer* peer, SQLMsg* pMsg)
873. {
874. TItemPricelistReqInfo* pReqInfo = (TItemPricelistReqInfo*)static_cast<CQueryInfo*>(pMsg->pvUserData)->pvData;
876. //
877. // DB ¿¡¼­ ·ÎµåÇÑ Á¤º¸¸¦ Cache ¿¡ ÀúÀå
878. //
880. TItemPriceListTable table;
881. table.dwOwnerID = pReqInfo->second;
882. table.byCount = 0;
884. MYSQL_ROW row;
886. while ((row = mysql_fetch_row(pMsg->Get()->pSQLResult)))
887. {
888. str_to_number(table.aPriceInfo[table.byCount].dwVnum, row[0]);
889. str_to_number(table.aPriceInfo[table.byCount].dwPrice, row[1]);
890. table.byCount++;
891. }
893. PutItemPriceListCache(&table);
895. //
896. // ·ÎµåÇÑ µ¥ÀÌÅ͸¦ Game server ¿¡ Àü¼Û
897. //
899. TPacketMyshopPricelistHeader header;
901. header.dwOwnerID = pReqInfo->second;
902. header.byCount = table.byCount;
904. size_t sizePriceListSize = sizeof(TItemPriceInfo) * header.byCount;
906. peer->EncodeHeader(HEADER_DG_MYSHOP_PRICELIST_RES, pReqInfo->first, sizeof(header) + sizePriceListSize);
907. peer->Encode(&header, sizeof(header));
908. peer->Encode(table.aPriceInfo, sizePriceListSize);
910. sys_log(0, "Load MyShopPricelist handle[%d] pid[%d] count[%d]", pReqInfo->first, pReqInfo->second, header.byCount);
912. delete pReqInfo;
913. }
915. void CClientManager::RESULT_PRICELIST_LOAD_FOR_UPDATE(SQLMsg* pMsg)
916. {
917. TItemPriceListTable* pUpdateTable = (TItemPriceListTable*)static_cast<CQueryInfo*>(pMsg->pvUserData)->pvData;
919. //
920. // DB ¿¡¼­ ·ÎµåÇÑ Á¤º¸¸¦ Cache ¿¡ ÀúÀå
921. //
923. TItemPriceListTable table;
924. table.dwOwnerID = pUpdateTable->dwOwnerID;
925. table.byCount = 0;
927. MYSQL_ROW row;
929. while ((row = mysql_fetch_row(pMsg->Get()->pSQLResult)))
930. {
931. str_to_number(table.aPriceInfo[table.byCount].dwVnum, row[0]);
932. str_to_number(table.aPriceInfo[table.byCount].dwPrice, row[1]);
933. table.byCount++;
934. }
936. PutItemPriceListCache(&table);
938. // Update cache
939. GetItemPriceListCache(pUpdateTable->dwOwnerID)->UpdateList(pUpdateTable);
941. delete pUpdateTable;
942. }
943. // END_OF_MYSHOP_PRICE_LIST
945. void CClientManager::QUERY_SAFEBOX_SAVE(CPeer * pkPeer, TSafeboxTable * pTable)
946. {
947. char szQuery[QUERY_MAX_LEN];
949. snprintf(szQuery, sizeof(szQuery),
950. "UPDATE safebox%s SET gold='%u' WHERE account_id=%u",
951. GetTablePostfix(), pTable->dwGold, pTable->dwID);
953. CDBManager::instance().ReturnQuery(szQuery, QID_SAFEBOX_SAVE, pkPeer->GetHandle(), NULL);
954. }
956. void CClientManager::QUERY_EMPIRE_SELECT(CPeer * pkPeer, DWORD dwHandle, TEmpireSelectPacket * p)
957. {
958. char szQuery[QUERY_MAX_LEN];
960. snprintf(szQuery, sizeof(szQuery), "UPDATE player_index%s SET empire=%u WHERE id=%u", GetTablePostfix(), p->bEmpire, p->dwAccountID);
961. delete CDBManager::instance().DirectQuery(szQuery);
963. sys_log(0, "EmpireSelect: %s", szQuery);
964. {
965. snprintf(szQuery, sizeof(szQuery),
966. "SELECT pid1, pid2, pid3, pid4 FROM player_index%s WHERE id=%u", GetTablePostfix(), p->dwAccountID);
968. std::auto_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery));
970. SQLResult * pRes = pmsg->Get();
972. if (pRes->uiNumRows)
973. {
974. sys_log(0, "EMPIRE %lu", pRes->uiNumRows);
976. MYSQL_ROW row = mysql_fetch_row(pRes->pSQLResult);
977. DWORD pids[3];
979. UINT g_start_map[4] =
980. {
981. 0, // reserved
982. 1, // ½Å¼ö±¹
983. 21, // õÁ¶±¹
984. 41 // Áø³ë±¹
985. };
987. // FIXME share with game
988. DWORD g_start_position[4][2]=
989. {
990. { 0, 0 },
991. { 469300, 964200 }, // ½Å¼ö±¹
992. { 55700, 157900 }, // õÁ¶±¹
993. { 969600, 278400 } // Áø³ë±¹
994. };
996. for (int i = 0; i < 3; ++i)
997. {
998. str_to_number(pids[i], row[i]);
999. sys_log(0, "EMPIRE PIDS[%d]", pids[i]);
1001. if (pids[i])
1002. {
1003. sys_log(0, "EMPIRE move to pid[%d] to villiage of %u, map_index %d",
1004. pids[i], p->bEmpire, g_start_map[p->bEmpire]);
1006. snprintf(szQuery, sizeof(szQuery), "UPDATE player%s SET map_index=%u,x=%u,y=%u WHERE id=%u",
1007. GetTablePostfix(),
1008. g_start_map[p->bEmpire],
1009. g_start_position[p->bEmpire][0],
1010. g_start_position[p->bEmpire][1],
1011. pids[i]);
1013. std::auto_ptr<SQLMsg> pmsg2(CDBManager::instance().DirectQuery(szQuery));
1014. }
1015. }
1016. }
1017. }
1019. pkPeer->EncodeHeader(HEADER_DG_EMPIRE_SELECT, dwHandle, sizeof(BYTE));
1020. pkPeer->EncodeBYTE(p->bEmpire);
1021. }
1023. void CClientManager::QUERY_SETUP(CPeer * peer, DWORD dwHandle, const char * c_pData)
1024. {
1025. TPacketGDSetup * p = (TPacketGDSetup *) c_pData;
1026. c_pData += sizeof(TPacketGDSetup);
1028. if (p->bAuthServer)
1029. {
1030. sys_log(0, "AUTH_PEER ptr %p", peer);
1032. m_pkAuthPeer = peer;
1033. return;
1034. }
1036. peer->SetPublicIP(p->szPublicIP);
1037. peer->SetChannel(p->bChannel);
1038. peer->SetListenPort(p->wListenPort);
1039. peer->SetP2PPort(p->wP2PPort);
1040. peer->SetMaps(p->alMaps);
1042. //
1043. // ¾î¶² ¸ÊÀÌ ¾î¶² ¼­¹ö¿¡ ÀÖ´ÂÁö º¸³»±â
1044. //
1045. TMapLocation kMapLocations;
1047. strlcpy(kMapLocations.szHost, peer->GetPublicIP(), sizeof(kMapLocations.szHost));
1048. kMapLocations.wPort = peer->GetListenPort();
1049. thecore_memcpy(kMapLocations.alMaps, peer->GetMaps(), sizeof(kMapLocations.alMaps));
1051. BYTE bMapCount;
1053. std::vector<TMapLocation> vec_kMapLocations;
1055. if (peer->GetChannel() == 1)
1056. {
1057. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end(); ++i)
1058. {
1059. CPeer * tmp = *i;
1061. if (tmp == peer)
1062. continue;
1064. if (!tmp->GetChannel())
1065. continue;
1067. if (tmp->GetChannel() == GUILD_WARP_WAR_CHANNEL || tmp->GetChannel() == peer->GetChannel())
1068. {
1069. TMapLocation kMapLocation2;
1070. strlcpy(kMapLocation2.szHost, tmp->GetPublicIP(), sizeof(kMapLocation2.szHost));
1071. kMapLocation2.wPort = tmp->GetListenPort();
1072. thecore_memcpy(kMapLocation2.alMaps, tmp->GetMaps(), sizeof(kMapLocation2.alMaps));
1073. vec_kMapLocations.push_back(kMapLocation2);
1075. tmp->EncodeHeader(HEADER_DG_MAP_LOCATIONS, 0, sizeof(BYTE) + sizeof(TMapLocation));
1076. bMapCount = 1;
1077. tmp->EncodeBYTE(bMapCount);
1078. tmp->Encode(&kMapLocations, sizeof(TMapLocation));
1079. }
1080. }
1081. }
1082. else if (peer->GetChannel() == GUILD_WARP_WAR_CHANNEL)
1083. {
1084. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end(); ++i)
1085. {
1086. CPeer * tmp = *i;
1088. if (tmp == peer)
1089. continue;
1091. if (!tmp->GetChannel())
1092. continue;
1094. if (tmp->GetChannel() == 1 || tmp->GetChannel() == peer->GetChannel())
1095. {
1096. TMapLocation kMapLocation2;
1097. strlcpy(kMapLocation2.szHost, tmp->GetPublicIP(), sizeof(kMapLocation2.szHost));
1098. kMapLocation2.wPort = tmp->GetListenPort();
1099. thecore_memcpy(kMapLocation2.alMaps, tmp->GetMaps(), sizeof(kMapLocation2.alMaps));
1100. vec_kMapLocations.push_back(kMapLocation2);
1101. }
1103. tmp->EncodeHeader(HEADER_DG_MAP_LOCATIONS, 0, sizeof(BYTE) + sizeof(TMapLocation));
1104. bMapCount = 1;
1105. tmp->EncodeBYTE(bMapCount);
1106. tmp->Encode(&kMapLocations, sizeof(TMapLocation));
1107. }
1108. }
1109. else
1110. {
1111. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end(); ++i)
1112. {
1113. CPeer * tmp = *i;
1115. if (tmp == peer)
1116. continue;
1118. if (!tmp->GetChannel())
1119. continue;
1121. if (tmp->GetChannel() == GUILD_WARP_WAR_CHANNEL || tmp->GetChannel() == peer->GetChannel())
1122. {
1123. TMapLocation kMapLocation2;
1125. strlcpy(kMapLocation2.szHost, tmp->GetPublicIP(), sizeof(kMapLocation2.szHost));
1126. kMapLocation2.wPort = tmp->GetListenPort();
1127. thecore_memcpy(kMapLocation2.alMaps, tmp->GetMaps(), sizeof(kMapLocation2.alMaps));
1129. vec_kMapLocations.push_back(kMapLocation2);
1130. }
1132. if (tmp->GetChannel() == peer->GetChannel())
1133. {
1134. tmp->EncodeHeader(HEADER_DG_MAP_LOCATIONS, 0, sizeof(BYTE) + sizeof(TMapLocation));
1135. bMapCount = 1;
1136. tmp->EncodeBYTE(bMapCount);
1137. tmp->Encode(&kMapLocations, sizeof(TMapLocation));
1138. }
1139. }
1140. }
1142. vec_kMapLocations.push_back(kMapLocations);
1144. peer->EncodeHeader(HEADER_DG_MAP_LOCATIONS, 0, sizeof(BYTE) + sizeof(TMapLocation) * vec_kMapLocations.size());
1145. bMapCount = vec_kMapLocations.size();
1146. peer->EncodeBYTE(bMapCount);
1147. peer->Encode(&vec_kMapLocations[0], sizeof(TMapLocation) * vec_kMapLocations.size());
1149. //
1150. // ¼Â¾÷ : Á¢¼ÓÇÑ ÇǾ ´Ù¸¥ ÇǾîµéÀÌ Á¢¼ÓÇÏ°Ô ¸¸µç´Ù. (P2P ÄÁ³Ø¼Ç »ı¼º)
1151. //
1152. sys_log(0, "SETUP: channel %u listen %u p2p %u count %u", peer->GetChannel(), p->wListenPort, p->wP2PPort, bMapCount);
1154. TPacketDGP2P p2pSetupPacket;
1155. p2pSetupPacket.wPort = peer->GetP2PPort();
1156. p2pSetupPacket.bChannel = peer->GetChannel();
1157. strlcpy(p2pSetupPacket.szHost, peer->GetPublicIP(), sizeof(p2pSetupPacket.szHost));
1159. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end();++i)
1160. {
1161. CPeer * tmp = *i;
1163. if (tmp == peer)
1164. continue;
1166. // ä³ÎÀÌ 0À̶ó¸é ¾ÆÁ÷ SETUP ÆĞŶÀÌ ¿ÀÁö ¾ÊÀº ÇÇ¾î ¶Ç´Â auth¶ó°í °£ÁÖÇÒ ¼ö ÀÖÀ½
1167. if (0 == tmp->GetChannel())
1168. continue;
1170. tmp->EncodeHeader(HEADER_DG_P2P, 0, sizeof(TPacketDGP2P));
1171. tmp->Encode(&p2pSetupPacket, sizeof(TPacketDGP2P));
1172. }
1174. //
1175. // ·Î±×ÀÎ ¹× ºô¸µÁ¤º¸ º¸³»±â
1176. //
1177. TPacketLoginOnSetup * pck = (TPacketLoginOnSetup *) c_pData;;
1179. for (DWORD c = 0; c < p->dwLoginCount; ++c, ++pck)
1180. {
1181. CLoginData * pkLD = new CLoginData;
1183. pkLD->SetKey(pck->dwLoginKey);
1184. pkLD->SetClientKey(pck->adwClientKey);
1185. pkLD->SetIP(pck->szHost);
1187. TAccountTable & r = pkLD->GetAccountRef();
1189. r.id = pck->dwID;
1190. trim_and_lower(pck->szLogin, r.login, sizeof(r.login));
1191. strlcpy(r.social_id, pck->szSocialID, sizeof(r.social_id));
1192. strlcpy(r.passwd, "TEMP", sizeof(r.passwd));
1194. InsertLoginData(pkLD);
1196. if (InsertLogonAccount(pck->szLogin, peer->GetHandle(), pck->szHost))
1197. {
1198. sys_log(0, "SETUP: login %u %s login_key %u host %s", pck->dwID, pck->szLogin, pck->dwLoginKey, pck->szHost);
1199. pkLD->SetPlay(true);
1201. // if (m_pkAuthPeer)
1202. // {
1203. // pck_repair.dwLoginKey = pkLD->GetKey();
1204. // strlcpy(pck_repair.szLogin, pck->szLogin, sizeof(pck_repair.szLogin));
1205. // strlcpy(pck_repair.szHost, pck->szHost, sizeof(pck_repair.szHost));
1206. // vec_repair.push_back(pck_repair);
1207. // }
1208. }
1209. else
1210. sys_log(0, "SETUP: login_fail %u %s login_key %u", pck->dwID, pck->szLogin, pck->dwLoginKey);
1211. }
1213. // if (m_pkAuthPeer && !vec_repair.empty())
1214. // {
1215. // sys_log(0, "REPAIR size %d", vec_repair.size());
1216. // m_pkAuthPeer->EncodeDWORD(vec_repair.size());
1217. // }
1219. SendPartyOnSetup(peer);
1220. CGuildManager::instance().OnSetup(peer);
1221. CPrivManager::instance().SendPrivOnSetup(peer);
1222. SendEventFlagsOnSetup(peer);
1223. marriage::CManager::instance().OnSetup(peer);
1224. }
1226. void CClientManager::QUERY_ITEM_FLUSH(CPeer * pkPeer, const char * c_pData)
1227. {
1228. DWORD dwID = *(DWORD *) c_pData;
1230. if (g_log)
1231. sys_log(0, "HEADER_GD_ITEM_FLUSH: %u", dwID);
1233. CItemCache * c = GetItemCache(dwID);
1235. if (c)
1236. c->Flush();
1237. }
1239. void CClientManager::QUERY_ITEM_SAVE(CPeer * pkPeer, const char * c_pData)
1240. {
1241. TPlayerItem * p = (TPlayerItem *) c_pData;
1243. // â°í¸é ij½¬ÇÏÁö ¾Ê°í, ij½¬¿¡ ÀÖ´ø °Íµµ »©¹ö·Á¾ß ÇÑ´Ù.
1244. // auctionÀº ÀÌ ·çÆ®¸¦ ŸÁö ¾Ê¾Æ¾ß ÇÑ´Ù. EnrollInAuctionÀ» Ÿ¾ßÇÑ´Ù.
1246. if (p->window == SAFEBOX || p->window == MALL)
1247. {
1248. CItemCache * c = GetItemCache(p->id);
1250. if (c)
1251. {
1252. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(c->Get()->owner);
1254. if (it != m_map_pkItemCacheSetPtr.end())
1255. {
1256. if (g_test_server)
1257. sys_log(0, "ITEM_CACHE: safebox owner %u id %u", c->Get()->owner, c->Get()->id);
1259. it->second->erase(c);
1260. }
1262. m_map_itemCache.erase(p->id);
1264. delete c;
1265. }
1266. char szQuery[512];
1268. snprintf(szQuery, sizeof(szQuery),
1269. "REPLACE INTO item%s (id, owner_id, window, pos, count, vnum, socket0, socket1, socket2, "
1270. "attrtype0, attrvalue0, "
1271. "attrtype1, attrvalue1, "
1272. "attrtype2, attrvalue2, "
1273. "attrtype3, attrvalue3, "
1274. "attrtype4, attrvalue4, "
1275. "attrtype5, attrvalue5, "
1276. "attrtype6, attrvalue6) "
1277. "VALUES(%u, %u, %d, %d, %u, %u, %ld, %ld, %ld, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)",
1278. GetTablePostfix(),
1279. p->id,
1280. p->owner,
1281. p->window,
1282. p->pos,
1283. p->count,
1284. p->vnum,
1285. p->alSockets[0],
1286. p->alSockets[1],
1287. p->alSockets[2],
1288. p->aAttr[0].bType, p->aAttr[0].sValue,
1289. p->aAttr[1].bType, p->aAttr[1].sValue,
1290. p->aAttr[2].bType, p->aAttr[2].sValue,
1291. p->aAttr[3].bType, p->aAttr[3].sValue,
1292. p->aAttr[4].bType, p->aAttr[4].sValue,
1293. p->aAttr[5].bType, p->aAttr[5].sValue,
1294. p->aAttr[6].bType, p->aAttr[6].sValue);
1296. CDBManager::instance().ReturnQuery(szQuery, QID_ITEM_SAVE, pkPeer->GetHandle(), NULL);
1297. }
1299. else
1300. {
1301. if (g_test_server)
1302. sys_log(0, "QUERY_ITEM_SAVE => PutItemCache() owner %d id %d vnum %d ", p->owner, p->id, p->vnum);
1304. PutItemCache(p);
1305. }
1306. }
1308. CClientManager::TItemCacheSet * CClientManager::GetItemCacheSet(DWORD pid)
1309. {
1310. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(pid);
1312. if (it == m_map_pkItemCacheSetPtr.end())
1313. return NULL;
1315. return it->second;
1316. }
1318. void CClientManager::CreateItemCacheSet(DWORD pid)
1319. {
1320. if (m_map_pkItemCacheSetPtr.find(pid) != m_map_pkItemCacheSetPtr.end())
1321. return;
1323. TItemCacheSet * pSet = new TItemCacheSet;
1324. m_map_pkItemCacheSetPtr.insert(TItemCacheSetPtrMap::value_type(pid, pSet));
1326. if (g_log)
1327. sys_log(0, "ITEM_CACHE: new cache %u", pid);
1328. }
1330. void CClientManager::FlushItemCacheSet(DWORD pid)
1331. {
1332. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(pid);
1334. if (it == m_map_pkItemCacheSetPtr.end())
1335. {
1336. sys_log(0, "FLUSH_ITEMCACHESET : No ItemCacheSet pid(%d)", pid);
1337. return;
1338. }
1340. TItemCacheSet * pSet = it->second;
1341. TItemCacheSet::iterator it_set = pSet->begin();
1343. while (it_set != pSet->end())
1344. {
1345. CItemCache * c = *it_set++;
1346. c->Flush();
1348. m_map_itemCache.erase(c->Get()->id);
1349. delete c;
1350. }
1352. pSet->clear();
1353. delete pSet;
1355. m_map_pkItemCacheSetPtr.erase(it);
1357. if (g_log)
1358. sys_log(0, "FLUSH_ITEMCACHESET : Deleted pid(%d)", pid);
1359. }
1361. CItemCache * CClientManager::GetItemCache(DWORD id)
1362. {
1363. TItemCacheMap::iterator it = m_map_itemCache.find(id);
1365. if (it == m_map_itemCache.end())
1366. return NULL;
1368. return it->second;
1369. }
1371. void CClientManager::PutItemCache(TPlayerItem * pNew, bool bSkipQuery)
1372. {
1373. CItemCache * c;
1375. c = GetItemCache(pNew->id);
1377. // ¾ÆÀÌÅÛ »õ·Î »ı¼º
1378. if (!c)
1379. {
1380. if (g_log)
1381. sys_log(0, "ITEM_CACHE: PutItemCache ==> New CItemCache id%d vnum%d new owner%d", pNew->id, pNew->vnum, pNew->owner);
1383. c = new CItemCache;
1384. m_map_itemCache.insert(TItemCacheMap::value_type(pNew->id, c));
1385. }
1386. // ÀÖÀ»½Ã
1387. else
1388. {
1389. if (g_log)
1390. sys_log(0, "ITEM_CACHE: PutItemCache ==> Have Cache");
1391. // ¼ÒÀ¯ÀÚ°¡ Ʋ¸®¸é
1392. if (pNew->owner != c->Get()->owner)
1393. {
1394. // ÀÌ¹Ì ÀÌ ¾ÆÀÌÅÛÀ» °¡Áö°í ÀÖ¾ú´ø À¯Àú·Î ºÎÅÍ ¾ÆÀÌÅÛÀ» »èÁ¦ÇÑ´Ù.
1395. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(c->Get()->owner);
1397. if (it != m_map_pkItemCacheSetPtr.end())
1398. {
1399. if (g_log)
1400. sys_log(0, "ITEM_CACHE: delete owner %u id %u new owner %u", c->Get()->owner, c->Get()->id, pNew->owner);
1401. it->second->erase(c);
1402. }
1403. }
1404. }
1406. // »õ·Î¿î Á¤º¸ ¾÷µ¥ÀÌÆ®
1407. c->Put(pNew, bSkipQuery);
1409. TItemCacheSetPtrMap::iterator it = m_map_pkItemCacheSetPtr.find(c->Get()->owner);
1411. if (it != m_map_pkItemCacheSetPtr.end())
1412. {
1413. if (g_log)
1414. sys_log(0, "ITEM_CACHE: save %u id %u", c->Get()->owner, c->Get()->id);
1415. else
1416. sys_log(1, "ITEM_CACHE: save %u id %u", c->Get()->owner, c->Get()->id);
1417. it->second->insert(c);
1418. }
1419. else
1420. {
1421. // ÇöÀç ¼ÒÀ¯ÀÚ°¡ ¾øÀ¸¹Ç·Î ¹Ù·Î ÀúÀåÇØ¾ß ´ÙÀ½ Á¢¼ÓÀÌ ¿Ã ¶§ SQL¿¡ Äõ¸®ÇÏ¿©
1422. // ¹ŞÀ» ¼ö ÀÖÀ¸¹Ç·Î ¹Ù·Î ÀúÀåÇÑ´Ù.
1423. if (g_log)
1424. sys_log(0, "ITEM_CACHE: direct save %u id %u", c->Get()->owner, c->Get()->id);
1425. else
1426. sys_log(1, "ITEM_CACHE: direct save %u id %u", c->Get()->owner, c->Get()->id);
1428. c->OnFlush();
1429. }
1430. }
1432. bool CClientManager::DeleteItemCache(DWORD dwID)
1433. {
1434. CItemCache * c = GetItemCache(dwID);
1436. if (!c)
1437. return false;
1439. c->Delete();
1440. return true;
1441. }
1443. // MYSHOP_PRICE_LIST
1444. CItemPriceListTableCache* CClientManager::GetItemPriceListCache(DWORD dwID)
1445. {
1446. TItemPriceListCacheMap::iterator it = m_mapItemPriceListCache.find(dwID);
1448. if (it == m_mapItemPriceListCache.end())
1449. return NULL;
1451. return it->second;
1452. }
1454. void CClientManager::PutItemPriceListCache(const TItemPriceListTable* pItemPriceList)
1455. {
1456. CItemPriceListTableCache* pCache = GetItemPriceListCache(pItemPriceList->dwOwnerID);
1458. if (!pCache)
1459. {
1460. pCache = new CItemPriceListTableCache;
1461. m_mapItemPriceListCache.insert(TItemPriceListCacheMap::value_type(pItemPriceList->dwOwnerID, pCache));
1462. }
1464. pCache->Put(const_cast<TItemPriceListTable*>(pItemPriceList), true);
1465. }
1467. void CClientManager::UpdatePlayerCache()
1468. {
1469. TPlayerTableCacheMap::iterator it = m_map_playerCache.begin();
1471. while (it != m_map_playerCache.end())
1472. {
1473. CPlayerTableCache * c = (it++)->second;
1475. if (c->CheckTimeout())
1476. {
1477. if (g_log)
1478. sys_log(0, "UPDATE : UpdatePlayerCache() ==> FlushPlayerCache %d %s ", c->Get(false)->id, c->Get(false)->name);
1480. c->Flush();
1482. // Item Cacheµµ ¾÷µ¥ÀÌÆ®
1483. UpdateItemCacheSet(c->Get()->id);
1484. }
1485. else if (c->CheckFlushTimeout())
1486. c->Flush();
1487. }
1488. }
1489. // END_OF_MYSHOP_PRICE_LIST
1491. void CClientManager::SetCacheFlushCountLimit(int iLimit)
1492. {
1493. m_iCacheFlushCountLimit = MAX(10, iLimit);
1494. sys_log(0, "CACHE_FLUSH_LIMIT_PER_SECOND: %d", m_iCacheFlushCountLimit);
1495. }
1497. void CClientManager::UpdateItemCache()
1498. {
1499. if (m_iCacheFlushCount >= m_iCacheFlushCountLimit)
1500. return;
1502. TItemCacheMap::iterator it = m_map_itemCache.begin();
1504. while (it != m_map_itemCache.end())
1505. {
1506. CItemCache * c = (it++)->second;
1508. // ¾ÆÀÌÅÛÀº Flush¸¸ ÇÑ´Ù.
1509. if (c->CheckFlushTimeout())
1510. {
1511. if (g_test_server)
1512. sys_log(0, "UpdateItemCache ==> Flush() vnum %d id owner %d", c->Get()->vnum, c->Get()->id, c->Get()->owner);
1514. c->Flush();
1516. if (++m_iCacheFlushCount >= m_iCacheFlushCountLimit)
1517. break;
1518. }
1519. }
1520. }
1522. void CClientManager::UpdateItemPriceListCache()
1523. {
1524. TItemPriceListCacheMap::iterator it = m_mapItemPriceListCache.begin();
1526. while (it != m_mapItemPriceListCache.end())
1527. {
1528. CItemPriceListTableCache* pCache = it->second;
1530. if (pCache->CheckFlushTimeout())
1531. {
1532. pCache->Flush();
1533. m_mapItemPriceListCache.erase(it++);
1534. }
1535. else
1536. ++it;
1537. }
1538. }
1540. void CClientManager::QUERY_ITEM_DESTROY(CPeer * pkPeer, const char * c_pData)
1541. {
1542. DWORD dwID = *(DWORD *) c_pData;
1543. c_pData += sizeof(DWORD);
1545. DWORD dwPID = *(DWORD *) c_pData;
1547. if (!DeleteItemCache(dwID))
1548. {
1549. char szQuery[64];
1550. snprintf(szQuery, sizeof(szQuery), "DELETE FROM item%s WHERE id=%u", GetTablePostfix(), dwID);
1552. if (g_log)
1553. sys_log(0, "HEADER_GD_ITEM_DESTROY: PID %u ID %u", dwPID, dwID);
1555. if (dwPID == 0) // ¾Æ¹«µµ °¡Áø »ç¶÷ÀÌ ¾ø¾ú´Ù¸é, ºñµ¿±â Äõ¸®
1556. CDBManager::instance().AsyncQuery(szQuery);
1557. else
1558. CDBManager::instance().ReturnQuery(szQuery, QID_ITEM_DESTROY, pkPeer->GetHandle(), NULL);
1559. }
1560. }
1562. void CClientManager::QUERY_FLUSH_CACHE(CPeer * pkPeer, const char * c_pData)
1563. {
1564. DWORD dwPID = *(DWORD *) c_pData;
1566. CPlayerTableCache * pkCache = GetPlayerCache(dwPID);
1568. if (!pkCache)
1569. return;
1571. sys_log(0, "FLUSH_CACHE: %u", dwPID);
1573. pkCache->Flush();
1574. FlushItemCacheSet(dwPID);
1576. m_map_playerCache.erase(dwPID);
1577. delete pkCache;
1578. }
1580. void CClientManager::QUERY_SMS(CPeer * pkPeer, TPacketGDSMS * pack)
1581. {
1582. char szQuery[QUERY_MAX_LEN];
1584. char szMsg[256+1];
1585. //unsigned long len = CDBManager::instance().EscapeString(szMsg, pack->szMsg, strlen(pack->szMsg), SQL_ACCOUNT);
1586. unsigned long len = CDBManager::instance().EscapeString(szMsg, pack->szMsg, strlen(pack->szMsg));
1587. szMsg[len] = '\0';
1589. snprintf(szQuery, sizeof(szQuery),
1590. "INSERT INTO sms_pool (server, sender, receiver, mobile, msg) VALUES(%d, '%s', '%s', '%s', '%s')",
1591. (m_iPlayerIDStart + 2) / 3, pack->szFrom, pack->szTo, pack->szMobile, szMsg);
1593. CDBManager::instance().AsyncQuery(szQuery);
1594. }
1596. void CClientManager::QUERY_RELOAD_PROTO()
1597. {
1598. if (!InitializeTables())
1599. {
1600. sys_err("QUERY_RELOAD_PROTO: cannot load tables");
1601. return;
1602. }
1604. for (TPeerList::iterator i = m_peerList.begin(); i != m_peerList.end(); ++i)
1605. {
1606. CPeer * tmp = *i;
1608. if (!tmp->GetChannel())
1609. continue;
1611. tmp->EncodeHeader(HEADER_DG_RELOAD_PROTO, 0,
1612. sizeof(WORD) + sizeof(TSkillTable) * m_vec_skillTable.size() +
1613. sizeof(WORD) + sizeof(TBanwordTable) * m_vec_banwordTable.size() +
1614. sizeof(WORD) + sizeof(TItemTable) * m_vec_itemTable.size() +
1615. sizeof(WORD) + sizeof(TMobTable) * m_vec_mobTable.size());
1617. tmp->EncodeWORD(m_vec_skillTable.size());
1618. tmp->Encode(&m_vec_skillTable[0], sizeof(TSkillTable) * m_vec_skillTable.size());
1620. tmp->EncodeWORD(m_vec_banwordTable.size());
1621. tmp->Encode(&m_vec_banwordTable[0], sizeof(TBanwordTable) * m_vec_banwordTable.size());
1623. tmp->EncodeWORD(m_vec_itemTable.size());
1624. tmp->Encode(&m_vec_itemTable[0], sizeof(TItemTable) * m_vec_itemTable.size());
1626. tmp->EncodeWORD(m_vec_mobTable.size());
1627. tmp->Encode(&m_vec_mobTable[0], sizeof(TMobTable) * m_vec_mobTable.size());
1628. }
1629. }
1631. // ADD_GUILD_PRIV_TIME
1632. /**
1633. * @version 05/06/08 Bang2ni - Áö¼Ó½Ã°£ Ãß°¡
1634. */
1635. void CClientManager::AddGuildPriv(TPacketGiveGuildPriv* p)
1636. {
1637. CPrivManager::instance().AddGuildPriv(p->guild_id, p->type, p->value, p->duration_sec);
1638. }
1640. void CClientManager::AddEmpirePriv(TPacketGiveEmpirePriv* p)
1641. {
1642. CPrivManager::instance().AddEmpirePriv(p->empire, p->type, p->value, p->duration_sec);
1643. }
1644. // END_OF_ADD_GUILD_PRIV_TIME
1646. void CClientManager::AddCharacterPriv(TPacketGiveCharacterPriv* p)
1647. {
1648. CPrivManager::instance().AddCharPriv(p->pid, p->type, p->value);
1649. }
1651. void CClientManager::MoneyLog(TPacketMoneyLog* p)
1652. {
1653. CMoneyLog::instance().AddLog(p->type, p->vnum, p->gold);
1654. }
1656. CLoginData * CClientManager::GetLoginData(DWORD dwKey)
1657. {
1658. TLoginDataByLoginKey::iterator it = m_map_pkLoginData.find(dwKey);
1660. if (it == m_map_pkLoginData.end())
1661. return NULL;
1663. return it->second;
1664. }
1666. CLoginData * CClientManager::GetLoginDataByLogin(const char * c_pszLogin)
1667. {
1668. char szLogin[LOGIN_MAX_LEN + 1];
1669. trim_and_lower(c_pszLogin, szLogin, sizeof(szLogin));
1671. TLoginDataByLogin::iterator it = m_map_pkLoginDataByLogin.find(szLogin);
1673. if (it == m_map_pkLoginDataByLogin.end())
1674. return NULL;
1676. return it->second;
1677. }
1679. CLoginData * CClientManager::GetLoginDataByAID(DWORD dwAID)
1680. {
1681. TLoginDataByAID::iterator it = m_map_pkLoginDataByAID.find(dwAID);
1683. if (it == m_map_pkLoginDataByAID.end())
1684. return NULL;
1686. return it->second;
1687. }
1689. void CClientManager::InsertLoginData(CLoginData * pkLD)
1690. {
1691. char szLogin[LOGIN_MAX_LEN + 1];
1692. trim_and_lower(pkLD->GetAccountRef().login, szLogin, sizeof(szLogin));
1694. m_map_pkLoginData.insert(std::make_pair(pkLD->GetKey(), pkLD));
1695. m_map_pkLoginDataByLogin.insert(std::make_pair(szLogin, pkLD));
1696. m_map_pkLoginDataByAID.insert(std::make_pair(pkLD->GetAccountRef().id, pkLD));
1697. }
1699. void CClientManager::DeleteLoginData(CLoginData * pkLD)
1700. {
1701. m_map_pkLoginData.erase(pkLD->GetKey());
1702. m_map_pkLoginDataByLogin.erase(pkLD->GetAccountRef().login);
1703. m_map_pkLoginDataByAID.erase(pkLD->GetAccountRef().id);
1705. if (m_map_kLogonAccount.find(pkLD->GetAccountRef().login) == m_map_kLogonAccount.end())
1706. delete pkLD;
1707. else
1708. pkLD->SetDeleted(true);
1709. }
1711. void CClientManager::QUERY_AUTH_LOGIN(CPeer * pkPeer, DWORD dwHandle, TPacketGDAuthLogin * p)
1712. {
1713. if (g_test_server)
1714. sys_log(0, "QUERY_AUTH_LOGIN %d %d %s", p->dwID, p->dwLoginKey, p->szLogin);
1715. CLoginData * pkLD = GetLoginDataByLogin(p->szLogin);
1717. if (pkLD)
1718. {
1719. DeleteLoginData(pkLD);
1720. }
1722. BYTE bResult;
1724. if (GetLoginData(p->dwLoginKey))
1725. {
1726. sys_err("LoginData already exist key %u login %s", p->dwLoginKey, p->szLogin);
1727. bResult = 0;
1729. pkPeer->EncodeHeader(HEADER_DG_AUTH_LOGIN, dwHandle, sizeof(BYTE));
1730. pkPeer->EncodeBYTE(bResult);
1731. }
1732. else
1733. {
1734. CLoginData * pkLD = new CLoginData;
1736. pkLD->SetKey(p->dwLoginKey);
1737. pkLD->SetClientKey(p->adwClientKey);
1738. pkLD->SetPremium(p->iPremiumTimes);
1740. TAccountTable & r = pkLD->GetAccountRef();
1742. r.id = p->dwID;
1743. trim_and_lower(p->szLogin, r.login, sizeof(r.login));
1744. strlcpy(r.social_id, p->szSocialID, sizeof(r.social_id));
1745. strlcpy(r.passwd, "TEMP", sizeof(r.passwd));
1747. sys_log(0, "AUTH_LOGIN id(%u) login(%s) social_id(%s) login_key(%u), client_key(%u %u %u %u)",
1748. p->dwID, p->szLogin, p->szSocialID, p->dwLoginKey,
1749. p->adwClientKey[0], p->adwClientKey[1], p->adwClientKey[2], p->adwClientKey[3]);
1751. bResult = 1;
1753. InsertLoginData(pkLD);
1755. pkPeer->EncodeHeader(HEADER_DG_AUTH_LOGIN, dwHandle, sizeof(BYTE));
1756. pkPeer->EncodeBYTE(bResult);
1757. }
1758. }
1760. void CClientManager::GuildDepositMoney(TPacketGDGuildMoney* p)
1761. {
1762. CGuildManager::instance().DepositMoney(p->dwGuild, p->iGold);
1763. }
1765. void CClientManager::GuildWithdrawMoney(CPeer* peer, TPacketGDGuildMoney* p)
1766. {
1767. CGuildManager::instance().WithdrawMoney(peer, p->dwGuild, p->iGold);
1768. }
1770. void CClientManager::GuildWithdrawMoneyGiveReply(TPacketGDGuildMoneyWithdrawGiveReply* p)
1771. {
1772. CGuildManager::instance().WithdrawMoneyReply(p->dwGuild, p->bGiveSuccess, p->iChangeGold);
1773. }
1775. void CClientManager::GuildWarBet(TPacketGDGuildWarBet * p)
1776. {
1777. CGuildManager::instance().Bet(p->dwWarID, p->szLogin, p->dwGold, p->dwGuild);
1778. }
1780. void CClientManager::CreateObject(TPacketGDCreateObject * p)
1781. {
1782. using namespace building;
1784. char szQuery[512];
1786. snprintf(szQuery, sizeof(szQuery),
1787. "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)",
1788. GetTablePostfix(), p->dwLandID, p->dwVnum, p->lMapIndex, p->x, p->y, p->xRot, p->yRot, p->zRot);
1790. std::auto_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery));
1792. if (pmsg->Get()->uiInsertID == 0)
1793. {
1794. sys_err("cannot insert object");
1795. return;
1796. }
1798. TObject * pkObj = new TObject;
1800. memset(pkObj, 0, sizeof(TObject));
1802. pkObj->dwID = pmsg->Get()->uiInsertID;
1803. pkObj->dwVnum = p->dwVnum;
1804. pkObj->dwLandID = p->dwLandID;
1805. pkObj->lMapIndex = p->lMapIndex;
1806. pkObj->x = p->x;
1807. pkObj->y = p->y;
1808. pkObj->xRot = p->xRot;
1809. pkObj->yRot = p->yRot;
1810. pkObj->zRot = p->zRot;
1811. pkObj->lLife = 0;
1813. ForwardPacket(HEADER_DG_CREATE_OBJECT, pkObj, sizeof(TObject));
1815. m_map_pkObjectTable.insert(std::make_pair(pkObj->dwID, pkObj));
1816. }
1818. void CClientManager::DeleteObject(DWORD dwID)
1819. {
1820. char szQuery[128];
1822. snprintf(szQuery, sizeof(szQuery), "DELETE FROM object%s WHERE id=%u", GetTablePostfix(), dwID);
1824. std::auto_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery));
1826. if (pmsg->Get()->uiAffectedRows == 0 || pmsg->Get()->uiAffectedRows == (uint32_t)-1)
1827. {
1828. sys_err("no object by id %u", dwID);
1829. return;
1830. }
1832. itertype(m_map_pkObjectTable) it = m_map_pkObjectTable.find(dwID);
1834. if (it != m_map_pkObjectTable.end())
1835. {
1836. delete it->second;
1837. m_map_pkObjectTable.erase(it);
1838. }
1840. ForwardPacket(HEADER_DG_DELETE_OBJECT, &dwID, sizeof(DWORD));
1841. }
1843. void CClientManager::UpdateLand(DWORD * pdw)
1844. {
1845. DWORD dwID = pdw[0];
1846. DWORD dwGuild = pdw[1];
1848. building::TLand * p = &m_vec_kLandTable[0];
1850. DWORD i;
1852. for (i = 0; i < m_vec_kLandTable.size(); ++i, ++p)
1853. {
1854. if (p->dwID == dwID)
1855. {
1856. char buf[256];
1857. snprintf(buf, sizeof(buf), "UPDATE land%s SET guild_id=%u WHERE id=%u", GetTablePostfix(), dwGuild, dwID);
1858. CDBManager::instance().AsyncQuery(buf);
1860. p->dwGuildID = dwGuild;
1861. break;
1862. }
1863. }
1865. if (i < m_vec_kLandTable.size())
1866. ForwardPacket(HEADER_DG_UPDATE_LAND, p, sizeof(building::TLand));
1867. }
1873. // BLOCK_CHAT
1874. void CClientManager::BlockChat(TPacketBlockChat* p)
1875. {
1876. char szQuery[256];
1878. if (g_stLocale == "sjis")
1879. snprintf(szQuery, sizeof(szQuery), "SELECT id FROM player%s WHERE name = '%s' collate sjis_japanese_ci", GetTablePostfix(), p->szName);
1880. else
1881. snprintf(szQuery, sizeof(szQuery), "SELECT id FROM player%s WHERE name = '%s'", GetTablePostfix(), p->szName);
1882. std::auto_ptr<SQLMsg> pmsg(CDBManager::instance().DirectQuery(szQuery));
1883. SQLResult * pRes = pmsg->Get();
1885. if (pRes->uiNumRows)
1886. {
1887. MYSQL_ROW row = mysql_fetch_row(pRes->pSQLResult);
1888. DWORD pid = strtoul(row[0], NULL, 10);
1890. TPacketGDAddAffect pa;
1891. pa.dwPID = pid;
1892. pa.elem.dwType = 223;
1893. pa.elem.bApplyOn = 0;
1894. pa.elem.lApplyValue = 0;
1895. pa.elem.dwFlag = 0;
1896. pa.elem.lDuration = p->lDuration;
1897. pa.elem.lSPCost = 0;
1898. QUERY_ADD_AFFECT(NULL, &pa);
1899. }
1900. else
1901. {
1902. // cannot find user with that name
1903. }
1904. }
1905. // END_OF_BLOCK_CHAT
1907. void CClientManager::MarriageAdd(TPacketMarriageAdd * p)
1908. {
1909. sys_log(0, "MarriageAdd %u %u %s %s", p->dwPID1, p->dwPID2, p->szName1, p->szName2);
1910. marriage::CManager::instance().Add(p->dwPID1, p->dwPID2, p->szName1, p->szName2);
1911. }
1913. void CClientManager::MarriageUpdate(TPacketMarriageUpdate * p)
1914. {
1915. sys_log(0, "MarriageUpdate PID:%u %u LP:%d ST:%d", p->dwPID1, p->dwPID2, p->iLovePoint, p->byMarried);
1916. marriage::CManager::instance().Update(p->dwPID1, p->dwPID2, p->iLovePoint, p->byMarried);
1917. }
1919. void CClientManager::MarriageRemove(TPacketMarriageRemove * p)
1920. {
1921. sys_log(0, "MarriageRemove %u %u", p->dwPID1, p->dwPID2);
1922. marriage::CManager::instance().Remove(p->dwPID1, p->dwPID2);
1923. }
1925. void CClientManager::WeddingRequest(TPacketWeddingRequest * p)
1926. {
1927. sys_log(0, "WeddingRequest %u %u", p->dwPID1, p->dwPID2);
1928. ForwardPacket(HEADER_DG_WEDDING_REQUEST, p, sizeof(TPacketWeddingRequest));
1929. //marriage::CManager::instance().RegisterWedding(p->dwPID1, p->szName1, p->dwPID2, p->szName2);
1930. }
1932. void CClientManager::WeddingReady(TPacketWeddingReady * p)
1933. {
1934. sys_log(0, "WeddingReady %u %u", p->dwPID1, p->dwPID2);
1935. ForwardPacket(HEADER_DG_WEDDING_READY, p, sizeof(TPacketWeddingReady));
1936. marriage::CManager::instance().ReadyWedding(p->dwMapIndex, p->dwPID1, p->dwPID2);
1937. }
1939. void CClientManager::WeddingEnd(TPacketWeddingEnd * p)
1940. {
1941. sys_log(0, "WeddingEnd %u %u", p->dwPID1, p->dwPID2);
1942. marriage::CManager::instance().EndWedding(p->dwPID1, p->dwPID2);
1943. }
1945. //
1946. // ij½Ã¿¡ °¡°İÁ¤º¸°¡ ÀÖÀ¸¸é ij½Ã¸¦ ¾÷µ¥ÀÌÆ® ÇÏ°í ij½Ã¿¡ °¡°İÁ¤º¸°¡ ¾ø´Ù¸é
1947. // ¿ì¼± ±âÁ¸ÀÇ µ¥ÀÌÅ͸¦ ·ÎµåÇÑ µÚ¿¡ ±âÁ¸ÀÇ Á¤º¸·Î ij½Ã¸¦ ¸¸µé°í »õ·Î ¹ŞÀº °¡°İÁ¤º¸¸¦ ¾÷µ¥ÀÌÆ® ÇÑ´Ù.
1948. //
1949. void CClientManager::MyshopPricelistUpdate(const TPacketMyshopPricelistHeader* pPacket)
1950. {
1951. if (pPacket->byCount > SHOP_PRICELIST_MAX_NUM)
1952. {
1953. sys_err("count overflow!");
1954. return;
1955. }
1957. CItemPriceListTableCache* pCache = GetItemPriceListCache(pPacket->dwOwnerID);
1959. if (pCache)
1960. {
1961. TItemPriceListTable table;
1963. table.dwOwnerID = pPacket->dwOwnerID;
1964. table.byCount = pPacket->byCount;
1966. const TItemPriceInfo * pInfo = reinterpret_cast<const TItemPriceInfo*>(pPacket + sizeof(TPacketMyshopPricelistHeader));
1967. thecore_memcpy(table.aPriceInfo, pInfo, sizeof(TItemPriceInfo) * pPacket->byCount);
1969. pCache->UpdateList(&table);
1970. }
1971. else
1972. {
1973. TItemPriceListTable* pUpdateTable = new TItemPriceListTable;
1975. pUpdateTable->dwOwnerID = pPacket->dwOwnerID;
1976. pUpdateTable->byCount = pPacket->byCount;
1978. const TItemPriceInfo * pInfo = reinterpret_cast<const TItemPriceInfo*>(pPacket + sizeof(TPacketMyshopPricelistHeader));
1979. thecore_memcpy(pUpdateTable->aPriceInfo, pInfo, sizeof(TItemPriceInfo) * pPacket->byCount);
1981. char szQuery[QUERY_MAX_LEN];
1982. snprintf(szQuery, sizeof(szQuery), "SELECT item_vnum, price FROM myshop_pricelist%s WHERE owner_id=%u", GetTablePostfix(), pPacket->dwOwnerID);
1983. CDBManager::instance().ReturnQuery(szQuery, QID_ITEMPRICE_LOAD_FOR_UPDATE, 0, pUpdateTable);
1984. }
1985. }
1987. // MYSHOP_PRICE_LIST
1988. // ij½ÃµÈ °¡°İÁ¤º¸°¡ ÀÖÀ¸¸é ij½Ã¸¦ ÀĞ¾î ¹Ù·Î Àü¼ÛÇÏ°í ij½Ã¿¡ Á¤º¸°¡ ¾øÀ¸¸é DB ¿¡ Äõ¸®¸¦ ÇÑ´Ù.
1989. //
1990. void CClientManager::MyshopPricelistRequest(CPeer* peer, DWORD dwHandle, DWORD dwPlayerID)
1991. {
1992. if (CItemPriceListTableCache* pCache = GetItemPriceListCache(dwPlayerID))
1993. {
1994. sys_log(0, "Cache MyShopPricelist handle[%d] pid[%d]", dwHandle, dwPlayerID);
1996. TItemPriceListTable* pTable = pCache->Get(false);
1998. TPacketMyshopPricelistHeader header =
1999. {
2000. pTable->dwOwnerID,
2001. pTable->byCount
2002. };
2004. size_t sizePriceListSize = sizeof(TItemPriceInfo) * pTable->byCount;
2006. peer->EncodeHeader(HEADER_DG_MYSHOP_PRICELIST_RES, dwHandle, sizeof(header) + sizePriceListSize);
2007. peer->Encode(&header, sizeof(header));
2008. peer->Encode(pTable->aPriceInfo, sizePriceListSize);
2010. }
2011. else
2012. {
2013. sys_log(0, "Query MyShopPricelist handle[%d] pid[%d]", dwHandle, dwPlayerID);
2015. char szQuery[QUERY_MAX_LEN];
2016. snprintf(szQuery, sizeof(szQuery), "SELECT item_vnum, price FROM myshop_pricelist%s WHERE owner_id=%u", GetTablePostfix(), dwPlayerID);
2017. CDBManager::instance().ReturnQuery(szQuery, QID_ITEMPRICE_LOAD, peer->GetHandle(), new TItemPricelistReqInfo(dwHandle, dwPlayerID));
2018. }
2019. }
2020. // END_OF_MYSHOP_PRICE_LIST
2022. void CPacketInfo::Add(int header)
2023. {
2024. itertype(m_map_info) it = m_map_info.find(header);
2026. if (it == m_map_info.end())
2027. m_map_info.insert(std::map<int, int>::value_type(header, 1));
2028. else
2029. ++it->second;
2030. }
2032. void CPacketInfo::Reset()
2033. {
2034. m_map_info.clear();
2035. }
2037. void CClientManager::ProcessPackets(CPeer * peer)
2038. {
2039. BYTE header;
2040. DWORD dwHandle;
2041. DWORD dwLength;
2042. const char * data = NULL;
2043. int i = 0;
2044. int iCount = 0;
2046. while (peer->PeekPacket(i, header, dwHandle, dwLength, &data))
2047. {
2048. // DISABLE_DB_HEADER_LOG
2049. // sys_log(0, "header %d %p size %d", header, this, dwLength);
2050. // END_OF_DISABLE_DB_HEADER_LOG
2051. m_bLastHeader = header;
2052. ++iCount;
2054. #ifdef _TEST
2055. if (header != 10)
2056. sys_log(0, " ProcessPacket Header [%d] Handle[%d] Length[%d] iCount[%d]", header, dwHandle, dwLength, iCount);
2057. #endif
2058. if (g_test_server)
2059. {
2060. if (header != 10)
2061. sys_log(0, " ProcessPacket Header [%d] Handle[%d] Length[%d] iCount[%d]", header, dwHandle, dwLength, iCount);
2062. }
2066. switch (header)
2067. {
2068. case HEADER_GD_BOOT:
2069. QUERY_BOOT(peer, (TPacketGDBoot *) data);
2070. break;
2072. case HEADER_GD_HAMMER_OF_TOR:
2073. break;
2075. case HEADER_GD_LOGIN_BY_KEY:
2076. QUERY_LOGIN_BY_KEY(peer, dwHandle, (TPacketGDLoginByKey *) data);
2077. break;
2079. case HEADER_GD_LOGOUT:
2080. //sys_log(0, "HEADER_GD_LOGOUT (handle: %d length: %d)", dwHandle, dwLength);
2081. QUERY_LOGOUT(peer, dwHandle, data);
2082. break;
2084. case HEADER_GD_PLAYER_LOAD:
2085. sys_log(1, "HEADER_GD_PLAYER_LOAD (handle: %d length: %d)", dwHandle, dwLength);
2086. QUERY_PLAYER_LOAD(peer, dwHandle, (TPlayerLoadPacket *) data);
2087. break;
2089. case HEADER_GD_PLAYER_SAVE:
2090. sys_log(1, "HEADER_GD_PLAYER_SAVE (handle: %d length: %d)", dwHandle, dwLength);
2091. QUERY_PLAYER_SAVE(peer, dwHandle, (TPlayerTable *) data);
2092. break;
2094. case HEADER_GD_PLAYER_CREATE:
2095. sys_log(0, "HEADER_GD_PLAYER_CREATE (handle: %d length: %d)", dwHandle, dwLength);
2096. __QUERY_PLAYER_CREATE(peer, dwHandle, (TPlayerCreatePacket *) data);
2097. sys_log(0, "END");
2098. break;
2100. case HEADER_GD_PLAYER_DELETE:
2101. sys_log(1, "HEADER_GD_PLAYER_DELETE (handle: %d length: %d)", dwHandle, dwLength);
2102. __QUERY_PLAYER_DELETE(peer, dwHandle, (TPlayerDeletePacket *) data);
2103. break;
2105. case HEADER_GD_PLAYER_COUNT:
2106. QUERY_PLAYER_COUNT(peer, (TPlayerCountPacket *) data);
2107. break;
2109. case HEADER_GD_QUEST_SAVE:
2110. sys_log(1, "HEADER_GD_QUEST_SAVE (handle: %d length: %d)", dwHandle, dwLength);
2111. QUERY_QUEST_SAVE(peer, (TQuestTable *) data, dwLength);
2112. break;
2114. case HEADER_GD_SAFEBOX_LOAD:
2115. QUERY_SAFEBOX_LOAD(peer, dwHandle, (TSafeboxLoadPacket *) data, 0);
2116. break;
2118. case HEADER_GD_SAFEBOX_SAVE:
2119. sys_log(1, "HEADER_GD_SAFEBOX_SAVE (handle: %d length: %d)", dwHandle, dwLength);
2120. QUERY_SAFEBOX_SAVE(peer, (TSafeboxTable *) data);
2121. break;
2123. case HEADER_GD_SAFEBOX_CHANGE_SIZE:
2124. QUERY_SAFEBOX_CHANGE_SIZE(peer, dwHandle, (TSafeboxChangeSizePacket *) data);
2125. break;
2127. case HEADER_GD_SAFEBOX_CHANGE_PASSWORD:
2128. QUERY_SAFEBOX_CHANGE_PASSWORD(peer, dwHandle, (TSafeboxChangePasswordPacket *) data);
2129. break;
2131. case HEADER_GD_MALL_LOAD:
2132. QUERY_SAFEBOX_LOAD(peer, dwHandle, (TSafeboxLoadPacket *) data, 1);
2133. break;
2135. case HEADER_GD_EMPIRE_SELECT:
2136. QUERY_EMPIRE_SELECT(peer, dwHandle, (TEmpireSelectPacket *) data);
2137. break;
2139. case HEADER_GD_SETUP:
2140. QUERY_SETUP(peer, dwHandle, data);
2141. break;
2143. case HEADER_GD_GUILD_CREATE:
2144. GuildCreate(peer, *(DWORD *) data);
2145. break;
2147. case HEADER_GD_GUILD_SKILL_UPDATE:
2148. GuildSkillUpdate(peer, (TPacketGuildSkillUpdate *) data);
2149. break;
2151. case HEADER_GD_GUILD_EXP_UPDATE:
2152. GuildExpUpdate(peer, (TPacketGuildExpUpdate *) data);
2153. break;
2155. case HEADER_GD_GUILD_ADD_MEMBER:
2156. GuildAddMember(peer, (TPacketGDGuildAddMember*) data);
2157. break;
2159. case HEADER_GD_GUILD_REMOVE_MEMBER:
2160. GuildRemoveMember(peer, (TPacketGuild*) data);
2161. break;
2163. case HEADER_GD_GUILD_CHANGE_GRADE:
2164. GuildChangeGrade(peer, (TPacketGuild*) data);
2165. break;
2167. case HEADER_GD_GUILD_CHANGE_MEMBER_DATA:
2168. GuildChangeMemberData(peer, (TPacketGuildChangeMemberData*) data);
2169. break;
2171. case HEADER_GD_GUILD_DISBAND:
2172. GuildDisband(peer, (TPacketGuild*) data);
2173. break;
2175. case HEADER_GD_GUILD_WAR:
2176. GuildWar(peer, (TPacketGuildWar*) data);
2177. break;
2179. case HEADER_GD_GUILD_WAR_SCORE:
2180. GuildWarScore(peer, (TPacketGuildWarScore*) data);
2181. break;
2183. case HEADER_GD_GUILD_CHANGE_LADDER_POINT:
2184. GuildChangeLadderPoint((TPacketGuildLadderPoint*) data);
2185. break;
2187. case HEADER_GD_GUILD_USE_SKILL:
2188. GuildUseSkill((TPacketGuildUseSkill*) data);
2189. break;
2191. case HEADER_GD_FLUSH_CACHE:
2192. QUERY_FLUSH_CACHE(peer, data);
2193. break;
2195. case HEADER_GD_ITEM_SAVE:
2196. QUERY_ITEM_SAVE(peer, data);
2197. break;
2199. case HEADER_GD_ITEM_DESTROY:
2200. QUERY_ITEM_DESTROY(peer, data);
2201. break;
2203. case HEADER_GD_ITEM_FLUSH:
2204. QUERY_ITEM_FLUSH(peer, data);
2205. break;
2207. case HEADER_GD_ADD_AFFECT:
2208. sys_log(1, "HEADER_GD_ADD_AFFECT");
2209. QUERY_ADD_AFFECT(peer, (TPacketGDAddAffect *) data);
2210. break;
2212. case HEADER_GD_REMOVE_AFFECT:
2213. sys_log(1, "HEADER_GD_REMOVE_AFFECT");
2214. QUERY_REMOVE_AFFECT(peer, (TPacketGDRemoveAffect *) data);
2215. break;
2217. case HEADER_GD_HIGHSCORE_REGISTER:
2218. QUERY_HIGHSCORE_REGISTER(peer, (TPacketGDHighscore *) data);
2219. break;
2221. case HEADER_GD_PARTY_CREATE:
2222. QUERY_PARTY_CREATE(peer, (TPacketPartyCreate*) data);
2223. break;
2225. case HEADER_GD_PARTY_DELETE:
2226. QUERY_PARTY_DELETE(peer, (TPacketPartyDelete*) data);
2227. break;
2229. case HEADER_GD_PARTY_ADD:
2230. QUERY_PARTY_ADD(peer, (TPacketPartyAdd*) data);
2231. break;
2233. case HEADER_GD_PARTY_REMOVE:
2234. QUERY_PARTY_REMOVE(peer, (TPacketPartyRemove*) data);
2235. break;
2237. case HEADER_GD_PARTY_STATE_CHANGE:
2238. QUERY_PARTY_STATE_CHANGE(peer, (TPacketPartyStateChange*) data);
2239. break;
2241. case HEADER_GD_PARTY_SET_MEMBER_LEVEL:
2242. QUERY_PARTY_SET_MEMBER_LEVEL(peer, (TPacketPartySetMemberLevel*) data);
2243. break;
2245. case HEADER_GD_RELOAD_PROTO:
2246. QUERY_RELOAD_PROTO();
2247. break;
2249. case HEADER_GD_CHANGE_NAME:
2250. QUERY_CHANGE_NAME(peer, dwHandle, (TPacketGDChangeName *) data);
2251. break;
2253. case HEADER_GD_SMS:
2254. QUERY_SMS(peer, (TPacketGDSMS *) data);
2255. break;
2257. case HEADER_GD_AUTH_LOGIN:
2258. QUERY_AUTH_LOGIN(peer, dwHandle, (TPacketGDAuthLogin *) data);
2259. break;
2261. case HEADER_GD_REQUEST_GUILD_PRIV:
2262. AddGuildPriv((TPacketGiveGuildPriv*)data);
2263. break;
2265. case HEADER_GD_REQUEST_EMPIRE_PRIV:
2266. AddEmpirePriv((TPacketGiveEmpirePriv*)data);
2267. break;
2269. case HEADER_GD_REQUEST_CHARACTER_PRIV:
2270. AddCharacterPriv((TPacketGiveCharacterPriv*) data);
2271. break;
2273. case HEADER_GD_MONEY_LOG:
2274. MoneyLog((TPacketMoneyLog*)data);
2275. break;
2277. case HEADER_GD_GUILD_DEPOSIT_MONEY:
2278. GuildDepositMoney((TPacketGDGuildMoney*)data);
2279. break;
2281. case HEADER_GD_GUILD_WITHDRAW_MONEY:
2282. GuildWithdrawMoney(peer, (TPacketGDGuildMoney*)data);
2283. break;
2285. case HEADER_GD_GUILD_WITHDRAW_MONEY_GIVE_REPLY:
2286. GuildWithdrawMoneyGiveReply((TPacketGDGuildMoneyWithdrawGiveReply*)data);
2287. break;
2289. case HEADER_GD_GUILD_WAR_BET:
2290. GuildWarBet((TPacketGDGuildWarBet *) data);
2291. break;
2293. case HEADER_GD_SET_EVENT_FLAG:
2294. SetEventFlag((TPacketSetEventFlag*) data);
2295. break;
2297. case HEADER_GD_CREATE_OBJECT:
2298. CreateObject((TPacketGDCreateObject *) data);
2299. break;
2301. case HEADER_GD_DELETE_OBJECT:
2302. DeleteObject(*(DWORD *) data);
2303. break;
2305. case HEADER_GD_UPDATE_LAND:
2306. UpdateLand((DWORD *) data);
2307. break;
2311. case HEADER_GD_MARRIAGE_ADD:
2312. MarriageAdd((TPacketMarriageAdd *) data);
2313. break;
2315. case HEADER_GD_MARRIAGE_UPDATE:
2316. MarriageUpdate((TPacketMarriageUpdate *) data);
2317. break;
2319. case HEADER_GD_MARRIAGE_REMOVE:
2320. MarriageRemove((TPacketMarriageRemove *) data);
2321. break;
2323. case HEADER_GD_WEDDING_REQUEST:
2324. WeddingRequest((TPacketWeddingRequest *) data);
2325. break;
2327. case HEADER_GD_WEDDING_READY:
2328. WeddingReady((TPacketWeddingReady *) data);
2329. break;
2331. case HEADER_GD_WEDDING_END:
2332. WeddingEnd((TPacketWeddingEnd *) data);
2333. break;
2335. // BLOCK_CHAT
2336. case HEADER_GD_BLOCK_CHAT:
2337. BlockChat((TPacketBlockChat *) data);
2338. break;
2339. // END_OF_BLOCK_CHAT
2341. // MYSHOP_PRICE_LIST
2342. case HEADER_GD_MYSHOP_PRICELIST_UPDATE:
2343. MyshopPricelistUpdate((TPacketMyshopPricelistHeader*)data);
2344. break;
2346. case HEADER_GD_MYSHOP_PRICELIST_REQ:
2347. MyshopPricelistRequest(peer, dwHandle, *(DWORD*)data);
2348. break;
2349. // END_OF_MYSHOP_PRICE_LIST
2351. //RELOAD_ADMIN
2352. case HEADER_GD_RELOAD_ADMIN:
2353. ReloadAdmin(peer, (TPacketReloadAdmin*)data);
2354. break;
2355. //END_RELOAD_ADMIN
2357. case HEADER_GD_BREAK_MARRIAGE:
2358. BreakMarriage(peer, data);
2359. break;
2361. case HEADER_GD_REQ_SPARE_ITEM_ID_RANGE :
2362. SendSpareItemIDRange(peer);
2363. break;
2365. case HEADER_GD_REQ_CHANGE_GUILD_MASTER :
2366. GuildChangeMaster((TPacketChangeGuildMaster*) data);
2367. break;
2369. case HEADER_GD_UPDATE_HORSE_NAME :
2370. UpdateHorseName((TPacketUpdateHorseName*) data, peer);
2371. break;
2373. case HEADER_GD_REQ_HORSE_NAME :
2374. AckHorseName(*(DWORD*)data, peer);
2375. break;
2377. case HEADER_GD_DC:
2378. DeleteLoginKey((TPacketDC*) data);
2379. break;
2381. case HEADER_GD_VALID_LOGOUT:
2382. ResetLastPlayerID((TPacketNeedLoginLogInfo*)data);
2383. break;
2385. case HEADER_GD_REQUEST_CHARGE_CASH:
2386. ChargeCash((TRequestChargeCash*)data);
2387. break;
2389. //delete gift notify icon
2391. case HEADER_GD_DELETE_AWARDID:
2392. DeleteAwardId((TPacketDeleteAwardID*) data);
2393. break;
2395. case HEADER_GD_UPDATE_CHANNELSTATUS:
2396. UpdateChannelStatus((SChannelStatus*) data);
2397. break;
2398. case HEADER_GD_REQUEST_CHANNELSTATUS:
2399. RequestChannelStatus(peer, dwHandle);
2400. break;
2402. #ifdef OFFLINE_SHOP
2403. case HEADER_GD_SHOP_NAME:
2404. ShopName(peer, (TPacketShopName *)data);
2405. break;
2406. case HEADER_GD_SHOP_CLOSE:
2407. ShopClose(peer, (TPacketShopClose *)data);
2408. break;
2409. case HEADER_GD_SHOP_UPDATE_ITEM:
2410. ShopUpdateItem(peer, (TPacketShopUpdateItem *)data);
2411. break;
2412. #endif
2414. default:
2415. sys_err("Unknown header (header: %d handle: %d length: %d)", header, dwHandle, dwLength);
2416. break;
2417. }
2418. }
2420. peer->RecvEnd(i);
2421. }
2423. void CClientManager::ShopClose(CPeer * peer, TPacketShopClose *p)
2424. {
2425. for (TPeerList::iterator i = m_peerList.begin(); i != m_peerList.end(); ++i)
2426. {
2427. CPeer * tmp = *i;
2429. if (tmp == peer)
2430. continue;
2432. if (0 == tmp->GetChannel())
2433. continue;
2435. TPacketShopClose packet;
2436. packet.shop_id = p->shop_id;
2437. packet.pid = p->pid;
2438. packet.error = p->error;
2439. tmp->EncodeHeader(HEADER_DG_SHOP_CLOSE, 0, sizeof(packet));
2440. tmp->Encode(&packet, sizeof(packet));
2441. }
2442. }
2443. void CClientManager::ShopUpdateItem(CPeer * peer, TPacketShopUpdateItem *p)
2444. {
2445. for (TPeerList::iterator i = m_peerList.begin(); i != m_peerList.end(); ++i)
2446. {
2447. CPeer * tmp = *i;
2449. if (tmp == peer)
2450. continue;
2452. if (0 == tmp->GetChannel())
2453. continue;
2454. TPacketShopUpdateItem packet;
2455. packet.shop_id = p->shop_id;
2456. packet.tick = p->tick;
2457. packet.refresh = p->refresh;
2458. packet.shop_locked = p->shop_locked;
2459. tmp->EncodeHeader(HEADER_DG_SHOP_UPDATE_ITEM, 0, sizeof(packet));
2460. tmp->Encode(&packet, sizeof(packet));
2461. }
2462. }
2463. #endif
2465. void CClientManager::AddPeer(socket_t fd)
2466. {
2467. CPeer * pPeer = new CPeer;
2469. if (pPeer->Accept(fd))
2470. m_peerList.push_front(pPeer);
2471. else
2472. delete pPeer;
2473. }
2475. void CClientManager::RemovePeer(CPeer * pPeer)
2476. {
2477. if (m_pkAuthPeer == pPeer)
2478. {
2479. m_pkAuthPeer = NULL;
2480. }
2481. else
2482. {
2483. TLogonAccountMap::iterator it = m_map_kLogonAccount.begin();
2485. while (it != m_map_kLogonAccount.end())
2486. {
2487. CLoginData * pkLD = it->second;
2489. if (pkLD->GetConnectedPeerHandle() == pPeer->GetHandle())
2490. {
2491. if (pkLD->IsPlay())
2492. {
2493. pkLD->SetPlay(false);
2494. }
2496. if (pkLD->IsDeleted())
2497. {
2498. sys_log(0, "DELETING LoginData");
2499. delete pkLD;
2500. }
2502. m_map_kLogonAccount.erase(it++);
2503. }
2504. else
2505. ++it;
2506. }
2507. }
2509. m_peerList.remove(pPeer);
2510. delete pPeer;
2511. }
2513. CPeer * CClientManager::GetPeer(IDENT ident)
2514. {
2515. for (itertype(m_peerList) i = m_peerList.begin(); i != m_peerList.end();++i)
2516. {
2517. CPeer * tmp = *i;
2519. if (tmp->GetHandle() == ident)
2520. return tmp;
2521. }
2523. return NULL;
2524. }
2526. CPeer * CClientManager::GetAnyPeer()
2527. {
2528. if (m_peerList.empty())
2529. return NULL;
2531. return m_peerList.front();
2532. }
2534. // DB ¸Å´ÏÀú·Î ºÎÅÍ ¹ŞÀº °á°ú¸¦ ó¸®ÇÑ´Ù.
2535. //
2536. // @version 05/06/10 Bang2ni - °¡°İÁ¤º¸ °ü·Ã Äõ¸®(QID_ITEMPRICE_XXX) Ãß°¡
2537. int CClientManager::AnalyzeQueryResult(SQLMsg * msg)
2538. {
2539. CQueryInfo * qi = (CQueryInfo *) msg->pvUserData;
2540. CPeer * peer = GetPeer(qi->dwIdent);
2542. #ifdef _TEST
2543. if (qi->iType != QID_ITEM_AWARD_LOAD)
2544. sys_log(0, "AnalyzeQueryResult %d", qi->iType);
2545. #endif
2546. switch (qi->iType)
2547. {
2548. case QID_ITEM_AWARD_LOAD:
2549. ItemAwardManager::instance().Load(msg);
2550. delete qi;
2551. return true;
2553. case QID_GUILD_RANKING:
2554. CGuildManager::instance().ResultRanking(msg->Get()->pSQLResult);
2555. break;
2557. // MYSHOP_PRICE_LIST
2558. case QID_ITEMPRICE_LOAD_FOR_UPDATE:
2559. RESULT_PRICELIST_LOAD_FOR_UPDATE(msg);
2560. break;
2561. // END_OF_MYSHOP_PRICE_LIST
2562. }
2564. if (!peer)
2565. {
2566. //sys_err("CClientManager::AnalyzeQueryResult: peer not exist anymore. (ident: %d)", qi->dwIdent);
2567. delete qi;
2568. return true;
2569. }
2571. switch (qi->iType)
2572. {
2573. case QID_PLAYER:
2574. case QID_ITEM:
2575. case QID_QUEST:
2576. case QID_AFFECT:
2577. RESULT_COMPOSITE_PLAYER(peer, msg, qi->iType);
2578. break;
2580. case QID_LOGIN:
2581. RESULT_LOGIN(peer, msg);
2582. break;
2584. case QID_SAFEBOX_LOAD:
2585. sys_log(0, "QUERY_RESULT: HEADER_GD_SAFEBOX_LOAD");
2586. RESULT_SAFEBOX_LOAD(peer, msg);
2587. break;
2589. case QID_SAFEBOX_CHANGE_SIZE:
2590. sys_log(0, "QUERY_RESULT: HEADER_GD_SAFEBOX_CHANGE_SIZE");
2591. RESULT_SAFEBOX_CHANGE_SIZE(peer, msg);
2592. break;
2594. case QID_SAFEBOX_CHANGE_PASSWORD:
2595. sys_log(0, "QUERY_RESULT: HEADER_GD_SAFEBOX_CHANGE_PASSWORD %p", msg);
2596. RESULT_SAFEBOX_CHANGE_PASSWORD(peer, msg);
2597. break;
2599. case QID_SAFEBOX_CHANGE_PASSWORD_SECOND:
2600. sys_log(0, "QUERY_RESULT: HEADER_GD_SAFEBOX_CHANGE_PASSWORD %p", msg);
2601. RESULT_SAFEBOX_CHANGE_PASSWORD_SECOND(peer, msg);
2602. break;
2604. case QID_HIGHSCORE_REGISTER:
2605. sys_log(0, "QUERY_RESULT: HEADER_GD_HIGHSCORE_REGISTER %p", msg);
2606. RESULT_HIGHSCORE_REGISTER(peer, msg);
2607. break;
2609. case QID_SAFEBOX_SAVE:
2610. case QID_ITEM_SAVE:
2611. case QID_ITEM_DESTROY:
2612. case QID_QUEST_SAVE:
2613. case QID_PLAYER_SAVE:
2614. case QID_ITEM_AWARD_TAKEN:
2615. break;
2617. // PLAYER_INDEX_CREATE_BUG_FIX
2618. case QID_PLAYER_INDEX_CREATE:
2619. RESULT_PLAYER_INDEX_CREATE(peer, msg);
2620. break;
2621. // END_PLAYER_INDEX_CREATE_BUG_FIX
2623. case QID_PLAYER_DELETE:
2624. __RESULT_PLAYER_DELETE(peer, msg);
2625. break;
2627. case QID_LOGIN_BY_KEY:
2628. RESULT_LOGIN_BY_KEY(peer, msg);
2629. break;
2631. // MYSHOP_PRICE_LIST
2632. case QID_ITEMPRICE_LOAD:
2633. RESULT_PRICELIST_LOAD(peer, msg);
2634. break;
2635. // END_OF_MYSHOP_PRICE_LIST
2637. default:
2638. sys_log(0, "CClientManager::AnalyzeQueryResult unknown query result type: %d, str: %s", qi->iType, msg->stQuery.c_str());
2639. break;
2640. }
2642. delete qi;
2643. return true;
2644. }
2646. void UsageLog()
2647. {
2648. FILE* fp = NULL;
2650. time_t ct;
2651. char *time_s;
2652. struct tm lt;
2654. int avg = g_dwUsageAvg / 3600; // 60 ÃÊ * 60 ºĞ
2656. fp = fopen("usage.txt", "a+");
2658. if (!fp)
2659. return;
2661. ct = time(0);
2662. lt = *localtime(&ct);
2663. time_s = asctime(&lt);
2665. time_s[strlen(time_s) - 1] = '\0';
2667. fprintf(fp, "| %4d %-15.15s | %5d | %5u |", lt.tm_year + 1900, time_s + 4, avg, g_dwUsageMax);
2669. fprintf(fp, "\n");
2670. fclose(fp);
2672. g_dwUsageMax = g_dwUsageAvg = 0;
2673. }
2675. int CClientManager::Process()
2676. {
2677. int pulses;
2679. if (!(pulses = thecore_idle()))
2680. return 0;
2682. while (pulses--)
2683. {
2684. ++thecore_heart->pulse;
2686. /*
2687. //30ºĞ¸¶´Ù º¯°æ
2688. if (((thecore_pulse() % (60 * 30 * 10)) == 0))
2689. {
2690. g_iPlayerCacheFlushSeconds = MAX(60, rand() % 180);
2691. g_iItemCacheFlushSeconds = MAX(60, rand() % 180);
2692. sys_log(0, "[SAVE_TIME]Change saving time item %d player %d", g_iPlayerCacheFlushSeconds, g_iItemCacheFlushSeconds);
2693. }
2694. */
2696. if (!(thecore_heart->pulse % thecore_heart->passes_per_sec))
2697. {
2698. if (g_test_server)
2699. {
2701. if (!(thecore_heart->pulse % thecore_heart->passes_per_sec * 10))
2703. {
2704. pt_log("[%9d] return %d/%d/%d/%d async %d/%d/%d/%d",
2705. thecore_heart->pulse,
2706. CDBManager::instance().CountReturnQuery(SQL_PLAYER),
2707. CDBManager::instance().CountReturnResult(SQL_PLAYER),
2708. CDBManager::instance().CountReturnQueryFinished(SQL_PLAYER),
2709. CDBManager::instance().CountReturnCopiedQuery(SQL_PLAYER),
2710. CDBManager::instance().CountAsyncQuery(SQL_PLAYER),
2711. CDBManager::instance().CountAsyncResult(SQL_PLAYER),
2712. CDBManager::instance().CountAsyncQueryFinished(SQL_PLAYER),
2713. CDBManager::instance().CountAsyncCopiedQuery(SQL_PLAYER));
2715. if ((thecore_heart->pulse % 50) == 0)
2716. sys_log(0, "[%9d] return %d/%d/%d async %d/%d/%d",
2717. thecore_heart->pulse,
2718. CDBManager::instance().CountReturnQuery(SQL_PLAYER),
2719. CDBManager::instance().CountReturnResult(SQL_PLAYER),
2720. CDBManager::instance().CountReturnQueryFinished(SQL_PLAYER),
2721. CDBManager::instance().CountAsyncQuery(SQL_PLAYER),
2722. CDBManager::instance().CountAsyncResult(SQL_PLAYER),
2723. CDBManager::instance().CountAsyncQueryFinished(SQL_PLAYER));
2724. }
2725. }
2726. else
2727. {
2728. pt_log("[%9d] return %d/%d/%d/%d async %d/%d/%d%/%d",
2729. thecore_heart->pulse,
2730. CDBManager::instance().CountReturnQuery(SQL_PLAYER),
2731. CDBManager::instance().CountReturnResult(SQL_PLAYER),
2732. CDBManager::instance().CountReturnQueryFinished(SQL_PLAYER),
2733. CDBManager::instance().CountReturnCopiedQuery(SQL_PLAYER),
2734. CDBManager::instance().CountAsyncQuery(SQL_PLAYER),
2735. CDBManager::instance().CountAsyncResult(SQL_PLAYER),
2736. CDBManager::instance().CountAsyncQueryFinished(SQL_PLAYER),
2737. CDBManager::instance().CountAsyncCopiedQuery(SQL_PLAYER));
2739. if ((thecore_heart->pulse % 50) == 0)
2740. sys_log(0, "[%9d] return %d/%d/%d async %d/%d/%d",
2741. thecore_heart->pulse,
2742. CDBManager::instance().CountReturnQuery(SQL_PLAYER),
2743. CDBManager::instance().CountReturnResult(SQL_PLAYER),
2744. CDBManager::instance().CountReturnQueryFinished(SQL_PLAYER),
2745. CDBManager::instance().CountAsyncQuery(SQL_PLAYER),
2746. CDBManager::instance().CountAsyncResult(SQL_PLAYER),
2747. CDBManager::instance().CountAsyncQueryFinished(SQL_PLAYER));
2748. }
2750. CDBManager::instance().ResetCounter();
2752. DWORD dwCount = CClientManager::instance().GetUserCount();
2754. g_dwUsageAvg += dwCount;
2755. g_dwUsageMax = MAX(g_dwUsageMax, dwCount);
2757. memset(&thecore_profiler[0], 0, sizeof(thecore_profiler));
2759. if (!(thecore_heart->pulse % (thecore_heart->passes_per_sec * 3600)))
2760. UsageLog();
2762. m_iCacheFlushCount = 0;
2765. //Ç÷¹À̾î Ç÷¯½¬
2766. UpdatePlayerCache();
2767. //¾ÆÀÌÅÛ Ç÷¯½¬
2768. UpdateItemCache();
2769. //·Î±×¾Æ¿ô½Ã ó¸®- ij½¬¼Â Ç÷¯½¬
2770. UpdateLogoutPlayer();
2772. // MYSHOP_PRICE_LIST
2773. UpdateItemPriceListCache();
2774. // END_OF_MYSHOP_PRICE_LIST
2776. CGuildManager::instance().Update();
2777. CPrivManager::instance().Update();
2778. marriage::CManager::instance().Update();
2779. }
2781. if (!(thecore_heart->pulse % (thecore_heart->passes_per_sec * 5)))
2782. {
2783. ItemAwardManager::instance().RequestLoad();
2784. }
2786. if (!(thecore_heart->pulse % (thecore_heart->passes_per_sec * 10)))
2787. {
2788. /*
2789. char buf[4096 + 1];
2790. int len
2791. itertype(g_query_info.m_map_info) it;
2793. /////////////////////////////////////////////////////////////////
2794. buf[0] = '\0';
2795. len = 0;
2797. it = g_query_info.m_map_info.begin();
2799. int count = 0;
2801. while (it != g_query_info.m_map_info.end())
2802. {
2803. len += snprintf(buf + len, sizeof(buf) - len, "%2d %3d\n", it->first, it->second);
2804. count += it->second;
2805. it++;
2806. }
2808. pt_log("QUERY:\n%s-------------------- MAX : %d\n", buf, count);
2809. g_query_info.Reset();
2810. */
2811. pt_log("QUERY: MAIN[%d] ASYNC[%d]", g_query_count[0], g_query_count[1]);
2812. g_query_count[0] = 0;
2813. g_query_count[1] = 0;
2814. /////////////////////////////////////////////////////////////////
2816. /////////////////////////////////////////////////////////////////
2817. /*
2818. buf[0] = '\0';
2819. len = 0;
2821. it = g_item_info.m_map_info.begin();
2823. count = 0;
2824. while (it != g_item_info.m_map_info.end())
2825. {
2826. len += snprintf(buf + len, sizeof(buf) - len, "%5d %3d\n", it->first, it->second);
2827. count += it->second;
2828. it++;
2829. }
2831. pt_log("ITEM:\n%s-------------------- MAX : %d\n", buf, count);
2832. g_item_info.Reset();
2833. */
2834. pt_log("ITEM:%d\n", g_item_count);
2835. g_item_count = 0;
2836. /////////////////////////////////////////////////////////////////
2837. }
2839. if (!(thecore_heart->pulse % (thecore_heart->passes_per_sec * 60))) // 60ÃÊ¿¡ Çѹø
2840. {
2841. // À¯´ÏÅ© ¾ÆÀÌÅÛÀ» À§ÇÑ ½Ã°£À» º¸³½´Ù.
2842. CClientManager::instance().SendTime();
2843. }
2845. if (!(thecore_heart->pulse % (thecore_heart->passes_per_sec * 3600))) // Çѽ𣿡 Çѹø
2846. {
2847. CMoneyLog::instance().Save();
2848. }
2849. }
2851. int num_events = fdwatch(m_fdWatcher, 0);
2852. int idx;
2853. CPeer * peer;
2855. for (idx = 0; idx < num_events; ++idx) // ÀÎDz
2856. {
2857. peer = (CPeer *) fdwatch_get_client_data(m_fdWatcher, idx);
2859. if (!peer)
2860. {
2861. if (fdwatch_check_event(m_fdWatcher, m_fdAccept, idx) == FDW_READ)
2862. {
2863. AddPeer(m_fdAccept);
2864. fdwatch_clear_event(m_fdWatcher, m_fdAccept, idx);
2865. }
2866. else
2867. {
2868. sys_err("FDWATCH: peer null in event: ident %d", fdwatch_get_ident(m_fdWatcher, idx));
2869. }
2871. continue;
2872. }
2874. switch (fdwatch_check_event(m_fdWatcher, peer->GetFd(), idx))
2875. {
2876. case FDW_READ:
2877. if (peer->Recv() < 0)
2878. {
2879. sys_err("Recv failed");
2880. RemovePeer(peer);
2881. }
2882. else
2883. {
2884. if (peer == m_pkAuthPeer)
2885. if (g_log)
2886. sys_log(0, "AUTH_PEER_READ: size %d", peer->GetRecvLength());
2888. ProcessPackets(peer);
2889. }
2890. break;
2892. case FDW_WRITE:
2893. if (peer == m_pkAuthPeer)
2894. if (g_log)
2895. sys_log(0, "AUTH_PEER_WRITE: size %d", peer->GetSendLength());
2897. if (peer->Send() < 0)
2898. {
2899. sys_err("Send failed");
2900. RemovePeer(peer);
2901. }
2903. break;
2905. case FDW_EOF:
2906. RemovePeer(peer);
2907. break;
2909. default:
2910. sys_err("fdwatch_check_fd returned unknown result");
2911. RemovePeer(peer);
2912. break;
2913. }
2914. }
2916. #ifdef __WIN32__
2917. if (_kbhit()) {
2918. int c = _getch();
2919. switch (c) {
2920. case 0x1b: // Esc
2921. return 0; // shutdown
2922. break;
2923. default:
2924. break;
2925. }
2926. }
2927. #endif
2930. return 1;
2931. }
2933. DWORD CClientManager::GetUserCount()
2934. {
2935. // ´Ü¼øÈ÷ ·Î±×ÀÎ Ä«¿îÆ®¸¦ ¼¾´Ù.. --;
2936. return m_map_kLogonAccount.size();
2937. }
2939. void CClientManager::SendAllGuildSkillRechargePacket()
2940. {
2941. ForwardPacket(HEADER_DG_GUILD_SKILL_RECHARGE, NULL, 0);
2942. }
2944. void CClientManager::SendTime()
2945. {
2946. time_t now = GetCurrentTime();
2947. ForwardPacket(HEADER_DG_TIME, &now, sizeof(time_t));
2948. }
2950. void CClientManager::ForwardPacket(BYTE header, const void* data, int size, BYTE bChannel, CPeer* except)
2951. {
2952. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
2953. {
2954. CPeer * peer = *it;
2956. if (peer == except)
2957. continue;
2959. if (!peer->GetChannel())
2960. continue;
2962. if (bChannel && peer->GetChannel() != bChannel)
2963. continue;
2965. peer->EncodeHeader(header, 0, size);
2967. if (size > 0 && data)
2968. peer->Encode(data, size);
2969. }
2970. }
2972. void CClientManager::SendNotice(const char * c_pszFormat, ...)
2973. {
2974. char szBuf[255+1];
2975. va_list args;
2977. va_start(args, c_pszFormat);
2978. int len = vsnprintf(szBuf, sizeof(szBuf), c_pszFormat, args);
2979. va_end(args);
2980. szBuf[len] = '\0';
2982. ForwardPacket(HEADER_DG_NOTICE, szBuf, len + 1);
2983. }
2985. time_t CClientManager::GetCurrentTime()
2986. {
2987. return time(0);
2988. }
2990. // ITEM_UNIQUE_ID
2991. bool CClientManager::InitializeNowItemID()
2992. {
2993. DWORD dwMin, dwMax;
2995. //¾ÆÀÌÅÛ ID¸¦ ÃʱâÈ­ ÇÑ´Ù.
2996. if (!CConfig::instance().GetTwoValue("ITEM_ID_RANGE", &dwMin, &dwMax))
2997. {
2998. sys_err("conf.txt: Cannot find ITEM_ID_RANGE [start_item_id] [end_item_id]");
2999. return false;
3000. }
3002. sys_log(0, "ItemRange From File %u ~ %u ", dwMin, dwMax);
3004. if (CItemIDRangeManager::instance().BuildRange(dwMin, dwMax, m_itemRange) == false)
3005. {
3006. sys_err("Can not build ITEM_ID_RANGE");
3007. return false;
3008. }
3010. sys_log(0, " Init Success Start %u End %u Now %u\n", m_itemRange.dwMin, m_itemRange.dwMax, m_itemRange.dwUsableItemIDMin);
3012. return true;
3013. }
3015. DWORD CClientManager::GainItemID()
3016. {
3017. return m_itemRange.dwUsableItemIDMin++;
3018. }
3020. DWORD CClientManager::GetItemID()
3021. {
3022. return m_itemRange.dwUsableItemIDMin;
3023. }
3024. // ITEM_UNIQUE_ID_END
3025. //BOOT_LOCALIZATION
3027. bool CClientManager::InitializeLocalization()
3028. {
3029. char szQuery[512];
3030. snprintf(szQuery, sizeof(szQuery), "SELECT mValue, mKey FROM locale");
3031. SQLMsg * pMsg = CDBManager::instance().DirectQuery(szQuery, SQL_COMMON);
3033. if (pMsg->Get()->uiNumRows == 0)
3034. {
3035. sys_err("InitializeLocalization() ==> DirectQuery failed(%s)", szQuery);
3036. delete pMsg;
3037. return false;
3038. }
3040. sys_log(0, "InitializeLocalization() - LoadLocaleTable(count:%d)", pMsg->Get()->uiNumRows);
3042. m_vec_Locale.clear();
3044. MYSQL_ROW row = NULL;
3046. for (int n = 0; (row = mysql_fetch_row(pMsg->Get()->pSQLResult)) != NULL; ++n)
3047. {
3048. int col = 0;
3049. tLocale locale;
3051. strlcpy(locale.szValue, row[col++], sizeof(locale.szValue));
3052. strlcpy(locale.szKey, row[col++], sizeof(locale.szKey));
3054. //DB_NAME_COLUMN Setting
3055. if (strcmp(locale.szKey, "LOCALE") == 0)
3056. {
3057. if (strcmp(locale.szValue, "cibn") == 0)
3058. {
3059. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3061. if (g_stLocale != locale.szValue)
3062. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "gb2312");
3064. g_stLocale = "gb2312";
3065. g_stLocaleNameColumn = "gb2312name";
3066. }
3067. else if (strcmp(locale.szValue, "ymir") == 0)
3068. {
3069. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3071. if (g_stLocale != locale.szValue)
3072. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3074. g_stLocale = "euckr";
3075. g_stLocaleNameColumn = "name";
3076. }
3077. else if (strcmp(locale.szValue, "japan") == 0)
3078. {
3079. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3081. if (g_stLocale != locale.szValue)
3082. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "sjis");
3084. g_stLocale = "sjis";
3085. g_stLocaleNameColumn = "locale_name";
3086. }
3087. else if (strcmp(locale.szValue, "english") == 0)
3088. {
3089. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3091. if (g_stLocale != locale.szValue)
3092. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3094. g_stLocale = "";
3095. g_stLocaleNameColumn = "locale_name";
3096. }
3097. else if (strcmp(locale.szValue, "germany") == 0)
3098. {
3099. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3101. if (g_stLocale != locale.szValue)
3102. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3104. g_stLocale = "latin1";
3105. g_stLocaleNameColumn = "locale_name";
3106. }
3107. else if (strcmp(locale.szValue, "france") == 0)
3108. {
3109. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3111. if (g_stLocale != locale.szValue)
3112. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3114. g_stLocale = "latin1";
3115. g_stLocaleNameColumn = "locale_name";
3116. }
3117. else if (strcmp(locale.szValue, "italy") == 0)
3118. {
3119. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3121. if (g_stLocale != locale.szValue)
3122. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3124. g_stLocale = "latin1";
3125. g_stLocaleNameColumn = "locale_name";
3126. }
3127. else if (strcmp(locale.szValue, "spain") == 0)
3128. {
3129. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3131. if (g_stLocale != locale.szValue)
3132. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3134. g_stLocale = "latin1";
3135. g_stLocaleNameColumn = "locale_name";
3136. }
3137. else if (strcmp(locale.szValue, "uk") == 0)
3138. {
3139. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3141. if (g_stLocale != locale.szValue)
3142. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3144. g_stLocale = "latin1";
3145. g_stLocaleNameColumn = "locale_name";
3146. }
3147. else if (strcmp(locale.szValue, "turkey") == 0)
3148. {
3149. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3151. if (g_stLocale != locale.szValue)
3152. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3154. g_stLocale = "latin5";
3155. g_stLocaleNameColumn = "locale_name";
3156. }
3157. else if (strcmp(locale.szValue, "poland") == 0)
3158. {
3159. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3161. if (g_stLocale != locale.szValue)
3162. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3164. g_stLocale = "latin2";
3165. g_stLocaleNameColumn = "locale_name";
3166. }
3167. else if (strcmp(locale.szValue, "portugal") == 0)
3168. {
3169. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3171. if (g_stLocale != locale.szValue)
3172. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3174. g_stLocale = "latin1";
3175. g_stLocaleNameColumn = "locale_name";
3176. }
3177. else if (strcmp(locale.szValue, "hongkong") == 0)
3178. {
3179. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3181. if (g_stLocale != locale.szValue)
3182. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "big5");
3184. g_stLocale = "big5";
3185. g_stLocaleNameColumn = "locale_name";
3186. }
3187. else if (strcmp(locale.szValue, "newcibn") == 0)
3188. {
3189. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3191. if (g_stLocale != locale.szValue)
3192. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "gb2312");
3194. g_stLocale = "gb2312";
3195. g_stLocaleNameColumn = "gb2312name";
3196. }
3197. else if (strcmp(locale.szValue, "korea") == 0)
3198. {
3199. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3201. if (g_stLocale != locale.szValue)
3202. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3204. g_stLocale = "euckr";
3205. g_stLocaleNameColumn = "name";
3206. }
3207. else if (strcmp(locale.szValue, "canada") == 0)
3208. {
3209. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3211. if (g_stLocale != locale.szValue)
3212. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3214. g_stLocale = "latin1";
3215. g_stLocaleNameColumn = "gb2312name";
3216. }
3217. else if (strcmp(locale.szValue, "brazil") == 0)
3218. {
3219. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3221. if (g_stLocale != locale.szValue)
3222. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3224. g_stLocale = "latin1";
3225. g_stLocaleNameColumn = "locale_name";
3226. }
3227. else if (strcmp(locale.szValue, "greek") == 0)
3228. {
3229. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3231. if (g_stLocale != locale.szValue)
3232. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3234. g_stLocale = "greek";
3235. g_stLocaleNameColumn = "locale_name";
3236. }
3237. else if (strcmp(locale.szValue, "russia") == 0)
3238. {
3239. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3241. if (g_stLocale != locale.szValue)
3242. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3244. g_stLocale = "cp1251";
3245. g_stLocaleNameColumn = "locale_name";
3246. }
3247. else if (strcmp(locale.szValue, "denmark") == 0)
3248. {
3249. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3251. if (g_stLocale != locale.szValue)
3252. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3254. g_stLocale = "latin1";
3255. g_stLocaleNameColumn = "locale_name";
3256. }
3257. else if (strcmp(locale.szValue, "bulgaria") == 0)
3258. {
3259. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3261. if (g_stLocale != locale.szValue)
3262. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3264. g_stLocale = "cp1251";
3265. g_stLocaleNameColumn = "locale_name";
3266. }
3267. else if (strcmp(locale.szValue, "croatia") == 0)
3268. {
3269. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3271. if (g_stLocale != locale.szValue)
3272. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3274. g_stLocale = "cp1251";
3275. g_stLocaleNameColumn = "locale_name";
3276. }
3277. else if (strcmp(locale.szValue, "mexico") == 0)
3278. {
3279. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3281. if (g_stLocale != locale.szValue)
3282. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3284. g_stLocale = "latin1";
3285. g_stLocaleNameColumn = "locale_name";
3286. }
3287. else if (strcmp(locale.szValue, "arabia") == 0)
3288. {
3289. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3291. if (g_stLocale != locale.szValue)
3292. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3294. g_stLocale = "cp1256";
3295. g_stLocaleNameColumn = "locale_name";
3296. }
3297. else if (strcmp(locale.szValue, "czech") == 0)
3298. {
3299. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3301. if (g_stLocale != locale.szValue)
3302. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3304. g_stLocale = "latin2";
3305. g_stLocaleNameColumn = "locale_name";
3306. }
3307. else if (strcmp(locale.szValue, "hungary") == 0)
3308. {
3309. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3311. if (g_stLocale != locale.szValue)
3312. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3314. g_stLocale = "latin2";
3315. g_stLocaleNameColumn = "locale_name";
3316. }
3317. else if (strcmp(locale.szValue, "romania") == 0)
3318. {
3319. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3321. if (g_stLocale != locale.szValue)
3322. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3324. g_stLocale = "latin2";
3325. g_stLocaleNameColumn = "locale_name";
3326. }
3327. else if (strcmp(locale.szValue, "netherlands") == 0)
3328. {
3329. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3331. if (g_stLocale != locale.szValue)
3332. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3334. g_stLocale = "latin1";
3335. g_stLocaleNameColumn = "locale_name";
3336. }
3337. else if (strcmp(locale.szValue, "singapore") == 0)
3338. {
3339. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3341. if (g_stLocale != locale.szValue)
3342. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3344. g_stLocale = "latin1";
3345. g_stLocaleNameColumn = "locale_name";
3346. }
3347. else if (strcmp(locale.szValue, "vietnam") == 0)
3348. {
3349. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3351. if (g_stLocale != locale.szValue)
3352. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3354. g_stLocale = "latin1";
3355. g_stLocaleNameColumn = "locale_name";
3356. }
3357. else if (strcmp(locale.szValue, "thailand") == 0)
3358. {
3359. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3361. if (g_stLocale != locale.szValue)
3362. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3364. g_stLocale = "latin1";
3365. g_stLocaleNameColumn = "locale_name";
3366. }
3367. else if (strcmp(locale.szValue, "usa") == 0)
3368. {
3369. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3371. if (g_stLocale != locale.szValue)
3372. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "latin1");
3374. g_stLocale = "latin1";
3375. g_stLocaleNameColumn = "locale_name";
3376. }
3377. else if (strcmp(locale.szValue, "we_korea") == 0)
3378. {
3379. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3381. if (g_stLocale != locale.szValue)
3382. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "euckr");
3384. g_stLocale = "euckr";
3385. g_stLocaleNameColumn = "name";
3386. }
3387. else if (strcmp(locale.szValue, "taiwan") == 0)
3388. {
3389. sys_log(0, "locale[LOCALE] = %s", locale.szValue);
3391. if (g_stLocale != locale.szValue)
3392. sys_log(0, "Changed g_stLocale %s to %s", g_stLocale.c_str(), "big5");
3393. g_stLocale = "big5";
3394. g_stLocaleNameColumn = "locale_name";
3395. }
3396. else
3397. {
3398. sys_err("locale[LOCALE] = UNKNOWN(%s)", locale.szValue);
3399. exit(0);
3400. }
3402. CDBManager::instance().SetLocale(g_stLocale.c_str());
3403. }
3404. else if (strcmp(locale.szKey, "DB_NAME_COLUMN") == 0)
3405. {
3406. sys_log(0, "locale[DB_NAME_COLUMN] = %s", locale.szValue);
3407. g_stLocaleNameColumn = locale.szValue;
3408. }
3409. else
3410. {
3411. sys_log(0, "locale[UNKNOWN_KEY(%s)] = %s", locale.szKey, locale.szValue);
3412. }
3413. m_vec_Locale.push_back(locale);
3414. }
3416. delete pMsg;
3418. return true;
3419. }
3420. //END_BOOT_LOCALIZATION
3421. //ADMIN_MANAGER
3423. bool CClientManager::__GetAdminInfo(const char *szIP, std::vector<tAdminInfo> & rAdminVec)
3424. {
3425. //szIP == NULL ÀÏ°æ¿ì ¸ğµç¼­¹ö¿¡ ¿î¿µÀÚ ±ÇÇÑÀ» °®´Â´Ù.
3426. char szQuery[512];
3427. snprintf(szQuery, sizeof(szQuery),
3428. "SELECT mID,mAccount,mName,mContactIP,mServerIP,mAuthority FROM gmlist WHERE mServerIP='ALL' or mServerIP='%s'",
3429. szIP ? szIP : "ALL");
3431. SQLMsg * pMsg = CDBManager::instance().DirectQuery(szQuery, SQL_COMMON);
3433. if (pMsg->Get()->uiNumRows == 0)
3434. {
3435. sys_err("__GetAdminInfo() ==> DirectQuery failed(%s)", szQuery);
3436. delete pMsg;
3437. return false;
3438. }
3440. MYSQL_ROW row;
3441. rAdminVec.reserve(pMsg->Get()->uiNumRows);
3443. while ((row = mysql_fetch_row(pMsg->Get()->pSQLResult)))
3444. {
3445. int idx = 0;
3446. tAdminInfo Info;
3448. str_to_number(Info.m_ID, row[idx++]);
3449. trim_and_lower(row[idx++], Info.m_szAccount, sizeof(Info.m_szAccount));
3450. strlcpy(Info.m_szName, row[idx++], sizeof(Info.m_szName));
3451. strlcpy(Info.m_szContactIP, row[idx++], sizeof(Info.m_szContactIP));
3452. strlcpy(Info.m_szServerIP, row[idx++], sizeof(Info.m_szServerIP));
3453. std::string stAuth = row[idx++];
3455. if (!stAuth.compare("IMPLEMENTOR"))
3456. Info.m_Authority = GM_IMPLEMENTOR;
3457. else if (!stAuth.compare("GOD"))
3458. Info.m_Authority = GM_GOD;
3459. else if (!stAuth.compare("HIGH_WIZARD"))
3460. Info.m_Authority = GM_HIGH_WIZARD;
3461. else if (!stAuth.compare("LOW_WIZARD"))
3462. Info.m_Authority = GM_LOW_WIZARD;
3463. else if (!stAuth.compare("WIZARD"))
3464. Info.m_Authority = GM_WIZARD;
3465. else
3466. continue;
3468. rAdminVec.push_back(Info);
3470. sys_log(0, "GM: PID %u Login %s Character %s ContactIP %s ServerIP %s Authority %d[%s]",
3471. Info.m_ID, Info.m_szAccount, Info.m_szName, Info.m_szContactIP, Info.m_szServerIP, Info.m_Authority, stAuth.c_str());
3472. }
3474. delete pMsg;
3476. return true;
3477. }
3479. bool CClientManager::__GetHostInfo(std::vector<std::string> & rIPVec)
3480. {
3481. char szQuery[512];
3482. snprintf(szQuery, sizeof(szQuery), "SELECT mIP FROM gmhost");
3483. SQLMsg * pMsg = CDBManager::instance().DirectQuery(szQuery, SQL_COMMON);
3485. if (pMsg->Get()->uiNumRows == 0)
3486. {
3487. sys_err("__GetHostInfo() ==> DirectQuery failed(%s)", szQuery);
3488. delete pMsg;
3489. return false;
3490. }
3492. rIPVec.reserve(pMsg->Get()->uiNumRows);
3494. MYSQL_ROW row;
3496. while ((row = mysql_fetch_row(pMsg->Get()->pSQLResult)))
3497. {
3498. if (row[0] && *row[0])
3499. {
3500. rIPVec.push_back(row[0]);
3501. sys_log(0, "GMHOST: %s", row[0]);
3502. }
3503. }
3505. delete pMsg;
3506. return true;
3507. }
3508. //END_ADMIN_MANAGER
3510. void CClientManager::ReloadAdmin(CPeer*, TPacketReloadAdmin* p)
3511. {
3512. std::vector<tAdminInfo> vAdmin;
3513. std::vector<std::string> vHost;
3515. __GetHostInfo(vHost);
3516. __GetAdminInfo(p->szIP, vAdmin);
3518. DWORD dwPacketSize = sizeof(WORD) + sizeof (WORD) + sizeof(tAdminInfo) * vAdmin.size() +
3519. sizeof(WORD) + sizeof(WORD) + 16 * vHost.size();
3521. for (itertype(m_peerList) it = m_peerList.begin(); it != m_peerList.end(); ++it)
3522. {
3523. CPeer * peer = *it;
3525. if (!peer->GetChannel())
3526. continue;
3528. peer->EncodeHeader(HEADER_DG_RELOAD_ADMIN, 0, dwPacketSize);
3530. peer->EncodeWORD(16);
3531. peer->EncodeWORD(vHost.size());
3533. for (size_t n = 0; n < vHost.size(); ++n)
3534. peer->Encode(vHost[n].c_str(), 16);
3536. peer->EncodeWORD(sizeof(tAdminInfo));
3537. peer->EncodeWORD(vAdmin.size());
3539. for (size_t n = 0; n < vAdmin.size(); ++n)
3540. peer->Encode(&vAdmin[n], sizeof(tAdminInfo));
3541. }
3543. sys_log(0, "ReloadAdmin End %s", p->szIP);
3544. }
3546. //BREAK_MARRIAGE
3547. void CClientManager::BreakMarriage(CPeer * peer, const char * data)
3548. {
3549. DWORD pid1, pid2;
3551. pid1 = *(int *) data;
3552. data += sizeof(int);
3554. pid2 = *(int *) data;
3555. data += sizeof(int);
3557. sys_log(0, "Breaking off a marriage engagement! pid %d and pid %d", pid1, pid2);
3558. marriage::CManager::instance().Remove(pid1, pid2);
3559. }
3560. //END_BREAK_MARIIAGE
3562. void CClientManager::UpdateItemCacheSet(DWORD pid)
3563. {
3564. itertype(m_map_pkItemCacheSetPtr) it = m_map_pkItemCacheSetPtr.find(pid);
3566. if (it == m_map_pkItemCacheSetPtr.end())
3567. {
3568. if (g_test_server)
3569. sys_log(0, "UPDATE_ITEMCACHESET : UpdateItemCacheSet ==> No ItemCacheSet pid(%d)", pid);
3570. return;
3571. }
3573. TItemCacheSet * pSet = it->second;
3574. TItemCacheSet::iterator it_set = pSet->begin();
3576. while (it_set != pSet->end())
3577. {
3578. CItemCache * c = *it_set++;
3579. c->Flush();
3580. }
3582. if (g_log)
3583. sys_log(0, "UPDATE_ITEMCACHESET : UpdateItemCachsSet pid(%d)", pid);
3584. }
3586. void CClientManager::SendSpareItemIDRange(CPeer* peer)
3587. {
3588. peer->SendSpareItemIDRange();
3589. }
3591. //
3592. // Login Key¸¸ ¸Ê¿¡¼­ Áö¿î´Ù.
3593. //
3594. void CClientManager::DeleteLoginKey(TPacketDC *data)
3595. {
3596. char login[LOGIN_MAX_LEN+1] = {0};
3597. trim_and_lower(data->login, login, sizeof(login));
3599. CLoginData *pkLD = GetLoginDataByLogin(login);
3601. if (pkLD)
3602. {
3603. TLoginDataByLoginKey::iterator it = m_map_pkLoginData.find(pkLD->GetKey());
3605. if (it != m_map_pkLoginData.end())
3606. m_map_pkLoginData.erase(it);
3607. }
3608. }
3610. // delete gift notify icon
3611. void CClientManager::DeleteAwardId(TPacketDeleteAwardID *data)
3612. {
3613. //sys_log(0,"data from game server arrived %d",data->dwID);
3614. std::map<DWORD, TItemAward *>::iterator it;
3615. it = ItemAwardManager::Instance().GetMapAward().find(data->dwID);
3616. if ( it != ItemAwardManager::Instance().GetMapAward().end() )
3617. {
3618. std::set<TItemAward *> & kSet = ItemAwardManager::Instance().GetMapkSetAwardByLogin()[it->second->szLogin];
3619. if(kSet.erase(it->second))
3620. sys_log(0,"erase ItemAward id: %d from cache", data->dwID);
3621. ItemAwardManager::Instance().GetMapAward().erase(data->dwID);
3622. }
3623. else
3624. {
3625. sys_log(0,"DELETE_AWARDID : could not find the id: %d", data->dwID);
3626. }
3628. }
3630. void CClientManager::UpdateChannelStatus(TChannelStatus* pData)
3631. {
3632. TChannelStatusMap::iterator it = m_mChannelStatus.find(pData->nPort);
3633. if (it != m_mChannelStatus.end()) {
3634. it->second = pData->bStatus;
3635. }
3636. else {
3637. m_mChannelStatus.insert(TChannelStatusMap::value_type(pData->nPort, pData->bStatus));
3638. }
3639. }
3641. void CClientManager::RequestChannelStatus(CPeer* peer, DWORD dwHandle)
3642. {
3643. const int nSize = m_mChannelStatus.size();
3644. peer->EncodeHeader(HEADER_DG_RESPOND_CHANNELSTATUS, dwHandle, sizeof(TChannelStatus)*nSize+sizeof(int));
3645. peer->Encode(&nSize, sizeof(int));
3646. for (TChannelStatusMap::iterator it = m_mChannelStatus.begin(); it != m_mChannelStatus.end(); it++) {
3647. peer->Encode(&it->first, sizeof(short));
3648. peer->Encode(&it->second, sizeof(BYTE));
3649. }
3650. }
3652. void CClientManager::ResetLastPlayerID(const TPacketNeedLoginLogInfo* data)
3653. {
3654. CLoginData* pkLD = GetLoginDataByAID( data->dwPlayerID );
3656. if (NULL != pkLD)
3657. {
3658. pkLD->SetLastPlayerID( 0 );
3659. }
3660. }
3662. void CClientManager::ChargeCash(const TRequestChargeCash* packet)
3663. {
3664. char szQuery[512];
3666. if (ERequestCharge_Cash == packet->eChargeType)
3667. sprintf(szQuery, "update account set `cash` = `cash` + %d where id = %d limit 1", packet->dwAmount, packet->dwAID);
3668. else if(ERequestCharge_Mileage == packet->eChargeType)
3669. sprintf(szQuery, "update account set `mileage` = `mileage` + %d where id = %d limit 1", packet->dwAmount, packet->dwAID);
3670. else
3671. {
3672. sys_err ("Invalid request charge type (type : %d, amount : %d, aid : %d)", packet->eChargeType, packet->dwAmount, packet->dwAID);
3673. return;
3674. }
3676. sys_err ("Request Charge (type : %d, amount : %d, aid : %d)", packet->eChargeType, packet->dwAmount, packet->dwAID);
3678. CDBManager::Instance().AsyncQuery(szQuery, SQL_ACCOUNT);
3679. }

cpp