1. #include "stdafx.h"
  2. #include "constants.h"
  3. #include "config.h"
  4. #include "utils.h"
  5. #include "desc_client.h"
  6. #include "desc_manager.h"
  7. #include "buffer_manager.h"
  8. #include "packet.h"
  9. #include "protocol.h"
  10. #include "char.h"
  11. #include "char_manager.h"
  12. #include "item.h"
  13. #include "item_manager.h"
  14. #include "cmd.h"
  15. #include "shop.h"
  16. #include "shop_manager.h"
  17. #include "safebox.h"
  18. #include "regen.h"
  19. #include "battle.h"
  20. #include "exchange.h"
  21. #include "questmanager.h"
  22. #include "profiler.h"
  23. #include "messenger_manager.h"
  24. #include "party.h"
  25. #include "p2p.h"
  26. #include "affect.h"
  27. #include "guild.h"
  28. #include "guild_manager.h"
  29. #include "log.h"
  30. #include "banword.h"
  31. #include "empire_text_convert.h"
  32. #include "unique_item.h"
  33. #include "building.h"
  34. #include "locale_service.h"
  35. #include "gm.h"
  36. #include "spam.h"
  37. #include "ani.h"
  38. #include "motion.h"
  39. #include "OXEvent.h"
  40. #include "locale_service.h"
  41. #include "HackShield.h"
  42. #include "XTrapManager.h"
  43. #include "DragonSoul.h"
  44. #include "belt_inventory_helper.h" // @fixme119
  45. #include "../../common/CommonDefines.h"
  47. #include "offline_shop.h"
  48. #include "offlineshop_manager.h"
  50. #include "input.h"
  52. #define ENABLE_CHAT_COLOR_SYSTEM
  53. #define ENABLE_CHAT_LOGGING
  54. #define ENABLE_CHAT_SPAMLIMIT
  55. #define ENABLE_WHISPER_CHAT_SPAMLIMIT
  56. #define ENABLE_CHECK_GHOSTMODE
  58. #ifdef ENABLE_CHAT_LOGGING
  59. static char __escape_string[1024];
  60. static char __escape_string2[1024];
  61. #endif
  63. static int __deposit_limit()
  64. {
  65. return (1000*10000); // 1천만
  66. }
  68. #ifdef __SEND_TARGET_INFO__
  69. void CInputMain::TargetInfoLoad(LPCHARACTER ch, const char* c_pData)
  70. {
  71. TPacketCGTargetInfoLoad* p = (TPacketCGTargetInfoLoad*)c_pData;
  72. TPacketGCTargetInfo pInfo;
  73. pInfo.header = HEADER_GC_TARGET_INFO;
  74. static std::vector<LPITEM> s_vec_item;
  75. s_vec_item.clear();
  76. LPITEM pkInfoItem;
  77. LPCHARACTER m_pkChrTarget = CHARACTER_MANAGER::instance().Find(p->dwVID);
  79. if (!ch || !m_pkChrTarget)
  80. return;
  82. if (ITEM_MANAGER::instance().CreateDropItemVector(m_pkChrTarget, ch, s_vec_item) && (m_pkChrTarget->IsMonster() || m_pkChrTarget->IsStone()))
  83. {
  84. if (s_vec_item.size() == 0);
  85. else if (s_vec_item.size() == 1)
  86. {
  87. pkInfoItem = s_vec_item[0];
  88. pInfo.dwVID = m_pkChrTarget->GetVID();
  89. pInfo.race = m_pkChrTarget->GetRaceNum();
  90. pInfo.dwVnum = pkInfoItem->GetVnum();
  91. pInfo.count = pkInfoItem->GetCount();
  92. ch->GetDesc()->Packet(&pInfo, sizeof(TPacketGCTargetInfo));
  93. }
  94. else
  95. {
  96. int iItemIdx = s_vec_item.size() - 1;
  97. while (iItemIdx >= 0)
  98. {
  99. pkInfoItem = s_vec_item[iItemIdx--];
  101. if (!pkInfoItem)
  102. {
  103. sys_err("pkInfoItem null in vector idx %d", iItemIdx + 1);
  104. continue;
  105. }
  107. pInfo.dwVID = m_pkChrTarget->GetVID();
  108. pInfo.race = m_pkChrTarget->GetRaceNum();
  109. pInfo.dwVnum = pkInfoItem->GetVnum();
  110. pInfo.count = pkInfoItem->GetCount();
  111. ch->GetDesc()->Packet(&pInfo, sizeof(TPacketGCTargetInfo));
  112. }
  113. }
  114. }
  115. }
  116. #endif
  118. void SendBlockChatInfo(LPCHARACTER ch, int sec)
  119. {
  120. if (sec <= 0)
  121. {
  122. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("채팅 금지 상태입니다."));
  123. return;
  124. }
  126. long hour = sec / 3600;
  127. sec -= hour * 3600;
  129. long min = (sec / 60);
  130. sec -= min * 60;
  132. char buf[128+1];
  134. if (hour > 0 && min > 0)
  135. snprintf(buf, sizeof(buf), LC_TEXT("%d 시간 %d 분 %d 초 동안 채팅금지 상태입니다"), hour, min, sec);
  136. else if (hour > 0 && min == 0)
  137. snprintf(buf, sizeof(buf), LC_TEXT("%d 시간 %d 초 동안 채팅금지 상태입니다"), hour, sec);
  138. else if (hour == 0 && min > 0)
  139. snprintf(buf, sizeof(buf), LC_TEXT("%d 분 %d 초 동안 채팅금지 상태입니다"), min, sec);
  140. else
  141. snprintf(buf, sizeof(buf), LC_TEXT("%d 초 동안 채팅금지 상태입니다"), sec);
  143. ch->ChatPacket(CHAT_TYPE_INFO, buf);
  144. }
  146. EVENTINFO(spam_event_info)
  147. {
  148. char host[MAX_HOST_LENGTH+1];
  150. spam_event_info()
  151. {
  152. ::memset( host, 0, MAX_HOST_LENGTH+1 );
  153. }
  154. };
  156. typedef boost::unordered_map<std::string, std::pair<unsigned int, LPEVENT> > spam_score_of_ip_t;
  157. spam_score_of_ip_t spam_score_of_ip;
  159. EVENTFUNC(block_chat_by_ip_event)
  160. {
  161. spam_event_info* info = dynamic_cast<spam_event_info*>( event->info );
  163. if ( info == NULL )
  164. {
  165. sys_err( "block_chat_by_ip_event> <Factor> Null pointer" );
  166. return 0;
  167. }
  169. const char * host = info->host;
  171. spam_score_of_ip_t::iterator it = spam_score_of_ip.find(host);
  173. if (it != spam_score_of_ip.end())
  174. {
  175. it->second.first = 0;
  176. it->second.second = NULL;
  177. }
  179. return 0;
  180. }
  182. bool SpamBlockCheck(LPCHARACTER ch, const char* const buf, const size_t buflen)
  183. {
  184. if (ch->GetLevel() < g_iSpamBlockMaxLevel)
  185. {
  186. spam_score_of_ip_t::iterator it = spam_score_of_ip.find(ch->GetDesc()->GetHostName());
  188. if (it == spam_score_of_ip.end())
  189. {
  190. spam_score_of_ip.insert(std::make_pair(ch->GetDesc()->GetHostName(), std::make_pair(0, (LPEVENT) NULL)));
  191. it = spam_score_of_ip.find(ch->GetDesc()->GetHostName());
  192. }
  194. if (it->second.second)
  195. {
  196. SendBlockChatInfo(ch, event_time(it->second.second) / passes_per_sec);
  197. return true;
  198. }
  200. unsigned int score;
  201. const char * word = SpamManager::instance().GetSpamScore(buf, buflen, score);
  203. it->second.first += score;
  205. if (word)
  206. sys_log(0, "SPAM_SCORE: %s text: %s score: %u total: %u word: %s", ch->GetName(), buf, score, it->second.first, word);
  208. if (it->second.first >= g_uiSpamBlockScore)
  209. {
  210. spam_event_info* info = AllocEventInfo<spam_event_info>();
  211. strlcpy(info->host, ch->GetDesc()->GetHostName(), sizeof(info->host));
  213. it->second.second = event_create(block_chat_by_ip_event, info, PASSES_PER_SEC(g_uiSpamBlockDuration));
  214. sys_log(0, "SPAM_IP: %s for %u seconds", info->host, g_uiSpamBlockDuration);
  216. LogManager::instance().CharLog(ch, 0, "SPAM", word);
  218. SendBlockChatInfo(ch, event_time(it->second.second) / passes_per_sec);
  220. return true;
  221. }
  222. }
  224. return false;
  225. }
  227. enum
  228. {
  229. TEXT_TAG_PLAIN,
  230. TEXT_TAG_TAG, // ||
  231. TEXT_TAG_COLOR, // |cffffffff
  232. TEXT_TAG_HYPERLINK_START, // |H
  233. TEXT_TAG_HYPERLINK_END, // |h ex) |Hitem:1234:1:1:1|h
  234. TEXT_TAG_RESTORE_COLOR,
  235. };
  237. int GetTextTag(const char * src, int maxLen, int & tagLen, std::string & extraInfo)
  238. {
  239. tagLen = 1;
  241. if (maxLen < 2 || *src != '|')
  242. return TEXT_TAG_PLAIN;
  244. const char * cur = ++src;
  246. if (*cur == '|') // ||는 |로 표시한다.
  247. {
  248. tagLen = 2;
  249. return TEXT_TAG_TAG;
  250. }
  251. else if (*cur == 'c') // color |cffffffffblahblah|r
  252. {
  253. tagLen = 2;
  254. return TEXT_TAG_COLOR;
  255. }
  256. else if (*cur == 'H') // hyperlink |Hitem:10000:0:0:0:0|h[이름]|h
  257. {
  258. tagLen = 2;
  259. return TEXT_TAG_HYPERLINK_START;
  260. }
  261. else if (*cur == 'h') // end of hyperlink
  262. {
  263. tagLen = 2;
  264. return TEXT_TAG_HYPERLINK_END;
  265. }
  267. return TEXT_TAG_PLAIN;
  268. }
  270. void GetTextTagInfo(const char * src, int src_len, int & hyperlinks, bool & colored)
  271. {
  272. colored = false;
  273. hyperlinks = 0;
  275. int len;
  276. std::string extraInfo;
  278. for (int i = 0; i < src_len;)
  279. {
  280. int tag = GetTextTag(&src[i], src_len - i, len, extraInfo);
  282. if (tag == TEXT_TAG_HYPERLINK_START)
  283. ++hyperlinks;
  285. if (tag == TEXT_TAG_COLOR)
  286. colored = true;
  288. i += len;
  289. }
  290. }
  292. int ProcessTextTag(LPCHARACTER ch, const char * c_pszText, size_t len)
  293. {
  294. //개인상점중에 금강경을 사용할 경우
  295. //0 : 정상적으로 사용
  296. //1 : 금강경 부족
  297. //2 : 금강경이 있으나, 개인상점에서 사용중
  298. //3 : 기타
  299. //4 : 에러
  300. int hyperlinks;
  301. bool colored;
  303. GetTextTagInfo(c_pszText, len, hyperlinks, colored);
  305. if (colored == true && hyperlinks == 0)
  306. return 4;
  308. #ifdef ENABLE_NEWSTUFF
  309. if (g_bDisablePrismNeed)
  310. return 0;
  311. #endif
  312. int nPrismCount = ch->CountSpecifyItem(ITEM_PRISM);
  314. if (nPrismCount < hyperlinks)
  315. return 1;
  318. if (!ch->GetMyShop())
  319. {
  320. ch->RemoveSpecifyItem(ITEM_PRISM, hyperlinks);
  321. return 0;
  322. } else
  323. {
  324. int sellingNumber = ch->GetMyShop()->GetNumberByVnum(ITEM_PRISM);
  325. if(nPrismCount - sellingNumber < hyperlinks)
  326. {
  327. return 2;
  328. } else
  329. {
  330. ch->RemoveSpecifyItem(ITEM_PRISM, hyperlinks);
  331. return 0;
  332. }
  333. }
  335. return 4;
  336. }
  338. int CInputMain::Whisper(LPCHARACTER ch, const char * data, size_t uiBytes)
  339. {
  340. const TPacketCGWhisper* pinfo = reinterpret_cast<const TPacketCGWhisper*>(data);
  342. if (uiBytes < pinfo->wSize)
  343. return -1;
  345. int iExtraLen = pinfo->wSize - sizeof(TPacketCGWhisper);
  347. if (iExtraLen < 0)
  348. {
  349. sys_err("invalid packet length (len %d size %u buffer %u)", iExtraLen, pinfo->wSize, uiBytes);
  350. ch->GetDesc()->SetPhase(PHASE_CLOSE);
  351. return -1;
  352. }
  354. #ifdef ENABLE_WHISPER_CHAT_SPAMLIMIT
  355. if (ch->IncreaseChatCounter() >= 10)
  356. {
  357. ch->GetDesc()->DelayedDisconnect(0);
  358. return (iExtraLen);
  359. }
  360. #endif
  362. if (ch->FindAffect(AFFECT_BLOCK_CHAT))
  363. {
  364. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("채팅 금지 상태입니다."));
  365. return (iExtraLen);
  366. }
  368. LPCHARACTER pkChr = CHARACTER_MANAGER::instance().FindPC(pinfo->szNameTo);
  370. if (pkChr == ch)
  371. return (iExtraLen);
  373. LPDESC pkDesc = NULL;
  375. BYTE bOpponentEmpire = 0;
  377. if (test_server)
  378. {
  379. if (!pkChr)
  380. sys_log(0, "Whisper to %s(%s) from %s", "Null", pinfo->szNameTo, ch->GetName());
  381. else
  382. sys_log(0, "Whisper to %s(%s) from %s", pkChr->GetName(), pinfo->szNameTo, ch->GetName());
  383. }
  385. if (ch->IsBlockMode(BLOCK_WHISPER))
  386. {
  387. if (ch->GetDesc())
  388. {
  389. TPacketGCWhisper pack;
  390. pack.bHeader = HEADER_GC_WHISPER;
  391. pack.bType = WHISPER_TYPE_SENDER_BLOCKED;
  392. pack.wSize = sizeof(TPacketGCWhisper);
  393. strlcpy(pack.szNameFrom, pinfo->szNameTo, sizeof(pack.szNameFrom));
  394. ch->GetDesc()->Packet(&pack, sizeof(pack));
  395. }
  396. return iExtraLen;
  397. }
  399. if (!pkChr)
  400. {
  401. CCI * pkCCI = P2P_MANAGER::instance().Find(pinfo->szNameTo);
  403. if (pkCCI)
  404. {
  405. pkDesc = pkCCI->pkDesc;
  406. pkDesc->SetRelay(pinfo->szNameTo);
  407. bOpponentEmpire = pkCCI->bEmpire;
  409. if (test_server)
  410. sys_log(0, "Whisper to %s from %s (Channel %d Mapindex %d)", "Null", ch->GetName(), pkCCI->bChannel, pkCCI->lMapIndex);
  411. }
  412. }
  413. else
  414. {
  415. pkDesc = pkChr->GetDesc();
  416. bOpponentEmpire = pkChr->GetEmpire();
  417. }
  419. if (!pkDesc)
  420. {
  421. if (ch->GetDesc())
  422. {
  423. TPacketGCWhisper pack;
  425. pack.bHeader = HEADER_GC_WHISPER;
  426. pack.bType = WHISPER_TYPE_NOT_EXIST;
  427. pack.wSize = sizeof(TPacketGCWhisper);
  428. strlcpy(pack.szNameFrom, pinfo->szNameTo, sizeof(pack.szNameFrom));
  429. ch->GetDesc()->Packet(&pack, sizeof(TPacketGCWhisper));
  430. sys_log(0, "WHISPER: no player");
  431. }
  432. }
  433. else
  434. {
  435. if (ch->IsBlockMode(BLOCK_WHISPER))
  436. {
  437. if (ch->GetDesc())
  438. {
  439. TPacketGCWhisper pack;
  440. pack.bHeader = HEADER_GC_WHISPER;
  441. pack.bType = WHISPER_TYPE_SENDER_BLOCKED;
  442. pack.wSize = sizeof(TPacketGCWhisper);
  443. strlcpy(pack.szNameFrom, pinfo->szNameTo, sizeof(pack.szNameFrom));
  444. ch->GetDesc()->Packet(&pack, sizeof(pack));
  445. }
  446. }
  447. else if (pkChr && pkChr->IsBlockMode(BLOCK_WHISPER))
  448. {
  449. if (ch->GetDesc())
  450. {
  451. TPacketGCWhisper pack;
  452. pack.bHeader = HEADER_GC_WHISPER;
  453. pack.bType = WHISPER_TYPE_TARGET_BLOCKED;
  454. pack.wSize = sizeof(TPacketGCWhisper);
  455. strlcpy(pack.szNameFrom, pinfo->szNameTo, sizeof(pack.szNameFrom));
  456. ch->GetDesc()->Packet(&pack, sizeof(pack));
  457. }
  458. }
  459. else
  460. {
  461. BYTE bType = WHISPER_TYPE_NORMAL;
  463. char buf[CHAT_MAX_LEN + 1];
  464. strlcpy(buf, data + sizeof(TPacketCGWhisper), MIN(iExtraLen + 1, sizeof(buf)));
  465. const size_t buflen = strlen(buf);
  467. if (true == SpamBlockCheck(ch, buf, buflen))
  468. {
  469. if (!pkChr)
  470. {
  471. CCI * pkCCI = P2P_MANAGER::instance().Find(pinfo->szNameTo);
  473. if (pkCCI)
  474. {
  475. pkDesc->SetRelay("");
  476. }
  477. }
  478. return iExtraLen;
  479. }
  481. CBanwordManager::instance().ConvertString(buf, buflen);
  483. if (g_bEmpireWhisper)
  484. if (!ch->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE))
  485. if (!(pkChr && pkChr->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE)))
  486. if (bOpponentEmpire != ch->GetEmpire() && ch->GetEmpire() && bOpponentEmpire // 서로 제국이 다르면서
  487. && ch->GetGMLevel() == GM_PLAYER && gm_get_level(pinfo->szNameTo) == GM_PLAYER) // 둘다 일반 플레이어이면
  488. // 이름 밖에 모르니 gm_get_level 함수를 사용
  489. {
  490. if (!pkChr)
  491. {
  492. // 다른 서버에 있으니 제국 표시만 한다. bType의 상위 4비트를 Empire번호로 사용한다.
  493. bType = ch->GetEmpire() << 4;
  494. }
  495. else
  496. {
  497. ConvertEmpireText(ch->GetEmpire(), buf, buflen, 10 + 2 * pkChr->GetSkillPower(SKILL_LANGUAGE1 + ch->GetEmpire() - 1)/*변환확률*/);
  498. }
  499. }
  501. int processReturn = ProcessTextTag(ch, buf, buflen);
  502. if (0!=processReturn)
  503. {
  504. if (ch->GetDesc())
  505. {
  506. TItemTable * pTable = ITEM_MANAGER::instance().GetTable(ITEM_PRISM);
  508. if (pTable)
  509. {
  510. char buf[128];
  511. int len;
  512. if (3==processReturn) //교환중
  513. len = snprintf(buf, sizeof(buf), LC_TEXT("사용할수 없습니다."), pTable->szLocaleName);
  514. else
  515. len = snprintf(buf, sizeof(buf), LC_TEXT("%s이 필요합니다."), pTable->szLocaleName);
  517. if (len < 0 || len >= (int) sizeof(buf))
  518. len = sizeof(buf) - 1;
  520. ++len; // \0 문자 포함
  522. TPacketGCWhisper pack;
  524. pack.bHeader = HEADER_GC_WHISPER;
  525. pack.bType = WHISPER_TYPE_ERROR;
  526. pack.wSize = sizeof(TPacketGCWhisper) + len;
  527. strlcpy(pack.szNameFrom, pinfo->szNameTo, sizeof(pack.szNameFrom));
  529. ch->GetDesc()->BufferedPacket(&pack, sizeof(pack));
  530. ch->GetDesc()->Packet(buf, len);
  532. sys_log(0, "WHISPER: not enough %s: char: %s", pTable->szLocaleName, ch->GetName());
  533. }
  534. }
  536. // 릴래이 상태일 수 있으므로 릴래이를 풀어준다.
  537. pkDesc->SetRelay("");
  538. return (iExtraLen);
  539. }
  541. if (ch->IsGM())
  542. bType = (bType & 0xF0) | WHISPER_TYPE_GM;
  544. if (buflen > 0)
  545. {
  546. TPacketGCWhisper pack;
  548. pack.bHeader = HEADER_GC_WHISPER;
  549. pack.wSize = sizeof(TPacketGCWhisper) + buflen;
  550. pack.bType = bType;
  551. strlcpy(pack.szNameFrom, ch->GetName(), sizeof(pack.szNameFrom));
  553. // desc->BufferedPacket을 하지 않고 버퍼에 써야하는 이유는
  554. // P2P relay되어 패킷이 캡슐화 될 수 있기 때문이다.
  555. TEMP_BUFFER tmpbuf;
  557. tmpbuf.write(&pack, sizeof(pack));
  558. tmpbuf.write(buf, buflen);
  560. pkDesc->Packet(tmpbuf.read_peek(), tmpbuf.size());
  562. // @warme006
  563. // sys_log(0, "WHISPER: %s -> %s : %s", ch->GetName(), pinfo->szNameTo, buf);
  564. #ifdef ENABLE_CHAT_LOGGING
  565. if (ch->IsGM())
  566. {
  567. LogManager::instance().EscapeString(__escape_string, sizeof(__escape_string), buf, buflen);
  568. LogManager::instance().EscapeString(__escape_string2, sizeof(__escape_string2), pinfo->szNameTo, sizeof(pack.szNameFrom));
  569. LogManager::instance().ChatLog(ch->GetMapIndex(), ch->GetPlayerID(), ch->GetName(), 0, __escape_string2, "WHISPER", __escape_string, ch->GetDesc() ? ch->GetDesc()->GetHostName() : "");
  570. }
  571. #endif
  572. }
  573. }
  574. }
  575. if(pkDesc)
  576. pkDesc->SetRelay("");
  578. return (iExtraLen);
  579. }
  581. struct RawPacketToCharacterFunc
  582. {
  583. const void * m_buf;
  584. int m_buf_len;
  586. RawPacketToCharacterFunc(const void * buf, int buf_len) : m_buf(buf), m_buf_len(buf_len)
  587. {
  588. }
  590. void operator () (LPCHARACTER c)
  591. {
  592. if (!c->GetDesc())
  593. return;
  595. c->GetDesc()->Packet(m_buf, m_buf_len);
  596. }
  597. };
  599. struct FEmpireChatPacket
  600. {
  601. packet_chat& p;
  602. const char* orig_msg;
  603. int orig_len;
  604. char converted_msg[CHAT_MAX_LEN+1];
  606. BYTE bEmpire;
  607. int iMapIndex;
  608. int namelen;
  610. FEmpireChatPacket(packet_chat& p, const char* chat_msg, int len, BYTE bEmpire, int iMapIndex, int iNameLen)
  611. : p(p), orig_msg(chat_msg), orig_len(len), bEmpire(bEmpire), iMapIndex(iMapIndex), namelen(iNameLen)
  612. {
  613. memset( converted_msg, 0, sizeof(converted_msg) );
  614. }
  616. void operator () (LPDESC d)
  617. {
  618. if (!d->GetCharacter())
  619. return;
  621. if (d->GetCharacter()->GetMapIndex() != iMapIndex)
  622. return;
  624. d->BufferedPacket(&p, sizeof(packet_chat));
  626. if (d->GetEmpire() == bEmpire ||
  627. bEmpire == 0 ||
  628. d->GetCharacter()->GetGMLevel() > GM_PLAYER ||
  629. d->GetCharacter()->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE))
  630. {
  631. d->Packet(orig_msg, orig_len);
  632. }
  633. else
  634. {
  635. // 사람마다 스킬레벨이 다르니 매번 해야합니다
  636. size_t len = strlcpy(converted_msg, orig_msg, sizeof(converted_msg));
  638. if (len >= sizeof(converted_msg))
  639. len = sizeof(converted_msg) - 1;
  641. ConvertEmpireText(bEmpire, converted_msg + namelen, len - namelen, 10 + 2 * d->GetCharacter()->GetSkillPower(SKILL_LANGUAGE1 + bEmpire - 1));
  642. d->Packet(converted_msg, orig_len);
  643. }
  644. }
  645. };
  647. struct FYmirChatPacket
  648. {
  649. packet_chat& packet;
  650. const char* m_szChat;
  651. size_t m_lenChat;
  652. const char* m_szName;
  654. int m_iMapIndex;
  655. BYTE m_bEmpire;
  656. bool m_ring;
  658. char m_orig_msg[CHAT_MAX_LEN+1];
  659. int m_len_orig_msg;
  660. char m_conv_msg[CHAT_MAX_LEN+1];
  661. int m_len_conv_msg;
  663. FYmirChatPacket(packet_chat& p, const char* chat, size_t len_chat, const char* name, size_t len_name, int iMapIndex, BYTE empire, bool ring)
  664. : packet(p),
  665. m_szChat(chat), m_lenChat(len_chat),
  666. m_szName(name),
  667. m_iMapIndex(iMapIndex), m_bEmpire(empire),
  668. m_ring(ring)
  669. {
  670. m_len_orig_msg = snprintf(m_orig_msg, sizeof(m_orig_msg), "%s : %s", m_szName, m_szChat) + 1; // 널 문자 포함
  672. if (m_len_orig_msg < 0 || m_len_orig_msg >= (int) sizeof(m_orig_msg))
  673. m_len_orig_msg = sizeof(m_orig_msg) - 1;
  675. m_len_conv_msg = snprintf(m_conv_msg, sizeof(m_conv_msg), "??? : %s", m_szChat) + 1; // 널 문자 미포함
  677. if (m_len_conv_msg < 0 || m_len_conv_msg >= (int) sizeof(m_conv_msg))
  678. m_len_conv_msg = sizeof(m_conv_msg) - 1;
  680. ConvertEmpireText(m_bEmpire, m_conv_msg + 6, m_len_conv_msg - 6, 10); // 6은 "??? : "의 길이
  681. }
  683. void operator() (LPDESC d)
  684. {
  685. if (!d->GetCharacter())
  686. return;
  688. if (d->GetCharacter()->GetMapIndex() != m_iMapIndex)
  689. return;
  691. if (m_ring ||
  692. d->GetEmpire() == m_bEmpire ||
  693. d->GetCharacter()->GetGMLevel() > GM_PLAYER ||
  694. d->GetCharacter()->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE))
  695. {
  696. packet.size = m_len_orig_msg + sizeof(TPacketGCChat);
  698. d->BufferedPacket(&packet, sizeof(packet_chat));
  699. d->Packet(m_orig_msg, m_len_orig_msg);
  700. }
  701. else
  702. {
  703. packet.size = m_len_conv_msg + sizeof(TPacketGCChat);
  705. d->BufferedPacket(&packet, sizeof(packet_chat));
  706. d->Packet(m_conv_msg, m_len_conv_msg);
  707. }
  708. }
  709. };
  711. int CInputMain::Chat(LPCHARACTER ch, const char * data, size_t uiBytes)
  712. {
  713. const TPacketCGChat* pinfo = reinterpret_cast<const TPacketCGChat*>(data);
  715. if (uiBytes < pinfo->size)
  716. return -1;
  718. const int iExtraLen = pinfo->size - sizeof(TPacketCGChat);
  720. if (iExtraLen < 0)
  721. {
  722. sys_err("invalid packet length (len %d size %u buffer %u)", iExtraLen, pinfo->size, uiBytes);
  723. ch->GetDesc()->SetPhase(PHASE_CLOSE);
  724. return -1;
  725. }
  727. char buf[CHAT_MAX_LEN - (CHARACTER_NAME_MAX_LEN + 3) + 1];
  728. strlcpy(buf, data + sizeof(TPacketCGChat), MIN(iExtraLen + 1, sizeof(buf)));
  729. const size_t buflen = strlen(buf);
  731. if (buflen > 1 && *buf == '/')
  732. {
  733. interpret_command(ch, buf + 1, buflen - 1);
  734. return iExtraLen;
  735. }
  736. #ifdef ENABLE_CHAT_SPAMLIMIT
  737. if (ch->IncreaseChatCounter() >= 4)
  738. {
  739. if (ch->GetChatCounter() == 10)
  740. ch->GetDesc()->DelayedDisconnect(0);
  741. return iExtraLen;
  742. }
  743. #else
  744. if (ch->IncreaseChatCounter() >= 10)
  745. {
  746. if (ch->GetChatCounter() == 10)
  747. {
  748. sys_log(0, "CHAT_HACK: %s", ch->GetName());
  749. ch->GetDesc()->DelayedDisconnect(5);
  750. }
  752. return iExtraLen;
  753. }
  754. #endif
  756. // 채팅 금지 Affect 처리
  757. const CAffect* pAffect = ch->FindAffect(AFFECT_BLOCK_CHAT);
  759. if (pAffect != NULL)
  760. {
  761. SendBlockChatInfo(ch, pAffect->lDuration);
  762. return iExtraLen;
  763. }
  765. if (true == SpamBlockCheck(ch, buf, buflen))
  766. {
  767. return iExtraLen;
  768. }
  770. // @fixme133 begin
  771. CBanwordManager::instance().ConvertString(buf, buflen);
  773. int processReturn = ProcessTextTag(ch, buf, buflen);
  774. if (0!=processReturn)
  775. {
  776. const TItemTable* pTable = ITEM_MANAGER::instance().GetTable(ITEM_PRISM);
  778. if (NULL != pTable)
  779. {
  780. if (3==processReturn) //교환중
  781. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용할수 없습니다."), pTable->szLocaleName);
  782. else
  783. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%s이 필요합니다."), pTable->szLocaleName);
  785. }
  787. return iExtraLen;
  788. }
  789. // @fixme133 end
  791. char chatbuf[CHAT_MAX_LEN + 1];
  792. #ifdef ENABLE_CHAT_COLOR_SYSTEM
  793. // static const char* colorbuf[] = {" |h|r[寔햇?|cFFffa200|h", " |h|r[遁鞍?|cFFff0000|h", " |h|r[讀安?|cFFffc700|h", " |h|r[警仰]|cFF000bff|h"}; // Arab
  794. static const char* colorbuf[] = {"|cFFffa200|H|h[Staff]|h|r", "|cFFff0000|H|h[Shinsoo]|h|r", "|cFFffc700|H|h[Chunjo]|h|r", "|cFF000bff|H|h[Jinno]|h|r"};
  795. int len = snprintf(chatbuf, sizeof(chatbuf), "%s %s : %s", (ch->IsGM()?colorbuf[0]:colorbuf[MINMAX(0, ch->GetEmpire(), 3)]), ch->GetName(), buf);
  796. #else
  797. int len = snprintf(chatbuf, sizeof(chatbuf), "%s : %s", ch->GetName(), buf);
  798. #endif
  799. if (CHAT_TYPE_SHOUT == pinfo->type)
  800. {
  801. LogManager::instance().ShoutLog(g_bChannel, ch->GetEmpire(), chatbuf);
  802. }
  804. if (len < 0 || len >= (int) sizeof(chatbuf))
  805. len = sizeof(chatbuf) - 1;
  807. if (pinfo->type == CHAT_TYPE_SHOUT)
  808. {
  809. // const int SHOUT_LIMIT_LEVEL = 15;
  811. if (ch->GetLevel() < g_iShoutLimitLevel)
  812. {
  813. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("외치기는 레벨 %d 이상만 사용 가능 합니다."), g_iShoutLimitLevel);
  814. return (iExtraLen);
  815. }
  817. // if (thecore_heart->pulse - (int) ch->GetLastShoutPulse() < passes_per_sec * g_iShoutLimitTime)
  818. if (thecore_heart->pulse - (int) ch->GetLastShoutPulse() < passes_per_sec * 15)
  819. return (iExtraLen);
  821. ch->SetLastShoutPulse(thecore_heart->pulse);
  823. TPacketGGShout p;
  825. p.bHeader = HEADER_GG_SHOUT;
  826. p.bEmpire = ch->GetEmpire();
  827. strlcpy(p.szText, chatbuf, sizeof(p.szText));
  829. P2P_MANAGER::instance().Send(&p, sizeof(TPacketGGShout));
  831. SendShout(chatbuf, ch->GetEmpire());
  833. return (iExtraLen);
  834. }
  836. TPacketGCChat pack_chat;
  838. pack_chat.header = HEADER_GC_CHAT;
  839. pack_chat.size = sizeof(TPacketGCChat) + len;
  840. pack_chat.type = pinfo->type;
  841. pack_chat.id = ch->GetVID();
  843. switch (pinfo->type)
  844. {
  845. case CHAT_TYPE_TALKING:
  846. {
  847. const DESC_MANAGER::DESC_SET & c_ref_set = DESC_MANAGER::instance().GetClientSet();
  849. if (false)
  850. {
  851. std::for_each(c_ref_set.begin(), c_ref_set.end(),
  852. FYmirChatPacket(pack_chat,
  853. buf,
  854. strlen(buf),
  855. ch->GetName(),
  856. strlen(ch->GetName()),
  857. ch->GetMapIndex(),
  858. ch->GetEmpire(),
  859. ch->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE)));
  860. }
  861. else
  862. {
  863. std::for_each(c_ref_set.begin(), c_ref_set.end(),
  864. FEmpireChatPacket(pack_chat,
  865. chatbuf,
  866. len,
  867. (ch->GetGMLevel() > GM_PLAYER ||
  868. ch->IsEquipUniqueGroup(UNIQUE_GROUP_RING_OF_LANGUAGE)) ? 0 : ch->GetEmpire(),
  869. ch->GetMapIndex(), strlen(ch->GetName())));
  870. #ifdef ENABLE_CHAT_LOGGING
  871. if (ch->IsGM())
  872. {
  873. LogManager::instance().EscapeString(__escape_string, sizeof(__escape_string), chatbuf, len);
  874. LogManager::instance().ChatLog(ch->GetMapIndex(), ch->GetPlayerID(), ch->GetName(), 0, "", "NORMAL", __escape_string, ch->GetDesc() ? ch->GetDesc()->GetHostName() : "");
  875. }
  876. #endif
  877. }
  878. }
  879. break;
  881. case CHAT_TYPE_PARTY:
  882. {
  883. if (!ch->GetParty())
  884. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("파티 중이 아닙니다."));
  885. else
  886. {
  887. TEMP_BUFFER tbuf;
  889. tbuf.write(&pack_chat, sizeof(pack_chat));
  890. tbuf.write(chatbuf, len);
  892. RawPacketToCharacterFunc f(tbuf.read_peek(), tbuf.size());
  893. ch->GetParty()->ForEachOnlineMember(f);
  894. #ifdef ENABLE_CHAT_LOGGING
  895. if (ch->IsGM())
  896. {
  897. LogManager::instance().EscapeString(__escape_string, sizeof(__escape_string), chatbuf, len);
  898. LogManager::instance().ChatLog(ch->GetMapIndex(), ch->GetPlayerID(), ch->GetName(), ch->GetParty()->GetLeaderPID(), "", "PARTY", __escape_string, ch->GetDesc() ? ch->GetDesc()->GetHostName() : "");
  899. }
  900. #endif
  901. }
  902. }
  903. break;
  905. case CHAT_TYPE_GUILD:
  906. {
  907. if (!ch->GetGuild())
  908. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("길드에 가입하지 않았습니다."));
  909. else
  910. {
  911. ch->GetGuild()->Chat(chatbuf);
  912. #ifdef ENABLE_CHAT_LOGGING
  913. if (ch->IsGM())
  914. {
  915. LogManager::instance().EscapeString(__escape_string, sizeof(__escape_string), chatbuf, len);
  916. LogManager::instance().ChatLog(ch->GetMapIndex(), ch->GetPlayerID(), ch->GetName(), ch->GetGuild()->GetID(), ch->GetGuild()->GetName(), "GUILD", __escape_string, ch->GetDesc() ? ch->GetDesc()->GetHostName() : "");
  917. }
  918. #endif
  919. }
  920. }
  921. break;
  923. default:
  924. sys_err("Unknown chat type %d", pinfo->type);
  925. break;
  926. }
  928. return (iExtraLen);
  929. }
  931. void CInputMain::ItemUse(LPCHARACTER ch, const char * data)
  932. {
  933. ch->UseItem(((struct command_item_use *) data)->Cell);
  934. }
  936. void CInputMain::ItemToItem(LPCHARACTER ch, const char * pcData)
  937. {
  938. TPacketCGItemUseToItem * p = (TPacketCGItemUseToItem *) pcData;
  939. if (ch)
  940. ch->UseItem(p->Cell, p->TargetCell);
  941. }
  943. void CInputMain::ItemDrop(LPCHARACTER ch, const char * data)
  944. {
  945. struct command_item_drop * pinfo = (struct command_item_drop *) data;
  947. //MONARCH_LIMIT
  948. //if (ch->IsMonarch())
  949. // return;
  950. //END_MONARCH_LIMIT
  951. if (!ch)
  952. return;
  954. // 엘크가 0보다 크면 엘크를 버리는 것 이다.
  955. if (pinfo->gold > 0)
  956. ch->DropGold(pinfo->gold);
  957. else
  958. ch->DropItem(pinfo->Cell);
  959. }
  961. void CInputMain::ItemDrop2(LPCHARACTER ch, const char * data)
  962. {
  963. //MONARCH_LIMIT
  964. //if (ch->IsMonarch())
  965. // return;
  966. //END_MONARCH_LIMIT
  968. TPacketCGItemDrop2 * pinfo = (TPacketCGItemDrop2 *) data;
  970. // 엘크가 0보다 크면 엘크를 버리는 것 이다.
  972. if (!ch)
  973. return;
  974. if (pinfo->gold > 0)
  975. ch->DropGold(pinfo->gold);
  976. else
  977. ch->DropItem(pinfo->Cell, pinfo->count);
  978. }
  980. #ifdef __DESTROYSELL_SYSTEM__
  981. void CInputMain::ItemDestroy(LPCHARACTER ch, const char * data)
  982. {
  983. struct command_item_destroy * pinfo = (struct command_item_destroy *) data;
  984. if (ch)
  985. ch->DestroyItem(pinfo->Cell);
  986. }
  988. void CInputMain::ItemSell(LPCHARACTER ch, const char * data)
  989. {
  990. struct command_item_sell * pinfo = (struct command_item_sell *) data;
  991. if (ch)
  992. ch->SellItem(pinfo->Cell);
  993. }
  994. #endif
  996. void CInputMain::ItemMove(LPCHARACTER ch, const char * data)
  997. {
  998. struct command_item_move * pinfo = (struct command_item_move *) data;
  1000. if (ch)
  1001. ch->MoveItem(pinfo->Cell, pinfo->CellTo, pinfo->count);
  1002. }
  1004. void CInputMain::ItemPickup(LPCHARACTER ch, const char * data)
  1005. {
  1006. struct command_item_pickup * pinfo = (struct command_item_pickup*) data;
  1007. if (ch)
  1008. ch->PickupItem(pinfo->vid);
  1009. }
  1011. void CInputMain::QuickslotAdd(LPCHARACTER ch, const char * data)
  1012. {
  1013. struct command_quickslot_add * pinfo = (struct command_quickslot_add *) data;
  1014. ch->SetQuickslot(pinfo->pos, pinfo->slot);
  1015. }
  1017. void CInputMain::QuickslotDelete(LPCHARACTER ch, const char * data)
  1018. {
  1019. struct command_quickslot_del * pinfo = (struct command_quickslot_del *) data;
  1020. ch->DelQuickslot(pinfo->pos);
  1021. }
  1023. void CInputMain::QuickslotSwap(LPCHARACTER ch, const char * data)
  1024. {
  1025. struct command_quickslot_swap * pinfo = (struct command_quickslot_swap *) data;
  1026. ch->SwapQuickslot(pinfo->pos, pinfo->change_pos);
  1027. }
  1029. int CInputMain::Messenger(LPCHARACTER ch, const char* c_pData, size_t uiBytes)
  1030. {
  1031. TPacketCGMessenger* p = (TPacketCGMessenger*) c_pData;
  1033. if (uiBytes < sizeof(TPacketCGMessenger))
  1034. return -1;
  1036. c_pData += sizeof(TPacketCGMessenger);
  1037. uiBytes -= sizeof(TPacketCGMessenger);
  1039. switch (p->subheader)
  1040. {
  1041. case MESSENGER_SUBHEADER_CG_ADD_BY_VID:
  1042. {
  1043. if (uiBytes < sizeof(TPacketCGMessengerAddByVID))
  1044. return -1;
  1046. TPacketCGMessengerAddByVID * p2 = (TPacketCGMessengerAddByVID *) c_pData;
  1047. LPCHARACTER ch_companion = CHARACTER_MANAGER::instance().Find(p2->vid);
  1049. if (!ch_companion)
  1050. return sizeof(TPacketCGMessengerAddByVID);
  1052. if (ch->IsObserverMode())
  1053. return sizeof(TPacketCGMessengerAddByVID);
  1055. if (ch_companion->IsBlockMode(BLOCK_MESSENGER_INVITE))
  1056. {
  1057. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방이 메신져 추가 거부 상태입니다."));
  1058. return sizeof(TPacketCGMessengerAddByVID);
  1059. }
  1061. LPDESC d = ch_companion->GetDesc();
  1063. if (!d)
  1064. return sizeof(TPacketCGMessengerAddByVID);
  1066. if (ch->GetGMLevel() == GM_PLAYER && ch_companion->GetGMLevel() != GM_PLAYER)
  1067. {
  1068. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<메신져> 운영자는 메신져에 추가할 수 없습니다."));
  1069. return sizeof(TPacketCGMessengerAddByVID);
  1070. }
  1072. if (ch->GetDesc() == d) // 자신은 추가할 수 없다.
  1073. return sizeof(TPacketCGMessengerAddByVID);
  1075. MessengerManager::instance().RequestToAdd(ch, ch_companion);
  1076. //MessengerManager::instance().AddToList(ch->GetName(), ch_companion->GetName());
  1077. }
  1078. return sizeof(TPacketCGMessengerAddByVID);
  1080. case MESSENGER_SUBHEADER_CG_ADD_BY_NAME:
  1081. {
  1082. if (uiBytes < CHARACTER_NAME_MAX_LEN)
  1083. return -1;
  1085. char name[CHARACTER_NAME_MAX_LEN + 1];
  1086. strlcpy(name, c_pData, sizeof(name));
  1088. if (ch->GetGMLevel() == GM_PLAYER && gm_get_level(name) != GM_PLAYER)
  1089. {
  1090. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<메신져> 운영자는 메신져에 추가할 수 없습니다."));
  1091. return CHARACTER_NAME_MAX_LEN;
  1092. }
  1094. LPCHARACTER tch = CHARACTER_MANAGER::instance().FindPC(name);
  1096. if (!tch)
  1097. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%s 님은 접속되 있지 않습니다."), name);
  1098. else
  1099. {
  1100. if (tch == ch) // 자신은 추가할 수 없다.
  1101. return CHARACTER_NAME_MAX_LEN;
  1103. if (tch->IsBlockMode(BLOCK_MESSENGER_INVITE) == true)
  1104. {
  1105. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방이 메신져 추가 거부 상태입니다."));
  1106. }
  1107. else
  1108. {
  1109. // 메신저가 캐릭터단위가 되면서 변경
  1110. MessengerManager::instance().RequestToAdd(ch, tch);
  1111. //MessengerManager::instance().AddToList(ch->GetName(), tch->GetName());
  1112. }
  1113. }
  1114. }
  1115. return CHARACTER_NAME_MAX_LEN;
  1117. case MESSENGER_SUBHEADER_CG_REMOVE:
  1118. {
  1119. if (uiBytes < CHARACTER_NAME_MAX_LEN)
  1120. return -1;
  1122. char char_name[CHARACTER_NAME_MAX_LEN + 1];
  1123. strlcpy(char_name, c_pData, sizeof(char_name));
  1124. MessengerManager::instance().RemoveFromList(ch->GetName(), char_name);
  1125. }
  1126. return CHARACTER_NAME_MAX_LEN;
  1128. default:
  1129. sys_err("CInputMain::Messenger : Unknown subheader %d : %s", p->subheader, ch->GetName());
  1130. break;
  1131. }
  1133. return 0;
  1134. }
  1136. int CInputMain::Shop(LPCHARACTER ch, const char * data, size_t uiBytes)
  1137. {
  1138. TPacketCGShop * p = (TPacketCGShop *) data;
  1140. if (uiBytes < sizeof(TPacketCGShop))
  1141. return -1;
  1143. if (test_server)
  1144. sys_log(0, "CInputMain::Shop() ==> SubHeader %d", p->subheader);
  1146. const char * c_pData = data + sizeof(TPacketCGShop);
  1147. uiBytes -= sizeof(TPacketCGShop);
  1149. switch (p->subheader)
  1150. {
  1151. case SHOP_SUBHEADER_CG_END:
  1152. sys_log(1, "INPUT: %s SHOP: END", ch->GetName());
  1153. CShopManager::instance().StopShopping(ch);
  1154. return 0;
  1156. case SHOP_SUBHEADER_CG_BUY:
  1157. {
  1158. if (uiBytes < sizeof(BYTE) + sizeof(BYTE))
  1159. return -1;
  1161. BYTE bPos = *(c_pData + 1);
  1162. sys_log(1, "INPUT: %s SHOP: BUY %d", ch->GetName(), bPos);
  1163. CShopManager::instance().Buy(ch, bPos);
  1164. return (sizeof(BYTE) + sizeof(BYTE));
  1165. }
  1167. case SHOP_SUBHEADER_CG_SELL:
  1168. {
  1169. if (uiBytes < sizeof(BYTE))
  1170. return -1;
  1172. BYTE pos = *c_pData;
  1174. sys_log(0, "INPUT: %s SHOP: SELL", ch->GetName());
  1175. CShopManager::instance().Sell(ch, pos);
  1176. return sizeof(BYTE);
  1177. }
  1179. case SHOP_SUBHEADER_CG_SELL2:
  1180. {
  1181. if (uiBytes < sizeof(BYTE) + sizeof(BYTE))
  1182. return -1;
  1184. BYTE pos = *(c_pData++);
  1185. BYTE count = *(c_pData);
  1187. sys_log(0, "INPUT: %s SHOP: SELL2", ch->GetName());
  1188. CShopManager::instance().Sell(ch, pos, count);
  1189. return sizeof(BYTE) + sizeof(BYTE);
  1190. }
  1192. default:
  1193. sys_err("CInputMain::Shop : Unknown subheader %d : %s", p->subheader, ch->GetName());
  1194. break;
  1195. }
  1197. return 0;
  1198. }
  1200. int CInputMain::OfflineShop(LPCHARACTER ch, const char * data, size_t uiBytes)
  1201. {
  1202. TPacketCGShop * p = (TPacketCGShop *)data;
  1204. if (uiBytes < sizeof(TPacketCGShop))
  1205. return -1;
  1207. if (test_server)
  1208. sys_log(0, "CInputMain::OfflineShop ==> SubHeader %d", p->subheader);
  1210. const char * c_pData = data + sizeof(TPacketCGShop);
  1211. uiBytes -= sizeof(TPacketCGShop);
  1213. switch (p->subheader)
  1214. {
  1215. case SHOP_SUBHEADER_CG_END:
  1216. sys_log(1, "INPUT: %s OFFLINE_SHOP: END", ch->GetName());
  1217. COfflineShopManager::instance().StopShopping(ch);
  1218. return 0;
  1219. case SHOP_SUBHEADER_CG_BUY:
  1220. {
  1221. if (uiBytes < sizeof(BYTE) + sizeof(BYTE))
  1222. return -1;
  1224. BYTE bPos = *(c_pData + 1);
  1225. sys_log(1, "INPUT: %s OFFLINE_SHOP: BUY %d", ch->GetName(), bPos);
  1226. COfflineShopManager::instance().Buy(ch, bPos);
  1227. return (sizeof(BYTE) + sizeof(BYTE));
  1228. }
  1229. case SHOP_SUBHEADER_CG_CHANGE_EDIT_TIME:
  1230. {
  1231. if (uiBytes < sizeof(BYTE))
  1232. return -1;
  1234. BYTE bTime = *c_pData;
  1235. sys_log(0, "INPUT: %s EDIT_OFFLINE_SHOP_TIME", ch->GetName());
  1236. COfflineShopManager::instance().ChangeOfflineShopTime(ch, bTime);
  1237. return sizeof(BYTE);
  1238. }
  1239. case SHOP_SUBHEADER_CG_DESTROY_OFFLINE_SHOP:
  1240. sys_log(1, "INPUT: %s OFFLINE_SHOP_DESTROY", ch->GetName());
  1241. COfflineShopManager::instance().DestroyOfflineShop(ch, ch->GetOfflineShopVID(), true);
  1242. return 0;
  1243. case SHOP_SUBHEADER_CG_ADD_ITEM:
  1244. {
  1245. ch->ChatPacket(CHAT_TYPE_INFO, "Add Item %d", ch->GetOfflineShopStatus());
  1246. // If the user is not update the client, give a message ;)
  1247. if (ch->GetOfflineShopStatus() == 0 || ch->GetOfflineShopStatus() == 1)
  1248. {
  1249. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't use this window now!"));
  1250. return 0;
  1251. }
  1253. if (uiBytes < sizeof(TOfflineShopItemTable2))
  1254. return -1;
  1256. TOfflineShopItemTable2 * pTable = (TOfflineShopItemTable2 *)(c_pData);
  1257. #ifdef ENABLE_MAXIMUM_YANG_FOR_OFFLINE_SHOP
  1258. COfflineShopManager::instance().AddItem(ch, pTable->bDisplayPos, pTable->bPos, pTable->llPrice);
  1259. #else
  1260. COfflineShopManager::instance().AddItem(ch, pTable->bDisplayPos, pTable->bPos, pTable->lPrice);
  1261. #endif
  1262. return (sizeof(TOfflineShopItemTable2));
  1263. }
  1264. case SHOP_SUBHEADER_CG_REMOVE_ITEM:
  1265. {
  1266. ch->ChatPacket(CHAT_TYPE_INFO, "Remove Item %d", ch->GetOfflineShopStatus());
  1267. // If the user is not update the client, give a message ;)
  1268. if (ch->GetOfflineShopStatus() == 0 || ch->GetOfflineShopStatus() == 1)
  1269. {
  1270. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't use this window now!"));
  1271. return 0;
  1272. }
  1274. if (uiBytes < sizeof(BYTE))
  1275. return -1;
  1277. BYTE bPos = *c_pData;
  1278. sys_log(0, "INPUT: %s REMOVE_ITEM : %d", ch->GetName(), bPos);
  1279. COfflineShopManager::instance().RemoveItem(ch, bPos);
  1280. return (sizeof(BYTE));
  1281. }
  1282. case SHOP_SUBHEADER_CG_CHANGE_PRICE:
  1283. {
  1284. // If the user is not update the client, give a message ;)
  1285. if (ch->GetOfflineShopStatus() == 0 || ch->GetOfflineShopStatus() == 1)
  1286. {
  1287. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't use this window now!"));
  1288. return 0;
  1289. }
  1291. if (uiBytes < sizeof(TOfflineShopItemTable2))
  1292. return -1;
  1294. TOfflineShopItemTable2 * pTable = (TOfflineShopItemTable2 *)(c_pData);
  1295. #ifdef ENABLE_MAXIMUM_YANG_FOR_OFFLINE_SHOP
  1296. sys_log(0, "INPUT: %s OFFLINE_CHANGE_PRICE(%lld)", ch->GetName(), pTable->bDisplayPos);
  1297. COfflineShopManager::instance().ChangePrice(ch, pTable->bDisplayPos, pTable->llPrice);
  1298. #else
  1299. sys_log(0, "INPUT: %s OFFLINE_CHANGE_PRICE (%d)", ch->GetName(), pTable->bDisplayPos);
  1300. COfflineShopManager::instance().ChangePrice(ch, pTable->bDisplayPos, pTable->lPrice);
  1301. #endif
  1302. return (sizeof(TOfflineShopItemTable2));
  1303. }
  1304. case SHOP_SUBHEADER_CG_REFRESH:
  1305. ch->ChatPacket(CHAT_TYPE_INFO, "Refresh %d", ch->GetOfflineShopStatus());
  1306. if (ch->GetOfflineShopStatus() == 0 || ch->GetOfflineShopStatus() == 1)
  1307. {
  1308. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't use this window now!"));
  1309. return 0;
  1310. }
  1312. sys_log(0, "INPUT: %s OFFLINE_SHOP_REFRESH_ITEM", ch->GetName());
  1313. COfflineShopManager::instance().Refresh(ch);
  1314. return 0;
  1315. case SHOP_SUBHEADER_CG_REFRESH_MONEY:
  1316. {
  1317. sys_log(0, "INPUT: %s OFFLINE_SHOP_REFRESH_MONEY", ch->GetName());
  1318. COfflineShopManager::instance().RefreshMoney(ch);
  1319. return 0;
  1320. }
  1321. case SHOP_SUBHEADER_CG_WITHDRAW_MONEY:
  1322. {
  1323. if (uiBytes < sizeof(long long))
  1324. return -1;
  1326. const long long gold = *reinterpret_cast<const long long*>(c_pData);
  1327. sys_log(0, "INPUT: %s(%lld) OFFLINE_SHOP_WITHDRAW_MONEY", ch->GetName(), gold);
  1328. COfflineShopManager::instance().WithdrawMoney(ch, gold);
  1329. return (sizeof(long long));
  1330. }
  1331. case SHOP_SUBHEADER_CG_REFRESH_UNSOLD_ITEMS:
  1332. {
  1333. sys_log(0, "INPUT: %s OFFLINE_SHOP_REFRESH_UNSOLD_ITEMS", ch->GetName());
  1334. COfflineShopManager::instance().RefreshUnsoldItems(ch);
  1335. return 0;
  1336. }
  1337. case SHOP_SUBHEADER_CG_TAKE_ITEM:
  1338. {
  1339. if (uiBytes < sizeof(BYTE))
  1340. return -1;
  1342. BYTE bPos = *c_pData;
  1343. sys_log(0, "INPUT: %s OFFLINE_SHOP_TAKE_ITEM", ch->GetName());
  1344. COfflineShopManager::instance().TakeItem(ch, bPos);
  1345. return (sizeof(BYTE));
  1346. }
  1347. case SHOP_SUBHEADER_CG_CHECK:
  1348. COfflineShopManager::instance().HasOfflineShop(ch);
  1349. return 0;
  1350. default:
  1351. sys_err("CInputMain::OfflineShop : Unknown subheader %d : %s", p->subheader, ch->GetName());
  1352. break;
  1353. }
  1355. return 0;
  1356. }
  1358. void CInputMain::OnClick(LPCHARACTER ch, const char * data)
  1359. {
  1360. struct command_on_click * pinfo = (struct command_on_click *) data;
  1361. LPCHARACTER victim;
  1363. if ((victim = CHARACTER_MANAGER::instance().Find(pinfo->vid)))
  1364. victim->OnClick(ch);
  1365. else if (test_server)
  1366. {
  1367. sys_err("CInputMain::OnClick %s.Click.NOT_EXIST_VID[%d]", ch->GetName(), pinfo->vid);
  1368. }
  1369. }
  1371. void CInputMain::Exchange(LPCHARACTER ch, const char * data)
  1372. {
  1373. struct command_exchange * pinfo = (struct command_exchange *) data;
  1374. LPCHARACTER to_ch = NULL;
  1376. if (!ch->CanHandleItem())
  1377. return;
  1379. int iPulse = thecore_pulse();
  1381. if ((to_ch = CHARACTER_MANAGER::instance().Find(pinfo->arg1)))
  1382. {
  1383. if (iPulse - to_ch->GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  1384. {
  1385. to_ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래 후 %d초 이내에 창고를 열수 없습니다."), g_nPortalLimitTime);
  1386. return;
  1387. }
  1389. if( true == to_ch->IsDead() )
  1390. {
  1391. return;
  1392. }
  1393. }
  1395. sys_log(0, "CInputMain()::Exchange() SubHeader %d ", pinfo->sub_header);
  1397. if (iPulse - ch->GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  1398. {
  1399. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래 후 %d초 이내에 창고를 열수 없습니다."), g_nPortalLimitTime);
  1400. return;
  1401. }
  1404. switch (pinfo->sub_header)
  1405. {
  1406. case EXCHANGE_SUBHEADER_CG_START: // arg1 == vid of target character
  1407. if (!ch->GetExchange())
  1408. {
  1409. if ((to_ch = CHARACTER_MANAGER::instance().Find(pinfo->arg1)))
  1410. {
  1411. //MONARCH_LIMIT
  1412. /*
  1413. if (to_ch->IsMonarch() || ch->IsMonarch())
  1414. {
  1415. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("군주와는 거래를 할수가 없습니다"), g_nPortalLimitTime);
  1416. return;
  1417. }
  1418. //END_MONARCH_LIMIT
  1419. */
  1420. if (iPulse - ch->GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  1421. {
  1422. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("창고를 연후 %d초 이내에는 거래를 할수 없습니다."), g_nPortalLimitTime);
  1424. if (test_server)
  1425. ch->ChatPacket(CHAT_TYPE_INFO, "[TestOnly][Safebox]Pulse %d LoadTime %d PASS %d", iPulse, ch->GetSafeboxLoadTime(), PASSES_PER_SEC(g_nPortalLimitTime));
  1426. return;
  1427. }
  1429. if (iPulse - to_ch->GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  1430. {
  1431. to_ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("창고를 연후 %d초 이내에는 거래를 할수 없습니다."), g_nPortalLimitTime);
  1434. if (test_server)
  1435. to_ch->ChatPacket(CHAT_TYPE_INFO, "[TestOnly][Safebox]Pulse %d LoadTime %d PASS %d", iPulse, to_ch->GetSafeboxLoadTime(), PASSES_PER_SEC(g_nPortalLimitTime));
  1436. return;
  1437. }
  1439. if (ch->GetGold() >= GOLD_MAX)
  1440. {
  1441. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("액수가 20억 냥을 초과하여 거래를 할수가 없습니다.."));
  1443. sys_err("[OVERFLOG_GOLD] START (%u) id %u name %s ", ch->GetGold(), ch->GetPlayerID(), ch->GetName());
  1444. return;
  1445. }
  1447. if (to_ch->IsPC())
  1448. {
  1449. if (quest::CQuestManager::instance().GiveItemToPC(ch->GetPlayerID(), to_ch))
  1450. {
  1451. sys_log(0, "Exchange canceled by quest %s %s", ch->GetName(), to_ch->GetName());
  1452. return;
  1453. }
  1454. }
  1456. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
  1457. if (ch->GetMyShop() || ch->IsOpenSafebox() || ch->GetShopOwner() || ch->IsCubeOpen() || ch->GetOfflineShopOwner())
  1458. {
  1459. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("다른 거래중일경우 개인상점을 열수가 없습니다."));
  1460. return;
  1461. }
  1462. #else
  1463. if (ch->GetMyShop() || ch->IsOpenSafebox() || ch->GetShopOwner() || ch->IsCubeOpen())
  1464. {
  1465. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("다른 거래중일경우 개인상점을 열수가 없습니다."));
  1466. return;
  1467. }
  1468. #endif
  1470. ch->ExchangeStart(to_ch);
  1471. }
  1472. }
  1473. break;
  1475. case EXCHANGE_SUBHEADER_CG_ITEM_ADD: // arg1 == position of item, arg2 == position in exchange window
  1476. if (ch->GetExchange())
  1477. {
  1478. if (ch->GetExchange()->GetCompany()->GetAcceptStatus() != true)
  1479. ch->GetExchange()->AddItem(pinfo->Pos, pinfo->arg2);
  1480. }
  1481. break;
  1483. case EXCHANGE_SUBHEADER_CG_ITEM_DEL: // arg1 == position of item
  1484. if (ch->GetExchange())
  1485. {
  1486. if (ch->GetExchange()->GetCompany()->GetAcceptStatus() != true)
  1487. ch->GetExchange()->RemoveItem(pinfo->arg1);
  1488. }
  1489. break;
  1491. case EXCHANGE_SUBHEADER_CG_ELK_ADD: // arg1 == amount of gold
  1492. if (ch->GetExchange())
  1493. {
  1494. const int64_t nTotalGold = static_cast<int64_t>(ch->GetExchange()->GetCompany()->GetOwner()->GetGold()) + static_cast<int64_t>(pinfo->arg1);
  1496. if (GOLD_MAX <= nTotalGold)
  1497. {
  1498. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상대방의 총금액이 20억 냥을 초과하여 거래를 할수가 없습니다.."));
  1500. sys_err("[OVERFLOW_GOLD] ELK_ADD (%u) id %u name %s ",
  1501. ch->GetExchange()->GetCompany()->GetOwner()->GetGold(),
  1502. ch->GetExchange()->GetCompany()->GetOwner()->GetPlayerID(),
  1503. ch->GetExchange()->GetCompany()->GetOwner()->GetName());
  1505. return;
  1506. }
  1508. if (ch->GetExchange()->GetCompany()->GetAcceptStatus() != true)
  1509. ch->GetExchange()->AddGold(pinfo->arg1);
  1510. }
  1511. break;
  1513. case EXCHANGE_SUBHEADER_CG_ACCEPT: // arg1 == not used
  1514. if (ch->GetExchange())
  1515. {
  1516. sys_log(0, "CInputMain()::Exchange() ==> ACCEPT ");
  1517. ch->GetExchange()->Accept(true);
  1518. }
  1520. break;
  1522. case EXCHANGE_SUBHEADER_CG_CANCEL: // arg1 == not used
  1523. if (ch->GetExchange())
  1524. ch->GetExchange()->Cancel();
  1525. break;
  1526. }
  1527. }
  1529. void CInputMain::Position(LPCHARACTER ch, const char * data)
  1530. {
  1531. struct command_position * pinfo = (struct command_position *) data;
  1533. switch (pinfo->position)
  1534. {
  1535. case POSITION_GENERAL:
  1536. ch->Standup();
  1537. break;
  1539. case POSITION_SITTING_CHAIR:
  1540. ch->Sitdown(0);
  1541. break;
  1543. case POSITION_SITTING_GROUND:
  1544. ch->Sitdown(1);
  1545. break;
  1546. }
  1547. }
  1549. static const int ComboSequenceBySkillLevel[3][8] =
  1550. {
  1551. // 0 1 2 3 4 5 6 7
  1552. { 14, 15, 16, 17, 0, 0, 0, 0 },
  1553. { 14, 15, 16, 18, 20, 0, 0, 0 },
  1554. { 14, 15, 16, 18, 19, 17, 0, 0 },
  1555. };
  1557. #define COMBO_HACK_ALLOWABLE_MS 100
  1559. bool CheckComboHack(LPCHARACTER ch, BYTE bArg, DWORD dwTime, bool CheckSpeedHack)
  1560. {
  1561. if(!gHackCheckEnable) return false;
  1563. // 죽거나 기절 상태에서는 공격할 수 없으므로, skip한다.
  1564. // 이렇게 하지 말고, CHRACTER::CanMove()에
  1565. // if (IsStun() || IsDead()) return false;
  1566. // 를 추가하는게 맞다고 생각하나,
  1567. // 이미 다른 부분에서 CanMove()는 IsStun(), IsDead()과
  1568. // 독립적으로 체크하고 있기 때문에 수정에 의한 영향을
  1569. // 최소화하기 위해 이렇게 땜빵 코드를 써놓는다.
  1570. if (ch->IsStun() || ch->IsDead())
  1571. return false;
  1572. int ComboInterval = dwTime - ch->GetLastComboTime();
  1573. int HackScalar = 0; // 기본 스칼라 단위 1
  1574. #if 0
  1575. sys_log(0, "COMBO: %s arg:%u seq:%u delta:%d checkspeedhack:%d",
  1576. ch->GetName(), bArg, ch->GetComboSequence(), ComboInterval - ch->GetValidComboInterval(), CheckSpeedHack);
  1577. #endif
  1578. // bArg 14 ~ 21번 까지 총 8콤보 가능
  1579. // 1. 첫 콤보(14)는 일정 시간 이후에 반복 가능
  1580. // 2. 15 ~ 21번은 반복 불가능
  1581. // 3. 차례대로 증가한다.
  1582. if (bArg == 14)
  1583. {
  1584. if (CheckSpeedHack && ComboInterval > 0 && ComboInterval < ch->GetValidComboInterval() - COMBO_HACK_ALLOWABLE_MS)
  1585. {
  1586. // FIXME 첫번째 콤보는 이상하게 빨리 올 수가 있어서 300으로 나눔 -_-;
  1588. // 다수의 몬스터에 의해 다운되는 상황에서 공격을 하면
  1589. // 첫번째 콤보가 매우 적은 인터벌로 들어오는 상황 발생.
  1590. // 이로 인해 콤보핵으로 튕기는 경우가 있어 다음 코드 비 활성화.
  1591. //HackScalar = 1 + (ch->GetValidComboInterval() - ComboInterval) / 300;
  1593. //sys_log(0, "COMBO_HACK: 2 %s arg:%u interval:%d valid:%u atkspd:%u riding:%s",
  1594. // ch->GetName(),
  1595. // bArg,
  1596. // ComboInterval,
  1597. // ch->GetValidComboInterval(),
  1598. // ch->GetPoint(POINT_ATT_SPEED),
  1599. // ch->IsRiding() ? "yes" : "no");
  1600. }
  1602. ch->SetComboSequence(1);
  1603. ch->SetValidComboInterval((int) (ani_combo_speed(ch, 1) / (ch->GetPoint(POINT_ATT_SPEED) / 100.f)));
  1604. ch->SetLastComboTime(dwTime);
  1605. }
  1606. else if (bArg > 14 && bArg < 22)
  1607. {
  1608. int idx = MIN(2, ch->GetComboIndex());
  1610. if (ch->GetComboSequence() > 5) // 현재 6콤보 이상은 없다.
  1611. {
  1612. HackScalar = 1;
  1613. ch->SetValidComboInterval(300);
  1614. sys_log(0, "COMBO_HACK: 5 %s combo_seq:%d", ch->GetName(), ch->GetComboSequence());
  1615. }
  1616. // 자객 쌍수 콤보 예외처리
  1617. else if (bArg == 21 &&
  1618. idx == 2 &&
  1619. ch->GetComboSequence() == 5 &&
  1620. ch->GetJob() == JOB_ASSASSIN &&
  1621. ch->GetWear(WEAR_WEAPON) &&
  1622. ch->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_DAGGER)
  1623. ch->SetValidComboInterval(300);
  1624. #ifdef ENABLE_WOLFMAN_CHARACTER
  1625. else if (bArg == 21 && idx == 2 && ch->GetComboSequence() == 5 && ch->GetJob() == JOB_WOLFMAN && ch->GetWear(WEAR_WEAPON) && ch->GetWear(WEAR_WEAPON)->GetSubType() == WEAPON_CLAW)
  1626. ch->SetValidComboInterval(300);
  1627. #endif
  1628. else if (ComboSequenceBySkillLevel[idx][ch->GetComboSequence()] != bArg)
  1629. {
  1630. HackScalar = 1;
  1631. ch->SetValidComboInterval(300);
  1633. sys_log(0, "COMBO_HACK: 3 %s arg:%u valid:%u combo_idx:%d combo_seq:%d",
  1634. ch->GetName(),
  1635. bArg,
  1636. ComboSequenceBySkillLevel[idx][ch->GetComboSequence()],
  1637. idx,
  1638. ch->GetComboSequence());
  1639. }
  1640. else
  1641. {
  1642. if (CheckSpeedHack && ComboInterval < ch->GetValidComboInterval() - COMBO_HACK_ALLOWABLE_MS)
  1643. {
  1644. HackScalar = 1 + (ch->GetValidComboInterval() - ComboInterval) / 100;
  1646. sys_log(0, "COMBO_HACK: 2 %s arg:%u interval:%d valid:%u atkspd:%u riding:%s",
  1647. ch->GetName(),
  1648. bArg,
  1649. ComboInterval,
  1650. ch->GetValidComboInterval(),
  1651. ch->GetPoint(POINT_ATT_SPEED),
  1652. ch->IsRiding() ? "yes" : "no");
  1653. }
  1655. // 말을 탔을 때는 15번 ~ 16번을 반복한다
  1656. //if (ch->IsHorseRiding())
  1657. if (ch->IsRiding())
  1658. ch->SetComboSequence(ch->GetComboSequence() == 1 ? 2 : 1);
  1659. else
  1660. ch->SetComboSequence(ch->GetComboSequence() + 1);
  1662. ch->SetValidComboInterval((int) (ani_combo_speed(ch, bArg - 13) / (ch->GetPoint(POINT_ATT_SPEED) / 100.f)));
  1663. ch->SetLastComboTime(dwTime);
  1664. }
  1665. }
  1666. else if (bArg == 13) // 기본 공격 (둔갑(Polymorph)했을 때 온다)
  1667. {
  1668. if (CheckSpeedHack && ComboInterval > 0 && ComboInterval < ch->GetValidComboInterval() - COMBO_HACK_ALLOWABLE_MS)
  1669. {
  1670. // 다수의 몬스터에 의해 다운되는 상황에서 공격을 하면
  1671. // 첫번째 콤보가 매우 적은 인터벌로 들어오는 상황 발생.
  1672. // 이로 인해 콤보핵으로 튕기는 경우가 있어 다음 코드 비 활성화.
  1673. //HackScalar = 1 + (ch->GetValidComboInterval() - ComboInterval) / 100;
  1675. //sys_log(0, "COMBO_HACK: 6 %s arg:%u interval:%d valid:%u atkspd:%u",
  1676. // ch->GetName(),
  1677. // bArg,
  1678. // ComboInterval,
  1679. // ch->GetValidComboInterval(),
  1680. // ch->GetPoint(POINT_ATT_SPEED));
  1681. }
  1683. if (ch->GetRaceNum() >= MAIN_RACE_MAX_NUM)
  1684. {
  1685. // POLYMORPH_BUG_FIX
  1687. // DELETEME
  1688. /*
  1689. const CMotion * pkMotion = CMotionManager::instance().GetMotion(ch->GetRaceNum(), MAKE_MOTION_KEY(MOTION_MODE_GENERAL, MOTION_NORMAL_ATTACK));
  1691. if (!pkMotion)
  1692. sys_err("cannot find motion by race %u", ch->GetRaceNum());
  1693. else
  1694. {
  1695. // 정상적 계산이라면 1000.f를 곱해야 하지만 클라이언트가 애니메이션 속도의 90%에서
  1696. // 다음 애니메이션 블렌딩을 허용하므로 900.f를 곱한다.
  1697. int k = (int) (pkMotion->GetDuration() / ((float) ch->GetPoint(POINT_ATT_SPEED) / 100.f) * 900.f);
  1698. ch->SetValidComboInterval(k);
  1699. ch->SetLastComboTime(dwTime);
  1700. }
  1701. */
  1702. float normalAttackDuration = CMotionManager::instance().GetNormalAttackDuration(ch->GetRaceNum());
  1703. int k = (int) (normalAttackDuration / ((float) ch->GetPoint(POINT_ATT_SPEED) / 100.f) * 900.f);
  1704. ch->SetValidComboInterval(k);
  1705. ch->SetLastComboTime(dwTime);
  1706. // END_OF_POLYMORPH_BUG_FIX
  1707. }
  1708. else
  1709. {
  1710. // 말이 안되는 콤보가 왔다 해커일 가능성?
  1711. //if (ch->GetDesc()->DelayedDisconnect(number(2, 9)))
  1712. //{
  1713. // LogManager::instance().HackLog("Hacker", ch);
  1714. // sys_log(0, "HACKER: %s arg %u", ch->GetName(), bArg);
  1715. //}
  1717. // 위 코드로 인해, 폴리모프를 푸는 중에 공격 하면,
  1718. // 가끔 핵으로 인식하는 경우가 있다.
  1720. // 자세히 말혀면,
  1721. // 서버에서 poly 0를 처리했지만,
  1722. // 클라에서 그 패킷을 받기 전에, 몹을 공격. <- 즉, 몹인 상태에서 공격.
  1723. //
  1724. // 그러면 클라에서는 서버에 몹 상태로 공격했다는 커맨드를 보내고 (arg == 13)
  1725. //
  1726. // 서버에서는 race는 인간인데 공격형태는 몹인 놈이다! 라고 하여 핵체크를 했다.
  1728. // 사실 공격 패턴에 대한 것은 클라이언트에서 판단해서 보낼 것이 아니라,
  1729. // 서버에서 판단해야 할 것인데... 왜 이렇게 해놨을까...
  1730. // by rtsummit
  1731. }
  1732. }
  1733. else
  1734. {
  1735. // 말이 안되는 콤보가 왔다 해커일 가능성?
  1736. if (ch->GetDesc()->DelayedDisconnect(number(2, 9)))
  1737. {
  1738. LogManager::instance().HackLog("Hacker", ch);
  1739. sys_log(0, "HACKER: %s arg %u", ch->GetName(), bArg);
  1740. }
  1742. HackScalar = 10;
  1743. ch->SetValidComboInterval(300);
  1744. }
  1746. if (HackScalar)
  1747. {
  1748. // 말에 타거나 내렸을 때 1.5초간 공격은 핵으로 간주하지 않되 공격력은 없게 하는 처리
  1749. if (get_dword_time() - ch->GetLastMountTime() > 1500)
  1750. ch->IncreaseComboHackCount(1 + HackScalar);
  1752. ch->SkipComboAttackByTime(ch->GetValidComboInterval());
  1753. }
  1755. return HackScalar;
  1758. }
  1760. void CInputMain::Move(LPCHARACTER ch, const char * data)
  1761. {
  1762. if (!ch->CanMove())
  1763. return;
  1765. struct command_move * pinfo = (struct command_move *) data;
  1767. if (pinfo->bFunc >= FUNC_MAX_NUM && !(pinfo->bFunc & 0x80))
  1768. {
  1769. sys_err("invalid move type: %s", ch->GetName());
  1770. return;
  1771. }
  1773. //enum EMoveFuncType
  1774. //{
  1775. // FUNC_WAIT,
  1776. // FUNC_MOVE,
  1777. // FUNC_ATTACK,
  1778. // FUNC_COMBO,
  1779. // FUNC_MOB_SKILL,
  1780. // _FUNC_SKILL,
  1781. // FUNC_MAX_NUM,
  1782. // FUNC_SKILL = 0x80,
  1783. //};
  1785. // 텔레포트 핵 체크
  1787. // if (!test_server)
  1788. {
  1789. const float fDist = DISTANCE_SQRT((ch->GetX() - pinfo->lX) / 100, (ch->GetY() - pinfo->lY) / 100);
  1790. // @fixme106 (changed 40 to 60)
  1791. if (((false == ch->IsRiding() && fDist > 25) || fDist > 60) && OXEVENT_MAP_INDEX != ch->GetMapIndex())
  1792. {
  1793. #ifdef ENABLE_HACK_TELEPORT_LOG // @warme006
  1794. {
  1795. const PIXEL_POSITION & warpPos = ch->GetWarpPosition();
  1797. if (warpPos.x == 0 && warpPos.y == 0)
  1798. LogManager::instance().HackLog("Teleport", ch); // 부정확할 수 있음
  1799. }
  1800. #endif
  1801. sys_log(0, "MOVE: %s trying to move too far (dist: %.1fm) Riding(%d)", ch->GetName(), fDist, ch->IsRiding());
  1803. ch->Show(ch->GetMapIndex(), ch->GetX(), ch->GetY(), ch->GetZ());
  1804. ch->Stop();
  1805. return;
  1806. }
  1807. #ifdef ENABLE_CHECK_GHOSTMODE
  1808. if (ch->IsPC() && ch->IsDead())
  1809. {
  1810. sys_log(0, "MOVE: %s trying to move as dead", ch->GetName());
  1812. ch->Show(ch->GetMapIndex(), ch->GetX(), ch->GetY(), ch->GetZ());
  1813. ch->Stop();
  1814. return;
  1815. }
  1816. #endif
  1817. //
  1818. // 스피드핵(SPEEDHACK) Check
  1819. //
  1820. DWORD dwCurTime = get_dword_time();
  1821. // 시간을 Sync하고 7초 후 부터 검사한다. (20090702 이전엔 5초였음)
  1822. bool CheckSpeedHack = (false == ch->GetDesc()->IsHandshaking() && dwCurTime - ch->GetDesc()->GetClientTime() > 7000);
  1824. if (CheckSpeedHack)
  1825. {
  1826. int iDelta = (int) (pinfo->dwTime - ch->GetDesc()->GetClientTime());
  1827. int iServerDelta = (int) (dwCurTime - ch->GetDesc()->GetClientTime());
  1829. iDelta = (int) (dwCurTime - pinfo->dwTime);
  1831. // 시간이 늦게간다. 일단 로그만 해둔다. 진짜 이런 사람들이 많은지 체크해야함. TODO
  1832. if (iDelta >= 30000)
  1833. {
  1834. sys_log(0, "SPEEDHACK: slow timer name %s delta %d", ch->GetName(), iDelta);
  1835. ch->GetDesc()->DelayedDisconnect(3);
  1836. }
  1837. // 1초에 20msec 빨리 가는거 까지는 이해한다.
  1838. else if (iDelta < -(iServerDelta / 50))
  1839. {
  1840. sys_log(0, "SPEEDHACK: DETECTED! %s (delta %d %d)", ch->GetName(), iDelta, iServerDelta);
  1841. ch->GetDesc()->DelayedDisconnect(3);
  1842. }
  1843. }
  1845. //
  1846. // 콤보핵 및 스피드핵 체크
  1847. //
  1848. if (pinfo->bFunc == FUNC_COMBO && g_bCheckMultiHack)
  1849. {
  1850. CheckComboHack(ch, pinfo->bArg, pinfo->dwTime, CheckSpeedHack); // 콤보 체크
  1851. }
  1852. }
  1854. if (pinfo->bFunc == FUNC_MOVE)
  1855. {
  1856. if (ch->GetLimitPoint(POINT_MOV_SPEED) == 0)
  1857. return;
  1859. ch->SetRotation(pinfo->bRot * 5); // 중복 코드
  1860. ch->ResetStopTime(); // ""
  1862. ch->Goto(pinfo->lX, pinfo->lY);
  1863. }
  1864. else
  1865. {
  1866. if (pinfo->bFunc == FUNC_ATTACK || pinfo->bFunc == FUNC_COMBO)
  1867. ch->OnMove(true);
  1868. else if (pinfo->bFunc & FUNC_SKILL)
  1869. {
  1870. const int MASK_SKILL_MOTION = 0x7F;
  1871. unsigned int motion = pinfo->bFunc & MASK_SKILL_MOTION;
  1873. if (!ch->IsUsableSkillMotion(motion))
  1874. {
  1875. const char* name = ch->GetName();
  1876. unsigned int job = ch->GetJob();
  1877. unsigned int group = ch->GetSkillGroup();
  1879. char szBuf[256];
  1880. snprintf(szBuf, sizeof(szBuf), "SKILL_HACK: name=%s, job=%d, group=%d, motion=%d", name, job, group, motion);
  1881. LogManager::instance().HackLog(szBuf, ch->GetDesc()->GetAccountTable().login, ch->GetName(), ch->GetDesc()->GetHostName());
  1882. sys_log(0, "%s", szBuf);
  1884. if (test_server)
  1885. {
  1886. ch->GetDesc()->DelayedDisconnect(number(2, 8));
  1887. ch->ChatPacket(CHAT_TYPE_INFO, szBuf);
  1888. }
  1889. else
  1890. {
  1891. ch->GetDesc()->DelayedDisconnect(number(150, 500));
  1892. }
  1893. }
  1895. ch->OnMove();
  1896. }
  1898. ch->SetRotation(pinfo->bRot * 5); // 중복 코드
  1899. ch->ResetStopTime(); // ""
  1901. ch->Move(pinfo->lX, pinfo->lY);
  1902. ch->Stop();
  1903. ch->StopStaminaConsume();
  1904. }
  1906. TPacketGCMove pack;
  1908. pack.bHeader = HEADER_GC_MOVE;
  1909. pack.bFunc = pinfo->bFunc;
  1910. pack.bArg = pinfo->bArg;
  1911. pack.bRot = pinfo->bRot;
  1912. pack.dwVID = ch->GetVID();
  1913. pack.lX = pinfo->lX;
  1914. pack.lY = pinfo->lY;
  1915. pack.dwTime = pinfo->dwTime;
  1916. pack.dwDuration = (pinfo->bFunc == FUNC_MOVE) ? ch->GetCurrentMoveDuration() : 0;
  1918. ch->PacketAround(&pack, sizeof(TPacketGCMove), ch);
  1919. /*
  1920. if (pinfo->dwTime == 10653691) // 디버거 발견
  1921. {
  1922. if (ch->GetDesc()->DelayedDisconnect(number(15, 30)))
  1923. LogManager::instance().HackLog("Debugger", ch);
  1925. }
  1926. else if (pinfo->dwTime == 10653971) // Softice 발견
  1927. {
  1928. if (ch->GetDesc()->DelayedDisconnect(number(15, 30)))
  1929. LogManager::instance().HackLog("Softice", ch);
  1930. }
  1931. */
  1932. /*
  1933. sys_log(0,
  1934. "MOVE: %s Func:%u Arg:%u Pos:%dx%d Time:%u Dist:%.1f",
  1935. ch->GetName(),
  1936. pinfo->bFunc,
  1937. pinfo->bArg,
  1938. pinfo->lX / 100,
  1939. pinfo->lY / 100,
  1940. pinfo->dwTime,
  1941. fDist);
  1942. */
  1943. }
  1945. void CInputMain::Attack(LPCHARACTER ch, const BYTE header, const char* data)
  1946. {
  1947. if (NULL == ch)
  1948. return;
  1950. struct type_identifier
  1951. {
  1952. BYTE header;
  1953. BYTE type;
  1954. };
  1956. const struct type_identifier* const type = reinterpret_cast<const struct type_identifier*>(data);
  1958. if (type->type > 0)
  1959. {
  1960. if (false == ch->CanUseSkill(type->type))
  1961. {
  1962. return;
  1963. }
  1965. switch (type->type)
  1966. {
  1967. case SKILL_GEOMPUNG:
  1968. case SKILL_SANGONG:
  1969. case SKILL_YEONSA:
  1970. case SKILL_KWANKYEOK:
  1971. case SKILL_HWAJO:
  1972. case SKILL_GIGUNG:
  1973. case SKILL_PABEOB:
  1974. case SKILL_MARYUNG:
  1975. case SKILL_TUSOK:
  1976. case SKILL_MAHWAN:
  1977. case SKILL_BIPABU:
  1978. case SKILL_NOEJEON:
  1979. case SKILL_CHAIN:
  1980. case SKILL_HORSE_WILDATTACK_RANGE:
  1981. if (HEADER_CG_SHOOT != type->header)
  1982. {
  1983. if (test_server)
  1984. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Attack :name[%s] Vnum[%d] can't use skill by attack(warning)"), type->type);
  1985. return;
  1986. }
  1987. break;
  1988. }
  1989. }
  1991. switch (header)
  1992. {
  1993. case HEADER_CG_ATTACK:
  1994. {
  1995. if (NULL == ch->GetDesc())
  1996. return;
  1998. const TPacketCGAttack* const packMelee = reinterpret_cast<const TPacketCGAttack*>(data);
  2000. ch->GetDesc()->AssembleCRCMagicCube(packMelee->bCRCMagicCubeProcPiece, packMelee->bCRCMagicCubeFilePiece);
  2002. LPCHARACTER victim = CHARACTER_MANAGER::instance().Find(packMelee->dwVID);
  2004. if (NULL == victim || ch == victim)
  2005. return;
  2007. switch (victim->GetCharType())
  2008. {
  2009. case CHAR_TYPE_NPC:
  2010. case CHAR_TYPE_WARP:
  2011. case CHAR_TYPE_GOTO:
  2012. return;
  2013. }
  2015. if (packMelee->bType > 0)
  2016. {
  2017. if (false == ch->CheckSkillHitCount(packMelee->bType, victim->GetVID()))
  2018. {
  2019. return;
  2020. }
  2021. }
  2023. ch->Attack(victim, packMelee->bType);
  2024. }
  2025. break;
  2027. case HEADER_CG_SHOOT:
  2028. {
  2029. const TPacketCGShoot* const packShoot = reinterpret_cast<const TPacketCGShoot*>(data);
  2031. ch->Shoot(packShoot->bType);
  2032. }
  2033. break;
  2034. }
  2035. }
  2037. int CInputMain::SyncPosition(LPCHARACTER ch, const char * c_pcData, size_t uiBytes)
  2038. {
  2039. const TPacketCGSyncPosition* pinfo = reinterpret_cast<const TPacketCGSyncPosition*>( c_pcData );
  2041. if (uiBytes < pinfo->wSize)
  2042. return -1;
  2044. int iExtraLen = pinfo->wSize - sizeof(TPacketCGSyncPosition);
  2046. if (iExtraLen < 0)
  2047. {
  2048. sys_err("invalid packet length (len %d size %u buffer %u)", iExtraLen, pinfo->wSize, uiBytes);
  2049. ch->GetDesc()->SetPhase(PHASE_CLOSE);
  2050. return -1;
  2051. }
  2053. if (0 != (iExtraLen % sizeof(TPacketCGSyncPositionElement)))
  2054. {
  2055. sys_err("invalid packet length %d (name: %s)", pinfo->wSize, ch->GetName());
  2056. return iExtraLen;
  2057. }
  2059. int iCount = iExtraLen / sizeof(TPacketCGSyncPositionElement);
  2061. if (iCount <= 0)
  2062. return iExtraLen;
  2064. static const int nCountLimit = 16;
  2066. if( iCount > nCountLimit )
  2067. {
  2068. //LogManager::instance().HackLog( "SYNC_POSITION_HACK", ch );
  2069. sys_err( "Too many SyncPosition Count(%d) from Name(%s)", iCount, ch->GetName() );
  2070. //ch->GetDesc()->SetPhase(PHASE_CLOSE);
  2071. //return -1;
  2072. iCount = nCountLimit;
  2073. }
  2075. TEMP_BUFFER tbuf;
  2076. LPBUFFER lpBuf = tbuf.getptr();
  2078. TPacketGCSyncPosition * pHeader = (TPacketGCSyncPosition *) buffer_write_peek(lpBuf);
  2079. buffer_write_proceed(lpBuf, sizeof(TPacketGCSyncPosition));
  2081. const TPacketCGSyncPositionElement* e =
  2082. reinterpret_cast<const TPacketCGSyncPositionElement*>(c_pcData + sizeof(TPacketCGSyncPosition));
  2084. timeval tvCurTime;
  2085. gettimeofday(&tvCurTime, NULL);
  2087. for (int i = 0; i < iCount; ++i, ++e)
  2088. {
  2089. LPCHARACTER victim = CHARACTER_MANAGER::instance().Find(e->dwVID);
  2091. if (!victim)
  2092. continue;
  2094. switch (victim->GetCharType())
  2095. {
  2096. case CHAR_TYPE_NPC:
  2097. case CHAR_TYPE_WARP:
  2098. case CHAR_TYPE_GOTO:
  2099. continue;
  2100. }
  2102. // 소유권 검사
  2103. if (!victim->SetSyncOwner(ch))
  2104. continue;
  2106. const float fDistWithSyncOwner = DISTANCE_SQRT( (victim->GetX() - ch->GetX()) / 100, (victim->GetY() - ch->GetY()) / 100 );
  2107. static const float fLimitDistWithSyncOwner = 2500.f + 1000.f;
  2108. // victim과의 거리가 2500 + a 이상이면 핵으로 간주.
  2109. // 거리 참조 : 클라이언트의 __GetSkillTargetRange, __GetBowRange 함수
  2110. // 2500 : 스킬 proto에서 가장 사거리가 긴 스킬의 사거리, 또는 활의 사거리
  2111. // a = POINT_BOW_DISTANCE 값... 인데 실제로 사용하는 값인지는 잘 모르겠음. 아이템이나 포션, 스킬, 퀘스트에는 없는데...
  2112. // 그래도 혹시나 하는 마음에 버퍼로 사용할 겸해서 1000.f 로 둠...
  2113. if (fDistWithSyncOwner > fLimitDistWithSyncOwner)
  2114. {
  2115. // g_iSyncHackLimitCount번 까지는 봐줌.
  2116. if (ch->GetSyncHackCount() < g_iSyncHackLimitCount)
  2117. {
  2118. ch->SetSyncHackCount(ch->GetSyncHackCount() + 1);
  2119. continue;
  2120. }
  2121. else
  2122. {
  2123. LogManager::instance().HackLog( "SYNC_POSITION_HACK", ch );
  2125. sys_err( "Too far SyncPosition DistanceWithSyncOwner(%f)(%s) from Name(%s) CH(%d,%d) VICTIM(%d,%d) SYNC(%d,%d)",
  2126. fDistWithSyncOwner, victim->GetName(), ch->GetName(), ch->GetX(), ch->GetY(), victim->GetX(), victim->GetY(),
  2127. e->lX, e->lY );
  2129. ch->GetDesc()->SetPhase(PHASE_CLOSE);
  2131. return -1;
  2132. }
  2133. }
  2135. const float fDist = DISTANCE_SQRT( (victim->GetX() - e->lX) / 100, (victim->GetY() - e->lY) / 100 );
  2136. static const long g_lValidSyncInterval = 100 * 1000; // 100ms
  2137. const timeval &tvLastSyncTime = victim->GetLastSyncTime();
  2138. timeval *tvDiff = timediff(&tvCurTime, &tvLastSyncTime);
  2140. // SyncPosition을 악용하여 타유저를 이상한 곳으로 보내는 핵 방어하기 위하여,
  2141. // 같은 유저를 g_lValidSyncInterval ms 이내에 다시 SyncPosition하려고 하면 핵으로 간주.
  2142. if (tvDiff->tv_sec == 0 && tvDiff->tv_usec < g_lValidSyncInterval)
  2143. {
  2144. // g_iSyncHackLimitCount번 까지는 봐줌.
  2145. if (ch->GetSyncHackCount() < g_iSyncHackLimitCount)
  2146. {
  2147. ch->SetSyncHackCount(ch->GetSyncHackCount() + 1);
  2148. continue;
  2149. }
  2150. else
  2151. {
  2152. LogManager::instance().HackLog( "SYNC_POSITION_HACK", ch );
  2154. sys_err( "Too often SyncPosition Interval(%ldms)(%s) from Name(%s) VICTIM(%d,%d) SYNC(%d,%d)",
  2155. tvDiff->tv_sec * 1000 + tvDiff->tv_usec / 1000, victim->GetName(), ch->GetName(), victim->GetX(), victim->GetY(),
  2156. e->lX, e->lY );
  2158. ch->GetDesc()->SetPhase(PHASE_CLOSE);
  2160. return -1;
  2161. }
  2162. }
  2163. else if( fDist > 25.0f )
  2164. {
  2165. LogManager::instance().HackLog( "SYNC_POSITION_HACK", ch );
  2167. sys_err( "Too far SyncPosition Distance(%f)(%s) from Name(%s) CH(%d,%d) VICTIM(%d,%d) SYNC(%d,%d)",
  2168. fDist, victim->GetName(), ch->GetName(), ch->GetX(), ch->GetY(), victim->GetX(), victim->GetY(),
  2169. e->lX, e->lY );
  2171. ch->GetDesc()->SetPhase(PHASE_CLOSE);
  2173. return -1;
  2174. }
  2175. else
  2176. {
  2177. victim->SetLastSyncTime(tvCurTime);
  2178. victim->Sync(e->lX, e->lY);
  2179. buffer_write(lpBuf, e, sizeof(TPacketCGSyncPositionElement));
  2180. }
  2181. }
  2183. if (buffer_size(lpBuf) != sizeof(TPacketGCSyncPosition))
  2184. {
  2185. pHeader->bHeader = HEADER_GC_SYNC_POSITION;
  2186. pHeader->wSize = buffer_size(lpBuf);
  2188. ch->PacketAround(buffer_read_peek(lpBuf), buffer_size(lpBuf), ch);
  2189. }
  2191. return iExtraLen;
  2192. }
  2194. void CInputMain::FlyTarget(LPCHARACTER ch, const char * pcData, BYTE bHeader)
  2195. {
  2196. TPacketCGFlyTargeting * p = (TPacketCGFlyTargeting *) pcData;
  2197. ch->FlyTarget(p->dwTargetVID, p->x, p->y, bHeader);
  2198. }
  2200. void CInputMain::UseSkill(LPCHARACTER ch, const char * pcData)
  2201. {
  2202. TPacketCGUseSkill * p = (TPacketCGUseSkill *) pcData;
  2203. ch->UseSkill(p->dwVnum, CHARACTER_MANAGER::instance().Find(p->dwVID));
  2204. }
  2206. void CInputMain::ScriptButton(LPCHARACTER ch, const void* c_pData)
  2207. {
  2208. TPacketCGScriptButton * p = (TPacketCGScriptButton *) c_pData;
  2209. sys_log(0, "QUEST ScriptButton pid %d idx %u", ch->GetPlayerID(), p->idx);
  2211. quest::PC* pc = quest::CQuestManager::instance().GetPCForce(ch->GetPlayerID());
  2212. if (pc && pc->IsConfirmWait())
  2213. {
  2214. quest::CQuestManager::instance().Confirm(ch->GetPlayerID(), quest::CONFIRM_TIMEOUT);
  2215. }
  2216. else if (p->idx & 0x80000000)
  2217. {
  2218. //퀘스트 창에서 클릭시(__SelectQuest) 여기로
  2219. quest::CQuestManager::Instance().QuestInfo(ch->GetPlayerID(), p->idx & 0x7fffffff);
  2220. }
  2221. else
  2222. {
  2223. quest::CQuestManager::Instance().QuestButton(ch->GetPlayerID(), p->idx);
  2224. }
  2225. }
  2227. void CInputMain::ScriptAnswer(LPCHARACTER ch, const void* c_pData)
  2228. {
  2229. TPacketCGScriptAnswer * p = (TPacketCGScriptAnswer *) c_pData;
  2230. sys_log(0, "QUEST ScriptAnswer pid %d answer %d", ch->GetPlayerID(), p->answer);
  2232. if (p->answer > 250) // 다음 버튼에 대한 응답으로 온 패킷인 경우
  2233. {
  2234. quest::CQuestManager::Instance().Resume(ch->GetPlayerID());
  2235. }
  2236. else // 선택 버튼을 골라서 온 패킷인 경우
  2237. {
  2238. quest::CQuestManager::Instance().Select(ch->GetPlayerID(), p->answer);
  2239. }
  2240. }
  2243. // SCRIPT_SELECT_ITEM
  2244. void CInputMain::ScriptSelectItem(LPCHARACTER ch, const void* c_pData)
  2245. {
  2246. TPacketCGScriptSelectItem* p = (TPacketCGScriptSelectItem*) c_pData;
  2247. sys_log(0, "QUEST ScriptSelectItem pid %d answer %d", ch->GetPlayerID(), p->selection);
  2248. quest::CQuestManager::Instance().SelectItem(ch->GetPlayerID(), p->selection);
  2249. }
  2250. // END_OF_SCRIPT_SELECT_ITEM
  2252. void CInputMain::QuestInputString(LPCHARACTER ch, const void* c_pData)
  2253. {
  2254. TPacketCGQuestInputString * p = (TPacketCGQuestInputString*) c_pData;
  2256. char msg[65];
  2257. strlcpy(msg, p->msg, sizeof(msg));
  2258. sys_log(0, "QUEST InputString pid %u msg %s", ch->GetPlayerID(), msg);
  2260. quest::CQuestManager::Instance().Input(ch->GetPlayerID(), msg);
  2261. }
  2263. void CInputMain::QuestConfirm(LPCHARACTER ch, const void* c_pData)
  2264. {
  2265. TPacketCGQuestConfirm* p = (TPacketCGQuestConfirm*) c_pData;
  2266. LPCHARACTER ch_wait = CHARACTER_MANAGER::instance().FindByPID(p->requestPID);
  2267. if (p->answer)
  2268. p->answer = quest::CONFIRM_YES;
  2269. sys_log(0, "QuestConfirm from %s pid %u name %s answer %d", ch->GetName(), p->requestPID, (ch_wait)?ch_wait->GetName():"", p->answer);
  2270. if (ch_wait)
  2271. {
  2272. quest::CQuestManager::Instance().Confirm(ch_wait->GetPlayerID(), (quest::EQuestConfirmType) p->answer, ch->GetPlayerID());
  2273. }
  2274. }
  2276. void CInputMain::Target(LPCHARACTER ch, const char * pcData)
  2277. {
  2278. TPacketCGTarget * p = (TPacketCGTarget *) pcData;
  2280. building::LPOBJECT pkObj = building::CManager::instance().FindObjectByVID(p->dwVID);
  2282. if (pkObj)
  2283. {
  2284. TPacketGCTarget pckTarget;
  2285. pckTarget.header = HEADER_GC_TARGET;
  2286. pckTarget.dwVID = p->dwVID;
  2287. ch->GetDesc()->Packet(&pckTarget, sizeof(TPacketGCTarget));
  2288. }
  2289. else
  2290. ch->SetTarget(CHARACTER_MANAGER::instance().Find(p->dwVID));
  2291. }
  2293. void CInputMain::Warp(LPCHARACTER ch, const char * pcData)
  2294. {
  2295. ch->WarpEnd();
  2296. }
  2298. void CInputMain::SafeboxCheckin(LPCHARACTER ch, const char * c_pData)
  2299. {
  2300. if (quest::CQuestManager::instance().GetPCForce(ch->GetPlayerID())->IsRunning() == true)
  2301. return;
  2303. TPacketCGSafeboxCheckin * p = (TPacketCGSafeboxCheckin *) c_pData;
  2305. if (!ch->CanHandleItem())
  2306. return;
  2308. {
  2309. CSafebox * pkSafebox = ch->GetSafebox();
  2310. LPITEM pkItem = ch->GetItem(p->ItemPos);
  2311. if (!pkSafebox || !pkItem)
  2312. LPITEM pkItemNew = ch->GetWear(WEAR_COSTUME_WEAPON);
  2313. return;
  2314. {
  2316. if (pkItem->GetCell() >= INVENTORY_MAX_NUM && IS_SET(pkItem->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  2318. {
  2319. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 창고로 옮길 수 없는 아이템 입니다."));
  2320. return;
  2321. }
  2323. {
  2324. if (pkItem->GetType() == ITEM_BELT && pkItem->IsEquipped())
  2325. ch->ChatPacket(CHAT_TYPE_INFO, "Once kemer Envanterini bosalt!");
  2326. return;
  2327. }
  2329. if (!pkSafebox->IsEmpty(p->bSafePos, pkItem->GetSize()))
  2330. {
  2331. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 옮길 수 없는 위치입니다."));
  2332. return;
  2333. }
  2335. if (pkItem->GetVnum() == UNIQUE_ITEM_SAFEBOX_EXPAND)
  2336. {
  2337. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 이 아이템은 넣을 수 없습니다."));
  2338. return;
  2339. }
  2341. if( IS_SET(pkItem->GetAntiFlag(), ITEM_ANTIFLAG_SAFEBOX) )
  2342. {
  2343. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 이 아이템은 넣을 수 없습니다."));
  2344. return;
  2345. }
  2347. if (true == pkItem->isLocked())
  2348. {
  2349. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 이 아이템은 넣을 수 없습니다."));
  2350. if (pkItemNew)
  2351. {
  2352. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("UYARI_KOSTUM"));
  2353. return;
  2354. }
  2356. pkItem->RemoveFromCharacter();
  2357. if (!pkItem->IsDragonSoul())
  2358. ch->SyncQuickslot(QUICKSLOT_TYPE_ITEM, p->ItemPos.cell, 255);
  2359. pkSafebox->Add(p->bSafePos, pkItem);
  2361. char szHint[128];
  2362. snprintf(szHint, sizeof(szHint), "%s %u", pkItem->GetName(), pkItem->GetCount());
  2363. LogManager::instance().ItemLog(ch, pkItem, "SAFEBOX PUT", szHint);
  2364. }
  2365. void CInputMain::SafeboxCheckout(LPCHARACTER ch, const char * c_pData, bool bMall)
  2367. {
  2368. TPacketCGSafeboxCheckout * p = (TPacketCGSafeboxCheckout *) c_pData;
  2370. if (!ch->CanHandleItem())
  2371. return;
  2373. CSafebox * pkSafebox;
  2375. if (bMall)
  2376. pkSafebox = ch->GetMall();
  2377. else
  2378. pkSafebox = ch->GetSafebox();
  2380. if (!pkSafebox)
  2381. return;
  2383. LPITEM pkItem = pkSafebox->Get(p->bSafePos);
  2385. if (!pkItem)
  2386. return;
  2388. if (!ch->IsEmptyItemGrid(p->ItemPos, pkItem->GetSize()))
  2389. return;
  2391. // 아이템 몰에서 인벤으로 옮기는 부분에서 용혼석 특수 처리
  2392. // (몰에서 만드는 아이템은 item_proto에 정의된대로 속성이 붙기 때문에,
  2393. // 용혼석의 경우, 이 처리를 하지 않으면 속성이 하나도 붙지 않게 된다.)
  2394. if (pkItem->IsDragonSoul())
  2395. {
  2396. if (bMall)
  2397. {
  2398. DSManager::instance().DragonSoulItemInitialize(pkItem);
  2399. }
  2401. if (DRAGON_SOUL_INVENTORY != p->ItemPos.window_type)
  2402. {
  2403. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 옮길 수 없는 위치입니다."));
  2404. return;
  2405. }
  2407. TItemPos DestPos = p->ItemPos;
  2408. if (!DSManager::instance().IsValidCellForThisItem(pkItem, DestPos))
  2409. {
  2410. int iCell = ch->GetEmptyDragonSoulInventory(pkItem);
  2411. if (iCell < 0)
  2412. {
  2413. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 옮길 수 없는 위치입니다."));
  2414. return ;
  2415. }
  2416. DestPos = TItemPos (DRAGON_SOUL_INVENTORY, iCell);
  2417. }
  2419. pkSafebox->Remove(p->bSafePos);
  2420. pkItem->AddToCharacter(ch, DestPos);
  2421. ITEM_MANAGER::instance().FlushDelayedSave(pkItem);
  2422. }
  2423. else
  2424. {
  2425. if (DRAGON_SOUL_INVENTORY == p->ItemPos.window_type)
  2426. {
  2427. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 옮길 수 없는 위치입니다."));
  2428. return;
  2429. }
  2430. // @fixme119
  2431. if (p->ItemPos.IsBeltInventoryPosition() && false == CBeltInventoryHelper::CanMoveIntoBeltInventory(pkItem))
  2432. {
  2433. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 벨트 인벤토리로 옮길 수 없습니다."));
  2434. return;
  2435. }
  2437. pkSafebox->Remove(p->bSafePos);
  2438. pkItem->AddToCharacter(ch, p->ItemPos);
  2439. ITEM_MANAGER::instance().FlushDelayedSave(pkItem);
  2440. }
  2442. DWORD dwID = pkItem->GetID();
  2443. db_clientdesc->DBPacketHeader(HEADER_GD_ITEM_FLUSH, 0, sizeof(DWORD));
  2444. db_clientdesc->Packet(&dwID, sizeof(DWORD));
  2446. char szHint[128];
  2447. snprintf(szHint, sizeof(szHint), "%s %u", pkItem->GetName(), pkItem->GetCount());
  2448. if (bMall)
  2449. LogManager::instance().ItemLog(ch, pkItem, "MALL GET", szHint);
  2450. else
  2451. LogManager::instance().ItemLog(ch, pkItem, "SAFEBOX GET", szHint);
  2452. }
  2454. void CInputMain::SafeboxItemMove(LPCHARACTER ch, const char * data)
  2455. {
  2456. struct command_item_move * pinfo = (struct command_item_move *) data;
  2458. if (!ch->CanHandleItem())
  2459. return;
  2461. if (!ch->GetSafebox())
  2462. return;
  2464. ch->GetSafebox()->MoveItem(pinfo->Cell.cell, pinfo->CellTo.cell, pinfo->count);
  2465. }
  2467. // PARTY_JOIN_BUG_FIX
  2468. void CInputMain::PartyInvite(LPCHARACTER ch, const char * c_pData)
  2469. {
  2470. if (ch->GetArena())
  2471. {
  2472. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  2473. return;
  2474. }
  2476. TPacketCGPartyInvite * p = (TPacketCGPartyInvite*) c_pData;
  2478. LPCHARACTER pInvitee = CHARACTER_MANAGER::instance().Find(p->vid);
  2480. if (!pInvitee || !ch->GetDesc() || !pInvitee->GetDesc())
  2481. {
  2482. sys_err("PARTY Cannot find invited character");
  2483. return;
  2484. }
  2486. ch->PartyInvite(pInvitee);
  2487. }
  2489. void CInputMain::PartyInviteAnswer(LPCHARACTER ch, const char * c_pData)
  2490. {
  2491. if (ch->GetArena())
  2492. {
  2493. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  2494. return;
  2495. }
  2497. TPacketCGPartyInviteAnswer * p = (TPacketCGPartyInviteAnswer*) c_pData;
  2499. LPCHARACTER pInviter = CHARACTER_MANAGER::instance().Find(p->leader_vid);
  2501. // pInviter 가 ch 에게 파티 요청을 했었다.
  2503. if (!pInviter)
  2504. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티요청을 한 캐릭터를 찾을수 없습니다."));
  2505. else if (!p->accept)
  2506. pInviter->PartyInviteDeny(ch->GetPlayerID());
  2507. else
  2508. pInviter->PartyInviteAccept(ch);
  2509. }
  2510. // END_OF_PARTY_JOIN_BUG_FIX
  2512. void CInputMain::PartySetState(LPCHARACTER ch, const char* c_pData)
  2513. {
  2514. if (!CPartyManager::instance().IsEnablePCParty())
  2515. {
  2516. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 서버 문제로 파티 관련 처리를 할 수 없습니다."));
  2517. return;
  2518. }
  2520. TPacketCGPartySetState* p = (TPacketCGPartySetState*) c_pData;
  2522. if (!ch->GetParty())
  2523. return;
  2525. if (ch->GetParty()->GetLeaderPID() != ch->GetPlayerID())
  2526. {
  2527. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 리더만 변경할 수 있습니다."));
  2528. return;
  2529. }
  2531. if (!ch->GetParty()->IsMember(p->pid))
  2532. {
  2533. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 상태를 변경하려는 사람이 파티원이 아닙니다."));
  2534. return;
  2535. }
  2537. DWORD pid = p->pid;
  2538. sys_log(0, "PARTY SetRole pid %d to role %d state %s", pid, p->byRole, p->flag ? "on" : "off");
  2540. switch (p->byRole)
  2541. {
  2542. case PARTY_ROLE_NORMAL:
  2543. break;
  2545. case PARTY_ROLE_ATTACKER:
  2546. case PARTY_ROLE_TANKER:
  2547. case PARTY_ROLE_BUFFER:
  2548. case PARTY_ROLE_SKILL_MASTER:
  2549. case PARTY_ROLE_HASTE:
  2550. case PARTY_ROLE_DEFENDER:
  2551. if (ch->GetParty()->SetRole(pid, p->byRole, p->flag))
  2552. {
  2553. TPacketPartyStateChange pack;
  2554. pack.dwLeaderPID = ch->GetPlayerID();
  2555. pack.dwPID = p->pid;
  2556. pack.bRole = p->byRole;
  2557. pack.bFlag = p->flag;
  2558. db_clientdesc->DBPacket(HEADER_GD_PARTY_STATE_CHANGE, 0, &pack, sizeof(pack));
  2559. }
  2560. /* else
  2561. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 어태커 설정에 실패하였습니다.")); */
  2562. break;
  2564. default:
  2565. sys_err("wrong byRole in PartySetState Packet name %s state %d", ch->GetName(), p->byRole);
  2566. break;
  2567. }
  2568. }
  2570. void CInputMain::PartyRemove(LPCHARACTER ch, const char* c_pData)
  2571. {
  2572. if (ch->GetArena())
  2573. {
  2574. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  2575. return;
  2576. }
  2578. if (!CPartyManager::instance().IsEnablePCParty())
  2579. {
  2580. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 서버 문제로 파티 관련 처리를 할 수 없습니다."));
  2581. return;
  2582. }
  2584. if (ch->GetDungeon())
  2585. {
  2586. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 던전 안에서는 파티에서 추방할 수 없습니다."));
  2587. return;
  2588. }
  2590. TPacketCGPartyRemove* p = (TPacketCGPartyRemove*) c_pData;
  2592. if (!ch->GetParty())
  2593. return;
  2595. LPPARTY pParty = ch->GetParty();
  2596. if (pParty->GetLeaderPID() == ch->GetPlayerID())
  2597. {
  2598. if (ch->GetDungeon())
  2599. {
  2600. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 던젼내에서는 파티원을 추방할 수 없습니다."));
  2601. }
  2602. else
  2603. {
  2604. // 적룡성에서 파티장이 던젼 밖에서 파티 해산 못하게 막자
  2605. if(pParty->IsPartyInDungeon(351))
  2606. {
  2607. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티>던전 안에 파티원이 있어 파티를 해산 할 수 없습니다."));
  2608. return;
  2609. }
  2611. // leader can remove any member
  2612. if (p->pid == ch->GetPlayerID() || pParty->GetMemberCount() == 2)
  2613. {
  2614. // party disband
  2615. CPartyManager::instance().DeleteParty(pParty);
  2616. }
  2617. else
  2618. {
  2619. LPCHARACTER B = CHARACTER_MANAGER::instance().FindByPID(p->pid);
  2620. if (B)
  2621. {
  2622. //pParty->SendPartyRemoveOneToAll(B);
  2623. B->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티에서 추방당하셨습니다."));
  2624. //pParty->Unlink(B);
  2625. //CPartyManager::instance().SetPartyMember(B->GetPlayerID(), NULL);
  2626. }
  2627. pParty->Quit(p->pid);
  2628. }
  2629. }
  2630. }
  2631. else
  2632. {
  2633. // otherwise, only remove itself
  2634. if (p->pid == ch->GetPlayerID())
  2635. {
  2636. if (ch->GetDungeon())
  2637. {
  2638. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 던젼내에서는 파티를 나갈 수 없습니다."));
  2639. }
  2640. else
  2641. {
  2642. if (pParty->GetMemberCount() == 2)
  2643. {
  2644. // party disband
  2645. CPartyManager::instance().DeleteParty(pParty);
  2646. }
  2647. else
  2648. {
  2649. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티에서 나가셨습니다."));
  2650. //pParty->SendPartyRemoveOneToAll(ch);
  2651. pParty->Quit(ch->GetPlayerID());
  2652. //pParty->SendPartyRemoveAllToOne(ch);
  2653. //CPartyManager::instance().SetPartyMember(ch->GetPlayerID(), NULL);
  2654. }
  2655. }
  2656. }
  2657. else
  2658. {
  2659. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 다른 파티원을 탈퇴시킬 수 없습니다."));
  2660. }
  2661. }
  2662. }
  2664. void CInputMain::AnswerMakeGuild(LPCHARACTER ch, const char* c_pData)
  2665. {
  2666. TPacketCGAnswerMakeGuild* p = (TPacketCGAnswerMakeGuild*) c_pData;
  2668. if (ch->GetGold() < 200000)
  2669. return;
  2671. if (get_global_time() - ch->GetQuestFlag("guild_manage.new_disband_time") <
  2672. CGuildManager::instance().GetDisbandDelay())
  2673. {
  2674. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 해산한 후 %d일 이내에는 길드를 만들 수 없습니다."),
  2675. quest::CQuestManager::instance().GetEventFlag("guild_disband_delay"));
  2676. return;
  2677. }
  2679. if (get_global_time() - ch->GetQuestFlag("guild_manage.new_withdraw_time") <
  2680. CGuildManager::instance().GetWithdrawDelay())
  2681. {
  2682. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 탈퇴한 후 %d일 이내에는 길드를 만들 수 없습니다."),
  2683. quest::CQuestManager::instance().GetEventFlag("guild_withdraw_delay"));
  2684. return;
  2685. }
  2687. if (ch->GetGuild())
  2688. return;
  2690. CGuildManager& gm = CGuildManager::instance();
  2692. TGuildCreateParameter cp;
  2693. memset(&cp, 0, sizeof(cp));
  2695. cp.master = ch;
  2696. strlcpy(cp.name, p->guild_name, sizeof(cp.name));
  2698. if (cp.name[0] == 0 || !check_name(cp.name))
  2699. {
  2700. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("적합하지 않은 길드 이름 입니다."));
  2701. return;
  2702. }
  2704. DWORD dwGuildID = gm.CreateGuild(cp);
  2706. if (dwGuildID)
  2707. {
  2708. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> [%s] 길드가 생성되었습니다."), cp.name);
  2710. int GuildCreateFee = 200000;
  2712. ch->PointChange(POINT_GOLD, -GuildCreateFee);
  2713. DBManager::instance().SendMoneyLog(MONEY_LOG_GUILD, ch->GetPlayerID(), -GuildCreateFee);
  2715. char Log[128];
  2716. snprintf(Log, sizeof(Log), "GUILD_NAME %s MASTER %s", cp.name, ch->GetName());
  2717. LogManager::instance().CharLog(ch, 0, "MAKE_GUILD", Log);
  2719. ch->RemoveSpecifyItem(GUILD_CREATE_ITEM_VNUM, 1);
  2720. //ch->SendGuildName(dwGuildID);
  2721. }
  2722. else
  2723. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드 생성에 실패하였습니다."));
  2724. }
  2726. void CInputMain::PartyUseSkill(LPCHARACTER ch, const char* c_pData)
  2727. {
  2728. TPacketCGPartyUseSkill* p = (TPacketCGPartyUseSkill*) c_pData;
  2729. if (!ch->GetParty())
  2730. return;
  2732. if (ch->GetPlayerID() != ch->GetParty()->GetLeaderPID())
  2733. {
  2734. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 파티 기술은 파티장만 사용할 수 있습니다."));
  2735. return;
  2736. }
  2738. switch (p->bySkillIndex)
  2739. {
  2740. case PARTY_SKILL_HEAL:
  2741. ch->GetParty()->HealParty();
  2742. break;
  2743. case PARTY_SKILL_WARP:
  2744. {
  2745. LPCHARACTER pch = CHARACTER_MANAGER::instance().Find(p->vid);
  2746. if (pch)
  2747. ch->GetParty()->SummonToLeader(pch->GetPlayerID());
  2748. else
  2749. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<파티> 소환하려는 대상을 찾을 수 없습니다."));
  2750. }
  2751. break;
  2752. }
  2753. }
  2755. void CInputMain::PartyParameter(LPCHARACTER ch, const char * c_pData)
  2756. {
  2757. TPacketCGPartyParameter * p = (TPacketCGPartyParameter *) c_pData;
  2759. if (ch->GetParty())
  2760. ch->GetParty()->SetParameter(p->bDistributeMode);
  2761. }
  2763. size_t GetSubPacketSize(const GUILD_SUBHEADER_CG& header)
  2764. {
  2765. switch (header)
  2766. {
  2767. case GUILD_SUBHEADER_CG_DEPOSIT_MONEY: return sizeof(int);
  2768. case GUILD_SUBHEADER_CG_WITHDRAW_MONEY: return sizeof(int);
  2769. case GUILD_SUBHEADER_CG_ADD_MEMBER: return sizeof(DWORD);
  2770. case GUILD_SUBHEADER_CG_REMOVE_MEMBER: return sizeof(DWORD);
  2771. case GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME: return 10;
  2772. case GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY: return sizeof(BYTE) + sizeof(BYTE);
  2773. case GUILD_SUBHEADER_CG_OFFER: return sizeof(DWORD);
  2774. case GUILD_SUBHEADER_CG_CHARGE_GSP: return sizeof(int);
  2775. case GUILD_SUBHEADER_CG_POST_COMMENT: return 1;
  2776. case GUILD_SUBHEADER_CG_DELETE_COMMENT: return sizeof(DWORD);
  2777. case GUILD_SUBHEADER_CG_REFRESH_COMMENT: return 0;
  2778. case GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE: return sizeof(DWORD) + sizeof(BYTE);
  2779. case GUILD_SUBHEADER_CG_USE_SKILL: return sizeof(TPacketCGGuildUseSkill);
  2780. case GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL: return sizeof(DWORD) + sizeof(BYTE);
  2781. case GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER: return sizeof(DWORD) + sizeof(BYTE);
  2782. }
  2784. return 0;
  2785. }
  2787. int CInputMain::Guild(LPCHARACTER ch, const char * data, size_t uiBytes)
  2788. {
  2789. if (uiBytes < sizeof(TPacketCGGuild))
  2790. return -1;
  2792. const TPacketCGGuild* p = reinterpret_cast<const TPacketCGGuild*>(data);
  2793. const char* c_pData = data + sizeof(TPacketCGGuild);
  2795. uiBytes -= sizeof(TPacketCGGuild);
  2797. const GUILD_SUBHEADER_CG SubHeader = static_cast<GUILD_SUBHEADER_CG>(p->subheader);
  2798. const size_t SubPacketLen = GetSubPacketSize(SubHeader);
  2800. if (uiBytes < SubPacketLen)
  2801. {
  2802. return -1;
  2803. }
  2805. CGuild* pGuild = ch->GetGuild();
  2807. if (NULL == pGuild)
  2808. {
  2809. if (SubHeader != GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER)
  2810. {
  2811. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드에 속해있지 않습니다."));
  2812. return SubPacketLen;
  2813. }
  2814. }
  2816. switch (SubHeader)
  2817. {
  2818. case GUILD_SUBHEADER_CG_DEPOSIT_MONEY:
  2819. {
  2820. // by mhh : 길드자금은 당분간 넣을 수 없다.
  2821. return SubPacketLen;
  2823. const int gold = MIN(*reinterpret_cast<const int*>(c_pData), __deposit_limit());
  2825. if (gold < 0)
  2826. {
  2827. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 잘못된 금액입니다."));
  2828. return SubPacketLen;
  2829. }
  2831. if (ch->GetGold() < gold)
  2832. {
  2833. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 가지고 있는 돈이 부족합니다."));
  2834. return SubPacketLen;
  2835. }
  2837. pGuild->RequestDepositMoney(ch, gold);
  2838. }
  2839. return SubPacketLen;
  2841. case GUILD_SUBHEADER_CG_WITHDRAW_MONEY:
  2842. {
  2843. // by mhh : 길드자금은 당분간 뺄 수 없다.
  2844. return SubPacketLen;
  2846. const int gold = MIN(*reinterpret_cast<const int*>(c_pData), 500000);
  2848. if (gold < 0)
  2849. {
  2850. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 잘못된 금액입니다."));
  2851. return SubPacketLen;
  2852. }
  2854. pGuild->RequestWithdrawMoney(ch, gold);
  2855. }
  2856. return SubPacketLen;
  2858. case GUILD_SUBHEADER_CG_ADD_MEMBER:
  2859. {
  2860. const DWORD vid = *reinterpret_cast<const DWORD*>(c_pData);
  2861. LPCHARACTER newmember = CHARACTER_MANAGER::instance().Find(vid);
  2863. if (!newmember)
  2864. {
  2865. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 그러한 사람을 찾을 수 없습니다."));
  2866. return SubPacketLen;
  2867. }
  2869. if (!ch->IsPC())
  2870. return SubPacketLen;
  2872. pGuild->Invite(ch, newmember);
  2873. }
  2874. return SubPacketLen;
  2876. case GUILD_SUBHEADER_CG_REMOVE_MEMBER:
  2877. {
  2878. if (pGuild->UnderAnyWar() != 0)
  2879. {
  2880. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드전 중에는 길드원을 탈퇴시킬 수 없습니다."));
  2881. return SubPacketLen;
  2882. }
  2884. const DWORD pid = *reinterpret_cast<const DWORD*>(c_pData);
  2885. const TGuildMember* m = pGuild->GetMember(ch->GetPlayerID());
  2887. if (NULL == m)
  2888. return -1;
  2890. LPCHARACTER member = CHARACTER_MANAGER::instance().FindByPID(pid);
  2892. if (member)
  2893. {
  2894. if (member->GetGuild() != pGuild)
  2895. {
  2896. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 상대방이 같은 길드가 아닙니다."));
  2897. return SubPacketLen;
  2898. }
  2900. if (!pGuild->HasGradeAuth(m->grade, GUILD_AUTH_REMOVE_MEMBER))
  2901. {
  2902. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드원을 강제 탈퇴 시킬 권한이 없습니다."));
  2903. return SubPacketLen;
  2904. }
  2906. member->SetQuestFlag("guild_manage.new_withdraw_time", get_global_time());
  2907. pGuild->RequestRemoveMember(member->GetPlayerID());
  2909. if (g_bGuildInviteLimit)
  2910. {
  2911. DBManager::instance().Query("REPLACE INTO guild_invite_limit VALUES(%d, %d)", pGuild->GetID(), get_global_time());
  2912. }
  2913. }
  2914. else
  2915. {
  2916. if (!pGuild->HasGradeAuth(m->grade, GUILD_AUTH_REMOVE_MEMBER))
  2917. {
  2918. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드원을 강제 탈퇴 시킬 권한이 없습니다."));
  2919. return SubPacketLen;
  2920. }
  2922. if (pGuild->RequestRemoveMember(pid))
  2923. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드원을 강제 탈퇴 시켰습니다."));
  2924. else
  2925. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 그러한 사람을 찾을 수 없습니다."));
  2926. }
  2927. }
  2928. return SubPacketLen;
  2930. case GUILD_SUBHEADER_CG_CHANGE_GRADE_NAME:
  2931. {
  2932. char gradename[GUILD_GRADE_NAME_MAX_LEN + 1];
  2933. strlcpy(gradename, c_pData + 1, sizeof(gradename));
  2935. const TGuildMember * m = pGuild->GetMember(ch->GetPlayerID());
  2937. if (NULL == m)
  2938. return -1;
  2940. if (m->grade != GUILD_LEADER_GRADE)
  2941. {
  2942. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 직위 이름을 변경할 권한이 없습니다."));
  2943. }
  2944. else if (*c_pData == GUILD_LEADER_GRADE)
  2945. {
  2946. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드장의 직위 이름은 변경할 수 없습니다."));
  2947. }
  2948. else if (!check_name(gradename))
  2949. {
  2950. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 적합하지 않은 직위 이름 입니다."));
  2951. }
  2952. else
  2953. {
  2954. pGuild->ChangeGradeName(*c_pData, gradename);
  2955. }
  2956. }
  2957. return SubPacketLen;
  2959. case GUILD_SUBHEADER_CG_CHANGE_GRADE_AUTHORITY:
  2960. {
  2961. const TGuildMember* m = pGuild->GetMember(ch->GetPlayerID());
  2963. if (NULL == m)
  2964. return -1;
  2966. if (m->grade != GUILD_LEADER_GRADE)
  2967. {
  2968. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 직위 권한을 변경할 권한이 없습니다."));
  2969. }
  2970. else if (*c_pData == GUILD_LEADER_GRADE)
  2971. {
  2972. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드장의 권한은 변경할 수 없습니다."));
  2973. }
  2974. else
  2975. {
  2976. pGuild->ChangeGradeAuth(*c_pData, *(c_pData + 1));
  2977. }
  2978. }
  2979. return SubPacketLen;
  2981. case GUILD_SUBHEADER_CG_OFFER:
  2982. {
  2983. DWORD offer = *reinterpret_cast<const DWORD*>(c_pData);
  2985. if (pGuild->GetLevel() >= GUILD_MAX_LEVEL)
  2986. {
  2987. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드가 이미 최고 레벨입니다."));
  2988. }
  2989. else
  2990. {
  2991. offer /= 100;
  2992. offer *= 100;
  2994. if (pGuild->OfferExp(ch, offer))
  2995. {
  2996. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> %u의 경험치를 투자하였습니다."), offer);
  2997. }
  2998. else
  2999. {
  3000. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 경험치 투자에 실패하였습니다."));
  3001. }
  3002. }
  3003. }
  3004. return SubPacketLen;
  3006. case GUILD_SUBHEADER_CG_CHARGE_GSP:
  3007. {
  3008. const int offer = *reinterpret_cast<const int*>(c_pData);
  3009. const int gold = offer * 100;
  3011. if (offer < 0 || gold < offer || gold < 0 || ch->GetGold() < gold)
  3012. {
  3013. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 돈이 부족합니다."));
  3014. return SubPacketLen;
  3015. }
  3017. if (!pGuild->ChargeSP(ch, offer))
  3018. {
  3019. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 용신력 회복에 실패하였습니다."));
  3020. }
  3021. }
  3022. return SubPacketLen;
  3024. case GUILD_SUBHEADER_CG_POST_COMMENT:
  3025. {
  3026. const size_t length = *c_pData;
  3028. if (length > GUILD_COMMENT_MAX_LEN)
  3029. {
  3030. // 잘못된 길이.. 끊어주자.
  3031. sys_err("POST_COMMENT: %s comment too long (length: %u)", ch->GetName(), length);
  3032. ch->GetDesc()->SetPhase(PHASE_CLOSE);
  3033. return -1;
  3034. }
  3036. if (uiBytes < 1 + length)
  3037. return -1;
  3039. const TGuildMember* m = pGuild->GetMember(ch->GetPlayerID());
  3041. if (NULL == m)
  3042. return -1;
  3044. if (length && !pGuild->HasGradeAuth(m->grade, GUILD_AUTH_NOTICE) && *(c_pData + 1) == '!')
  3045. {
  3046. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 공지글을 작성할 권한이 없습니다."));
  3047. }
  3048. else
  3049. {
  3050. std::string str(c_pData + 1, length);
  3051. pGuild->AddComment(ch, str);
  3052. }
  3054. return (1 + length);
  3055. }
  3057. case GUILD_SUBHEADER_CG_DELETE_COMMENT:
  3058. {
  3059. const DWORD comment_id = *reinterpret_cast<const DWORD*>(c_pData);
  3061. pGuild->DeleteComment(ch, comment_id);
  3062. }
  3063. return SubPacketLen;
  3065. case GUILD_SUBHEADER_CG_REFRESH_COMMENT:
  3066. pGuild->RefreshComment(ch);
  3067. return SubPacketLen;
  3069. case GUILD_SUBHEADER_CG_CHANGE_MEMBER_GRADE:
  3070. {
  3071. const DWORD pid = *reinterpret_cast<const DWORD*>(c_pData);
  3072. const BYTE grade = *(c_pData + sizeof(DWORD));
  3073. const TGuildMember* m = pGuild->GetMember(ch->GetPlayerID());
  3075. if (NULL == m)
  3076. return -1;
  3078. if (m->grade != GUILD_LEADER_GRADE)
  3079. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 직위를 변경할 권한이 없습니다."));
  3080. else if (ch->GetPlayerID() == pid)
  3081. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드장의 직위는 변경할 수 없습니다."));
  3082. else if (grade == 1)
  3083. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 길드장으로 직위를 변경할 수 없습니다."));
  3084. else
  3085. pGuild->ChangeMemberGrade(pid, grade);
  3086. }
  3087. return SubPacketLen;
  3089. case GUILD_SUBHEADER_CG_USE_SKILL:
  3090. {
  3091. const TPacketCGGuildUseSkill* p = reinterpret_cast<const TPacketCGGuildUseSkill*>(c_pData);
  3093. pGuild->UseSkill(p->dwVnum, ch, p->dwPID);
  3094. }
  3095. return SubPacketLen;
  3097. case GUILD_SUBHEADER_CG_CHANGE_MEMBER_GENERAL:
  3098. {
  3099. const DWORD pid = *reinterpret_cast<const DWORD*>(c_pData);
  3100. const BYTE is_general = *(c_pData + sizeof(DWORD));
  3101. const TGuildMember* m = pGuild->GetMember(ch->GetPlayerID());
  3103. if (NULL == m)
  3104. return -1;
  3106. if (m->grade != GUILD_LEADER_GRADE)
  3107. {
  3108. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 장군을 지정할 권한이 없습니다."));
  3109. }
  3110. else
  3111. {
  3112. if (!pGuild->ChangeMemberGeneral(pid, is_general))
  3113. {
  3114. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<길드> 더이상 장수를 지정할 수 없습니다."));
  3115. }
  3116. }
  3117. }
  3118. return SubPacketLen;
  3120. case GUILD_SUBHEADER_CG_GUILD_INVITE_ANSWER:
  3121. {
  3122. const DWORD guild_id = *reinterpret_cast<const DWORD*>(c_pData);
  3123. const BYTE accept = *(c_pData + sizeof(DWORD));
  3125. CGuild * g = CGuildManager::instance().FindGuild(guild_id);
  3127. if (g)
  3128. {
  3129. if (accept)
  3130. g->InviteAccept(ch);
  3131. else
  3132. g->InviteDeny(ch->GetPlayerID());
  3133. }
  3134. }
  3135. return SubPacketLen;
  3137. }
  3139. return 0;
  3140. }
  3142. void CInputMain::Fishing(LPCHARACTER ch, const char* c_pData)
  3143. {
  3144. TPacketCGFishing* p = (TPacketCGFishing*)c_pData;
  3145. ch->SetRotation(p->dir * 5);
  3146. ch->fishing();
  3147. return;
  3148. }
  3150. void CInputMain::ItemGive(LPCHARACTER ch, const char* c_pData)
  3151. {
  3152. TPacketCGGiveItem* p = (TPacketCGGiveItem*) c_pData;
  3153. LPCHARACTER to_ch = CHARACTER_MANAGER::instance().Find(p->dwTargetVID);
  3155. if (to_ch)
  3156. ch->GiveItem(to_ch, p->ItemPos);
  3157. else
  3158. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템을 건네줄 수 없습니다."));
  3159. }
  3161. void CInputMain::Hack(LPCHARACTER ch, const char * c_pData)
  3162. {
  3163. TPacketCGHack * p = (TPacketCGHack *) c_pData;
  3165. char buf[sizeof(p->szBuf)];
  3166. strlcpy(buf, p->szBuf, sizeof(buf));
  3168. sys_err("HACK_DETECT: %s %s", ch->GetName(), buf);
  3170. // 현재 클라이언트에서 이 패킷을 보내는 경우가 없으므로 무조건 끊도록 한다
  3171. ch->GetDesc()->SetPhase(PHASE_CLOSE);
  3172. }
  3174. int CInputMain::MyShop(LPCHARACTER ch, const char * c_pData, size_t uiBytes)
  3175. {
  3176. TPacketCGMyShop * p = (TPacketCGMyShop *) c_pData;
  3177. int iExtraLen = p->bCount * sizeof(TShopItemTable);
  3179. if (uiBytes < sizeof(TPacketCGMyShop) + iExtraLen)
  3180. return -1;
  3182. if (ch->GetGold() >= GOLD_MAX)
  3183. {
  3184. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소유 돈이 20억냥을 넘어 거래를 핼수가 없습니다."));
  3185. sys_log(0, "MyShop ==> OverFlow Gold id %u name %s ", ch->GetPlayerID(), ch->GetName());
  3186. return (iExtraLen);
  3187. }
  3189. if (ch->IsStun() || ch->IsDead())
  3190. return (iExtraLen);
  3192. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
  3193. if (ch->GetExchange() || ch->IsOpenSafebox() || ch->GetShopOwner() || ch->IsCubeOpen() || ch->GetOfflineShopOwner())
  3194. {
  3195. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("다른 거래중일경우 개인상점을 열수가 없습니다."));
  3196. return (iExtraLen);
  3197. }
  3198. #else
  3199. if (ch->GetExchange() || ch->IsOpenSafebox() || ch->GetShopOwner() || ch->IsCubeOpen())
  3200. {
  3201. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("다른 거래중일경우 개인상점을 열수가 없습니다."));
  3202. return (iExtraLen);
  3203. }
  3204. #endif
  3206. sys_log(0, "MyShop count %d", p->bCount);
  3207. ch->OpenMyShop(p->szSign, (TShopItemTable *) (c_pData + sizeof(TPacketCGMyShop)), p->bCount);
  3208. return (iExtraLen);
  3209. }
  3211. int CInputMain::MyOfflineShop(LPCHARACTER ch, const char * c_pData, size_t uiBytes)
  3212. {
  3213. TPacketCGMyOfflineShop * p = (TPacketCGMyOfflineShop *)c_pData;
  3214. #ifdef ENABLE_MAXIMUM_YANG_FOR_OFFLINE_SHOP
  3215. int iExtraLen = p->bCount * sizeof(TOfflineShopItemTable);
  3216. #else
  3217. int iExtraLen = p->bCount * sizeof(TShopItemTable);
  3218. #endif
  3220. if (uiBytes < sizeof(TPacketCGMyOfflineShop) + iExtraLen)
  3221. return -1;
  3223. if (ch->IsStun() || ch->IsDead())
  3224. return (iExtraLen);
  3226. if (ch->GetExchange() || ch->IsOpenSafebox() || ch->GetShopOwner() || ch->IsCubeOpen() || ch->GetOfflineShopOwner())
  3227. {
  3228. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("다른 거래중일경우 개인상점을 열수가 없습니다."));
  3229. return (iExtraLen);
  3230. }
  3232. sys_log(0, "MyOfflineShop count %d", p->bCount);
  3233. #ifdef ENABLE_MAXIMUM_YANG_FOR_OFFLINE_SHOP
  3234. ch->OpenMyOfflineShop(p->szSign, (TOfflineShopItemTable *)(c_pData + sizeof(TPacketCGMyOfflineShop)), p->bCount, p->bTime);
  3235. #else
  3236. ch->OpenMyOfflineShop(p->szSign, (TShopItemTable *)(c_pData + sizeof(TPacketCGMyOfflineShop)), p->bCount, p->bTime);
  3237. #endif
  3238. return (iExtraLen);
  3239. }
  3241. void CInputMain::Refine(LPCHARACTER ch, const char* c_pData)
  3242. {
  3243. const TPacketCGRefine* p = reinterpret_cast<const TPacketCGRefine*>(c_pData);
  3245. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
  3246. if (ch->GetExchange() || ch->IsOpenSafebox() || ch->GetShopOwner() || ch->GetMyShop() || ch->IsCubeOpen() || ch->GetOfflineShopOwner())
  3247. {
  3248. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("창고,거래창등이 열린 상태에서는 개량을 할수가 없습니다"));
  3249. ch->ClearRefineMode();
  3250. return;
  3251. }
  3252. #else
  3253. if (ch->GetExchange() || ch->IsOpenSafebox() || ch->GetShopOwner() || ch->GetMyShop() || ch->IsCubeOpen())
  3254. {
  3255. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("창고,거래창등이 열린 상태에서는 개량을 할수가 없습니다"));
  3256. ch->ClearRefineMode();
  3257. return;
  3258. }
  3259. #endif
  3261. if (p->type == 255)
  3262. {
  3263. // DoRefine Cancel
  3264. ch->ClearRefineMode();
  3265. return;
  3266. }
  3268. if (p->pos >= INVENTORY_MAX_NUM)
  3269. {
  3270. ch->ClearRefineMode();
  3271. return;
  3272. }
  3274. LPITEM item = ch->GetInventoryItem(p->pos);
  3276. if (!item)
  3277. {
  3278. ch->ClearRefineMode();
  3279. return;
  3280. }
  3282. #ifdef __SOULBINDING_SYSTEM__
  3283. if (item->IsBind() || item->IsUntilBind())
  3284. {
  3285. ch->ClearRefineMode();
  3286. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't refine this item because is binded!"));
  3287. return;
  3288. }
  3289. #endif
  3291. ch->SetRefineTime();
  3293. if (p->type == REFINE_TYPE_NORMAL)
  3294. {
  3295. sys_log (0, "refine_type_noraml");
  3296. ch->DoRefine(item);
  3297. }
  3298. else if (p->type == REFINE_TYPE_SCROLL || p->type == REFINE_TYPE_HYUNIRON || p->type == REFINE_TYPE_MUSIN || p->type == REFINE_TYPE_BDRAGON)
  3299. {
  3300. sys_log (0, "refine_type_scroll, ...");
  3301. ch->DoRefineWithScroll(item);
  3302. }
  3303. else if (p->type == REFINE_TYPE_MONEY_ONLY)
  3304. {
  3305. const LPITEM item = ch->GetInventoryItem(p->pos);
  3307. if (NULL != item)
  3308. {
  3309. if (500 <= item->GetRefineSet())
  3310. {
  3311. LogManager::instance().HackLog("DEVIL_TOWER_REFINE_HACK", ch);
  3312. }
  3313. else
  3314. {
  3315. if (ch->GetQuestFlag("deviltower_zone.can_refine"))
  3316. {
  3317. ch->DoRefine(item, true);
  3318. ch->SetQuestFlag("deviltower_zone.can_refine", 0);
  3319. }
  3320. else
  3321. {
  3322. ch->ChatPacket(CHAT_TYPE_INFO, "사귀 타워 완료 보상은 한번까지 사용가능합니다.");
  3323. }
  3324. }
  3325. }
  3326. }
  3328. ch->ClearRefineMode();
  3329. }
  3331. #ifdef __SASH_SYSTEM__
  3332. void CInputMain::Sash(LPCHARACTER pkChar, const char* c_pData)
  3333. {
  3334. quest::PC * pPC = quest::CQuestManager::instance().GetPCForce(pkChar->GetPlayerID());
  3335. if (pPC->IsRunning())
  3336. return;
  3338. TPacketSash * sPacket = (TPacketSash*) c_pData;
  3339. switch (sPacket->subheader)
  3340. {
  3341. case SASH_SUBHEADER_CG_CLOSE:
  3342. {
  3343. pkChar->CloseSash();
  3344. }
  3345. break;
  3346. case SASH_SUBHEADER_CG_ADD:
  3347. {
  3348. pkChar->AddSashMaterial(sPacket->tPos, sPacket->bPos);
  3349. }
  3350. break;
  3351. case SASH_SUBHEADER_CG_REMOVE:
  3352. {
  3353. pkChar->RemoveSashMaterial(sPacket->bPos);
  3354. }
  3355. break;
  3356. case SASH_SUBHEADER_CG_REFINE:
  3357. {
  3358. pkChar->RefineSashMaterials();
  3359. }
  3360. break;
  3361. default:
  3362. break;
  3363. }
  3364. }
  3365. #endif
  3367. #ifdef __CHANGELOOK_SYSTEM__
  3368. void CInputMain::ChangeLook(LPCHARACTER pkChar, const char* c_pData)
  3369. {
  3370. quest::PC * pPC = quest::CQuestManager::instance().GetPCForce(pkChar->GetPlayerID());
  3371. if (pPC->IsRunning())
  3372. return;
  3374. TPacketChangeLook * sPacket = (TPacketChangeLook*) c_pData;
  3375. switch (sPacket->subheader)
  3376. {
  3377. case CL_SUBHEADER_CLOSE:
  3378. {
  3379. pkChar->ChangeLookWindow(false);
  3380. }
  3381. break;
  3382. case CL_SUBHEADER_ADD:
  3383. {
  3384. pkChar->AddClMaterial(sPacket->tPos, sPacket->bPos);
  3385. }
  3386. break;
  3387. case CL_SUBHEADER_REMOVE:
  3388. {
  3389. pkChar->RemoveClMaterial(sPacket->bPos);
  3390. }
  3391. break;
  3392. case CL_SUBHEADER_REFINE:
  3393. {
  3394. pkChar->RefineClMaterials();
  3395. }
  3396. break;
  3397. default:
  3398. break;
  3399. }
  3400. }
  3401. #endif
  3403. int CInputMain::Analyze(LPDESC d, BYTE bHeader, const char * c_pData)
  3404. {
  3405. LPCHARACTER ch;
  3407. if (!(ch = d->GetCharacter()))
  3408. {
  3409. sys_err("no character on desc");
  3410. d->SetPhase(PHASE_CLOSE);
  3411. return (0);
  3412. }
  3414. int iExtraLen = 0;
  3416. if (test_server && bHeader != HEADER_CG_MOVE)
  3417. sys_log(0, "CInputMain::Analyze() ==> Header [%d] ", bHeader);
  3419. switch (bHeader)
  3420. {
  3421. case HEADER_CG_PONG:
  3422. Pong(d);
  3423. break;
  3425. case HEADER_CG_TIME_SYNC:
  3426. Handshake(d, c_pData);
  3427. break;
  3429. case HEADER_CG_CHAT:
  3430. if (test_server)
  3431. {
  3432. char* pBuf = (char*)c_pData;
  3433. sys_log(0, "%s", pBuf + sizeof(TPacketCGChat));
  3434. }
  3436. if ((iExtraLen = Chat(ch, c_pData, m_iBufferLeft)) < 0)
  3437. return -1;
  3438. break;
  3440. case HEADER_CG_WHISPER:
  3441. if ((iExtraLen = Whisper(ch, c_pData, m_iBufferLeft)) < 0)
  3442. return -1;
  3443. break;
  3445. case HEADER_CG_MOVE:
  3446. Move(ch, c_pData);
  3448. if (g_bCheckClientVersion)
  3449. {
  3450. if (0 != g_stClientVersion.compare(d->GetClientVersion())) // @fixme103 (version > date)
  3451. {
  3452. ch->ChatPacket(CHAT_TYPE_NOTICE, LC_TEXT("클라이언트 버전이 틀려 로그아웃 됩니다. 정상적으로 패치 후 접속하세요."));
  3453. d->DelayedDisconnect(0); // @fixme103 (10);
  3454. LogManager::instance().HackLog("VERSION_CONFLICT", d->GetAccountTable().login, ch->GetName(), d->GetHostName());
  3455. }
  3456. }
  3457. break;
  3459. case HEADER_CG_CHARACTER_POSITION:
  3460. Position(ch, c_pData);
  3461. break;
  3463. case HEADER_CG_ITEM_USE:
  3464. if (!ch->IsObserverMode())
  3465. ItemUse(ch, c_pData);
  3466. break;
  3468. case HEADER_CG_ITEM_DROP:
  3469. if (!ch->IsObserverMode())
  3470. {
  3471. ItemDrop(ch, c_pData);
  3472. }
  3473. break;
  3475. case HEADER_CG_ITEM_DROP2:
  3476. if (!ch->IsObserverMode())
  3477. ItemDrop2(ch, c_pData);
  3478. break;
  3480. #ifdef __DESTROYSELL_SYSTEM__
  3481. case HEADER_CG_ITEM_DESTROY:
  3482. if (!ch->IsObserverMode())
  3483. ItemDestroy(ch, c_pData);
  3484. break;
  3486. case HEADER_CG_ITEM_SELL:
  3487. if (!ch->IsObserverMode())
  3488. ItemSell(ch, c_pData);
  3489. break;
  3490. #endif
  3492. case HEADER_CG_ITEM_MOVE:
  3493. if (!ch->IsObserverMode())
  3494. ItemMove(ch, c_pData);
  3495. break;
  3497. case HEADER_CG_ITEM_PICKUP:
  3498. if (!ch->IsObserverMode())
  3499. ItemPickup(ch, c_pData);
  3500. break;
  3502. case HEADER_CG_ITEM_USE_TO_ITEM:
  3503. if (!ch->IsObserverMode())
  3504. ItemToItem(ch, c_pData);
  3505. break;
  3507. case HEADER_CG_ITEM_GIVE:
  3508. if (!ch->IsObserverMode())
  3509. ItemGive(ch, c_pData);
  3510. break;
  3512. case HEADER_CG_EXCHANGE:
  3513. if (!ch->IsObserverMode())
  3514. Exchange(ch, c_pData);
  3515. break;
  3517. case HEADER_CG_ATTACK:
  3518. case HEADER_CG_SHOOT:
  3519. if (!ch->IsObserverMode())
  3520. {
  3521. Attack(ch, bHeader, c_pData);
  3522. }
  3523. break;
  3525. case HEADER_CG_USE_SKILL:
  3526. if (!ch->IsObserverMode())
  3527. UseSkill(ch, c_pData);
  3528. break;
  3530. case HEADER_CG_QUICKSLOT_ADD:
  3531. QuickslotAdd(ch, c_pData);
  3532. break;
  3534. case HEADER_CG_QUICKSLOT_DEL:
  3535. QuickslotDelete(ch, c_pData);
  3536. break;
  3538. case HEADER_CG_QUICKSLOT_SWAP:
  3539. QuickslotSwap(ch, c_pData);
  3540. break;
  3542. case HEADER_CG_SHOP:
  3543. if ((iExtraLen = Shop(ch, c_pData, m_iBufferLeft)) < 0)
  3544. return -1;
  3545. break;
  3547. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
  3548. case HEADER_CG_OFFLINE_SHOP:
  3549. if ((iExtraLen = OfflineShop(ch, c_pData, m_iBufferLeft)) < 0)
  3550. return -1;
  3551. break;
  3552. #endif
  3554. case HEADER_CG_MESSENGER:
  3555. if ((iExtraLen = Messenger(ch, c_pData, m_iBufferLeft))<0)
  3556. return -1;
  3557. break;
  3559. case HEADER_CG_ON_CLICK:
  3560. OnClick(ch, c_pData);
  3561. break;
  3563. case HEADER_CG_SYNC_POSITION:
  3564. if ((iExtraLen = SyncPosition(ch, c_pData, m_iBufferLeft)) < 0)
  3565. return -1;
  3566. break;
  3568. case HEADER_CG_ADD_FLY_TARGETING:
  3569. case HEADER_CG_FLY_TARGETING:
  3570. FlyTarget(ch, c_pData, bHeader);
  3571. break;
  3573. case HEADER_CG_SCRIPT_BUTTON:
  3574. ScriptButton(ch, c_pData);
  3575. break;
  3577. // SCRIPT_SELECT_ITEM
  3578. case HEADER_CG_SCRIPT_SELECT_ITEM:
  3579. ScriptSelectItem(ch, c_pData);
  3580. break;
  3581. // END_OF_SCRIPT_SELECT_ITEM
  3583. case HEADER_CG_SCRIPT_ANSWER:
  3584. ScriptAnswer(ch, c_pData);
  3585. break;
  3587. case HEADER_CG_QUEST_INPUT_STRING:
  3588. QuestInputString(ch, c_pData);
  3589. break;
  3591. case HEADER_CG_QUEST_CONFIRM:
  3592. QuestConfirm(ch, c_pData);
  3593. break;
  3595. case HEADER_CG_TARGET:
  3596. Target(ch, c_pData);
  3597. break;
  3599. case HEADER_CG_WARP:
  3600. Warp(ch, c_pData);
  3601. break;
  3603. case HEADER_CG_SAFEBOX_CHECKIN:
  3604. SafeboxCheckin(ch, c_pData);
  3605. break;
  3607. case HEADER_CG_SAFEBOX_CHECKOUT:
  3608. SafeboxCheckout(ch, c_pData, false);
  3609. break;
  3611. case HEADER_CG_SAFEBOX_ITEM_MOVE:
  3612. SafeboxItemMove(ch, c_pData);
  3613. break;
  3615. case HEADER_CG_MALL_CHECKOUT:
  3616. SafeboxCheckout(ch, c_pData, true);
  3617. break;
  3619. case HEADER_CG_PARTY_INVITE:
  3620. PartyInvite(ch, c_pData);
  3621. break;
  3623. case HEADER_CG_PARTY_REMOVE:
  3624. PartyRemove(ch, c_pData);
  3625. break;
  3627. case HEADER_CG_PARTY_INVITE_ANSWER:
  3628. PartyInviteAnswer(ch, c_pData);
  3629. break;
  3631. case HEADER_CG_PARTY_SET_STATE:
  3632. PartySetState(ch, c_pData);
  3633. break;
  3635. case HEADER_CG_PARTY_USE_SKILL:
  3636. PartyUseSkill(ch, c_pData);
  3637. break;
  3639. case HEADER_CG_PARTY_PARAMETER:
  3640. PartyParameter(ch, c_pData);
  3641. break;
  3643. case HEADER_CG_ANSWER_MAKE_GUILD:
  3644. AnswerMakeGuild(ch, c_pData);
  3645. break;
  3647. case HEADER_CG_GUILD:
  3648. if ((iExtraLen = Guild(ch, c_pData, m_iBufferLeft)) < 0)
  3649. return -1;
  3650. break;
  3652. case HEADER_CG_FISHING:
  3653. Fishing(ch, c_pData);
  3654. break;
  3656. case HEADER_CG_HACK:
  3657. Hack(ch, c_pData);
  3658. break;
  3660. case HEADER_CG_MYSHOP:
  3661. if ((iExtraLen = MyShop(ch, c_pData, m_iBufferLeft)) < 0)
  3662. return -1;
  3663. break;
  3665. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
  3666. case HEADER_CG_MY_OFFLINE_SHOP:
  3667. if ((iExtraLen = MyOfflineShop(ch, c_pData, m_iBufferLeft)) < 0)
  3668. return -1;
  3669. break;
  3670. #endif
  3672. case HEADER_CG_REFINE:
  3673. Refine(ch, c_pData);
  3674. break;
  3676. #ifdef __SASH_SYSTEM__
  3677. case HEADER_CG_SASH:
  3678. {
  3679. Sash(ch, c_pData);
  3680. }
  3681. break;
  3682. #endif
  3684. #ifdef __CHANGELOOK_SYSTEM__
  3685. case HEADER_CG_CL:
  3686. {
  3687. ChangeLook(ch, c_pData);
  3688. }
  3689. break;
  3690. #endif
  3692. case HEADER_CG_CLIENT_VERSION:
  3693. Version(ch, c_pData);
  3694. break;
  3696. case HEADER_CG_HS_ACK:
  3697. if (isHackShieldEnable)
  3698. {
  3699. CHackShieldManager::instance().VerifyAck(d->GetCharacter(), c_pData);
  3700. }
  3701. break;
  3703. case HEADER_CG_XTRAP_ACK:
  3704. {
  3705. TPacketXTrapCSVerify* p = reinterpret_cast<TPacketXTrapCSVerify*>((void*)c_pData);
  3706. CXTrapManager::instance().Verify_CSStep3(d->GetCharacter(), p->bPacketData);
  3707. }
  3708. break;
  3709. #ifdef __SEND_TARGET_INFO__
  3710. case HEADER_CG_TARGET_INFO_LOAD:
  3711. {
  3712. TargetInfoLoad(ch, c_pData);
  3713. }
  3714. break;
  3715. #endif
  3716. case HEADER_CG_DRAGON_SOUL_REFINE:
  3717. {
  3718. TPacketCGDragonSoulRefine* p = reinterpret_cast <TPacketCGDragonSoulRefine*>((void*)c_pData);
  3719. switch(p->bSubType)
  3720. {
  3721. case DS_SUB_HEADER_CLOSE:
  3722. ch->DragonSoul_RefineWindow_Close();
  3723. break;
  3724. case DS_SUB_HEADER_DO_REFINE_GRADE:
  3725. {
  3726. DSManager::instance().DoRefineGrade(ch, p->ItemGrid);
  3727. }
  3728. break;
  3729. case DS_SUB_HEADER_DO_REFINE_STEP:
  3730. {
  3731. DSManager::instance().DoRefineStep(ch, p->ItemGrid);
  3732. }
  3733. break;
  3734. case DS_SUB_HEADER_DO_REFINE_STRENGTH:
  3735. {
  3736. DSManager::instance().DoRefineStrength(ch, p->ItemGrid);
  3737. }
  3738. break;
  3739. }
  3740. }
  3742. break;
  3743. }
  3744. return (iExtraLen);
  3745. }
  3747. int CInputDead::Analyze(LPDESC d, BYTE bHeader, const char * c_pData)
  3748. {
  3749. LPCHARACTER ch;
  3751. if (!(ch = d->GetCharacter()))
  3752. {
  3753. sys_err("no character on desc");
  3754. return 0;
  3755. }
  3757. int iExtraLen = 0;
  3759. switch (bHeader)
  3760. {
  3761. case HEADER_CG_PONG:
  3762. Pong(d);
  3763. break;
  3765. case HEADER_CG_TIME_SYNC:
  3766. Handshake(d, c_pData);
  3767. break;
  3769. case HEADER_CG_CHAT:
  3770. if ((iExtraLen = Chat(ch, c_pData, m_iBufferLeft)) < 0)
  3771. return -1;
  3773. break;
  3775. case HEADER_CG_WHISPER:
  3776. if ((iExtraLen = Whisper(ch, c_pData, m_iBufferLeft)) < 0)
  3777. return -1;
  3779. break;
  3781. case HEADER_CG_HACK:
  3782. Hack(ch, c_pData);
  3783. break;
  3785. default:
  3786. return (0);
  3787. }
  3789. return (iExtraLen);
  3790. }