1. #include "stdafx.h"
  3. #include <stack>
  5. #include "utils.h"
  6. #include "config.h"
  7. #include "char.h"
  8. #include "char_manager.h"
  9. #include "item_manager.h"
  10. #include "desc.h"
  11. #include "desc_client.h"
  12. #include "desc_manager.h"
  13. #include "packet.h"
  14. #include "affect.h"
  15. #include "skill.h"
  16. #include "start_position.h"
  17. #include "mob_manager.h"
  18. #include "db.h"
  19. #include "log.h"
  20. #include "vector.h"
  21. #include "buffer_manager.h"
  22. #include "questmanager.h"
  23. #include "fishing.h"
  24. #include "party.h"
  25. #include "dungeon.h"
  26. #include "refine.h"
  27. #include "unique_item.h"
  28. #include "war_map.h"
  29. #include "xmas_event.h"
  30. #include "marriage.h"
  31. #include "monarch.h"
  32. #include "polymorph.h"
  33. #include "blend_item.h"
  34. #include "castle.h"
  35. #include "BattleArena.h"
  36. #include "arena.h"
  37. #include "dev_log.h"
  38. #include "pcbang.h"
  39. #include "threeway_war.h"
  41. #include "safebox.h"
  42. #include "shop.h"
  44. #include "../../common/VnumHelper.h"
  45. #include "DragonSoul.h"
  46. #include "buff_on_attributes.h"
  47. #include "belt_inventory_helper.h"
  49. //auction_temp
  50. #ifdef __AUCTION__
  51. #include "auction_manager.h"
  52. #endif
  53. const int ITEM_BROKEN_METIN_VNUM = 28960;
  55. // CHANGE_ITEM_ATTRIBUTES
  56. const DWORD CHARACTER::msc_dwDefaultChangeItemAttrCycle = 10;
  57. const char CHARACTER::msc_szLastChangeItemAttrFlag[] = "Item.LastChangeItemAttr";
  58. const char CHARACTER::msc_szChangeItemAttrCycleFlag[] = "change_itemattr_cycle";
  59. // END_OF_CHANGE_ITEM_ATTRIBUTES
  60. const BYTE g_aBuffOnAttrPoints[] = { POINT_ENERGY, POINT_COSTUME_ATTR_BONUS };
  62. struct FFindStone
  63. {
  64. std::map<DWORD, LPCHARACTER> m_mapStone;
  66. void operator()(LPENTITY pEnt)
  67. {
  68. if (pEnt->IsType(ENTITY_CHARACTER) == true)
  69. {
  70. LPCHARACTER pChar = (LPCHARACTER)pEnt;
  72. if (pChar->IsStone() == true)
  73. {
  74. m_mapStone[(DWORD)pChar->GetVID()] = pChar;
  75. }
  76. }
  77. }
  78. };
  81. //귀환부, 귀환기억부, 결혼반지
  82. static bool IS_SUMMON_ITEM(int vnum)
  83. {
  84. switch (vnum)
  85. {
  86. case 22000:
  87. case 22010:
  88. case 22011:
  89. case 22020:
  90. case ITEM_MARRIAGE_RING:
  91. return true;
  92. }
  94. return false;
  95. }
  97. static bool IS_MONKEY_DUNGEON(int map_index)
  98. {
  99. switch (map_index)
  100. {
  101. case 5:
  102. case 25:
  103. case 45:
  104. case 108:
  105. case 109:
  106. return true;;
  107. }
  109. return false;
  110. }
  112. bool IS_SUMMONABLE_ZONE(int map_index)
  113. {
  114. // 몽키던전
  115. if (IS_MONKEY_DUNGEON(map_index))
  116. return false;
  117. // 성
  118. if (IS_CASTLE_MAP(map_index))
  119. return false;
  121. switch (map_index)
  122. {
  123. case 66 : // 사귀타워
  124. case 71 : // 거미 던전 2층
  125. case 72 : // 천의 동굴
  126. case 73 : // 천의 동굴 2층
  127. case 193 : // 거미 던전 2-1층
  128. #if 0
  129. case 184 : // 천의 동굴(신수)
  130. case 185 : // 천의 동굴 2층(신수)
  131. case 186 : // 천의 동굴(천조)
  132. case 187 : // 천의 동굴 2층(천조)
  133. case 188 : // 천의 동굴(진노)
  134. case 189 : // 천의 동굴 2층(진노)
  135. #endif
  136. // case 206 : // 아귀동굴
  137. case 216 : // 아귀동굴
  138. case 217 : // 거미 던전 3층
  139. case 208 : // 천의 동굴 (용방)
  140. return false;
  141. }
  143. if (CBattleArena::IsBattleArenaMap(map_index)) return false;
  145. // 모든 private 맵으론 워프 불가능
  146. if (map_index > 10000) return false;
  148. return true;
  149. }
  151. bool IS_BOTARYABLE_ZONE(int nMapIndex)
  152. {
  153. if (LC_IsYMIR() == false && LC_IsKorea() == false) return true;
  155. switch (nMapIndex)
  156. {
  157. case 1 :
  158. case 3 :
  159. case 21 :
  160. case 23 :
  161. case 41 :
  162. case 43 :
  163. return true;
  164. }
  166. return false;
  167. }
  169. // item socket 이 프로토타입과 같은지 체크 -- by mhh
  170. static bool FN_check_item_socket(LPITEM item)
  171. {
  172. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  173. {
  174. if (item->GetSocket(i) != item->GetProto()->alSockets[i])
  175. return false;
  176. }
  178. return true;
  179. }
  181. // item socket 복사 -- by mhh
  182. static void FN_copy_item_socket(LPITEM dest, LPITEM src)
  183. {
  184. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  185. {
  186. dest->SetSocket(i, src->GetSocket(i));
  187. }
  188. }
  189. static bool FN_check_item_sex(LPCHARACTER ch, LPITEM item)
  190. {
  191. // 남자 금지
  192. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_MALE))
  193. {
  194. if (SEX_MALE==GET_SEX(ch))
  195. return false;
  196. }
  197. // 여자금지
  198. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_FEMALE))
  199. {
  200. if (SEX_FEMALE==GET_SEX(ch))
  201. return false;
  202. }
  204. return true;
  205. }
  208. /////////////////////////////////////////////////////////////////////////////
  209. // ITEM HANDLING
  210. /////////////////////////////////////////////////////////////////////////////
  211. bool CHARACTER::CanHandleItem(bool bSkipCheckRefine, bool bSkipObserver)
  212. {
  213. if (!bSkipObserver)
  214. if (m_bIsObserver)
  215. return false;
  217. if (GetMyShop())
  218. return false;
  220. if (!bSkipCheckRefine)
  221. if (m_bUnderRefine)
  222. return false;
  224. if (IsAcceOpen() || IsCubeOpen() || NULL != DragonSoul_RefineWindow_GetOpener())
  225. return false;
  227. if (IsWarping())
  228. return false;
  230. return true;
  231. }
  233. LPITEM CHARACTER::GetInventoryItem(WORD wCell) const
  234. {
  235. return GetItem(TItemPos(INVENTORY, wCell));
  236. }
  237. LPITEM CHARACTER::GetItem(TItemPos Cell) const
  238. {
  239. if (!IsValidItemPosition(Cell))
  240. return NULL;
  241. WORD wCell = Cell.cell;
  242. BYTE window_type = Cell.window_type;
  243. switch (window_type)
  244. {
  245. case INVENTORY:
  246. case EQUIPMENT:
  247. if (wCell >= INVENTORY_AND_EQUIP_SLOT_MAX)
  248. {
  249. sys_err("CHARACTER::GetInventoryItem: invalid item cell %d", wCell);
  250. return NULL;
  251. }
  252. return m_pointsInstant.pItems[wCell];
  253. case DRAGON_SOUL_INVENTORY:
  254. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  255. {
  256. sys_err("CHARACTER::GetInventoryItem: invalid DS item cell %d", wCell);
  257. return NULL;
  258. }
  259. return m_pointsInstant.pDSItems[wCell];
  261. default:
  262. return NULL;
  263. }
  264. return NULL;
  265. }
  267. void CHARACTER::SetItem(TItemPos Cell, LPITEM pItem, bool bWereMine)
  268. {
  269. WORD wCell = Cell.cell;
  270. BYTE window_type = Cell.window_type;
  271. if ((unsigned long)((CItem*)pItem) == 0xff || (unsigned long)((CItem*)pItem) == 0xffffffff)
  272. {
  273. sys_err("!!! FATAL ERROR !!! item == 0xff (char: %s cell: %u)", GetName(), wCell);
  274. core_dump();
  275. return;
  276. }
  278. if (pItem && pItem->GetOwner())
  279. {
  280. assert(!"GetOwner exist");
  281. return;
  282. }
  283. // 기본 인벤토리
  284. switch(window_type)
  285. {
  286. case INVENTORY:
  287. case EQUIPMENT:
  288. {
  289. if (wCell >= INVENTORY_AND_EQUIP_SLOT_MAX)
  290. {
  291. sys_err("CHARACTER::SetItem: invalid item cell %d", wCell);
  292. return;
  293. }
  295. LPITEM pOld = m_pointsInstant.pItems[wCell];
  297. if (pOld)
  298. {
  299. if (wCell < INVENTORY_MAX_NUM)
  300. {
  301. for (int i = 0; i < pOld->GetSize(); ++i)
  302. {
  303. int p = wCell + (i * 5);
  305. if (p >= INVENTORY_MAX_NUM)
  306. continue;
  308. if (m_pointsInstant.pItems[p] && m_pointsInstant.pItems[p] != pOld)
  309. continue;
  311. m_pointsInstant.bItemGrid[p] = 0;
  312. }
  313. }
  314. else
  315. m_pointsInstant.bItemGrid[wCell] = 0;
  316. }
  318. if (pItem)
  319. {
  320. if (wCell < INVENTORY_MAX_NUM)
  321. {
  322. for (int i = 0; i < pItem->GetSize(); ++i)
  323. {
  324. int p = wCell + (i * 5);
  326. if (p >= INVENTORY_MAX_NUM)
  327. continue;
  329. // wCell + 1 로 하는 것은 빈곳을 체크할 때 같은
  330. // 아이템은 예외처리하기 위함
  331. m_pointsInstant.bItemGrid[p] = wCell + 1;
  332. }
  333. }
  334. else
  335. m_pointsInstant.bItemGrid[wCell] = wCell + 1;
  336. }
  338. m_pointsInstant.pItems[wCell] = pItem;
  339. }
  340. break;
  341. // 용혼석 인벤토리
  342. case DRAGON_SOUL_INVENTORY:
  343. {
  344. LPITEM pOld = m_pointsInstant.pDSItems[wCell];
  346. if (pOld)
  347. {
  348. if (wCell < DRAGON_SOUL_INVENTORY_MAX_NUM)
  349. {
  350. for (int i = 0; i < pOld->GetSize(); ++i)
  351. {
  352. int p = wCell + (i * DRAGON_SOUL_BOX_COLUMN_NUM);
  354. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  355. continue;
  357. if (m_pointsInstant.pDSItems[p] && m_pointsInstant.pDSItems[p] != pOld)
  358. continue;
  360. m_pointsInstant.wDSItemGrid[p] = 0;
  361. }
  362. }
  363. else
  364. m_pointsInstant.wDSItemGrid[wCell] = 0;
  365. }
  367. if (pItem)
  368. {
  369. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  370. {
  371. sys_err("CHARACTER::SetItem: invalid DS item cell %d", wCell);
  372. return;
  373. }
  375. if (wCell < DRAGON_SOUL_INVENTORY_MAX_NUM)
  376. {
  377. for (int i = 0; i < pItem->GetSize(); ++i)
  378. {
  379. int p = wCell + (i * DRAGON_SOUL_BOX_COLUMN_NUM);
  381. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  382. continue;
  384. // wCell + 1 로 하는 것은 빈곳을 체크할 때 같은
  385. // 아이템은 예외처리하기 위함
  386. m_pointsInstant.wDSItemGrid[p] = wCell + 1;
  387. }
  388. }
  389. else
  390. m_pointsInstant.wDSItemGrid[wCell] = wCell + 1;
  391. }
  393. m_pointsInstant.pDSItems[wCell] = pItem;
  394. }
  395. break;
  396. default:
  397. sys_err ("Invalid Inventory type %d", window_type);
  398. return;
  399. }
  401. if (GetDesc())
  402. {
  403. // 확장 아이템: 서버에서 아이템 플래그 정보를 보낸다
  404. if (pItem)
  405. {
  406. TPacketGCItemSet pack;
  407. pack.header = HEADER_GC_ITEM_SET;
  408. pack.Cell = Cell;
  410. pack.count = pItem->GetCount();
  411. pack.vnum = pItem->GetVnum();
  412. pack.flags = pItem->GetFlag();
  413. pack.anti_flags = pItem->GetAntiFlag();
  414. pack.highlight = !bWereMine || (Cell.window_type == DRAGON_SOUL_INVENTORY);
  417. thecore_memcpy(pack.alSockets, pItem->GetSockets(), sizeof(pack.alSockets));
  418. thecore_memcpy(pack.aAttr, pItem->GetAttributes(), sizeof(pack.aAttr));
  420. GetDesc()->Packet(&pack, sizeof(TPacketGCItemSet));
  421. }
  422. else
  423. {
  424. TPacketGCItemDelDeprecated pack;
  425. pack.header = HEADER_GC_ITEM_DEL;
  426. pack.Cell = Cell;
  427. pack.count = 0;
  428. pack.vnum = 0;
  429. memset(pack.alSockets, 0, sizeof(pack.alSockets));
  430. memset(pack.aAttr, 0, sizeof(pack.aAttr));
  432. GetDesc()->Packet(&pack, sizeof(TPacketGCItemDelDeprecated));
  433. }
  434. }
  436. if (pItem)
  437. {
  438. pItem->SetCell(this, wCell);
  439. switch (window_type)
  440. {
  441. case INVENTORY:
  442. case EQUIPMENT:
  443. if ((wCell < INVENTORY_MAX_NUM) || (BELT_INVENTORY_SLOT_START <= wCell && BELT_INVENTORY_SLOT_END > wCell))
  444. pItem->SetWindow(INVENTORY);
  445. else
  446. pItem->SetWindow(EQUIPMENT);
  447. break;
  448. case DRAGON_SOUL_INVENTORY:
  449. pItem->SetWindow(DRAGON_SOUL_INVENTORY);
  450. break;
  451. }
  452. }
  453. }
  455. LPITEM CHARACTER::GetWear(BYTE bCell) const
  456. {
  457. // > WEAR_MAX_NUM : 용혼석 슬롯들.
  458. if (bCell >= WEAR_MAX_NUM + DRAGON_SOUL_DECK_MAX_NUM * DS_SLOT_MAX)
  459. {
  460. sys_err("CHARACTER::GetWear: invalid wear cell %d", bCell);
  461. return NULL;
  462. }
  464. return m_pointsInstant.pItems[INVENTORY_MAX_NUM + bCell];
  465. }
  467. void CHARACTER::SetWear(BYTE bCell, LPITEM item)
  468. {
  469. // > WEAR_MAX_NUM : 용혼석 슬롯들.
  470. if (bCell >= WEAR_MAX_NUM + DRAGON_SOUL_DECK_MAX_NUM * DS_SLOT_MAX)
  471. {
  472. sys_err("CHARACTER::SetItem: invalid item cell %d", bCell);
  473. return;
  474. }
  476. SetItem(TItemPos (INVENTORY, INVENTORY_MAX_NUM + bCell), item);
  478. if (!item && bCell == WEAR_WEAPON)
  479. {
  480. // 귀검 사용 시 벗는 것이라면 효과를 없애야 한다.
  481. if (IsAffectFlag(AFF_GWIGUM))
  482. RemoveAffect(SKILL_GWIGEOM);
  484. if (IsAffectFlag(AFF_GEOMGYEONG))
  485. RemoveAffect(SKILL_GEOMKYUNG);
  486. }
  487. }
  489. void CHARACTER::ClearItem()
  490. {
  491. int i;
  492. LPITEM item;
  494. for (i = 0; i < INVENTORY_AND_EQUIP_SLOT_MAX; ++i)
  495. {
  496. if ((item = GetInventoryItem(i)))
  497. {
  498. item->SetSkipSave(true);
  499. ITEM_MANAGER::instance().FlushDelayedSave(item);
  501. item->RemoveFromCharacter();
  502. M2_DESTROY_ITEM(item);
  504. SyncQuickslot(QUICKSLOT_TYPE_ITEM, i, 255);
  505. }
  506. }
  507. for (i = 0; i < DRAGON_SOUL_INVENTORY_MAX_NUM; ++i)
  508. {
  509. if ((item = GetItem(TItemPos(DRAGON_SOUL_INVENTORY, i))))
  510. {
  511. item->SetSkipSave(true);
  512. ITEM_MANAGER::instance().FlushDelayedSave(item);
  514. item->RemoveFromCharacter();
  515. M2_DESTROY_ITEM(item);
  516. }
  517. }
  518. }
  520. bool CHARACTER::IsEmptyItemGrid(TItemPos Cell, BYTE bSize, int iExceptionCell) const
  521. {
  522. #ifdef NEW_ADD_INVENTORY
  523. int malibuclub2 = (90 + (5*Black_Envanter()));
  524. switch (Cell.window_type)
  525. {
  526. case INVENTORY:
  527. {
  528. BYTE bCell = Cell.cell;
  530. // bItemCell은 0이 false임을 나타내기 위해 + 1 해서 처리한다.
  531. // 따라서 iExceptionCell에 1을 더해 비교한다.
  532. ++iExceptionCell;
  534. if (Cell.IsBeltInventoryPosition())
  535. {
  536. LPITEM beltItem = GetWear(WEAR_BELT);
  538. if (NULL == beltItem)
  539. return false;
  541. if (false == CBeltInventoryHelper::IsAvailableCell(bCell - BELT_INVENTORY_SLOT_START, beltItem->GetValue(0)))
  542. return false;
  544. if (m_pointsInstant.bItemGrid[bCell])
  545. {
  546. if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell)
  547. return true;
  549. return false;
  550. }
  552. if (bSize == 1)
  553. return true;
  555. }
  556. //black
  557. else if (bCell >= malibuclub2)
  558. return false;
  560. if (m_pointsInstant.bItemGrid[bCell])
  561. {
  562. if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell)
  563. {
  564. if (bSize == 1)
  565. return true;
  567. int j = 1;
  568. BYTE bPage = bCell / (INVENTORY_MAX_NUM / 4);
  569. do
  570. {
  571. BYTE p = bCell + (5 * j);
  573. if (p >= malibuclub2)
  574. return false;
  576. if (p / (INVENTORY_MAX_NUM / 4) != bPage)
  577. return false;
  579. if (m_pointsInstant.bItemGrid[p])
  580. if (m_pointsInstant.bItemGrid[p] != iExceptionCell)
  581. return false;
  582. }
  583. while (++j < bSize);
  585. return true;
  586. }
  587. else
  588. return false;
  589. }
  591. // 크기가 1이면 한칸을 차지하는 것이므로 그냥 리턴
  592. if (1 == bSize)
  593. return true;
  594. else
  595. {
  596. int j = 1;
  597. BYTE bPage = bCell / (INVENTORY_MAX_NUM / 4);
  599. do
  600. {
  601. BYTE p = bCell + (5 * j);
  603. if (p >= malibuclub2)
  604. return false;
  605. if (p / (INVENTORY_MAX_NUM / 4) != bPage)
  606. return false;
  608. if (m_pointsInstant.bItemGrid[p])
  609. if (m_pointsInstant.bItemGrid[p] != iExceptionCell)
  610. return false;
  611. }
  612. while (++j < bSize);
  614. return true;
  615. }
  616. }
  617. break;
  618. #else
  619. switch (Cell.window_type)
  620. {
  621. case INVENTORY:
  622. {
  623. BYTE bCell = Cell.cell;
  625. // bItemCell은 0이 false임을 나타내기 위해 + 1 해서 처리한다.
  626. // 따라서 iExceptionCell에 1을 더해 비교한다.
  627. ++iExceptionCell;
  629. if (Cell.IsBeltInventoryPosition())
  630. {
  631. LPITEM beltItem = GetWear(WEAR_BELT);
  633. if (NULL == beltItem)
  634. return false;
  636. if (false == CBeltInventoryHelper::IsAvailableCell(bCell - BELT_INVENTORY_SLOT_START, beltItem->GetValue(0)))
  637. return false;
  639. if (m_pointsInstant.bItemGrid[bCell])
  640. {
  641. if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell)
  642. return true;
  644. return false;
  645. }
  647. if (bSize == 1)
  648. return true;
  650. }
  651. //black
  652. else if (bCell >= INVENTORY_MAX_NUM)
  653. return false;
  655. if (m_pointsInstant.bItemGrid[bCell])
  656. {
  657. if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell)
  658. {
  659. if (bSize == 1)
  660. return true;
  662. int j = 1;
  663. BYTE bPage = bCell / (INVENTORY_MAX_NUM / 4);
  665. do
  666. {
  667. BYTE p = bCell + (5 * j);
  669. if (p >= INVENTORY_MAX_NUM)
  670. return false;
  672. if (p / (INVENTORY_MAX_NUM / 4) != bPage)
  673. return false;
  675. if (m_pointsInstant.bItemGrid[p])
  676. if (m_pointsInstant.bItemGrid[p] != iExceptionCell)
  677. return false;
  678. }
  679. while (++j < bSize);
  681. return true;
  682. }
  683. else
  684. return false;
  685. }
  687. // 크기가 1이면 한칸을 차지하는 것이므로 그냥 리턴
  688. if (1 == bSize)
  689. return true;
  690. else
  691. {
  692. int j = 1;
  693. BYTE bPage = bCell / (INVENTORY_MAX_NUM / 4);
  695. do
  696. {
  697. BYTE p = bCell + (5 * j);
  699. if (p >= INVENTORY_MAX_NUM)
  700. return false;
  701. if (p / (INVENTORY_MAX_NUM / 4) != bPage)
  702. return false;
  704. if (m_pointsInstant.bItemGrid[p])
  705. if (m_pointsInstant.bItemGrid[p] != iExceptionCell)
  706. return false;
  707. }
  708. while (++j < bSize);
  710. return true;
  711. }
  712. }
  713. break;
  714. #endif
  715. case DRAGON_SOUL_INVENTORY:
  716. {
  717. WORD wCell = Cell.cell;
  718. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  719. return false;
  721. // bItemCell은 0이 false임을 나타내기 위해 + 1 해서 처리한다.
  722. // 따라서 iExceptionCell에 1을 더해 비교한다.
  723. iExceptionCell++;
  725. if (m_pointsInstant.wDSItemGrid[wCell])
  726. {
  727. if (m_pointsInstant.wDSItemGrid[wCell] == iExceptionCell)
  728. {
  729. if (bSize == 1)
  730. return true;
  732. int j = 1;
  734. do
  735. {
  736. BYTE p = wCell + (DRAGON_SOUL_BOX_COLUMN_NUM * j);
  738. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  739. return false;
  741. if (m_pointsInstant.wDSItemGrid[p])
  742. if (m_pointsInstant.wDSItemGrid[p] != iExceptionCell)
  743. return false;
  744. }
  745. while (++j < bSize);
  747. return true;
  748. }
  749. else
  750. return false;
  751. }
  753. // 크기가 1이면 한칸을 차지하는 것이므로 그냥 리턴
  754. if (1 == bSize)
  755. return true;
  756. else
  757. {
  758. int j = 1;
  760. do
  761. {
  762. BYTE p = wCell + (DRAGON_SOUL_BOX_COLUMN_NUM * j);
  764. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  765. return false;
  767. if (m_pointsInstant.bItemGrid[p])
  768. if (m_pointsInstant.wDSItemGrid[p] != iExceptionCell)
  769. return false;
  770. }
  771. while (++j < bSize);
  773. return true;
  774. }
  775. }
  776. }
  777. }
  779. #ifdef NEW_ADD_INVENTORY
  780. int CHARACTER::GetEmptyInventory(BYTE size) const
  781. {
  782. // NOTE: 현재 이 함수는 아이템 지급, 획득 등의 행위를 할 때 인벤토리의 빈 칸을 찾기 위해 사용되고 있는데,
  783. // 벨트 인벤토리는 특수 인벤토리이므로 검사하지 않도록 한다. (기본 인벤토리: INVENTORY_MAX_NUM 까지만 검사)
  784. // int malibuclub = INVENTORY_MAX_NUM;
  785. //45 first page
  786. //90 second page
  787. int malibuclub = 90 + (5*Black_Envanter());
  788. for ( int i = 0; i < malibuclub; ++i)
  789. if (IsEmptyItemGrid(TItemPos (INVENTORY, i), size))
  790. return i;
  791. return -1;
  792. }
  793. #else
  794. int CHARACTER::GetEmptyInventory(BYTE size) const
  795. {
  796. // NOTE: 현재 이 함수는 아이템 지급, 획득 등의 행위를 할 때 인벤토리의 빈 칸을 찾기 위해 사용되고 있는데,
  797. // 벨트 인벤토리는 특수 인벤토리이므로 검사하지 않도록 한다. (기본 인벤토리: INVENTORY_MAX_NUM 까지만 검사)
  798. for ( int i = 0; i < INVENTORY_MAX_NUM; ++i)
  799. if (IsEmptyItemGrid(TItemPos (INVENTORY, i), size))
  800. return i;
  801. return -1;
  802. }
  803. #endif
  806. int CHARACTER::GetEmptyDragonSoulInventory(LPITEM pItem) const
  807. {
  808. if (NULL == pItem || !pItem->IsDragonSoul())
  809. return -1;
  810. if (!DragonSoul_IsQualified())
  811. {
  812. return -1;
  813. }
  814. BYTE bSize = pItem->GetSize();
  815. WORD wBaseCell = DSManager::instance().GetBasePosition(pItem);
  817. if (WORD_MAX == wBaseCell)
  818. return -1;
  820. for (int i = 0; i < DRAGON_SOUL_BOX_SIZE; ++i)
  821. if (IsEmptyItemGrid(TItemPos(DRAGON_SOUL_INVENTORY, i + wBaseCell), bSize))
  822. return i + wBaseCell;
  824. return -1;
  825. }
  827. void CHARACTER::CopyDragonSoulItemGrid(std::vector<WORD>& vDragonSoulItemGrid) const
  828. {
  829. vDragonSoulItemGrid.resize(DRAGON_SOUL_INVENTORY_MAX_NUM);
  831. std::copy(m_pointsInstant.wDSItemGrid, m_pointsInstant.wDSItemGrid + DRAGON_SOUL_INVENTORY_MAX_NUM, vDragonSoulItemGrid.begin());
  832. }
  834. int CHARACTER::CountEmptyInventory() const
  835. {
  836. int count = 0;
  838. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  839. if (GetInventoryItem(i))
  840. count += GetInventoryItem(i)->GetSize();
  842. return (INVENTORY_MAX_NUM - count);
  843. }
  845. void TransformRefineItem(LPITEM pkOldItem, LPITEM pkNewItem)
  846. {
  847. // ACCESSORY_REFINE
  848. if (pkOldItem->IsAccessoryForSocket())
  849. {
  850. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  851. {
  852. pkNewItem->SetSocket(i, pkOldItem->GetSocket(i));
  853. }
  854. //pkNewItem->StartAccessorySocketExpireEvent();
  855. }
  856. // END_OF_ACCESSORY_REFINE
  857. else
  858. {
  859. // 여기서 깨진석이 자동적으로 청소 됨
  860. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  861. {
  862. if (!pkOldItem->GetSocket(i))
  863. break;
  864. else
  865. pkNewItem->SetSocket(i, 1);
  866. }
  868. // 소켓 설정
  869. int slot = 0;
  871. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  872. {
  873. long socket = pkOldItem->GetSocket(i);
  875. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
  876. pkNewItem->SetSocket(slot++, socket);
  877. }
  879. }
  881. // 매직 아이템 설정
  882. pkOldItem->CopyAttributeTo(pkNewItem);
  883. }
  885. void NotifyRefineSuccess(LPCHARACTER ch, LPITEM item, const char* way)
  886. {
  887. if (NULL != ch && item != NULL)
  888. {
  889. ch->ChatPacket(CHAT_TYPE_COMMAND, "RefineSuceeded");
  891. LogManager::instance().RefineLog(ch->GetPlayerID(), item->GetName(), item->GetID(), item->GetRefineLevel(), 1, way);
  892. }
  893. }
  895. void NotifyRefineFail(LPCHARACTER ch, LPITEM item, const char* way, int success = 0)
  896. {
  897. if (NULL != ch && NULL != item)
  898. {
  899. ch->ChatPacket(CHAT_TYPE_COMMAND, "RefineFailed");
  901. LogManager::instance().RefineLog(ch->GetPlayerID(), item->GetName(), item->GetID(), item->GetRefineLevel(), success, way);
  902. }
  903. }
  905. void CHARACTER::SetRefineNPC(LPCHARACTER ch)
  906. {
  907. if ( ch != NULL )
  908. {
  909. m_dwRefineNPCVID = ch->GetVID();
  910. }
  911. else
  912. {
  913. m_dwRefineNPCVID = 0;
  914. }
  915. }
  917. bool CHARACTER::DoRefine(LPITEM item, bool bMoneyOnly)
  918. {
  919. if (!CanHandleItem(true))
  920. {
  921. ClearRefineMode();
  922. return false;
  923. }
  925. //개량 시간제한 : upgrade_refine_scroll.quest 에서 개량후 5분이내에 일반 개량을
  926. //진행할수 없음
  927. if (quest::CQuestManager::instance().GetEventFlag("update_refine_time") != 0)
  928. {
  929. if (get_global_time() < quest::CQuestManager::instance().GetEventFlag("update_refine_time") + (60 * 5))
  930. {
  931. sys_log(0, "can't refine %d %s", GetPlayerID(), GetName());
  932. return false;
  933. }
  934. }
  936. const TRefineTable * prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
  938. if (!prt)
  939. return false;
  941. DWORD result_vnum = item->GetRefinedVnum();
  943. // REFINE_COST
  944. int cost = ComputeRefineFee(prt->cost);
  946. int RefineChance = GetQuestFlag("main_quest_lv7.refine_chance");
  948. if (RefineChance > 0)
  949. {
  950. if (!item->CheckItemUseLevel(20) || item->GetType() != ITEM_WEAPON)
  951. {
  952. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무료 개량 기회는 20 이하의 무기만 가능합니다"));
  953. return false;
  954. }
  956. cost = 0;
  957. SetQuestFlag("main_quest_lv7.refine_chance", RefineChance - 1);
  958. }
  959. // END_OF_REFINE_COST
  961. if (result_vnum == 0)
  962. {
  963. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 개량할 수 없습니다."));
  964. return false;
  965. }
  967. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_TUNING)
  968. return false;
  970. TItemTable * pProto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
  972. if (!pProto)
  973. {
  974. sys_err("DoRefine NOT GET ITEM PROTO %d", item->GetRefinedVnum());
  975. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  976. return false;
  977. }
  979. // Check level limit in korea only
  980. if (!g_iUseLocale)
  981. {
  982. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  983. {
  984. long limit = pProto->aLimits[i].lValue;
  986. switch (pProto->aLimits[i].bType)
  987. {
  988. case LIMIT_LEVEL:
  989. if (GetLevel() < limit)
  990. {
  991. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량된 후 아이템의 레벨 제한보다 레벨이 낮습니다."));
  992. return false;
  993. }
  994. break;
  995. }
  996. }
  997. }
  999. // REFINE_COST
  1000. if (GetGold() < cost)
  1001. {
  1002. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 돈이 부족합니다."));
  1003. return false;
  1004. }
  1006. if (!bMoneyOnly && !RefineChance)
  1007. {
  1008. for (int i = 0; i < prt->material_count; ++i)
  1009. {
  1010. if (CountSpecifyItem(prt->materials[i].vnum) < prt->materials[i].count)
  1011. {
  1012. if (test_server)
  1013. {
  1014. ChatPacket(CHAT_TYPE_INFO, "Find %d, count %d, require %d", prt->materials[i].vnum, CountSpecifyItem(prt->materials[i].vnum), prt->materials[i].count);
  1015. }
  1016. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 재료가 부족합니다."));
  1017. return false;
  1018. }
  1019. }
  1021. for (int i = 0; i < prt->material_count; ++i)
  1022. RemoveSpecifyItem(prt->materials[i].vnum, prt->materials[i].count);
  1023. }
  1025. int prob = number(1, 100);
  1027. if (IsRefineThroughGuild() || bMoneyOnly)
  1028. prob -= 10;
  1030. // END_OF_REFINE_COST
  1032. if (prob <= prt->prob)
  1033. {
  1034. // 성공! 모든 아이템이 사라지고, 같은 속성의 다른 아이템 획득
  1035. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
  1037. if (pkNewItem)
  1038. {
  1039. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  1040. LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
  1042. BYTE bCell = item->GetCell();
  1044. // DETAIL_REFINE_LOG
  1045. NotifyRefineSuccess(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  1046. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -cost);
  1047. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
  1048. // END_OF_DETAIL_REFINE_LOG
  1050. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1051. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1053. sys_log(0, "Refine Success %d", cost);
  1054. pkNewItem->AttrLog();
  1055. //PointChange(POINT_GOLD, -cost);
  1056. sys_log(0, "PayPee %d", cost);
  1057. PayRefineFee(cost);
  1058. sys_log(0, "PayPee End %d", cost);
  1059. }
  1060. else
  1061. {
  1062. // DETAIL_REFINE_LOG
  1063. // 아이템 생성에 실패 -> 개량 실패로 간주
  1064. sys_err("cannot create item %u", result_vnum);
  1065. NotifyRefineFail(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  1066. // END_OF_DETAIL_REFINE_LOG
  1067. }
  1068. }
  1069. else
  1070. {
  1071. // 실패! 모든 아이템이 사라짐.
  1072. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -cost);
  1073. NotifyRefineFail(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  1074. item->AttrLog();
  1075. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
  1077. //PointChange(POINT_GOLD, -cost);
  1078. PayRefineFee(cost);
  1079. }
  1081. return true;
  1082. }
  1084. enum enum_RefineScrolls
  1085. {
  1086. CHUKBOK_SCROLL = 0,
  1087. HYUNIRON_CHN = 1, // 중국에서만 사용
  1088. YONGSIN_SCROLL = 2,
  1089. MUSIN_SCROLL = 3,
  1090. YAGONG_SCROLL = 4,
  1091. MEMO_SCROLL = 5,
  1092. BDRAGON_SCROLL = 6,
  1093. ACCE_CLEAN_ATTR = 7,
  1094. };
  1096. bool CHARACTER::DoRefineWithScroll(LPITEM item)
  1097. {
  1098. if (!CanHandleItem(true))
  1099. {
  1100. ClearRefineMode();
  1101. return false;
  1102. }
  1104. ClearRefineMode();
  1106. //개량 시간제한 : upgrade_refine_scroll.quest 에서 개량후 5분이내에 일반 개량을
  1107. //진행할수 없음
  1108. if (quest::CQuestManager::instance().GetEventFlag("update_refine_time") != 0)
  1109. {
  1110. if (get_global_time() < quest::CQuestManager::instance().GetEventFlag("update_refine_time") + (60 * 5))
  1111. {
  1112. sys_log(0, "can't refine %d %s", GetPlayerID(), GetName());
  1113. return false;
  1114. }
  1115. }
  1117. const TRefineTable * prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
  1119. if (!prt)
  1120. return false;
  1122. LPITEM pkItemScroll;
  1124. // 개량서 체크
  1125. if (m_iRefineAdditionalCell < 0)
  1126. return false;
  1128. pkItemScroll = GetInventoryItem(m_iRefineAdditionalCell);
  1130. if (!pkItemScroll)
  1131. return false;
  1133. if (!(pkItemScroll->GetType() == ITEM_USE && pkItemScroll->GetSubType() == USE_TUNING))
  1134. return false;
  1136. if (pkItemScroll->GetVnum() == item->GetVnum())
  1137. return false;
  1139. DWORD result_vnum = item->GetRefinedVnum();
  1140. DWORD result_fail_vnum = item->GetRefineFromVnum();
  1142. if (result_vnum == 0)
  1143. {
  1144. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 개량할 수 없습니다."));
  1145. return false;
  1146. }
  1148. // MUSIN_SCROLL
  1149. if (pkItemScroll->GetValue(0) == MUSIN_SCROLL)
  1150. {
  1151. if (item->GetRefineLevel() >= 4)
  1152. {
  1153. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 개량서로 더 이상 개량할 수 없습니다."));
  1154. return false;
  1155. }
  1156. }
  1157. // END_OF_MUSIC_SCROLL
  1159. else if (pkItemScroll->GetValue(0) == MEMO_SCROLL)
  1160. {
  1161. if (item->GetRefineLevel() != pkItemScroll->GetValue(1))
  1162. {
  1163. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 개량서로 개량할 수 없습니다."));
  1164. return false;
  1165. }
  1166. }
  1167. else if (pkItemScroll->GetValue(0) == BDRAGON_SCROLL)
  1168. {
  1169. if (item->GetType() != ITEM_METIN || item->GetRefineLevel() != 4)
  1170. {
  1171. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템으로 개량할 수 없습니다."));
  1172. return false;
  1173. }
  1174. }
  1176. TItemTable * pProto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
  1178. if (!pProto)
  1179. {
  1180. sys_err("DoRefineWithScroll NOT GET ITEM PROTO %d", item->GetRefinedVnum());
  1181. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  1182. return false;
  1183. }
  1185. // Check level limit in korea only
  1186. if (!g_iUseLocale)
  1187. {
  1188. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  1189. {
  1190. long limit = pProto->aLimits[i].lValue;
  1192. switch (pProto->aLimits[i].bType)
  1193. {
  1194. case LIMIT_LEVEL:
  1195. if (GetLevel() < limit)
  1196. {
  1197. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량된 후 아이템의 레벨 제한보다 레벨이 낮습니다."));
  1198. return false;
  1199. }
  1200. break;
  1201. }
  1202. }
  1203. }
  1205. if (GetGold() < prt->cost)
  1206. {
  1207. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 돈이 부족합니다."));
  1208. return false;
  1209. }
  1211. for (int i = 0; i < prt->material_count; ++i)
  1212. {
  1213. if (CountSpecifyItem(prt->materials[i].vnum) < prt->materials[i].count)
  1214. {
  1215. if (test_server)
  1216. {
  1217. ChatPacket(CHAT_TYPE_INFO, "Find %d, count %d, require %d", prt->materials[i].vnum, CountSpecifyItem(prt->materials[i].vnum), prt->materials[i].count);
  1218. }
  1219. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 재료가 부족합니다."));
  1220. return false;
  1221. }
  1222. }
  1224. for (int i = 0; i < prt->material_count; ++i)
  1225. RemoveSpecifyItem(prt->materials[i].vnum, prt->materials[i].count);
  1227. int prob = number(1, 100);
  1228. int success_prob = prt->prob;
  1229. bool bDestroyWhenFail = false;
  1231. const char* szRefineType = "SCROLL";
  1233. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN ||
  1234. pkItemScroll->GetValue(0) == YONGSIN_SCROLL ||
  1235. pkItemScroll->GetValue(0) == YAGONG_SCROLL) // 현철, 용신의 축복서, 야공의 비전서 처리
  1236. {
  1237. const char hyuniron_prob[9] = { 100, 75, 65, 55, 45, 40, 35, 25, 20 };
  1238. const char hyuniron_prob_euckr[9] = { 100, 75, 65, 55, 45, 40, 35, 30, 25 };
  1240. const char yagong_prob[9] = { 100, 100, 90, 80, 70, 60, 50, 30, 20 };
  1241. const char yagong_prob_euckr[9] = { 100, 100, 90, 80, 70, 60, 50, 40, 30 };
  1243. if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL)
  1244. {
  1245. if (LC_IsYMIR() == true || LC_IsKorea() == true)
  1246. success_prob = hyuniron_prob_euckr[MINMAX(0, item->GetRefineLevel(), 8)];
  1247. else
  1248. success_prob = hyuniron_prob[MINMAX(0, item->GetRefineLevel(), 8)];
  1249. }
  1250. else if (pkItemScroll->GetValue(0) == YAGONG_SCROLL)
  1251. {
  1252. if (LC_IsYMIR() == true || LC_IsKorea() == true)
  1253. success_prob = yagong_prob_euckr[MINMAX(0, item->GetRefineLevel(), 8)];
  1254. else
  1255. success_prob = yagong_prob[MINMAX(0, item->GetRefineLevel(), 8)];
  1256. }
  1257. else
  1258. {
  1259. sys_err("REFINE : Unknown refine scroll item. Value0: %d", pkItemScroll->GetValue(0));
  1260. }
  1262. if (test_server)
  1263. {
  1264. ChatPacket(CHAT_TYPE_INFO, "[Only Test] Success_Prob %d, RefineLevel %d ", success_prob, item->GetRefineLevel());
  1265. }
  1266. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN) // 현철은 아이템이 부서져야 한다.
  1267. bDestroyWhenFail = true;
  1269. // DETAIL_REFINE_LOG
  1270. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN)
  1271. {
  1272. szRefineType = "HYUNIRON";
  1273. }
  1274. else if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL)
  1275. {
  1276. szRefineType = "GOD_SCROLL";
  1277. }
  1278. else if (pkItemScroll->GetValue(0) == YAGONG_SCROLL)
  1279. {
  1280. szRefineType = "YAGONG_SCROLL";
  1281. }
  1282. // END_OF_DETAIL_REFINE_LOG
  1283. }
  1285. // DETAIL_REFINE_LOG
  1286. if (pkItemScroll->GetValue(0) == MUSIN_SCROLL) // 무신의 축복서는 100% 성공 (+4까지만)
  1287. {
  1288. success_prob = 100;
  1290. szRefineType = "MUSIN_SCROLL";
  1291. }
  1292. // END_OF_DETAIL_REFINE_LOG
  1293. else if (pkItemScroll->GetValue(0) == MEMO_SCROLL)
  1294. {
  1295. success_prob = 100;
  1296. szRefineType = "MEMO_SCROLL";
  1297. }
  1298. else if (pkItemScroll->GetValue(0) == BDRAGON_SCROLL)
  1299. {
  1300. success_prob = 80;
  1301. szRefineType = "BDRAGON_SCROLL";
  1302. }
  1304. pkItemScroll->SetCount(pkItemScroll->GetCount() - 1);
  1306. if (prob <= success_prob)
  1307. {
  1308. // 성공! 모든 아이템이 사라지고, 같은 속성의 다른 아이템 획득
  1309. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
  1311. if (pkNewItem)
  1312. {
  1313. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  1314. LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
  1316. BYTE bCell = item->GetCell();
  1318. NotifyRefineSuccess(this, item, szRefineType);
  1319. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -prt->cost);
  1320. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
  1322. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1323. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1324. pkNewItem->AttrLog();
  1325. //PointChange(POINT_GOLD, -prt->cost);
  1326. PayRefineFee(prt->cost);
  1327. }
  1328. else
  1329. {
  1330. // 아이템 생성에 실패 -> 개량 실패로 간주
  1331. sys_err("cannot create item %u", result_vnum);
  1332. NotifyRefineFail(this, item, szRefineType);
  1333. }
  1334. }
  1335. else if (!bDestroyWhenFail && result_fail_vnum)
  1336. {
  1337. // 실패! 모든 아이템이 사라지고, 같은 속성의 낮은 등급의 아이템 획득
  1338. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_fail_vnum, 1, 0, false);
  1340. if (pkNewItem)
  1341. {
  1342. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  1343. LogManager::instance().ItemLog(this, pkNewItem, "REFINE FAIL", pkNewItem->GetName());
  1345. BYTE bCell = item->GetCell();
  1347. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -prt->cost);
  1348. NotifyRefineFail(this, item, szRefineType, -1);
  1349. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
  1351. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1352. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1354. pkNewItem->AttrLog();
  1356. //PointChange(POINT_GOLD, -prt->cost);
  1357. PayRefineFee(prt->cost);
  1358. }
  1359. else
  1360. {
  1361. // 아이템 생성에 실패 -> 개량 실패로 간주
  1362. sys_err("cannot create item %u", result_fail_vnum);
  1363. NotifyRefineFail(this, item, szRefineType);
  1364. }
  1365. }
  1366. else
  1367. {
  1368. NotifyRefineFail(this, item, szRefineType); // 개량시 아이템 사라지지 않음
  1370. PayRefineFee(prt->cost);
  1371. }
  1373. return true;
  1374. }
  1376. bool CHARACTER::RefineInformation(BYTE bCell, BYTE bType, int iAdditionalCell)
  1377. {
  1378. if (bCell > INVENTORY_MAX_NUM)
  1379. return false;
  1381. LPITEM item = GetInventoryItem(bCell);
  1383. if (!item)
  1384. return false;
  1386. // REFINE_COST
  1387. if (bType == REFINE_TYPE_MONEY_ONLY && !GetQuestFlag("deviltower_zone.can_refine"))
  1388. {
  1389. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사귀 타워 완료 보상은 한번까지 사용가능합니다."));
  1390. return false;
  1391. }
  1392. // END_OF_REFINE_COST
  1394. TPacketGCRefineInformation p;
  1396. p.header = HEADER_GC_REFINE_INFORMATION;
  1397. p.pos = bCell;
  1398. p.src_vnum = item->GetVnum();
  1399. p.result_vnum = item->GetRefinedVnum();
  1400. p.type = bType;
  1402. if (p.result_vnum == 0)
  1403. {
  1404. sys_err("RefineInformation p.result_vnum == 0");
  1405. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  1406. return false;
  1407. }
  1409. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_TUNING)
  1410. {
  1411. if (bType == 0)
  1412. {
  1413. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 이 방식으로는 개량할 수 없습니다."));
  1414. return false;
  1415. }
  1416. else
  1417. {
  1418. LPITEM itemScroll = GetInventoryItem(iAdditionalCell);
  1419. if (!itemScroll || item->GetVnum() == itemScroll->GetVnum())
  1420. {
  1421. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("같은 개량서를 합칠 수는 없습니다."));
  1422. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("축복의 서와 현철을 합칠 수 있습니다."));
  1423. return false;
  1424. }
  1425. }
  1426. }
  1428. CRefineManager & rm = CRefineManager::instance();
  1430. const TRefineTable* prt = rm.GetRefineRecipe(item->GetRefineSet());
  1432. if (!prt)
  1433. {
  1434. sys_err("RefineInformation NOT GET REFINE SET %d", item->GetRefineSet());
  1435. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  1436. return false;
  1437. }
  1439. // REFINE_COST
  1441. //MAIN_QUEST_LV7
  1442. if (GetQuestFlag("main_quest_lv7.refine_chance") > 0)
  1443. {
  1444. // 일본은 제외
  1445. if (!item->CheckItemUseLevel(20) || item->GetType() != ITEM_WEAPON)
  1446. {
  1447. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무료 개량 기회는 20 이하의 무기만 가능합니다"));
  1448. return false;
  1449. }
  1450. p.cost = 0;
  1451. }
  1452. else
  1453. p.cost = ComputeRefineFee(prt->cost);
  1455. //END_MAIN_QUEST_LV7
  1456. p.prob = prt->prob;
  1457. if (bType == REFINE_TYPE_MONEY_ONLY)
  1458. {
  1459. p.material_count = 0;
  1460. memset(p.materials, 0, sizeof(p.materials));
  1461. }
  1462. else
  1463. {
  1464. p.material_count = prt->material_count;
  1465. thecore_memcpy(&p.materials, prt->materials, sizeof(prt->materials));
  1466. }
  1467. // END_OF_REFINE_COST
  1469. GetDesc()->Packet(&p, sizeof(TPacketGCRefineInformation));
  1471. SetRefineMode(iAdditionalCell);
  1472. return true;
  1473. }
  1475. bool CHARACTER::RefineItem(LPITEM pkItem, LPITEM pkTarget)
  1476. {
  1477. if (!CanHandleItem())
  1478. return false;
  1480. if (pkItem->GetSubType() == USE_TUNING)
  1481. {
  1482. // XXX 성능, 소켓 개량서는 사라졌습니다...
  1483. // XXX 성능개량서는 축복의 서가 되었다!
  1484. // MUSIN_SCROLL
  1485. if (pkItem->GetValue(0) == MUSIN_SCROLL)
  1486. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_MUSIN, pkItem->GetCell());
  1487. // END_OF_MUSIN_SCROLL
  1488. else if (pkItem->GetValue(0) == HYUNIRON_CHN)
  1489. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_HYUNIRON, pkItem->GetCell());
  1490. else if (pkItem->GetValue(0) == BDRAGON_SCROLL)
  1491. {
  1492. if (pkTarget->GetRefineSet() != 702) return false;
  1493. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_BDRAGON, pkItem->GetCell());
  1494. }
  1495. else
  1496. {
  1497. if (pkTarget->GetRefineSet() == 501) return false;
  1498. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_SCROLL, pkItem->GetCell());
  1499. }
  1500. }
  1501. else if (pkItem->GetSubType() == USE_DETACHMENT && IS_SET(pkTarget->GetFlag(), ITEM_FLAG_REFINEABLE))
  1502. {
  1503. LogManager::instance().ItemLog(this, pkTarget, "USE_DETACHMENT", pkTarget->GetName());
  1505. bool bHasMetinStone = false;
  1507. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; i++)
  1508. {
  1509. long socket = pkTarget->GetSocket(i);
  1510. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
  1511. {
  1512. bHasMetinStone = true;
  1513. break;
  1514. }
  1515. }
  1517. if (bHasMetinStone)
  1518. {
  1519. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  1520. {
  1521. long socket = pkTarget->GetSocket(i);
  1522. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
  1523. {
  1524. AutoGiveItem(socket);
  1525. //TItemTable* pTable = ITEM_MANAGER::instance().GetTable(pkTarget->GetSocket(i));
  1526. //pkTarget->SetSocket(i, pTable->alValues[2]);
  1527. // 깨진돌로 대체해준다
  1528. pkTarget->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
  1529. }
  1530. }
  1531. pkItem->SetCount(pkItem->GetCount() - 1);
  1532. return true;
  1533. }
  1534. else
  1535. {
  1536. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빼낼 수 있는 메틴석이 없습니다."));
  1537. return false;
  1538. }
  1539. }
  1541. return false;
  1542. }
  1544. bool CHARACTER::CleanAcceAttr(LPITEM pkItem, LPITEM pkTarget)
  1545. {
  1546. if (!CanHandleItem())
  1547. return false;
  1549. if (pkTarget->GetType() != ITEM_COSTUME && pkTarget->GetSubType() != COSTUME_ACCE)
  1550. return false;
  1552. if (pkTarget->GetAcceAttributeCount() < 1)
  1553. return false;
  1555. if (pkItem->GetValue(0) == ACCE_CLEAN_ATTR)
  1556. {
  1557. LogManager::instance().ItemLog(this, pkTarget, "USE_DETACHMENT", pkTarget->GetName());
  1558. pkTarget->SetForceAttribute(0, 0, 0);
  1559. pkTarget->SetForceAttribute(1, 0, 0);
  1560. pkTarget->SetForceAttribute(2, 0, 0);
  1561. pkTarget->SetForceAttribute(3, 0, 0);
  1562. pkTarget->SetForceAttribute(4, 0, 0);
  1563. pkTarget->SetForceAttribute(5, 0, 0);
  1564. pkTarget->SetForceAttribute(6, 0, 0);
  1565. pkTarget->SetForceAttribute(7, 0, 0);
  1566. pkTarget->SetForceAttribute(8, 0, 0);
  1567. pkTarget->SetForceAttribute(9, 0, 0);
  1568. pkTarget->SetForceAttribute(10, 0, 0);
  1569. pkTarget->SetForceAttribute(11, 0, 0);
  1570. pkTarget->SetForceAttribute(12, 0, 0);
  1571. pkTarget->SetForceAttribute(13, 0, 0);
  1572. pkTarget->SetForceAttribute(14, 0, 0);
  1573. pkItem->SetCount(pkItem->GetCount() - 1);
  1574. return true;
  1575. }
  1577. return false;
  1578. }
  1580. EVENTFUNC(kill_campfire_event)
  1581. {
  1582. char_event_info* info = dynamic_cast<char_event_info*>( event->info );
  1584. if ( info == NULL )
  1585. {
  1586. sys_err( "kill_campfire_event> <Factor> Null pointer" );
  1587. return 0;
  1588. }
  1590. LPCHARACTER ch = info->ch;
  1592. if (ch == NULL) { // <Factor>
  1593. return 0;
  1594. }
  1595. ch->m_pkMiningEvent = NULL;
  1596. M2_DESTROY_CHARACTER(ch);
  1597. return 0;
  1598. }
  1600. bool CHARACTER::GiveRecallItem(LPITEM item)
  1601. {
  1602. int idx = GetMapIndex();
  1603. int iEmpireByMapIndex = -1;
  1605. if (idx < 20)
  1606. iEmpireByMapIndex = 1;
  1607. else if (idx < 40)
  1608. iEmpireByMapIndex = 2;
  1609. else if (idx < 60)
  1610. iEmpireByMapIndex = 3;
  1611. else if (idx < 10000)
  1612. iEmpireByMapIndex = 0;
  1614. switch (idx)
  1615. {
  1616. case 66:
  1617. case 216:
  1618. iEmpireByMapIndex = -1;
  1619. break;
  1620. }
  1622. if (iEmpireByMapIndex && GetEmpire() != iEmpireByMapIndex)
  1623. {
  1624. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("기억해 둘 수 없는 위치 입니다."));
  1625. return false;
  1626. }
  1628. int pos;
  1630. if (item->GetCount() == 1) // 아이템이 하나라면 그냥 셋팅.
  1631. {
  1632. item->SetSocket(0, GetX());
  1633. item->SetSocket(1, GetY());
  1634. }
  1635. else if ((pos = GetEmptyInventory(item->GetSize())) != -1) // 그렇지 않다면 다른 인벤토리 슬롯을 찾는다.
  1636. {
  1637. LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), 1);
  1639. if (NULL != item2)
  1640. {
  1641. item2->SetSocket(0, GetX());
  1642. item2->SetSocket(1, GetY());
  1643. item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
  1645. item->SetCount(item->GetCount() - 1);
  1646. }
  1647. }
  1648. else
  1649. {
  1650. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지품에 빈 공간이 없습니다."));
  1651. return false;
  1652. }
  1654. return true;
  1655. }
  1657. void CHARACTER::ProcessRecallItem(LPITEM item)
  1658. {
  1659. int idx;
  1661. if ((idx = SECTREE_MANAGER::instance().GetMapIndex(item->GetSocket(0), item->GetSocket(1))) == 0)
  1662. return;
  1664. int iEmpireByMapIndex = -1;
  1666. if (idx < 20)
  1667. iEmpireByMapIndex = 1;
  1668. else if (idx < 40)
  1669. iEmpireByMapIndex = 2;
  1670. else if (idx < 60)
  1671. iEmpireByMapIndex = 3;
  1672. else if (idx < 10000)
  1673. iEmpireByMapIndex = 0;
  1675. switch (idx)
  1676. {
  1677. case 66:
  1678. case 216:
  1679. iEmpireByMapIndex = -1;
  1680. break;
  1681. // 악룡군도 일때
  1682. case 301:
  1683. case 302:
  1684. case 303:
  1685. case 304:
  1686. if( GetLevel() < 90 )
  1687. {
  1688. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템의 레벨 제한보다 레벨이 낮습니다."));
  1689. return;
  1690. }
  1691. else
  1692. break;
  1693. }
  1695. if (iEmpireByMapIndex && GetEmpire() != iEmpireByMapIndex)
  1696. {
  1697. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("기억된 위치가 타제국에 속해 있어서 귀환할 수 없습니다."));
  1698. item->SetSocket(0, 0);
  1699. item->SetSocket(1, 0);
  1700. }
  1701. else
  1702. {
  1703. sys_log(1, "Recall: %s %d %d -> %d %d", GetName(), GetX(), GetY(), item->GetSocket(0), item->GetSocket(1));
  1704. WarpSet(item->GetSocket(0), item->GetSocket(1));
  1705. item->SetCount(item->GetCount() - 1);
  1706. }
  1707. }
  1709. void CHARACTER::__OpenPrivateShop()
  1710. {
  1711. unsigned bodyPart = GetPart(PART_MAIN);
  1712. switch (bodyPart)
  1713. {
  1714. case 0:
  1715. case 1:
  1716. case 2:
  1717. ChatPacket(CHAT_TYPE_COMMAND, "OpenPrivateShop");
  1718. break;
  1719. default:
  1720. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("갑옷을 벗어야 개인 상점을 열 수 있습니다."));
  1721. break;
  1722. }
  1723. }
  1725. // MYSHOP_PRICE_LIST
  1726. void CHARACTER::SendMyShopPriceListCmd(DWORD dwItemVnum, DWORD dwItemPrice)
  1727. {
  1728. char szLine[256];
  1729. snprintf(szLine, sizeof(szLine), "MyShopPriceList %u %u", dwItemVnum, dwItemPrice);
  1730. ChatPacket(CHAT_TYPE_COMMAND, szLine);
  1731. sys_log(0, szLine);
  1732. }
  1734. //
  1735. // DB 캐시로 부터 받은 리스트를 User 에게 전송하고 상점을 열라는 커맨드를 보낸다.
  1736. //
  1737. void CHARACTER::UseSilkBotaryReal(const TPacketMyshopPricelistHeader* p)
  1738. {
  1739. const TItemPriceInfo* pInfo = (const TItemPriceInfo*)(p + 1);
  1741. if (!p->byCount)
  1742. // 가격 리스트가 없다. dummy 데이터를 넣은 커맨드를 보내준다.
  1743. SendMyShopPriceListCmd(1, 0);
  1744. else {
  1745. for (int idx = 0; idx < p->byCount; idx++)
  1746. SendMyShopPriceListCmd(pInfo[ idx ].dwVnum, pInfo[ idx ].dwPrice);
  1747. }
  1749. __OpenPrivateShop();
  1750. }
  1752. //
  1753. // 이번 접속 후 처음 상점을 Open 하는 경우 리스트를 Load 하기 위해 DB 캐시에 가격정보 리스트 요청 패킷을 보낸다.
  1754. // 이후부터는 바로 상점을 열라는 응답을 보낸다.
  1755. //
  1756. void CHARACTER::UseSilkBotary(void)
  1757. {
  1758. if (m_bNoOpenedShop) {
  1759. DWORD dwPlayerID = GetPlayerID();
  1760. db_clientdesc->DBPacket(HEADER_GD_MYSHOP_PRICELIST_REQ, GetDesc()->GetHandle(), &dwPlayerID, sizeof(DWORD));
  1761. m_bNoOpenedShop = false;
  1762. } else {
  1763. __OpenPrivateShop();
  1764. }
  1765. }
  1766. // END_OF_MYSHOP_PRICE_LIST
  1769. int CalculateConsume(LPCHARACTER ch)
  1770. {
  1771. static const int WARP_NEED_LIFE_PERCENT = 30;
  1772. static const int WARP_MIN_LIFE_PERCENT = 10;
  1773. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  1774. int consumeLife = 0;
  1775. {
  1776. // CheckNeedLifeForWarp
  1777. const int curLife = ch->GetHP();
  1778. const int needPercent = WARP_NEED_LIFE_PERCENT;
  1779. const int needLife = ch->GetMaxHP() * needPercent / 100;
  1780. if (curLife < needLife)
  1781. {
  1782. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("남은 생명력 양이 모자라 사용할 수 없습니다."));
  1783. return -1;
  1784. }
  1786. consumeLife = needLife;
  1789. // CheckMinLifeForWarp: 독에 의해서 죽으면 안되므로 생명력 최소량는 남겨준다
  1790. const int minPercent = WARP_MIN_LIFE_PERCENT;
  1791. const int minLife = ch->GetMaxHP() * minPercent / 100;
  1792. if (curLife - needLife < minLife)
  1793. consumeLife = curLife - minLife;
  1795. if (consumeLife < 0)
  1796. consumeLife = 0;
  1797. }
  1798. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  1799. return consumeLife;
  1800. }
  1802. #ifdef ENABLE_YMIR_AFFECT_FIX
  1804. bool CHARACTER::CheckTimeUsed(LPITEM item)
  1805. {
  1806. switch (item->GetVnum())
  1807. {
  1809. case 50821: case 50822: case 50823: case 50824: case 50825: case 50826:
  1812. case 27866: case 27868: case 27870: case 27873: case 39026: case 50093: case 50094:
  1813. case 50123: case 50801: case 50802: case 50817: case 50818: case 50819: case 50820:
  1815. case 39010: case 39017: case 39018: case 39019: case 39020: case 39024: case 39025:
  1816. case 39031: case 50813: case 50814: case 71014: case 71015: case 71016: case 71017:
  1817. case 71027: case 71028: case 71029: case 71030: case 71034: case 71044: case 71045:
  1818. case 71101: case 71102: case 71153: case 71154: case 71155: case 71156: case 72025:
  1819. case 72026: case 72027: case 72031: case 72032: case 72033: case 72034: case 72035:
  1820. case 72036: case 72037: case 72038: case 72039: case 72040: case 72041: case 72042:
  1821. case 72046: case 72047: case 72048: case 72312: case 72313: case 72501: case 72502:
  1822. case 76003: case 76017: case 76018:
  1824. int pGetTime[] = {10}; // Set timer for how you need a long after you login for can use item
  1826. int pGetFlag = GetQuestFlag("item.last_time"); // Get questflag where him set from input_login.cpp (Not change)
  1828. const char* pGetMessage[] = {"|cFFd0ffcc|H|hPoti utiliza |cFFc9ff00|H|h[%s] doar la [%u] secunde dupa logare"}; // Get message when you use time so fast
  1830. if (pGetFlag) // Initializate questflag on item
  1831. {
  1832. if (get_global_time() < pGetFlag + pGetTime[0]) // Initializate to get a + second for questflag
  1833. {
  1834. ChatPacket(CHAT_TYPE_INFO, pGetMessage[0], item->GetName(), pGetTime[0]); // Get message
  1835. return false; // Returns false if you use the item quicker than those seconds
  1836. }
  1837. }
  1838. break;
  1839. }
  1840. return true;
  1841. }
  1842. #endif
  1844. int CalculateConsumeSP(LPCHARACTER lpChar)
  1845. {
  1846. static const int NEED_WARP_SP_PERCENT = 30;
  1848. const int curSP = lpChar->GetSP();
  1849. const int needSP = lpChar->GetMaxSP() * NEED_WARP_SP_PERCENT / 100;
  1851. if (curSP < needSP)
  1852. {
  1853. lpChar->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("남은 정신력 양이 모자라 사용할 수 없습니다."));
  1854. return -1;
  1855. }
  1857. return needSP;
  1858. }
  1860. bool CHARACTER::UseItemEx(LPITEM item, TItemPos DestCell)
  1861. {
  1862. int iLimitRealtimeStartFirstUseFlagIndex = -1;
  1863. int iLimitTimerBasedOnWearFlagIndex = -1;
  1865. WORD wDestCell = DestCell.cell;
  1866. BYTE bDestInven = DestCell.window_type;
  1867. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  1868. {
  1869. long limitValue = item->GetProto()->aLimits[i].lValue;
  1871. switch (item->GetProto()->aLimits[i].bType)
  1872. {
  1873. case LIMIT_LEVEL:
  1874. if (GetLevel() < limitValue)
  1875. {
  1876. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템의 레벨 제한보다 레벨이 낮습니다."));
  1877. return false;
  1878. }
  1879. break;
  1881. case LIMIT_REAL_TIME_START_FIRST_USE:
  1882. iLimitRealtimeStartFirstUseFlagIndex = i;
  1883. break;
  1885. case LIMIT_TIMER_BASED_ON_WEAR:
  1886. iLimitTimerBasedOnWearFlagIndex = i;
  1887. break;
  1888. }
  1889. }
  1891. if (test_server)
  1892. {
  1893. sys_log(0, "USE_ITEM %s, Inven %d, Cell %d, ItemType %d, SubType %d", item->GetName(), bDestInven, wDestCell, item->GetType(), item->GetSubType());
  1894. }
  1896. if ( CArenaManager::instance().IsLimitedItem( GetMapIndex(), item->GetVnum() ) == true )
  1897. {
  1898. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  1899. return false;
  1900. }
  1902. // 아이템 최초 사용 이후부터는 사용하지 않아도 시간이 차감되는 방식 처리.
  1903. if (-1 != iLimitRealtimeStartFirstUseFlagIndex)
  1904. {
  1905. // 한 번이라도 사용한 아이템인지 여부는 Socket1을 보고 판단한다. (Socket1에 사용횟수 기록)
  1906. if (0 == item->GetSocket(1))
  1907. {
  1908. // 사용가능시간은 Default 값으로 Limit Value 값을 사용하되, Socket0에 값이 있으면 그 값을 사용하도록 한다. (단위는 초)
  1909. long duration = (0 != item->GetSocket(0)) ? item->GetSocket(0) : item->GetProto()->aLimits[iLimitRealtimeStartFirstUseFlagIndex].lValue;
  1911. if (0 == duration)
  1912. duration = 60 * 60 * 24 * 7;
  1914. item->SetSocket(0, time(0) + duration);
  1915. item->StartRealTimeExpireEvent();
  1916. }
  1918. if (false == item->IsEquipped())
  1919. item->SetSocket(1, item->GetSocket(1) + 1);
  1920. }
  1922. switch (item->GetType())
  1923. {
  1924. case ITEM_HAIR:
  1925. return ItemProcess_Hair(item, wDestCell);
  1927. case ITEM_POLYMORPH:
  1928. return ItemProcess_Polymorph(item);
  1930. case ITEM_QUEST:
  1931. if (GetArena() != NULL || IsObserverMode() == true)
  1932. {
  1933. if (item->GetVnum() == 50051 || item->GetVnum() == 50052 || item->GetVnum() == 50053)
  1934. {
  1935. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  1936. return false;
  1937. }
  1938. }
  1940. if (!IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE | ITEM_FLAG_QUEST_USE_MULTIPLE))
  1941. {
  1942. if (item->GetSIGVnum() == 0)
  1943. {
  1944. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  1945. }
  1946. else
  1947. {
  1948. quest::CQuestManager::instance().SIGUse(GetPlayerID(), item->GetSIGVnum(), item, false);
  1949. }
  1950. }
  1951. break;
  1953. case ITEM_CAMPFIRE:
  1954. {
  1955. float fx, fy;
  1956. GetDeltaByDegree(GetRotation(), 100.0f, &fx, &fy);
  1958. LPSECTREE tree = SECTREE_MANAGER::instance().Get(GetMapIndex(), (long)(GetX()+fx), (long)(GetY()+fy));
  1960. if (!tree)
  1961. {
  1962. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("모닥불을 피울 수 없는 지점입니다."));
  1963. return false;
  1964. }
  1966. if (tree->IsAttr((long)(GetX()+fx), (long)(GetY()+fy), ATTR_WATER))
  1967. {
  1968. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물 속에 모닥불을 피울 수 없습니다."));
  1969. return false;
  1970. }
  1972. LPCHARACTER campfire = CHARACTER_MANAGER::instance().SpawnMob(fishing::CAMPFIRE_MOB, GetMapIndex(), (long)(GetX()+fx), (long)(GetY()+fy), 0, false, number(0, 359));
  1974. char_event_info* info = AllocEventInfo<char_event_info>();
  1976. info->ch = campfire;
  1978. campfire->m_pkMiningEvent = event_create(kill_campfire_event, info, PASSES_PER_SEC(40));
  1980. item->SetCount(item->GetCount() - 1);
  1981. }
  1982. break;
  1984. case ITEM_UNIQUE:
  1985. {
  1986. switch (item->GetSubType())
  1987. {
  1988. case USE_ABILITY_UP:
  1989. {
  1990. switch (item->GetValue(0))
  1991. {
  1992. case APPLY_MOV_SPEED:
  1993. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_MOV_SPEED, item->GetValue(2), AFF_MOV_SPEED_POTION, item->GetValue(1), 0, true, true);
  1994. break;
  1996. case APPLY_ATT_SPEED:
  1997. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ATT_SPEED, item->GetValue(2), AFF_ATT_SPEED_POTION, item->GetValue(1), 0, true, true);
  1998. break;
  2000. case APPLY_STR:
  2001. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ST, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2002. break;
  2004. case APPLY_DEX:
  2005. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_DX, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2006. break;
  2008. case APPLY_CON:
  2009. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_HT, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2010. break;
  2012. case APPLY_INT:
  2013. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_IQ, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2014. break;
  2016. case APPLY_CAST_SPEED:
  2017. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_CASTING_SPEED, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2018. break;
  2020. case APPLY_RESIST_MAGIC:
  2021. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_RESIST_MAGIC, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2022. break;
  2024. case APPLY_ATT_GRADE_BONUS:
  2025. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ATT_GRADE_BONUS,
  2026. item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2027. break;
  2029. case APPLY_DEF_GRADE_BONUS:
  2030. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_DEF_GRADE_BONUS,
  2031. item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2032. break;
  2033. }
  2034. }
  2036. if (GetDungeon())
  2037. GetDungeon()->UsePotion(this);
  2039. if (GetWarMap())
  2040. GetWarMap()->UsePotion(this, item);
  2042. item->SetCount(item->GetCount() - 1);
  2043. break;
  2045. default:
  2046. {
  2047. if (item->GetSubType() == USE_SPECIAL)
  2048. {
  2049. sys_log(0, "ITEM_UNIQUE: USE_SPECIAL %u", item->GetVnum());
  2051. switch (item->GetVnum())
  2052. {
  2053. case 71049: // 비단보따리
  2054. if (LC_IsYMIR() == true || LC_IsKorea() == true)
  2055. {
  2056. if (IS_BOTARYABLE_ZONE(GetMapIndex()) == true)
  2057. {
  2058. UseSilkBotary();
  2059. }
  2060. else
  2061. {
  2062. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개인 상점을 열 수 없는 지역입니다"));
  2063. }
  2064. }
  2065. else
  2066. {
  2067. UseSilkBotary();
  2068. }
  2069. break;
  2070. }
  2071. }
  2072. else
  2073. {
  2074. if (!item->IsEquipped())
  2075. EquipItem(item);
  2076. else
  2077. UnequipItem(item);
  2078. }
  2079. }
  2080. break;
  2081. }
  2082. }
  2083. break;
  2085. case ITEM_COSTUME:
  2086. case ITEM_WEAPON:
  2087. case ITEM_ARMOR:
  2088. case ITEM_ROD:
  2089. case ITEM_RING: // 신규 반지 아이템
  2090. case ITEM_BELT: // 신규 벨트 아이템
  2091. // MINING
  2092. case ITEM_PICK:
  2093. // END_OF_MINING
  2094. if (!item->IsEquipped())
  2095. EquipItem(item);
  2096. else
  2097. UnequipItem(item);
  2098. break;
  2099. // 착용하지 않은 용혼석은 사용할 수 없다.
  2100. // 정상적인 클라라면, 용혼석에 관하여 item use 패킷을 보낼 수 없다.
  2101. // 용혼석 착용은 item move 패킷으로 한다.
  2102. // 착용한 용혼석은 추출한다.
  2103. case ITEM_DS:
  2104. {
  2105. if (!item->IsEquipped())
  2106. return false;
  2107. return DSManager::instance().PullOut(this, NPOS, item);
  2108. break;
  2109. }
  2110. case ITEM_SPECIAL_DS:
  2111. if (!item->IsEquipped())
  2112. EquipItem(item);
  2113. else
  2114. UnequipItem(item);
  2115. break;
  2117. case ITEM_FISH:
  2118. {
  2119. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  2120. {
  2121. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2122. return false;
  2123. }
  2125. if (item->GetSubType() == FISH_ALIVE)
  2126. fishing::UseFish(this, item);
  2127. }
  2128. break;
  2130. case ITEM_TREASURE_BOX:
  2131. {
  2132. return false;
  2133. //ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠로 잠겨 있어서 열리지 않는것 같다. 열쇠를 구해보자."));
  2134. }
  2135. break;
  2137. case ITEM_TREASURE_KEY:
  2138. {
  2139. LPITEM item2;
  2141. if (!GetItem(DestCell) || !(item2 = GetItem(DestCell)))
  2142. return false;
  2144. if (item2->IsExchanging())
  2145. return false;
  2147. if (item2->GetType() != ITEM_TREASURE_BOX)
  2148. {
  2149. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠로 여는 물건이 아닌것 같다."));
  2150. return false;
  2151. }
  2153. if (item->GetValue(0) == item2->GetValue(0))
  2154. {
  2155. //ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠는 맞으나 아이템 주는 부분 구현이 안되었습니다."));
  2156. DWORD dwBoxVnum = item2->GetVnum();
  2157. std::vector <DWORD> dwVnums;
  2158. std::vector <DWORD> dwCounts;
  2159. std::vector <LPITEM> item_gets(NULL);
  2160. int count = 0;
  2162. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  2163. {
  2164. ITEM_MANAGER::instance().RemoveItem(item);
  2165. ITEM_MANAGER::instance().RemoveItem(item2);
  2167. for (int i = 0; i < count; i++){
  2168. switch (dwVnums[i])
  2169. {
  2170. case CSpecialItemGroup::GOLD:
  2171. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  2172. break;
  2173. case CSpecialItemGroup::EXP:
  2174. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
  2175. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
  2176. break;
  2177. case CSpecialItemGroup::MOB:
  2178. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  2179. break;
  2180. case CSpecialItemGroup::SLOW:
  2181. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 빨간 연기를 들이마시자 움직이는 속도가 느려졌습니다!"));
  2182. break;
  2183. case CSpecialItemGroup::DRAIN_HP:
  2184. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자가 갑자기 폭발하였습니다! 생명력이 감소했습니다."));
  2185. break;
  2186. case CSpecialItemGroup::POISON:
  2187. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  2188. break;
  2189. case CSpecialItemGroup::MOB_GROUP:
  2190. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  2191. break;
  2192. default:
  2193. if (item_gets[i])
  2194. {
  2195. if (dwCounts[i] > 1)
  2196. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
  2197. else
  2198. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
  2200. }
  2201. }
  2202. }
  2203. }
  2204. else
  2205. {
  2206. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠가 맞지 않는 것 같다."));
  2207. return false;
  2208. }
  2209. }
  2210. else
  2211. {
  2212. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠가 맞지 않는 것 같다."));
  2213. return false;
  2214. }
  2215. }
  2216. break;
  2218. case ITEM_GIFTBOX:
  2219. {
  2220. DWORD dwBoxVnum = item->GetVnum();
  2221. std::vector <DWORD> dwVnums;
  2222. std::vector <DWORD> dwCounts;
  2223. std::vector <LPITEM> item_gets(NULL);
  2224. int count = 0;
  2226. if (dwBoxVnum == 50033 && LC_IsYMIR()) // 알수없는 상자
  2227. {
  2228. if (GetLevel() < 15)
  2229. {
  2230. ChatPacket(CHAT_TYPE_INFO, "15레벨 이하에서는 사용할 수 없습니다.");
  2231. return false;
  2232. }
  2233. }
  2235. if( (dwBoxVnum > 51500 && dwBoxVnum < 52000) || (dwBoxVnum >= 50255 && dwBoxVnum <= 50260) ) // 용혼원석들
  2236. {
  2237. if( !(this->DragonSoul_IsQualified()) )
  2238. {
  2239. ChatPacket(CHAT_TYPE_INFO,LC_TEXT("먼저 용혼석 퀘스트를 완료하셔야 합니다."));
  2240. return false;
  2241. }
  2242. }
  2244. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  2245. {
  2246. item->SetCount(item->GetCount()-1);
  2248. for (int i = 0; i < count; i++){
  2249. switch (dwVnums[i])
  2250. {
  2251. case CSpecialItemGroup::GOLD:
  2252. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  2253. break;
  2254. case CSpecialItemGroup::EXP:
  2255. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
  2256. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
  2257. break;
  2258. case CSpecialItemGroup::MOB:
  2259. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  2260. break;
  2261. case CSpecialItemGroup::SLOW:
  2262. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 빨간 연기를 들이마시자 움직이는 속도가 느려졌습니다!"));
  2263. break;
  2264. case CSpecialItemGroup::DRAIN_HP:
  2265. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자가 갑자기 폭발하였습니다! 생명력이 감소했습니다."));
  2266. break;
  2267. case CSpecialItemGroup::POISON:
  2268. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  2269. break;
  2270. case CSpecialItemGroup::MOB_GROUP:
  2271. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  2272. break;
  2273. default:
  2274. if (item_gets[i])
  2275. {
  2276. if (dwCounts[i] > 1)
  2277. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
  2278. else
  2279. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
  2280. }
  2281. }
  2282. }
  2283. }
  2284. else
  2285. {
  2286. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("아무것도 얻을 수 없었습니다."));
  2287. return false;
  2288. }
  2289. }
  2290. break;
  2292. case ITEM_SKILLFORGET:
  2293. {
  2294. if (!item->GetSocket(0))
  2295. {
  2296. ITEM_MANAGER::instance().RemoveItem(item);
  2297. return false;
  2298. }
  2300. DWORD dwVnum = item->GetSocket(0);
  2302. if (SkillLevelDown(dwVnum))
  2303. {
  2304. ITEM_MANAGER::instance().RemoveItem(item);
  2305. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("스킬 레벨을 내리는데 성공하였습니다."));
  2306. }
  2307. else
  2308. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("스킬 레벨을 내릴 수 없습니다."));
  2309. }
  2310. break;
  2312. case ITEM_SKILLBOOK:
  2313. {
  2314. if (IsPolymorphed())
  2315. {
  2316. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  2317. return false;
  2318. }
  2320. DWORD dwVnum = 0;
  2322. if (item->GetVnum() == 50300)
  2323. {
  2324. dwVnum = item->GetSocket(0);
  2325. }
  2326. else
  2327. {
  2328. // 새로운 수련서는 value 0 에 스킬 번호가 있으므로 그것을 사용.
  2329. dwVnum = item->GetValue(0);
  2330. }
  2332. if (0 == dwVnum)
  2333. {
  2334. ITEM_MANAGER::instance().RemoveItem(item);
  2336. return false;
  2337. }
  2339. if (true == LearnSkillByBook(dwVnum))
  2340. {
  2341. item->SetCount(item->GetCount() - 1);
  2343. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2345. if (distribution_test_server)
  2346. iReadDelay /= 3;
  2348. //한국 본섭의 경우에는 시간을 24시간 고정
  2349. if (LC_IsKorea())
  2350. iReadDelay = 86400;
  2352. SetSkillNextReadTime(dwVnum, get_global_time() + iReadDelay);
  2353. }
  2354. }
  2355. break;
  2357. case ITEM_USE:
  2358. {
  2359. if (item->GetVnum() > 50800 && item->GetVnum() <= 50820)
  2360. {
  2361. if (test_server)
  2362. sys_log (0, "ADD addtional effect : vnum(%d) subtype(%d)", item->GetOriginalVnum(), item->GetSubType());
  2364. int affect_type = AFFECT_EXP_BONUS_EURO_FREE;
  2365. int apply_type = aApplyInfo[item->GetValue(0)].bPointType;
  2366. int apply_value = item->GetValue(2);
  2367. int apply_duration = item->GetValue(1);
  2369. switch (item->GetSubType())
  2370. {
  2371. case USE_ABILITY_UP:
  2372. if (FindAffect(affect_type, apply_type))
  2373. {
  2374. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  2375. return false;
  2376. }
  2377. #ifdef ENABLE_YMIR_AFFECT_FIX
  2378. if ((CheckTimeUsed(item) == false)) { return false; }
  2379. #endif
  2381. {
  2382. switch (item->GetValue(0))
  2383. {
  2384. case APPLY_MOV_SPEED:
  2385. AddAffect(affect_type, apply_type, apply_value, AFF_MOV_SPEED_POTION, apply_duration, 0, true, true);
  2386. break;
  2388. case APPLY_ATT_SPEED:
  2389. AddAffect(affect_type, apply_type, apply_value, AFF_ATT_SPEED_POTION, apply_duration, 0, true, true);
  2390. break;
  2392. case APPLY_STR:
  2393. case APPLY_DEX:
  2394. case APPLY_CON:
  2395. case APPLY_INT:
  2396. case APPLY_CAST_SPEED:
  2397. case APPLY_RESIST_MAGIC:
  2398. case APPLY_ATT_GRADE_BONUS:
  2399. case APPLY_DEF_GRADE_BONUS:
  2400. AddAffect(affect_type, apply_type, apply_value, 0, apply_duration, 0, true, true);
  2401. break;
  2402. }
  2403. }
  2405. if (GetDungeon())
  2406. GetDungeon()->UsePotion(this);
  2408. if (GetWarMap())
  2409. GetWarMap()->UsePotion(this, item);
  2411. item->SetCount(item->GetCount() - 1);
  2412. break;
  2414. case USE_AFFECT :
  2415. {
  2417. #ifdef ENABLE_YMIR_AFFECT_FIX
  2418. if ((CheckTimeUsed(item) == false)) { return false; }
  2419. #endif
  2421. if (FindAffect(AFFECT_EXP_BONUS_EURO_FREE, aApplyInfo[item->GetValue(1)].bPointType))
  2422. {
  2423. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  2424. }
  2425. else
  2426. {
  2427. // PC_BANG_ITEM_ADD
  2428. if (item->IsPCBangItem() == true)
  2429. {
  2430. // PC방인지 체크해서 처리
  2431. if (CPCBangManager::instance().IsPCBangIP(GetDesc()->GetHostName()) == false)
  2432. {
  2433. // PC방이 아님!
  2434. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 PC방에서만 사용할 수 있습니다."));
  2435. return false;
  2436. }
  2437. }
  2438. // END_PC_BANG_ITEM_ADD
  2440. AddAffect(AFFECT_EXP_BONUS_EURO_FREE, aApplyInfo[item->GetValue(1)].bPointType, item->GetValue(2), 0, item->GetValue(3), 0, false, true);
  2441. item->SetCount(item->GetCount() - 1);
  2442. }
  2443. }
  2444. break;
  2446. case USE_POTION_NODELAY:
  2447. {
  2448. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  2449. {
  2450. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
  2451. {
  2452. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  2453. return false;
  2454. }
  2456. switch (item->GetVnum())
  2457. {
  2458. case 70020 :
  2459. case 71018 :
  2460. case 71019 :
  2461. case 71020 :
  2462. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
  2463. {
  2464. if (m_nPotionLimit <= 0)
  2465. {
  2466. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용 제한량을 초과하였습니다."));
  2467. return false;
  2468. }
  2469. }
  2470. break;
  2472. default :
  2473. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  2474. return false;
  2475. break;
  2476. }
  2477. }
  2479. bool used = false;
  2481. if (item->GetValue(0) != 0) // HP 절대값 회복
  2482. {
  2483. if (GetHP() < GetMaxHP())
  2484. {
  2485. PointChange(POINT_HP, item->GetValue(0) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  2486. EffectPacket(SE_HPUP_RED);
  2487. used = TRUE;
  2488. }
  2489. }
  2491. if (item->GetValue(1) != 0) // SP 절대값 회복
  2492. {
  2493. if (GetSP() < GetMaxSP())
  2494. {
  2495. PointChange(POINT_SP, item->GetValue(1) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  2496. EffectPacket(SE_SPUP_BLUE);
  2497. used = TRUE;
  2498. }
  2499. }
  2501. if (item->GetValue(3) != 0) // HP % 회복
  2502. {
  2503. if (GetHP() < GetMaxHP())
  2504. {
  2505. PointChange(POINT_HP, item->GetValue(3) * GetMaxHP() / 100);
  2506. EffectPacket(SE_HPUP_RED);
  2507. used = TRUE;
  2508. }
  2509. }
  2511. if (item->GetValue(4) != 0) // SP % 회복
  2512. {
  2513. if (GetSP() < GetMaxSP())
  2514. {
  2515. PointChange(POINT_SP, item->GetValue(4) * GetMaxSP() / 100);
  2516. EffectPacket(SE_SPUP_BLUE);
  2517. used = TRUE;
  2518. }
  2519. }
  2521. if (used)
  2522. {
  2523. if (item->GetVnum() == 50085 || item->GetVnum() == 50086)
  2524. {
  2525. if (test_server)
  2526. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("월병 또는 종자 를 사용하였습니다"));
  2527. SetUseSeedOrMoonBottleTime();
  2528. }
  2529. if (GetDungeon())
  2530. GetDungeon()->UsePotion(this);
  2532. if (GetWarMap())
  2533. GetWarMap()->UsePotion(this, item);
  2535. m_nPotionLimit--;
  2537. //RESTRICT_USE_SEED_OR_MOONBOTTLE
  2538. item->SetCount(item->GetCount() - 1);
  2539. //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
  2540. }
  2541. }
  2542. break;
  2543. }
  2545. return true;
  2546. }
  2549. if (item->GetVnum() >= 27863 && item->GetVnum() <= 27883)
  2550. {
  2551. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  2552. {
  2553. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2554. return false;
  2555. }
  2556. }
  2558. if (test_server)
  2559. {
  2560. sys_log (0, "USE_ITEM %s Type %d SubType %d vnum %d", item->GetName(), item->GetType(), item->GetSubType(), item->GetOriginalVnum());
  2561. }
  2563. switch (item->GetSubType())
  2564. {
  2565. case USE_TIME_CHARGE_PER:
  2566. {
  2567. LPITEM pDestItem = GetItem(DestCell);
  2568. if (NULL == pDestItem)
  2569. {
  2570. return false;
  2571. }
  2572. // 우선 용혼석에 관해서만 하도록 한다.
  2573. if (pDestItem->IsDragonSoul())
  2574. {
  2575. int ret;
  2576. char buf[128];
  2577. if (item->GetVnum() == DRAGON_HEART_VNUM)
  2578. {
  2579. ret = pDestItem->GiveMoreTime_Per((float)item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
  2580. }
  2581. else
  2582. {
  2583. ret = pDestItem->GiveMoreTime_Per((float)item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2584. }
  2585. if (ret > 0)
  2586. {
  2587. if (item->GetVnum() == DRAGON_HEART_VNUM)
  2588. {
  2589. sprintf(buf, "Inc %ds by item{VN:%d SOC%d:%d}", ret, item->GetVnum(), ITEM_SOCKET_CHARGING_AMOUNT_IDX, item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
  2590. }
  2591. else
  2592. {
  2593. sprintf(buf, "Inc %ds by item{VN:%d VAL%d:%d}", ret, item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2594. }
  2596. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d초 만큼 충전되었습니다."), ret);
  2597. item->SetCount(item->GetCount() - 1);
  2598. LogManager::instance().ItemLog(this, item, "DS_CHARGING_SUCCESS", buf);
  2599. return true;
  2600. }
  2601. else
  2602. {
  2603. if (item->GetVnum() == DRAGON_HEART_VNUM)
  2604. {
  2605. sprintf(buf, "No change by item{VN:%d SOC%d:%d}", item->GetVnum(), ITEM_SOCKET_CHARGING_AMOUNT_IDX, item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
  2606. }
  2607. else
  2608. {
  2609. sprintf(buf, "No change by item{VN:%d VAL%d:%d}", item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2610. }
  2612. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("충전할 수 없습니다."));
  2613. LogManager::instance().ItemLog(this, item, "DS_CHARGING_FAILED", buf);
  2614. return false;
  2615. }
  2616. }
  2617. else
  2618. return false;
  2619. }
  2620. break;
  2621. case USE_TIME_CHARGE_FIX:
  2622. {
  2623. LPITEM pDestItem = GetItem(DestCell);
  2624. if (NULL == pDestItem)
  2625. {
  2626. return false;
  2627. }
  2628. // 우선 용혼석에 관해서만 하도록 한다.
  2629. if (pDestItem->IsDragonSoul())
  2630. {
  2631. int ret = pDestItem->GiveMoreTime_Fix(item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2632. char buf[128];
  2633. if (ret)
  2634. {
  2635. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d초 만큼 충전되었습니다."), ret);
  2636. sprintf(buf, "Increase %ds by item{VN:%d VAL%d:%d}", ret, item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2637. LogManager::instance().ItemLog(this, item, "DS_CHARGING_SUCCESS", buf);
  2638. item->SetCount(item->GetCount() - 1);
  2639. return true;
  2640. }
  2641. else
  2642. {
  2643. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("충전할 수 없습니다."));
  2644. sprintf(buf, "No change by item{VN:%d VAL%d:%d}", item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2645. LogManager::instance().ItemLog(this, item, "DS_CHARGING_FAILED", buf);
  2646. return false;
  2647. }
  2648. }
  2649. else
  2650. return false;
  2651. }
  2652. break;
  2653. case USE_SPECIAL:
  2655. switch (item->GetVnum())
  2656. {
  2657. //크리스마스 란주
  2658. case ITEM_NOG_POCKET:
  2659. {
  2660. /*
  2661. 란주능력치 : item_proto value 의미
  2662. 이동속도 value 1
  2663. 공격력 value 2
  2664. 경험치 value 3
  2665. 지속시간 value 0 (단위 초)
  2667. */
  2668. if (FindAffect(AFFECT_NOG_ABILITY))
  2669. {
  2670. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  2671. return false;
  2672. }
  2673. long time = item->GetValue(0);
  2674. long moveSpeedPer = item->GetValue(1);
  2675. long attPer = item->GetValue(2);
  2676. long expPer = item->GetValue(3);
  2677. AddAffect(AFFECT_NOG_ABILITY, POINT_MOV_SPEED, moveSpeedPer, AFF_MOV_SPEED_POTION, time, 0, true, true);
  2678. EffectPacket(SE_DXUP_PURPLE);
  2679. AddAffect(AFFECT_NOG_ABILITY, POINT_MALL_ATTBONUS, attPer, AFF_NONE, time, 0, true, true);
  2680. AddAffect(AFFECT_NOG_ABILITY, POINT_MALL_EXPBONUS, expPer, AFF_NONE, time, 0, true, true);
  2681. item->SetCount(item->GetCount() - 1);
  2682. }
  2683. break;
  2685. //라마단용 사탕
  2686. case ITEM_RAMADAN_CANDY:
  2687. {
  2688. /*
  2689. 사탕능력치 : item_proto value 의미
  2690. 이동속도 value 1
  2691. 공격력 value 2
  2692. 경험치 value 3
  2693. 지속시간 value 0 (단위 초)
  2695. */
  2696. long time = item->GetValue(0);
  2697. long moveSpeedPer = item->GetValue(1);
  2698. long attPer = item->GetValue(2);
  2699. long expPer = item->GetValue(3);
  2700. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MOV_SPEED, moveSpeedPer, AFF_MOV_SPEED_POTION, time, 0, true, true);
  2701. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MALL_ATTBONUS, attPer, AFF_NONE, time, 0, true, true);
  2702. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MALL_EXPBONUS, expPer, AFF_NONE, time, 0, true, true);
  2703. item->SetCount(item->GetCount() - 1);
  2704. }
  2705. break;
  2706. case ITEM_MARRIAGE_RING:
  2707. {
  2708. marriage::TMarriage* pMarriage = marriage::CManager::instance().Get(GetPlayerID());
  2709. if (pMarriage)
  2710. {
  2711. if (pMarriage->ch1 != NULL)
  2712. {
  2713. if (CArenaManager::instance().IsArenaMap(pMarriage->ch1->GetMapIndex()) == true)
  2714. {
  2715. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2716. break;
  2717. }
  2718. }
  2720. if (pMarriage->ch2 != NULL)
  2721. {
  2722. if (CArenaManager::instance().IsArenaMap(pMarriage->ch2->GetMapIndex()) == true)
  2723. {
  2724. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2725. break;
  2726. }
  2727. }
  2729. int consumeSP = CalculateConsumeSP(this);
  2731. if (consumeSP < 0)
  2732. return false;
  2734. PointChange(POINT_SP, -consumeSP, false);
  2736. WarpToPID(pMarriage->GetOther(GetPlayerID()));
  2737. }
  2738. else
  2739. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("결혼 상태가 아니면 결혼반지를 사용할 수 없습니다."));
  2740. }
  2741. break;
  2743. //기존 용기의 망토
  2744. case UNIQUE_ITEM_CAPE_OF_COURAGE:
  2745. //라마단 보상용 용기의 망토
  2746. case 70057:
  2747. case REWARD_BOX_UNIQUE_ITEM_CAPE_OF_COURAGE:
  2748. AggregateMonster();
  2749. item->SetCount(item->GetCount()-1);
  2750. break;
  2752. case UNIQUE_ITEM_WHITE_FLAG:
  2753. ForgetMyAttacker();
  2754. item->SetCount(item->GetCount()-1);
  2755. break;
  2757. case UNIQUE_ITEM_TREASURE_BOX:
  2758. break;
  2760. case 30093:
  2761. case 30094:
  2762. case 30095:
  2763. case 30096:
  2764. // 복주머니
  2765. {
  2766. const int MAX_BAG_INFO = 26;
  2767. static struct LuckyBagInfo
  2768. {
  2769. DWORD count;
  2770. int prob;
  2771. DWORD vnum;
  2772. } b1[MAX_BAG_INFO] =
  2773. {
  2774. { 1000, 302, 1 },
  2775. { 10, 150, 27002 },
  2776. { 10, 75, 27003 },
  2777. { 10, 100, 27005 },
  2778. { 10, 50, 27006 },
  2779. { 10, 80, 27001 },
  2780. { 10, 50, 27002 },
  2781. { 10, 80, 27004 },
  2782. { 10, 50, 27005 },
  2783. { 1, 10, 50300 },
  2784. { 1, 6, 92 },
  2785. { 1, 2, 132 },
  2786. { 1, 6, 1052 },
  2787. { 1, 2, 1092 },
  2788. { 1, 6, 2082 },
  2789. { 1, 2, 2122 },
  2790. { 1, 6, 3082 },
  2791. { 1, 2, 3122 },
  2792. { 1, 6, 5052 },
  2793. { 1, 2, 5082 },
  2794. { 1, 6, 7082 },
  2795. { 1, 2, 7122 },
  2796. { 1, 1, 11282 },
  2797. { 1, 1, 11482 },
  2798. { 1, 1, 11682 },
  2799. { 1, 1, 11882 },
  2800. };
  2802. struct LuckyBagInfo b2[MAX_BAG_INFO] =
  2803. {
  2804. { 1000, 302, 1 },
  2805. { 10, 150, 27002 },
  2806. { 10, 75, 27002 },
  2807. { 10, 100, 27005 },
  2808. { 10, 50, 27005 },
  2809. { 10, 80, 27001 },
  2810. { 10, 50, 27002 },
  2811. { 10, 80, 27004 },
  2812. { 10, 50, 27005 },
  2813. { 1, 10, 50300 },
  2814. { 1, 6, 92 },
  2815. { 1, 2, 132 },
  2816. { 1, 6, 1052 },
  2817. { 1, 2, 1092 },
  2818. { 1, 6, 2082 },
  2819. { 1, 2, 2122 },
  2820. { 1, 6, 3082 },
  2821. { 1, 2, 3122 },
  2822. { 1, 6, 5052 },
  2823. { 1, 2, 5082 },
  2824. { 1, 6, 7082 },
  2825. { 1, 2, 7122 },
  2826. { 1, 1, 11282 },
  2827. { 1, 1, 11482 },
  2828. { 1, 1, 11682 },
  2829. { 1, 1, 11882 },
  2830. };
  2832. LuckyBagInfo * bi = NULL;
  2833. if (LC_IsHongKong())
  2834. bi = b2;
  2835. else
  2836. bi = b1;
  2838. int pct = number(1, 1000);
  2840. int i;
  2841. for (i=0;i<MAX_BAG_INFO;i++)
  2842. {
  2843. if (pct <= bi[i].prob)
  2844. break;
  2845. pct -= bi[i].prob;
  2846. }
  2847. if (i>=MAX_BAG_INFO)
  2848. return false;
  2850. if (bi[i].vnum == 50300)
  2851. {
  2852. // 스킬수련서는 특수하게 준다.
  2853. GiveRandomSkillBook();
  2854. }
  2855. else if (bi[i].vnum == 1)
  2856. {
  2857. PointChange(POINT_GOLD, 1000, true);
  2858. }
  2859. else
  2860. {
  2861. AutoGiveItem(bi[i].vnum, bi[i].count);
  2862. }
  2863. ITEM_MANAGER::instance().RemoveItem(item);
  2864. }
  2865. break;
  2867. case 50004: // 이벤트용 감지기
  2868. {
  2869. if (item->GetSocket(0))
  2870. {
  2871. item->SetSocket(0, item->GetSocket(0) + 1);
  2872. }
  2873. else
  2874. {
  2875. // 처음 사용시
  2876. int iMapIndex = GetMapIndex();
  2878. PIXEL_POSITION pos;
  2880. if (SECTREE_MANAGER::instance().GetRandomLocation(iMapIndex, pos, 700))
  2881. {
  2882. item->SetSocket(0, 1);
  2883. item->SetSocket(1, pos.x);
  2884. item->SetSocket(2, pos.y);
  2885. }
  2886. else
  2887. {
  2888. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 곳에선 이벤트용 감지기가 동작하지 않는것 같습니다."));
  2889. return false;
  2890. }
  2891. }
  2893. int dist = 0;
  2894. float distance = (DISTANCE_SQRT(GetX()-item->GetSocket(1), GetY()-item->GetSocket(2)));
  2896. if (distance < 1000.0f)
  2897. {
  2898. // 발견!
  2899. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이벤트용 감지기가 신비로운 빛을 내며 사라집니다."));
  2901. // 사용횟수에 따라 주는 아이템을 다르게 한다.
  2902. struct TEventStoneInfo
  2903. {
  2904. DWORD dwVnum;
  2905. int count;
  2906. int prob;
  2907. };
  2908. const int EVENT_STONE_MAX_INFO = 15;
  2909. TEventStoneInfo info_10[EVENT_STONE_MAX_INFO] =
  2910. {
  2911. { 27001, 10, 8 },
  2912. { 27004, 10, 6 },
  2913. { 27002, 10, 12 },
  2914. { 27005, 10, 12 },
  2915. { 27100, 1, 9 },
  2916. { 27103, 1, 9 },
  2917. { 27101, 1, 10 },
  2918. { 27104, 1, 10 },
  2919. { 27999, 1, 12 },
  2921. { 25040, 1, 4 },
  2923. { 27410, 1, 0 },
  2924. { 27600, 1, 0 },
  2925. { 25100, 1, 0 },
  2927. { 50001, 1, 0 },
  2928. { 50003, 1, 1 },
  2929. };
  2930. TEventStoneInfo info_7[EVENT_STONE_MAX_INFO] =
  2931. {
  2932. { 27001, 10, 1 },
  2933. { 27004, 10, 1 },
  2934. { 27004, 10, 9 },
  2935. { 27005, 10, 9 },
  2936. { 27100, 1, 5 },
  2937. { 27103, 1, 5 },
  2938. { 27101, 1, 10 },
  2939. { 27104, 1, 10 },
  2940. { 27999, 1, 14 },
  2942. { 25040, 1, 5 },
  2944. { 27410, 1, 5 },
  2945. { 27600, 1, 5 },
  2946. { 25100, 1, 5 },
  2948. { 50001, 1, 0 },
  2949. { 50003, 1, 5 },
  2951. };
  2952. TEventStoneInfo info_4[EVENT_STONE_MAX_INFO] =
  2953. {
  2954. { 27001, 10, 0 },
  2955. { 27004, 10, 0 },
  2956. { 27002, 10, 0 },
  2957. { 27005, 10, 0 },
  2958. { 27100, 1, 0 },
  2959. { 27103, 1, 0 },
  2960. { 27101, 1, 0 },
  2961. { 27104, 1, 0 },
  2962. { 27999, 1, 25 },
  2964. { 25040, 1, 0 },
  2966. { 27410, 1, 0 },
  2967. { 27600, 1, 0 },
  2968. { 25100, 1, 15 },
  2970. { 50001, 1, 10 },
  2971. { 50003, 1, 50 },
  2973. };
  2975. {
  2976. TEventStoneInfo* info;
  2977. if (item->GetSocket(0) <= 4)
  2978. info = info_4;
  2979. else if (item->GetSocket(0) <= 7)
  2980. info = info_7;
  2981. else
  2982. info = info_10;
  2984. int prob = number(1, 100);
  2986. for (int i = 0; i < EVENT_STONE_MAX_INFO; ++i)
  2987. {
  2988. if (!info[i].prob)
  2989. continue;
  2991. if (prob <= info[i].prob)
  2992. {
  2993. if (info[i].dwVnum == 50001)
  2994. {
  2995. DWORD * pdw = M2_NEW DWORD[2];
  2997. pdw[0] = info[i].dwVnum;
  2998. pdw[1] = info[i].count;
  3000. // 추첨서는 소켓을 설정한다
  3001. DBManager::instance().ReturnQuery(QID_LOTTO, GetPlayerID(), pdw,
  3002. "INSERT INTO lotto_list VALUES(0, 'server%s', %u, NOW())",
  3003. get_table_postfix(), GetPlayerID());
  3004. }
  3005. else
  3006. AutoGiveItem(info[i].dwVnum, info[i].count);
  3008. break;
  3009. }
  3010. prob -= info[i].prob;
  3011. }
  3012. }
  3014. char chatbuf[CHAT_MAX_LEN + 1];
  3015. int len = snprintf(chatbuf, sizeof(chatbuf), "StoneDetect %u 0 0", (DWORD)GetVID());
  3017. if (len < 0 || len >= (int) sizeof(chatbuf))
  3018. len = sizeof(chatbuf) - 1;
  3020. ++len; // \0 문자까지 보내기
  3022. TPacketGCChat pack_chat;
  3023. pack_chat.header = HEADER_GC_CHAT;
  3024. pack_chat.size = sizeof(TPacketGCChat) + len;
  3025. pack_chat.type = CHAT_TYPE_COMMAND;
  3026. pack_chat.id = 0;
  3027. pack_chat.bEmpire = GetDesc()->GetEmpire();
  3028. //pack_chat.id = vid;
  3030. TEMP_BUFFER buf;
  3031. buf.write(&pack_chat, sizeof(TPacketGCChat));
  3032. buf.write(chatbuf, len);
  3034. PacketAround(buf.read_peek(), buf.size());
  3036. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (DETECT_EVENT_STONE) 1");
  3037. return true;
  3038. }
  3039. else if (distance < 20000)
  3040. dist = 1;
  3041. else if (distance < 70000)
  3042. dist = 2;
  3043. else
  3044. dist = 3;
  3046. // 많이 사용했으면 사라진다.
  3047. const int STONE_DETECT_MAX_TRY = 10;
  3048. if (item->GetSocket(0) >= STONE_DETECT_MAX_TRY)
  3049. {
  3050. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이벤트용 감지기가 흔적도 없이 사라집니다."));
  3051. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (DETECT_EVENT_STONE) 0");
  3052. AutoGiveItem(27002);
  3053. return true;
  3054. }
  3056. if (dist)
  3057. {
  3058. char chatbuf[CHAT_MAX_LEN + 1];
  3059. int len = snprintf(chatbuf, sizeof(chatbuf),
  3060. "StoneDetect %u %d %d",
  3061. (DWORD)GetVID(), dist, (int)GetDegreeFromPositionXY(GetX(), item->GetSocket(2), item->GetSocket(1), GetY()));
  3063. if (len < 0 || len >= (int) sizeof(chatbuf))
  3064. len = sizeof(chatbuf) - 1;
  3066. ++len; // \0 문자까지 보내기
  3068. TPacketGCChat pack_chat;
  3069. pack_chat.header = HEADER_GC_CHAT;
  3070. pack_chat.size = sizeof(TPacketGCChat) + len;
  3071. pack_chat.type = CHAT_TYPE_COMMAND;
  3072. pack_chat.id = 0;
  3073. pack_chat.bEmpire = GetDesc()->GetEmpire();
  3074. //pack_chat.id = vid;
  3076. TEMP_BUFFER buf;
  3077. buf.write(&pack_chat, sizeof(TPacketGCChat));
  3078. buf.write(chatbuf, len);
  3080. PacketAround(buf.read_peek(), buf.size());
  3081. }
  3083. }
  3084. break;
  3086. case 27989: // 영석감지기
  3087. case 76006: // 선물용 영석감지기
  3088. {
  3089. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(GetMapIndex());
  3091. if (pMap != NULL)
  3092. {
  3093. item->SetSocket(0, item->GetSocket(0) + 1);
  3095. FFindStone f;
  3097. // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
  3098. pMap->for_each(f);
  3100. if (f.m_mapStone.size() > 0)
  3101. {
  3102. std::map<DWORD, LPCHARACTER>::iterator stone = f.m_mapStone.begin();
  3104. DWORD max = UINT_MAX;
  3105. LPCHARACTER pTarget = stone->second;
  3107. while (stone != f.m_mapStone.end())
  3108. {
  3109. DWORD dist = (DWORD)DISTANCE_SQRT(GetX()-stone->second->GetX(), GetY()-stone->second->GetY());
  3111. if (dist != 0 && max > dist)
  3112. {
  3113. max = dist;
  3114. pTarget = stone->second;
  3115. }
  3116. stone++;
  3117. }
  3119. if (pTarget != NULL)
  3120. {
  3121. int val = 3;
  3123. if (max < 10000) val = 2;
  3124. else if (max < 70000) val = 1;
  3126. ChatPacket(CHAT_TYPE_COMMAND, "StoneDetect %u %d %d", (DWORD)GetVID(), val,
  3127. (int)GetDegreeFromPositionXY(GetX(), pTarget->GetY(), pTarget->GetX(), GetY()));
  3128. }
  3129. else
  3130. {
  3131. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("감지기를 작용하였으나 감지되는 영석이 없습니다."));
  3132. }
  3133. }
  3134. else
  3135. {
  3136. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("감지기를 작용하였으나 감지되는 영석이 없습니다."));
  3137. }
  3139. if (item->GetSocket(0) >= 6)
  3140. {
  3141. ChatPacket(CHAT_TYPE_COMMAND, "StoneDetect %u 0 0", (DWORD)GetVID());
  3142. ITEM_MANAGER::instance().RemoveItem(item);
  3143. }
  3144. }
  3145. break;
  3146. }
  3147. break;
  3149. case 27996: // 독병
  3150. item->SetCount(item->GetCount() - 1);
  3151. /*if (GetSkillLevel(SKILL_CREATE_POISON))
  3152. AddAffect(AFFECT_ATT_GRADE, POINT_ATT_GRADE, 3, AFF_DRINK_POISON, 15*60, 0, true);
  3153. else
  3154. {
  3155. // 독다루기가 없으면 50% 즉사 50% 공격력 +2
  3156. if (number(0, 1))
  3157. {
  3158. if (GetHP() > 100)
  3159. PointChange(POINT_HP, -(GetHP() - 1));
  3160. else
  3161. Dead();
  3162. }
  3163. else
  3164. AddAffect(AFFECT_ATT_GRADE, POINT_ATT_GRADE, 2, AFF_DRINK_POISON, 15*60, 0, true);
  3165. }*/
  3166. break;
  3168. case 27987: // 조개
  3169. // 50 돌조각 47990
  3170. // 30 꽝
  3171. // 10 백진주 47992
  3172. // 7 청진주 47993
  3173. // 3 피진주 47994
  3174. {
  3175. item->SetCount(item->GetCount() - 1);
  3177. int r = number(1, 100);
  3179. if (r <= 50)
  3180. {
  3181. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 돌조각이 나왔습니다."));
  3182. AutoGiveItem(27990);
  3183. }
  3184. else
  3185. {
  3186. const int prob_table_euckr[] =
  3187. {
  3188. 80, 90, 97
  3189. };
  3191. const int prob_table_gb2312[] =
  3192. {
  3193. 95, 97, 99
  3194. };
  3196. const int * prob_table = !g_iUseLocale ? prob_table_euckr : prob_table_gb2312;
  3198. if (r <= prob_table[0])
  3199. {
  3200. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개가 흔적도 없이 사라집니다."));
  3201. }
  3202. else if (r <= prob_table[1])
  3203. {
  3204. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 백진주가 나왔습니다."));
  3205. AutoGiveItem(27992);
  3206. }
  3207. else if (r <= prob_table[2])
  3208. {
  3209. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 청진주가 나왔습니다."));
  3210. AutoGiveItem(27993);
  3211. }
  3212. else
  3213. {
  3214. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 피진주가 나왔습니다."));
  3215. AutoGiveItem(27994);
  3216. }
  3217. }
  3218. }
  3219. break;
  3221. case 71013: // 축제용폭죽
  3222. CreateFly(number(FLY_FIREWORK1, FLY_FIREWORK6), this);
  3223. item->SetCount(item->GetCount() - 1);
  3224. break;
  3226. case 50100: // 폭죽
  3227. case 50101:
  3228. case 50102:
  3229. case 50103:
  3230. case 50104:
  3231. case 50105:
  3232. case 50106:
  3233. CreateFly(item->GetVnum() - 50100 + FLY_FIREWORK1, this);
  3234. item->SetCount(item->GetCount() - 1);
  3235. break;
  3237. case 50200: // 보따리
  3238. if (LC_IsYMIR() == true || LC_IsKorea() == true)
  3239. {
  3240. if (IS_BOTARYABLE_ZONE(GetMapIndex()) == true)
  3241. {
  3242. __OpenPrivateShop();
  3243. }
  3244. else
  3245. {
  3246. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개인 상점을 열 수 없는 지역입니다"));
  3247. }
  3248. }
  3249. else
  3250. {
  3251. __OpenPrivateShop();
  3252. }
  3253. break;
  3255. case fishing::FISH_MIND_PILL_VNUM:
  3256. AddAffect(AFFECT_FISH_MIND_PILL, POINT_NONE, 0, AFF_FISH_MIND, 20*60, 0, true);
  3257. item->SetCount(item->GetCount() - 1);
  3258. break;
  3260. case 50301: // 통솔력 수련서
  3261. case 50302:
  3262. case 50303:
  3263. {
  3264. if (IsPolymorphed() == true)
  3265. {
  3266. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑 중에는 능력을 올릴 수 없습니다."));
  3267. return false;
  3268. }
  3270. int lv = GetSkillLevel(SKILL_LEADERSHIP);
  3272. if (lv < item->GetValue(0))
  3273. {
  3274. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책은 너무 어려워 이해하기가 힘듭니다."));
  3275. return false;
  3276. }
  3278. if (lv >= item->GetValue(1))
  3279. {
  3280. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책은 아무리 봐도 도움이 될 것 같지 않습니다."));
  3281. return false;
  3282. }
  3284. if (LearnSkillByBook(SKILL_LEADERSHIP))
  3285. {
  3286. ITEM_MANAGER::instance().RemoveItem(item);
  3288. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3289. if (distribution_test_server) iReadDelay /= 3;
  3291. SetSkillNextReadTime(SKILL_LEADERSHIP, get_global_time() + iReadDelay);
  3292. }
  3293. }
  3294. break;
  3296. case 50304: // 연계기 수련서
  3297. case 50305:
  3298. case 50306:
  3299. {
  3300. if (IsPolymorphed())
  3301. {
  3302. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3303. return false;
  3305. }
  3306. if (GetSkillLevel(SKILL_COMBO) == 0 && GetLevel() < 30)
  3307. {
  3308. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("레벨 30이 되기 전에는 습득할 수 있을 것 같지 않습니다."));
  3309. return false;
  3310. }
  3312. if (GetSkillLevel(SKILL_COMBO) == 1 && GetLevel() < 50)
  3313. {
  3314. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("레벨 50이 되기 전에는 습득할 수 있을 것 같지 않습니다."));
  3315. return false;
  3316. }
  3318. if (GetSkillLevel(SKILL_COMBO) >= 2)
  3319. {
  3320. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("연계기는 더이상 수련할 수 없습니다."));
  3321. return false;
  3322. }
  3324. int iPct = item->GetValue(0);
  3326. if (LearnSkillByBook(SKILL_COMBO, iPct))
  3327. {
  3328. ITEM_MANAGER::instance().RemoveItem(item);
  3330. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3331. if (distribution_test_server) iReadDelay /= 3;
  3333. SetSkillNextReadTime(SKILL_COMBO, get_global_time() + iReadDelay);
  3334. }
  3335. }
  3336. break;
  3337. case 50311: // 언어 수련서
  3338. case 50312:
  3339. case 50313:
  3340. {
  3341. if (IsPolymorphed())
  3342. {
  3343. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3344. return false;
  3346. }
  3347. DWORD dwSkillVnum = item->GetValue(0);
  3348. int iPct = MINMAX(0, item->GetValue(1), 100);
  3349. if (GetSkillLevel(dwSkillVnum)>=20 || dwSkillVnum-SKILL_LANGUAGE1+1 == GetEmpire())
  3350. {
  3351. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 완벽하게 알아들을 수 있는 언어이다."));
  3352. return false;
  3353. }
  3355. if (LearnSkillByBook(dwSkillVnum, iPct))
  3356. {
  3357. ITEM_MANAGER::instance().RemoveItem(item);
  3359. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3360. if (distribution_test_server) iReadDelay /= 3;
  3362. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3363. }
  3364. }
  3365. break;
  3367. case 50061 : // 일본 말 소환 스킬 수련서
  3368. {
  3369. if (IsPolymorphed())
  3370. {
  3371. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3372. return false;
  3374. }
  3375. DWORD dwSkillVnum = item->GetValue(0);
  3376. int iPct = MINMAX(0, item->GetValue(1), 100);
  3378. if (GetSkillLevel(dwSkillVnum) >= 10)
  3379. {
  3380. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
  3381. return false;
  3382. }
  3384. if (LearnSkillByBook(dwSkillVnum, iPct))
  3385. {
  3386. ITEM_MANAGER::instance().RemoveItem(item);
  3388. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3389. if (distribution_test_server) iReadDelay /= 3;
  3391. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3392. }
  3393. }
  3394. break;
  3396. case 50314: case 50315: case 50316: // 변신 수련서
  3397. case 50323: case 50324: // 증혈 수련서
  3398. case 50325: case 50326: // 철통 수련서
  3399. {
  3400. if (IsPolymorphed() == true)
  3401. {
  3402. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑 중에는 능력을 올릴 수 없습니다."));
  3403. return false;
  3404. }
  3406. int iSkillLevelLowLimit = item->GetValue(0);
  3407. int iSkillLevelHighLimit = item->GetValue(1);
  3408. int iPct = MINMAX(0, item->GetValue(2), 100);
  3409. int iLevelLimit = item->GetValue(3);
  3410. DWORD dwSkillVnum = 0;
  3412. switch (item->GetVnum())
  3413. {
  3414. case 50314: case 50315: case 50316:
  3415. dwSkillVnum = SKILL_POLYMORPH;
  3416. break;
  3418. case 50323: case 50324:
  3419. dwSkillVnum = SKILL_ADD_HP;
  3420. break;
  3422. case 50325: case 50326:
  3423. dwSkillVnum = SKILL_RESIST_PENETRATE;
  3424. break;
  3426. default:
  3427. return false;
  3428. }
  3430. if (0 == dwSkillVnum)
  3431. return false;
  3433. if (GetLevel() < iLevelLimit)
  3434. {
  3435. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책을 읽으려면 레벨을 더 올려야 합니다."));
  3436. return false;
  3437. }
  3439. if (GetSkillLevel(dwSkillVnum) >= 40)
  3440. {
  3441. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
  3442. return false;
  3443. }
  3445. if (GetSkillLevel(dwSkillVnum) < iSkillLevelLowLimit)
  3446. {
  3447. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책은 너무 어려워 이해하기가 힘듭니다."));
  3448. return false;
  3449. }
  3451. if (GetSkillLevel(dwSkillVnum) >= iSkillLevelHighLimit)
  3452. {
  3453. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책으로는 더 이상 수련할 수 없습니다."));
  3454. return false;
  3455. }
  3457. if (LearnSkillByBook(dwSkillVnum, iPct))
  3458. {
  3459. ITEM_MANAGER::instance().RemoveItem(item);
  3461. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3462. if (distribution_test_server) iReadDelay /= 3;
  3464. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3465. }
  3466. }
  3467. break;
  3469. case 50902:
  3470. case 50903:
  3471. case 50904:
  3472. {
  3473. if (IsPolymorphed())
  3474. {
  3475. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3476. return false;
  3478. }
  3479. DWORD dwSkillVnum = SKILL_CREATE;
  3480. int iPct = MINMAX(0, item->GetValue(1), 100);
  3482. if (GetSkillLevel(dwSkillVnum)>=40)
  3483. {
  3484. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
  3485. return false;
  3486. }
  3488. if (LearnSkillByBook(dwSkillVnum, iPct))
  3489. {
  3490. ITEM_MANAGER::instance().RemoveItem(item);
  3492. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3493. if (distribution_test_server) iReadDelay /= 3;
  3495. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3497. if (test_server)
  3498. {
  3499. ChatPacket(CHAT_TYPE_INFO, "[TEST_SERVER] Success to learn skill ");
  3500. }
  3501. }
  3502. else
  3503. {
  3504. if (test_server)
  3505. {
  3506. ChatPacket(CHAT_TYPE_INFO, "[TEST_SERVER] Failed to learn skill ");
  3507. }
  3508. }
  3509. }
  3510. break;
  3512. // MINING
  3513. case ITEM_MINING_SKILL_TRAIN_BOOK:
  3514. {
  3515. if (IsPolymorphed())
  3516. {
  3517. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3518. return false;
  3520. }
  3521. DWORD dwSkillVnum = SKILL_MINING;
  3522. int iPct = MINMAX(0, item->GetValue(1), 100);
  3524. if (GetSkillLevel(dwSkillVnum)>=40)
  3525. {
  3526. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
  3527. return false;
  3528. }
  3530. if (LearnSkillByBook(dwSkillVnum, iPct))
  3531. {
  3532. ITEM_MANAGER::instance().RemoveItem(item);
  3534. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3535. if (distribution_test_server) iReadDelay /= 3;
  3537. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3538. }
  3539. }
  3540. break;
  3541. // END_OF_MINING
  3543. case ITEM_HORSE_SKILL_TRAIN_BOOK:
  3544. {
  3545. if (IsPolymorphed())
  3546. {
  3547. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3548. return false;
  3550. }
  3551. DWORD dwSkillVnum = SKILL_HORSE;
  3552. int iPct = MINMAX(0, item->GetValue(1), 100);
  3554. if (GetLevel() < 50)
  3555. {
  3556. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 승마 스킬을 수련할 수 있는 레벨이 아닙니다."));
  3557. return false;
  3558. }
  3560. if (!test_server && get_global_time() < GetSkillNextReadTime(dwSkillVnum))
  3561. {
  3562. if (FindAffect(AFFECT_SKILL_NO_BOOK_DELAY))
  3563. {
  3564. // 주안술서 사용중에는 시간 제한 무시
  3565. RemoveAffect(AFFECT_SKILL_NO_BOOK_DELAY);
  3566. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("주안술서를 통해 주화입마에서 빠져나왔습니다."));
  3567. }
  3568. else
  3569. {
  3570. SkillLearnWaitMoreTimeMessage(GetSkillNextReadTime(dwSkillVnum) - get_global_time());
  3571. return false;
  3572. }
  3573. }
  3575. if (GetPoint(POINT_HORSE_SKILL) >= 20 ||
  3576. GetSkillLevel(SKILL_HORSE_WILDATTACK) + GetSkillLevel(SKILL_HORSE_CHARGE) + GetSkillLevel(SKILL_HORSE_ESCAPE) >= 60 ||
  3577. GetSkillLevel(SKILL_HORSE_WILDATTACK_RANGE) + GetSkillLevel(SKILL_HORSE_CHARGE) + GetSkillLevel(SKILL_HORSE_ESCAPE) >= 60)
  3578. {
  3579. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 승마 수련서를 읽을 수 없습니다."));
  3580. return false;
  3581. }
  3583. if (number(1, 100) <= iPct)
  3584. {
  3585. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("승마 수련서를 읽어 승마 스킬 포인트를 얻었습니다."));
  3586. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("얻은 포인트로는 승마 스킬의 레벨을 올릴 수 있습니다."));
  3587. PointChange(POINT_HORSE_SKILL, 1);
  3589. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3590. if (distribution_test_server) iReadDelay /= 3;
  3592. if (!test_server)
  3593. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3594. }
  3595. else
  3596. {
  3597. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("승마 수련서 이해에 실패하였습니다."));
  3598. }
  3600. ITEM_MANAGER::instance().RemoveItem(item);
  3601. }
  3602. break;
  3604. case 70102: // 선두
  3605. case 70103: // 선두
  3606. {
  3607. if (GetAlignment() >= 0)
  3608. return false;
  3610. int delta = MIN(-GetAlignment(), item->GetValue(0));
  3612. sys_log(0, "%s ALIGNMENT ITEM %d", GetName(), delta);
  3614. UpdateAlignment(delta);
  3615. item->SetCount(item->GetCount() - 1);
  3617. if (delta / 10 > 0)
  3618. {
  3619. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("마음이 맑아지는군. 가슴을 짓누르던 무언가가 좀 가벼워진 느낌이야."));
  3620. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("선악치가 %d 증가하였습니다."), delta/10);
  3621. }
  3622. }
  3623. break;
  3625. case 71107: // 천도복숭아
  3626. {
  3627. int val = item->GetValue(0);
  3628. int interval = item->GetValue(1);
  3629. quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetPlayerID());
  3630. int last_use_time = pPC->GetFlag("mythical_peach.last_use_time");
  3632. if (get_global_time() - last_use_time < interval * 60 * 60)
  3633. {
  3634. if (test_server == false)
  3635. {
  3636. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 사용할 수 없습니다."));
  3637. return false;
  3638. }
  3639. else
  3640. {
  3641. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("테스트 서버 시간제한 통과"));
  3642. }
  3643. }
  3645. if (GetAlignment() == 200000)
  3646. {
  3647. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("선악치를 더 이상 올릴 수 없습니다."));
  3648. return false;
  3649. }
  3651. if (200000 - GetAlignment() < val * 10)
  3652. {
  3653. val = (200000 - GetAlignment()) / 10;
  3654. }
  3656. int old_alignment = GetAlignment() / 10;
  3658. UpdateAlignment(val*10);
  3660. item->SetCount(item->GetCount()-1);
  3661. pPC->SetFlag("mythical_peach.last_use_time", get_global_time());
  3663. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("마음이 맑아지는군. 가슴을 짓누르던 무언가가 좀 가벼워진 느낌이야."));
  3664. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("선악치가 %d 증가하였습니다."), val);
  3666. char buf[256 + 1];
  3667. snprintf(buf, sizeof(buf), "%d %d", old_alignment, GetAlignment() / 10);
  3668. LogManager::instance().CharLog(this, val, "MYTHICAL_PEACH", buf);
  3669. }
  3670. break;
  3672. case 71109: // 탈석서
  3673. case 72719:
  3674. {
  3675. LPITEM item2;
  3677. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  3678. return false;
  3680. if (item2->IsExchanging() == true)
  3681. return false;
  3683. if (item2->GetSocketCount() == 0)
  3684. return false;
  3686. switch( item2->GetType() )
  3687. {
  3688. case ITEM_WEAPON:
  3689. break;
  3690. case ITEM_ARMOR:
  3691. switch (item2->GetSubType())
  3692. {
  3693. case ARMOR_EAR:
  3694. case ARMOR_WRIST:
  3695. case ARMOR_NECK:
  3696. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빼낼 영석이 없습니다"));
  3697. return false;
  3698. }
  3699. break;
  3701. default:
  3702. return false;
  3703. }
  3705. std::stack<long> socket;
  3707. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  3708. socket.push(item2->GetSocket(i));
  3710. int idx = ITEM_SOCKET_MAX_NUM - 1;
  3712. while (socket.size() > 0)
  3713. {
  3714. if (socket.top() > 2 && socket.top() != ITEM_BROKEN_METIN_VNUM)
  3715. break;
  3717. idx--;
  3718. socket.pop();
  3719. }
  3721. if (socket.size() == 0)
  3722. {
  3723. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빼낼 영석이 없습니다"));
  3724. return false;
  3725. }
  3727. LPITEM pItemReward = AutoGiveItem(socket.top());
  3729. if (pItemReward != NULL)
  3730. {
  3731. item2->SetSocket(idx, 1);
  3733. char buf[256+1];
  3734. snprintf(buf, sizeof(buf), "%s(%u) %s(%u)",
  3735. item2->GetName(), item2->GetID(), pItemReward->GetName(), pItemReward->GetID());
  3736. LogManager::instance().ItemLog(this, item, "USE_DETACHMENT_ONE", buf);
  3738. item->SetCount(item->GetCount() - 1);
  3739. }
  3740. }
  3741. break;
  3743. case 70201: // 탈색제
  3744. case 70202: // 염색약(흰색)
  3745. case 70203: // 염색약(금색)
  3746. case 70204: // 염색약(빨간색)
  3747. case 70205: // 염색약(갈색)
  3748. case 70206: // 염색약(검은색)
  3749. {
  3750. // NEW_HAIR_STYLE_ADD
  3751. if (GetPart(PART_HAIR) >= 1001)
  3752. {
  3753. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("현재 헤어스타일에서는 염색과 탈색이 불가능합니다."));
  3754. }
  3755. // END_NEW_HAIR_STYLE_ADD
  3756. else
  3757. {
  3758. quest::CQuestManager& q = quest::CQuestManager::instance();
  3759. quest::PC* pPC = q.GetPC(GetPlayerID());
  3761. if (pPC)
  3762. {
  3763. int last_dye_level = pPC->GetFlag("dyeing_hair.last_dye_level");
  3765. if (last_dye_level == 0 ||
  3766. last_dye_level+3 <= GetLevel() ||
  3767. item->GetVnum() == 70201)
  3768. {
  3769. SetPart(PART_HAIR, item->GetVnum() - 70201);
  3771. if (item->GetVnum() == 70201)
  3772. pPC->SetFlag("dyeing_hair.last_dye_level", 0);
  3773. else
  3774. pPC->SetFlag("dyeing_hair.last_dye_level", GetLevel());
  3776. item->SetCount(item->GetCount() - 1);
  3777. UpdatePacket();
  3778. }
  3779. else
  3780. {
  3781. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d 레벨이 되어야 다시 염색하실 수 있습니다."), last_dye_level+3);
  3782. }
  3783. }
  3784. }
  3785. }
  3786. break;
  3788. case ITEM_NEW_YEAR_GREETING_VNUM:
  3789. {
  3790. DWORD dwBoxVnum = ITEM_NEW_YEAR_GREETING_VNUM;
  3791. std::vector <DWORD> dwVnums;
  3792. std::vector <DWORD> dwCounts;
  3793. std::vector <LPITEM> item_gets;
  3794. int count = 0;
  3796. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  3797. {
  3798. for (int i = 0; i < count; i++)
  3799. {
  3800. if (dwVnums[i] == CSpecialItemGroup::GOLD)
  3801. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  3802. }
  3804. item->SetCount(item->GetCount() - 1);
  3805. }
  3806. }
  3807. break;
  3809. case ITEM_VALENTINE_ROSE:
  3810. case ITEM_VALENTINE_CHOCOLATE:
  3811. {
  3812. DWORD dwBoxVnum = item->GetVnum();
  3813. std::vector <DWORD> dwVnums;
  3814. std::vector <DWORD> dwCounts;
  3815. std::vector <LPITEM> item_gets(NULL);
  3816. int count = 0;
  3819. if (item->GetVnum() == ITEM_VALENTINE_ROSE && SEX_MALE==GET_SEX(this) ||
  3820. item->GetVnum() == ITEM_VALENTINE_CHOCOLATE && SEX_FEMALE==GET_SEX(this))
  3821. {
  3822. // 성별이 맞지않아 쓸 수 없다.
  3823. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 열 수 없습니다."));
  3824. return false;
  3825. }
  3828. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  3829. item->SetCount(item->GetCount()-1);
  3830. }
  3831. break;
  3833. case ITEM_WHITEDAY_CANDY:
  3834. case ITEM_WHITEDAY_ROSE:
  3835. {
  3836. DWORD dwBoxVnum = item->GetVnum();
  3837. std::vector <DWORD> dwVnums;
  3838. std::vector <DWORD> dwCounts;
  3839. std::vector <LPITEM> item_gets(NULL);
  3840. int count = 0;
  3843. if (item->GetVnum() == ITEM_WHITEDAY_CANDY && SEX_MALE==GET_SEX(this) ||
  3844. item->GetVnum() == ITEM_WHITEDAY_ROSE && SEX_FEMALE==GET_SEX(this))
  3845. {
  3846. // 성별이 맞지않아 쓸 수 없다.
  3847. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 열 수 없습니다."));
  3848. return false;
  3849. }
  3852. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  3853. item->SetCount(item->GetCount()-1);
  3854. }
  3855. break;
  3857. case 50011: // 월광보합
  3858. {
  3859. DWORD dwBoxVnum = 50011;
  3860. std::vector <DWORD> dwVnums;
  3861. std::vector <DWORD> dwCounts;
  3862. std::vector <LPITEM> item_gets(NULL);
  3863. int count = 0;
  3865. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  3866. {
  3867. for (int i = 0; i < count; i++)
  3868. {
  3869. char buf[50 + 1];
  3870. snprintf(buf, sizeof(buf), "%u %u", dwVnums[i], dwCounts[i]);
  3871. LogManager::instance().ItemLog(this, item, "MOONLIGHT_GET", buf);
  3873. //ITEM_MANAGER::instance().RemoveItem(item);
  3874. item->SetCount(item->GetCount() - 1);
  3876. switch (dwVnums[i])
  3877. {
  3878. case CSpecialItemGroup::GOLD:
  3879. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  3880. break;
  3882. case CSpecialItemGroup::EXP:
  3883. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
  3884. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
  3885. break;
  3887. case CSpecialItemGroup::MOB:
  3888. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  3889. break;
  3891. case CSpecialItemGroup::SLOW:
  3892. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 빨간 연기를 들이마시자 움직이는 속도가 느려졌습니다!"));
  3893. break;
  3895. case CSpecialItemGroup::DRAIN_HP:
  3896. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자가 갑자기 폭발하였습니다! 생명력이 감소했습니다."));
  3897. break;
  3899. case CSpecialItemGroup::POISON:
  3900. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  3901. break;
  3903. case CSpecialItemGroup::MOB_GROUP:
  3904. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  3905. break;
  3907. default:
  3908. if (item_gets[i])
  3909. {
  3910. if (dwCounts[i] > 1)
  3911. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
  3912. else
  3913. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
  3914. }
  3915. break;
  3916. }
  3917. }
  3918. }
  3919. else
  3920. {
  3921. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("아무것도 얻을 수 없었습니다."));
  3922. return false;
  3923. }
  3924. }
  3925. break;
  3927. case ITEM_GIVE_STAT_RESET_COUNT_VNUM:
  3928. {
  3929. //PointChange(POINT_GOLD, -iCost);
  3930. PointChange(POINT_STAT_RESET_COUNT, 1);
  3931. item->SetCount(item->GetCount()-1);
  3932. }
  3933. break;
  3935. case 50107:
  3936. {
  3937. EffectPacket(SE_CHINA_FIREWORK);
  3938. // 스턴 공격을 올려준다
  3939. AddAffect(AFFECT_CHINA_FIREWORK, POINT_STUN_PCT, 30, AFF_CHINA_FIREWORK, 5*60, 0, true);
  3940. item->SetCount(item->GetCount()-1);
  3941. }
  3942. break;
  3944. case 50108:
  3945. {
  3946. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  3947. {
  3948. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  3949. return false;
  3950. }
  3952. EffectPacket(SE_SPIN_TOP);
  3953. // 스턴 공격을 올려준다
  3954. AddAffect(AFFECT_CHINA_FIREWORK, POINT_STUN_PCT, 30, AFF_CHINA_FIREWORK, 5*60, 0, true);
  3955. item->SetCount(item->GetCount()-1);
  3956. }
  3957. break;
  3959. case ITEM_WONSO_BEAN_VNUM:
  3960. PointChange(POINT_HP, GetMaxHP() - GetHP());
  3961. item->SetCount(item->GetCount()-1);
  3962. break;
  3964. case ITEM_WONSO_SUGAR_VNUM:
  3965. PointChange(POINT_SP, GetMaxSP() - GetSP());
  3966. item->SetCount(item->GetCount()-1);
  3967. break;
  3969. case ITEM_WONSO_FRUIT_VNUM:
  3970. PointChange(POINT_STAMINA, GetMaxStamina()-GetStamina());
  3971. item->SetCount(item->GetCount()-1);
  3972. break;
  3974. case 90008: // VCARD
  3975. case 90009: // VCARD
  3976. VCardUse(this, this, item);
  3977. break;
  3979. case ITEM_ELK_VNUM: // 돈꾸러미
  3980. {
  3981. int iGold = item->GetSocket(0);
  3982. ITEM_MANAGER::instance().RemoveItem(item);
  3983. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), iGold);
  3984. PointChange(POINT_GOLD, iGold);
  3985. }
  3986. break;
  3988. //군주의 증표
  3989. case 70021:
  3990. {
  3991. int HealPrice = quest::CQuestManager::instance().GetEventFlag("MonarchHealGold");
  3992. if (HealPrice == 0)
  3993. HealPrice = 2000000;
  3995. if (CMonarch::instance().HealMyEmpire(this, HealPrice))
  3996. {
  3997. char szNotice[256];
  3998. snprintf(szNotice, sizeof(szNotice), LC_TEXT("군주의 축복으로 이지역 %s 유저는 HP,SP가 모두 채워집니다."), EMPIRE_NAME(GetEmpire()));
  3999. SendNoticeMap(szNotice, GetMapIndex(), false);
  4001. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("군주의 축복을 사용하였습니다."));
  4002. }
  4003. }
  4004. break;
  4006. case 27995:
  4007. {
  4008. }
  4009. break;
  4011. case 71092 : // 변신 해체부 임시
  4012. {
  4013. if (m_pkChrTarget != NULL)
  4014. {
  4015. if (m_pkChrTarget->IsPolymorphed())
  4016. {
  4017. m_pkChrTarget->SetPolymorph(0);
  4018. m_pkChrTarget->RemoveAffect(AFFECT_POLYMORPH);
  4019. }
  4020. }
  4021. else
  4022. {
  4023. if (IsPolymorphed())
  4024. {
  4025. SetPolymorph(0);
  4026. RemoveAffect(AFFECT_POLYMORPH);
  4027. }
  4028. }
  4029. }
  4030. break;
  4032. case 71051 : // 진재가
  4033. {
  4034. // 유럽, 싱가폴, 베트남 진재가 사용금지
  4035. if (LC_IsEurope() || LC_IsSingapore() || LC_IsVietnam())
  4036. return false;
  4038. LPITEM item2;
  4040. if (!IsValidItemPosition(DestCell) || !(item2 = GetInventoryItem(wDestCell)))
  4041. return false;
  4043. if (item2->IsExchanging() == true)
  4044. return false;
  4046. if (item2->GetType() == ITEM_COSTUME)
  4047. {
  4048. return false;
  4049. }
  4051. if (item2->GetAttributeSetIndex() == -1)
  4052. {
  4053. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  4054. return false;
  4055. }
  4057. if (item2->AddRareAttribute() == true)
  4058. {
  4059. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성공적으로 속성이 추가 되었습니다"));
  4061. int iAddedIdx = item2->GetRareAttrCount() + 4;
  4062. char buf[21];
  4063. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4065. LogManager::instance().ItemLog(
  4066. GetPlayerID(),
  4067. item2->GetAttributeType(iAddedIdx),
  4068. item2->GetAttributeValue(iAddedIdx),
  4069. item->GetID(),
  4070. "ADD_RARE_ATTR",
  4071. buf,
  4072. GetDesc()->GetHostName(),
  4073. item->GetOriginalVnum());
  4075. item->SetCount(item->GetCount() - 1);
  4076. }
  4077. else
  4078. {
  4079. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 이 아이템으로 속성을 추가할 수 없습니다"));
  4080. }
  4081. }
  4082. break;
  4084. case 71052 : // 진재경
  4085. {
  4086. // 유럽, 싱가폴, 베트남 진재가 사용금지
  4087. if (LC_IsEurope() || LC_IsSingapore() || LC_IsVietnam())
  4088. return false;
  4090. LPITEM item2;
  4092. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  4093. return false;
  4095. if (item2->IsExchanging() == true)
  4096. return false;
  4098. if (item2->GetType() == ITEM_COSTUME)
  4099. {
  4100. return false;
  4101. }
  4103. if (item2->GetAttributeSetIndex() == -1)
  4104. {
  4105. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  4106. return false;
  4107. }
  4109. if (item2->ChangeRareAttribute() == true)
  4110. {
  4111. char buf[21];
  4112. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4113. LogManager::instance().ItemLog(this, item, "CHANGE_RARE_ATTR", buf);
  4115. item->SetCount(item->GetCount() - 1);
  4116. }
  4117. else
  4118. {
  4119. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변경 시킬 속성이 없습니다"));
  4120. }
  4121. }
  4122. break;
  4124. case ITEM_AUTO_HP_RECOVERY_S:
  4125. case ITEM_AUTO_HP_RECOVERY_M:
  4126. case ITEM_AUTO_HP_RECOVERY_L:
  4127. case ITEM_AUTO_HP_RECOVERY_X:
  4128. case ITEM_AUTO_SP_RECOVERY_S:
  4129. case ITEM_AUTO_SP_RECOVERY_M:
  4130. case ITEM_AUTO_SP_RECOVERY_L:
  4131. case ITEM_AUTO_SP_RECOVERY_X:
  4132. // 무시무시하지만 이전에 하던 걸 고치기는 무섭고...
  4133. // 그래서 그냥 하드 코딩. 선물 상자용 자동물약 아이템들.
  4134. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_XS:
  4135. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_S:
  4136. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_XS:
  4137. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_S:
  4138. case FUCKING_BRAZIL_ITEM_AUTO_SP_RECOVERY_S:
  4139. case FUCKING_BRAZIL_ITEM_AUTO_HP_RECOVERY_S:
  4140. {
  4141. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  4142. {
  4143. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  4144. return false;
  4145. }
  4147. EAffectTypes type = AFFECT_NONE;
  4148. bool isSpecialPotion = false;
  4150. switch (item->GetVnum())
  4151. {
  4152. case ITEM_AUTO_HP_RECOVERY_X:
  4153. isSpecialPotion = true;
  4155. case ITEM_AUTO_HP_RECOVERY_S:
  4156. case ITEM_AUTO_HP_RECOVERY_M:
  4157. case ITEM_AUTO_HP_RECOVERY_L:
  4158. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_XS:
  4159. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_S:
  4160. case FUCKING_BRAZIL_ITEM_AUTO_HP_RECOVERY_S:
  4161. type = AFFECT_AUTO_HP_RECOVERY;
  4162. break;
  4164. case ITEM_AUTO_SP_RECOVERY_X:
  4165. isSpecialPotion = true;
  4167. case ITEM_AUTO_SP_RECOVERY_S:
  4168. case ITEM_AUTO_SP_RECOVERY_M:
  4169. case ITEM_AUTO_SP_RECOVERY_L:
  4170. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_XS:
  4171. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_S:
  4172. case FUCKING_BRAZIL_ITEM_AUTO_SP_RECOVERY_S:
  4173. type = AFFECT_AUTO_SP_RECOVERY;
  4174. break;
  4175. }
  4177. if (AFFECT_NONE == type)
  4178. break;
  4180. if (item->GetCount() > 1)
  4181. {
  4182. int pos = GetEmptyInventory(item->GetSize());
  4184. if (-1 == pos)
  4185. {
  4186. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지품에 빈 공간이 없습니다."));
  4187. break;
  4188. }
  4190. item->SetCount( item->GetCount() - 1 );
  4192. LPITEM item2 = ITEM_MANAGER::instance().CreateItem( item->GetVnum(), 1 );
  4193. item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
  4195. if (item->GetSocket(1) != 0)
  4196. {
  4197. item2->SetSocket(1, item->GetSocket(1));
  4198. }
  4200. item = item2;
  4201. }
  4203. CAffect* pAffect = FindAffect( type );
  4205. if (NULL == pAffect)
  4206. {
  4207. EPointTypes bonus = POINT_NONE;
  4209. if (true == isSpecialPotion)
  4210. {
  4211. if (type == AFFECT_AUTO_HP_RECOVERY)
  4212. {
  4213. bonus = POINT_MAX_HP_PCT;
  4214. }
  4215. else if (type == AFFECT_AUTO_SP_RECOVERY)
  4216. {
  4217. bonus = POINT_MAX_SP_PCT;
  4218. }
  4219. }
  4221. AddAffect( type, bonus, 4, item->GetID(), INFINITE_AFFECT_DURATION, 0, true, false);
  4223. item->Lock(true);
  4224. item->SetSocket(0, true);
  4226. AutoRecoveryItemProcess( type );
  4227. }
  4228. else
  4229. {
  4230. if (item->GetID() == pAffect->dwFlag)
  4231. {
  4232. RemoveAffect( pAffect );
  4234. item->Lock(false);
  4235. item->SetSocket(0, false);
  4236. }
  4237. else
  4238. {
  4239. LPITEM old = FindItemByID( pAffect->dwFlag );
  4241. if (NULL != old)
  4242. {
  4243. old->Lock(false);
  4244. old->SetSocket(0, false);
  4245. }
  4247. RemoveAffect( pAffect );
  4249. EPointTypes bonus = POINT_NONE;
  4251. if (true == isSpecialPotion)
  4252. {
  4253. if (type == AFFECT_AUTO_HP_RECOVERY)
  4254. {
  4255. bonus = POINT_MAX_HP_PCT;
  4256. }
  4257. else if (type == AFFECT_AUTO_SP_RECOVERY)
  4258. {
  4259. bonus = POINT_MAX_SP_PCT;
  4260. }
  4261. }
  4263. AddAffect( type, bonus, 4, item->GetID(), INFINITE_AFFECT_DURATION, 0, true, false);
  4265. item->Lock(true);
  4266. item->SetSocket(0, true);
  4268. AutoRecoveryItemProcess( type );
  4269. }
  4270. }
  4271. }
  4272. break;
  4273. }
  4274. break;
  4276. case USE_CLEAR:
  4277. {
  4278. RemoveBadAffect();
  4279. item->SetCount(item->GetCount() - 1);
  4280. }
  4281. break;
  4283. case USE_INVISIBILITY:
  4284. {
  4285. if (item->GetVnum() == 70026)
  4286. {
  4287. quest::CQuestManager& q = quest::CQuestManager::instance();
  4288. quest::PC* pPC = q.GetPC(GetPlayerID());
  4290. if (pPC != NULL)
  4291. {
  4292. int last_use_time = pPC->GetFlag("mirror_of_disapper.last_use_time");
  4294. if (get_global_time() - last_use_time < 10*60)
  4295. {
  4296. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 사용할 수 없습니다."));
  4297. return false;
  4298. }
  4300. pPC->SetFlag("mirror_of_disapper.last_use_time", get_global_time());
  4301. }
  4302. }
  4304. AddAffect(AFFECT_INVISIBILITY, POINT_NONE, 0, AFF_INVISIBILITY, 300, 0, true);
  4305. item->SetCount(item->GetCount() - 1);
  4306. }
  4307. break;
  4309. case USE_POTION_NODELAY:
  4310. {
  4311. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  4312. {
  4313. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
  4314. {
  4315. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  4316. return false;
  4317. }
  4319. switch (item->GetVnum())
  4320. {
  4321. case 70020 :
  4322. case 71018 :
  4323. case 71019 :
  4324. case 71020 :
  4325. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
  4326. {
  4327. if (m_nPotionLimit <= 0)
  4328. {
  4329. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용 제한량을 초과하였습니다."));
  4330. return false;
  4331. }
  4332. }
  4333. break;
  4335. default :
  4336. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  4337. return false;
  4338. }
  4339. }
  4341. bool used = false;
  4343. if (item->GetValue(0) != 0) // HP 절대값 회복
  4344. {
  4345. if (GetHP() < GetMaxHP())
  4346. {
  4347. PointChange(POINT_HP, item->GetValue(0) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  4348. EffectPacket(SE_HPUP_RED);
  4349. used = TRUE;
  4350. }
  4351. }
  4353. if (item->GetValue(1) != 0) // SP 절대값 회복
  4354. {
  4355. if (GetSP() < GetMaxSP())
  4356. {
  4357. PointChange(POINT_SP, item->GetValue(1) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  4358. EffectPacket(SE_SPUP_BLUE);
  4359. used = TRUE;
  4360. }
  4361. }
  4363. if (item->GetValue(3) != 0) // HP % 회복
  4364. {
  4365. if (GetHP() < GetMaxHP())
  4366. {
  4367. PointChange(POINT_HP, item->GetValue(3) * GetMaxHP() / 100);
  4368. EffectPacket(SE_HPUP_RED);
  4369. used = TRUE;
  4370. }
  4371. }
  4373. if (item->GetValue(4) != 0) // SP % 회복
  4374. {
  4375. if (GetSP() < GetMaxSP())
  4376. {
  4377. PointChange(POINT_SP, item->GetValue(4) * GetMaxSP() / 100);
  4378. EffectPacket(SE_SPUP_BLUE);
  4379. used = TRUE;
  4380. }
  4381. }
  4383. if (used)
  4384. {
  4385. if (item->GetVnum() == 50085 || item->GetVnum() == 50086)
  4386. {
  4387. if (test_server)
  4388. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("월병 또는 종자 를 사용하였습니다"));
  4389. SetUseSeedOrMoonBottleTime();
  4390. }
  4391. if (GetDungeon())
  4392. GetDungeon()->UsePotion(this);
  4394. if (GetWarMap())
  4395. GetWarMap()->UsePotion(this, item);
  4397. m_nPotionLimit--;
  4399. //RESTRICT_USE_SEED_OR_MOONBOTTLE
  4400. item->SetCount(item->GetCount() - 1);
  4401. //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
  4402. }
  4403. }
  4404. break;
  4406. case USE_POTION:
  4407. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  4408. {
  4409. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
  4410. {
  4411. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  4412. return false;
  4413. }
  4415. switch (item->GetVnum())
  4416. {
  4417. case 27001 :
  4418. case 27002 :
  4419. case 27003 :
  4420. case 27004 :
  4421. case 27005 :
  4422. case 27006 :
  4423. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
  4424. {
  4425. if (m_nPotionLimit <= 0)
  4426. {
  4427. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용 제한량을 초과하였습니다."));
  4428. return false;
  4429. }
  4430. }
  4431. break;
  4433. default :
  4434. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  4435. return false;
  4436. }
  4437. }
  4439. if (item->GetValue(1) != 0)
  4440. {
  4441. if (GetPoint(POINT_SP_RECOVERY) + GetSP() >= GetMaxSP())
  4442. {
  4443. return false;
  4444. }
  4446. PointChange(POINT_SP_RECOVERY, item->GetValue(1) * MIN(200, (100 + GetPoint(POINT_POTION_BONUS))) / 100);
  4447. StartAffectEvent();
  4448. EffectPacket(SE_SPUP_BLUE);
  4449. }
  4451. if (item->GetValue(0) != 0)
  4452. {
  4453. if (GetPoint(POINT_HP_RECOVERY) + GetHP() >= GetMaxHP())
  4454. {
  4455. return false;
  4456. }
  4458. PointChange(POINT_HP_RECOVERY, item->GetValue(0) * MIN(200, (100 + GetPoint(POINT_POTION_BONUS))) / 100);
  4459. StartAffectEvent();
  4460. EffectPacket(SE_HPUP_RED);
  4461. }
  4463. if (GetDungeon())
  4464. GetDungeon()->UsePotion(this);
  4466. if (GetWarMap())
  4467. GetWarMap()->UsePotion(this, item);
  4469. item->SetCount(item->GetCount() - 1);
  4470. m_nPotionLimit--;
  4471. break;
  4473. case USE_POTION_CONTINUE:
  4474. {
  4475. if (item->GetValue(0) != 0)
  4476. {
  4477. AddAffect(AFFECT_HP_RECOVER_CONTINUE, POINT_HP_RECOVER_CONTINUE, item->GetValue(0), 0, item->GetValue(2), 0, true);
  4478. }
  4479. else if (item->GetValue(1) != 0)
  4480. {
  4481. AddAffect(AFFECT_SP_RECOVER_CONTINUE, POINT_SP_RECOVER_CONTINUE, item->GetValue(1), 0, item->GetValue(2), 0, true);
  4482. }
  4483. else
  4484. return false;
  4485. }
  4487. if (GetDungeon())
  4488. GetDungeon()->UsePotion(this);
  4490. if (GetWarMap())
  4491. GetWarMap()->UsePotion(this, item);
  4493. item->SetCount(item->GetCount() - 1);
  4494. break;
  4496. case USE_ABILITY_UP:
  4497. {
  4498. switch (item->GetValue(0))
  4499. {
  4500. case APPLY_MOV_SPEED:
  4501. EffectPacket(SE_DXUP_PURPLE); //purple potion
  4502. AddAffect(AFFECT_MOV_SPEED, POINT_MOV_SPEED, item->GetValue(2), AFF_MOV_SPEED_POTION, item->GetValue(1), 0, true);
  4503. break;
  4505. case APPLY_ATT_SPEED:
  4506. AddAffect(AFFECT_ATT_SPEED, POINT_ATT_SPEED, item->GetValue(2), AFF_ATT_SPEED_POTION, item->GetValue(1), 0, true);
  4507. EffectPacket(SE_SPEEDUP_GREEN); //green potion
  4508. break;
  4510. case APPLY_STR:
  4511. AddAffect(AFFECT_STR, POINT_ST, item->GetValue(2), 0, item->GetValue(1), 0, true);
  4512. break;
  4514. case APPLY_DEX:
  4515. AddAffect(AFFECT_DEX, POINT_DX, item->GetValue(2), 0, item->GetValue(1), 0, true);
  4516. break;
  4518. case APPLY_CON:
  4519. AddAffect(AFFECT_CON, POINT_HT, item->GetValue(2), 0, item->GetValue(1), 0, true);
  4520. break;
  4522. case APPLY_INT:
  4523. AddAffect(AFFECT_INT, POINT_IQ, item->GetValue(2), 0, item->GetValue(1), 0, true);
  4524. break;
  4526. case APPLY_CAST_SPEED:
  4527. AddAffect(AFFECT_CAST_SPEED, POINT_CASTING_SPEED, item->GetValue(2), 0, item->GetValue(1), 0, true);
  4528. break;
  4530. case APPLY_ATT_GRADE_BONUS:
  4531. AddAffect(AFFECT_ATT_GRADE, POINT_ATT_GRADE_BONUS,
  4532. item->GetValue(2), 0, item->GetValue(1), 0, true);
  4533. break;
  4535. case APPLY_DEF_GRADE_BONUS:
  4536. AddAffect(AFFECT_DEF_GRADE, POINT_DEF_GRADE_BONUS,
  4537. item->GetValue(2), 0, item->GetValue(1), 0, true);
  4538. break;
  4539. }
  4540. }
  4542. if (GetDungeon())
  4543. GetDungeon()->UsePotion(this);
  4545. if (GetWarMap())
  4546. GetWarMap()->UsePotion(this, item);
  4548. item->SetCount(item->GetCount() - 1);
  4549. break;
  4551. case USE_TALISMAN:
  4552. {
  4553. const int TOWN_PORTAL = 1;
  4554. const int MEMORY_PORTAL = 2;
  4557. // gm_guild_build, oxevent 맵에서 귀환부 귀환기억부 를 사용못하게 막음
  4558. if (GetMapIndex() == 200 || GetMapIndex() == 113)
  4559. {
  4560. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("현재 위치에서 사용할 수 없습니다."));
  4561. return false;
  4562. }
  4564. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  4565. {
  4566. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  4567. return false;
  4568. }
  4570. if (m_pkWarpEvent)
  4571. {
  4572. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이동할 준비가 되어있음으로 귀환부를 사용할수 없습니다"));
  4573. return false;
  4574. }
  4576. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4577. int consumeLife = CalculateConsume(this);
  4579. if (consumeLife < 0)
  4580. return false;
  4581. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4583. if (item->GetValue(0) == TOWN_PORTAL) // 귀환부
  4584. {
  4585. if (item->GetSocket(0) == 0)
  4586. {
  4587. if (!GetDungeon())
  4588. if (!GiveRecallItem(item))
  4589. return false;
  4591. PIXEL_POSITION posWarp;
  4593. if (SECTREE_MANAGER::instance().GetRecallPositionByEmpire(GetMapIndex(), GetEmpire(), posWarp))
  4594. {
  4595. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4596. PointChange(POINT_HP, -consumeLife, false);
  4597. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4599. WarpSet(posWarp.x, posWarp.y);
  4600. }
  4601. else
  4602. {
  4603. sys_err("CHARACTER::UseItem : cannot find spawn position (name %s, %d x %d)", GetName(), GetX(), GetY());
  4604. }
  4605. }
  4606. else
  4607. {
  4608. if (test_server)
  4609. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("원래 위치로 복귀"));
  4611. ProcessRecallItem(item);
  4612. }
  4613. }
  4614. else if (item->GetValue(0) == MEMORY_PORTAL) // 귀환기억부
  4615. {
  4616. if (item->GetSocket(0) == 0)
  4617. {
  4618. if (GetDungeon())
  4619. {
  4620. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("던전 안에서는 %s%s 사용할 수 없습니다."),
  4621. item->GetName(),
  4622. g_iUseLocale ? "" : (under_han(item->GetName()) ? LC_TEXT("을") : LC_TEXT("를")));
  4623. return false;
  4624. }
  4626. if (!GiveRecallItem(item))
  4627. return false;
  4628. }
  4629. else
  4630. {
  4631. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4632. PointChange(POINT_HP, -consumeLife, false);
  4633. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4635. ProcessRecallItem(item);
  4636. }
  4637. }
  4638. }
  4639. break;
  4641. case USE_TUNING:
  4642. case USE_DETACHMENT:
  4643. {
  4644. LPITEM item2;
  4646. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  4647. return false;
  4649. if (item2->IsExchanging())
  4650. return false;
  4652. if (item2->GetVnum() >= 28330 && item2->GetVnum() <= 28343) // 영석+3
  4653. {
  4654. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("+3 영석은 이 아이템으로 개량할 수 없습니다"));
  4655. return false;
  4656. }
  4658. if (item->GetValue(0) == ACCE_CLEAN_ATTR)
  4659. {
  4660. CleanAcceAttr(item, item2);
  4661. }
  4663. if (item2->GetVnum() >= 28430 && item2->GetVnum() <= 28443) // 영석+4
  4664. {
  4665. if (item->GetVnum() == 71056) // 청룡의숨결
  4666. {
  4667. RefineItem(item, item2);
  4668. }
  4669. else
  4670. {
  4671. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("영석은 이 아이템으로 개량할 수 없습니다"));
  4672. }
  4673. }
  4674. else
  4675. {
  4676. RefineItem(item, item2);
  4677. }
  4678. }
  4679. break;
  4681. // ACCESSORY_REFINE & ADD/CHANGE_ATTRIBUTES
  4682. case USE_PUT_INTO_BELT_SOCKET:
  4683. case USE_PUT_INTO_RING_SOCKET:
  4684. case USE_PUT_INTO_ACCESSORY_SOCKET:
  4685. case USE_ADD_ACCESSORY_SOCKET:
  4686. case USE_CLEAN_SOCKET:
  4687. case USE_CHANGE_ATTRIBUTE:
  4688. case USE_CHANGE_ATTRIBUTE2 :
  4689. case USE_ADD_ATTRIBUTE:
  4690. case USE_ADD_ATTRIBUTE2:
  4691. {
  4692. LPITEM item2;
  4693. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  4694. return false;
  4696. if (item2->IsEquipped())
  4697. {
  4698. BuffOnAttr_RemoveBuffsFromItem(item2);
  4699. }
  4701. // [NOTE] 코스튬 아이템에는 아이템 최초 생성시 랜덤 속성을 부여하되, 재경재가 등등은 막아달라는 요청이 있었음.
  4702. // 원래 ANTI_CHANGE_ATTRIBUTE 같은 아이템 Flag를 추가하여 기획 레벨에서 유연하게 컨트롤 할 수 있도록 할 예정이었으나
  4703. // 그딴거 필요없으니 닥치고 빨리 해달래서 그냥 여기서 막음... -_-
  4704. if (ITEM_COSTUME == item2->GetType())
  4705. {
  4706. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  4707. return false;
  4708. }
  4710. if (item2->IsExchanging())
  4711. return false;
  4713. if (item2->IsEquipped())
  4714. return false;
  4716. switch (item->GetSubType())
  4717. {
  4718. case USE_CLEAN_SOCKET:
  4719. {
  4720. int i;
  4721. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  4722. {
  4723. if (item2->GetSocket(i) == ITEM_BROKEN_METIN_VNUM)
  4724. break;
  4725. }
  4727. if (i == ITEM_SOCKET_MAX_NUM)
  4728. {
  4729. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("청소할 석이 박혀있지 않습니다."));
  4730. return false;
  4731. }
  4733. int j = 0;
  4735. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  4736. {
  4737. if (item2->GetSocket(i) != ITEM_BROKEN_METIN_VNUM && item2->GetSocket(i) != 0)
  4738. item2->SetSocket(j++, item2->GetSocket(i));
  4739. }
  4741. for (; j < ITEM_SOCKET_MAX_NUM; ++j)
  4742. {
  4743. if (item2->GetSocket(j) > 0)
  4744. item2->SetSocket(j, 1);
  4745. }
  4747. {
  4748. char buf[21];
  4749. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4750. LogManager::instance().ItemLog(this, item, "CLEAN_SOCKET", buf);
  4751. }
  4753. item->SetCount(item->GetCount() - 1);
  4755. }
  4756. break;
  4758. case USE_CHANGE_ATTRIBUTE :
  4759. if (item2->GetType() == ITEM_COSTUME)
  4760. {
  4761. return false;
  4762. }
  4763. if (item2->GetAttributeSetIndex() == -1)
  4764. {
  4765. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  4766. return false;
  4767. }
  4769. if (item2->GetAttributeCount() == 0)
  4770. {
  4771. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변경할 속성이 없습니다."));
  4772. return false;
  4773. }
  4775. if (GM_PLAYER == GetGMLevel() && false == test_server)
  4776. {
  4777. //
  4778. // Event Flag 를 통해 이전에 아이템 속성 변경을 한 시간으로 부터 충분한 시간이 흘렀는지 검사하고
  4779. // 시간이 충분히 흘렀다면 현재 속성변경에 대한 시간을 설정해 준다.
  4780. //
  4782. DWORD dwChangeItemAttrCycle = quest::CQuestManager::instance().GetEventFlag(msc_szChangeItemAttrCycleFlag);
  4783. if (dwChangeItemAttrCycle < msc_dwDefaultChangeItemAttrCycle)
  4784. dwChangeItemAttrCycle = msc_dwDefaultChangeItemAttrCycle;
  4786. quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetPlayerID());
  4788. if (pPC)
  4789. {
  4790. DWORD dwNowMin = get_global_time() / 60;
  4792. //DWORD dwLastChangeItemAttrMin = pPC->GetFlag(msc_szLastChangeItemAttrFlag);
  4794. //if (dwLastChangeItemAttrMin + dwChangeItemAttrCycle > dwNowMin)
  4795. //{
  4796. //ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 바꾼지 %d분 이내에는 다시 변경할 수 없습니다.(%d 분 남음)"),
  4797. //dwChangeItemAttrCycle, dwChangeItemAttrCycle - (dwNowMin - dwLastChangeItemAttrMin));
  4798. //return false;
  4799. //}
  4801. pPC->SetFlag(msc_szLastChangeItemAttrFlag, dwNowMin);
  4802. }
  4803. }
  4805. if (item->GetSubType() == USE_CHANGE_ATTRIBUTE2)
  4806. {
  4807. int aiChangeProb[ITEM_ATTRIBUTE_MAX_LEVEL] =
  4808. {
  4809. 0, 0, 30, 40, 3
  4810. };
  4812. item2->ChangeAttribute(aiChangeProb);
  4813. }
  4814. else if (item->GetVnum() == 76014)
  4815. {
  4816. int aiChangeProb[ITEM_ATTRIBUTE_MAX_LEVEL] =
  4817. {
  4818. 0, 10, 50, 39, 1
  4819. };
  4821. item2->ChangeAttribute(aiChangeProb);
  4822. }
  4824. else
  4825. {
  4826. // 연재경 특수처리
  4827. // 절대로 연재가 추가 안될거라 하여 하드 코딩함.
  4828. if (item->GetVnum() == 71151 || item->GetVnum() == 76023)
  4829. {
  4830. if ((item2->GetType() == ITEM_WEAPON)
  4831. || (item2->GetType() == ITEM_ARMOR && item2->GetSubType() == ARMOR_BODY))
  4832. {
  4833. bool bCanUse = true;
  4834. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  4835. {
  4836. if (item2->GetLimitType(i) == LIMIT_LEVEL && item2->GetLimitValue(i) > 40)
  4837. {
  4838. bCanUse = false;
  4839. break;
  4840. }
  4841. }
  4842. if (false == bCanUse)
  4843. {
  4844. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("적용 레벨보다 높아 사용이 불가능합니다."));
  4845. break;
  4846. }
  4847. }
  4848. else
  4849. {
  4850. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무기와 갑옷에만 사용 가능합니다."));
  4851. break;
  4852. }
  4853. }
  4854. item2->ChangeAttribute();
  4855. }
  4857. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경하였습니다."));
  4858. {
  4859. char buf[21];
  4860. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4861. LogManager::instance().ItemLog(this, item, "CHANGE_ATTRIBUTE", buf);
  4862. }
  4864. item->SetCount(item->GetCount() - 1);
  4865. break;
  4867. case USE_ADD_ATTRIBUTE :
  4868. if (item2->GetType() == ITEM_COSTUME)
  4869. {
  4870. return false;
  4871. }
  4872. if (item2->GetAttributeSetIndex() == -1)
  4873. {
  4874. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  4875. return false;
  4876. }
  4878. if (item2->GetAttributeCount() < 4)
  4879. {
  4880. // 연재가 특수처리
  4881. // 절대로 연재가 추가 안될거라 하여 하드 코딩함.
  4882. if (item->GetVnum() == 71152 || item->GetVnum() == 76024)
  4883. {
  4884. if ((item2->GetType() == ITEM_WEAPON)
  4885. || (item2->GetType() == ITEM_ARMOR && item2->GetSubType() == ARMOR_BODY))
  4886. {
  4887. bool bCanUse = true;
  4888. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  4889. {
  4890. if (item2->GetLimitType(i) == LIMIT_LEVEL && item2->GetLimitValue(i) > 40)
  4891. {
  4892. bCanUse = false;
  4893. break;
  4894. }
  4895. }
  4896. if (false == bCanUse)
  4897. {
  4898. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("적용 레벨보다 높아 사용이 불가능합니다."));
  4899. break;
  4900. }
  4901. }
  4902. else
  4903. {
  4904. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무기와 갑옷에만 사용 가능합니다."));
  4905. break;
  4906. }
  4907. }
  4908. char buf[21];
  4909. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4911. if (number(1, 100) <= aiItemAttributeAddPercent[item2->GetAttributeCount()])
  4912. {
  4913. item2->AddAttribute();
  4914. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 성공하였습니다."));
  4916. int iAddedIdx = item2->GetAttributeCount() - 1;
  4917. LogManager::instance().ItemLog(
  4918. GetPlayerID(),
  4919. item2->GetAttributeType(iAddedIdx),
  4920. item2->GetAttributeValue(iAddedIdx),
  4921. item->GetID(),
  4922. "ADD_ATTRIBUTE_SUCCESS",
  4923. buf,
  4924. GetDesc()->GetHostName(),
  4925. item->GetOriginalVnum());
  4926. }
  4927. else
  4928. {
  4929. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 실패하였습니다."));
  4930. LogManager::instance().ItemLog(this, item, "ADD_ATTRIBUTE_FAIL", buf);
  4931. }
  4933. item->SetCount(item->GetCount() - 1);
  4934. }
  4935. else
  4936. {
  4937. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더이상 이 아이템을 이용하여 속성을 추가할 수 없습니다."));
  4938. }
  4939. break;
  4941. case USE_ADD_ATTRIBUTE2 :
  4942. // 축복의 구슬
  4943. // 재가비서를 통해 속성을 4개 추가 시킨 아이템에 대해서 하나의 속성을 더 붙여준다.
  4944. if (item2->GetType() == ITEM_COSTUME)
  4945. {
  4946. return false;
  4947. }
  4948. if (item2->GetAttributeSetIndex() == -1)
  4949. {
  4950. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  4951. return false;
  4952. }
  4954. // 속성이 이미 4개 추가 되었을 때만 속성을 추가 가능하다.
  4955. if (item2->GetAttributeCount() == 4)
  4956. {
  4957. char buf[21];
  4958. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4960. if (number(1, 100) <= aiItemAttributeAddPercent[item2->GetAttributeCount()])
  4961. {
  4962. item2->AddAttribute();
  4963. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 성공하였습니다."));
  4965. int iAddedIdx = item2->GetAttributeCount() - 1;
  4966. LogManager::instance().ItemLog(
  4967. GetPlayerID(),
  4968. item2->GetAttributeType(iAddedIdx),
  4969. item2->GetAttributeValue(iAddedIdx),
  4970. item->GetID(),
  4971. "ADD_ATTRIBUTE2_SUCCESS",
  4972. buf,
  4973. GetDesc()->GetHostName(),
  4974. item->GetOriginalVnum());
  4975. }
  4976. else
  4977. {
  4978. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 실패하였습니다."));
  4979. LogManager::instance().ItemLog(this, item, "ADD_ATTRIBUTE2_FAIL", buf);
  4980. }
  4982. item->SetCount(item->GetCount() - 1);
  4983. }
  4984. else if (item2->GetAttributeCount() == 5)
  4985. {
  4986. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 이 아이템을 이용하여 속성을 추가할 수 없습니다."));
  4987. }
  4988. else if (item2->GetAttributeCount() < 4)
  4989. {
  4990. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("먼저 재가비서를 이용하여 속성을 추가시켜 주세요."));
  4991. }
  4992. else
  4993. {
  4994. // wtf ?!
  4995. sys_err("ADD_ATTRIBUTE2 : Item has wrong AttributeCount(%d)", item2->GetAttributeCount());
  4996. }
  4997. break;
  4999. case USE_ADD_ACCESSORY_SOCKET:
  5000. {
  5001. char buf[21];
  5002. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5004. if (item2->IsAccessoryForSocket())
  5005. {
  5006. if (item2->GetAccessorySocketMaxGrade() < ITEM_ACCESSORY_SOCKET_MAX_NUM)
  5007. {
  5008. if (number(1, 100) <= 50)
  5009. {
  5010. item2->SetAccessorySocketMaxGrade(item2->GetAccessorySocketMaxGrade() + 1);
  5011. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소켓이 성공적으로 추가되었습니다."));
  5012. LogManager::instance().ItemLog(this, item, "ADD_SOCKET_SUCCESS", buf);
  5013. }
  5014. else
  5015. {
  5016. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소켓 추가에 실패하였습니다."));
  5017. LogManager::instance().ItemLog(this, item, "ADD_SOCKET_FAIL", buf);
  5018. }
  5020. item->SetCount(item->GetCount() - 1);
  5021. }
  5022. else
  5023. {
  5024. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 액세서리에는 더이상 소켓을 추가할 공간이 없습니다."));
  5025. }
  5026. }
  5027. else
  5028. {
  5029. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템으로 소켓을 추가할 수 없는 아이템입니다."));
  5030. }
  5031. }
  5032. break;
  5034. case USE_PUT_INTO_BELT_SOCKET:
  5035. case USE_PUT_INTO_ACCESSORY_SOCKET:
  5036. if (item2->IsAccessoryForSocket() && item->CanPutInto(item2))
  5037. {
  5038. char buf[21];
  5039. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5041. if (item2->GetAccessorySocketGrade() < item2->GetAccessorySocketMaxGrade())
  5042. {
  5043. if (number(1, 100) <= aiAccessorySocketPutPct[item2->GetAccessorySocketGrade()])
  5044. {
  5045. item2->SetAccessorySocketGrade(item2->GetAccessorySocketGrade() + 1);
  5046. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("장착에 성공하였습니다."));
  5047. LogManager::instance().ItemLog(this, item, "PUT_SOCKET_SUCCESS", buf);
  5048. }
  5049. else
  5050. {
  5051. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("장착에 실패하였습니다."));
  5052. LogManager::instance().ItemLog(this, item, "PUT_SOCKET_FAIL", buf);
  5053. }
  5055. item->SetCount(item->GetCount() - 1);
  5056. }
  5057. else
  5058. {
  5059. if (item2->GetAccessorySocketMaxGrade() == 0)
  5060. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("먼저 다이아몬드로 악세서리에 소켓을 추가해야합니다."));
  5061. else if (item2->GetAccessorySocketMaxGrade() < ITEM_ACCESSORY_SOCKET_MAX_NUM)
  5062. {
  5063. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 액세서리에는 더이상 장착할 소켓이 없습니다."));
  5064. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("다이아몬드로 소켓을 추가해야합니다."));
  5065. }
  5066. else
  5067. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 액세서리에는 더이상 보석을 장착할 수 없습니다."));
  5068. }
  5069. }
  5070. else
  5071. {
  5072. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템을 장착할 수 없습니다."));
  5073. }
  5074. break;
  5075. }
  5076. if (item2->IsEquipped())
  5077. {
  5078. BuffOnAttr_AddBuffsFromItem(item2);
  5079. }
  5080. }
  5081. break;
  5082. // END_OF_ACCESSORY_REFINE & END_OF_ADD_ATTRIBUTES & END_OF_CHANGE_ATTRIBUTES
  5084. case USE_BAIT:
  5085. {
  5087. if (m_pkFishingEvent)
  5088. {
  5089. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("낚시 중에 미끼를 갈아끼울 수 없습니다."));
  5090. return false;
  5091. }
  5093. LPITEM weapon = GetWear(WEAR_WEAPON);
  5095. if (!weapon || weapon->GetType() != ITEM_ROD)
  5096. return false;
  5098. if (weapon->GetSocket(2))
  5099. {
  5100. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 꽂혀있던 미끼를 빼고 %s를 끼웁니다."), item->GetName());
  5101. }
  5102. else
  5103. {
  5104. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("낚시대에 %s를 미끼로 끼웁니다."), item->GetName());
  5105. }
  5107. weapon->SetSocket(2, item->GetValue(0));
  5108. item->SetCount(item->GetCount() - 1);
  5109. }
  5110. break;
  5112. case USE_MOVE:
  5113. case USE_TREASURE_BOX:
  5114. case USE_MONEYBAG:
  5115. break;
  5117. case USE_AFFECT :
  5118. {
  5119. if (FindAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType))
  5120. {
  5121. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  5122. }
  5123. else
  5124. {
  5125. // PC_BANG_ITEM_ADD
  5126. if (item->IsPCBangItem() == true)
  5127. {
  5128. // PC방인지 체크해서 처리
  5129. if (CPCBangManager::instance().IsPCBangIP(GetDesc()->GetHostName()) == false)
  5130. {
  5131. // PC방이 아님!
  5132. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 PC방에서만 사용할 수 있습니다."));
  5133. return false;
  5134. }
  5135. }
  5136. // END_PC_BANG_ITEM_ADD
  5138. AddAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType, item->GetValue(2), 0, item->GetValue(3), 0, false);
  5139. item->SetCount(item->GetCount() - 1);
  5140. }
  5141. }
  5142. break;
  5144. case USE_CREATE_STONE:
  5145. AutoGiveItem(number(28000, 28013));
  5146. item->SetCount(item->GetCount() - 1);
  5147. break;
  5149. // 물약 제조 스킬용 레시피 처리
  5150. case USE_RECIPE :
  5151. {
  5152. LPITEM pSource1 = FindSpecifyItem(item->GetValue(1));
  5153. DWORD dwSourceCount1 = item->GetValue(2);
  5155. LPITEM pSource2 = FindSpecifyItem(item->GetValue(3));
  5156. DWORD dwSourceCount2 = item->GetValue(4);
  5158. if (dwSourceCount1 != 0)
  5159. {
  5160. if (pSource1 == NULL)
  5161. {
  5162. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물약 조합을 위한 재료가 부족합니다."));
  5163. return false;
  5164. }
  5165. }
  5167. if (dwSourceCount2 != 0)
  5168. {
  5169. if (pSource2 == NULL)
  5170. {
  5171. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물약 조합을 위한 재료가 부족합니다."));
  5172. return false;
  5173. }
  5174. }
  5176. if (pSource1 != NULL)
  5177. {
  5178. if (pSource1->GetCount() < dwSourceCount1)
  5179. {
  5180. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("재료(%s)가 부족합니다."), pSource1->GetName());
  5181. return false;
  5182. }
  5184. pSource1->SetCount(pSource1->GetCount() - dwSourceCount1);
  5185. }
  5187. if (pSource2 != NULL)
  5188. {
  5189. if (pSource2->GetCount() < dwSourceCount2)
  5190. {
  5191. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("재료(%s)가 부족합니다."), pSource2->GetName());
  5192. return false;
  5193. }
  5195. pSource2->SetCount(pSource2->GetCount() - dwSourceCount2);
  5196. }
  5198. LPITEM pBottle = FindSpecifyItem(50901);
  5200. if (!pBottle || pBottle->GetCount() < 1)
  5201. {
  5202. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빈 병이 모자릅니다."));
  5203. return false;
  5204. }
  5206. pBottle->SetCount(pBottle->GetCount() - 1);
  5208. if (number(1, 100) > item->GetValue(5))
  5209. {
  5210. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물약 제조에 실패했습니다."));
  5211. return false;
  5212. }
  5214. AutoGiveItem(item->GetValue(0));
  5215. }
  5216. break;
  5217. }
  5218. }
  5219. break;
  5221. case ITEM_METIN:
  5222. {
  5223. LPITEM item2;
  5225. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  5226. return false;
  5228. if (item2->IsExchanging())
  5229. return false;
  5231. if (item2->GetType() == ITEM_PICK) return false;
  5232. if (item2->GetType() == ITEM_ROD) return false;
  5234. int i;
  5236. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  5237. {
  5238. DWORD dwVnum;
  5240. if ((dwVnum = item2->GetSocket(i)) <= 2)
  5241. continue;
  5243. TItemTable * p = ITEM_MANAGER::instance().GetTable(dwVnum);
  5245. if (!p)
  5246. continue;
  5248. if (item->GetValue(5) == p->alValues[5])
  5249. {
  5250. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("같은 종류의 메틴석은 여러개 부착할 수 없습니다."));
  5251. return false;
  5252. }
  5253. }
  5255. if (item2->GetType() == ITEM_ARMOR)
  5256. {
  5257. if (!IS_SET(item->GetWearFlag(), WEARABLE_BODY) || !IS_SET(item2->GetWearFlag(), WEARABLE_BODY))
  5258. {
  5259. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 메틴석은 장비에 부착할 수 없습니다."));
  5260. return false;
  5261. }
  5262. }
  5263. else if (item2->GetType() == ITEM_WEAPON)
  5264. {
  5265. if (!IS_SET(item->GetWearFlag(), WEARABLE_WEAPON))
  5266. {
  5267. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 메틴석은 무기에 부착할 수 없습니다."));
  5268. return false;
  5269. }
  5270. }
  5271. else
  5272. {
  5273. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("부착할 수 있는 슬롯이 없습니다."));
  5274. return false;
  5275. }
  5277. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  5278. if (item2->GetSocket(i) >= 1 && item2->GetSocket(i) <= 2 && item2->GetSocket(i) >= item->GetValue(2))
  5279. {
  5280. // 석 확률
  5281. if (number(1, 100) <= 30)
  5282. {
  5283. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("메틴석 부착에 성공하였습니다."));
  5284. item2->SetSocket(i, item->GetVnum());
  5285. }
  5286. else
  5287. {
  5288. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("메틴석 부착에 실패하였습니다."));
  5289. item2->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
  5290. }
  5292. LogManager::instance().ItemLog(this, item2, "SOCKET", item->GetName());
  5293. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (METIN)");
  5294. break;
  5295. }
  5297. if (i == ITEM_SOCKET_MAX_NUM)
  5298. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("부착할 수 있는 슬롯이 없습니다."));
  5299. }
  5300. break;
  5302. case ITEM_AUTOUSE:
  5303. case ITEM_MATERIAL:
  5304. case ITEM_SPECIAL:
  5305. case ITEM_TOOL:
  5306. case ITEM_LOTTERY:
  5307. break;
  5309. case ITEM_TOTEM:
  5310. {
  5311. if (!item->IsEquipped())
  5312. EquipItem(item);
  5313. }
  5314. break;
  5316. case ITEM_BLEND:
  5317. // 새로운 약초들
  5318. #ifdef ENABLE_YMIR_AFFECT_FIX
  5319. if ((CheckTimeUsed(item) == false)) { return false; }
  5320. #endif
  5321. sys_log(0,"ITEM_BLEND!!");
  5322. if (Blend_Item_find(item->GetVnum()))
  5323. {
  5324. int affect_type = AFFECT_BLEND;
  5325. if (item->GetSocket(0) >= _countof(aApplyInfo))
  5326. {
  5327. sys_err ("INVALID BLEND ITEM(id : %d, vnum : %d). APPLY TYPE IS %d.", item->GetID(), item->GetVnum(), item->GetSocket(0));
  5328. return false;
  5329. }
  5330. int apply_type = aApplyInfo[item->GetSocket(0)].bPointType;
  5331. int apply_value = item->GetSocket(1);
  5332. int apply_duration = item->GetSocket(2);
  5334. if (FindAffect(affect_type, apply_type))
  5335. {
  5336. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  5337. }
  5338. else
  5339. {
  5340. if (FindAffect(AFFECT_EXP_BONUS_EURO_FREE, POINT_RESIST_MAGIC))
  5341. {
  5342. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  5343. }
  5344. else
  5345. {
  5346. AddAffect(affect_type, apply_type, apply_value, 0, apply_duration, 0, false);
  5347. item->SetCount(item->GetCount() - 1);
  5348. }
  5349. }
  5350. }
  5351. break;
  5352. case ITEM_EXTRACT:
  5353. {
  5354. LPITEM pDestItem = GetItem(DestCell);
  5355. if (NULL == pDestItem)
  5356. {
  5357. return false;
  5358. }
  5359. switch (item->GetSubType())
  5360. {
  5361. case EXTRACT_DRAGON_SOUL:
  5362. if (pDestItem->IsDragonSoul())
  5363. {
  5364. return DSManager::instance().PullOut(this, NPOS, pDestItem, item);
  5365. }
  5366. return false;
  5367. case EXTRACT_DRAGON_HEART:
  5368. if (pDestItem->IsDragonSoul())
  5369. {
  5370. return DSManager::instance().ExtractDragonHeart(this, pDestItem, item);
  5371. }
  5372. return false;
  5373. default:
  5374. return false;
  5375. }
  5376. }
  5377. break;
  5379. case ITEM_NONE:
  5380. sys_err("Item type NONE %s", item->GetName());
  5381. break;
  5383. default:
  5384. sys_log(0, "UseItemEx: Unknown type %s %d", item->GetName(), item->GetType());
  5385. return false;
  5386. }
  5388. return true;
  5389. }
  5391. int g_nPortalLimitTime = 10;
  5393. bool CHARACTER::UseItem(TItemPos Cell, TItemPos DestCell)
  5394. {
  5395. WORD wCell = Cell.cell;
  5396. BYTE window_type = Cell.window_type;
  5397. WORD wDestCell = DestCell.cell;
  5398. BYTE bDestInven = DestCell.window_type;
  5399. LPITEM item;
  5401. if (!CanHandleItem())
  5402. return false;
  5404. if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
  5405. return false;
  5407. sys_log(0, "%s: USE_ITEM %s (inven %d, cell: %d)", GetName(), item->GetName(), window_type, wCell);
  5409. if (item->IsExchanging())
  5410. return false;
  5412. if (!item->CanUsedBy(this))
  5413. {
  5414. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("군직이 맞지않아 이 아이템을 사용할 수 없습니다."));
  5415. return false;
  5416. }
  5418. if (IsStun())
  5419. return false;
  5421. if (false == FN_check_item_sex(this, item))
  5422. {
  5423. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 사용할 수 없습니다."));
  5424. return false;
  5425. }
  5427. //PREVENT_TRADE_WINDOW
  5428. if (IS_SUMMON_ITEM(item->GetVnum()))
  5429. {
  5430. if (false == IS_SUMMONABLE_ZONE(GetMapIndex()))
  5431. {
  5432. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용할수 없습니다."));
  5433. return false;
  5434. }
  5436. // 경혼반지 사용지 상대방이 SUMMONABLE_ZONE에 있는가는 WarpToPC()에서 체크
  5438. //삼거리 관려 맵에서는 귀환부를 막아버린다.
  5439. if (CThreeWayWar::instance().IsThreeWayWarMapIndex(GetMapIndex()))
  5440. {
  5441. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("삼거리 전투 참가중에는 귀환부,귀환기억부를 사용할수 없습니다."));
  5442. return false;
  5443. }
  5444. int iPulse = thecore_pulse();
  5446. //창고 연후 체크
  5447. if (iPulse - GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  5448. {
  5449. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("창고를 연후 %d초 이내에는 귀환부,귀환기억부를 사용할 수 없습니다."), g_nPortalLimitTime);
  5451. if (test_server)
  5452. ChatPacket(CHAT_TYPE_INFO, "[TestOnly]Pulse %d LoadTime %d PASS %d", iPulse, GetSafeboxLoadTime(), PASSES_PER_SEC(g_nPortalLimitTime));
  5453. return false;
  5454. }
  5456. //거래관련 창 체크
  5457. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
  5458. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || GetOfflineShopOwner() || IsAcceOpen())
  5459. {
  5460. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 귀환부,귀환기억부 를 사용할수 없습니다."));
  5461. return false;
  5462. }
  5463. #else
  5464. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || IsAcceOpen())
  5465. {
  5466. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 귀환부,귀환기억부 를 사용할수 없습니다."));
  5467. return false;
  5468. }
  5469. #endif
  5471. //PREVENT_REFINE_HACK
  5472. //개량후 시간체크
  5473. {
  5474. if (iPulse - GetRefineTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  5475. {
  5476. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 개량후 %d초 이내에는 귀환부,귀환기억부를 사용할 수 없습니다."), g_nPortalLimitTime);
  5477. return false;
  5478. }
  5479. }
  5480. //END_PREVENT_REFINE_HACK
  5483. //PREVENT_ITEM_COPY
  5484. {
  5485. if (iPulse - GetMyShopTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  5486. {
  5487. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개인상점 사용후 %d초 이내에는 귀환부,귀환기억부를 사용할 수 없습니다."), g_nPortalLimitTime);
  5488. return false;
  5489. }
  5491. }
  5492. //END_PREVENT_ITEM_COPY
  5495. //귀환부 거리체크
  5496. if (item->GetVnum() != 70302)
  5497. {
  5498. PIXEL_POSITION posWarp;
  5500. int x = 0;
  5501. int y = 0;
  5503. double nDist = 0;
  5504. const double nDistant = 5000.0;
  5505. //귀환기억부
  5506. if (item->GetVnum() == 22010)
  5507. {
  5508. x = item->GetSocket(0) - GetX();
  5509. y = item->GetSocket(1) - GetY();
  5510. }
  5511. //귀환부
  5512. else if (item->GetVnum() == 22000)
  5513. {
  5514. SECTREE_MANAGER::instance().GetRecallPositionByEmpire(GetMapIndex(), GetEmpire(), posWarp);
  5516. if (item->GetSocket(0) == 0)
  5517. {
  5518. x = posWarp.x - GetX();
  5519. y = posWarp.y - GetY();
  5520. }
  5521. else
  5522. {
  5523. x = item->GetSocket(0) - GetX();
  5524. y = item->GetSocket(1) - GetY();
  5525. }
  5526. }
  5528. nDist = sqrt(pow((float)x,2) + pow((float)y,2));
  5530. if (nDistant > nDist)
  5531. {
  5532. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이동 되어질 위치와 너무 가까워 귀환부를 사용할수 없습니다."));
  5533. if (test_server)
  5534. ChatPacket(CHAT_TYPE_INFO, "PossibleDistant %f nNowDist %f", nDistant,nDist);
  5535. return false;
  5536. }
  5537. }
  5539. //PREVENT_PORTAL_AFTER_EXCHANGE
  5540. //교환 후 시간체크
  5541. if (iPulse - GetExchangeTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  5542. {
  5543. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래 후 %d초 이내에는 귀환부,귀환기억부등을 사용할 수 없습니다."), g_nPortalLimitTime);
  5544. return false;
  5545. }
  5546. //END_PREVENT_PORTAL_AFTER_EXCHANGE
  5548. }
  5550. //보따리 비단 사용시 거래창 제한 체크
  5551. if (item->GetVnum() == 50200 | item->GetVnum() == 71049)
  5552. {
  5553. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
  5554. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || GetOfflineShopOwner() || IsAcceOpen())
  5555. {
  5556. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 보따리,비단보따리를 사용할수 없습니다."));
  5557. return false;
  5558. }
  5559. #else
  5560. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || IsAcceOpen())
  5561. {
  5562. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 보따리,비단보따리를 사용할수 없습니다."));
  5563. return false;
  5564. }
  5565. #endif
  5567. }
  5569. if (item->GetVnum() == 70527)
  5570. {
  5571. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || IsAcceOpen())
  5572. {
  5573. ChatPacket(CHAT_TYPE_INFO, "Nu poti folosi itemul cand ai o casuta deschisa");
  5574. return false;
  5575. }
  5576. else
  5577. {
  5578. AddAffect(SKILL_HOSIN, POINT_RESIST_NORMAL_DAMAGE, 40, AFF_HOSIN, 360, 0, true, true);
  5579. AddAffect(SKILL_REFLECT, POINT_REFLECT_MELEE, 40, AFF_BOHO, 360, 0, true, true);
  5580. AddAffect(SKILL_GICHEON, POINT_CRITICAL_PCT, 40, AFF_GICHEON, 360, 0, true, true);
  5581. item->SetCount(item->GetCount() - 1);
  5582. ChatPacket(CHAT_TYPE_INFO, "Ai primit 40% binecuvantare/forta/reflexie, buff-urile tin 6 minute.");
  5583. }
  5584. }
  5586. //END_PREVENT_TRADE_WINDOW
  5588. if (IS_SET(item->GetFlag(), ITEM_FLAG_LOG)) // 사용 로그를 남기는 아이템 처리
  5589. {
  5590. DWORD vid = item->GetVID();
  5591. DWORD oldCount = item->GetCount();
  5592. DWORD vnum = item->GetVnum();
  5594. char hint[ITEM_NAME_MAX_LEN + 32 + 1];
  5595. int len = snprintf(hint, sizeof(hint) - 32, "%s", item->GetName());
  5597. if (len < 0 || len >= (int) sizeof(hint) - 32)
  5598. len = (sizeof(hint) - 32) - 1;
  5600. bool ret = UseItemEx(item, DestCell);
  5602. if (NULL == ITEM_MANAGER::instance().FindByVID(vid)) // UseItemEx에서 아이템이 삭제 되었다. 삭제 로그를 남김
  5603. {
  5604. LogManager::instance().ItemLog(this, vid, vnum, "REMOVE", hint);
  5605. }
  5606. else if (oldCount != item->GetCount())
  5607. {
  5608. snprintf(hint + len, sizeof(hint) - len, " %u", oldCount - 1);
  5609. LogManager::instance().ItemLog(this, vid, vnum, "USE_ITEM", hint);
  5610. }
  5611. return (ret);
  5612. }
  5613. else
  5614. return UseItemEx(item, DestCell);
  5615. }
  5617. bool CHARACTER::DropItem(TItemPos Cell, BYTE bCount)
  5618. {
  5619. LPITEM item = NULL;
  5621. if (!CanHandleItem())
  5622. {
  5623. if (NULL != DragonSoul_RefineWindow_GetOpener())
  5624. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("강화창을 연 상태에서는 아이템을 옮길 수 없습니다."));
  5625. return false;
  5626. }
  5628. if (IsDead())
  5629. return false;
  5631. if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
  5632. return false;
  5634. if (item->IsExchanging())
  5635. return false;
  5637. if (true == item->isLocked())
  5638. return false;
  5640. if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  5641. return false;
  5643. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP | ITEM_ANTIFLAG_GIVE))
  5644. {
  5645. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("버릴 수 없는 아이템입니다."));
  5646. return false;
  5647. }
  5649. if (bCount == 0 || bCount > item->GetCount())
  5650. bCount = item->GetCount();
  5652. SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, 255); // Quickslot 에서 지움
  5654. LPITEM pkItemToDrop;
  5656. if (bCount == item->GetCount())
  5657. {
  5658. item->RemoveFromCharacter();
  5659. pkItemToDrop = item;
  5660. }
  5661. else
  5662. {
  5663. if (bCount == 0)
  5664. {
  5665. if (test_server)
  5666. sys_log(0, "[DROP_ITEM] drop item count == 0");
  5667. return false;
  5668. }
  5670. // check non-split items for china
  5671. //if (LC_IsNewCIBN())
  5672. // if (item->GetVnum() == 71095 || item->GetVnum() == 71050 || item->GetVnum() == 70038)
  5673. // return false;
  5675. item->SetCount(item->GetCount() - bCount);
  5676. ITEM_MANAGER::instance().FlushDelayedSave(item);
  5678. pkItemToDrop = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), bCount);
  5680. // copy item socket -- by mhh
  5681. FN_copy_item_socket(pkItemToDrop, item);
  5683. char szBuf[51 + 1];
  5684. snprintf(szBuf, sizeof(szBuf), "%u %u", pkItemToDrop->GetID(), pkItemToDrop->GetCount());
  5685. LogManager::instance().ItemLog(this, item, "ITEM_SPLIT", szBuf);
  5686. }
  5688. PIXEL_POSITION pxPos = GetXYZ();
  5690. if (pkItemToDrop->AddToGround(GetMapIndex(), pxPos))
  5691. {
  5692. // 한국에는 아이템을 버리고 복구해달라는 진상유저들이 많아서
  5693. // 아이템을 바닥에 버릴 시 속성로그를 남긴다.
  5694. if (LC_IsYMIR())
  5695. item->AttrLog();
  5697. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("떨어진 아이템은 3분 후 사라집니다."));
  5698. pkItemToDrop->StartDestroyEvent(15);
  5700. ITEM_MANAGER::instance().FlushDelayedSave(pkItemToDrop);
  5702. char szHint[32 + 1];
  5703. snprintf(szHint, sizeof(szHint), "%s %u %u", pkItemToDrop->GetName(), pkItemToDrop->GetCount(), pkItemToDrop->GetOriginalVnum());
  5704. LogManager::instance().ItemLog(this, pkItemToDrop, "DROP", szHint);
  5705. //Motion(MOTION_PICKUP);
  5706. }
  5708. return true;
  5709. }
  5711. bool CHARACTER::DropGold(int gold)
  5712. {
  5713. if (gold <= 0 || gold > GetGold())
  5714. return false;
  5716. if (!CanHandleItem())
  5717. return false;
  5719. if (0 != g_GoldDropTimeLimitValue)
  5720. {
  5721. if (get_dword_time() < m_dwLastGoldDropTime+g_GoldDropTimeLimitValue)
  5722. {
  5723. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 골드를 버릴 수 없습니다."));
  5724. return false;
  5725. }
  5726. }
  5728. m_dwLastGoldDropTime = get_dword_time();
  5730. LPITEM item = ITEM_MANAGER::instance().CreateItem(1, gold);
  5732. if (item)
  5733. {
  5734. PIXEL_POSITION pos = GetXYZ();
  5736. if (item->AddToGround(GetMapIndex(), pos))
  5737. {
  5738. //Motion(MOTION_PICKUP);
  5739. PointChange(POINT_GOLD, -gold, true);
  5741. // 브라질에 돈이 없어진다는 버그가 있는데,
  5742. // 가능한 시나리오 중에 하나는,
  5743. // 메크로나, 핵을 써서 1000원 이하의 돈을 계속 버려 골드를 0으로 만들고,
  5744. // 돈이 없어졌다고 복구 신청하는 것일 수도 있다.
  5745. // 따라서 그런 경우를 잡기 위해 낮은 수치의 골드에 대해서도 로그를 남김.
  5746. if (LC_IsBrazil() == true)
  5747. {
  5748. if (gold >= 213)
  5749. LogManager::instance().CharLog(this, gold, "DROP_GOLD", "");
  5750. }
  5751. else
  5752. {
  5753. if (gold > 1000) // 천원 이상만 기록한다.
  5754. LogManager::instance().CharLog(this, gold, "DROP_GOLD", "");
  5755. }
  5757. if (false == LC_IsBrazil())
  5758. {
  5759. item->StartDestroyEvent(150);
  5760. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("떨어진 아이템은 %d분 후 사라집니다."), 150/60);
  5761. }
  5762. else
  5763. {
  5764. item->StartDestroyEvent(60);
  5765. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("떨어진 아이템은 %d분 후 사라집니다."), 1);
  5766. }
  5767. }
  5769. Save();
  5770. return true;
  5771. }
  5773. return false;
  5774. }
  5776. bool CHARACTER::MoveItem(TItemPos Cell, TItemPos DestCell, BYTE count)
  5777. {
  5778. LPITEM item = NULL;
  5780. #ifdef NEW_ADD_INVENTORY
  5781. if (DestCell.cell >= (90 + (5*Black_Envanter())))
  5782. {
  5783. // ChatPacket(CHAT_TYPE_INFO, "Yasak");
  5784. return false;
  5785. }
  5786. #endif
  5788. if (!IsValidItemPosition(Cell))
  5789. return false;
  5791. if (!(item = GetItem(Cell)))
  5792. return false;
  5794. if (item->IsExchanging())
  5795. return false;
  5797. if (item->GetCount() < count)
  5798. return false;
  5800. if (INVENTORY == Cell.window_type && Cell.cell >= INVENTORY_MAX_NUM && IS_SET(item->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  5801. return false;
  5803. if (true == item->isLocked())
  5804. return false;
  5806. if (!IsValidItemPosition(DestCell))
  5807. {
  5808. return false;
  5809. }
  5811. if (!CanHandleItem())
  5812. {
  5813. if (NULL != DragonSoul_RefineWindow_GetOpener())
  5814. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("강화창을 연 상태에서는 아이템을 옮길 수 없습니다."));
  5815. return false;
  5816. }
  5818. // 기획자의 요청으로 벨트 인벤토리에는 특정 타입의 아이템만 넣을 수 있다.
  5819. if (DestCell.IsBeltInventoryPosition() && false == CBeltInventoryHelper::CanMoveIntoBeltInventory(item))
  5820. {
  5821. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 벨트 인벤토리로 옮길 수 없습니다."));
  5822. return false;
  5823. }
  5825. // 이미 착용중인 아이템을 다른 곳으로 옮기는 경우, '장책 해제' 가능한 지 확인하고 옮김
  5826. if (Cell.IsEquipPosition() && !CanUnequipNow(item))
  5827. return false;
  5829. if (DestCell.IsEquipPosition())
  5830. {
  5831. if (GetItem(DestCell)) // 장비일 경우 한 곳만 검사해도 된다.
  5832. {
  5833. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 장비를 착용하고 있습니다."));
  5835. return false;
  5836. }
  5838. EquipItem(item, DestCell.cell - INVENTORY_MAX_NUM);
  5839. }
  5840. else
  5841. {
  5842. if (item->IsDragonSoul())
  5843. {
  5844. if (item->IsEquipped())
  5845. {
  5846. return DSManager::instance().PullOut(this, DestCell, item);
  5847. }
  5848. else
  5849. {
  5850. if (DestCell.window_type != DRAGON_SOUL_INVENTORY)
  5851. {
  5852. return false;
  5853. }
  5855. if (!DSManager::instance().IsValidCellForThisItem(item, DestCell))
  5856. return false;
  5857. }
  5858. }
  5859. // 용혼석이 아닌 아이템은 용혼석 인벤에 들어갈 수 없다.
  5860. else if (DRAGON_SOUL_INVENTORY == DestCell.window_type)
  5861. return false;
  5863. LPITEM item2;
  5865. if ((item2 = GetItem(DestCell)) && item != item2 && item2->IsStackable() &&
  5866. !IS_SET(item2->GetAntiFlag(), ITEM_ANTIFLAG_STACK) &&
  5867. item2->GetVnum() == item->GetVnum()) // 합칠 수 있는 아이템의 경우
  5868. {
  5869. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  5870. if (item2->GetSocket(i) != item->GetSocket(i))
  5871. return false;
  5873. if (count == 0)
  5874. count = item->GetCount();
  5876. sys_log(0, "%s: ITEM_STACK %s (window: %d, cell : %d) -> (window:%d, cell %d) count %d", GetName(), item->GetName(), Cell.window_type, Cell.cell,
  5877. DestCell.window_type, DestCell.cell, count);
  5879. count = MIN(200 - item2->GetCount(), count);
  5881. item->SetCount(item->GetCount() - count);
  5882. item2->SetCount(item2->GetCount() + count);
  5883. return true;
  5884. }
  5886. if (!IsEmptyItemGrid(DestCell, item->GetSize(), Cell.cell))
  5887. return false;
  5889. if (count == 0 || count >= item->GetCount() || !item->IsStackable() || IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_STACK))
  5890. {
  5891. sys_log(0, "%s: ITEM_MOVE %s (window: %d, cell : %d) -> (window:%d, cell %d) count %d", GetName(), item->GetName(), Cell.window_type, Cell.cell,
  5892. DestCell.window_type, DestCell.cell, count);
  5894. item->RemoveFromCharacter();
  5895. SetItem(DestCell, item, true);
  5897. if (INVENTORY == Cell.window_type && INVENTORY == DestCell.window_type)
  5898. SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, DestCell.cell);
  5899. }
  5900. else if (count < item->GetCount())
  5901. {
  5902. //check non-split items
  5903. //if (LC_IsNewCIBN())
  5904. //{
  5905. // if (item->GetVnum() == 71095 || item->GetVnum() == 71050 || item->GetVnum() == 70038)
  5906. // {
  5907. // return false;
  5908. // }
  5909. //}
  5911. sys_log(0, "%s: ITEM_SPLIT %s (window: %d, cell : %d) -> (window:%d, cell %d) count %d", GetName(), item->GetName(), Cell.window_type, Cell.cell,
  5912. DestCell.window_type, DestCell.cell, count);
  5914. item->SetCount(item->GetCount() - count);
  5915. LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), count);
  5917. // copy socket -- by mhh
  5918. FN_copy_item_socket(item2, item);
  5920. item2->AddToCharacter(this, DestCell);
  5922. char szBuf[51+1];
  5923. snprintf(szBuf, sizeof(szBuf), "%u %u %u %u ", item2->GetID(), item2->GetCount(), item->GetCount(), item->GetCount() + item2->GetCount());
  5924. LogManager::instance().ItemLog(this, item, "ITEM_SPLIT", szBuf);
  5925. }
  5926. }
  5928. return true;
  5929. }
  5931. namespace NPartyPickupDistribute
  5932. {
  5933. struct FFindOwnership
  5934. {
  5935. LPITEM item;
  5936. LPCHARACTER owner;
  5938. FFindOwnership(LPITEM item)
  5939. : item(item), owner(NULL)
  5940. {
  5941. }
  5943. void operator () (LPCHARACTER ch)
  5944. {
  5945. if (item->IsOwnership(ch))
  5946. owner = ch;
  5947. }
  5948. };
  5950. struct FCountNearMember
  5951. {
  5952. int total;
  5953. int x, y;
  5955. FCountNearMember(LPCHARACTER center )
  5956. : total(0), x(center->GetX()), y(center->GetY())
  5957. {
  5958. }
  5960. void operator () (LPCHARACTER ch)
  5961. {
  5962. if (DISTANCE_APPROX(ch->GetX() - x, ch->GetY() - y) <= PARTY_DEFAULT_RANGE)
  5963. total += 1;
  5964. }
  5965. };
  5967. struct FMoneyDistributor
  5968. {
  5969. int total;
  5970. LPCHARACTER c;
  5971. int x, y;
  5972. int iMoney;
  5974. FMoneyDistributor(LPCHARACTER center, int iMoney)
  5975. : total(0), c(center), x(center->GetX()), y(center->GetY()), iMoney(iMoney)
  5976. {
  5977. }
  5979. void operator ()(LPCHARACTER ch)
  5980. {
  5981. if (ch!=c)
  5982. if (DISTANCE_APPROX(ch->GetX() - x, ch->GetY() - y) <= PARTY_DEFAULT_RANGE)
  5983. {
  5984. ch->PointChange(POINT_GOLD, iMoney, true);
  5986. if (iMoney > 1000) // 천원 이상만 기록한다.
  5987. LogManager::instance().CharLog(ch, iMoney, "GET_GOLD", "");
  5988. }
  5989. }
  5990. };
  5991. }
  5993. void CHARACTER::GiveGold(int iAmount)
  5994. {
  5995. if (iAmount <= 0)
  5996. return;
  5998. sys_log(0, "GIVE_GOLD: %s %d", GetName(), iAmount);
  6000. if (GetParty())
  6001. {
  6002. LPPARTY pParty = GetParty();
  6004. // 파티가 있는 경우 나누어 가진다.
  6005. DWORD dwTotal = iAmount;
  6006. DWORD dwMyAmount = dwTotal;
  6008. NPartyPickupDistribute::FCountNearMember funcCountNearMember(this);
  6009. pParty->ForEachOnlineMember(funcCountNearMember);
  6011. if (funcCountNearMember.total > 1)
  6012. {
  6013. DWORD dwShare = dwTotal / funcCountNearMember.total;
  6014. dwMyAmount -= dwShare * (funcCountNearMember.total - 1);
  6016. NPartyPickupDistribute::FMoneyDistributor funcMoneyDist(this, dwShare);
  6018. pParty->ForEachOnlineMember(funcMoneyDist);
  6019. }
  6021. PointChange(POINT_GOLD, dwMyAmount, true);
  6023. if (dwMyAmount > 1000) // 천원 이상만 기록한다.
  6024. LogManager::instance().CharLog(this, dwMyAmount, "GET_GOLD", "");
  6025. }
  6026. else
  6027. {
  6028. PointChange(POINT_GOLD, iAmount, true);
  6030. // 브라질에 돈이 없어진다는 버그가 있는데,
  6031. // 가능한 시나리오 중에 하나는,
  6032. // 메크로나, 핵을 써서 1000원 이하의 돈을 계속 버려 골드를 0으로 만들고,
  6033. // 돈이 없어졌다고 복구 신청하는 것일 수도 있다.
  6034. // 따라서 그런 경우를 잡기 위해 낮은 수치의 골드에 대해서도 로그를 남김.
  6035. if (LC_IsBrazil() == true)
  6036. {
  6037. if (iAmount >= 213)
  6038. LogManager::instance().CharLog(this, iAmount, "GET_GOLD", "");
  6039. }
  6040. else
  6041. {
  6042. if (iAmount > 1000) // 천원 이상만 기록한다.
  6043. LogManager::instance().CharLog(this, iAmount, "GET_GOLD", "");
  6044. }
  6045. }
  6046. }
  6048. bool CHARACTER::PickupItem(DWORD dwVID)
  6049. {
  6050. LPITEM item = ITEM_MANAGER::instance().FindByVID(dwVID);
  6052. if (IsObserverMode())
  6053. return false;
  6055. if (!item || !item->GetSectree())
  6056. return false;
  6058. if (item->DistanceValid(this))
  6059. {
  6060. if (item->IsOwnership(this))
  6061. {
  6062. // 만약 주으려 하는 아이템이 엘크라면
  6063. if (item->GetType() == ITEM_ELK)
  6064. {
  6065. GiveGold(item->GetCount());
  6066. item->RemoveFromGround();
  6068. M2_DESTROY_ITEM(item);
  6070. Save();
  6071. }
  6072. // 평범한 아이템이라면
  6073. else
  6074. {
  6075. if (item->IsStackable() && !IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_STACK))
  6076. {
  6077. BYTE bCount = item->GetCount();
  6079. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6080. {
  6081. LPITEM item2 = GetInventoryItem(i);
  6083. if (!item2)
  6084. continue;
  6086. if (item2->GetVnum() == item->GetVnum())
  6087. {
  6088. int j;
  6090. for (j = 0; j < ITEM_SOCKET_MAX_NUM; ++j)
  6091. if (item2->GetSocket(j) != item->GetSocket(j))
  6092. break;
  6094. if (j != ITEM_SOCKET_MAX_NUM)
  6095. continue;
  6097. BYTE bCount2 = MIN(200 - item2->GetCount(), bCount);
  6098. bCount -= bCount2;
  6100. item2->SetCount(item2->GetCount() + bCount2);
  6102. if (bCount == 0)
  6103. {
  6104. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item2->GetName());
  6105. M2_DESTROY_ITEM(item);
  6106. if (item2->GetType() == ITEM_QUEST)
  6107. quest::CQuestManager::instance().PickupItem (GetPlayerID(), item2);
  6108. return true;
  6109. }
  6110. }
  6111. }
  6113. item->SetCount(bCount);
  6114. }
  6116. int iEmptyCell;
  6117. if (item->IsDragonSoul())
  6118. {
  6119. if ((iEmptyCell = GetEmptyDragonSoulInventory(item)) == -1)
  6120. {
  6121. sys_log(0, "No empty ds inventory pid %u size %ud itemid %u", GetPlayerID(), item->GetSize(), item->GetID());
  6122. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
  6123. return false;
  6124. }
  6125. }
  6126. else
  6127. {
  6128. if ((iEmptyCell = GetEmptyInventory(item->GetSize())) == -1)
  6129. {
  6130. sys_log(0, "No empty inventory pid %u size %ud itemid %u", GetPlayerID(), item->GetSize(), item->GetID());
  6131. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
  6132. return false;
  6133. }
  6134. }
  6136. item->RemoveFromGround();
  6138. if (item->IsDragonSoul())
  6139. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  6140. else
  6141. item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
  6143. char szHint[32+1];
  6144. snprintf(szHint, sizeof(szHint), "%s %u %u", item->GetName(), item->GetCount(), item->GetOriginalVnum());
  6145. LogManager::instance().ItemLog(this, item, "GET", szHint);
  6146. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  6148. if (item->GetType() == ITEM_QUEST)
  6149. quest::CQuestManager::instance().PickupItem (GetPlayerID(), item);
  6150. }
  6152. //Motion(MOTION_PICKUP);
  6153. return true;
  6154. }
  6155. else if (!IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_DROP) && GetParty())
  6156. {
  6157. // 다른 파티원 소유권 아이템을 주으려고 한다면
  6158. NPartyPickupDistribute::FFindOwnership funcFindOwnership(item);
  6160. GetParty()->ForEachOnlineMember(funcFindOwnership);
  6162. LPCHARACTER owner = funcFindOwnership.owner;
  6164. int iEmptyCell;
  6166. if (item->IsDragonSoul())
  6167. {
  6168. if (!(owner && (iEmptyCell = owner->GetEmptyDragonSoulInventory(item)) != -1))
  6169. {
  6170. owner = this;
  6172. if ((iEmptyCell = GetEmptyDragonSoulInventory(item)) == -1)
  6173. {
  6174. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
  6175. return false;
  6176. }
  6177. }
  6178. }
  6179. else
  6180. {
  6181. if (!(owner && (iEmptyCell = owner->GetEmptyInventory(item->GetSize())) != -1))
  6182. {
  6183. owner = this;
  6185. if ((iEmptyCell = GetEmptyInventory(item->GetSize())) == -1)
  6186. {
  6187. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
  6188. return false;
  6189. }
  6190. }
  6191. }
  6193. item->RemoveFromGround();
  6195. if (item->IsDragonSoul())
  6196. item->AddToCharacter(owner, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  6197. else
  6198. item->AddToCharacter(owner, TItemPos(INVENTORY, iEmptyCell));
  6200. char szHint[32+1];
  6201. snprintf(szHint, sizeof(szHint), "%s %u %u", item->GetName(), item->GetCount(), item->GetOriginalVnum());
  6202. LogManager::instance().ItemLog(owner, item, "GET", szHint);
  6204. if (owner == this)
  6205. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  6206. else
  6207. {
  6208. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s 님으로부터 %s"), GetName(), item->GetName());
  6209. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 전달: %s 님에게 %s"), owner->GetName(), item->GetName());
  6210. }
  6212. if (item->GetType() == ITEM_QUEST)
  6213. quest::CQuestManager::instance().PickupItem (owner->GetPlayerID(), item);
  6215. return true;
  6216. }
  6217. }
  6219. return false;
  6220. }
  6222. bool CHARACTER::SwapItem(BYTE bCell, BYTE bDestCell)
  6223. {
  6224. if (!CanHandleItem())
  6225. return false;
  6227. TItemPos srcCell(INVENTORY, bCell), destCell(INVENTORY, bDestCell);
  6229. // 올바른 Cell 인지 검사
  6230. // 용혼석은 Swap할 수 없으므로, 여기서 걸림.
  6231. //if (bCell >= INVENTORY_MAX_NUM + WEAR_MAX_NUM || bDestCell >= INVENTORY_MAX_NUM + WEAR_MAX_NUM)
  6232. if (srcCell.IsDragonSoulEquipPosition() || destCell.IsDragonSoulEquipPosition())
  6233. return false;
  6235. // 같은 CELL 인지 검사
  6236. if (bCell == bDestCell)
  6237. return false;
  6239. // 둘 다 장비창 위치면 Swap 할 수 없다.
  6240. if (srcCell.IsEquipPosition() && destCell.IsEquipPosition())
  6241. return false;
  6243. LPITEM item1, item2;
  6245. // item2가 장비창에 있는 것이 되도록.
  6246. if (srcCell.IsEquipPosition())
  6247. {
  6248. item1 = GetInventoryItem(bDestCell);
  6249. item2 = GetInventoryItem(bCell);
  6250. }
  6251. else
  6252. {
  6253. item1 = GetInventoryItem(bCell);
  6254. item2 = GetInventoryItem(bDestCell);
  6255. }
  6257. if (!item1 || !item2)
  6258. return false;
  6260. if (item1 == item2)
  6261. {
  6262. sys_log(0, "[WARNING][WARNING][HACK USER!] : %s %d %d", m_stName.c_str(), bCell, bDestCell);
  6263. return false;
  6264. }
  6266. // item2가 bCell위치에 들어갈 수 있는지 확인한다.
  6267. if (!IsEmptyItemGrid(TItemPos (INVENTORY, item1->GetCell()), item2->GetSize(), item1->GetCell()))
  6268. return false;
  6270. // 바꿀 아이템이 장비창에 있으면
  6271. if (TItemPos(EQUIPMENT, item2->GetCell()).IsEquipPosition())
  6272. {
  6273. BYTE bEquipCell = item2->GetCell() - INVENTORY_MAX_NUM;
  6274. BYTE bInvenCell = item1->GetCell();
  6276. // 착용중인 아이템을 벗을 수 있고, 착용 예정 아이템이 착용 가능한 상태여야만 진행
  6277. //if (false == CanUnequipNow(item2) || false == CanEquipNow(item1))
  6278. if (false == CanEquipNow(item1))
  6279. return false;
  6280. if (item2->IsDragonSoul() && false == CanUnequipNow(item2))
  6281. return false;
  6283. if (bEquipCell != item1->FindEquipCell(this)) // 같은 위치일때만 허용
  6284. return false;
  6286. item2->RemoveFromCharacter();
  6288. if (item1->EquipTo(this, bEquipCell))
  6289. item2->AddToCharacter(this, TItemPos(INVENTORY, bInvenCell));
  6290. else
  6291. sys_err("SwapItem cannot equip %s! item1 %s", item2->GetName(), item1->GetName());
  6292. }
  6293. else
  6294. {
  6295. BYTE bCell1 = item1->GetCell();
  6296. BYTE bCell2 = item2->GetCell();
  6298. item1->RemoveFromCharacter();
  6299. item2->RemoveFromCharacter();
  6301. item1->AddToCharacter(this, TItemPos(INVENTORY, bCell2));
  6302. item2->AddToCharacter(this, TItemPos(INVENTORY, bCell1));
  6303. }
  6305. return true;
  6306. }
  6308. bool CHARACTER::UnequipItem(LPITEM item)
  6309. {
  6310. int pos;
  6312. if (false == CanUnequipNow(item))
  6313. return false;
  6315. if (item->IsDragonSoul())
  6316. pos = GetEmptyDragonSoulInventory(item);
  6317. else
  6318. pos = GetEmptyInventory(item->GetSize());
  6320. // HARD CODING
  6321. if (item->GetVnum() == UNIQUE_ITEM_HIDE_ALIGNMENT_TITLE)
  6322. ShowAlignment(true);
  6324. item->RemoveFromCharacter();
  6325. if (item->IsDragonSoul())
  6326. {
  6327. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, pos));
  6328. }
  6329. else
  6330. item->AddToCharacter(this, TItemPos(INVENTORY, pos));
  6332. CheckMaximumPoints();
  6334. return true;
  6335. }
  6337. //
  6338. // @version 05/07/05 Bang2ni - Skill 사용후 1.5 초 이내에 장비 착용 금지
  6339. //
  6340. bool CHARACTER::EquipItem(LPITEM item, int iCandidateCell)
  6341. {
  6342. if (item->IsExchanging())
  6343. return false;
  6345. if (false == item->IsEquipable())
  6346. return false;
  6348. if (false == CanEquipNow(item))
  6349. return false;
  6351. int iWearCell = item->FindEquipCell(this, iCandidateCell);
  6353. if (iWearCell < 0)
  6354. return false;
  6356. // 무언가를 탄 상태에서 턱시도 입기 금지
  6357. if (iWearCell == WEAR_BODY && IsRiding() && (item->GetVnum() >= 11901 && item->GetVnum() <= 11904))
  6358. {
  6359. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("말을 탄 상태에서 예복을 입을 수 없습니다."));
  6360. return false;
  6361. }
  6363. if (iWearCell != WEAR_ARROW && IsPolymorphed())
  6364. {
  6365. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑 중에는 착용중인 장비를 변경할 수 없습니다."));
  6366. return false;
  6367. }
  6369. if (FN_check_item_sex(this, item) == false)
  6370. {
  6371. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 사용할 수 없습니다."));
  6372. return false;
  6373. }
  6375. //신규 탈것 사용시 기존 말 사용여부 체크
  6376. if(item->IsRideItem() && IsRiding())
  6377. {
  6378. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 탈것을 이용중입니다."));
  6379. return false;
  6380. }
  6382. // 화살 이외에는 마지막 공격 시간 또는 스킬 사용 1.5 후에 장비 교체가 가능
  6383. DWORD dwCurTime = get_dword_time();
  6385. if (iWearCell != WEAR_ARROW
  6386. && (dwCurTime - GetLastAttackTime() <= 1500 || dwCurTime - m_dwLastSkillTime <= 1500))
  6387. {
  6388. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("가만히 있을 때만 착용할 수 있습니다."));
  6389. return false;
  6390. }
  6392. // 용혼석 특수 처리
  6393. if (item->IsDragonSoul())
  6394. {
  6395. // 같은 타입의 용혼석이 이미 들어가 있다면 착용할 수 없다.
  6396. // 용혼석은 swap을 지원하면 안됨.
  6397. if(GetInventoryItem(INVENTORY_MAX_NUM + iWearCell))
  6398. {
  6399. ChatPacket(CHAT_TYPE_INFO, "이미 같은 종류의 용혼석을 착용하고 있습니다.");
  6400. return false;
  6401. }
  6403. if (!item->EquipTo(this, iWearCell))
  6404. {
  6405. return false;
  6406. }
  6407. }
  6408. // 용혼석이 아님.
  6409. else
  6410. {
  6411. // 착용할 곳에 아이템이 있다면,
  6412. if (GetWear(iWearCell) && !IS_SET(GetWear(iWearCell)->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  6413. {
  6414. // 이 아이템은 한번 박히면 변경 불가. swap 역시 완전 불가
  6415. if (item->GetWearFlag() == WEARABLE_ABILITY)
  6416. return false;
  6418. if (false == SwapItem(item->GetCell(), INVENTORY_MAX_NUM + iWearCell))
  6419. {
  6420. return false;
  6421. }
  6422. }
  6423. else
  6424. {
  6425. BYTE bOldCell = item->GetCell();
  6427. if (item->EquipTo(this, iWearCell))
  6428. {
  6429. SyncQuickslot(QUICKSLOT_TYPE_ITEM, bOldCell, iWearCell);
  6430. }
  6431. }
  6432. }
  6434. if (true == item->IsEquipped())
  6435. {
  6436. // 아이템 최초 사용 이후부터는 사용하지 않아도 시간이 차감되는 방식 처리.
  6437. if (-1 != item->GetProto()->cLimitRealTimeFirstUseIndex)
  6438. {
  6439. // 한 번이라도 사용한 아이템인지 여부는 Socket1을 보고 판단한다. (Socket1에 사용횟수 기록)
  6440. if (0 == item->GetSocket(1))
  6441. {
  6442. // 사용가능시간은 Default 값으로 Limit Value 값을 사용하되, Socket0에 값이 있으면 그 값을 사용하도록 한다. (단위는 초)
  6443. long duration = (0 != item->GetSocket(0)) ? item->GetSocket(0) : item->GetProto()->aLimits[item->GetProto()->cLimitRealTimeFirstUseIndex].lValue;
  6445. if (0 == duration)
  6446. duration = 60 * 60 * 24 * 7;
  6448. item->SetSocket(0, time(0) + duration);
  6449. item->StartRealTimeExpireEvent();
  6450. }
  6452. item->SetSocket(1, item->GetSocket(1) + 1);
  6453. }
  6455. if (item->GetVnum() == UNIQUE_ITEM_HIDE_ALIGNMENT_TITLE)
  6456. ShowAlignment(false);
  6458. const DWORD& dwVnum = item->GetVnum();
  6460. // 라마단 이벤트 초승달의 반지(71135) 착용시 이펙트 발동
  6461. if (true == CItemVnumHelper::IsRamadanMoonRing(dwVnum))
  6462. {
  6463. this->EffectPacket(SE_EQUIP_RAMADAN_RING);
  6464. }
  6465. // 할로윈 사탕(71136) 착용시 이펙트 발동
  6466. else if (true == CItemVnumHelper::IsHalloweenCandy(dwVnum))
  6467. {
  6468. this->EffectPacket(SE_EQUIP_HALLOWEEN_CANDY);
  6469. }
  6470. // 행복의 반지(71143) 착용시 이펙트 발동
  6471. else if (true == CItemVnumHelper::IsHappinessRing(dwVnum))
  6472. {
  6473. this->EffectPacket(SE_EQUIP_HAPPINESS_RING);
  6474. }
  6475. // 사랑의 팬던트(71145) 착용시 이펙트 발동
  6476. else if (true == CItemVnumHelper::IsLovePendant(dwVnum))
  6477. {
  6478. this->EffectPacket(SE_EQUIP_LOVE_PENDANT);
  6479. }
  6480. // ITEM_UNIQUE의 경우, SpecialItemGroup에 정의되어 있고, (item->GetSIGVnum() != NULL)
  6481. //
  6482. else if (ITEM_UNIQUE == item->GetType() && 0 != item->GetSIGVnum())
  6483. {
  6484. const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(item->GetSIGVnum());
  6485. if (NULL != pGroup)
  6486. {
  6487. const CSpecialAttrGroup* pAttrGroup = ITEM_MANAGER::instance().GetSpecialAttrGroup(pGroup->GetAttrVnum(item->GetVnum()));
  6488. if (NULL != pAttrGroup)
  6489. {
  6490. const std::string& std = pAttrGroup->m_stEffectFileName;
  6491. SpecificEffectPacket(std.c_str());
  6492. }
  6493. }
  6494. }
  6496. else if (true == CItemVnumHelper::IsAcce_Grade1(dwVnum))
  6497. {
  6498. this->EffectPacket(SE_EQUIP_ACCE_1);
  6499. }
  6500. else if (true == CItemVnumHelper::IsAcce_Grade2(dwVnum))
  6501. {
  6502. this->EffectPacket(SE_EQUIP_ACCE_2);
  6503. }
  6504. else if (true == CItemVnumHelper::IsAcce_Grade3(dwVnum))
  6505. {
  6506. this->EffectPacket(SE_EQUIP_ACCE_3);
  6507. }
  6508. else if (true == CItemVnumHelper::IsAcce_Grade4(dwVnum))
  6509. {
  6510. this->EffectPacket(SE_EQUIP_ACCE_4);
  6511. }
  6513. if (UNIQUE_SPECIAL_RIDE == item->GetSubType() && IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE))
  6514. {
  6515. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  6516. }
  6518. if (COSTUME_MOUNT == item->GetSubType())
  6519. {
  6520. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  6521. }
  6522. }
  6524. return true;
  6525. }
  6527. void CHARACTER::BuffOnAttr_AddBuffsFromItem(LPITEM pItem)
  6528. {
  6529. for (int i = 0; i < sizeof(g_aBuffOnAttrPoints)/sizeof(g_aBuffOnAttrPoints[0]); i++)
  6530. {
  6531. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(g_aBuffOnAttrPoints[i]);
  6532. if (it != m_map_buff_on_attrs.end())
  6533. {
  6534. it->second->AddBuffFromItem(pItem);
  6535. }
  6536. }
  6537. }
  6539. void CHARACTER::BuffOnAttr_RemoveBuffsFromItem(LPITEM pItem)
  6540. {
  6541. for (int i = 0; i < sizeof(g_aBuffOnAttrPoints)/sizeof(g_aBuffOnAttrPoints[0]); i++)
  6542. {
  6543. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(g_aBuffOnAttrPoints[i]);
  6544. if (it != m_map_buff_on_attrs.end())
  6545. {
  6546. it->second->RemoveBuffFromItem(pItem);
  6547. }
  6548. }
  6549. }
  6551. void CHARACTER::BuffOnAttr_ClearAll()
  6552. {
  6553. for (TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.begin(); it != m_map_buff_on_attrs.end(); it++)
  6554. {
  6555. CBuffOnAttributes* pBuff = it->second;
  6556. if (pBuff)
  6557. {
  6558. pBuff->Initialize();
  6559. }
  6560. }
  6561. }
  6563. void CHARACTER::BuffOnAttr_ValueChange(BYTE bType, BYTE bOldValue, BYTE bNewValue)
  6564. {
  6565. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(bType);
  6567. if (0 == bNewValue)
  6568. {
  6569. if (m_map_buff_on_attrs.end() == it)
  6570. return;
  6571. else
  6572. it->second->Off();
  6573. }
  6574. else if(0 == bOldValue)
  6575. {
  6576. CBuffOnAttributes* pBuff;
  6577. if (m_map_buff_on_attrs.end() == it)
  6578. {
  6579. switch (bType)
  6580. {
  6581. case POINT_ENERGY:
  6582. {
  6583. static BYTE abSlot[] = { WEAR_BODY, WEAR_HEAD, WEAR_FOOTS, WEAR_WRIST, WEAR_WEAPON, WEAR_NECK, WEAR_EAR, WEAR_SHIELD };
  6584. static std::vector <BYTE> vec_slots (abSlot, abSlot + _countof(abSlot));
  6585. pBuff = M2_NEW CBuffOnAttributes(this, bType, &vec_slots);
  6586. }
  6587. break;
  6588. case POINT_COSTUME_ATTR_BONUS:
  6589. {
  6590. static BYTE abSlot[] = {WEAR_COSTUME_BODY, WEAR_COSTUME_HAIR,
  6591. #ifdef __WEAPON_COSTUME_SYSTEM__
  6592. WEAR_COSTUME_WEAPON,
  6593. #endif
  6594. WEAR_COSTUME_MOUNT};
  6595. static std::vector <BYTE> vec_slots (abSlot, abSlot + _countof(abSlot));
  6596. pBuff = M2_NEW CBuffOnAttributes(this, bType, &vec_slots);
  6597. }
  6598. break;
  6599. default:
  6600. break;
  6601. }
  6602. m_map_buff_on_attrs.insert(TMapBuffOnAttrs::value_type(bType, pBuff));
  6604. }
  6605. else
  6606. pBuff = it->second;
  6608. pBuff->On(bNewValue);
  6609. }
  6610. else
  6611. {
  6612. if (m_map_buff_on_attrs.end() == it)
  6613. return;
  6614. else
  6615. it->second->ChangeBuffValue(bNewValue);
  6616. }
  6617. }
  6620. LPITEM CHARACTER::FindSpecifyItem(DWORD vnum) const
  6621. {
  6622. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6623. if (GetInventoryItem(i) && GetInventoryItem(i)->GetVnum() == vnum)
  6624. return GetInventoryItem(i);
  6626. return NULL;
  6627. }
  6629. LPITEM CHARACTER::FindItemByID(DWORD id) const
  6630. {
  6631. for (int i=0 ; i < INVENTORY_MAX_NUM ; ++i)
  6632. {
  6633. if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetID() == id)
  6634. return GetInventoryItem(i);
  6635. }
  6637. for (int i=BELT_INVENTORY_SLOT_START; i < BELT_INVENTORY_SLOT_END ; ++i)
  6638. {
  6639. if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetID() == id)
  6640. return GetInventoryItem(i);
  6641. }
  6643. return NULL;
  6644. }
  6646. int CHARACTER::CountSpecifyItem(DWORD vnum) const
  6647. {
  6648. int count = 0;
  6649. LPITEM item;
  6651. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6652. {
  6653. item = GetInventoryItem(i);
  6654. if (NULL != item && item->GetVnum() == vnum)
  6655. {
  6656. // 개인 상점에 등록된 물건이면 넘어간다.
  6657. if (m_pkMyShop && m_pkMyShop->IsSellingItem(item->GetID()))
  6658. {
  6659. continue;
  6660. }
  6661. else
  6662. {
  6663. count += item->GetCount();
  6664. }
  6665. }
  6666. }
  6668. return count;
  6669. }
  6671. void CHARACTER::RemoveSpecifyItem(DWORD vnum, DWORD count)
  6672. {
  6673. if (0 == count)
  6674. return;
  6676. for (UINT i = 0; i < INVENTORY_MAX_NUM; ++i)
  6677. {
  6678. if (NULL == GetInventoryItem(i))
  6679. continue;
  6681. if (GetInventoryItem(i)->GetVnum() != vnum)
  6682. continue;
  6684. //개인 상점에 등록된 물건이면 넘어간다. (개인 상점에서 판매될때 이 부분으로 들어올 경우 문제!)
  6685. if(m_pkMyShop)
  6686. {
  6687. bool isItemSelling = m_pkMyShop->IsSellingItem(GetInventoryItem(i)->GetID());
  6688. if (isItemSelling)
  6689. continue;
  6690. }
  6692. if (vnum >= 80003 && vnum <= 80007)
  6693. LogManager::instance().GoldBarLog(GetPlayerID(), GetInventoryItem(i)->GetID(), QUEST, "RemoveSpecifyItem");
  6695. if (count >= GetInventoryItem(i)->GetCount())
  6696. {
  6697. count -= GetInventoryItem(i)->GetCount();
  6698. GetInventoryItem(i)->SetCount(0);
  6700. if (0 == count)
  6701. return;
  6702. }
  6703. else
  6704. {
  6705. GetInventoryItem(i)->SetCount(GetInventoryItem(i)->GetCount() - count);
  6706. return;
  6707. }
  6708. }
  6710. // 예외처리가 약하다.
  6711. if (count)
  6712. sys_log(0, "CHARACTER::RemoveSpecifyItem cannot remove enough item vnum %u, still remain %d", vnum, count);
  6713. }
  6715. int CHARACTER::CountSpecifyTypeItem(BYTE type) const
  6716. {
  6717. int count = 0;
  6719. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6720. {
  6721. LPITEM pItem = GetInventoryItem(i);
  6722. if (pItem != NULL && pItem->GetType() == type)
  6723. {
  6724. count += pItem->GetCount();
  6725. }
  6726. }
  6728. return count;
  6729. }
  6731. void CHARACTER::RemoveSpecifyTypeItem(BYTE type, DWORD count)
  6732. {
  6733. if (0 == count)
  6734. return;
  6736. for (UINT i = 0; i < INVENTORY_MAX_NUM; ++i)
  6737. {
  6738. if (NULL == GetInventoryItem(i))
  6739. continue;
  6741. if (GetInventoryItem(i)->GetType() != type)
  6742. continue;
  6744. //개인 상점에 등록된 물건이면 넘어간다. (개인 상점에서 판매될때 이 부분으로 들어올 경우 문제!)
  6745. if(m_pkMyShop)
  6746. {
  6747. bool isItemSelling = m_pkMyShop->IsSellingItem(GetInventoryItem(i)->GetID());
  6748. if (isItemSelling)
  6749. continue;
  6750. }
  6752. if (count >= GetInventoryItem(i)->GetCount())
  6753. {
  6754. count -= GetInventoryItem(i)->GetCount();
  6755. GetInventoryItem(i)->SetCount(0);
  6757. if (0 == count)
  6758. return;
  6759. }
  6760. else
  6761. {
  6762. GetInventoryItem(i)->SetCount(GetInventoryItem(i)->GetCount() - count);
  6763. return;
  6764. }
  6765. }
  6766. }
  6768. void CHARACTER::AutoGiveItem(LPITEM item, bool longOwnerShip)
  6769. {
  6770. if (NULL == item)
  6771. {
  6772. sys_err ("NULL point.");
  6773. return;
  6774. }
  6775. if (item->GetOwner())
  6776. {
  6777. sys_err ("item %d 's owner exists!",item->GetID());
  6778. return;
  6779. }
  6781. int cell;
  6782. if (item->IsDragonSoul())
  6783. {
  6784. cell = GetEmptyDragonSoulInventory(item);
  6785. }
  6786. else
  6787. {
  6788. cell = GetEmptyInventory (item->GetSize());
  6789. }
  6791. if (cell != -1)
  6792. {
  6793. if (item->IsDragonSoul())
  6794. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, cell));
  6795. else
  6796. item->AddToCharacter(this, TItemPos(INVENTORY, cell));
  6798. LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
  6800. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_POTION)
  6801. {
  6802. TQuickslot * pSlot;
  6804. if (GetQuickslot(0, &pSlot) && pSlot->type == QUICKSLOT_TYPE_NONE)
  6805. {
  6806. TQuickslot slot;
  6807. slot.type = QUICKSLOT_TYPE_ITEM;
  6808. slot.pos = cell;
  6809. SetQuickslot(0, slot);
  6810. }
  6811. }
  6812. }
  6813. else
  6814. {
  6815. item->AddToGround (GetMapIndex(), GetXYZ());
  6816. item->StartDestroyEvent();
  6818. if (longOwnerShip)
  6819. item->SetOwnership (this, 300);
  6820. else
  6821. item->SetOwnership (this, 60);
  6822. LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
  6823. }
  6824. }
  6826. LPITEM CHARACTER::AutoGiveItem(DWORD dwItemVnum, BYTE bCount, int iRarePct, bool bMsg)
  6827. {
  6828. TItemTable * p = ITEM_MANAGER::instance().GetTable(dwItemVnum);
  6830. if (!p)
  6831. return NULL;
  6833. DBManager::instance().SendMoneyLog(MONEY_LOG_DROP, dwItemVnum, bCount);
  6835. if (p->dwFlags & ITEM_FLAG_STACKABLE && p->bType != ITEM_BLEND)
  6836. {
  6837. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6838. {
  6839. LPITEM item = GetInventoryItem(i);
  6841. if (!item)
  6842. continue;
  6844. if (item->GetVnum() == dwItemVnum && FN_check_item_socket(item))
  6845. {
  6846. if (IS_SET(p->dwFlags, ITEM_FLAG_MAKECOUNT))
  6847. {
  6848. if (bCount < p->alValues[1])
  6849. bCount = p->alValues[1];
  6850. }
  6852. BYTE bCount2 = MIN(200 - item->GetCount(), bCount);
  6853. bCount -= bCount2;
  6855. item->SetCount(item->GetCount() + bCount2);
  6857. if (bCount == 0)
  6858. {
  6859. if (bMsg)
  6860. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  6862. return item;
  6863. }
  6864. }
  6865. }
  6866. }
  6868. LPITEM item = ITEM_MANAGER::instance().CreateItem(dwItemVnum, bCount, 0, true);
  6870. if (!item)
  6871. {
  6872. sys_err("cannot create item by vnum %u (name: %s)", dwItemVnum, GetName());
  6873. return NULL;
  6874. }
  6876. if (item->GetType() == ITEM_BLEND)
  6877. {
  6878. for (int i=0; i < INVENTORY_MAX_NUM; i++)
  6879. {
  6880. LPITEM inv_item = GetInventoryItem(i);
  6882. if (inv_item == NULL) continue;
  6884. if (inv_item->GetType() == ITEM_BLEND)
  6885. {
  6886. if (inv_item->GetVnum() == item->GetVnum())
  6887. {
  6888. if (inv_item->GetSocket(0) == item->GetSocket(0) &&
  6889. inv_item->GetSocket(1) == item->GetSocket(1) &&
  6890. inv_item->GetSocket(2) == item->GetSocket(2) &&
  6891. inv_item->GetCount() < ITEM_MAX_COUNT)
  6892. {
  6893. inv_item->SetCount(inv_item->GetCount() + item->GetCount());
  6894. return inv_item;
  6895. }
  6896. }
  6897. }
  6898. }
  6899. }
  6901. int iEmptyCell;
  6902. if (item->IsDragonSoul())
  6903. {
  6904. iEmptyCell = GetEmptyDragonSoulInventory(item);
  6905. }
  6906. else
  6907. iEmptyCell = GetEmptyInventory(item->GetSize());
  6909. if (iEmptyCell != -1)
  6910. {
  6911. if (bMsg)
  6912. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  6914. if (item->IsDragonSoul())
  6915. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  6916. else
  6917. item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
  6918. LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
  6920. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_POTION)
  6921. {
  6922. TQuickslot * pSlot;
  6924. if (GetQuickslot(0, &pSlot) && pSlot->type == QUICKSLOT_TYPE_NONE)
  6925. {
  6926. TQuickslot slot;
  6927. slot.type = QUICKSLOT_TYPE_ITEM;
  6928. slot.pos = iEmptyCell;
  6929. SetQuickslot(0, slot);
  6930. }
  6931. }
  6932. }
  6933. else
  6934. {
  6935. item->AddToGround(GetMapIndex(), GetXYZ());
  6936. item->StartDestroyEvent();
  6937. // 안티 드랍 flag가 걸려있는 아이템의 경우,
  6938. // 인벤에 빈 공간이 없어서 어쩔 수 없이 떨어트리게 되면,
  6939. // ownership을 아이템이 사라질 때까지(300초) 유지한다.
  6940. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP))
  6941. item->SetOwnership(this, 300);
  6942. else
  6943. item->SetOwnership(this, 60);
  6944. LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
  6945. }
  6947. sys_log(0,
  6948. "7: %d %d", dwItemVnum, bCount);
  6949. return item;
  6950. }
  6952. LPITEM CHARACTER::AutoGiveAcce(DWORD dwItemVnum, BYTE bCount, int iSocketTwo, int iRarePct, bool bMsg)
  6953. {
  6954. TItemTable * p = ITEM_MANAGER::instance().GetTable(dwItemVnum);
  6955. if (!p)
  6956. return NULL;
  6958. DBManager::instance().SendMoneyLog(MONEY_LOG_DROP, dwItemVnum, bCount);
  6960. if (p->dwFlags & ITEM_FLAG_STACKABLE && p->bType != ITEM_BLEND)
  6961. {
  6962. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6963. {
  6964. LPITEM item = GetInventoryItem(i);
  6965. if (!item)
  6966. continue;
  6968. if (item->GetVnum() == dwItemVnum && FN_check_item_socket(item))
  6969. {
  6970. if (IS_SET(p->dwFlags, ITEM_FLAG_MAKECOUNT))
  6971. {
  6972. if (bCount < p->alValues[1])
  6973. bCount = p->alValues[1];
  6974. }
  6976. BYTE bCount2 = MIN(200 - item->GetCount(), bCount);
  6977. bCount -= bCount2;
  6979. item->SetCount(item->GetCount() + bCount2);
  6980. if (bCount == 0)
  6981. {
  6982. if (bMsg)
  6983. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("?????? ??μ?: %s"), item->GetName());
  6985. return item;
  6986. }
  6987. }
  6988. }
  6989. }
  6991. LPITEM item = ITEM_MANAGER::instance().CreateItem(dwItemVnum, bCount, 0, true);
  6992. if (!item)
  6993. {
  6994. sys_err("Cannot create item by vnum %u (name: %s).", dwItemVnum, GetName());
  6995. return NULL;
  6996. }
  6998. int iEmptyCell;
  6999. if (item->IsDragonSoul())
  7000. {
  7001. iEmptyCell = GetEmptyDragonSoulInventory(item);
  7002. }
  7003. else
  7004. iEmptyCell = GetEmptyInventory(item->GetSize());
  7006. if (iEmptyCell != -1)
  7007. {
  7008. if (bMsg)
  7009. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("?????? ??μ?: %s"), item->GetName());
  7011. if (item->IsDragonSoul())
  7012. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  7013. else
  7014. item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
  7016. item->SetSocket(1, iSocketTwo);
  7017. LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
  7018. }
  7019. else
  7020. {
  7021. item->AddToGround(GetMapIndex(), GetXYZ());
  7022. item->SetSocket(1, iSocketTwo);
  7023. item->StartDestroyEvent();
  7024. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP))
  7025. item->SetOwnership(this, 300);
  7026. else
  7027. item->SetOwnership(this, 60);
  7029. LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
  7030. }
  7032. sys_log(0, "Acce received: %d %d", dwItemVnum, bCount);
  7033. return item;
  7034. }
  7036. bool CHARACTER::GiveItem(LPCHARACTER victim, TItemPos Cell)
  7037. {
  7038. if (!CanHandleItem())
  7039. return false;
  7041. LPITEM item = GetItem(Cell);
  7043. if (item && !item->IsExchanging())
  7044. {
  7045. if (victim->CanReceiveItem(this, item))
  7046. {
  7047. victim->ReceiveItem(this, item);
  7048. return true;
  7049. }
  7050. }
  7052. return false;
  7053. }
  7055. bool CHARACTER::CanReceiveItem(LPCHARACTER from, LPITEM item) const
  7056. {
  7057. if (IsPC())
  7058. return false;
  7060. // TOO_LONG_DISTANCE_EXCHANGE_BUG_FIX
  7061. if (DISTANCE_APPROX(GetX() - from->GetX(), GetY() - from->GetY()) > 2000)
  7062. return false;
  7063. // END_OF_TOO_LONG_DISTANCE_EXCHANGE_BUG_FIX
  7065. switch (GetRaceNum())
  7066. {
  7067. case fishing::CAMPFIRE_MOB:
  7068. if (item->GetType() == ITEM_FISH &&
  7069. (item->GetSubType() == FISH_ALIVE || item->GetSubType() == FISH_DEAD))
  7070. return true;
  7071. break;
  7073. case fishing::FISHER_MOB:
  7074. if (item->GetType() == ITEM_ROD)
  7075. return true;
  7076. break;
  7078. // BUILDING_NPC
  7079. case BLACKSMITH_WEAPON_MOB:
  7080. case DEVILTOWER_BLACKSMITH_WEAPON_MOB:
  7081. if (item->GetType() == ITEM_WEAPON &&
  7082. item->GetRefinedVnum())
  7083. return true;
  7084. else
  7085. return false;
  7086. break;
  7088. case BLACKSMITH_ARMOR_MOB:
  7089. case DEVILTOWER_BLACKSMITH_ARMOR_MOB:
  7090. if (item->GetType() == ITEM_ARMOR &&
  7091. (item->GetSubType() == ARMOR_BODY || item->GetSubType() == ARMOR_SHIELD || item->GetSubType() == ARMOR_HEAD) &&
  7092. item->GetRefinedVnum())
  7093. return true;
  7094. else
  7095. return false;
  7096. break;
  7098. case BLACKSMITH_ACCESSORY_MOB:
  7099. case DEVILTOWER_BLACKSMITH_ACCESSORY_MOB:
  7100. if (item->GetType() == ITEM_ARMOR &&
  7101. !(item->GetSubType() == ARMOR_BODY || item->GetSubType() == ARMOR_SHIELD || item->GetSubType() == ARMOR_HEAD) &&
  7102. item->GetRefinedVnum())
  7103. return true;
  7104. else
  7105. return false;
  7106. break;
  7107. // END_OF_BUILDING_NPC
  7109. case BLACKSMITH_MOB:
  7110. if (item->GetRefinedVnum() && item->GetRefineSet() < 500)
  7111. {
  7112. return true;
  7113. }
  7114. else
  7115. {
  7116. return false;
  7117. }
  7119. case BLACKSMITH2_MOB:
  7120. if (item->GetRefineSet() >= 500)
  7121. {
  7122. return true;
  7123. }
  7124. else
  7125. {
  7126. return false;
  7127. }
  7129. case ALCHEMIST_MOB:
  7130. if (item->GetRefinedVnum())
  7131. return true;
  7132. break;
  7134. case 20101:
  7135. case 20102:
  7136. case 20103:
  7137. // 초급 말
  7138. if (item->GetVnum() == ITEM_REVIVE_HORSE_1)
  7139. {
  7140. if (!IsDead())
  7141. {
  7142. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽지 않은 말에게 선초를 먹일 수 없습니다."));
  7143. return false;
  7144. }
  7145. return true;
  7146. }
  7147. else if (item->GetVnum() == ITEM_HORSE_FOOD_1)
  7148. {
  7149. if (IsDead())
  7150. {
  7151. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽은 말에게 사료를 먹일 수 없습니다."));
  7152. return false;
  7153. }
  7154. return true;
  7155. }
  7156. else if (item->GetVnum() == ITEM_HORSE_FOOD_2 || item->GetVnum() == ITEM_HORSE_FOOD_3)
  7157. {
  7158. return false;
  7159. }
  7160. break;
  7161. case 20104:
  7162. case 20105:
  7163. case 20106:
  7164. // 중급 말
  7165. if (item->GetVnum() == ITEM_REVIVE_HORSE_2)
  7166. {
  7167. if (!IsDead())
  7168. {
  7169. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽지 않은 말에게 선초를 먹일 수 없습니다."));
  7170. return false;
  7171. }
  7172. return true;
  7173. }
  7174. else if (item->GetVnum() == ITEM_HORSE_FOOD_2)
  7175. {
  7176. if (IsDead())
  7177. {
  7178. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽은 말에게 사료를 먹일 수 없습니다."));
  7179. return false;
  7180. }
  7181. return true;
  7182. }
  7183. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 || item->GetVnum() == ITEM_HORSE_FOOD_3)
  7184. {
  7185. return false;
  7186. }
  7187. break;
  7188. case 20107:
  7189. case 20108:
  7190. case 20109:
  7191. // 고급 말
  7192. if (item->GetVnum() == ITEM_REVIVE_HORSE_3)
  7193. {
  7194. if (!IsDead())
  7195. {
  7196. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽지 않은 말에게 선초를 먹일 수 없습니다."));
  7197. return false;
  7198. }
  7199. return true;
  7200. }
  7201. else if (item->GetVnum() == ITEM_HORSE_FOOD_3)
  7202. {
  7203. if (IsDead())
  7204. {
  7205. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽은 말에게 사료를 먹일 수 없습니다."));
  7206. return false;
  7207. }
  7208. return true;
  7209. }
  7210. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 || item->GetVnum() == ITEM_HORSE_FOOD_2)
  7211. {
  7212. return false;
  7213. }
  7214. break;
  7215. }
  7217. //if (IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_GIVE))
  7218. {
  7219. return true;
  7220. }
  7222. return false;
  7223. }
  7225. void CHARACTER::ReceiveItem(LPCHARACTER from, LPITEM item)
  7226. {
  7227. if (IsPC())
  7228. return;
  7230. switch (GetRaceNum())
  7231. {
  7232. case fishing::CAMPFIRE_MOB:
  7233. if (item->GetType() == ITEM_FISH && (item->GetSubType() == FISH_ALIVE || item->GetSubType() == FISH_DEAD))
  7234. fishing::Grill(from, item);
  7235. else
  7236. {
  7237. // TAKE_ITEM_BUG_FIX
  7238. from->SetQuestNPCID(GetVID());
  7239. // END_OF_TAKE_ITEM_BUG_FIX
  7240. quest::CQuestManager::instance().TakeItem(from->GetPlayerID(), GetRaceNum(), item);
  7241. }
  7242. break;
  7244. // DEVILTOWER_NPC
  7245. case DEVILTOWER_BLACKSMITH_WEAPON_MOB:
  7246. case DEVILTOWER_BLACKSMITH_ARMOR_MOB:
  7247. case DEVILTOWER_BLACKSMITH_ACCESSORY_MOB:
  7248. if (item->GetRefinedVnum() != 0 && item->GetRefineSet() != 0 && item->GetRefineSet() < 500)
  7249. {
  7250. from->SetRefineNPC(this);
  7251. from->RefineInformation(item->GetCell(), REFINE_TYPE_MONEY_ONLY);
  7252. }
  7253. else
  7254. {
  7255. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  7256. }
  7257. break;
  7258. // END_OF_DEVILTOWER_NPC
  7260. case BLACKSMITH_MOB:
  7261. case BLACKSMITH2_MOB:
  7262. case BLACKSMITH_WEAPON_MOB:
  7263. case BLACKSMITH_ARMOR_MOB:
  7264. case BLACKSMITH_ACCESSORY_MOB:
  7265. if (item->GetRefinedVnum())
  7266. {
  7267. from->SetRefineNPC(this);
  7268. from->RefineInformation(item->GetCell(), REFINE_TYPE_NORMAL);
  7269. }
  7270. else
  7271. {
  7272. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  7273. }
  7274. break;
  7276. case 20101:
  7277. case 20102:
  7278. case 20103:
  7279. case 20104:
  7280. case 20105:
  7281. case 20106:
  7282. case 20107:
  7283. case 20108:
  7284. case 20109:
  7285. if (item->GetVnum() == ITEM_REVIVE_HORSE_1 ||
  7286. item->GetVnum() == ITEM_REVIVE_HORSE_2 ||
  7287. item->GetVnum() == ITEM_REVIVE_HORSE_3)
  7288. {
  7289. from->ReviveHorse();
  7290. item->SetCount(item->GetCount()-1);
  7291. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("말에게 선초를 주었습니다."));
  7292. }
  7293. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 ||
  7294. item->GetVnum() == ITEM_HORSE_FOOD_2 ||
  7295. item->GetVnum() == ITEM_HORSE_FOOD_3)
  7296. {
  7297. from->FeedHorse();
  7298. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("말에게 사료를 주었습니다."));
  7299. item->SetCount(item->GetCount()-1);
  7300. EffectPacket(SE_HPUP_RED);
  7301. }
  7302. break;
  7304. default:
  7305. sys_log(0, "TakeItem %s %d %s", from->GetName(), GetRaceNum(), item->GetName());
  7306. from->SetQuestNPCID(GetVID());
  7307. quest::CQuestManager::instance().TakeItem(from->GetPlayerID(), GetRaceNum(), item);
  7308. break;
  7309. }
  7310. }
  7312. bool CHARACTER::IsEquipUniqueItem(DWORD dwItemVnum) const
  7313. {
  7314. {
  7315. LPITEM u = GetWear(WEAR_UNIQUE1);
  7317. if (u && u->GetVnum() == dwItemVnum)
  7318. return true;
  7319. }
  7321. {
  7322. LPITEM u = GetWear(WEAR_UNIQUE2);
  7324. if (u && u->GetVnum() == dwItemVnum)
  7325. return true;
  7326. }
  7328. {
  7329. LPITEM u = GetWear(WEAR_COSTUME_MOUNT);
  7331. if (u && u->GetVnum() == dwItemVnum)
  7332. return true;
  7333. }
  7335. if (dwItemVnum == UNIQUE_ITEM_RING_OF_LANGUAGE)
  7336. return IsEquipUniqueItem(UNIQUE_ITEM_RING_OF_LANGUAGE_SAMPLE);
  7338. return false;
  7339. }
  7341. // CHECK_UNIQUE_GROUP
  7342. bool CHARACTER::IsEquipUniqueGroup(DWORD dwGroupVnum) const
  7343. {
  7344. {
  7345. LPITEM u = GetWear(WEAR_UNIQUE1);
  7347. if (u && u->GetSpecialGroup() == (int)dwGroupVnum)
  7348. return true;
  7349. }
  7351. {
  7352. LPITEM u = GetWear(WEAR_UNIQUE2);
  7354. if (u && u->GetSpecialGroup() == (int)dwGroupVnum)
  7355. return true;
  7356. }
  7358. {
  7359. LPITEM u = GetWear(WEAR_COSTUME_MOUNT);
  7361. if (u && u->GetSpecialGroup() == (int)dwGroupVnum)
  7362. return true;
  7363. }
  7365. return false;
  7366. }
  7367. // END_OF_CHECK_UNIQUE_GROUP
  7369. void CHARACTER::SetRefineMode(int iAdditionalCell)
  7370. {
  7371. m_iRefineAdditionalCell = iAdditionalCell;
  7372. m_bUnderRefine = true;
  7373. }
  7375. void CHARACTER::ClearRefineMode()
  7376. {
  7377. m_bUnderRefine = false;
  7378. SetRefineNPC( NULL );
  7379. }
  7381. bool CHARACTER::GiveItemFromSpecialItemGroup(DWORD dwGroupNum, std::vector<DWORD> &dwItemVnums,
  7382. std::vector<DWORD> &dwItemCounts, std::vector <LPITEM> &item_gets, int &count)
  7383. {
  7384. const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(dwGroupNum);
  7386. if (!pGroup)
  7387. {
  7388. sys_err("cannot find special item group %d", dwGroupNum);
  7389. return false;
  7390. }
  7392. std::vector <int> idxes;
  7393. int n = pGroup->GetMultiIndex(idxes);
  7395. bool bSuccess;
  7397. for (int i = 0; i < n; i++)
  7398. {
  7399. bSuccess = false;
  7400. int idx = idxes[i];
  7401. DWORD dwVnum = pGroup->GetVnum(idx);
  7402. DWORD dwCount = pGroup->GetCount(idx);
  7403. int iRarePct = pGroup->GetRarePct(idx);
  7404. LPITEM item_get = NULL;
  7405. switch (dwVnum)
  7406. {
  7407. case CSpecialItemGroup::GOLD:
  7408. PointChange(POINT_GOLD, dwCount);
  7409. LogManager::instance().CharLog(this, dwCount, "TREASURE_GOLD", "");
  7411. bSuccess = true;
  7412. break;
  7413. case CSpecialItemGroup::EXP:
  7414. {
  7415. PointChange(POINT_EXP, dwCount);
  7416. LogManager::instance().CharLog(this, dwCount, "TREASURE_EXP", "");
  7418. bSuccess = true;
  7419. }
  7420. break;
  7422. case CSpecialItemGroup::MOB:
  7423. {
  7424. sys_log(0, "CSpecialItemGroup::MOB %d", dwCount);
  7425. int x = GetX() + number(-500, 500);
  7426. int y = GetY() + number(-500, 500);
  7428. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(dwCount, GetMapIndex(), x, y, 0, true, -1);
  7429. if (ch)
  7430. ch->SetAggressive();
  7431. bSuccess = true;
  7432. }
  7433. break;
  7434. case CSpecialItemGroup::SLOW:
  7435. {
  7436. sys_log(0, "CSpecialItemGroup::SLOW %d", -(int)dwCount);
  7437. AddAffect(AFFECT_SLOW, POINT_MOV_SPEED, -(int)dwCount, AFF_SLOW, 300, 0, true);
  7438. bSuccess = true;
  7439. }
  7440. break;
  7441. case CSpecialItemGroup::DRAIN_HP:
  7442. {
  7443. int iDropHP = GetMaxHP()*dwCount/100;
  7444. sys_log(0, "CSpecialItemGroup::DRAIN_HP %d", -iDropHP);
  7445. iDropHP = MIN(iDropHP, GetHP()-1);
  7446. sys_log(0, "CSpecialItemGroup::DRAIN_HP %d", -iDropHP);
  7447. PointChange(POINT_HP, -iDropHP);
  7448. bSuccess = true;
  7449. }
  7450. break;
  7451. case CSpecialItemGroup::POISON:
  7452. {
  7453. AttackedByPoison(NULL);
  7454. bSuccess = true;
  7455. }
  7456. break;
  7458. case CSpecialItemGroup::MOB_GROUP:
  7459. {
  7460. int sx = GetX() - number(300, 500);
  7461. int sy = GetY() - number(300, 500);
  7462. int ex = GetX() + number(300, 500);
  7463. int ey = GetY() + number(300, 500);
  7464. CHARACTER_MANAGER::instance().SpawnGroup(dwCount, GetMapIndex(), sx, sy, ex, ey, NULL, true);
  7466. bSuccess = true;
  7467. }
  7468. break;
  7469. default:
  7470. {
  7471. item_get = AutoGiveItem(dwVnum, dwCount, iRarePct);
  7473. if (item_get)
  7474. {
  7475. bSuccess = true;
  7476. }
  7477. }
  7478. break;
  7479. }
  7481. if (bSuccess)
  7482. {
  7483. dwItemVnums.push_back(dwVnum);
  7484. dwItemCounts.push_back(dwCount);
  7485. item_gets.push_back(item_get);
  7486. count++;
  7488. }
  7489. else
  7490. {
  7491. return false;
  7492. }
  7493. }
  7494. return bSuccess;
  7495. }
  7497. // NEW_HAIR_STYLE_ADD
  7498. bool CHARACTER::ItemProcess_Hair(LPITEM item, int iDestCell)
  7499. {
  7500. if (item->CheckItemUseLevel(GetLevel()) == false)
  7501. {
  7502. // 레벨 제한에 걸림
  7503. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 이 머리를 사용할 수 없는 레벨입니다."));
  7504. return false;
  7505. }
  7507. DWORD hair = item->GetVnum();
  7509. switch (GetJob())
  7510. {
  7511. case JOB_WARRIOR :
  7512. hair -= 72000; // 73001 - 72000 = 1001 부터 헤어 번호 시작
  7513. break;
  7515. case JOB_ASSASSIN :
  7516. hair -= 71250;
  7517. break;
  7519. case JOB_SURA :
  7520. hair -= 70500;
  7521. break;
  7523. case JOB_SHAMAN :
  7524. hair -= 69750;
  7525. break;
  7527. default :
  7528. return false;
  7529. break;
  7530. }
  7532. if (hair == GetPart(PART_HAIR))
  7533. {
  7534. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("동일한 머리 스타일로는 교체할 수 없습니다."));
  7535. return true;
  7536. }
  7538. item->SetCount(item->GetCount() - 1);
  7540. SetPart(PART_HAIR, hair);
  7541. UpdatePacket();
  7543. return true;
  7544. }
  7545. // END_NEW_HAIR_STYLE_ADD
  7547. bool CHARACTER::ItemProcess_Polymorph(LPITEM item)
  7548. {
  7549. if (IsPolymorphed())
  7550. {
  7551. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 둔갑중인 상태입니다."));
  7552. return false;
  7553. }
  7555. if (true == IsRiding())
  7556. {
  7557. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑할 수 없는 상태입니다."));
  7558. return false;
  7559. }
  7561. DWORD dwVnum = item->GetSocket(0);
  7563. if (dwVnum == 0)
  7564. {
  7565. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("잘못된 둔갑 아이템입니다."));
  7566. item->SetCount(item->GetCount()-1);
  7567. return false;
  7568. }
  7570. const CMob* pMob = CMobManager::instance().Get(dwVnum);
  7572. if (pMob == NULL)
  7573. {
  7574. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("잘못된 둔갑 아이템입니다."));
  7575. item->SetCount(item->GetCount()-1);
  7576. return false;
  7577. }
  7579. switch (item->GetVnum())
  7580. {
  7581. case 70104 :
  7582. case 70105 :
  7583. case 70106 :
  7584. case 70107 :
  7585. case 71093 :
  7586. {
  7587. // 둔갑구 처리
  7588. sys_log(0, "USE_POLYMORPH_BALL PID(%d) vnum(%d)", GetPlayerID(), dwVnum);
  7590. // 레벨 제한 체크
  7591. int iPolymorphLevelLimit = MAX(0, 20 - GetLevel() * 3 / 10);
  7592. if (pMob->m_table.bLevel >= GetLevel() + iPolymorphLevelLimit)
  7593. {
  7594. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("나보다 너무 높은 레벨의 몬스터로는 변신 할 수 없습니다."));
  7595. return false;
  7596. }
  7598. int iDuration = GetSkillLevel(POLYMORPH_SKILL_ID) == 0 ? 5 : (5 + (5 + GetSkillLevel(POLYMORPH_SKILL_ID)/40 * 25));
  7599. iDuration *= 60;
  7601. DWORD dwBonus = 0;
  7603. if (true == LC_IsYMIR() || true == LC_IsKorea())
  7604. {
  7605. dwBonus = GetSkillLevel(POLYMORPH_SKILL_ID) + 60;
  7606. }
  7607. else
  7608. {
  7609. dwBonus = (2 + GetSkillLevel(POLYMORPH_SKILL_ID)/40) * 100;
  7610. }
  7612. AddAffect(AFFECT_POLYMORPH, POINT_POLYMORPH, dwVnum, AFF_POLYMORPH, iDuration, 0, true);
  7613. AddAffect(AFFECT_POLYMORPH, POINT_ATT_BONUS, dwBonus, AFF_POLYMORPH, iDuration, 0, false);
  7615. item->SetCount(item->GetCount()-1);
  7616. }
  7617. break;
  7619. case 50322:
  7620. {
  7621. // 보류
  7623. // 둔갑서 처리
  7624. // 소켓0 소켓1 소켓2
  7625. // 둔갑할 몬스터 번호 수련정도 둔갑서 레벨
  7626. sys_log(0, "USE_POLYMORPH_BOOK: %s(%u) vnum(%u)", GetName(), GetPlayerID(), dwVnum);
  7628. if (CPolymorphUtils::instance().PolymorphCharacter(this, item, pMob) == true)
  7629. {
  7630. CPolymorphUtils::instance().UpdateBookPracticeGrade(this, item);
  7631. }
  7632. else
  7633. {
  7634. }
  7635. }
  7636. break;
  7638. default :
  7639. sys_err("POLYMORPH invalid item passed PID(%d) vnum(%d)", GetPlayerID(), item->GetOriginalVnum());
  7640. return false;
  7641. }
  7643. return true;
  7644. }
  7646. bool CHARACTER::CanDoAcce() const
  7647. {
  7648. if (m_bIsObserver)
  7649. return false;
  7651. if (GetShop())
  7652. return false;
  7654. if (GetMyShop())
  7655. return false;
  7657. if (m_bUnderRefine)
  7658. return false;
  7660. if (IsWarping())
  7661. return false;
  7663. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
  7664. if (GetOfflineShop())
  7665. return false;
  7666. #endif
  7668. return true;
  7669. }
  7671. bool CHARACTER::CanDoCube() const
  7672. {
  7673. if (m_bIsObserver) return false;
  7674. if (GetShop()) return false;
  7675. if (GetMyShop()) return false;
  7676. if (m_bUnderRefine) return false;
  7677. if (IsWarping()) return false;
  7678. #ifdef ENABLE_OFFLINE_SHOP_SYSTEM
  7679. if (GetOfflineShop()) return false;
  7680. #endif
  7682. return true;
  7683. }
  7685. bool CHARACTER::UnEquipSpecialRideUniqueItem()
  7686. {
  7687. LPITEM Unique1 = GetWear(WEAR_UNIQUE1);
  7688. LPITEM Unique2 = GetWear(WEAR_UNIQUE2);
  7689. LPITEM Unique3 = GetWear(WEAR_COSTUME_MOUNT);
  7691. if (NULL != Unique1)
  7692. {
  7693. if (UNIQUE_GROUP_SPECIAL_RIDE == Unique1->GetSpecialGroup())
  7694. {
  7695. return UnequipItem(Unique1);
  7696. }
  7697. }
  7699. if (NULL != Unique2)
  7700. {
  7701. if (UNIQUE_GROUP_SPECIAL_RIDE == Unique2->GetSpecialGroup())
  7702. {
  7703. return UnequipItem(Unique2);
  7704. }
  7705. }
  7707. if (NULL != Unique3)
  7708. {
  7709. if (UNIQUE_GROUP_SPECIAL_RIDE == Unique3->GetSpecialGroup())
  7710. {
  7711. return UnequipItem(Unique3);
  7712. }
  7713. }
  7715. return true;
  7716. }
  7718. void CHARACTER::AutoRecoveryItemProcess(const EAffectTypes type)
  7719. {
  7720. if (true == IsDead() || true == IsStun())
  7721. return;
  7723. if (false == IsPC())
  7724. return;
  7726. if (AFFECT_AUTO_HP_RECOVERY != type && AFFECT_AUTO_SP_RECOVERY != type)
  7727. return;
  7729. if (NULL != FindAffect(AFFECT_STUN))
  7730. return;
  7732. {
  7733. const DWORD stunSkills[] = { SKILL_TANHWAN, SKILL_GEOMPUNG, SKILL_BYEURAK, SKILL_GIGUNG };
  7735. for (size_t i=0 ; i < sizeof(stunSkills)/sizeof(DWORD) ; ++i)
  7736. {
  7737. const CAffect* p = FindAffect(stunSkills[i]);
  7739. if (NULL != p && AFF_STUN == p->dwFlag)
  7740. return;
  7741. }
  7742. }
  7744. const CAffect* pAffect = FindAffect(type);
  7745. const size_t idx_of_amount_of_used = 1;
  7746. const size_t idx_of_amount_of_full = 2;
  7748. if (NULL != pAffect)
  7749. {
  7750. LPITEM pItem = FindItemByID(pAffect->dwFlag);
  7752. if (NULL != pItem && true == pItem->GetSocket(0))
  7753. {
  7754. if (false == CArenaManager::instance().IsArenaMap(GetMapIndex()))
  7755. {
  7756. const long amount_of_used = pItem->GetSocket(idx_of_amount_of_used);
  7757. const long amount_of_full = pItem->GetSocket(idx_of_amount_of_full);
  7759. const int32_t avail = amount_of_full - amount_of_used;
  7761. int32_t amount = 0;
  7763. if (AFFECT_AUTO_HP_RECOVERY == type)
  7764. {
  7765. amount = GetMaxHP() - (GetHP() + GetPoint(POINT_HP_RECOVERY));
  7766. }
  7767. else if (AFFECT_AUTO_SP_RECOVERY == type)
  7768. {
  7769. amount = GetMaxSP() - (GetSP() + GetPoint(POINT_SP_RECOVERY));
  7770. }
  7772. if (amount > 0)
  7773. {
  7774. if (avail > amount)
  7775. {
  7776. const int pct_of_used = amount_of_used * 100 / amount_of_full;
  7777. const int pct_of_will_used = (amount_of_used + amount) * 100 / amount_of_full;
  7779. bool bLog = false;
  7780. // 사용량의 10% 단위로 로그를 남김
  7781. // (사용량의 %에서, 십의 자리가 바뀔 때마다 로그를 남김.)
  7782. if ((pct_of_will_used / 10) - (pct_of_used / 10) >= 1)
  7783. bLog = true;
  7784. pItem->SetSocket(idx_of_amount_of_used, amount_of_used + amount, bLog);
  7785. }
  7786. else
  7787. {
  7788. amount = avail;
  7790. ITEM_MANAGER::instance().RemoveItem( pItem );
  7791. }
  7793. if (AFFECT_AUTO_HP_RECOVERY == type)
  7794. {
  7795. PointChange( POINT_HP_RECOVERY, amount );
  7796. EffectPacket( SE_AUTO_HPUP );
  7797. }
  7798. else if (AFFECT_AUTO_SP_RECOVERY == type)
  7799. {
  7800. PointChange( POINT_SP_RECOVERY, amount );
  7801. EffectPacket( SE_AUTO_SPUP );
  7802. }
  7803. }
  7804. }
  7805. else
  7806. {
  7807. pItem->Lock(false);
  7808. pItem->SetSocket(0, false);
  7809. RemoveAffect( const_cast<CAffect*>(pAffect) );
  7810. }
  7811. }
  7812. else
  7813. {
  7814. RemoveAffect( const_cast<CAffect*>(pAffect) );
  7815. }
  7816. }
  7817. }
  7819. bool CHARACTER::IsValidItemPosition(TItemPos Pos) const
  7820. {
  7821. BYTE window_type = Pos.window_type;
  7822. WORD cell = Pos.cell;
  7824. switch (window_type)
  7825. {
  7826. case RESERVED_WINDOW:
  7827. return false;
  7829. case INVENTORY:
  7830. case EQUIPMENT:
  7831. return cell < (INVENTORY_AND_EQUIP_SLOT_MAX);
  7833. case DRAGON_SOUL_INVENTORY:
  7834. return cell < (DRAGON_SOUL_INVENTORY_MAX_NUM);
  7836. case SAFEBOX:
  7837. if (NULL != m_pkSafebox)
  7838. return m_pkSafebox->IsValidPosition(cell);
  7839. else
  7840. return false;
  7842. case MALL:
  7843. if (NULL != m_pkMall)
  7844. return m_pkMall->IsValidPosition(cell);
  7845. else
  7846. return false;
  7847. default:
  7848. return false;
  7849. }
  7850. }
  7853. // 귀찮아서 만든 매크로.. exp가 true면 msg를 출력하고 return false 하는 매크로 (일반적인 verify 용도랑은 return 때문에 약간 반대라 이름때문에 헷갈릴 수도 있겠다..)
  7854. #define VERIFY_MSG(exp, msg) \
  7855. if (true == (exp)) { \
  7856. ChatPacket(CHAT_TYPE_INFO, LC_TEXT(msg)); \
  7857. return false; \
  7858. }
  7861. /// 현재 캐릭터의 상태를 바탕으로 주어진 item을 착용할 수 있는 지 확인하고, 불가능 하다면 캐릭터에게 이유를 알려주는 함수
  7862. bool CHARACTER::CanEquipNow(const LPITEM item, const TItemPos& srcCell, const TItemPos& destCell) /*const*/
  7863. {
  7864. const TItemTable* itemTable = item->GetProto();
  7865. BYTE itemType = item->GetType();
  7866. BYTE itemSubType = item->GetSubType();
  7868. switch (GetJob())
  7869. {
  7870. case JOB_WARRIOR:
  7871. if (item->GetAntiFlag() & ITEM_ANTIFLAG_WARRIOR)
  7872. return false;
  7873. break;
  7875. case JOB_ASSASSIN:
  7876. if (item->GetAntiFlag() & ITEM_ANTIFLAG_ASSASSIN)
  7877. return false;
  7878. break;
  7880. case JOB_SHAMAN:
  7881. if (item->GetAntiFlag() & ITEM_ANTIFLAG_SHAMAN)
  7882. return false;
  7883. break;
  7885. case JOB_SURA:
  7886. if (item->GetAntiFlag() & ITEM_ANTIFLAG_SURA)
  7887. return false;
  7888. break;
  7889. }
  7891. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  7892. {
  7893. long limit = itemTable->aLimits[i].lValue;
  7894. switch (itemTable->aLimits[i].bType)
  7895. {
  7896. case LIMIT_LEVEL:
  7897. if (GetLevel() < limit)
  7898. {
  7899. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("레벨이 낮아 착용할 수 없습니다."));
  7900. return false;
  7901. }
  7902. break;
  7904. case LIMIT_STR:
  7905. if (GetPoint(POINT_ST) < limit)
  7906. {
  7907. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("근력이 낮아 착용할 수 없습니다."));
  7908. return false;
  7909. }
  7910. break;
  7912. case LIMIT_INT:
  7913. if (GetPoint(POINT_IQ) < limit)
  7914. {
  7915. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("지능이 낮아 착용할 수 없습니다."));
  7916. return false;
  7917. }
  7918. break;
  7920. case LIMIT_DEX:
  7921. if (GetPoint(POINT_DX) < limit)
  7922. {
  7923. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("민첩이 낮아 착용할 수 없습니다."));
  7924. return false;
  7925. }
  7926. break;
  7928. case LIMIT_CON:
  7929. if (GetPoint(POINT_HT) < limit)
  7930. {
  7931. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("체력이 낮아 착용할 수 없습니다."));
  7932. return false;
  7933. }
  7934. break;
  7935. }
  7936. }
  7938. if (item->GetWearFlag() & WEARABLE_UNIQUE)
  7939. {
  7940. if ((GetWear(WEAR_UNIQUE1) && GetWear(WEAR_UNIQUE1)->IsSameSpecialGroup(item)) ||
  7941. (GetWear(WEAR_UNIQUE2) && GetWear(WEAR_UNIQUE2)->IsSameSpecialGroup(item)) ||
  7942. (GetWear(WEAR_COSTUME_MOUNT) && GetWear(WEAR_COSTUME_MOUNT)->IsSameSpecialGroup(item)))
  7943. {
  7944. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("?? ??? ??? ??? ? ?? ??? ??? ? ????."));
  7945. return false;
  7946. }
  7948. if (marriage::CManager::instance().IsMarriageUniqueItem(item->GetVnum()) &&
  7949. !marriage::CManager::instance().IsMarried(GetPlayerID()))
  7950. {
  7951. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°aE￥CIAo ¾EAº ≫oAA¿¡¼­ ¿¹¹°A≫ Aø¿eCO ¼o ¾ø½A´I´U."));
  7952. return false;
  7953. }
  7955. if (item->GetType() & ITEM_RING)
  7956. {
  7957. if ((GetWear(WEAR_RING1) && GetWear(WEAR_RING1)->IsSameSpecialGroup(item)) || (GetWear(WEAR_RING2) && GetWear(WEAR_RING2)->IsSameSpecialGroup(item)))
  7958. {
  7959. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Nu poti folosi doua inele de acelasi fel"));
  7960. return false;
  7961. }
  7962. }
  7964. }
  7966. if (item->GetType() & ITEM_RING)
  7967. {
  7968. if (marriage::CManager::instance().IsMarriageUniqueItem(item->GetVnum()) &&
  7969. !marriage::CManager::instance().IsMarried(GetPlayerID()))
  7970. {
  7971. ChatPacket(CHAT_TYPE_INFO, "Nu poti folosi doua inele de acelasi fel ");
  7972. return false;
  7973. }
  7974. }
  7976. #ifdef __WEAPON_COSTUME_SYSTEM__
  7977. #ifdef __NEW_ARROW_SYSTEM__
  7978. if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_ARROW && item->GetSubType() != WEAPON_UNLIMITED_ARROW)
  7979. #else
  7980. if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_ARROW)
  7981. #endif
  7982. {
  7983. LPITEM pkItem = GetWear(WEAR_COSTUME_WEAPON);
  7984. if (pkItem)
  7985. {
  7986. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("For can do this unwear the costume weapon."));
  7987. return false;
  7988. }
  7989. }
  7990. else if (item->GetType() == ITEM_COSTUME && item->GetSubType() == COSTUME_WEAPON)
  7991. {
  7992. LPITEM pkItem = GetWear(WEAR_WEAPON);
  7993. if (!pkItem)
  7994. {
  7995. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't wear a costume weapon without have a weapon weared."));
  7996. return false;
  7997. }
  7998. else if (item->GetValue(3) != pkItem->GetSubType())
  7999. {
  8000. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't wear a costume weapon who has different type of your weapon."));
  8001. return false;
  8002. }
  8003. }
  8005. if (item->GetType() == ITEM_ROD || item->GetType() == ITEM_PICK)
  8006. {
  8007. LPITEM pkItem = GetWear(WEAR_COSTUME_WEAPON);
  8008. if (pkItem)
  8009. {
  8010. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("For can do this unwear the costume weapon."));
  8011. return false;
  8012. }
  8013. }
  8014. #endif
  8016. return true;
  8017. }
  8019. /// 현재 캐릭터의 상태를 바탕으로 착용 중인 item을 벗을 수 있는 지 확인하고, 불가능 하다면 캐릭터에게 이유를 알려주는 함수
  8020. bool CHARACTER::CanUnequipNow(const LPITEM item, const TItemPos& srcCell, const TItemPos& destCell)
  8021. {
  8022. if (ITEM_BELT == item->GetType())
  8023. VERIFY_MSG(CBeltInventoryHelper::IsExistItemInBeltInventory(this), "벨트 인벤토리에 아이템이 존재하면 해제할 수 없습니다.");
  8025. // 영원히 해제할 수 없는 아이템
  8026. if (IS_SET(item->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  8027. return false;
  8029. // 아이템 unequip시 인벤토리로 옮길 때 빈 자리가 있는 지 확인
  8030. {
  8031. int pos = -1;
  8032. if (item->IsDragonSoul())
  8033. pos = GetEmptyDragonSoulInventory(item);
  8034. else
  8035. pos = GetEmptyInventory(item->GetSize());
  8037. VERIFY_MSG( -1 == pos, "소지품에 빈 공간이 없습니다." );
  8038. }
  8040. #ifdef __WEAPON_COSTUME_SYSTEM__
  8041. #ifdef __NEW_ARROW_SYSTEM__
  8042. if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_ARROW && item->GetSubType() != WEAPON_UNLIMITED_ARROW)
  8043. #else
  8044. if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_ARROW)
  8045. #endif
  8046. {
  8047. LPITEM pkItem = GetWear(WEAR_COSTUME_WEAPON);
  8048. if (pkItem)
  8049. {
  8050. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("For can do this unwear the costume weapon."));
  8051. return false;
  8052. }
  8053. }
  8054. #endif
  8056. return true;
  8057. }