API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jul 18th, 2019
206
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 213.39 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2.  
  3. #include <stack>
  4.  
  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"
  40.  
  41. #include "safebox.h"
  42. #include "shop.h"
  43.  
  44. #ifdef ENABLE_NEWSTUFF
  45. #include "pvp.h"
  46. #endif
  47.  
  48. #include "../../common/VnumHelper.h"
  49. #include "DragonSoul.h"
  50. #include "buff_on_attributes.h"
  51. #include "belt_inventory_helper.h"
  52. #include "../../common/CommonDefines.h"
  53.  
  54. //auction_temp
  55. #ifdef __AUCTION__
  56. #include "auction_manager.h"
  57. #endif
  58. const int ITEM_BROKEN_METIN_VNUM = 28960;
  59. #define ENABLE_EFFECT_EXTRAPOT
  60. #define ENABLE_BOOKS_STACKFIX
  61.  
  62. // CHANGE_ITEM_ATTRIBUTES
  63. // const DWORD CHARACTER::msc_dwDefaultChangeItemAttrCycle = 10;
  64. const char CHARACTER::msc_szLastChangeItemAttrFlag[] = "Item.LastChangeItemAttr";
  65. // const char CHARACTER::msc_szChangeItemAttrCycleFlag[] = "change_itemattr_cycle";
  66. // END_OF_CHANGE_ITEM_ATTRIBUTES
  67. const BYTE g_aBuffOnAttrPoints[] = { POINT_ENERGY, POINT_COSTUME_ATTR_BONUS };
  68.  
  69. struct FFindStone
  70. {
  71. std::map<DWORD, LPCHARACTER> m_mapStone;
  72.  
  73. void operator()(LPENTITY pEnt)
  74. {
  75. if (pEnt->IsType(ENTITY_CHARACTER) == true)
  76. {
  77. LPCHARACTER pChar = (LPCHARACTER)pEnt;
  78.  
  79. if (pChar->IsStone() == true)
  80. {
  81. m_mapStone[(DWORD)pChar->GetVID()] = pChar;
  82. }
  83. }
  84. }
  85. };
  86.  
  87.  
  88.  
  89. static bool IS_SUMMON_ITEM(int vnum)
  90. {
  91. switch (vnum)
  92. {
  93. case 22000:
  94. case 22010:
  95. case 22011:
  96. case 22020:
  97. case ITEM_MARRIAGE_RING:
  98. return true;
  99. }
  100.  
  101. return false;
  102. }
  103.  
  104. static bool IS_MONKEY_DUNGEON(int map_index)
  105. {
  106. switch (map_index)
  107. {
  108. case 5:
  109. case 25:
  110. case 45:
  111. case 108:
  112. case 109:
  113. return true;;
  114. }
  115.  
  116. return false;
  117. }
  118.  
  119. bool IS_SUMMONABLE_ZONE(int map_index)
  120. {
  121.  
  122. if (IS_MONKEY_DUNGEON(map_index))
  123. return false;
  124. // Ľş
  125. if (IS_CASTLE_MAP(map_index))
  126. return false;
  127.  
  128. switch (map_index)
  129. {
  130. case 66 :
  131. case 71 :
  132. case 72 :
  133. case 73 :
  134. case 193 :
  135. #if 0
  136. case 184 :
  137. case 185 :
  138. case 186 :
  139. case 187 :
  140. case 188 :
  141. case 189 :
  142. #endif
  143.  
  144. case 216 :
  145. case 217 :
  146. case 208 :
  147.  
  148. case 113 : // OX Event ¸Ę
  149. return false;
  150. }
  151.  
  152. if (CBattleArena::IsBattleArenaMap(map_index)) return false;
  153.  
  154.  
  155. if (map_index > 10000) return false;
  156.  
  157. return true;
  158. }
  159.  
  160. bool IS_BOTARYABLE_ZONE(int nMapIndex)
  161. {
  162. if (!g_bEnableBootaryCheck) return true;
  163.  
  164. switch (nMapIndex)
  165. {
  166. case 1 :
  167. case 3 :
  168. case 21 :
  169. case 23 :
  170. case 41 :
  171. case 43 :
  172. return true;
  173. }
  174.  
  175. return false;
  176. }
  177.  
  178.  
  179. static bool FN_check_item_socket(LPITEM item)
  180. {
  181. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  182. {
  183. if (item->GetSocket(i) != item->GetProto()->alSockets[i])
  184. return false;
  185. }
  186.  
  187. return true;
  188. }
  189.  
  190. // item socket şą»ç -- by mhh
  191. static void FN_copy_item_socket(LPITEM dest, LPITEM src)
  192. {
  193. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  194. {
  195. dest->SetSocket(i, src->GetSocket(i));
  196. }
  197. }
  198. static bool FN_check_item_sex(LPCHARACTER ch, LPITEM item)
  199. {
  200.  
  201. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_MALE))
  202. {
  203. if (SEX_MALE==GET_SEX(ch))
  204. return false;
  205. }
  206.  
  207. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_FEMALE))
  208. {
  209. if (SEX_FEMALE==GET_SEX(ch))
  210. return false;
  211. }
  212.  
  213. return true;
  214. }
  215.  
  216.  
  217. /////////////////////////////////////////////////////////////////////////////
  218. // ITEM HANDLING
  219. /////////////////////////////////////////////////////////////////////////////
  220. bool CHARACTER::CanHandleItem(bool bSkipCheckRefine, bool bSkipObserver)
  221. {
  222. if (!bSkipObserver)
  223. if (m_bIsObserver)
  224. return false;
  225.  
  226. if (GetMyShop())
  227. return false;
  228.  
  229. if (!bSkipCheckRefine)
  230. if (m_bUnderRefine)
  231. return false;
  232.  
  233. if (IsCubeOpen() || NULL != DragonSoul_RefineWindow_GetOpener())
  234. return false;
  235.  
  236. if (IsWarping())
  237. return false;
  238. #ifdef ENABLE_ACCE_SYSTEM
  239. if ((m_bAcceCombination) || (m_bAcceAbsorption))
  240. return false;
  241. #endif
  242. return true;
  243. }
  244.  
  245. LPITEM CHARACTER::GetInventoryItem(WORD wCell) const
  246. {
  247. return GetItem(TItemPos(INVENTORY, wCell));
  248. }
  249. LPITEM CHARACTER::GetItem(TItemPos Cell) const
  250. {
  251. if (!IsValidItemPosition(Cell))
  252. return NULL;
  253. WORD wCell = Cell.cell;
  254. BYTE window_type = Cell.window_type;
  255. switch (window_type)
  256. {
  257. case INVENTORY:
  258. case EQUIPMENT:
  259. if (wCell >= INVENTORY_AND_EQUIP_SLOT_MAX)
  260. {
  261. sys_err("CHARACTER::GetInventoryItem: invalid item cell %d", wCell);
  262. return NULL;
  263. }
  264. return m_pointsInstant.pItems[wCell];
  265. case DRAGON_SOUL_INVENTORY:
  266. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  267. {
  268. sys_err("CHARACTER::GetInventoryItem: invalid DS item cell %d", wCell);
  269. return NULL;
  270. }
  271. return m_pointsInstant.pDSItems[wCell];
  272.  
  273. default:
  274. return NULL;
  275. }
  276. return NULL;
  277. }
  278.  
  279. #ifdef ENABLE_HIGHLIGHT_NEW_ITEM
  280. void CHARACTER::SetItem(TItemPos Cell, LPITEM pItem, bool bWereMine)
  281. #else
  282. void CHARACTER::SetItem(TItemPos Cell, LPITEM pItem)
  283. #endif
  284. {
  285. WORD wCell = Cell.cell;
  286. BYTE window_type = Cell.window_type;
  287. if ((unsigned long)((CItem*)pItem) == 0xff || (unsigned long)((CItem*)pItem) == 0xffffffff)
  288. {
  289. sys_err("!!! FATAL ERROR !!! item == 0xff (char: %s cell: %u)", GetName(), wCell);
  290. core_dump();
  291. return;
  292. }
  293.  
  294. if (pItem && pItem->GetOwner())
  295. {
  296. assert(!"GetOwner exist");
  297. return;
  298. }
  299.  
  300. switch(window_type)
  301. {
  302. case INVENTORY:
  303. case EQUIPMENT:
  304. {
  305. if (wCell >= INVENTORY_AND_EQUIP_SLOT_MAX)
  306. {
  307. sys_err("CHARACTER::SetItem: invalid item cell %d", wCell);
  308. return;
  309. }
  310.  
  311. LPITEM pOld = m_pointsInstant.pItems[wCell];
  312.  
  313. if (pOld)
  314. {
  315. if (wCell < INVENTORY_MAX_NUM)
  316. {
  317. for (int i = 0; i < pOld->GetSize(); ++i)
  318. {
  319. int p = wCell + (i * 5);
  320.  
  321. if (p >= INVENTORY_MAX_NUM)
  322. continue;
  323.  
  324. if (m_pointsInstant.pItems[p] && m_pointsInstant.pItems[p] != pOld)
  325. continue;
  326.  
  327. m_pointsInstant.bItemGrid[p] = 0;
  328. }
  329. }
  330. else
  331. m_pointsInstant.bItemGrid[wCell] = 0;
  332. }
  333.  
  334. if (pItem)
  335. {
  336. if (wCell < INVENTORY_MAX_NUM)
  337. {
  338. for (int i = 0; i < pItem->GetSize(); ++i)
  339. {
  340. int p = wCell + (i * 5);
  341.  
  342. if (p >= INVENTORY_MAX_NUM)
  343. continue;
  344.  
  345.  
  346.  
  347. m_pointsInstant.bItemGrid[p] = wCell + 1;
  348. }
  349. }
  350. else
  351. m_pointsInstant.bItemGrid[wCell] = wCell + 1;
  352. }
  353.  
  354. m_pointsInstant.pItems[wCell] = pItem;
  355. }
  356. break;
  357.  
  358. case DRAGON_SOUL_INVENTORY:
  359. {
  360. LPITEM pOld = m_pointsInstant.pDSItems[wCell];
  361.  
  362. if (pOld)
  363. {
  364. if (wCell < DRAGON_SOUL_INVENTORY_MAX_NUM)
  365. {
  366. for (int i = 0; i < pOld->GetSize(); ++i)
  367. {
  368. int p = wCell + (i * DRAGON_SOUL_BOX_COLUMN_NUM);
  369.  
  370. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  371. continue;
  372.  
  373. if (m_pointsInstant.pDSItems[p] && m_pointsInstant.pDSItems[p] != pOld)
  374. continue;
  375.  
  376. m_pointsInstant.wDSItemGrid[p] = 0;
  377. }
  378. }
  379. else
  380. m_pointsInstant.wDSItemGrid[wCell] = 0;
  381. }
  382.  
  383. if (pItem)
  384. {
  385. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  386. {
  387. sys_err("CHARACTER::SetItem: invalid DS item cell %d", wCell);
  388. return;
  389. }
  390.  
  391. if (wCell < DRAGON_SOUL_INVENTORY_MAX_NUM)
  392. {
  393. for (int i = 0; i < pItem->GetSize(); ++i)
  394. {
  395. int p = wCell + (i * DRAGON_SOUL_BOX_COLUMN_NUM);
  396.  
  397. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  398. continue;
  399.  
  400.  
  401.  
  402. m_pointsInstant.wDSItemGrid[p] = wCell + 1;
  403. }
  404. }
  405. else
  406. m_pointsInstant.wDSItemGrid[wCell] = wCell + 1;
  407. }
  408.  
  409. m_pointsInstant.pDSItems[wCell] = pItem;
  410. }
  411. break;
  412. default:
  413. sys_err ("Invalid Inventory type %d", window_type);
  414. return;
  415. }
  416.  
  417. if (GetDesc())
  418. {
  419.  
  420. if (pItem)
  421. {
  422. TPacketGCItemSet pack;
  423. pack.header = HEADER_GC_ITEM_SET;
  424. pack.Cell = Cell;
  425.  
  426. pack.count = pItem->GetCount();
  427. pack.vnum = pItem->GetVnum();
  428. pack.flags = pItem->GetFlag();
  429. pack.anti_flags = pItem->GetAntiFlag();
  430. #ifdef ENABLE_HIGHLIGHT_NEW_ITEM
  431. pack.highlight = !bWereMine || (Cell.window_type == DRAGON_SOUL_INVENTORY);(Cell.window_type == DRAGON_SOUL_INVENTORY);
  432. #else
  433. pack.highlight = (Cell.window_type == DRAGON_SOUL_INVENTORY);
  434. #endif
  435.  
  436. thecore_memcpy(pack.alSockets, pItem->GetSockets(), sizeof(pack.alSockets));
  437. thecore_memcpy(pack.aAttr, pItem->GetAttributes(), sizeof(pack.aAttr));
  438.  
  439. GetDesc()->Packet(&pack, sizeof(TPacketGCItemSet));
  440. }
  441. else
  442. {
  443. TPacketGCItemDelDeprecated pack;
  444. pack.header = HEADER_GC_ITEM_DEL;
  445. pack.Cell = Cell;
  446. pack.count = 0;
  447. pack.vnum = 0;
  448. memset(pack.alSockets, 0, sizeof(pack.alSockets));
  449. memset(pack.aAttr, 0, sizeof(pack.aAttr));
  450.  
  451. GetDesc()->Packet(&pack, sizeof(TPacketGCItemDelDeprecated));
  452. }
  453. }
  454.  
  455. if (pItem)
  456. {
  457. pItem->SetCell(this, wCell);
  458. switch (window_type)
  459. {
  460. case INVENTORY:
  461. case EQUIPMENT:
  462. if ((wCell < INVENTORY_MAX_NUM) || (BELT_INVENTORY_SLOT_START <= wCell && BELT_INVENTORY_SLOT_END > wCell))
  463. pItem->SetWindow(INVENTORY);
  464. else
  465. pItem->SetWindow(EQUIPMENT);
  466. break;
  467. case DRAGON_SOUL_INVENTORY:
  468. pItem->SetWindow(DRAGON_SOUL_INVENTORY);
  469. break;
  470. }
  471. }
  472. }
  473.  
  474. LPITEM CHARACTER::GetWear(BYTE bCell) const
  475. {
  476.  
  477. if (bCell >= WEAR_MAX_NUM + DRAGON_SOUL_DECK_MAX_NUM * DS_SLOT_MAX)
  478. {
  479. sys_err("CHARACTER::GetWear: invalid wear cell %d", bCell);
  480. return NULL;
  481. }
  482.  
  483. return m_pointsInstant.pItems[INVENTORY_MAX_NUM + bCell];
  484. }
  485.  
  486. void CHARACTER::SetWear(BYTE bCell, LPITEM item)
  487. {
  488.  
  489. if (bCell >= WEAR_MAX_NUM + DRAGON_SOUL_DECK_MAX_NUM * DS_SLOT_MAX)
  490. {
  491. sys_err("CHARACTER::SetItem: invalid item cell %d", bCell);
  492. return;
  493. }
  494.  
  495. SetItem(TItemPos (INVENTORY, INVENTORY_MAX_NUM + bCell), item);
  496.  
  497. if (!item && bCell == WEAR_WEAPON)
  498. {
  499.  
  500. if (IsAffectFlag(AFF_GWIGUM))
  501. RemoveAffect(SKILL_GWIGEOM);
  502.  
  503. if (IsAffectFlag(AFF_GEOMGYEONG))
  504. RemoveAffect(SKILL_GEOMKYUNG);
  505. }
  506. }
  507.  
  508. void CHARACTER::ClearItem()
  509. {
  510. int i;
  511. LPITEM item;
  512.  
  513. for (i = 0; i < INVENTORY_AND_EQUIP_SLOT_MAX; ++i)
  514. {
  515. if ((item = GetInventoryItem(i)))
  516. {
  517. item->SetSkipSave(true);
  518. ITEM_MANAGER::instance().FlushDelayedSave(item);
  519.  
  520. item->RemoveFromCharacter();
  521. M2_DESTROY_ITEM(item);
  522.  
  523. SyncQuickslot(QUICKSLOT_TYPE_ITEM, i, 255);
  524. }
  525. }
  526. for (i = 0; i < DRAGON_SOUL_INVENTORY_MAX_NUM; ++i)
  527. {
  528. if ((item = GetItem(TItemPos(DRAGON_SOUL_INVENTORY, i))))
  529. {
  530. item->SetSkipSave(true);
  531. ITEM_MANAGER::instance().FlushDelayedSave(item);
  532.  
  533. item->RemoveFromCharacter();
  534. M2_DESTROY_ITEM(item);
  535. }
  536. }
  537. }
  538.  
  539. bool CHARACTER::IsEmptyItemGrid(TItemPos Cell, BYTE bSize, int iExceptionCell) const
  540. {
  541. switch (Cell.window_type)
  542. {
  543. case INVENTORY:
  544. {
  545. WORD bCell = Cell.cell;
  546.  
  547.  
  548.  
  549. ++iExceptionCell;
  550.  
  551. if (Cell.IsBeltInventoryPosition())
  552. {
  553. LPITEM beltItem = GetWear(WEAR_BELT);
  554.  
  555. if (NULL == beltItem)
  556. return false;
  557.  
  558. if (false == CBeltInventoryHelper::IsAvailableCell(bCell - BELT_INVENTORY_SLOT_START, beltItem->GetValue(0)))
  559. return false;
  560.  
  561. if (m_pointsInstant.bItemGrid[bCell])
  562. {
  563. if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell)
  564. return true;
  565.  
  566. return false;
  567. }
  568.  
  569. if (bSize == 1)
  570. return true;
  571.  
  572. }
  573. else if (bCell >= INVENTORY_MAX_NUM)
  574. return false;
  575.  
  576. if (m_pointsInstant.bItemGrid[bCell])
  577. {
  578. if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell)
  579. {
  580. if (bSize == 1)
  581. return true;
  582.  
  583. int j = 1;
  584. BYTE bPage = bCell / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT);
  585.  
  586. do
  587. {
  588. BYTE p = bCell + (5 * j);
  589.  
  590. if (p >= INVENTORY_MAX_NUM)
  591. return false;
  592.  
  593. if (p / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT) != bPage)
  594. return false;
  595.  
  596. if (m_pointsInstant.bItemGrid[p])
  597. if (m_pointsInstant.bItemGrid[p] != iExceptionCell)
  598. return false;
  599. }
  600. while (++j < bSize);
  601.  
  602. return true;
  603. }
  604. else
  605. return false;
  606. }
  607.  
  608.  
  609. if (1 == bSize)
  610. return true;
  611. else
  612. {
  613. int j = 1;
  614. BYTE bPage = bCell / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT);
  615.  
  616. do
  617. {
  618. BYTE p = bCell + (5 * j);
  619.  
  620. if (p >= INVENTORY_MAX_NUM)
  621. return false;
  622.  
  623. if (p / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT) != bPage)
  624. return false;
  625.  
  626. if (m_pointsInstant.bItemGrid[p])
  627. if (m_pointsInstant.bItemGrid[p] != iExceptionCell)
  628. return false;
  629. }
  630. while (++j < bSize);
  631.  
  632. return true;
  633. }
  634. }
  635. break;
  636. case DRAGON_SOUL_INVENTORY:
  637. {
  638. WORD wCell = Cell.cell;
  639. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  640. return false;
  641.  
  642.  
  643.  
  644. iExceptionCell++;
  645.  
  646. if (m_pointsInstant.wDSItemGrid[wCell])
  647. {
  648. if (m_pointsInstant.wDSItemGrid[wCell] == iExceptionCell)
  649. {
  650. if (bSize == 1)
  651. return true;
  652.  
  653. int j = 1;
  654.  
  655. do
  656. {
  657. int p = wCell + (DRAGON_SOUL_BOX_COLUMN_NUM * j);
  658.  
  659. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  660. return false;
  661.  
  662. if (m_pointsInstant.wDSItemGrid[p])
  663. if (m_pointsInstant.wDSItemGrid[p] != iExceptionCell)
  664. return false;
  665. }
  666. while (++j < bSize);
  667.  
  668. return true;
  669. }
  670. else
  671. return false;
  672. }
  673.  
  674.  
  675. if (1 == bSize)
  676. return true;
  677. else
  678. {
  679. int j = 1;
  680.  
  681. do
  682. {
  683. int p = wCell + (DRAGON_SOUL_BOX_COLUMN_NUM * j);
  684.  
  685. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  686. return false;
  687.  
  688. if (m_pointsInstant.bItemGrid[p])
  689. if (m_pointsInstant.wDSItemGrid[p] != iExceptionCell)
  690. return false;
  691. }
  692. while (++j < bSize);
  693.  
  694. return true;
  695. }
  696. }
  697. }
  698. return false;
  699. }
  700.  
  701. int CHARACTER::GetEmptyInventory(BYTE size) const
  702. {
  703.  
  704.  
  705. for ( int i = 0; i < INVENTORY_MAX_NUM; ++i)
  706. if (IsEmptyItemGrid(TItemPos (INVENTORY, i), size))
  707. return i;
  708. return -1;
  709. }
  710.  
  711. int CHARACTER::GetEmptyDragonSoulInventory(LPITEM pItem) const
  712. {
  713. if (NULL == pItem || !pItem->IsDragonSoul())
  714. return -1;
  715. if (!DragonSoul_IsQualified())
  716. {
  717. return -1;
  718. }
  719. BYTE bSize = pItem->GetSize();
  720. WORD wBaseCell = DSManager::instance().GetBasePosition(pItem);
  721.  
  722. if (WORD_MAX == wBaseCell)
  723. return -1;
  724.  
  725. for (int i = 0; i < DRAGON_SOUL_BOX_SIZE; ++i)
  726. if (IsEmptyItemGrid(TItemPos(DRAGON_SOUL_INVENTORY, i + wBaseCell), bSize))
  727. return i + wBaseCell;
  728.  
  729. return -1;
  730. }
  731.  
  732. void CHARACTER::CopyDragonSoulItemGrid(std::vector<WORD>& vDragonSoulItemGrid) const
  733. {
  734. vDragonSoulItemGrid.resize(DRAGON_SOUL_INVENTORY_MAX_NUM);
  735.  
  736. std::copy(m_pointsInstant.wDSItemGrid, m_pointsInstant.wDSItemGrid + DRAGON_SOUL_INVENTORY_MAX_NUM, vDragonSoulItemGrid.begin());
  737. }
  738.  
  739. int CHARACTER::CountEmptyInventory() const
  740. {
  741. int count = 0;
  742.  
  743. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  744. if (GetInventoryItem(i))
  745. count += GetInventoryItem(i)->GetSize();
  746.  
  747. return (INVENTORY_MAX_NUM - count);
  748. }
  749.  
  750. void TransformRefineItem(LPITEM pkOldItem, LPITEM pkNewItem)
  751. {
  752. // ACCESSORY_REFINE
  753. if (pkOldItem->IsAccessoryForSocket())
  754. {
  755. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  756. {
  757. pkNewItem->SetSocket(i, pkOldItem->GetSocket(i));
  758. }
  759. //pkNewItem->StartAccessorySocketExpireEvent();
  760. }
  761. // END_OF_ACCESSORY_REFINE
  762. else
  763. {
  764.  
  765. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  766. {
  767. if (!pkOldItem->GetSocket(i))
  768. break;
  769. else
  770. pkNewItem->SetSocket(i, 1);
  771. }
  772.  
  773.  
  774. int slot = 0;
  775.  
  776. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  777. {
  778. long socket = pkOldItem->GetSocket(i);
  779.  
  780. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
  781. pkNewItem->SetSocket(slot++, socket);
  782. }
  783.  
  784. }
  785.  
  786.  
  787. pkOldItem->CopyAttributeTo(pkNewItem);
  788. }
  789.  
  790. void NotifyRefineSuccess(LPCHARACTER ch, LPITEM item, const char* way)
  791. {
  792. if (NULL != ch && item != NULL)
  793. {
  794. ch->ChatPacket(CHAT_TYPE_COMMAND, "RefineSuceeded");
  795.  
  796. LogManager::instance().RefineLog(ch->GetPlayerID(), item->GetName(), item->GetID(), item->GetRefineLevel(), 1, way);
  797. }
  798. }
  799.  
  800. void NotifyRefineFail(LPCHARACTER ch, LPITEM item, const char* way, int success = 0)
  801. {
  802. if (NULL != ch && NULL != item)
  803. {
  804. ch->ChatPacket(CHAT_TYPE_COMMAND, "RefineFailed");
  805.  
  806. LogManager::instance().RefineLog(ch->GetPlayerID(), item->GetName(), item->GetID(), item->GetRefineLevel(), success, way);
  807. }
  808. }
  809.  
  810. void CHARACTER::SetRefineNPC(LPCHARACTER ch)
  811. {
  812. if ( ch != NULL )
  813. {
  814. m_dwRefineNPCVID = ch->GetVID();
  815. }
  816. else
  817. {
  818. m_dwRefineNPCVID = 0;
  819. }
  820. }
  821.  
  822. bool CHARACTER::DoRefine(LPITEM item, bool bMoneyOnly)
  823. {
  824. if (!CanHandleItem(true))
  825. {
  826. ClearRefineMode();
  827. return false;
  828. }
  829.  
  830.  
  831.  
  832. if (quest::CQuestManager::instance().GetEventFlag("update_refine_time") != 0)
  833. {
  834. if (get_global_time() < quest::CQuestManager::instance().GetEventFlag("update_refine_time") + (60 * 5))
  835. {
  836. sys_log(0, "can't refine %d %s", GetPlayerID(), GetName());
  837. return false;
  838. }
  839. }
  840.  
  841. const TRefineTable * prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
  842.  
  843. if (!prt)
  844. return false;
  845.  
  846. DWORD result_vnum = item->GetRefinedVnum();
  847.  
  848. // REFINE_COST
  849. int cost = ComputeRefineFee(prt->cost);
  850.  
  851. int RefineChance = GetQuestFlag("main_quest_lv7.refine_chance");
  852.  
  853. if (RefineChance > 0)
  854. {
  855. if (!item->CheckItemUseLevel(20) || item->GetType() != ITEM_WEAPON)
  856. {
  857. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ą«·á °ł·® ±âȸ´Â 20 ŔĚÇĎŔÇ ą«±â¸¸ °ˇ´ÉÇŐ´Ď´Ů"));
  858. return false;
  859. }
  860.  
  861. cost = 0;
  862. SetQuestFlag("main_quest_lv7.refine_chance", RefineChance - 1);
  863. }
  864. // END_OF_REFINE_COST
  865.  
  866. if (result_vnum == 0)
  867. {
  868. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ő ŔĚ»ó °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  869. return false;
  870. }
  871.  
  872. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_TUNING)
  873. return false;
  874.  
  875. TItemTable * pProto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
  876.  
  877. if (!pProto)
  878. {
  879. sys_err("DoRefine NOT GET ITEM PROTO %d", item->GetRefinedVnum());
  880. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔş °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  881. return false;
  882. }
  883.  
  884. // REFINE_COST
  885. if (GetGold() < cost)
  886. {
  887. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°ł·®Ŕ» Çϱâ Ŕ§ÇŃ µ·ŔĚ şÎÁ·ÇŐ´Ď´Ů."));
  888. return false;
  889. }
  890.  
  891. if (!bMoneyOnly && !RefineChance)
  892. {
  893. for (int i = 0; i < prt->material_count; ++i)
  894. {
  895. if (CountSpecifyItem(prt->materials[i].vnum) < prt->materials[i].count)
  896. {
  897. if (test_server)
  898. {
  899. ChatPacket(CHAT_TYPE_INFO, "Find %d, count %d, require %d", prt->materials[i].vnum, CountSpecifyItem(prt->materials[i].vnum), prt->materials[i].count);
  900. }
  901. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°ł·®Ŕ» Çϱâ Ŕ§ÇŃ Ŕç·á°ˇ şÎÁ·ÇŐ´Ď´Ů."));
  902. return false;
  903. }
  904. }
  905.  
  906. for (int i = 0; i < prt->material_count; ++i)
  907. RemoveSpecifyItem(prt->materials[i].vnum, prt->materials[i].count);
  908. }
  909.  
  910. int prob = number(1, 100);
  911.  
  912. if (IsRefineThroughGuild() || bMoneyOnly)
  913. prob -= 10;
  914.  
  915. // END_OF_REFINE_COST
  916.  
  917. if (prob <= prt->prob)
  918. {
  919.  
  920. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
  921.  
  922. if (pkNewItem)
  923. {
  924. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  925. LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
  926.  
  927. BYTE bCell = item->GetCell();
  928.  
  929. // DETAIL_REFINE_LOG
  930. NotifyRefineSuccess(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  931. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -cost);
  932. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
  933. // END_OF_DETAIL_REFINE_LOG
  934.  
  935. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  936. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  937.  
  938. sys_log(0, "Refine Success %d", cost);
  939. pkNewItem->AttrLog();
  940. //PointChange(POINT_GOLD, -cost);
  941. sys_log(0, "PayPee %d", cost);
  942. PayRefineFee(cost);
  943. sys_log(0, "PayPee End %d", cost);
  944. }
  945. else
  946. {
  947. // DETAIL_REFINE_LOG
  948.  
  949. sys_err("cannot create item %u", result_vnum);
  950. NotifyRefineFail(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  951. // END_OF_DETAIL_REFINE_LOG
  952. }
  953. }
  954. else
  955. {
  956.  
  957. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -cost);
  958. NotifyRefineFail(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  959. item->AttrLog();
  960. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
  961.  
  962. //PointChange(POINT_GOLD, -cost);
  963. PayRefineFee(cost);
  964. }
  965.  
  966. return true;
  967. }
  968.  
  969. enum enum_RefineScrolls
  970. {
  971. CHUKBOK_SCROLL = 0,
  972. HYUNIRON_CHN = 1,
  973. YONGSIN_SCROLL = 2,
  974. MUSIN_SCROLL = 3,
  975. YAGONG_SCROLL = 4,
  976. MEMO_SCROLL = 5,
  977. BDRAGON_SCROLL = 6,
  978. };
  979.  
  980. bool CHARACTER::DoRefineWithScroll(LPITEM item)
  981. {
  982. if (!CanHandleItem(true))
  983. {
  984. ClearRefineMode();
  985. return false;
  986. }
  987.  
  988. ClearRefineMode();
  989.  
  990.  
  991.  
  992. if (quest::CQuestManager::instance().GetEventFlag("update_refine_time") != 0)
  993. {
  994. if (get_global_time() < quest::CQuestManager::instance().GetEventFlag("update_refine_time") + (60 * 5))
  995. {
  996. sys_log(0, "can't refine %d %s", GetPlayerID(), GetName());
  997. return false;
  998. }
  999. }
  1000.  
  1001. const TRefineTable * prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
  1002.  
  1003. if (!prt)
  1004. return false;
  1005.  
  1006. LPITEM pkItemScroll;
  1007.  
  1008.  
  1009. if (m_iRefineAdditionalCell < 0)
  1010. return false;
  1011.  
  1012. pkItemScroll = GetInventoryItem(m_iRefineAdditionalCell);
  1013.  
  1014. if (!pkItemScroll)
  1015. return false;
  1016.  
  1017. if (!(pkItemScroll->GetType() == ITEM_USE && pkItemScroll->GetSubType() == USE_TUNING))
  1018. return false;
  1019.  
  1020. if (pkItemScroll->GetVnum() == item->GetVnum())
  1021. return false;
  1022.  
  1023. DWORD result_vnum = item->GetRefinedVnum();
  1024. DWORD result_fail_vnum = item->GetRefineFromVnum();
  1025.  
  1026. if (result_vnum == 0)
  1027. {
  1028. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ő ŔĚ»ó °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1029. return false;
  1030. }
  1031.  
  1032. // MUSIN_SCROLL
  1033. if (pkItemScroll->GetValue(0) == MUSIN_SCROLL)
  1034. {
  1035. if (item->GetRefineLevel() >= 4)
  1036. {
  1037. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ °ł·®Ľ­·Î ´ő ŔĚ»ó °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1038. return false;
  1039. }
  1040. }
  1041. // END_OF_MUSIC_SCROLL
  1042.  
  1043. else if (pkItemScroll->GetValue(0) == MEMO_SCROLL)
  1044. {
  1045. if (item->GetRefineLevel() != pkItemScroll->GetValue(1))
  1046. {
  1047. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ °ł·®Ľ­·Î °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1048. return false;
  1049. }
  1050. }
  1051. else if (pkItemScroll->GetValue(0) == BDRAGON_SCROLL)
  1052. {
  1053. if (item->GetType() != ITEM_METIN || item->GetRefineLevel() != 4)
  1054. {
  1055. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔ¸·Î °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1056. return false;
  1057. }
  1058. }
  1059.  
  1060. TItemTable * pProto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
  1061.  
  1062. if (!pProto)
  1063. {
  1064. sys_err("DoRefineWithScroll NOT GET ITEM PROTO %d", item->GetRefinedVnum());
  1065. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔş °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1066. return false;
  1067. }
  1068.  
  1069. if (GetGold() < prt->cost)
  1070. {
  1071. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°ł·®Ŕ» Çϱâ Ŕ§ÇŃ µ·ŔĚ şÎÁ·ÇŐ´Ď´Ů."));
  1072. return false;
  1073. }
  1074.  
  1075. for (int i = 0; i < prt->material_count; ++i)
  1076. {
  1077. if (CountSpecifyItem(prt->materials[i].vnum) < prt->materials[i].count)
  1078. {
  1079. if (test_server)
  1080. {
  1081. ChatPacket(CHAT_TYPE_INFO, "Find %d, count %d, require %d", prt->materials[i].vnum, CountSpecifyItem(prt->materials[i].vnum), prt->materials[i].count);
  1082. }
  1083. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°ł·®Ŕ» Çϱâ Ŕ§ÇŃ Ŕç·á°ˇ şÎÁ·ÇŐ´Ď´Ů."));
  1084. return false;
  1085. }
  1086. }
  1087.  
  1088. for (int i = 0; i < prt->material_count; ++i)
  1089. RemoveSpecifyItem(prt->materials[i].vnum, prt->materials[i].count);
  1090.  
  1091. int prob = number(1, 100);
  1092. int success_prob = prt->prob;
  1093. bool bDestroyWhenFail = false;
  1094.  
  1095. const char* szRefineType = "SCROLL";
  1096.  
  1097. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN ||
  1098. pkItemScroll->GetValue(0) == YONGSIN_SCROLL ||
  1099. pkItemScroll->GetValue(0) == YAGONG_SCROLL)
  1100. {
  1101. const char hyuniron_prob[9] = { 100, 75, 65, 55, 45, 40, 35, 25, 20 };
  1102. const char yagong_prob[9] = { 100, 100, 90, 80, 70, 60, 50, 30, 20 };
  1103.  
  1104. if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL)
  1105. {
  1106. success_prob = hyuniron_prob[MINMAX(0, item->GetRefineLevel(), 8)];
  1107. }
  1108. else if (pkItemScroll->GetValue(0) == YAGONG_SCROLL)
  1109. {
  1110. success_prob = yagong_prob[MINMAX(0, item->GetRefineLevel(), 8)];
  1111. }
  1112. else if (pkItemScroll->GetValue(0) == HYUNIRON_CHN) {} // @fixme121
  1113. else
  1114. {
  1115. sys_err("REFINE : Unknown refine scroll item. Value0: %d", pkItemScroll->GetValue(0));
  1116. }
  1117.  
  1118. if (test_server)
  1119. {
  1120. ChatPacket(CHAT_TYPE_INFO, "[Only Test] Success_Prob %d, RefineLevel %d ", success_prob, item->GetRefineLevel());
  1121. }
  1122. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN)
  1123. bDestroyWhenFail = true;
  1124.  
  1125. // DETAIL_REFINE_LOG
  1126. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN)
  1127. {
  1128. szRefineType = "HYUNIRON";
  1129. }
  1130. else if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL)
  1131. {
  1132. szRefineType = "GOD_SCROLL";
  1133. }
  1134. else if (pkItemScroll->GetValue(0) == YAGONG_SCROLL)
  1135. {
  1136. szRefineType = "YAGONG_SCROLL";
  1137. }
  1138. // END_OF_DETAIL_REFINE_LOG
  1139. }
  1140.  
  1141. // DETAIL_REFINE_LOG
  1142. if (pkItemScroll->GetValue(0) == MUSIN_SCROLL)
  1143. {
  1144. success_prob = 100;
  1145.  
  1146. szRefineType = "MUSIN_SCROLL";
  1147. }
  1148. // END_OF_DETAIL_REFINE_LOG
  1149. else if (pkItemScroll->GetValue(0) == MEMO_SCROLL)
  1150. {
  1151. success_prob = 100;
  1152. szRefineType = "MEMO_SCROLL";
  1153. }
  1154. else if (pkItemScroll->GetValue(0) == BDRAGON_SCROLL)
  1155. {
  1156. success_prob = 80;
  1157. szRefineType = "BDRAGON_SCROLL";
  1158. }
  1159.  
  1160. pkItemScroll->SetCount(pkItemScroll->GetCount() - 1);
  1161.  
  1162. if (prob <= success_prob)
  1163. {
  1164.  
  1165. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
  1166.  
  1167. if (pkNewItem)
  1168. {
  1169. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  1170. LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
  1171.  
  1172. BYTE bCell = item->GetCell();
  1173.  
  1174. NotifyRefineSuccess(this, item, szRefineType);
  1175. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -prt->cost);
  1176. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
  1177.  
  1178. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1179. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1180. pkNewItem->AttrLog();
  1181. //PointChange(POINT_GOLD, -prt->cost);
  1182. PayRefineFee(prt->cost);
  1183. }
  1184. else
  1185. {
  1186.  
  1187. sys_err("cannot create item %u", result_vnum);
  1188. NotifyRefineFail(this, item, szRefineType);
  1189. }
  1190. }
  1191. else if (!bDestroyWhenFail && result_fail_vnum)
  1192. {
  1193.  
  1194. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_fail_vnum, 1, 0, false);
  1195.  
  1196. if (pkNewItem)
  1197. {
  1198. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  1199. LogManager::instance().ItemLog(this, pkNewItem, "REFINE FAIL", pkNewItem->GetName());
  1200.  
  1201. BYTE bCell = item->GetCell();
  1202.  
  1203. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -prt->cost);
  1204. NotifyRefineFail(this, item, szRefineType, -1);
  1205. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
  1206.  
  1207. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1208. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1209.  
  1210. pkNewItem->AttrLog();
  1211.  
  1212. //PointChange(POINT_GOLD, -prt->cost);
  1213. PayRefineFee(prt->cost);
  1214. }
  1215. else
  1216. {
  1217.  
  1218. sys_err("cannot create item %u", result_fail_vnum);
  1219. NotifyRefineFail(this, item, szRefineType);
  1220. }
  1221. }
  1222. else
  1223. {
  1224. NotifyRefineFail(this, item, szRefineType);
  1225.  
  1226. PayRefineFee(prt->cost);
  1227. }
  1228.  
  1229. return true;
  1230. }
  1231.  
  1232. bool CHARACTER::RefineInformation(BYTE bCell, BYTE bType, int iAdditionalCell)
  1233. {
  1234. if (bCell > INVENTORY_MAX_NUM)
  1235. return false;
  1236.  
  1237. LPITEM item = GetInventoryItem(bCell);
  1238.  
  1239. if (!item)
  1240. return false;
  1241.  
  1242. // REFINE_COST
  1243. if (bType == REFINE_TYPE_MONEY_ONLY && !GetQuestFlag("deviltower_zone.can_refine"))
  1244. {
  1245. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»ç±Í Ÿżö żĎ·á ş¸»óŔş ÇŃąř±îÁö »çżë°ˇ´ÉÇŐ´Ď´Ů."));
  1246. return false;
  1247. }
  1248. // END_OF_REFINE_COST
  1249.  
  1250. TPacketGCRefineInformation p;
  1251.  
  1252. p.header = HEADER_GC_REFINE_INFORMATION;
  1253. p.pos = bCell;
  1254. p.src_vnum = item->GetVnum();
  1255. p.result_vnum = item->GetRefinedVnum();
  1256. p.type = bType;
  1257.  
  1258. if (p.result_vnum == 0)
  1259. {
  1260. sys_err("RefineInformation p.result_vnum == 0");
  1261. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔş °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1262. return false;
  1263. }
  1264.  
  1265. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_TUNING)
  1266. {
  1267. if (bType == 0)
  1268. {
  1269. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔş ŔĚ ąć˝ÄŔ¸·Î´Â °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1270. return false;
  1271. }
  1272. else
  1273. {
  1274. LPITEM itemScroll = GetInventoryItem(iAdditionalCell);
  1275. if (!itemScroll || item->GetVnum() == itemScroll->GetVnum())
  1276. {
  1277. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°°Ŕş °ł·®Ľ­¸¦ ÇŐÄĄ Ľö´Â ľř˝Ŕ´Ď´Ů."));
  1278. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĂŕşąŔÇ Ľ­żÍ ÇööŔ» ÇŐÄĄ Ľö ŔÖ˝Ŕ´Ď´Ů."));
  1279. return false;
  1280. }
  1281. }
  1282. }
  1283.  
  1284. CRefineManager & rm = CRefineManager::instance();
  1285.  
  1286. const TRefineTable* prt = rm.GetRefineRecipe(item->GetRefineSet());
  1287.  
  1288. if (!prt)
  1289. {
  1290. sys_err("RefineInformation NOT GET REFINE SET %d", item->GetRefineSet());
  1291. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔş °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1292. return false;
  1293. }
  1294.  
  1295. // REFINE_COST
  1296.  
  1297. //MAIN_QUEST_LV7
  1298. if (GetQuestFlag("main_quest_lv7.refine_chance") > 0)
  1299. {
  1300.  
  1301. if (!item->CheckItemUseLevel(20) || item->GetType() != ITEM_WEAPON)
  1302. {
  1303. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ą«·á °ł·® ±âȸ´Â 20 ŔĚÇĎŔÇ ą«±â¸¸ °ˇ´ÉÇŐ´Ď´Ů"));
  1304. return false;
  1305. }
  1306. p.cost = 0;
  1307. }
  1308. else
  1309. p.cost = ComputeRefineFee(prt->cost);
  1310.  
  1311. //END_MAIN_QUEST_LV7
  1312. p.prob = prt->prob;
  1313. if (bType == REFINE_TYPE_MONEY_ONLY)
  1314. {
  1315. p.material_count = 0;
  1316. memset(p.materials, 0, sizeof(p.materials));
  1317. }
  1318. else
  1319. {
  1320. p.material_count = prt->material_count;
  1321. thecore_memcpy(&p.materials, prt->materials, sizeof(prt->materials));
  1322. }
  1323. // END_OF_REFINE_COST
  1324.  
  1325. GetDesc()->Packet(&p, sizeof(TPacketGCRefineInformation));
  1326.  
  1327. SetRefineMode(iAdditionalCell);
  1328. return true;
  1329. }
  1330.  
  1331. bool CHARACTER::RefineItem(LPITEM pkItem, LPITEM pkTarget)
  1332. {
  1333. if (!CanHandleItem())
  1334. return false;
  1335.  
  1336. if (pkItem->GetSubType() == USE_TUNING)
  1337. {
  1338.  
  1339.  
  1340. // MUSIN_SCROLL
  1341. if (pkItem->GetValue(0) == MUSIN_SCROLL)
  1342. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_MUSIN, pkItem->GetCell());
  1343. // END_OF_MUSIN_SCROLL
  1344. else if (pkItem->GetValue(0) == HYUNIRON_CHN)
  1345. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_HYUNIRON, pkItem->GetCell());
  1346. else if (pkItem->GetValue(0) == BDRAGON_SCROLL)
  1347. {
  1348. if (pkTarget->GetRefineSet() != 702) return false;
  1349. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_BDRAGON, pkItem->GetCell());
  1350. }
  1351. else
  1352. {
  1353. if (pkTarget->GetRefineSet() == 501) return false;
  1354. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_SCROLL, pkItem->GetCell());
  1355. }
  1356. }
  1357. else if (pkItem->GetSubType() == USE_DETACHMENT && IS_SET(pkTarget->GetFlag(), ITEM_FLAG_REFINEABLE))
  1358. {
  1359. LogManager::instance().ItemLog(this, pkTarget, "USE_DETACHMENT", pkTarget->GetName());
  1360.  
  1361. bool bHasMetinStone = false;
  1362.  
  1363. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; i++)
  1364. {
  1365. long socket = pkTarget->GetSocket(i);
  1366. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
  1367. {
  1368. bHasMetinStone = true;
  1369. break;
  1370. }
  1371. }
  1372.  
  1373. if (bHasMetinStone)
  1374. {
  1375. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  1376. {
  1377. long socket = pkTarget->GetSocket(i);
  1378. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
  1379. {
  1380. AutoGiveItem(socket);
  1381. //TItemTable* pTable = ITEM_MANAGER::instance().GetTable(pkTarget->GetSocket(i));
  1382. //pkTarget->SetSocket(i, pTable->alValues[2]);
  1383.  
  1384. pkTarget->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
  1385. }
  1386. }
  1387. pkItem->SetCount(pkItem->GetCount() - 1);
  1388. return true;
  1389. }
  1390. else
  1391. {
  1392. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»©łľ Ľö ŔÖ´Â ¸ŢĆľĽ®ŔĚ ľř˝Ŕ´Ď´Ů."));
  1393. return false;
  1394. }
  1395. }
  1396.  
  1397. return false;
  1398. }
  1399.  
  1400. EVENTFUNC(kill_campfire_event)
  1401. {
  1402. char_event_info* info = dynamic_cast<char_event_info*>( event->info );
  1403.  
  1404. if ( info == NULL )
  1405. {
  1406. sys_err( "kill_campfire_event> <Factor> Null pointer" );
  1407. return 0;
  1408. }
  1409.  
  1410. LPCHARACTER ch = info->ch;
  1411.  
  1412. if (ch == NULL) { // <Factor>
  1413. return 0;
  1414. }
  1415. ch->m_pkMiningEvent = NULL;
  1416. M2_DESTROY_CHARACTER(ch);
  1417. return 0;
  1418. }
  1419.  
  1420. bool CHARACTER::GiveRecallItem(LPITEM item)
  1421. {
  1422. int idx = GetMapIndex();
  1423. int iEmpireByMapIndex = -1;
  1424.  
  1425. if (idx < 20)
  1426. iEmpireByMapIndex = 1;
  1427. else if (idx < 40)
  1428. iEmpireByMapIndex = 2;
  1429. else if (idx < 60)
  1430. iEmpireByMapIndex = 3;
  1431. else if (idx < 10000)
  1432. iEmpireByMapIndex = 0;
  1433.  
  1434. switch (idx)
  1435. {
  1436. case 66:
  1437. case 216:
  1438. iEmpireByMapIndex = -1;
  1439. break;
  1440. }
  1441.  
  1442. if (iEmpireByMapIndex && GetEmpire() != iEmpireByMapIndex)
  1443. {
  1444. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±âľďÇŘ µŃ Ľö ľř´Â Ŕ§Äˇ ŔÔ´Ď´Ů."));
  1445. return false;
  1446. }
  1447.  
  1448. int pos;
  1449.  
  1450. if (item->GetCount() == 1)
  1451. {
  1452. item->SetSocket(0, GetX());
  1453. item->SetSocket(1, GetY());
  1454. }
  1455. else if ((pos = GetEmptyInventory(item->GetSize())) != -1)
  1456. {
  1457. LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), 1);
  1458.  
  1459. if (NULL != item2)
  1460. {
  1461. item2->SetSocket(0, GetX());
  1462. item2->SetSocket(1, GetY());
  1463. item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
  1464.  
  1465. item->SetCount(item->GetCount() - 1);
  1466. }
  1467. }
  1468. else
  1469. {
  1470. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽŇÁöÇ°żˇ şó °ř°ŁŔĚ ľř˝Ŕ´Ď´Ů."));
  1471. return false;
  1472. }
  1473.  
  1474. return true;
  1475. }
  1476.  
  1477. void CHARACTER::ProcessRecallItem(LPITEM item)
  1478. {
  1479. int idx;
  1480.  
  1481. if ((idx = SECTREE_MANAGER::instance().GetMapIndex(item->GetSocket(0), item->GetSocket(1))) == 0)
  1482. return;
  1483.  
  1484. int iEmpireByMapIndex = -1;
  1485.  
  1486. if (idx < 20)
  1487. iEmpireByMapIndex = 1;
  1488. else if (idx < 40)
  1489. iEmpireByMapIndex = 2;
  1490. else if (idx < 60)
  1491. iEmpireByMapIndex = 3;
  1492. else if (idx < 10000)
  1493. iEmpireByMapIndex = 0;
  1494.  
  1495. switch (idx)
  1496. {
  1497. case 66:
  1498. case 216:
  1499. iEmpireByMapIndex = -1;
  1500. break;
  1501.  
  1502. case 301:
  1503. case 302:
  1504. case 303:
  1505. case 304:
  1506. if( GetLevel() < 90 )
  1507. {
  1508. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆŔĚĹŰŔÇ ·ąş§ Á¦ÇŃş¸´Ů ·ąş§ŔĚ ł·˝Ŕ´Ď´Ů."));
  1509. return;
  1510. }
  1511. else
  1512. break;
  1513. }
  1514.  
  1515. if (iEmpireByMapIndex && GetEmpire() != iEmpireByMapIndex)
  1516. {
  1517. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±âľďµČ Ŕ§Äˇ°ˇ ŸÁ¦±ążˇ ĽÓÇŘ Ŕ־ ±ÍČŻÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1518. item->SetSocket(0, 0);
  1519. item->SetSocket(1, 0);
  1520. }
  1521. else
  1522. {
  1523. sys_log(1, "Recall: %s %d %d -> %d %d", GetName(), GetX(), GetY(), item->GetSocket(0), item->GetSocket(1));
  1524. WarpSet(item->GetSocket(0), item->GetSocket(1));
  1525. item->SetCount(item->GetCount() - 1);
  1526. }
  1527. }
  1528.  
  1529. void CHARACTER::__OpenPrivateShop()
  1530. {
  1531. #ifdef ENABLE_OPEN_SHOP_WITH_ARMOR
  1532. ChatPacket(CHAT_TYPE_COMMAND, "OpenPrivateShop");
  1533. #else
  1534. unsigned bodyPart = GetPart(PART_MAIN);
  1535. switch (bodyPart)
  1536. {
  1537. case 0:
  1538. case 1:
  1539. case 2:
  1540. ChatPacket(CHAT_TYPE_COMMAND, "OpenPrivateShop");
  1541. break;
  1542. default:
  1543. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°©żĘŔ» ąţľîľß °łŔÎ »óÁˇŔ» ż­ Ľö ŔÖ˝Ŕ´Ď´Ů."));
  1544. break;
  1545. }
  1546. #endif
  1547. }
  1548.  
  1549. // MYSHOP_PRICE_LIST
  1550. void CHARACTER::SendMyShopPriceListCmd(DWORD dwItemVnum, DWORD dwItemPrice)
  1551. {
  1552. char szLine[256];
  1553. snprintf(szLine, sizeof(szLine), "MyShopPriceList %u %u", dwItemVnum, dwItemPrice);
  1554. ChatPacket(CHAT_TYPE_COMMAND, szLine);
  1555. sys_log(0, szLine);
  1556. }
  1557.  
  1558. //
  1559.  
  1560. //
  1561. void CHARACTER::UseSilkBotaryReal(const TPacketMyshopPricelistHeader* p)
  1562. {
  1563. const TItemPriceInfo* pInfo = (const TItemPriceInfo*)(p + 1);
  1564.  
  1565. if (!p->byCount)
  1566.  
  1567. SendMyShopPriceListCmd(1, 0);
  1568. else {
  1569. for (int idx = 0; idx < p->byCount; idx++)
  1570. SendMyShopPriceListCmd(pInfo[ idx ].dwVnum, pInfo[ idx ].dwPrice);
  1571. }
  1572.  
  1573. __OpenPrivateShop();
  1574. }
  1575.  
  1576. //
  1577.  
  1578.  
  1579. //
  1580. void CHARACTER::UseSilkBotary(void)
  1581. {
  1582. if (m_bNoOpenedShop) {
  1583. DWORD dwPlayerID = GetPlayerID();
  1584. db_clientdesc->DBPacket(HEADER_GD_MYSHOP_PRICELIST_REQ, GetDesc()->GetHandle(), &dwPlayerID, sizeof(DWORD));
  1585. m_bNoOpenedShop = false;
  1586. } else {
  1587. __OpenPrivateShop();
  1588. }
  1589. }
  1590. // END_OF_MYSHOP_PRICE_LIST
  1591.  
  1592.  
  1593. int CalculateConsume(LPCHARACTER ch)
  1594. {
  1595. static const int WARP_NEED_LIFE_PERCENT = 30;
  1596. static const int WARP_MIN_LIFE_PERCENT = 10;
  1597. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  1598. int consumeLife = 0;
  1599. {
  1600. // CheckNeedLifeForWarp
  1601. const int curLife = ch->GetHP();
  1602. const int needPercent = WARP_NEED_LIFE_PERCENT;
  1603. const int needLife = ch->GetMaxHP() * needPercent / 100;
  1604. if (curLife < needLife)
  1605. {
  1606. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ł˛Ŕş »ý¸í·Â ľçŔĚ ¸đŔÚ¶ó »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1607. return -1;
  1608. }
  1609.  
  1610. consumeLife = needLife;
  1611.  
  1612.  
  1613.  
  1614. const int minPercent = WARP_MIN_LIFE_PERCENT;
  1615. const int minLife = ch->GetMaxHP() * minPercent / 100;
  1616. if (curLife - needLife < minLife)
  1617. consumeLife = curLife - minLife;
  1618.  
  1619. if (consumeLife < 0)
  1620. consumeLife = 0;
  1621. }
  1622. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  1623. return consumeLife;
  1624. }
  1625.  
  1626. int CalculateConsumeSP(LPCHARACTER lpChar)
  1627. {
  1628. static const int NEED_WARP_SP_PERCENT = 30;
  1629.  
  1630. const int curSP = lpChar->GetSP();
  1631. const int needSP = lpChar->GetMaxSP() * NEED_WARP_SP_PERCENT / 100;
  1632.  
  1633. if (curSP < needSP)
  1634. {
  1635. lpChar->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ł˛Ŕş Á¤˝Ĺ·Â ľçŔĚ ¸đŔÚ¶ó »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1636. return -1;
  1637. }
  1638.  
  1639. return needSP;
  1640. }
  1641.  
  1642. #define ENABLE_FIREWORK_STUN
  1643. #define ENABLE_ADDSTONE_FAILURE
  1644. bool CHARACTER::UseItemEx(LPITEM item, TItemPos DestCell)
  1645. {
  1646. int iLimitRealtimeStartFirstUseFlagIndex = -1;
  1647. //int iLimitTimerBasedOnWearFlagIndex = -1;
  1648.  
  1649. WORD wDestCell = DestCell.cell;
  1650. BYTE bDestInven = DestCell.window_type;
  1651. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  1652. {
  1653. long limitValue = item->GetProto()->aLimits[i].lValue;
  1654.  
  1655. switch (item->GetProto()->aLimits[i].bType)
  1656. {
  1657. case LIMIT_LEVEL:
  1658. if (GetLevel() < limitValue)
  1659. {
  1660. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆŔĚĹŰŔÇ ·ąş§ Á¦ÇŃş¸´Ů ·ąş§ŔĚ ł·˝Ŕ´Ď´Ů."));
  1661. return false;
  1662. }
  1663. break;
  1664.  
  1665. case LIMIT_REAL_TIME_START_FIRST_USE:
  1666. iLimitRealtimeStartFirstUseFlagIndex = i;
  1667. break;
  1668.  
  1669. case LIMIT_TIMER_BASED_ON_WEAR:
  1670. //iLimitTimerBasedOnWearFlagIndex = i;
  1671. break;
  1672. }
  1673. }
  1674.  
  1675. if (test_server)
  1676. {
  1677. sys_log(0, "USE_ITEM %s, Inven %d, Cell %d, ItemType %d, SubType %d", item->GetName(), bDestInven, wDestCell, item->GetType(), item->GetSubType());
  1678. }
  1679.  
  1680. if ( CArenaManager::instance().IsLimitedItem( GetMapIndex(), item->GetVnum() ) == true )
  1681. {
  1682. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  1683. return false;
  1684. }
  1685. #ifdef ENABLE_NEWSTUFF
  1686. else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && IsLimitedPotionOnPVP(item->GetVnum()))
  1687. {
  1688. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  1689. return false;
  1690. }
  1691. #endif
  1692.  
  1693. // @fixme402 (IsLoadedAffect to block affect hacking)
  1694. if (!IsLoadedAffect())
  1695. {
  1696. ChatPacket(CHAT_TYPE_INFO, "Affects are not loaded yet!");
  1697. return false;
  1698. }
  1699.  
  1700. // @fixme141 BEGIN
  1701. if (TItemPos(item->GetWindow(), item->GetCell()).IsBeltInventoryPosition())
  1702. {
  1703. LPITEM beltItem = GetWear(WEAR_BELT);
  1704.  
  1705. if (NULL == beltItem)
  1706. {
  1707. ChatPacket(CHAT_TYPE_INFO, "<Belt> You can't use this item if you have no equipped belt.");
  1708. return false;
  1709. }
  1710.  
  1711. if (false == CBeltInventoryHelper::IsAvailableCell(item->GetCell() - BELT_INVENTORY_SLOT_START, beltItem->GetValue(0)))
  1712. {
  1713. ChatPacket(CHAT_TYPE_INFO, "<Belt> You can't use this item if you don't upgrade your belt.");
  1714. return false;
  1715. }
  1716. }
  1717. // @fixme141 END
  1718.  
  1719.  
  1720. if (-1 != iLimitRealtimeStartFirstUseFlagIndex)
  1721. {
  1722.  
  1723. if (0 == item->GetSocket(1))
  1724. {
  1725.  
  1726. long duration = (0 != item->GetSocket(0)) ? item->GetSocket(0) : item->GetProto()->aLimits[iLimitRealtimeStartFirstUseFlagIndex].lValue;
  1727.  
  1728. if (0 == duration)
  1729. duration = 60 * 60 * 24 * 7;
  1730.  
  1731. item->SetSocket(0, time(0) + duration);
  1732. item->StartRealTimeExpireEvent();
  1733. }
  1734.  
  1735. if (false == item->IsEquipped())
  1736. item->SetSocket(1, item->GetSocket(1) + 1);
  1737. }
  1738.  
  1739. switch (item->GetType())
  1740. {
  1741. case ITEM_HAIR:
  1742. return ItemProcess_Hair(item, wDestCell);
  1743.  
  1744. case ITEM_POLYMORPH:
  1745. return ItemProcess_Polymorph(item);
  1746.  
  1747. case ITEM_QUEST:
  1748. if (GetArena() != NULL || IsObserverMode() == true)
  1749. {
  1750. if (item->GetVnum() == 50051 || item->GetVnum() == 50052 || item->GetVnum() == 50053)
  1751. {
  1752. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  1753. return false;
  1754. }
  1755. }
  1756.  
  1757. if (!IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE | ITEM_FLAG_QUEST_USE_MULTIPLE))
  1758. {
  1759. if (item->GetSIGVnum() == 0)
  1760. {
  1761. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  1762. }
  1763. else
  1764. {
  1765. quest::CQuestManager::instance().SIGUse(GetPlayerID(), item->GetSIGVnum(), item, false);
  1766. }
  1767. }
  1768. break;
  1769.  
  1770. case ITEM_CAMPFIRE:
  1771. {
  1772. float fx, fy;
  1773. GetDeltaByDegree(GetRotation(), 100.0f, &fx, &fy);
  1774.  
  1775. LPSECTREE tree = SECTREE_MANAGER::instance().Get(GetMapIndex(), (long)(GetX()+fx), (long)(GetY()+fy));
  1776.  
  1777. if (!tree)
  1778. {
  1779. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸đ´ÚşŇŔ» ÇÇżď Ľö ľř´Â ÁöÁˇŔÔ´Ď´Ů."));
  1780. return false;
  1781. }
  1782.  
  1783. if (tree->IsAttr((long)(GetX()+fx), (long)(GetY()+fy), ATTR_WATER))
  1784. {
  1785. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ą° ĽÓżˇ ¸đ´ÚşŇŔ» ÇÇżď Ľö ľř˝Ŕ´Ď´Ů."));
  1786. return false;
  1787. }
  1788.  
  1789. LPCHARACTER campfire = CHARACTER_MANAGER::instance().SpawnMob(fishing::CAMPFIRE_MOB, GetMapIndex(), (long)(GetX()+fx), (long)(GetY()+fy), 0, false, number(0, 359));
  1790.  
  1791. char_event_info* info = AllocEventInfo<char_event_info>();
  1792.  
  1793. info->ch = campfire;
  1794.  
  1795. campfire->m_pkMiningEvent = event_create(kill_campfire_event, info, PASSES_PER_SEC(40));
  1796.  
  1797. item->SetCount(item->GetCount() - 1);
  1798. }
  1799. break;
  1800.  
  1801. case ITEM_UNIQUE:
  1802. {
  1803. switch (item->GetSubType())
  1804. {
  1805. case USE_ABILITY_UP:
  1806. {
  1807. switch (item->GetValue(0))
  1808. {
  1809. case APPLY_MOV_SPEED:
  1810. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_MOV_SPEED, item->GetValue(2), AFF_MOV_SPEED_POTION, item->GetValue(1), 0, true, true);
  1811. break;
  1812.  
  1813. case APPLY_ATT_SPEED:
  1814. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ATT_SPEED, item->GetValue(2), AFF_ATT_SPEED_POTION, item->GetValue(1), 0, true, true);
  1815. break;
  1816.  
  1817. case APPLY_STR:
  1818. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ST, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1819. break;
  1820.  
  1821. case APPLY_DEX:
  1822. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_DX, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1823. break;
  1824.  
  1825. case APPLY_CON:
  1826. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_HT, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1827. break;
  1828.  
  1829. case APPLY_INT:
  1830. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_IQ, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1831. break;
  1832.  
  1833. case APPLY_CAST_SPEED:
  1834. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_CASTING_SPEED, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1835. break;
  1836.  
  1837. case APPLY_RESIST_MAGIC:
  1838. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_RESIST_MAGIC, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1839. break;
  1840.  
  1841. case APPLY_ATT_GRADE_BONUS:
  1842. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ATT_GRADE_BONUS,
  1843. item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1844. break;
  1845.  
  1846. case APPLY_DEF_GRADE_BONUS:
  1847. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_DEF_GRADE_BONUS,
  1848. item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1849. break;
  1850. }
  1851. }
  1852.  
  1853. if (GetDungeon())
  1854. GetDungeon()->UsePotion(this);
  1855.  
  1856. if (GetWarMap())
  1857. GetWarMap()->UsePotion(this, item);
  1858.  
  1859. item->SetCount(item->GetCount() - 1);
  1860. break;
  1861.  
  1862. default:
  1863. {
  1864. if (item->GetSubType() == USE_SPECIAL)
  1865. {
  1866. sys_log(0, "ITEM_UNIQUE: USE_SPECIAL %u", item->GetVnum());
  1867.  
  1868. switch (item->GetVnum())
  1869. {
  1870. case 71049:
  1871. if (g_bEnableBootaryCheck)
  1872. {
  1873. if (IS_BOTARYABLE_ZONE(GetMapIndex()) == true)
  1874. {
  1875. UseSilkBotary();
  1876. }
  1877. else
  1878. {
  1879. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°łŔÎ »óÁˇŔ» ż­ Ľö ľř´Â ÁöżŞŔÔ´Ď´Ů"));
  1880. }
  1881. }
  1882. else
  1883. {
  1884. UseSilkBotary();
  1885. }
  1886. break;
  1887. }
  1888. }
  1889. else
  1890. {
  1891. if (!item->IsEquipped())
  1892. {
  1893. LPITEM Unique1 = GetWear(WEAR_UNIQUE1);
  1894. LPITEM Unique2 = GetWear(WEAR_UNIQUE2);
  1895.  
  1896. if ((NULL != Unique1 && Unique1->GetVnum() != item->GetVnum()) && (NULL != Unique2 && Unique2->GetVnum() != item->GetVnum()))
  1897. {
  1898. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şÎÂřÇŇ Ľö ŔÖ´Â ˝˝·ÔŔĚ ľř˝Ŕ´Ď´Ů."));
  1899. break;
  1900. }
  1901. if ((NULL != Unique1 && Unique1->GetVnum() == item->GetVnum()) || (NULL != Unique2 && Unique2->GetVnum() == item->GetVnum()))
  1902. {
  1903. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°°Ŕş Áľ·ůŔÇ ŔŻ´ĎĹ© ľĆŔĚĹŰ µÎ °ł¸¦ µż˝Ăżˇ ŔĺÂřÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  1904. break;
  1905. }
  1906.  
  1907. if (item->GetCount() > 1)
  1908. {
  1909. int pos = GetEmptyInventory(item->GetSize());
  1910.  
  1911. if (-1 != pos)
  1912. {
  1913. item->SetCount( item->GetCount() - 1 );
  1914.  
  1915. LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), 1);
  1916. item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
  1917.  
  1918. if (item->GetSocket(1) != 0)
  1919. {
  1920. item2->SetSocket(1, item->GetSocket(1));
  1921. }
  1922. item = item2;
  1923. EquipItem(item);
  1924. }else{
  1925. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽŇÁöÇ°żˇ şó °ř°ŁŔĚ ľř˝Ŕ´Ď´Ů."));
  1926. }
  1927. }else{
  1928. EquipItem(item);
  1929. }
  1930. }else{
  1931. UnequipItem(item);
  1932. }
  1933. }
  1934. break;
  1935. }
  1936. }
  1937. break;
  1938.  
  1939. case ITEM_COSTUME:
  1940. case ITEM_WEAPON:
  1941. case ITEM_ARMOR:
  1942. case ITEM_ROD:
  1943. case ITEM_RING:
  1944. case ITEM_BELT:
  1945. // MINING
  1946. case ITEM_PICK:
  1947. // END_OF_MINING
  1948. if (!item->IsEquipped())
  1949. EquipItem(item);
  1950. else
  1951. UnequipItem(item);
  1952. break;
  1953.  
  1954.  
  1955.  
  1956.  
  1957. case ITEM_DS:
  1958. {
  1959. if (!item->IsEquipped())
  1960. return false;
  1961. return DSManager::instance().PullOut(this, NPOS, item);
  1962. break;
  1963. }
  1964. case ITEM_SPECIAL_DS:
  1965. if (!item->IsEquipped())
  1966. EquipItem(item);
  1967. else
  1968. UnequipItem(item);
  1969. break;
  1970.  
  1971. case ITEM_FISH:
  1972. {
  1973. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  1974. {
  1975. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  1976. return false;
  1977. }
  1978. #ifdef ENABLE_NEWSTUFF
  1979. else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  1980. {
  1981. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  1982. return false;
  1983. }
  1984. #endif
  1985.  
  1986. if (item->GetSubType() == FISH_ALIVE)
  1987. fishing::UseFish(this, item);
  1988. }
  1989. break;
  1990.  
  1991. case ITEM_TREASURE_BOX:
  1992. {
  1993. return false;
  1994.  
  1995. }
  1996. break;
  1997.  
  1998. case ITEM_TREASURE_KEY:
  1999. {
  2000. LPITEM item2;
  2001.  
  2002. if (!GetItem(DestCell) || !(item2 = GetItem(DestCell)))
  2003. return false;
  2004.  
  2005. if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  2006. return false;
  2007.  
  2008. if (item2->GetType() != ITEM_TREASURE_BOX)
  2009. {
  2010. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("ż­Ľč·Î ż©´Â ą°°ÇŔĚ ľĆ´Ń°Í °°´Ů."));
  2011. return false;
  2012. }
  2013.  
  2014. if (item->GetValue(0) == item2->GetValue(0))
  2015. {
  2016.  
  2017. DWORD dwBoxVnum = item2->GetVnum();
  2018. std::vector <DWORD> dwVnums;
  2019. std::vector <DWORD> dwCounts;
  2020. std::vector <LPITEM> item_gets(0);
  2021. int count = 0;
  2022.  
  2023. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  2024. {
  2025. ITEM_MANAGER::instance().RemoveItem(item);
  2026. ITEM_MANAGER::instance().RemoveItem(item2);
  2027.  
  2028. for (int i = 0; i < count; i++){
  2029. switch (dwVnums[i])
  2030. {
  2031. case CSpecialItemGroup::GOLD:
  2032. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ· %d łÉŔ» ČąµćÇß˝Ŕ´Ď´Ů."), dwCounts[i]);
  2033. break;
  2034. case CSpecialItemGroup::EXP:
  2035. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ şÎĹÍ ˝ĹşńÇŃ şűŔĚ łŞżÉ´Ď´Ů."));
  2036. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%dŔÇ °ćÇčġ¸¦ ČąµćÇß˝Ŕ´Ď´Ů."), dwCounts[i]);
  2037. break;
  2038. case CSpecialItemGroup::MOB:
  2039. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ ¸ó˝şĹÍ°ˇ łŞĹ¸łµ˝Ŕ´Ď´Ů!"));
  2040. break;
  2041. case CSpecialItemGroup::SLOW:
  2042. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ łŞżÂ »ˇ°Ł ż¬±â¸¦ µéŔ̸¶˝ĂŔÚ żňÁ÷ŔĚ´Â ĽÓµµ°ˇ ´Ŕ·ÁÁł˝Ŕ´Ď´Ů!"));
  2043. break;
  2044. case CSpecialItemGroup::DRAIN_HP:
  2045. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚ°ˇ °©ŔÚ±â ĆřąßÇĎż´˝Ŕ´Ď´Ů! »ý¸í·ÂŔĚ °¨ĽŇÇß˝Ŕ´Ď´Ů."));
  2046. break;
  2047. case CSpecialItemGroup::POISON:
  2048. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ łŞżÂ łě»ö ż¬±â¸¦ µéŔ̸¶˝ĂŔÚ µ¶ŔĚ żÂ¸öŔ¸·Î ĆŰÁý´Ď´Ů!"));
  2049. break;
  2050. #ifdef ENABLE_WOLFMAN_CHARACTER
  2051. case CSpecialItemGroup::BLEEDING:
  2052. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ łŞżÂ łě»ö ż¬±â¸¦ µéŔ̸¶˝ĂŔÚ µ¶ŔĚ żÂ¸öŔ¸·Î ĆŰÁý´Ď´Ů!"));
  2053. break;
  2054. #endif
  2055. case CSpecialItemGroup::MOB_GROUP:
  2056. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ ¸ó˝şĹÍ°ˇ łŞĹ¸łµ˝Ŕ´Ď´Ů!"));
  2057. break;
  2058. default:
  2059. if (item_gets[i])
  2060. {
  2061. if (dwCounts[i] > 1)
  2062. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ %s °ˇ %d °ł łŞżÔ˝Ŕ´Ď´Ů."), item_gets[i]->GetName(), dwCounts[i]);
  2063. else
  2064. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ %s °ˇ łŞżÔ˝Ŕ´Ď´Ů."), item_gets[i]->GetName());
  2065.  
  2066. }
  2067. }
  2068. }
  2069. }
  2070. else
  2071. {
  2072. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("ż­Ľč°ˇ ¸ÂÁö ľĘ´Â °Í °°´Ů."));
  2073. return false;
  2074. }
  2075. }
  2076. else
  2077. {
  2078. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("ż­Ľč°ˇ ¸ÂÁö ľĘ´Â °Í °°´Ů."));
  2079. return false;
  2080. }
  2081. }
  2082. break;
  2083.  
  2084. case ITEM_GIFTBOX:
  2085. {
  2086. #ifdef ENABLE_NEWSTUFF
  2087. if (0 != g_BoxUseTimeLimitValue)
  2088. {
  2089. if (get_dword_time() < m_dwLastBoxUseTime+g_BoxUseTimeLimitValue)
  2090. {
  2091. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆÁ÷ °ńµĺ¸¦ ąö¸± Ľö ľř˝Ŕ´Ď´Ů."));
  2092. return false;
  2093. }
  2094. }
  2095.  
  2096. m_dwLastBoxUseTime = get_dword_time();
  2097. #endif
  2098. DWORD dwBoxVnum = item->GetVnum();
  2099. std::vector <DWORD> dwVnums;
  2100. std::vector <DWORD> dwCounts;
  2101. std::vector <LPITEM> item_gets(0);
  2102. int count = 0;
  2103.  
  2104. if( dwBoxVnum > 51500 && dwBoxVnum < 52000 )
  2105. {
  2106. if( !(this->DragonSoul_IsQualified()) )
  2107. {
  2108. ChatPacket(CHAT_TYPE_INFO,LC_TEXT("¸ŐŔú żëČĄĽ® Äů˝şĆ®¸¦ żĎ·áÇĎĽĹľß ÇŐ´Ď´Ů."));
  2109. return false;
  2110. }
  2111. }
  2112.  
  2113. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  2114. {
  2115. item->SetCount(item->GetCount()-1);
  2116.  
  2117. for (int i = 0; i < count; i++){
  2118. switch (dwVnums[i])
  2119. {
  2120. case CSpecialItemGroup::GOLD:
  2121. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ· %d łÉŔ» ČąµćÇß˝Ŕ´Ď´Ů."), dwCounts[i]);
  2122. break;
  2123. case CSpecialItemGroup::EXP:
  2124. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ şÎĹÍ ˝ĹşńÇŃ şűŔĚ łŞżÉ´Ď´Ů."));
  2125. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%dŔÇ °ćÇčġ¸¦ ČąµćÇß˝Ŕ´Ď´Ů."), dwCounts[i]);
  2126. break;
  2127. case CSpecialItemGroup::MOB:
  2128. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ ¸ó˝şĹÍ°ˇ łŞĹ¸łµ˝Ŕ´Ď´Ů!"));
  2129. break;
  2130. case CSpecialItemGroup::SLOW:
  2131. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ łŞżÂ »ˇ°Ł ż¬±â¸¦ µéŔ̸¶˝ĂŔÚ żňÁ÷ŔĚ´Â ĽÓµµ°ˇ ´Ŕ·ÁÁł˝Ŕ´Ď´Ů!"));
  2132. break;
  2133. case CSpecialItemGroup::DRAIN_HP:
  2134. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚ°ˇ °©ŔÚ±â ĆřąßÇĎż´˝Ŕ´Ď´Ů! »ý¸í·ÂŔĚ °¨ĽŇÇß˝Ŕ´Ď´Ů."));
  2135. break;
  2136. case CSpecialItemGroup::POISON:
  2137. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ łŞżÂ łě»ö ż¬±â¸¦ µéŔ̸¶˝ĂŔÚ µ¶ŔĚ żÂ¸öŔ¸·Î ĆŰÁý´Ď´Ů!"));
  2138. break;
  2139. #ifdef ENABLE_WOLFMAN_CHARACTER
  2140. case CSpecialItemGroup::BLEEDING:
  2141. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ łŞżÂ łě»ö ż¬±â¸¦ µéŔ̸¶˝ĂŔÚ µ¶ŔĚ żÂ¸öŔ¸·Î ĆŰÁý´Ď´Ů!"));
  2142. break;
  2143. #endif
  2144. case CSpecialItemGroup::MOB_GROUP:
  2145. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ ¸ó˝şĹÍ°ˇ łŞĹ¸łµ˝Ŕ´Ď´Ů!"));
  2146. break;
  2147. default:
  2148. if (item_gets[i])
  2149. {
  2150. if (dwCounts[i] > 1)
  2151. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ %s °ˇ %d °ł łŞżÔ˝Ŕ´Ď´Ů."), item_gets[i]->GetName(), dwCounts[i]);
  2152. else
  2153. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ %s °ˇ łŞżÔ˝Ŕ´Ď´Ů."), item_gets[i]->GetName());
  2154. }
  2155. }
  2156. }
  2157. }
  2158. else
  2159. {
  2160. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("ľĆą«°Íµµ ľňŔ» Ľö ľřľú˝Ŕ´Ď´Ů."));
  2161. return false;
  2162. }
  2163. }
  2164. break;
  2165.  
  2166. case ITEM_SKILLFORGET:
  2167. {
  2168. if (!item->GetSocket(0))
  2169. {
  2170. ITEM_MANAGER::instance().RemoveItem(item);
  2171. return false;
  2172. }
  2173.  
  2174. DWORD dwVnum = item->GetSocket(0);
  2175.  
  2176. if (SkillLevelDown(dwVnum))
  2177. {
  2178. ITEM_MANAGER::instance().RemoveItem(item);
  2179. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("˝şĹł ·ąş§Ŕ» ł»¸®´ÂµĄ Ľş°řÇĎż´˝Ŕ´Ď´Ů."));
  2180. }
  2181. else
  2182. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("˝şĹł ·ąş§Ŕ» ł»¸± Ľö ľř˝Ŕ´Ď´Ů."));
  2183. }
  2184. break;
  2185.  
  2186. case ITEM_SKILLBOOK:
  2187. {
  2188. if (IsPolymorphed())
  2189. {
  2190. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şŻ˝ĹÁßżˇ´Â ĂĄŔ» ŔĐŔ»Ľö ľř˝Ŕ´Ď´Ů."));
  2191. return false;
  2192. }
  2193.  
  2194. DWORD dwVnum = 0;
  2195.  
  2196. if (item->GetVnum() == 50300)
  2197. {
  2198. dwVnum = item->GetSocket(0);
  2199. }
  2200. else
  2201. {
  2202.  
  2203. dwVnum = item->GetValue(0);
  2204. }
  2205.  
  2206. if (0 == dwVnum)
  2207. {
  2208. ITEM_MANAGER::instance().RemoveItem(item);
  2209.  
  2210. return false;
  2211. }
  2212.  
  2213. if (true == LearnSkillByBook(dwVnum))
  2214. {
  2215. #ifdef ENABLE_BOOKS_STACKFIX
  2216. item->SetCount(item->GetCount() - 1);
  2217. #else
  2218. ITEM_MANAGER::instance().RemoveItem(item);
  2219. #endif
  2220.  
  2221. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2222.  
  2223. if (distribution_test_server)
  2224. iReadDelay /= 3;
  2225.  
  2226. SetSkillNextReadTime(dwVnum, get_global_time() + iReadDelay);
  2227. }
  2228. }
  2229. break;
  2230.  
  2231. case ITEM_USE:
  2232. {
  2233. if (item->GetVnum() > 50800 && item->GetVnum() <= 50820)
  2234. {
  2235. if (test_server)
  2236. sys_log (0, "ADD addtional effect : vnum(%d) subtype(%d)", item->GetOriginalVnum(), item->GetSubType());
  2237.  
  2238. int affect_type = AFFECT_EXP_BONUS_EURO_FREE;
  2239. int apply_type = aApplyInfo[item->GetValue(0)].bPointType;
  2240. int apply_value = item->GetValue(2);
  2241. int apply_duration = item->GetValue(1);
  2242.  
  2243. switch (item->GetSubType())
  2244. {
  2245. case USE_ABILITY_UP:
  2246. if (FindAffect(affect_type, apply_type))
  2247. {
  2248. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ Čż°ú°ˇ °É·Á ŔÖ˝Ŕ´Ď´Ů."));
  2249. return false;
  2250. }
  2251.  
  2252. {
  2253. switch (item->GetValue(0))
  2254. {
  2255. case APPLY_MOV_SPEED:
  2256. AddAffect(affect_type, apply_type, apply_value, AFF_MOV_SPEED_POTION, apply_duration, 0, true, true);
  2257. break;
  2258.  
  2259. case APPLY_ATT_SPEED:
  2260. AddAffect(affect_type, apply_type, apply_value, AFF_ATT_SPEED_POTION, apply_duration, 0, true, true);
  2261. break;
  2262.  
  2263. case APPLY_STR:
  2264. case APPLY_DEX:
  2265. case APPLY_CON:
  2266. case APPLY_INT:
  2267. case APPLY_CAST_SPEED:
  2268. case APPLY_RESIST_MAGIC:
  2269. case APPLY_ATT_GRADE_BONUS:
  2270. case APPLY_DEF_GRADE_BONUS:
  2271. AddAffect(affect_type, apply_type, apply_value, 0, apply_duration, 0, true, true);
  2272. break;
  2273. }
  2274. }
  2275.  
  2276. if (GetDungeon())
  2277. GetDungeon()->UsePotion(this);
  2278.  
  2279. if (GetWarMap())
  2280. GetWarMap()->UsePotion(this, item);
  2281.  
  2282. item->SetCount(item->GetCount() - 1);
  2283. break;
  2284.  
  2285. case USE_AFFECT :
  2286. {
  2287. if (FindAffect(AFFECT_EXP_BONUS_EURO_FREE, aApplyInfo[item->GetValue(1)].bPointType))
  2288. {
  2289. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ Čż°ú°ˇ °É·Á ŔÖ˝Ŕ´Ď´Ů."));
  2290. }
  2291. else
  2292. {
  2293. // PC_BANG_ITEM_ADD
  2294. if (item->IsPCBangItem() == true)
  2295. {
  2296.  
  2297. if (CPCBangManager::instance().IsPCBangIP(GetDesc()->GetHostName()) == false)
  2298. {
  2299.  
  2300. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔş PCąćżˇĽ­¸¸ »çżëÇŇ Ľö ŔÖ˝Ŕ´Ď´Ů."));
  2301. return false;
  2302. }
  2303. }
  2304. // END_PC_BANG_ITEM_ADD
  2305.  
  2306. AddAffect(AFFECT_EXP_BONUS_EURO_FREE, aApplyInfo[item->GetValue(1)].bPointType, item->GetValue(2), 0, item->GetValue(3), 0, false, true);
  2307. item->SetCount(item->GetCount() - 1);
  2308. }
  2309. }
  2310. break;
  2311.  
  2312. case USE_POTION_NODELAY:
  2313. {
  2314. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  2315. {
  2316. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
  2317. {
  2318. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ĂŔ忡Ľ­ »çżëÇĎ˝Ç Ľö ľř˝Ŕ´Ď´Ů."));
  2319. return false;
  2320. }
  2321.  
  2322. switch (item->GetVnum())
  2323. {
  2324. case 70020 :
  2325. case 71018 :
  2326. case 71019 :
  2327. case 71020 :
  2328. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
  2329. {
  2330. if (m_nPotionLimit <= 0)
  2331. {
  2332. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»çżë Á¦ÇŃ·®Ŕ» ĂĘ°úÇĎż´˝Ŕ´Ď´Ů."));
  2333. return false;
  2334. }
  2335. }
  2336. break;
  2337.  
  2338. default :
  2339. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ĂŔ忡Ľ­ »çżëÇĎ˝Ç Ľö ľř˝Ŕ´Ď´Ů."));
  2340. return false;
  2341. break;
  2342. }
  2343. }
  2344. #ifdef ENABLE_NEWSTUFF
  2345. else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  2346. {
  2347. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  2348. return false;
  2349. }
  2350. #endif
  2351.  
  2352. bool used = false;
  2353.  
  2354. if (item->GetValue(0) != 0)
  2355. {
  2356. if (GetHP() < GetMaxHP())
  2357. {
  2358. PointChange(POINT_HP, item->GetValue(0) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  2359. EffectPacket(SE_HPUP_RED);
  2360. used = TRUE;
  2361. }
  2362. }
  2363.  
  2364. if (item->GetValue(1) != 0)
  2365. {
  2366. if (GetSP() < GetMaxSP())
  2367. {
  2368. PointChange(POINT_SP, item->GetValue(1) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  2369. EffectPacket(SE_SPUP_BLUE);
  2370. used = TRUE;
  2371. }
  2372. }
  2373.  
  2374. if (item->GetValue(3) != 0)
  2375. {
  2376. if (GetHP() < GetMaxHP())
  2377. {
  2378. PointChange(POINT_HP, item->GetValue(3) * GetMaxHP() / 100);
  2379. EffectPacket(SE_HPUP_RED);
  2380. used = TRUE;
  2381. }
  2382. }
  2383.  
  2384. if (item->GetValue(4) != 0)
  2385. {
  2386. if (GetSP() < GetMaxSP())
  2387. {
  2388. PointChange(POINT_SP, item->GetValue(4) * GetMaxSP() / 100);
  2389. EffectPacket(SE_SPUP_BLUE);
  2390. used = TRUE;
  2391. }
  2392. }
  2393.  
  2394. if (used)
  2395. {
  2396. if (item->GetVnum() == 50085 || item->GetVnum() == 50086)
  2397. {
  2398. if (test_server)
  2399. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("żůş´ ¶Ç´Â ÁľŔÚ ¸¦ »çżëÇĎż´˝Ŕ´Ď´Ů"));
  2400. SetUseSeedOrMoonBottleTime();
  2401. }
  2402. if (GetDungeon())
  2403. GetDungeon()->UsePotion(this);
  2404.  
  2405. if (GetWarMap())
  2406. GetWarMap()->UsePotion(this, item);
  2407.  
  2408. m_nPotionLimit--;
  2409.  
  2410. //RESTRICT_USE_SEED_OR_MOONBOTTLE
  2411. item->SetCount(item->GetCount() - 1);
  2412. //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
  2413. }
  2414. }
  2415. break;
  2416. }
  2417.  
  2418. return true;
  2419. }
  2420.  
  2421.  
  2422. if (item->GetVnum() >= 27863 && item->GetVnum() <= 27883)
  2423. {
  2424. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  2425. {
  2426. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  2427. return false;
  2428. }
  2429. #ifdef ENABLE_NEWSTUFF
  2430. else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  2431. {
  2432. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  2433. return false;
  2434. }
  2435. #endif
  2436. }
  2437.  
  2438. if (test_server)
  2439. {
  2440. sys_log (0, "USE_ITEM %s Type %d SubType %d vnum %d", item->GetName(), item->GetType(), item->GetSubType(), item->GetOriginalVnum());
  2441. }
  2442.  
  2443. switch (item->GetSubType())
  2444. {
  2445. case USE_TIME_CHARGE_PER:
  2446. {
  2447. LPITEM pDestItem = GetItem(DestCell);
  2448. if (NULL == pDestItem)
  2449. {
  2450. return false;
  2451. }
  2452.  
  2453. if (pDestItem->IsDragonSoul())
  2454. {
  2455. int ret;
  2456. char buf[128];
  2457. if (item->GetVnum() == DRAGON_HEART_VNUM)
  2458. {
  2459. ret = pDestItem->GiveMoreTime_Per((float)item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
  2460. }
  2461. else
  2462. {
  2463. ret = pDestItem->GiveMoreTime_Per((float)item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2464. }
  2465. if (ret > 0)
  2466. {
  2467. if (item->GetVnum() == DRAGON_HEART_VNUM)
  2468. {
  2469. sprintf(buf, "Inc %ds by item{VN:%d SOC%d:%ld}", ret, item->GetVnum(), ITEM_SOCKET_CHARGING_AMOUNT_IDX, item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
  2470. }
  2471. else
  2472. {
  2473. sprintf(buf, "Inc %ds by item{VN:%d VAL%d:%ld}", ret, item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2474. }
  2475.  
  2476. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%dĂĘ ¸¸Ĺ­ ĂćŔüµÇľú˝Ŕ´Ď´Ů."), ret);
  2477. item->SetCount(item->GetCount() - 1);
  2478. LogManager::instance().ItemLog(this, item, "DS_CHARGING_SUCCESS", buf);
  2479. return true;
  2480. }
  2481. else
  2482. {
  2483. if (item->GetVnum() == DRAGON_HEART_VNUM)
  2484. {
  2485. sprintf(buf, "No change by item{VN:%d SOC%d:%ld}", item->GetVnum(), ITEM_SOCKET_CHARGING_AMOUNT_IDX, item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
  2486. }
  2487. else
  2488. {
  2489. sprintf(buf, "No change by item{VN:%d VAL%d:%ld}", item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2490. }
  2491.  
  2492. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĂćŔüÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  2493. LogManager::instance().ItemLog(this, item, "DS_CHARGING_FAILED", buf);
  2494. return false;
  2495. }
  2496. }
  2497. else
  2498. return false;
  2499. }
  2500. break;
  2501. case USE_TIME_CHARGE_FIX:
  2502. {
  2503. LPITEM pDestItem = GetItem(DestCell);
  2504. if (NULL == pDestItem)
  2505. {
  2506. return false;
  2507. }
  2508.  
  2509. if (pDestItem->IsDragonSoul())
  2510. {
  2511. int ret = pDestItem->GiveMoreTime_Fix(item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2512. char buf[128];
  2513. if (ret)
  2514. {
  2515. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%dĂĘ ¸¸Ĺ­ ĂćŔüµÇľú˝Ŕ´Ď´Ů."), ret);
  2516. sprintf(buf, "Increase %ds by item{VN:%d VAL%d:%ld}", ret, item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2517. LogManager::instance().ItemLog(this, item, "DS_CHARGING_SUCCESS", buf);
  2518. item->SetCount(item->GetCount() - 1);
  2519. return true;
  2520. }
  2521. else
  2522. {
  2523. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĂćŔüÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  2524. sprintf(buf, "No change by item{VN:%d VAL%d:%ld}", item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2525. LogManager::instance().ItemLog(this, item, "DS_CHARGING_FAILED", buf);
  2526. return false;
  2527. }
  2528. }
  2529. else
  2530. return false;
  2531. }
  2532. break;
  2533. case USE_SPECIAL:
  2534.  
  2535. switch (item->GetVnum())
  2536. {
  2537.  
  2538. case ITEM_NOG_POCKET:
  2539. {
  2540. /*
  2541. ¶őÁÖ´É·Âġ : item_proto value ŔÇąĚ
  2542. Ŕ̵żĽÓµµ value 1
  2543. °ř°Ý·Â value 2
  2544. °ćÇčġ value 3
  2545. ÁöĽÓ˝Ă°Ł value 0 (´ÜŔ§ ĂĘ)
  2546.  
  2547. */
  2548. if (FindAffect(AFFECT_NOG_ABILITY))
  2549. {
  2550. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ Čż°ú°ˇ °É·Á ŔÖ˝Ŕ´Ď´Ů."));
  2551. return false;
  2552. }
  2553. long time = item->GetValue(0);
  2554. long moveSpeedPer = item->GetValue(1);
  2555. long attPer = item->GetValue(2);
  2556. long expPer = item->GetValue(3);
  2557. AddAffect(AFFECT_NOG_ABILITY, POINT_MOV_SPEED, moveSpeedPer, AFF_MOV_SPEED_POTION, time, 0, true, true);
  2558. AddAffect(AFFECT_NOG_ABILITY, POINT_MALL_ATTBONUS, attPer, AFF_NONE, time, 0, true, true);
  2559. AddAffect(AFFECT_NOG_ABILITY, POINT_MALL_EXPBONUS, expPer, AFF_NONE, time, 0, true, true);
  2560. item->SetCount(item->GetCount() - 1);
  2561. }
  2562. break;
  2563.  
  2564.  
  2565. case ITEM_RAMADAN_CANDY:
  2566. {
  2567. /*
  2568. »çĹÁ´É·Âġ : item_proto value ŔÇąĚ
  2569. Ŕ̵żĽÓµµ value 1
  2570. °ř°Ý·Â value 2
  2571. °ćÇčġ value 3
  2572. ÁöĽÓ˝Ă°Ł value 0 (´ÜŔ§ ĂĘ)
  2573.  
  2574. */
  2575. // @fixme147 BEGIN
  2576. if (FindAffect(AFFECT_RAMADAN_ABILITY))
  2577. {
  2578. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ Čż°ú°ˇ °É·Á ŔÖ˝Ŕ´Ď´Ů."));
  2579. return false;
  2580. }
  2581. // @fixme147 END
  2582. long time = item->GetValue(0);
  2583. long moveSpeedPer = item->GetValue(1);
  2584. long attPer = item->GetValue(2);
  2585. long expPer = item->GetValue(3);
  2586. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MOV_SPEED, moveSpeedPer, AFF_MOV_SPEED_POTION, time, 0, true, true);
  2587. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MALL_ATTBONUS, attPer, AFF_NONE, time, 0, true, true);
  2588. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MALL_EXPBONUS, expPer, AFF_NONE, time, 0, true, true);
  2589. item->SetCount(item->GetCount() - 1);
  2590. }
  2591. break;
  2592. case ITEM_MARRIAGE_RING:
  2593. {
  2594. marriage::TMarriage* pMarriage = marriage::CManager::instance().Get(GetPlayerID());
  2595. if (pMarriage)
  2596. {
  2597. if (pMarriage->ch1 != NULL)
  2598. {
  2599. if (CArenaManager::instance().IsArenaMap(pMarriage->ch1->GetMapIndex()) == true)
  2600. {
  2601. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  2602. break;
  2603. }
  2604. }
  2605.  
  2606. if (pMarriage->ch2 != NULL)
  2607. {
  2608. if (CArenaManager::instance().IsArenaMap(pMarriage->ch2->GetMapIndex()) == true)
  2609. {
  2610. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  2611. break;
  2612. }
  2613. }
  2614.  
  2615. int consumeSP = CalculateConsumeSP(this);
  2616.  
  2617. if (consumeSP < 0)
  2618. return false;
  2619.  
  2620. PointChange(POINT_SP, -consumeSP, false);
  2621.  
  2622. WarpToPID(pMarriage->GetOther(GetPlayerID()));
  2623. }
  2624. else
  2625. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°áČĄ »óĹ°ˇ ľĆ´Ď¸é °áČĄąÝÁö¸¦ »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  2626. }
  2627. break;
  2628.  
  2629.  
  2630. case UNIQUE_ITEM_CAPE_OF_COURAGE:
  2631.  
  2632. case 70057:
  2633. case REWARD_BOX_UNIQUE_ITEM_CAPE_OF_COURAGE:
  2634. AggregateMonster();
  2635. item->SetCount(item->GetCount()-1);
  2636. break;
  2637.  
  2638. case UNIQUE_ITEM_WHITE_FLAG:
  2639. ForgetMyAttacker();
  2640. item->SetCount(item->GetCount()-1);
  2641. break;
  2642.  
  2643. case UNIQUE_ITEM_TREASURE_BOX:
  2644. break;
  2645.  
  2646. case 30093:
  2647. case 30094:
  2648. case 30095:
  2649. case 30096:
  2650.  
  2651. {
  2652. const int MAX_BAG_INFO = 26;
  2653. static struct LuckyBagInfo
  2654. {
  2655. DWORD count;
  2656. int prob;
  2657. DWORD vnum;
  2658. } b1[MAX_BAG_INFO] =
  2659. {
  2660. { 1000, 302, 1 },
  2661. { 10, 150, 27002 },
  2662. { 10, 75, 27003 },
  2663. { 10, 100, 27005 },
  2664. { 10, 50, 27006 },
  2665. { 10, 80, 27001 },
  2666. { 10, 50, 27002 },
  2667. { 10, 80, 27004 },
  2668. { 10, 50, 27005 },
  2669. { 1, 10, 50300 },
  2670. { 1, 6, 92 },
  2671. { 1, 2, 132 },
  2672. { 1, 6, 1052 },
  2673. { 1, 2, 1092 },
  2674. { 1, 6, 2082 },
  2675. { 1, 2, 2122 },
  2676. { 1, 6, 3082 },
  2677. { 1, 2, 3122 },
  2678. { 1, 6, 5052 },
  2679. { 1, 2, 5082 },
  2680. { 1, 6, 7082 },
  2681. { 1, 2, 7122 },
  2682. { 1, 1, 11282 },
  2683. { 1, 1, 11482 },
  2684. { 1, 1, 11682 },
  2685. { 1, 1, 11882 },
  2686. };
  2687.  
  2688. LuckyBagInfo * bi = NULL;
  2689. bi = b1;
  2690.  
  2691. int pct = number(1, 1000);
  2692.  
  2693. int i;
  2694. for (i=0;i<MAX_BAG_INFO;i++)
  2695. {
  2696. if (pct <= bi[i].prob)
  2697. break;
  2698. pct -= bi[i].prob;
  2699. }
  2700. if (i>=MAX_BAG_INFO)
  2701. return false;
  2702.  
  2703. if (bi[i].vnum == 50300)
  2704. {
  2705.  
  2706. GiveRandomSkillBook();
  2707. }
  2708. else if (bi[i].vnum == 1)
  2709. {
  2710. PointChange(POINT_GOLD, 1000, true);
  2711. }
  2712. else
  2713. {
  2714. AutoGiveItem(bi[i].vnum, bi[i].count);
  2715. }
  2716. ITEM_MANAGER::instance().RemoveItem(item);
  2717. }
  2718. break;
  2719.  
  2720. case 50004:
  2721. {
  2722. if (item->GetSocket(0))
  2723. {
  2724. item->SetSocket(0, item->GetSocket(0) + 1);
  2725. }
  2726. else
  2727. {
  2728.  
  2729. int iMapIndex = GetMapIndex();
  2730.  
  2731. PIXEL_POSITION pos;
  2732.  
  2733. if (SECTREE_MANAGER::instance().GetRandomLocation(iMapIndex, pos, 700))
  2734. {
  2735. item->SetSocket(0, 1);
  2736. item->SetSocket(1, pos.x);
  2737. item->SetSocket(2, pos.y);
  2738. }
  2739. else
  2740. {
  2741. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ °÷żˇĽ± ŔĚşĄĆ®żë °¨Áö±â°ˇ µżŔŰÇĎÁö ľĘ´Â°Í °°˝Ŕ´Ď´Ů."));
  2742. return false;
  2743. }
  2744. }
  2745.  
  2746. int dist = 0;
  2747. float distance = (DISTANCE_SQRT(GetX()-item->GetSocket(1), GetY()-item->GetSocket(2)));
  2748.  
  2749. if (distance < 1000.0f)
  2750. {
  2751.  
  2752. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚşĄĆ®żë °¨Áö±â°ˇ ˝Ĺşń·Îżî şűŔ» ł»¸ç »ç¶óÁý´Ď´Ů."));
  2753.  
  2754.  
  2755. struct TEventStoneInfo
  2756. {
  2757. DWORD dwVnum;
  2758. int count;
  2759. int prob;
  2760. };
  2761. const int EVENT_STONE_MAX_INFO = 15;
  2762. TEventStoneInfo info_10[EVENT_STONE_MAX_INFO] =
  2763. {
  2764. { 27001, 10, 8 },
  2765. { 27004, 10, 6 },
  2766. { 27002, 10, 12 },
  2767. { 27005, 10, 12 },
  2768. { 27100, 1, 9 },
  2769. { 27103, 1, 9 },
  2770. { 27101, 1, 10 },
  2771. { 27104, 1, 10 },
  2772. { 27999, 1, 12 },
  2773.  
  2774. { 25040, 1, 4 },
  2775.  
  2776. { 27410, 1, 0 },
  2777. { 27600, 1, 0 },
  2778. { 25100, 1, 0 },
  2779.  
  2780. { 50001, 1, 0 },
  2781. { 50003, 1, 1 },
  2782. };
  2783. TEventStoneInfo info_7[EVENT_STONE_MAX_INFO] =
  2784. {
  2785. { 27001, 10, 1 },
  2786. { 27004, 10, 1 },
  2787. { 27004, 10, 9 },
  2788. { 27005, 10, 9 },
  2789. { 27100, 1, 5 },
  2790. { 27103, 1, 5 },
  2791. { 27101, 1, 10 },
  2792. { 27104, 1, 10 },
  2793. { 27999, 1, 14 },
  2794.  
  2795. { 25040, 1, 5 },
  2796.  
  2797. { 27410, 1, 5 },
  2798. { 27600, 1, 5 },
  2799. { 25100, 1, 5 },
  2800.  
  2801. { 50001, 1, 0 },
  2802. { 50003, 1, 5 },
  2803.  
  2804. };
  2805. TEventStoneInfo info_4[EVENT_STONE_MAX_INFO] =
  2806. {
  2807. { 27001, 10, 0 },
  2808. { 27004, 10, 0 },
  2809. { 27002, 10, 0 },
  2810. { 27005, 10, 0 },
  2811. { 27100, 1, 0 },
  2812. { 27103, 1, 0 },
  2813. { 27101, 1, 0 },
  2814. { 27104, 1, 0 },
  2815. { 27999, 1, 25 },
  2816.  
  2817. { 25040, 1, 0 },
  2818.  
  2819. { 27410, 1, 0 },
  2820. { 27600, 1, 0 },
  2821. { 25100, 1, 15 },
  2822.  
  2823. { 50001, 1, 10 },
  2824. { 50003, 1, 50 },
  2825.  
  2826. };
  2827.  
  2828. {
  2829. TEventStoneInfo* info;
  2830. if (item->GetSocket(0) <= 4)
  2831. info = info_4;
  2832. else if (item->GetSocket(0) <= 7)
  2833. info = info_7;
  2834. else
  2835. info = info_10;
  2836.  
  2837. int prob = number(1, 100);
  2838.  
  2839. for (int i = 0; i < EVENT_STONE_MAX_INFO; ++i)
  2840. {
  2841. if (!info[i].prob)
  2842. continue;
  2843.  
  2844. if (prob <= info[i].prob)
  2845. {
  2846. if (info[i].dwVnum == 50001)
  2847. {
  2848. DWORD * pdw = M2_NEW DWORD[2];
  2849.  
  2850. pdw[0] = info[i].dwVnum;
  2851. pdw[1] = info[i].count;
  2852.  
  2853.  
  2854. DBManager::instance().ReturnQuery(QID_LOTTO, GetPlayerID(), pdw,
  2855. "INSERT INTO lotto_list VALUES(0, 'server%s', %u, NOW())",
  2856. get_table_postfix(), GetPlayerID());
  2857. }
  2858. else
  2859. AutoGiveItem(info[i].dwVnum, info[i].count);
  2860.  
  2861. break;
  2862. }
  2863. prob -= info[i].prob;
  2864. }
  2865. }
  2866.  
  2867. char chatbuf[CHAT_MAX_LEN + 1];
  2868. int len = snprintf(chatbuf, sizeof(chatbuf), "StoneDetect %u 0 0", (DWORD)GetVID());
  2869.  
  2870. if (len < 0 || len >= (int) sizeof(chatbuf))
  2871. len = sizeof(chatbuf) - 1;
  2872.  
  2873. ++len;
  2874.  
  2875. TPacketGCChat pack_chat;
  2876. pack_chat.header = HEADER_GC_CHAT;
  2877. pack_chat.size = sizeof(TPacketGCChat) + len;
  2878. pack_chat.type = CHAT_TYPE_COMMAND;
  2879. pack_chat.id = 0;
  2880. pack_chat.bEmpire = GetDesc()->GetEmpire();
  2881. //pack_chat.id = vid;
  2882.  
  2883. TEMP_BUFFER buf;
  2884. buf.write(&pack_chat, sizeof(TPacketGCChat));
  2885. buf.write(chatbuf, len);
  2886.  
  2887. PacketAround(buf.read_peek(), buf.size());
  2888.  
  2889. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (DETECT_EVENT_STONE) 1");
  2890. return true;
  2891. }
  2892. else if (distance < 20000)
  2893. dist = 1;
  2894. else if (distance < 70000)
  2895. dist = 2;
  2896. else
  2897. dist = 3;
  2898.  
  2899.  
  2900. const int STONE_DETECT_MAX_TRY = 10;
  2901. if (item->GetSocket(0) >= STONE_DETECT_MAX_TRY)
  2902. {
  2903. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚşĄĆ®żë °¨Áö±â°ˇ ČçŔűµµ ľřŔĚ »ç¶óÁý´Ď´Ů."));
  2904. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (DETECT_EVENT_STONE) 0");
  2905. AutoGiveItem(27002);
  2906. return true;
  2907. }
  2908.  
  2909. if (dist)
  2910. {
  2911. char chatbuf[CHAT_MAX_LEN + 1];
  2912. int len = snprintf(chatbuf, sizeof(chatbuf),
  2913. "StoneDetect %u %d %d",
  2914. (DWORD)GetVID(), dist, (int)GetDegreeFromPositionXY(GetX(), item->GetSocket(2), item->GetSocket(1), GetY()));
  2915.  
  2916. if (len < 0 || len >= (int) sizeof(chatbuf))
  2917. len = sizeof(chatbuf) - 1;
  2918.  
  2919. ++len;
  2920.  
  2921. TPacketGCChat pack_chat;
  2922. pack_chat.header = HEADER_GC_CHAT;
  2923. pack_chat.size = sizeof(TPacketGCChat) + len;
  2924. pack_chat.type = CHAT_TYPE_COMMAND;
  2925. pack_chat.id = 0;
  2926. pack_chat.bEmpire = GetDesc()->GetEmpire();
  2927. //pack_chat.id = vid;
  2928.  
  2929. TEMP_BUFFER buf;
  2930. buf.write(&pack_chat, sizeof(TPacketGCChat));
  2931. buf.write(chatbuf, len);
  2932.  
  2933. PacketAround(buf.read_peek(), buf.size());
  2934. }
  2935.  
  2936. }
  2937. break;
  2938.  
  2939. case 27989:
  2940. case 76006:
  2941. {
  2942. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(GetMapIndex());
  2943.  
  2944. if (pMap != NULL)
  2945. {
  2946. item->SetSocket(0, item->GetSocket(0) + 1);
  2947.  
  2948. FFindStone f;
  2949.  
  2950. // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
  2951. pMap->for_each(f);
  2952.  
  2953. if (f.m_mapStone.size() > 0)
  2954. {
  2955. std::map<DWORD, LPCHARACTER>::iterator stone = f.m_mapStone.begin();
  2956.  
  2957. DWORD max = UINT_MAX;
  2958. LPCHARACTER pTarget = stone->second;
  2959.  
  2960. while (stone != f.m_mapStone.end())
  2961. {
  2962. DWORD dist = (DWORD)DISTANCE_SQRT(GetX()-stone->second->GetX(), GetY()-stone->second->GetY());
  2963.  
  2964. if (dist != 0 && max > dist)
  2965. {
  2966. max = dist;
  2967. pTarget = stone->second;
  2968. }
  2969. stone++;
  2970. }
  2971.  
  2972. if (pTarget != NULL)
  2973. {
  2974. int val = 3;
  2975.  
  2976. if (max < 10000) val = 2;
  2977. else if (max < 70000) val = 1;
  2978.  
  2979. ChatPacket(CHAT_TYPE_COMMAND, "StoneDetect %u %d %d", (DWORD)GetVID(), val,
  2980. (int)GetDegreeFromPositionXY(GetX(), pTarget->GetY(), pTarget->GetX(), GetY()));
  2981. }
  2982. else
  2983. {
  2984. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°¨Áö±â¸¦ ŔŰżëÇĎż´Ŕ¸łŞ °¨ÁöµÇ´Â żµĽ®ŔĚ ľř˝Ŕ´Ď´Ů."));
  2985. }
  2986. }
  2987. else
  2988. {
  2989. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°¨Áö±â¸¦ ŔŰżëÇĎż´Ŕ¸łŞ °¨ÁöµÇ´Â żµĽ®ŔĚ ľř˝Ŕ´Ď´Ů."));
  2990. }
  2991.  
  2992. if (item->GetSocket(0) >= 6)
  2993. {
  2994. ChatPacket(CHAT_TYPE_COMMAND, "StoneDetect %u 0 0", (DWORD)GetVID());
  2995. ITEM_MANAGER::instance().RemoveItem(item);
  2996. }
  2997. }
  2998. break;
  2999. }
  3000. break;
  3001.  
  3002. case 27996:
  3003. item->SetCount(item->GetCount() - 1);
  3004. AttackedByPoison(NULL); // @warme008
  3005. break;
  3006.  
  3007. case 27987:
  3008.  
  3009. // 30 ˛Î
  3010.  
  3011.  
  3012.  
  3013. {
  3014. item->SetCount(item->GetCount() - 1);
  3015.  
  3016. int r = number(1, 100);
  3017.  
  3018. if (r <= 50)
  3019. {
  3020. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¶°łżˇĽ­ µąÁ¶°˘ŔĚ łŞżÔ˝Ŕ´Ď´Ů."));
  3021. AutoGiveItem(27990);
  3022. }
  3023. else
  3024. {
  3025. const int prob_table_gb2312[] =
  3026. {
  3027. 95, 97, 99
  3028. };
  3029.  
  3030. const int * prob_table = prob_table_gb2312;
  3031.  
  3032. if (r <= prob_table[0])
  3033. {
  3034. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¶°ł°ˇ ČçŔűµµ ľřŔĚ »ç¶óÁý´Ď´Ů."));
  3035. }
  3036. else if (r <= prob_table[1])
  3037. {
  3038. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¶°łżˇĽ­ ąéÁřÁÖ°ˇ łŞżÔ˝Ŕ´Ď´Ů."));
  3039. AutoGiveItem(27992);
  3040. }
  3041. else if (r <= prob_table[2])
  3042. {
  3043. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¶°łżˇĽ­ Ă»ÁřÁÖ°ˇ łŞżÔ˝Ŕ´Ď´Ů."));
  3044. AutoGiveItem(27993);
  3045. }
  3046. else
  3047. {
  3048. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¶°łżˇĽ­ ÇÇÁřÁÖ°ˇ łŞżÔ˝Ŕ´Ď´Ů."));
  3049. AutoGiveItem(27994);
  3050. }
  3051. }
  3052. }
  3053. break;
  3054.  
  3055. case 71013:
  3056. CreateFly(number(FLY_FIREWORK1, FLY_FIREWORK6), this);
  3057. item->SetCount(item->GetCount() - 1);
  3058. break;
  3059.  
  3060. case 50100:
  3061. case 50101:
  3062. case 50102:
  3063. case 50103:
  3064. case 50104:
  3065. case 50105:
  3066. case 50106:
  3067. CreateFly(item->GetVnum() - 50100 + FLY_FIREWORK1, this);
  3068. item->SetCount(item->GetCount() - 1);
  3069. break;
  3070.  
  3071. case 50200:
  3072. if (g_bEnableBootaryCheck)
  3073. {
  3074. if (IS_BOTARYABLE_ZONE(GetMapIndex()) == true)
  3075. {
  3076. __OpenPrivateShop();
  3077. }
  3078. else
  3079. {
  3080. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°łŔÎ »óÁˇŔ» ż­ Ľö ľř´Â ÁöżŞŔÔ´Ď´Ů"));
  3081. }
  3082. }
  3083. else
  3084. {
  3085. __OpenPrivateShop();
  3086. }
  3087. break;
  3088.  
  3089. case fishing::FISH_MIND_PILL_VNUM:
  3090. AddAffect(AFFECT_FISH_MIND_PILL, POINT_NONE, 0, AFF_FISH_MIND, 20*60, 0, true);
  3091. item->SetCount(item->GetCount() - 1);
  3092. break;
  3093.  
  3094. case 50301:
  3095. case 50302:
  3096. case 50303:
  3097. {
  3098. if (IsPolymorphed() == true)
  3099. {
  3100. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µĐ°© Áßżˇ´Â ´É·ÂŔ» żĂ¸± Ľö ľř˝Ŕ´Ď´Ů."));
  3101. return false;
  3102. }
  3103.  
  3104. int lv = GetSkillLevel(SKILL_LEADERSHIP);
  3105.  
  3106. if (lv < item->GetValue(0))
  3107. {
  3108. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ĂĄŔş łĘą« ľî·Áżö ŔĚÇŘÇϱⰡ Čűµě´Ď´Ů."));
  3109. return false;
  3110. }
  3111.  
  3112. if (lv >= item->GetValue(1))
  3113. {
  3114. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ĂĄŔş ľĆą«¸® şÁµµ µµżňŔĚ µÉ °Í °°Áö ľĘ˝Ŕ´Ď´Ů."));
  3115. return false;
  3116. }
  3117.  
  3118. if (LearnSkillByBook(SKILL_LEADERSHIP))
  3119. {
  3120. #ifdef ENABLE_BOOKS_STACKFIX
  3121. item->SetCount(item->GetCount() - 1);
  3122. #else
  3123. ITEM_MANAGER::instance().RemoveItem(item);
  3124. #endif
  3125.  
  3126. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3127. if (distribution_test_server) iReadDelay /= 3;
  3128.  
  3129. SetSkillNextReadTime(SKILL_LEADERSHIP, get_global_time() + iReadDelay);
  3130. }
  3131. }
  3132. break;
  3133.  
  3134. case 50304:
  3135. case 50305:
  3136. case 50306:
  3137. {
  3138. if (IsPolymorphed())
  3139. {
  3140. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şŻ˝ĹÁßżˇ´Â ĂĄŔ» ŔĐŔ»Ľö ľř˝Ŕ´Ď´Ů."));
  3141. return false;
  3142.  
  3143. }
  3144. if (GetSkillLevel(SKILL_COMBO) == 0 && GetLevel() < 30)
  3145. {
  3146. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("·ąş§ 30ŔĚ µÇ±â Ŕüżˇ´Â ˝ŔµćÇŇ Ľö ŔÖŔ» °Í °°Áö ľĘ˝Ŕ´Ď´Ů."));
  3147. return false;
  3148. }
  3149.  
  3150. if (GetSkillLevel(SKILL_COMBO) == 1 && GetLevel() < 50)
  3151. {
  3152. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("·ąş§ 50ŔĚ µÇ±â Ŕüżˇ´Â ˝ŔµćÇŇ Ľö ŔÖŔ» °Í °°Áö ľĘ˝Ŕ´Ď´Ů."));
  3153. return false;
  3154. }
  3155.  
  3156. if (GetSkillLevel(SKILL_COMBO) >= 2)
  3157. {
  3158. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ż¬°č±â´Â ´őŔĚ»ó Ľö·ĂÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  3159. return false;
  3160. }
  3161.  
  3162. int iPct = item->GetValue(0);
  3163.  
  3164. if (LearnSkillByBook(SKILL_COMBO, iPct))
  3165. {
  3166. #ifdef ENABLE_BOOKS_STACKFIX
  3167. item->SetCount(item->GetCount() - 1);
  3168. #else
  3169. ITEM_MANAGER::instance().RemoveItem(item);
  3170. #endif
  3171.  
  3172. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3173. if (distribution_test_server) iReadDelay /= 3;
  3174.  
  3175. SetSkillNextReadTime(SKILL_COMBO, get_global_time() + iReadDelay);
  3176. }
  3177. }
  3178. break;
  3179. case 50311:
  3180. case 50312:
  3181. case 50313:
  3182. {
  3183. if (IsPolymorphed())
  3184. {
  3185. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şŻ˝ĹÁßżˇ´Â ĂĄŔ» ŔĐŔ»Ľö ľř˝Ŕ´Ď´Ů."));
  3186. return false;
  3187.  
  3188. }
  3189. DWORD dwSkillVnum = item->GetValue(0);
  3190. int iPct = MINMAX(0, item->GetValue(1), 100);
  3191. if (GetSkillLevel(dwSkillVnum)>=20 || dwSkillVnum-SKILL_LANGUAGE1+1 == GetEmpire())
  3192. {
  3193. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ żĎş®ÇĎ°Ô ľËľĆµéŔ» Ľö ŔÖ´Â ľđľîŔĚ´Ů."));
  3194. return false;
  3195. }
  3196.  
  3197. if (LearnSkillByBook(dwSkillVnum, iPct))
  3198. {
  3199. #ifdef ENABLE_BOOKS_STACKFIX
  3200. item->SetCount(item->GetCount() - 1);
  3201. #else
  3202. ITEM_MANAGER::instance().RemoveItem(item);
  3203. #endif
  3204.  
  3205. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3206. if (distribution_test_server) iReadDelay /= 3;
  3207.  
  3208. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3209. }
  3210. }
  3211. break;
  3212.  
  3213. case 50061 :
  3214. {
  3215. if (IsPolymorphed())
  3216. {
  3217. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şŻ˝ĹÁßżˇ´Â ĂĄŔ» ŔĐŔ»Ľö ľř˝Ŕ´Ď´Ů."));
  3218. return false;
  3219.  
  3220. }
  3221. DWORD dwSkillVnum = item->GetValue(0);
  3222. int iPct = MINMAX(0, item->GetValue(1), 100);
  3223.  
  3224. if (GetSkillLevel(dwSkillVnum) >= 10)
  3225. {
  3226. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ő ŔĚ»ó Ľö·ĂÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  3227. return false;
  3228. }
  3229.  
  3230. if (LearnSkillByBook(dwSkillVnum, iPct))
  3231. {
  3232. #ifdef ENABLE_BOOKS_STACKFIX
  3233. item->SetCount(item->GetCount() - 1);
  3234. #else
  3235. ITEM_MANAGER::instance().RemoveItem(item);
  3236. #endif
  3237.  
  3238. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3239. if (distribution_test_server) iReadDelay /= 3;
  3240.  
  3241. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3242. }
  3243. }
  3244. break;
  3245.  
  3246. case 50314: case 50315: case 50316:
  3247. case 50323: case 50324:
  3248. case 50325: case 50326:
  3249. {
  3250. if (IsPolymorphed() == true)
  3251. {
  3252. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µĐ°© Áßżˇ´Â ´É·ÂŔ» żĂ¸± Ľö ľř˝Ŕ´Ď´Ů."));
  3253. return false;
  3254. }
  3255.  
  3256. int iSkillLevelLowLimit = item->GetValue(0);
  3257. int iSkillLevelHighLimit = item->GetValue(1);
  3258. int iPct = MINMAX(0, item->GetValue(2), 100);
  3259. int iLevelLimit = item->GetValue(3);
  3260. DWORD dwSkillVnum = 0;
  3261.  
  3262. switch (item->GetVnum())
  3263. {
  3264. case 50314: case 50315: case 50316:
  3265. dwSkillVnum = SKILL_POLYMORPH;
  3266. break;
  3267.  
  3268. case 50323: case 50324:
  3269. dwSkillVnum = SKILL_ADD_HP;
  3270. break;
  3271.  
  3272. case 50325: case 50326:
  3273. dwSkillVnum = SKILL_RESIST_PENETRATE;
  3274. break;
  3275.  
  3276. default:
  3277. return false;
  3278. }
  3279.  
  3280. if (0 == dwSkillVnum)
  3281. return false;
  3282.  
  3283. if (GetLevel() < iLevelLimit)
  3284. {
  3285. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ĂĄŔ» ŔĐŔ¸·Á¸é ·ąş§Ŕ» ´ő żĂ·Áľß ÇŐ´Ď´Ů."));
  3286. return false;
  3287. }
  3288.  
  3289. if (GetSkillLevel(dwSkillVnum) >= 40)
  3290. {
  3291. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ő ŔĚ»ó Ľö·ĂÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  3292. return false;
  3293. }
  3294.  
  3295. if (GetSkillLevel(dwSkillVnum) < iSkillLevelLowLimit)
  3296. {
  3297. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ĂĄŔş łĘą« ľî·Áżö ŔĚÇŘÇϱⰡ Čűµě´Ď´Ů."));
  3298. return false;
  3299. }
  3300.  
  3301. if (GetSkillLevel(dwSkillVnum) >= iSkillLevelHighLimit)
  3302. {
  3303. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ĂĄŔ¸·Î´Â ´ő ŔĚ»ó Ľö·ĂÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  3304. return false;
  3305. }
  3306.  
  3307. if (LearnSkillByBook(dwSkillVnum, iPct))
  3308. {
  3309. #ifdef ENABLE_BOOKS_STACKFIX
  3310. item->SetCount(item->GetCount() - 1);
  3311. #else
  3312. ITEM_MANAGER::instance().RemoveItem(item);
  3313. #endif
  3314.  
  3315. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3316. if (distribution_test_server) iReadDelay /= 3;
  3317.  
  3318. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3319. }
  3320. }
  3321. break;
  3322.  
  3323. case 50902:
  3324. case 50903:
  3325. case 50904:
  3326. {
  3327. if (IsPolymorphed())
  3328. {
  3329. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şŻ˝ĹÁßżˇ´Â ĂĄŔ» ŔĐŔ»Ľö ľř˝Ŕ´Ď´Ů."));
  3330. return false;
  3331.  
  3332. }
  3333. DWORD dwSkillVnum = SKILL_CREATE;
  3334. int iPct = MINMAX(0, item->GetValue(1), 100);
  3335.  
  3336. if (GetSkillLevel(dwSkillVnum)>=40)
  3337. {
  3338. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ő ŔĚ»ó Ľö·ĂÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  3339. return false;
  3340. }
  3341.  
  3342. if (LearnSkillByBook(dwSkillVnum, iPct))
  3343. {
  3344. #ifdef ENABLE_BOOKS_STACKFIX
  3345. item->SetCount(item->GetCount() - 1);
  3346. #else
  3347. ITEM_MANAGER::instance().RemoveItem(item);
  3348. #endif
  3349.  
  3350. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3351. if (distribution_test_server) iReadDelay /= 3;
  3352.  
  3353. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3354.  
  3355. if (test_server)
  3356. {
  3357. ChatPacket(CHAT_TYPE_INFO, "[TEST_SERVER] Success to learn skill ");
  3358. }
  3359. }
  3360. else
  3361. {
  3362. if (test_server)
  3363. {
  3364. ChatPacket(CHAT_TYPE_INFO, "[TEST_SERVER] Failed to learn skill ");
  3365. }
  3366. }
  3367. }
  3368. break;
  3369.  
  3370. // MINING
  3371. case ITEM_MINING_SKILL_TRAIN_BOOK:
  3372. {
  3373. if (IsPolymorphed())
  3374. {
  3375. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şŻ˝ĹÁßżˇ´Â ĂĄŔ» ŔĐŔ»Ľö ľř˝Ŕ´Ď´Ů."));
  3376. return false;
  3377.  
  3378. }
  3379. DWORD dwSkillVnum = SKILL_MINING;
  3380. int iPct = MINMAX(0, item->GetValue(1), 100);
  3381.  
  3382. if (GetSkillLevel(dwSkillVnum)>=40)
  3383. {
  3384. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ő ŔĚ»ó Ľö·ĂÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  3385. return false;
  3386. }
  3387.  
  3388. if (LearnSkillByBook(dwSkillVnum, iPct))
  3389. {
  3390. #ifdef ENABLE_BOOKS_STACKFIX
  3391. item->SetCount(item->GetCount() - 1);
  3392. #else
  3393. ITEM_MANAGER::instance().RemoveItem(item);
  3394. #endif
  3395.  
  3396. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3397. if (distribution_test_server) iReadDelay /= 3;
  3398.  
  3399. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3400. }
  3401. }
  3402. break;
  3403. // END_OF_MINING
  3404.  
  3405. case ITEM_HORSE_SKILL_TRAIN_BOOK:
  3406. {
  3407. if (IsPolymorphed())
  3408. {
  3409. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şŻ˝ĹÁßżˇ´Â ĂĄŔ» ŔĐŔ»Ľö ľř˝Ŕ´Ď´Ů."));
  3410. return false;
  3411.  
  3412. }
  3413. DWORD dwSkillVnum = SKILL_HORSE;
  3414. int iPct = MINMAX(0, item->GetValue(1), 100);
  3415.  
  3416. if (GetLevel() < 50)
  3417. {
  3418. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆÁ÷ ˝Â¸¶ ˝şĹłŔ» Ľö·ĂÇŇ Ľö ŔÖ´Â ·ąş§ŔĚ ľĆ´Ő´Ď´Ů."));
  3419. return false;
  3420. }
  3421.  
  3422. if (!test_server && get_global_time() < GetSkillNextReadTime(dwSkillVnum))
  3423. {
  3424. if (FindAffect(AFFECT_SKILL_NO_BOOK_DELAY))
  3425. {
  3426.  
  3427. RemoveAffect(AFFECT_SKILL_NO_BOOK_DELAY);
  3428. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á־ȼúĽ­¸¦ ĹëÇŘ ÁÖČ­ŔÔ¸¶żˇĽ­ şüÁ®łŞżÔ˝Ŕ´Ď´Ů."));
  3429. }
  3430. else
  3431. {
  3432. SkillLearnWaitMoreTimeMessage(GetSkillNextReadTime(dwSkillVnum) - get_global_time());
  3433. return false;
  3434. }
  3435. }
  3436.  
  3437. if (GetPoint(POINT_HORSE_SKILL) >= 20 ||
  3438. GetSkillLevel(SKILL_HORSE_WILDATTACK) + GetSkillLevel(SKILL_HORSE_CHARGE) + GetSkillLevel(SKILL_HORSE_ESCAPE) >= 60 ||
  3439. GetSkillLevel(SKILL_HORSE_WILDATTACK_RANGE) + GetSkillLevel(SKILL_HORSE_CHARGE) + GetSkillLevel(SKILL_HORSE_ESCAPE) >= 60)
  3440. {
  3441. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ő ŔĚ»ó ˝Â¸¶ Ľö·ĂĽ­¸¦ ŔĐŔ» Ľö ľř˝Ŕ´Ď´Ů."));
  3442. return false;
  3443. }
  3444.  
  3445. if (number(1, 100) <= iPct)
  3446. {
  3447. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("˝Â¸¶ Ľö·ĂĽ­¸¦ ŔĐľî ˝Â¸¶ ˝şĹł Ć÷ŔÎĆ®¸¦ ľňľú˝Ŕ´Ď´Ů."));
  3448. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľňŔş Ć÷ŔÎĆ®·Î´Â ˝Â¸¶ ˝şĹłŔÇ ·ąş§Ŕ» żĂ¸± Ľö ŔÖ˝Ŕ´Ď´Ů."));
  3449. PointChange(POINT_HORSE_SKILL, 1);
  3450.  
  3451. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3452. if (distribution_test_server) iReadDelay /= 3;
  3453.  
  3454. if (!test_server)
  3455. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3456. }
  3457. else
  3458. {
  3459. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("˝Â¸¶ Ľö·ĂĽ­ ŔĚÇŘżˇ ˝ÇĆĐÇĎż´˝Ŕ´Ď´Ů."));
  3460. }
  3461. #ifdef ENABLE_BOOKS_STACKFIX
  3462. item->SetCount(item->GetCount() - 1);
  3463. #else
  3464. ITEM_MANAGER::instance().RemoveItem(item);
  3465. #endif
  3466. }
  3467. break;
  3468.  
  3469. case 70102:
  3470. case 70103:
  3471. {
  3472. if (GetAlignment() >= 0)
  3473. return false;
  3474.  
  3475. int delta = MIN(-GetAlignment(), item->GetValue(0));
  3476.  
  3477. sys_log(0, "%s ALIGNMENT ITEM %d", GetName(), delta);
  3478.  
  3479. UpdateAlignment(delta);
  3480. item->SetCount(item->GetCount() - 1);
  3481.  
  3482. if (delta / 10 > 0)
  3483. {
  3484. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¸¶Ŕ˝ŔĚ ¸ĽľĆÁö´Â±ş. °ˇ˝żŔ» Áţ´©¸Ł´ř ą«ľđ°ˇ°ˇ Á» °ˇş­żöÁř ´Ŕł¦ŔĚľß."));
  3485. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ľ±ľÇġ°ˇ %d Áő°ˇÇĎż´˝Ŕ´Ď´Ů."), delta/10);
  3486. }
  3487. }
  3488. break;
  3489.  
  3490. case 71107:
  3491. {
  3492. int val = item->GetValue(0);
  3493. int interval = item->GetValue(1);
  3494. quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetPlayerID());
  3495. int last_use_time = pPC->GetFlag("mythical_peach.last_use_time");
  3496.  
  3497. if (get_global_time() - last_use_time < interval * 60 * 60)
  3498. {
  3499. if (test_server == false)
  3500. {
  3501. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆÁ÷ »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  3502. return false;
  3503. }
  3504. else
  3505. {
  3506. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ĺ×˝şĆ® Ľ­ąö ˝Ă°ŁÁ¦ÇŃ Ĺë°ú"));
  3507. }
  3508. }
  3509.  
  3510. if (GetAlignment() == 200000)
  3511. {
  3512. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ľ±ľÇġ¸¦ ´ő ŔĚ»ó żĂ¸± Ľö ľř˝Ŕ´Ď´Ů."));
  3513. return false;
  3514. }
  3515.  
  3516. if (200000 - GetAlignment() < val * 10)
  3517. {
  3518. val = (200000 - GetAlignment()) / 10;
  3519. }
  3520.  
  3521. int old_alignment = GetAlignment() / 10;
  3522.  
  3523. UpdateAlignment(val*10);
  3524.  
  3525. item->SetCount(item->GetCount()-1);
  3526. pPC->SetFlag("mythical_peach.last_use_time", get_global_time());
  3527.  
  3528. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¸¶Ŕ˝ŔĚ ¸ĽľĆÁö´Â±ş. °ˇ˝żŔ» Áţ´©¸Ł´ř ą«ľđ°ˇ°ˇ Á» °ˇş­żöÁř ´Ŕł¦ŔĚľß."));
  3529. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ľ±ľÇġ°ˇ %d Áő°ˇÇĎż´˝Ŕ´Ď´Ů."), val);
  3530.  
  3531. char buf[256 + 1];
  3532. snprintf(buf, sizeof(buf), "%d %d", old_alignment, GetAlignment() / 10);
  3533. LogManager::instance().CharLog(this, val, "MYTHICAL_PEACH", buf);
  3534. }
  3535. break;
  3536.  
  3537. case 71109:
  3538. case 72719:
  3539. {
  3540. LPITEM item2;
  3541.  
  3542. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  3543. return false;
  3544.  
  3545. if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  3546. return false;
  3547.  
  3548. if (item2->GetSocketCount() == 0)
  3549. return false;
  3550.  
  3551. switch( item2->GetType() )
  3552. {
  3553. case ITEM_WEAPON:
  3554. break;
  3555. case ITEM_ARMOR:
  3556. switch (item2->GetSubType())
  3557. {
  3558. case ARMOR_EAR:
  3559. case ARMOR_WRIST:
  3560. case ARMOR_NECK:
  3561. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»©łľ żµĽ®ŔĚ ľř˝Ŕ´Ď´Ů"));
  3562. return false;
  3563. }
  3564. break;
  3565.  
  3566. default:
  3567. return false;
  3568. }
  3569.  
  3570. std::stack<long> socket;
  3571.  
  3572. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  3573. socket.push(item2->GetSocket(i));
  3574.  
  3575. int idx = ITEM_SOCKET_MAX_NUM - 1;
  3576.  
  3577. while (socket.size() > 0)
  3578. {
  3579. if (socket.top() > 2 && socket.top() != ITEM_BROKEN_METIN_VNUM)
  3580. break;
  3581.  
  3582. idx--;
  3583. socket.pop();
  3584. }
  3585.  
  3586. if (socket.size() == 0)
  3587. {
  3588. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»©łľ żµĽ®ŔĚ ľř˝Ŕ´Ď´Ů"));
  3589. return false;
  3590. }
  3591.  
  3592. LPITEM pItemReward = AutoGiveItem(socket.top());
  3593.  
  3594. if (pItemReward != NULL)
  3595. {
  3596. item2->SetSocket(idx, 1);
  3597.  
  3598. char buf[256+1];
  3599. snprintf(buf, sizeof(buf), "%s(%u) %s(%u)",
  3600. item2->GetName(), item2->GetID(), pItemReward->GetName(), pItemReward->GetID());
  3601. LogManager::instance().ItemLog(this, item, "USE_DETACHMENT_ONE", buf);
  3602.  
  3603. item->SetCount(item->GetCount() - 1);
  3604. }
  3605. }
  3606. break;
  3607.  
  3608. case 70201:
  3609. case 70202:
  3610. case 70203:
  3611. case 70204:
  3612. case 70205:
  3613. case 70206:
  3614. {
  3615. // NEW_HAIR_STYLE_ADD
  3616. if (GetPart(PART_HAIR) >= 1001)
  3617. {
  3618. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÇöŔç Çěľî˝şĹ¸ŔĎżˇĽ­´Â ż°»ö°ú Ĺ»»öŔĚ şŇ°ˇ´ÉÇŐ´Ď´Ů."));
  3619. }
  3620. // END_NEW_HAIR_STYLE_ADD
  3621. else
  3622. {
  3623. quest::CQuestManager& q = quest::CQuestManager::instance();
  3624. quest::PC* pPC = q.GetPC(GetPlayerID());
  3625.  
  3626. if (pPC)
  3627. {
  3628. int last_dye_level = pPC->GetFlag("dyeing_hair.last_dye_level");
  3629.  
  3630. if (last_dye_level == 0 ||
  3631. last_dye_level+3 <= GetLevel() ||
  3632. item->GetVnum() == 70201)
  3633. {
  3634. SetPart(PART_HAIR, item->GetVnum() - 70201);
  3635.  
  3636. if (item->GetVnum() == 70201)
  3637. pPC->SetFlag("dyeing_hair.last_dye_level", 0);
  3638. else
  3639. pPC->SetFlag("dyeing_hair.last_dye_level", GetLevel());
  3640.  
  3641. item->SetCount(item->GetCount() - 1);
  3642. UpdatePacket();
  3643. }
  3644. else
  3645. {
  3646. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d ·ąş§ŔĚ µÇľîľß ´Ů˝Ă ż°»öÇĎ˝Ç Ľö ŔÖ˝Ŕ´Ď´Ů."), last_dye_level+3);
  3647. }
  3648. }
  3649. }
  3650. }
  3651. break;
  3652.  
  3653. case ITEM_NEW_YEAR_GREETING_VNUM:
  3654. {
  3655. DWORD dwBoxVnum = ITEM_NEW_YEAR_GREETING_VNUM;
  3656. std::vector <DWORD> dwVnums;
  3657. std::vector <DWORD> dwCounts;
  3658. std::vector <LPITEM> item_gets;
  3659. int count = 0;
  3660.  
  3661. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  3662. {
  3663. for (int i = 0; i < count; i++)
  3664. {
  3665. if (dwVnums[i] == CSpecialItemGroup::GOLD)
  3666. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ· %d łÉŔ» ČąµćÇß˝Ŕ´Ď´Ů."), dwCounts[i]);
  3667. }
  3668.  
  3669. item->SetCount(item->GetCount() - 1);
  3670. }
  3671. }
  3672. break;
  3673.  
  3674. case ITEM_VALENTINE_ROSE:
  3675. case ITEM_VALENTINE_CHOCOLATE:
  3676. {
  3677. DWORD dwBoxVnum = item->GetVnum();
  3678. std::vector <DWORD> dwVnums;
  3679. std::vector <DWORD> dwCounts;
  3680. std::vector <LPITEM> item_gets(0);
  3681. int count = 0;
  3682.  
  3683.  
  3684. if (((item->GetVnum() == ITEM_VALENTINE_ROSE) && (SEX_MALE==GET_SEX(this))) ||
  3685. ((item->GetVnum() == ITEM_VALENTINE_CHOCOLATE) && (SEX_FEMALE==GET_SEX(this))))
  3686. {
  3687.  
  3688. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ľşş°ŔĚ ¸ÂÁöľĘľĆ ŔĚ ľĆŔĚĹŰŔ» ż­ Ľö ľř˝Ŕ´Ď´Ů."));
  3689. return false;
  3690. }
  3691.  
  3692.  
  3693. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  3694. item->SetCount(item->GetCount()-1);
  3695. }
  3696. break;
  3697.  
  3698. case ITEM_WHITEDAY_CANDY:
  3699. case ITEM_WHITEDAY_ROSE:
  3700. {
  3701. DWORD dwBoxVnum = item->GetVnum();
  3702. std::vector <DWORD> dwVnums;
  3703. std::vector <DWORD> dwCounts;
  3704. std::vector <LPITEM> item_gets(0);
  3705. int count = 0;
  3706.  
  3707.  
  3708. if (((item->GetVnum() == ITEM_WHITEDAY_CANDY) && (SEX_MALE==GET_SEX(this))) ||
  3709. ((item->GetVnum() == ITEM_WHITEDAY_ROSE) && (SEX_FEMALE==GET_SEX(this))))
  3710. {
  3711.  
  3712. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ľşş°ŔĚ ¸ÂÁöľĘľĆ ŔĚ ľĆŔĚĹŰŔ» ż­ Ľö ľř˝Ŕ´Ď´Ů."));
  3713. return false;
  3714. }
  3715.  
  3716.  
  3717. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  3718. item->SetCount(item->GetCount()-1);
  3719. }
  3720. break;
  3721.  
  3722. case 50011:
  3723. {
  3724. DWORD dwBoxVnum = 50011;
  3725. std::vector <DWORD> dwVnums;
  3726. std::vector <DWORD> dwCounts;
  3727. std::vector <LPITEM> item_gets(0);
  3728. int count = 0;
  3729.  
  3730. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  3731. {
  3732. for (int i = 0; i < count; i++)
  3733. {
  3734. char buf[50 + 1];
  3735. snprintf(buf, sizeof(buf), "%u %u", dwVnums[i], dwCounts[i]);
  3736. LogManager::instance().ItemLog(this, item, "MOONLIGHT_GET", buf);
  3737.  
  3738. //ITEM_MANAGER::instance().RemoveItem(item);
  3739. item->SetCount(item->GetCount() - 1);
  3740.  
  3741. switch (dwVnums[i])
  3742. {
  3743. case CSpecialItemGroup::GOLD:
  3744. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ· %d łÉŔ» ČąµćÇß˝Ŕ´Ď´Ů."), dwCounts[i]);
  3745. break;
  3746.  
  3747. case CSpecialItemGroup::EXP:
  3748. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ şÎĹÍ ˝ĹşńÇŃ şűŔĚ łŞżÉ´Ď´Ů."));
  3749. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%dŔÇ °ćÇčġ¸¦ ČąµćÇß˝Ŕ´Ď´Ů."), dwCounts[i]);
  3750. break;
  3751.  
  3752. case CSpecialItemGroup::MOB:
  3753. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ ¸ó˝şĹÍ°ˇ łŞĹ¸łµ˝Ŕ´Ď´Ů!"));
  3754. break;
  3755.  
  3756. case CSpecialItemGroup::SLOW:
  3757. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ łŞżÂ »ˇ°Ł ż¬±â¸¦ µéŔ̸¶˝ĂŔÚ żňÁ÷ŔĚ´Â ĽÓµµ°ˇ ´Ŕ·ÁÁł˝Ŕ´Ď´Ů!"));
  3758. break;
  3759.  
  3760. case CSpecialItemGroup::DRAIN_HP:
  3761. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚ°ˇ °©ŔÚ±â ĆřąßÇĎż´˝Ŕ´Ď´Ů! »ý¸í·ÂŔĚ °¨ĽŇÇß˝Ŕ´Ď´Ů."));
  3762. break;
  3763.  
  3764. case CSpecialItemGroup::POISON:
  3765. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ łŞżÂ łě»ö ż¬±â¸¦ µéŔ̸¶˝ĂŔÚ µ¶ŔĚ żÂ¸öŔ¸·Î ĆŰÁý´Ď´Ů!"));
  3766. break;
  3767. #ifdef ENABLE_WOLFMAN_CHARACTER
  3768. case CSpecialItemGroup::BLEEDING:
  3769. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ łŞżÂ łě»ö ż¬±â¸¦ µéŔ̸¶˝ĂŔÚ µ¶ŔĚ żÂ¸öŔ¸·Î ĆŰÁý´Ď´Ů!"));
  3770. break;
  3771. #endif
  3772. case CSpecialItemGroup::MOB_GROUP:
  3773. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ ¸ó˝şĹÍ°ˇ łŞĹ¸łµ˝Ŕ´Ď´Ů!"));
  3774. break;
  3775.  
  3776. default:
  3777. if (item_gets[i])
  3778. {
  3779. if (dwCounts[i] > 1)
  3780. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ %s °ˇ %d °ł łŞżÔ˝Ŕ´Ď´Ů."), item_gets[i]->GetName(), dwCounts[i]);
  3781. else
  3782. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óŔÚżˇĽ­ %s °ˇ łŞżÔ˝Ŕ´Ď´Ů."), item_gets[i]->GetName());
  3783. }
  3784. break;
  3785. }
  3786. }
  3787. }
  3788. else
  3789. {
  3790. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("ľĆą«°Íµµ ľňŔ» Ľö ľřľú˝Ŕ´Ď´Ů."));
  3791. return false;
  3792. }
  3793. }
  3794. break;
  3795.  
  3796. case ITEM_GIVE_STAT_RESET_COUNT_VNUM:
  3797. {
  3798. //PointChange(POINT_GOLD, -iCost);
  3799. PointChange(POINT_STAT_RESET_COUNT, 1);
  3800. item->SetCount(item->GetCount()-1);
  3801. }
  3802. break;
  3803.  
  3804. case 50107:
  3805. {
  3806. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  3807. {
  3808. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  3809. return false;
  3810. }
  3811. #ifdef ENABLE_NEWSTUFF
  3812. else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  3813. {
  3814. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  3815. return false;
  3816. }
  3817. #endif
  3818.  
  3819. EffectPacket(SE_CHINA_FIREWORK);
  3820. #ifdef ENABLE_FIREWORK_STUN
  3821.  
  3822. AddAffect(AFFECT_CHINA_FIREWORK, POINT_STUN_PCT, 30, AFF_CHINA_FIREWORK, 5*60, 0, true);
  3823. #endif
  3824. item->SetCount(item->GetCount()-1);
  3825. }
  3826. break;
  3827.  
  3828. case 50108:
  3829. {
  3830. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  3831. {
  3832. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  3833. return false;
  3834. }
  3835. #ifdef ENABLE_NEWSTUFF
  3836. else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  3837. {
  3838. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  3839. return false;
  3840. }
  3841. #endif
  3842.  
  3843. EffectPacket(SE_SPIN_TOP);
  3844. #ifdef ENABLE_FIREWORK_STUN
  3845.  
  3846. AddAffect(AFFECT_CHINA_FIREWORK, POINT_STUN_PCT, 30, AFF_CHINA_FIREWORK, 5*60, 0, true);
  3847. #endif
  3848. item->SetCount(item->GetCount()-1);
  3849. }
  3850. break;
  3851.  
  3852. case ITEM_WONSO_BEAN_VNUM:
  3853. PointChange(POINT_HP, GetMaxHP() - GetHP());
  3854. item->SetCount(item->GetCount()-1);
  3855. break;
  3856.  
  3857. case ITEM_WONSO_SUGAR_VNUM:
  3858. PointChange(POINT_SP, GetMaxSP() - GetSP());
  3859. item->SetCount(item->GetCount()-1);
  3860. break;
  3861.  
  3862. case ITEM_WONSO_FRUIT_VNUM:
  3863. PointChange(POINT_STAMINA, GetMaxStamina()-GetStamina());
  3864. item->SetCount(item->GetCount()-1);
  3865. break;
  3866.  
  3867. case 90008: // VCARD
  3868. case 90009: // VCARD
  3869. VCardUse(this, this, item);
  3870. break;
  3871.  
  3872. case ITEM_ELK_VNUM:
  3873. {
  3874. int iGold = item->GetSocket(0);
  3875. ITEM_MANAGER::instance().RemoveItem(item);
  3876. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ· %d łÉŔ» ČąµćÇß˝Ŕ´Ď´Ů."), iGold);
  3877. PointChange(POINT_GOLD, iGold);
  3878. }
  3879. break;
  3880.  
  3881.  
  3882. case 70021:
  3883. {
  3884. int HealPrice = quest::CQuestManager::instance().GetEventFlag("MonarchHealGold");
  3885. if (HealPrice == 0)
  3886. HealPrice = 2000000;
  3887.  
  3888. if (CMonarch::instance().HealMyEmpire(this, HealPrice))
  3889. {
  3890. char szNotice[256];
  3891. snprintf(szNotice, sizeof(szNotice), LC_TEXT("±şÁÖŔÇ ĂŕşąŔ¸·Î ŔĚÁöżŞ %s ŔŻŔú´Â HP,SP°ˇ ¸đµÎ äżöÁý´Ď´Ů."), EMPIRE_NAME(GetEmpire()));
  3892. SendNoticeMap(szNotice, GetMapIndex(), false);
  3893.  
  3894. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±şÁÖŔÇ ĂŕşąŔ» »çżëÇĎż´˝Ŕ´Ď´Ů."));
  3895. }
  3896. }
  3897. break;
  3898.  
  3899. case 27995:
  3900. {
  3901. }
  3902. break;
  3903.  
  3904. case 71092 :
  3905. {
  3906. if (m_pkChrTarget != NULL)
  3907. {
  3908. if (m_pkChrTarget->IsPolymorphed())
  3909. {
  3910. m_pkChrTarget->SetPolymorph(0);
  3911. m_pkChrTarget->RemoveAffect(AFFECT_POLYMORPH);
  3912. }
  3913. }
  3914. else
  3915. {
  3916. if (IsPolymorphed())
  3917. {
  3918. SetPolymorph(0);
  3919. RemoveAffect(AFFECT_POLYMORPH);
  3920. }
  3921. }
  3922. }
  3923. break;
  3924.  
  3925. case 71051 :
  3926. {
  3927.  
  3928. LPITEM item2;
  3929.  
  3930. if (!IsValidItemPosition(DestCell) || !(item2 = GetInventoryItem(wDestCell)))
  3931. return false;
  3932.  
  3933. if (ITEM_COSTUME == item2->GetType()) // @fixme124
  3934. {
  3935. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  3936. return false;
  3937. }
  3938.  
  3939. if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  3940. return false;
  3941.  
  3942. if (item2->GetAttributeSetIndex() == -1)
  3943. {
  3944. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  3945. return false;
  3946. }
  3947.  
  3948. if (item2->AddRareAttribute() == true)
  3949. {
  3950. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ľş°řŔűŔ¸·Î ĽÓĽşŔĚ Ăß°ˇ µÇľú˝Ŕ´Ď´Ů"));
  3951.  
  3952. int iAddedIdx = item2->GetRareAttrCount() + 4;
  3953. char buf[21];
  3954. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  3955.  
  3956. LogManager::instance().ItemLog(
  3957. GetPlayerID(),
  3958. item2->GetAttributeType(iAddedIdx),
  3959. item2->GetAttributeValue(iAddedIdx),
  3960. item->GetID(),
  3961. "ADD_RARE_ATTR",
  3962. buf,
  3963. GetDesc()->GetHostName(),
  3964. item->GetOriginalVnum());
  3965.  
  3966. item->SetCount(item->GetCount() - 1);
  3967. }
  3968. else
  3969. {
  3970. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ő ŔĚ»ó ŔĚ ľĆŔĚĹŰŔ¸·Î ĽÓĽşŔ» Ăß°ˇÇŇ Ľö ľř˝Ŕ´Ď´Ů"));
  3971. }
  3972. }
  3973. break;
  3974.  
  3975. case 71052 :
  3976. {
  3977.  
  3978. LPITEM item2;
  3979.  
  3980. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  3981. return false;
  3982.  
  3983. if (ITEM_COSTUME == item2->GetType()) // @fixme124
  3984. {
  3985. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  3986. return false;
  3987. }
  3988.  
  3989. if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  3990. return false;
  3991.  
  3992. if (item2->GetAttributeSetIndex() == -1)
  3993. {
  3994. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  3995. return false;
  3996. }
  3997.  
  3998. if (item2->ChangeRareAttribute() == true)
  3999. {
  4000. char buf[21];
  4001. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4002. LogManager::instance().ItemLog(this, item, "CHANGE_RARE_ATTR", buf);
  4003.  
  4004. item->SetCount(item->GetCount() - 1);
  4005. }
  4006. else
  4007. {
  4008. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şŻ°ć ˝ĂĹł ĽÓĽşŔĚ ľř˝Ŕ´Ď´Ů"));
  4009. }
  4010. }
  4011. break;
  4012.  
  4013. case ITEM_AUTO_HP_RECOVERY_S:
  4014. case ITEM_AUTO_HP_RECOVERY_M:
  4015. case ITEM_AUTO_HP_RECOVERY_L:
  4016. case ITEM_AUTO_HP_RECOVERY_X:
  4017. case ITEM_AUTO_SP_RECOVERY_S:
  4018. case ITEM_AUTO_SP_RECOVERY_M:
  4019. case ITEM_AUTO_SP_RECOVERY_L:
  4020. case ITEM_AUTO_SP_RECOVERY_X:
  4021.  
  4022.  
  4023. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_XS:
  4024. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_S:
  4025. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_XS:
  4026. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_S:
  4027. case FUCKING_BRAZIL_ITEM_AUTO_SP_RECOVERY_S:
  4028. case FUCKING_BRAZIL_ITEM_AUTO_HP_RECOVERY_S:
  4029. {
  4030. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  4031. {
  4032. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ĂŔ忡Ľ­ »çżëÇĎ˝Ç Ľö ľř˝Ŕ´Ď´Ů."));
  4033. return false;
  4034. }
  4035. #ifdef ENABLE_NEWSTUFF
  4036. else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  4037. {
  4038. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  4039. return false;
  4040. }
  4041. #endif
  4042.  
  4043. EAffectTypes type = AFFECT_NONE;
  4044. bool isSpecialPotion = false;
  4045.  
  4046. switch (item->GetVnum())
  4047. {
  4048. case ITEM_AUTO_HP_RECOVERY_X:
  4049. isSpecialPotion = true;
  4050.  
  4051. case ITEM_AUTO_HP_RECOVERY_S:
  4052. case ITEM_AUTO_HP_RECOVERY_M:
  4053. case ITEM_AUTO_HP_RECOVERY_L:
  4054. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_XS:
  4055. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_S:
  4056. case FUCKING_BRAZIL_ITEM_AUTO_HP_RECOVERY_S:
  4057. type = AFFECT_AUTO_HP_RECOVERY;
  4058. break;
  4059.  
  4060. case ITEM_AUTO_SP_RECOVERY_X:
  4061. isSpecialPotion = true;
  4062.  
  4063. case ITEM_AUTO_SP_RECOVERY_S:
  4064. case ITEM_AUTO_SP_RECOVERY_M:
  4065. case ITEM_AUTO_SP_RECOVERY_L:
  4066. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_XS:
  4067. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_S:
  4068. case FUCKING_BRAZIL_ITEM_AUTO_SP_RECOVERY_S:
  4069. type = AFFECT_AUTO_SP_RECOVERY;
  4070. break;
  4071. }
  4072.  
  4073. if (AFFECT_NONE == type)
  4074. break;
  4075.  
  4076. if (item->GetCount() > 1)
  4077. {
  4078. int pos = GetEmptyInventory(item->GetSize());
  4079.  
  4080. if (-1 == pos)
  4081. {
  4082. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽŇÁöÇ°żˇ şó °ř°ŁŔĚ ľř˝Ŕ´Ď´Ů."));
  4083. break;
  4084. }
  4085.  
  4086. item->SetCount( item->GetCount() - 1 );
  4087.  
  4088. LPITEM item2 = ITEM_MANAGER::instance().CreateItem( item->GetVnum(), 1 );
  4089. item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
  4090.  
  4091. if (item->GetSocket(1) != 0)
  4092. {
  4093. item2->SetSocket(1, item->GetSocket(1));
  4094. }
  4095.  
  4096. item = item2;
  4097. }
  4098.  
  4099. CAffect* pAffect = FindAffect( type );
  4100.  
  4101. if (NULL == pAffect)
  4102. {
  4103. EPointTypes bonus = POINT_NONE;
  4104.  
  4105. if (true == isSpecialPotion)
  4106. {
  4107. if (type == AFFECT_AUTO_HP_RECOVERY)
  4108. {
  4109. bonus = POINT_MAX_HP_PCT;
  4110. }
  4111. else if (type == AFFECT_AUTO_SP_RECOVERY)
  4112. {
  4113. bonus = POINT_MAX_SP_PCT;
  4114. }
  4115. }
  4116.  
  4117. AddAffect( type, bonus, 4, item->GetID(), INFINITE_AFFECT_DURATION, 0, true, false);
  4118.  
  4119. item->Lock(true);
  4120. item->SetSocket(0, true);
  4121.  
  4122. AutoRecoveryItemProcess( type );
  4123. }
  4124. else
  4125. {
  4126. if (item->GetID() == pAffect->dwFlag)
  4127. {
  4128. RemoveAffect( pAffect );
  4129.  
  4130. item->Lock(false);
  4131. item->SetSocket(0, false);
  4132. }
  4133. else
  4134. {
  4135. LPITEM old = FindItemByID( pAffect->dwFlag );
  4136.  
  4137. if (NULL != old)
  4138. {
  4139. old->Lock(false);
  4140. old->SetSocket(0, false);
  4141. }
  4142.  
  4143. RemoveAffect( pAffect );
  4144.  
  4145. EPointTypes bonus = POINT_NONE;
  4146.  
  4147. if (true == isSpecialPotion)
  4148. {
  4149. if (type == AFFECT_AUTO_HP_RECOVERY)
  4150. {
  4151. bonus = POINT_MAX_HP_PCT;
  4152. }
  4153. else if (type == AFFECT_AUTO_SP_RECOVERY)
  4154. {
  4155. bonus = POINT_MAX_SP_PCT;
  4156. }
  4157. }
  4158.  
  4159. AddAffect( type, bonus, 4, item->GetID(), INFINITE_AFFECT_DURATION, 0, true, false);
  4160.  
  4161. item->Lock(true);
  4162. item->SetSocket(0, true);
  4163.  
  4164. AutoRecoveryItemProcess( type );
  4165. }
  4166. }
  4167. }
  4168. break;
  4169. }
  4170. break;
  4171.  
  4172. case USE_CLEAR:
  4173. {
  4174. switch (item->GetVnum())
  4175. {
  4176. #ifdef ENABLE_WOLFMAN_CHARACTER
  4177. case 27124: // Bandage
  4178. RemoveBleeding();
  4179. break;
  4180. #endif
  4181. case 27874: // Grilled Perch
  4182. default:
  4183. RemoveBadAffect();
  4184. break;
  4185. }
  4186. item->SetCount(item->GetCount() - 1);
  4187. }
  4188. break;
  4189.  
  4190. case USE_INVISIBILITY:
  4191. {
  4192. if (item->GetVnum() == 70026)
  4193. {
  4194. quest::CQuestManager& q = quest::CQuestManager::instance();
  4195. quest::PC* pPC = q.GetPC(GetPlayerID());
  4196.  
  4197. if (pPC != NULL)
  4198. {
  4199. int last_use_time = pPC->GetFlag("mirror_of_disapper.last_use_time");
  4200.  
  4201. if (get_global_time() - last_use_time < 10*60)
  4202. {
  4203. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆÁ÷ »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  4204. return false;
  4205. }
  4206.  
  4207. pPC->SetFlag("mirror_of_disapper.last_use_time", get_global_time());
  4208. }
  4209. }
  4210.  
  4211. AddAffect(AFFECT_INVISIBILITY, POINT_NONE, 0, AFF_INVISIBILITY, 300, 0, true);
  4212. item->SetCount(item->GetCount() - 1);
  4213. }
  4214. break;
  4215.  
  4216. case USE_POTION_NODELAY:
  4217. {
  4218. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  4219. {
  4220. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
  4221. {
  4222. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ĂŔ忡Ľ­ »çżëÇĎ˝Ç Ľö ľř˝Ŕ´Ď´Ů."));
  4223. return false;
  4224. }
  4225.  
  4226. switch (item->GetVnum())
  4227. {
  4228. case 70020 :
  4229. case 71018 :
  4230. case 71019 :
  4231. case 71020 :
  4232. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
  4233. {
  4234. if (m_nPotionLimit <= 0)
  4235. {
  4236. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»çżë Á¦ÇŃ·®Ŕ» ĂĘ°úÇĎż´˝Ŕ´Ď´Ů."));
  4237. return false;
  4238. }
  4239. }
  4240. break;
  4241.  
  4242. default :
  4243. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ĂŔ忡Ľ­ »çżëÇĎ˝Ç Ľö ľř˝Ŕ´Ď´Ů."));
  4244. return false;
  4245. }
  4246. }
  4247. #ifdef ENABLE_NEWSTUFF
  4248. else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  4249. {
  4250. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  4251. return false;
  4252. }
  4253. #endif
  4254.  
  4255. bool used = false;
  4256.  
  4257. if (item->GetValue(0) != 0)
  4258. {
  4259. if (GetHP() < GetMaxHP())
  4260. {
  4261. PointChange(POINT_HP, item->GetValue(0) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  4262. EffectPacket(SE_HPUP_RED);
  4263. used = TRUE;
  4264. }
  4265. }
  4266.  
  4267. if (item->GetValue(1) != 0)
  4268. {
  4269. if (GetSP() < GetMaxSP())
  4270. {
  4271. PointChange(POINT_SP, item->GetValue(1) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  4272. EffectPacket(SE_SPUP_BLUE);
  4273. used = TRUE;
  4274. }
  4275. }
  4276.  
  4277. if (item->GetValue(3) != 0)
  4278. {
  4279. if (GetHP() < GetMaxHP())
  4280. {
  4281. PointChange(POINT_HP, item->GetValue(3) * GetMaxHP() / 100);
  4282. EffectPacket(SE_HPUP_RED);
  4283. used = TRUE;
  4284. }
  4285. }
  4286.  
  4287. if (item->GetValue(4) != 0)
  4288. {
  4289. if (GetSP() < GetMaxSP())
  4290. {
  4291. PointChange(POINT_SP, item->GetValue(4) * GetMaxSP() / 100);
  4292. EffectPacket(SE_SPUP_BLUE);
  4293. used = TRUE;
  4294. }
  4295. }
  4296.  
  4297. if (used)
  4298. {
  4299. if (item->GetVnum() == 50085 || item->GetVnum() == 50086)
  4300. {
  4301. if (test_server)
  4302. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("żůş´ ¶Ç´Â ÁľŔÚ ¸¦ »çżëÇĎż´˝Ŕ´Ď´Ů"));
  4303. SetUseSeedOrMoonBottleTime();
  4304. }
  4305. if (GetDungeon())
  4306. GetDungeon()->UsePotion(this);
  4307.  
  4308. if (GetWarMap())
  4309. GetWarMap()->UsePotion(this, item);
  4310.  
  4311. m_nPotionLimit--;
  4312.  
  4313. //RESTRICT_USE_SEED_OR_MOONBOTTLE
  4314. item->SetCount(item->GetCount() - 1);
  4315. //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
  4316. }
  4317. }
  4318. break;
  4319.  
  4320. case USE_POTION:
  4321. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  4322. {
  4323. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
  4324. {
  4325. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ĂŔ忡Ľ­ »çżëÇĎ˝Ç Ľö ľř˝Ŕ´Ď´Ů."));
  4326. return false;
  4327. }
  4328.  
  4329. switch (item->GetVnum())
  4330. {
  4331. case 27001 :
  4332. case 27002 :
  4333. case 27003 :
  4334. case 27004 :
  4335. case 27005 :
  4336. case 27006 :
  4337. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
  4338. {
  4339. if (m_nPotionLimit <= 0)
  4340. {
  4341. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»çżë Á¦ÇŃ·®Ŕ» ĂĘ°úÇĎż´˝Ŕ´Ď´Ů."));
  4342. return false;
  4343. }
  4344. }
  4345. break;
  4346.  
  4347. default :
  4348. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ĂŔ忡Ľ­ »çżëÇĎ˝Ç Ľö ľř˝Ŕ´Ď´Ů."));
  4349. return false;
  4350. }
  4351. }
  4352. #ifdef ENABLE_NEWSTUFF
  4353. else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  4354. {
  4355. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  4356. return false;
  4357. }
  4358. #endif
  4359.  
  4360. if (item->GetValue(1) != 0)
  4361. {
  4362. if (GetPoint(POINT_SP_RECOVERY) + GetSP() >= GetMaxSP())
  4363. {
  4364. return false;
  4365. }
  4366.  
  4367. PointChange(POINT_SP_RECOVERY, item->GetValue(1) * MIN(200, (100 + GetPoint(POINT_POTION_BONUS))) / 100);
  4368. StartAffectEvent();
  4369. EffectPacket(SE_SPUP_BLUE);
  4370. }
  4371.  
  4372. if (item->GetValue(0) != 0)
  4373. {
  4374. if (GetPoint(POINT_HP_RECOVERY) + GetHP() >= GetMaxHP())
  4375. {
  4376. return false;
  4377. }
  4378.  
  4379. PointChange(POINT_HP_RECOVERY, item->GetValue(0) * MIN(200, (100 + GetPoint(POINT_POTION_BONUS))) / 100);
  4380. StartAffectEvent();
  4381. EffectPacket(SE_HPUP_RED);
  4382. }
  4383.  
  4384. if (GetDungeon())
  4385. GetDungeon()->UsePotion(this);
  4386.  
  4387. if (GetWarMap())
  4388. GetWarMap()->UsePotion(this, item);
  4389.  
  4390. item->SetCount(item->GetCount() - 1);
  4391. m_nPotionLimit--;
  4392. break;
  4393.  
  4394. case USE_POTION_CONTINUE:
  4395. {
  4396. if (item->GetValue(0) != 0)
  4397. {
  4398. AddAffect(AFFECT_HP_RECOVER_CONTINUE, POINT_HP_RECOVER_CONTINUE, item->GetValue(0), 0, item->GetValue(2), 0, true);
  4399. }
  4400. else if (item->GetValue(1) != 0)
  4401. {
  4402. AddAffect(AFFECT_SP_RECOVER_CONTINUE, POINT_SP_RECOVER_CONTINUE, item->GetValue(1), 0, item->GetValue(2), 0, true);
  4403. }
  4404. else
  4405. return false;
  4406. }
  4407.  
  4408. if (GetDungeon())
  4409. GetDungeon()->UsePotion(this);
  4410.  
  4411. if (GetWarMap())
  4412. GetWarMap()->UsePotion(this, item);
  4413.  
  4414. item->SetCount(item->GetCount() - 1);
  4415. break;
  4416.  
  4417. case USE_ABILITY_UP:
  4418. {
  4419. switch (item->GetValue(0))
  4420. {
  4421. case APPLY_MOV_SPEED:
  4422. AddAffect(AFFECT_MOV_SPEED, POINT_MOV_SPEED, item->GetValue(2), AFF_MOV_SPEED_POTION, item->GetValue(1), 0, true);
  4423. #ifdef ENABLE_EFFECT_EXTRAPOT
  4424. EffectPacket(SE_DXUP_PURPLE);
  4425. #endif
  4426. break;
  4427.  
  4428. case APPLY_ATT_SPEED:
  4429. AddAffect(AFFECT_ATT_SPEED, POINT_ATT_SPEED, item->GetValue(2), AFF_ATT_SPEED_POTION, item->GetValue(1), 0, true);
  4430. #ifdef ENABLE_EFFECT_EXTRAPOT
  4431. EffectPacket(SE_SPEEDUP_GREEN);
  4432. #endif
  4433. break;
  4434.  
  4435. case APPLY_STR:
  4436. AddAffect(AFFECT_STR, POINT_ST, item->GetValue(2), 0, item->GetValue(1), 0, true);
  4437. break;
  4438.  
  4439. case APPLY_DEX:
  4440. AddAffect(AFFECT_DEX, POINT_DX, item->GetValue(2), 0, item->GetValue(1), 0, true);
  4441. break;
  4442.  
  4443. case APPLY_CON:
  4444. AddAffect(AFFECT_CON, POINT_HT, item->GetValue(2), 0, item->GetValue(1), 0, true);
  4445. break;
  4446.  
  4447. case APPLY_INT:
  4448. AddAffect(AFFECT_INT, POINT_IQ, item->GetValue(2), 0, item->GetValue(1), 0, true);
  4449. break;
  4450.  
  4451. case APPLY_CAST_SPEED:
  4452. AddAffect(AFFECT_CAST_SPEED, POINT_CASTING_SPEED, item->GetValue(2), 0, item->GetValue(1), 0, true);
  4453. break;
  4454.  
  4455. case APPLY_ATT_GRADE_BONUS:
  4456. AddAffect(AFFECT_ATT_GRADE, POINT_ATT_GRADE_BONUS,
  4457. item->GetValue(2), 0, item->GetValue(1), 0, true);
  4458. break;
  4459.  
  4460. case APPLY_DEF_GRADE_BONUS:
  4461. AddAffect(AFFECT_DEF_GRADE, POINT_DEF_GRADE_BONUS,
  4462. item->GetValue(2), 0, item->GetValue(1), 0, true);
  4463. break;
  4464. }
  4465. }
  4466.  
  4467. if (GetDungeon())
  4468. GetDungeon()->UsePotion(this);
  4469.  
  4470. if (GetWarMap())
  4471. GetWarMap()->UsePotion(this, item);
  4472.  
  4473. item->SetCount(item->GetCount() - 1);
  4474. break;
  4475.  
  4476. case USE_TALISMAN:
  4477. {
  4478. const int TOWN_PORTAL = 1;
  4479. const int MEMORY_PORTAL = 2;
  4480.  
  4481.  
  4482.  
  4483. if (GetMapIndex() == 200 || GetMapIndex() == 113)
  4484. {
  4485. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÇöŔç Ŕ§ÄˇżˇĽ­ »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  4486. return false;
  4487. }
  4488.  
  4489. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  4490. {
  4491. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  4492. return false;
  4493. }
  4494. #ifdef ENABLE_NEWSTUFF
  4495. else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  4496. {
  4497. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ă Áßżˇ´Â ŔĚżëÇŇ Ľö ľř´Â ą°Ç°ŔÔ´Ď´Ů."));
  4498. return false;
  4499. }
  4500. #endif
  4501.  
  4502. if (m_pkWarpEvent)
  4503. {
  4504. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ŕ̵żÇŇ ÁŘşń°ˇ µÇľîŔÖŔ˝Ŕ¸·Î ±ÍČŻşÎ¸¦ »çżëÇŇĽö ľř˝Ŕ´Ď´Ů"));
  4505. return false;
  4506. }
  4507.  
  4508. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4509. int consumeLife = CalculateConsume(this);
  4510.  
  4511. if (consumeLife < 0)
  4512. return false;
  4513. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4514.  
  4515. if (item->GetValue(0) == TOWN_PORTAL)
  4516. {
  4517. if (item->GetSocket(0) == 0)
  4518. {
  4519. if (!GetDungeon())
  4520. if (!GiveRecallItem(item))
  4521. return false;
  4522.  
  4523. PIXEL_POSITION posWarp;
  4524.  
  4525. if (SECTREE_MANAGER::instance().GetRecallPositionByEmpire(GetMapIndex(), GetEmpire(), posWarp))
  4526. {
  4527. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4528. PointChange(POINT_HP, -consumeLife, false);
  4529. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4530.  
  4531. WarpSet(posWarp.x, posWarp.y);
  4532. }
  4533. else
  4534. {
  4535. sys_err("CHARACTER::UseItem : cannot find spawn position (name %s, %d x %d)", GetName(), GetX(), GetY());
  4536. }
  4537. }
  4538. else
  4539. {
  4540. if (test_server)
  4541. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("żř·ˇ Ŕ§Äˇ·Î şą±Í"));
  4542.  
  4543. ProcessRecallItem(item);
  4544. }
  4545. }
  4546. else if (item->GetValue(0) == MEMORY_PORTAL)
  4547. {
  4548. if (item->GetSocket(0) == 0)
  4549. {
  4550. if (GetDungeon())
  4551. {
  4552. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´řŔü ľČżˇĽ­´Â %s%s »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."),
  4553. item->GetName(),
  4554. "");
  4555. return false;
  4556. }
  4557.  
  4558. if (!GiveRecallItem(item))
  4559. return false;
  4560. }
  4561. else
  4562. {
  4563. // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4564. PointChange(POINT_HP, -consumeLife, false);
  4565. // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  4566.  
  4567. ProcessRecallItem(item);
  4568. }
  4569. }
  4570. }
  4571. break;
  4572.  
  4573. case USE_TUNING:
  4574. case USE_DETACHMENT:
  4575. {
  4576. LPITEM item2;
  4577.  
  4578. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  4579. return false;
  4580.  
  4581. if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  4582. return false;
  4583.  
  4584. if (item2->GetVnum() >= 28330 && item2->GetVnum() <= 28343)
  4585. {
  4586. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("+3 żµĽ®Ŕş ŔĚ ľĆŔĚĹŰŔ¸·Î °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů"));
  4587. return false;
  4588. }
  4589. #ifdef ENABLE_ACCE_SYSTEM
  4590. if (item->GetValue(0) == ACCE_CLEAN_ATTR_VALUE0)
  4591. {
  4592. if (!CleanAcceAttr(item, item2))
  4593. return false;
  4594.  
  4595. return true;
  4596. }
  4597. #endif
  4598. if (item2->GetVnum() >= 28430 && item2->GetVnum() <= 28443)
  4599. {
  4600. if (item->GetVnum() == 71056)
  4601. {
  4602. RefineItem(item, item2);
  4603. }
  4604. else
  4605. {
  4606. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("żµĽ®Ŕş ŔĚ ľĆŔĚĹŰŔ¸·Î °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů"));
  4607. }
  4608. }
  4609. else
  4610. {
  4611. RefineItem(item, item2);
  4612. }
  4613. }
  4614. break;
  4615.  
  4616. case USE_CHANGE_COSTUME_ATTR:
  4617. case USE_RESET_COSTUME_ATTR:
  4618. {
  4619. LPITEM item2;
  4620. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  4621. return false;
  4622.  
  4623. if (item2->IsEquipped())
  4624. {
  4625. BuffOnAttr_RemoveBuffsFromItem(item2);
  4626. }
  4627.  
  4628. if (ITEM_COSTUME != item2->GetType())
  4629. {
  4630. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  4631. return false;
  4632. }
  4633.  
  4634. if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  4635. return false;
  4636.  
  4637. if (item2->GetAttributeSetIndex() == -1)
  4638. {
  4639. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  4640. return false;
  4641. }
  4642.  
  4643. if (item2->GetAttributeCount() == 0)
  4644. {
  4645. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şŻ°ćÇŇ ĽÓĽşŔĚ ľř˝Ŕ´Ď´Ů."));
  4646. return false;
  4647. }
  4648.  
  4649. switch (item->GetSubType())
  4650. {
  4651. case USE_CHANGE_COSTUME_ATTR:
  4652. item2->ChangeAttribute();
  4653. {
  4654. char buf[21];
  4655. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4656. LogManager::instance().ItemLog(this, item, "CHANGE_COSTUME_ATTR", buf);
  4657. }
  4658. break;
  4659. case USE_RESET_COSTUME_ATTR:
  4660. item2->ClearAttribute();
  4661. item2->AlterToMagicItem();
  4662. {
  4663. char buf[21];
  4664. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4665. LogManager::instance().ItemLog(this, item, "RESET_COSTUME_ATTR", buf);
  4666. }
  4667. break;
  4668. }
  4669.  
  4670. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇĎż´˝Ŕ´Ď´Ů."));
  4671.  
  4672. item->SetCount(item->GetCount() - 1);
  4673. break;
  4674. }
  4675.  
  4676. // ACCESSORY_REFINE & ADD/CHANGE_ATTRIBUTES
  4677. case USE_PUT_INTO_BELT_SOCKET:
  4678. case USE_PUT_INTO_RING_SOCKET:
  4679. case USE_PUT_INTO_ACCESSORY_SOCKET:
  4680. case USE_ADD_ACCESSORY_SOCKET:
  4681. case USE_CLEAN_SOCKET:
  4682. case USE_CHANGE_ATTRIBUTE:
  4683. case USE_CHANGE_ATTRIBUTE2 :
  4684. case USE_ADD_ATTRIBUTE:
  4685. case USE_ADD_ATTRIBUTE2:
  4686. {
  4687. LPITEM item2;
  4688. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  4689. return false;
  4690.  
  4691. if (item2->IsEquipped())
  4692. {
  4693. BuffOnAttr_RemoveBuffsFromItem(item2);
  4694. }
  4695.  
  4696.  
  4697.  
  4698.  
  4699. if (ITEM_COSTUME == item2->GetType())
  4700. {
  4701. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  4702. return false;
  4703. }
  4704.  
  4705. if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  4706. return false;
  4707.  
  4708. switch (item->GetSubType())
  4709. {
  4710. case USE_CLEAN_SOCKET:
  4711. {
  4712. int i;
  4713. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  4714. {
  4715. if (item2->GetSocket(i) == ITEM_BROKEN_METIN_VNUM)
  4716. break;
  4717. }
  4718.  
  4719. if (i == ITEM_SOCKET_MAX_NUM)
  4720. {
  4721. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ă»ĽŇÇŇ Ľ®ŔĚ ąÚÇôŔÖÁö ľĘ˝Ŕ´Ď´Ů."));
  4722. return false;
  4723. }
  4724.  
  4725. int j = 0;
  4726.  
  4727. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  4728. {
  4729. if (item2->GetSocket(i) != ITEM_BROKEN_METIN_VNUM && item2->GetSocket(i) != 0)
  4730. item2->SetSocket(j++, item2->GetSocket(i));
  4731. }
  4732.  
  4733. for (; j < ITEM_SOCKET_MAX_NUM; ++j)
  4734. {
  4735. if (item2->GetSocket(j) > 0)
  4736. item2->SetSocket(j, 1);
  4737. }
  4738.  
  4739. {
  4740. char buf[21];
  4741. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4742. LogManager::instance().ItemLog(this, item, "CLEAN_SOCKET", buf);
  4743. }
  4744.  
  4745. item->SetCount(item->GetCount() - 1);
  4746.  
  4747. }
  4748. break;
  4749.  
  4750. case USE_CHANGE_ATTRIBUTE :
  4751. case USE_CHANGE_ATTRIBUTE2 : // @fixme123
  4752. if (item2->GetAttributeSetIndex() == -1)
  4753. {
  4754. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  4755. return false;
  4756. }
  4757.  
  4758. if (item2->GetAttributeCount() == 0)
  4759. {
  4760. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şŻ°ćÇŇ ĽÓĽşŔĚ ľř˝Ŕ´Ď´Ů."));
  4761. return false;
  4762. }
  4763.  
  4764. if ((GM_PLAYER == GetGMLevel()) && (false == test_server) && (g_dwItemBonusChangeTime > 0))
  4765. {
  4766. //
  4767.  
  4768.  
  4769. //
  4770.  
  4771. // DWORD dwChangeItemAttrCycle = quest::CQuestManager::instance().GetEventFlag(msc_szChangeItemAttrCycleFlag);
  4772. // if (dwChangeItemAttrCycle < msc_dwDefaultChangeItemAttrCycle)
  4773. // dwChangeItemAttrCycle = msc_dwDefaultChangeItemAttrCycle;
  4774. DWORD dwChangeItemAttrCycle = g_dwItemBonusChangeTime;
  4775.  
  4776. quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetPlayerID());
  4777.  
  4778. if (pPC)
  4779. {
  4780. DWORD dwNowSec = get_global_time();
  4781.  
  4782. DWORD dwLastChangeItemAttrSec = pPC->GetFlag(msc_szLastChangeItemAttrFlag);
  4783.  
  4784. if (dwLastChangeItemAttrSec + dwChangeItemAttrCycle > dwNowSec)
  4785. {
  4786. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» ąŮ˛ŰÁö %dşĐ ŔĚł»żˇ´Â ´Ů˝Ă şŻ°ćÇŇ Ľö ľř˝Ŕ´Ď´Ů.(%d şĐ ł˛Ŕ˝)"),
  4787. dwChangeItemAttrCycle, dwChangeItemAttrCycle - (dwNowSec - dwLastChangeItemAttrSec));
  4788. return false;
  4789. }
  4790.  
  4791. pPC->SetFlag(msc_szLastChangeItemAttrFlag, dwNowSec);
  4792. }
  4793. }
  4794.  
  4795. if (item->GetSubType() == USE_CHANGE_ATTRIBUTE2)
  4796. {
  4797. int aiChangeProb[ITEM_ATTRIBUTE_MAX_LEVEL] =
  4798. {
  4799. 0, 0, 30, 40, 3
  4800. };
  4801.  
  4802. item2->ChangeAttribute(aiChangeProb);
  4803. }
  4804. else if (item->GetVnum() == 76014)
  4805. {
  4806. int aiChangeProb[ITEM_ATTRIBUTE_MAX_LEVEL] =
  4807. {
  4808. 0, 10, 50, 39, 1
  4809. };
  4810.  
  4811. item2->ChangeAttribute(aiChangeProb);
  4812. }
  4813.  
  4814. else
  4815. {
  4816.  
  4817.  
  4818. if (item->GetVnum() == 71151 || item->GetVnum() == 76023)
  4819. {
  4820. if ((item2->GetType() == ITEM_WEAPON)
  4821. || (item2->GetType() == ITEM_ARMOR && item2->GetSubType() == ARMOR_BODY))
  4822. {
  4823. bool bCanUse = true;
  4824. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  4825. {
  4826. if (item2->GetLimitType(i) == LIMIT_LEVEL && item2->GetLimitValue(i) > 40)
  4827. {
  4828. bCanUse = false;
  4829. break;
  4830. }
  4831. }
  4832. if (false == bCanUse)
  4833. {
  4834. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ŕűżë ·ąş§ş¸´Ů łôľĆ »çżëŔĚ şŇ°ˇ´ÉÇŐ´Ď´Ů."));
  4835. break;
  4836. }
  4837. }
  4838. else
  4839. {
  4840. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ą«±âżÍ °©żĘżˇ¸¸ »çżë °ˇ´ÉÇŐ´Ď´Ů."));
  4841. break;
  4842. }
  4843. }
  4844. item2->ChangeAttribute();
  4845. }
  4846.  
  4847. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇĎż´˝Ŕ´Ď´Ů."));
  4848. {
  4849. char buf[21];
  4850. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4851. LogManager::instance().ItemLog(this, item, "CHANGE_ATTRIBUTE", buf);
  4852. }
  4853.  
  4854. item->SetCount(item->GetCount() - 1);
  4855. break;
  4856.  
  4857. case USE_ADD_ATTRIBUTE :
  4858. if (item2->GetAttributeSetIndex() == -1)
  4859. {
  4860. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  4861. return false;
  4862. }
  4863.  
  4864. if (item2->GetAttributeCount() < 4)
  4865. {
  4866.  
  4867.  
  4868. if (item->GetVnum() == 71152 || item->GetVnum() == 76024)
  4869. {
  4870. if ((item2->GetType() == ITEM_WEAPON)
  4871. || (item2->GetType() == ITEM_ARMOR && item2->GetSubType() == ARMOR_BODY))
  4872. {
  4873. bool bCanUse = true;
  4874. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  4875. {
  4876. if (item2->GetLimitType(i) == LIMIT_LEVEL && item2->GetLimitValue(i) > 40)
  4877. {
  4878. bCanUse = false;
  4879. break;
  4880. }
  4881. }
  4882. if (false == bCanUse)
  4883. {
  4884. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ŕűżë ·ąş§ş¸´Ů łôľĆ »çżëŔĚ şŇ°ˇ´ÉÇŐ´Ď´Ů."));
  4885. break;
  4886. }
  4887. }
  4888. else
  4889. {
  4890. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ą«±âżÍ °©żĘżˇ¸¸ »çżë °ˇ´ÉÇŐ´Ď´Ů."));
  4891. break;
  4892. }
  4893. }
  4894. char buf[21];
  4895. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4896.  
  4897. if (number(1, 100) <= aiItemAttributeAddPercent[item2->GetAttributeCount()])
  4898. {
  4899. item2->AddAttribute();
  4900. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽş Ăß°ˇżˇ Ľş°řÇĎż´˝Ŕ´Ď´Ů."));
  4901.  
  4902. int iAddedIdx = item2->GetAttributeCount() - 1;
  4903. LogManager::instance().ItemLog(
  4904. GetPlayerID(),
  4905. item2->GetAttributeType(iAddedIdx),
  4906. item2->GetAttributeValue(iAddedIdx),
  4907. item->GetID(),
  4908. "ADD_ATTRIBUTE_SUCCESS",
  4909. buf,
  4910. GetDesc()->GetHostName(),
  4911. item->GetOriginalVnum());
  4912. }
  4913. else
  4914. {
  4915. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽş Ăß°ˇżˇ ˝ÇĆĐÇĎż´˝Ŕ´Ď´Ů."));
  4916. LogManager::instance().ItemLog(this, item, "ADD_ATTRIBUTE_FAIL", buf);
  4917. }
  4918.  
  4919. item->SetCount(item->GetCount() - 1);
  4920. }
  4921. else
  4922. {
  4923. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´őŔĚ»ó ŔĚ ľĆŔĚĹŰŔ» ŔĚżëÇĎż© ĽÓĽşŔ» Ăß°ˇÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  4924. }
  4925. break;
  4926.  
  4927. case USE_ADD_ATTRIBUTE2 :
  4928.  
  4929.  
  4930. if (item2->GetAttributeSetIndex() == -1)
  4931. {
  4932. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽşŔ» şŻ°ćÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  4933. return false;
  4934. }
  4935.  
  4936.  
  4937. if (item2->GetAttributeCount() == 4)
  4938. {
  4939. char buf[21];
  4940. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4941.  
  4942. if (number(1, 100) <= aiItemAttributeAddPercent[item2->GetAttributeCount()])
  4943. {
  4944. item2->AddAttribute();
  4945. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽş Ăß°ˇżˇ Ľş°řÇĎż´˝Ŕ´Ď´Ů."));
  4946.  
  4947. int iAddedIdx = item2->GetAttributeCount() - 1;
  4948. LogManager::instance().ItemLog(
  4949. GetPlayerID(),
  4950. item2->GetAttributeType(iAddedIdx),
  4951. item2->GetAttributeValue(iAddedIdx),
  4952. item->GetID(),
  4953. "ADD_ATTRIBUTE2_SUCCESS",
  4954. buf,
  4955. GetDesc()->GetHostName(),
  4956. item->GetOriginalVnum());
  4957. }
  4958. else
  4959. {
  4960. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽÓĽş Ăß°ˇżˇ ˝ÇĆĐÇĎż´˝Ŕ´Ď´Ů."));
  4961. LogManager::instance().ItemLog(this, item, "ADD_ATTRIBUTE2_FAIL", buf);
  4962. }
  4963.  
  4964. item->SetCount(item->GetCount() - 1);
  4965. }
  4966. else if (item2->GetAttributeCount() == 5)
  4967. {
  4968. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ő ŔĚ»ó ŔĚ ľĆŔĚĹŰŔ» ŔĚżëÇĎż© ĽÓĽşŔ» Ăß°ˇÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  4969. }
  4970. else if (item2->GetAttributeCount() < 4)
  4971. {
  4972. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸ŐŔú Ŕç°ˇşńĽ­¸¦ ŔĚżëÇĎż© ĽÓĽşŔ» Ăß°ˇ˝ĂÄŃ ÁÖĽĽżä."));
  4973. }
  4974. else
  4975. {
  4976. // wtf ?!
  4977. sys_err("ADD_ATTRIBUTE2 : Item has wrong AttributeCount(%d)", item2->GetAttributeCount());
  4978. }
  4979. break;
  4980.  
  4981. case USE_ADD_ACCESSORY_SOCKET:
  4982. {
  4983. char buf[21];
  4984. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4985.  
  4986. if (item2->IsAccessoryForSocket())
  4987. {
  4988. if (item2->GetAccessorySocketMaxGrade() < ITEM_ACCESSORY_SOCKET_MAX_NUM)
  4989. {
  4990. #ifdef ENABLE_ADDSTONE_FAILURE
  4991. if (number(1, 100) <= 50)
  4992. #else
  4993. if (1)
  4994. #endif
  4995. {
  4996. item2->SetAccessorySocketMaxGrade(item2->GetAccessorySocketMaxGrade() + 1);
  4997. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽŇÄĎŔĚ Ľş°řŔűŔ¸·Î Ăß°ˇµÇľú˝Ŕ´Ď´Ů."));
  4998. LogManager::instance().ItemLog(this, item, "ADD_SOCKET_SUCCESS", buf);
  4999. }
  5000. else
  5001. {
  5002. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽŇÄĎ Ăß°ˇżˇ ˝ÇĆĐÇĎż´˝Ŕ´Ď´Ů."));
  5003. LogManager::instance().ItemLog(this, item, "ADD_SOCKET_FAIL", buf);
  5004. }
  5005.  
  5006. item->SetCount(item->GetCount() - 1);
  5007. }
  5008. else
  5009. {
  5010. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľ×ĽĽĽ­¸®żˇ´Â ´őŔĚ»ó ĽŇÄĎŔ» Ăß°ˇÇŇ °ř°ŁŔĚ ľř˝Ŕ´Ď´Ů."));
  5011. }
  5012. }
  5013. else
  5014. {
  5015. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔ¸·Î ĽŇÄĎŔ» Ăß°ˇÇŇ Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  5016. }
  5017. }
  5018. break;
  5019.  
  5020. case USE_PUT_INTO_BELT_SOCKET:
  5021. case USE_PUT_INTO_ACCESSORY_SOCKET:
  5022. if (item2->IsAccessoryForSocket() && item->CanPutInto(item2))
  5023. {
  5024. char buf[21];
  5025. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5026.  
  5027. if (item2->GetAccessorySocketGrade() < item2->GetAccessorySocketMaxGrade())
  5028. {
  5029. if (number(1, 100) <= aiAccessorySocketPutPct[item2->GetAccessorySocketGrade()])
  5030. {
  5031. item2->SetAccessorySocketGrade(item2->GetAccessorySocketGrade() + 1);
  5032. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĺÂřżˇ Ľş°řÇĎż´˝Ŕ´Ď´Ů."));
  5033. LogManager::instance().ItemLog(this, item, "PUT_SOCKET_SUCCESS", buf);
  5034. }
  5035. else
  5036. {
  5037. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĺÂřżˇ ˝ÇĆĐÇĎż´˝Ŕ´Ď´Ů."));
  5038. LogManager::instance().ItemLog(this, item, "PUT_SOCKET_FAIL", buf);
  5039. }
  5040.  
  5041. item->SetCount(item->GetCount() - 1);
  5042. }
  5043. else
  5044. {
  5045. if (item2->GetAccessorySocketMaxGrade() == 0)
  5046. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸ŐŔú ´ŮŔ̾Ƹóµĺ·Î ľÇĽĽĽ­¸®żˇ ĽŇÄĎŔ» Ăß°ˇÇŘľßÇŐ´Ď´Ů."));
  5047. else if (item2->GetAccessorySocketMaxGrade() < ITEM_ACCESSORY_SOCKET_MAX_NUM)
  5048. {
  5049. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľ×ĽĽĽ­¸®żˇ´Â ´őŔĚ»ó ŔĺÂřÇŇ ĽŇÄĎŔĚ ľř˝Ŕ´Ď´Ů."));
  5050. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ŮŔ̾Ƹóµĺ·Î ĽŇÄĎŔ» Ăß°ˇÇŘľßÇŐ´Ď´Ů."));
  5051. }
  5052. else
  5053. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľ×ĽĽĽ­¸®żˇ´Â ´őŔĚ»ó ş¸Ľ®Ŕ» ŔĺÂřÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  5054. }
  5055. }
  5056. else
  5057. {
  5058. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔ» ŔĺÂřÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  5059. }
  5060. break;
  5061. }
  5062. if (item2->IsEquipped())
  5063. {
  5064. BuffOnAttr_AddBuffsFromItem(item2);
  5065. }
  5066. }
  5067. break;
  5068. // END_OF_ACCESSORY_REFINE & END_OF_ADD_ATTRIBUTES & END_OF_CHANGE_ATTRIBUTES
  5069.  
  5070. case USE_BAIT:
  5071. {
  5072.  
  5073. if (m_pkFishingEvent)
  5074. {
  5075. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ł¬˝Ă Áßżˇ ąĚł˘¸¦ °ĄľĆł˘żď Ľö ľř˝Ŕ´Ď´Ů."));
  5076. return false;
  5077. }
  5078.  
  5079. LPITEM weapon = GetWear(WEAR_WEAPON);
  5080.  
  5081. if (!weapon || weapon->GetType() != ITEM_ROD)
  5082. return false;
  5083.  
  5084. if (weapon->GetSocket(2))
  5085. {
  5086. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ ˛ČÇôŔÖ´ř ąĚł˘¸¦ »©°í %s¸¦ ł˘żó´Ď´Ů."), item->GetName());
  5087. }
  5088. else
  5089. {
  5090. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ł¬˝Ă´ëżˇ %s¸¦ ąĚł˘·Î ł˘żó´Ď´Ů."), item->GetName());
  5091. }
  5092.  
  5093. weapon->SetSocket(2, item->GetValue(0));
  5094. item->SetCount(item->GetCount() - 1);
  5095. }
  5096. break;
  5097.  
  5098. case USE_MOVE:
  5099. case USE_TREASURE_BOX:
  5100. case USE_MONEYBAG:
  5101. break;
  5102.  
  5103. case USE_AFFECT :
  5104. {
  5105. if (FindAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType))
  5106. {
  5107. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ Čż°ú°ˇ °É·Á ŔÖ˝Ŕ´Ď´Ů."));
  5108. }
  5109. else
  5110. {
  5111. // PC_BANG_ITEM_ADD
  5112. if (item->IsPCBangItem() == true)
  5113. {
  5114.  
  5115. if (CPCBangManager::instance().IsPCBangIP(GetDesc()->GetHostName()) == false)
  5116. {
  5117.  
  5118. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔş PCąćżˇĽ­¸¸ »çżëÇŇ Ľö ŔÖ˝Ŕ´Ď´Ů."));
  5119. return false;
  5120. }
  5121. }
  5122. // END_PC_BANG_ITEM_ADD
  5123.  
  5124. AddAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType, item->GetValue(2), 0, item->GetValue(3), 0, false);
  5125. item->SetCount(item->GetCount() - 1);
  5126. }
  5127. }
  5128. break;
  5129.  
  5130. case USE_CREATE_STONE:
  5131. AutoGiveItem(number(28000, 28013));
  5132. item->SetCount(item->GetCount() - 1);
  5133. break;
  5134.  
  5135.  
  5136. case USE_RECIPE :
  5137. {
  5138. LPITEM pSource1 = FindSpecifyItem(item->GetValue(1));
  5139. DWORD dwSourceCount1 = item->GetValue(2);
  5140.  
  5141. LPITEM pSource2 = FindSpecifyItem(item->GetValue(3));
  5142. DWORD dwSourceCount2 = item->GetValue(4);
  5143.  
  5144. if (dwSourceCount1 != 0)
  5145. {
  5146. if (pSource1 == NULL)
  5147. {
  5148. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ą°ľŕ Á¶ÇŐŔ» Ŕ§ÇŃ Ŕç·á°ˇ şÎÁ·ÇŐ´Ď´Ů."));
  5149. return false;
  5150. }
  5151. }
  5152.  
  5153. if (dwSourceCount2 != 0)
  5154. {
  5155. if (pSource2 == NULL)
  5156. {
  5157. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ą°ľŕ Á¶ÇŐŔ» Ŕ§ÇŃ Ŕç·á°ˇ şÎÁ·ÇŐ´Ď´Ů."));
  5158. return false;
  5159. }
  5160. }
  5161.  
  5162. if (pSource1 != NULL)
  5163. {
  5164. if (pSource1->GetCount() < dwSourceCount1)
  5165. {
  5166. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ŕç·á(%s)°ˇ şÎÁ·ÇŐ´Ď´Ů."), pSource1->GetName());
  5167. return false;
  5168. }
  5169.  
  5170. pSource1->SetCount(pSource1->GetCount() - dwSourceCount1);
  5171. }
  5172.  
  5173. if (pSource2 != NULL)
  5174. {
  5175. if (pSource2->GetCount() < dwSourceCount2)
  5176. {
  5177. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ŕç·á(%s)°ˇ şÎÁ·ÇŐ´Ď´Ů."), pSource2->GetName());
  5178. return false;
  5179. }
  5180.  
  5181. pSource2->SetCount(pSource2->GetCount() - dwSourceCount2);
  5182. }
  5183.  
  5184. LPITEM pBottle = FindSpecifyItem(50901);
  5185.  
  5186. if (!pBottle || pBottle->GetCount() < 1)
  5187. {
  5188. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şó ş´ŔĚ ¸đŔÚ¸¨´Ď´Ů."));
  5189. return false;
  5190. }
  5191.  
  5192. pBottle->SetCount(pBottle->GetCount() - 1);
  5193.  
  5194. if (number(1, 100) > item->GetValue(5))
  5195. {
  5196. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ą°ľŕ Á¦Á¶żˇ ˝ÇĆĐÇß˝Ŕ´Ď´Ů."));
  5197. return false;
  5198. }
  5199.  
  5200. AutoGiveItem(item->GetValue(0));
  5201. }
  5202. break;
  5203. }
  5204. }
  5205. break;
  5206.  
  5207. case ITEM_METIN:
  5208. {
  5209. LPITEM item2;
  5210.  
  5211. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  5212. return false;
  5213.  
  5214. if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  5215. return false;
  5216.  
  5217. if (item2->GetType() == ITEM_PICK) return false;
  5218. if (item2->GetType() == ITEM_ROD) return false;
  5219.  
  5220. int i;
  5221.  
  5222. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  5223. {
  5224. DWORD dwVnum;
  5225.  
  5226. if ((dwVnum = item2->GetSocket(i)) <= 2)
  5227. continue;
  5228.  
  5229. TItemTable * p = ITEM_MANAGER::instance().GetTable(dwVnum);
  5230.  
  5231. if (!p)
  5232. continue;
  5233.  
  5234. if (item->GetValue(5) == p->alValues[5])
  5235. {
  5236. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°°Ŕş Áľ·ůŔÇ ¸ŢĆľĽ®Ŕş ż©·Ż°ł şÎÂřÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  5237. return false;
  5238. }
  5239. }
  5240.  
  5241. if (item2->GetType() == ITEM_ARMOR)
  5242. {
  5243. if (!IS_SET(item->GetWearFlag(), WEARABLE_BODY) || !IS_SET(item2->GetWearFlag(), WEARABLE_BODY))
  5244. {
  5245. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ¸ŢĆľĽ®Ŕş Ŕĺşńżˇ şÎÂřÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  5246. return false;
  5247. }
  5248. }
  5249. else if (item2->GetType() == ITEM_WEAPON)
  5250. {
  5251. if (!IS_SET(item->GetWearFlag(), WEARABLE_WEAPON))
  5252. {
  5253. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ¸ŢĆľĽ®Ŕş ą«±âżˇ şÎÂřÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  5254. return false;
  5255. }
  5256. }
  5257. else
  5258. {
  5259. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şÎÂřÇŇ Ľö ŔÖ´Â ˝˝·ÔŔĚ ľř˝Ŕ´Ď´Ů."));
  5260. return false;
  5261. }
  5262.  
  5263. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  5264. if (item2->GetSocket(i) >= 1 && item2->GetSocket(i) <= 2 && item2->GetSocket(i) >= item->GetValue(2))
  5265. {
  5266.  
  5267. #ifdef ENABLE_ADDSTONE_FAILURE
  5268. if (number(1, 100) <= 30)
  5269. #else
  5270. if (1)
  5271. #endif
  5272. {
  5273. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸ŢĆľĽ® şÎÂřżˇ Ľş°řÇĎż´˝Ŕ´Ď´Ů."));
  5274. item2->SetSocket(i, item->GetVnum());
  5275. }
  5276. else
  5277. {
  5278. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸ŢĆľĽ® şÎÂřżˇ ˝ÇĆĐÇĎż´˝Ŕ´Ď´Ů."));
  5279. item2->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
  5280. }
  5281.  
  5282. LogManager::instance().ItemLog(this, item2, "SOCKET", item->GetName());
  5283. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (METIN)");
  5284. break;
  5285. }
  5286.  
  5287. if (i == ITEM_SOCKET_MAX_NUM)
  5288. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("şÎÂřÇŇ Ľö ŔÖ´Â ˝˝·ÔŔĚ ľř˝Ŕ´Ď´Ů."));
  5289. }
  5290. break;
  5291.  
  5292. case ITEM_AUTOUSE:
  5293. case ITEM_MATERIAL:
  5294. case ITEM_SPECIAL:
  5295. case ITEM_TOOL:
  5296. case ITEM_LOTTERY:
  5297. break;
  5298.  
  5299. case ITEM_TOTEM:
  5300. {
  5301. if (!item->IsEquipped())
  5302. EquipItem(item);
  5303. }
  5304. break;
  5305.  
  5306. case ITEM_BLEND:
  5307.  
  5308. sys_log(0,"ITEM_BLEND!!");
  5309. if (Blend_Item_find(item->GetVnum()))
  5310. {
  5311. int affect_type = AFFECT_BLEND;
  5312. int apply_type = aApplyInfo[item->GetSocket(0)].bPointType;
  5313. int apply_value = item->GetSocket(1);
  5314. int apply_duration = item->GetSocket(2);
  5315.  
  5316. if (FindAffect(affect_type, apply_type))
  5317. {
  5318. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ Čż°ú°ˇ °É·Á ŔÖ˝Ŕ´Ď´Ů."));
  5319. }
  5320. else
  5321. {
  5322. if (FindAffect(AFFECT_EXP_BONUS_EURO_FREE, POINT_RESIST_MAGIC))
  5323. {
  5324. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ Čż°ú°ˇ °É·Á ŔÖ˝Ŕ´Ď´Ů."));
  5325. }
  5326. else
  5327. {
  5328. AddAffect(affect_type, apply_type, apply_value, 0, apply_duration, 0, false);
  5329. item->SetCount(item->GetCount() - 1);
  5330. }
  5331. }
  5332. }
  5333. break;
  5334. case ITEM_EXTRACT:
  5335. {
  5336. LPITEM pDestItem = GetItem(DestCell);
  5337. if (NULL == pDestItem)
  5338. {
  5339. return false;
  5340. }
  5341. switch (item->GetSubType())
  5342. {
  5343. case EXTRACT_DRAGON_SOUL:
  5344. if (pDestItem->IsDragonSoul())
  5345. {
  5346. return DSManager::instance().PullOut(this, NPOS, pDestItem, item);
  5347. }
  5348. return false;
  5349. case EXTRACT_DRAGON_HEART:
  5350. if (pDestItem->IsDragonSoul())
  5351. {
  5352. return DSManager::instance().ExtractDragonHeart(this, pDestItem, item);
  5353. }
  5354. return false;
  5355. default:
  5356. return false;
  5357. }
  5358. }
  5359. break;
  5360.  
  5361. case ITEM_NONE:
  5362. sys_err("Item type NONE %s", item->GetName());
  5363. break;
  5364.  
  5365. default:
  5366. sys_log(0, "UseItemEx: Unknown type %s %d", item->GetName(), item->GetType());
  5367. return false;
  5368. }
  5369.  
  5370. return true;
  5371. }
  5372.  
  5373. int g_nPortalLimitTime = 10;
  5374.  
  5375. bool CHARACTER::UseItem(TItemPos Cell, TItemPos DestCell)
  5376. {
  5377. WORD wCell = Cell.cell;
  5378. BYTE window_type = Cell.window_type;
  5379. //WORD wDestCell = DestCell.cell;
  5380. //BYTE bDestInven = DestCell.window_type;
  5381. LPITEM item;
  5382.  
  5383. if (!CanHandleItem())
  5384. return false;
  5385.  
  5386. if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
  5387. return false;
  5388.  
  5389. sys_log(0, "%s: USE_ITEM %s (inven %d, cell: %d)", GetName(), item->GetName(), window_type, wCell);
  5390.  
  5391. if (item->IsExchanging())
  5392. return false;
  5393.  
  5394. if (!item->CanUsedBy(this))
  5395. {
  5396. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±şÁ÷ŔĚ ¸ÂÁöľĘľĆ ŔĚ ľĆŔĚĹŰŔ» »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  5397. return false;
  5398. }
  5399.  
  5400. if (IsStun())
  5401. return false;
  5402.  
  5403. if (false == FN_check_item_sex(this, item))
  5404. {
  5405. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ľşş°ŔĚ ¸ÂÁöľĘľĆ ŔĚ ľĆŔĚĹŰŔ» »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  5406. return false;
  5407. }
  5408.  
  5409. //PREVENT_TRADE_WINDOW
  5410. if (IS_SUMMON_ITEM(item->GetVnum()))
  5411. {
  5412. if (false == IS_SUMMONABLE_ZONE(GetMapIndex()))
  5413. {
  5414. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»çżëÇŇĽö ľř˝Ŕ´Ď´Ů."));
  5415. return false;
  5416. }
  5417.  
  5418.  
  5419.  
  5420.  
  5421. if (CThreeWayWar::instance().IsThreeWayWarMapIndex(GetMapIndex()))
  5422. {
  5423. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»ď°Ĺ¸® ŔüĹő Âü°ˇÁßżˇ´Â ±ÍČŻşÎ,±ÍČŻ±âľďşÎ¸¦ »çżëÇŇĽö ľř˝Ŕ´Ď´Ů."));
  5424. return false;
  5425. }
  5426. int iPulse = thecore_pulse();
  5427.  
  5428.  
  5429. if (iPulse - GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  5430. {
  5431. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("â°í¸¦ ż¬ČÄ %dĂĘ ŔĚł»żˇ´Â ±ÍČŻşÎ,±ÍČŻ±âľďşÎ¸¦ »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."), g_nPortalLimitTime);
  5432.  
  5433. if (test_server)
  5434. ChatPacket(CHAT_TYPE_INFO, "[TestOnly]Pulse %d LoadTime %d PASS %d", iPulse, GetSafeboxLoadTime(), PASSES_PER_SEC(g_nPortalLimitTime));
  5435. return false;
  5436. }
  5437.  
  5438.  
  5439. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen())
  5440. {
  5441. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°Ĺ·ˇĂ˘,â°í µîŔ» ż¬ »óĹÂżˇĽ­´Â ±ÍČŻşÎ,±ÍČŻ±âľďşÎ ¸¦ »çżëÇŇĽö ľř˝Ŕ´Ď´Ů."));
  5442. return false;
  5443. }
  5444.  
  5445. //PREVENT_REFINE_HACK
  5446.  
  5447. {
  5448. if (iPulse - GetRefineTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  5449. {
  5450. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆŔĚĹŰ °ł·®ČÄ %dĂĘ ŔĚł»żˇ´Â ±ÍČŻşÎ,±ÍČŻ±âľďşÎ¸¦ »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."), g_nPortalLimitTime);
  5451. return false;
  5452. }
  5453. }
  5454. //END_PREVENT_REFINE_HACK
  5455.  
  5456.  
  5457. //PREVENT_ITEM_COPY
  5458. {
  5459. if (iPulse - GetMyShopTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  5460. {
  5461. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°łŔλóÁˇ »çżëČÄ %dĂĘ ŔĚł»żˇ´Â ±ÍČŻşÎ,±ÍČŻ±âľďşÎ¸¦ »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."), g_nPortalLimitTime);
  5462. return false;
  5463. }
  5464.  
  5465. }
  5466. //END_PREVENT_ITEM_COPY
  5467.  
  5468.  
  5469.  
  5470. if (item->GetVnum() != 70302)
  5471. {
  5472. PIXEL_POSITION posWarp;
  5473.  
  5474. int x = 0;
  5475. int y = 0;
  5476.  
  5477. double nDist = 0;
  5478. const double nDistant = 5000.0;
  5479.  
  5480. if (item->GetVnum() == 22010)
  5481. {
  5482. x = item->GetSocket(0) - GetX();
  5483. y = item->GetSocket(1) - GetY();
  5484. }
  5485.  
  5486. else if (item->GetVnum() == 22000)
  5487. {
  5488. SECTREE_MANAGER::instance().GetRecallPositionByEmpire(GetMapIndex(), GetEmpire(), posWarp);
  5489.  
  5490. if (item->GetSocket(0) == 0)
  5491. {
  5492. x = posWarp.x - GetX();
  5493. y = posWarp.y - GetY();
  5494. }
  5495. else
  5496. {
  5497. x = item->GetSocket(0) - GetX();
  5498. y = item->GetSocket(1) - GetY();
  5499. }
  5500. }
  5501.  
  5502. nDist = sqrt(pow((float)x,2) + pow((float)y,2));
  5503.  
  5504. if (nDistant > nDist)
  5505. {
  5506. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ŕ̵ż µÇľîÁú Ŕ§ÄˇżÍ łĘą« °ˇ±îżö ±ÍČŻşÎ¸¦ »çżëÇŇĽö ľř˝Ŕ´Ď´Ů."));
  5507. if (test_server)
  5508. ChatPacket(CHAT_TYPE_INFO, "PossibleDistant %f nNowDist %f", nDistant,nDist);
  5509. return false;
  5510. }
  5511. }
  5512.  
  5513. //PREVENT_PORTAL_AFTER_EXCHANGE
  5514.  
  5515. if (iPulse - GetExchangeTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  5516. {
  5517. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°Ĺ·ˇ ČÄ %dĂĘ ŔĚł»żˇ´Â ±ÍČŻşÎ,±ÍČŻ±âľďşÎµîŔ» »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."), g_nPortalLimitTime);
  5518. return false;
  5519. }
  5520. //END_PREVENT_PORTAL_AFTER_EXCHANGE
  5521.  
  5522. }
  5523.  
  5524.  
  5525. if ((item->GetVnum() == 50200) || (item->GetVnum() == 71049))
  5526. {
  5527. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen())
  5528. {
  5529. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°Ĺ·ˇĂ˘,â°í µîŔ» ż¬ »óĹÂżˇĽ­´Â ş¸µű¸®,şń´Üş¸µű¸®¸¦ »çżëÇŇĽö ľř˝Ŕ´Ď´Ů."));
  5530. return false;
  5531. }
  5532.  
  5533. }
  5534. //END_PREVENT_TRADE_WINDOW
  5535.  
  5536. // @fixme150 BEGIN
  5537. if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  5538. {
  5539. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot use this item if you're using quests"));
  5540. return false;
  5541. }
  5542. // @fixme150 END
  5543.  
  5544. if (IS_SET(item->GetFlag(), ITEM_FLAG_LOG))
  5545. {
  5546. DWORD vid = item->GetVID();
  5547. DWORD oldCount = item->GetCount();
  5548. DWORD vnum = item->GetVnum();
  5549.  
  5550. char hint[ITEM_NAME_MAX_LEN + 32 + 1];
  5551. int len = snprintf(hint, sizeof(hint) - 32, "%s", item->GetName());
  5552.  
  5553. if (len < 0 || len >= (int) sizeof(hint) - 32)
  5554. len = (sizeof(hint) - 32) - 1;
  5555.  
  5556. bool ret = UseItemEx(item, DestCell);
  5557.  
  5558. if (NULL == ITEM_MANAGER::instance().FindByVID(vid))
  5559. {
  5560. LogManager::instance().ItemLog(this, vid, vnum, "REMOVE", hint);
  5561. }
  5562. else if (oldCount != item->GetCount())
  5563. {
  5564. snprintf(hint + len, sizeof(hint) - len, " %u", oldCount - 1);
  5565. LogManager::instance().ItemLog(this, vid, vnum, "USE_ITEM", hint);
  5566. }
  5567. return (ret);
  5568. }
  5569. else
  5570. return UseItemEx(item, DestCell);
  5571. }
  5572.  
  5573. bool CHARACTER::DropItem(TItemPos Cell, BYTE bCount)
  5574. {
  5575. LPITEM item = NULL;
  5576.  
  5577. if (!CanHandleItem())
  5578. {
  5579. if (NULL != DragonSoul_RefineWindow_GetOpener())
  5580. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°­Č­Ă˘Ŕ» ż¬ »óĹÂżˇĽ­´Â ľĆŔĚĹŰŔ» żĹ±ć Ľö ľř˝Ŕ´Ď´Ů."));
  5581. return false;
  5582. }
  5583. #ifdef ENABLE_NEWSTUFF
  5584. if (0 != g_ItemDropTimeLimitValue)
  5585. {
  5586. if (get_dword_time() < m_dwLastItemDropTime+g_ItemDropTimeLimitValue)
  5587. {
  5588. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆÁ÷ °ńµĺ¸¦ ąö¸± Ľö ľř˝Ŕ´Ď´Ů."));
  5589. return false;
  5590. }
  5591. }
  5592.  
  5593. m_dwLastItemDropTime = get_dword_time();
  5594. #endif
  5595. if (IsDead())
  5596. return false;
  5597.  
  5598. if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
  5599. return false;
  5600.  
  5601. if (item->IsExchanging())
  5602. return false;
  5603.  
  5604. if (true == item->isLocked())
  5605. return false;
  5606.  
  5607. if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  5608. return false;
  5609.  
  5610. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP | ITEM_ANTIFLAG_GIVE))
  5611. {
  5612. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ąö¸± Ľö ľř´Â ľĆŔĚĹŰŔÔ´Ď´Ů."));
  5613. return false;
  5614. }
  5615.  
  5616. if (bCount == 0 || bCount > item->GetCount())
  5617. bCount = item->GetCount();
  5618.  
  5619. SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, 255);
  5620.  
  5621. LPITEM pkItemToDrop;
  5622.  
  5623. if (bCount == item->GetCount())
  5624. {
  5625. item->RemoveFromCharacter();
  5626. pkItemToDrop = item;
  5627. }
  5628. else
  5629. {
  5630. if (bCount == 0)
  5631. {
  5632. if (test_server)
  5633. sys_log(0, "[DROP_ITEM] drop item count == 0");
  5634. return false;
  5635. }
  5636.  
  5637. item->SetCount(item->GetCount() - bCount);
  5638. ITEM_MANAGER::instance().FlushDelayedSave(item);
  5639.  
  5640. pkItemToDrop = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), bCount);
  5641.  
  5642. // copy item socket -- by mhh
  5643. FN_copy_item_socket(pkItemToDrop, item);
  5644.  
  5645. char szBuf[51 + 1];
  5646. snprintf(szBuf, sizeof(szBuf), "%u %u", pkItemToDrop->GetID(), pkItemToDrop->GetCount());
  5647. LogManager::instance().ItemLog(this, item, "ITEM_SPLIT", szBuf);
  5648. }
  5649.  
  5650. PIXEL_POSITION pxPos = GetXYZ();
  5651.  
  5652. if (pkItemToDrop->AddToGround(GetMapIndex(), pxPos))
  5653. {
  5654. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¶łľîÁř ľĆŔĚĹŰŔş 3şĐ ČÄ »ç¶óÁý´Ď´Ů."));
  5655. #ifdef ENABLE_NEWSTUFF
  5656. pkItemToDrop->StartDestroyEvent(g_aiItemDestroyTime[ITEM_DESTROY_TIME_DROPITEM]);
  5657. #else
  5658. pkItemToDrop->StartDestroyEvent();
  5659. #endif
  5660.  
  5661. ITEM_MANAGER::instance().FlushDelayedSave(pkItemToDrop);
  5662.  
  5663. char szHint[32 + 1];
  5664. snprintf(szHint, sizeof(szHint), "%s %u %u", pkItemToDrop->GetName(), pkItemToDrop->GetCount(), pkItemToDrop->GetOriginalVnum());
  5665. LogManager::instance().ItemLog(this, pkItemToDrop, "DROP", szHint);
  5666. //Motion(MOTION_PICKUP);
  5667. }
  5668.  
  5669. return true;
  5670. }
  5671.  
  5672. bool CHARACTER::DropGold(int gold)
  5673. {
  5674. if (gold <= 0 || gold > GetGold())
  5675. return false;
  5676.  
  5677. if (!CanHandleItem())
  5678. return false;
  5679.  
  5680. if (0 != g_GoldDropTimeLimitValue)
  5681. {
  5682. if (get_dword_time() < m_dwLastGoldDropTime+g_GoldDropTimeLimitValue)
  5683. {
  5684. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆÁ÷ °ńµĺ¸¦ ąö¸± Ľö ľř˝Ŕ´Ď´Ů."));
  5685. return false;
  5686. }
  5687. }
  5688.  
  5689. m_dwLastGoldDropTime = get_dword_time();
  5690.  
  5691. LPITEM item = ITEM_MANAGER::instance().CreateItem(1, gold);
  5692.  
  5693. if (item)
  5694. {
  5695. PIXEL_POSITION pos = GetXYZ();
  5696.  
  5697. if (item->AddToGround(GetMapIndex(), pos))
  5698. {
  5699. //Motion(MOTION_PICKUP);
  5700. PointChange(POINT_GOLD, -gold, true);
  5701.  
  5702. if (gold > 1000)
  5703. LogManager::instance().CharLog(this, gold, "DROP_GOLD", "");
  5704.  
  5705. #ifdef ENABLE_NEWSTUFF
  5706. item->StartDestroyEvent(g_aiItemDestroyTime[ITEM_DESTROY_TIME_DROPGOLD]);
  5707. #else
  5708. item->StartDestroyEvent();
  5709. #endif
  5710. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¶łľîÁř ľĆŔĚĹŰŔş %dşĐ ČÄ »ç¶óÁý´Ď´Ů."), 150/60);
  5711. }
  5712.  
  5713. Save();
  5714. return true;
  5715. }
  5716.  
  5717. return false;
  5718. }
  5719.  
  5720. bool CHARACTER::MoveItem(TItemPos Cell, TItemPos DestCell, BYTE count)
  5721. {
  5722. LPITEM item = NULL;
  5723.  
  5724. if (!IsValidItemPosition(Cell))
  5725. return false;
  5726.  
  5727. if (!(item = GetItem(Cell)))
  5728. return false;
  5729.  
  5730. if (item->IsExchanging())
  5731. return false;
  5732.  
  5733. if (item->GetCount() < count)
  5734. return false;
  5735.  
  5736. if (INVENTORY == Cell.window_type && Cell.cell >= INVENTORY_MAX_NUM && IS_SET(item->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  5737. return false;
  5738.  
  5739. if (true == item->isLocked())
  5740. return false;
  5741.  
  5742. if (!IsValidItemPosition(DestCell))
  5743. {
  5744. return false;
  5745. }
  5746.  
  5747. if (!CanHandleItem())
  5748. {
  5749. if (NULL != DragonSoul_RefineWindow_GetOpener())
  5750. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°­Č­Ă˘Ŕ» ż¬ »óĹÂżˇĽ­´Â ľĆŔĚĹŰŔ» żĹ±ć Ľö ľř˝Ŕ´Ď´Ů."));
  5751. return false;
  5752. }
  5753.  
  5754.  
  5755. if (DestCell.IsBeltInventoryPosition() && false == CBeltInventoryHelper::CanMoveIntoBeltInventory(item))
  5756. {
  5757. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔş ş§Ć® ŔÎşĄĹ丮·Î żĹ±ć Ľö ľř˝Ŕ´Ď´Ů."));
  5758. return false;
  5759. }
  5760.  
  5761.  
  5762. if (Cell.IsEquipPosition())
  5763. {
  5764. if (!CanUnequipNow(item))
  5765. return false;
  5766.  
  5767. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
  5768. int iWearCell = item->FindEquipCell(this);
  5769. if (iWearCell == WEAR_WEAPON)
  5770. {
  5771. LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
  5772. if (costumeWeapon && !UnequipItem(costumeWeapon))
  5773. {
  5774. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
  5775. return false;
  5776. }
  5777.  
  5778. if (!IsEmptyItemGrid(DestCell, item->GetSize(), Cell.cell))
  5779. return UnequipItem(item);
  5780. }
  5781. #endif
  5782. }
  5783.  
  5784. if (DestCell.IsEquipPosition())
  5785. {
  5786. if (GetItem(DestCell))
  5787. {
  5788. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ Ŕĺşń¸¦ ÂřżëÇĎ°í ŔÖ˝Ŕ´Ď´Ů."));
  5789.  
  5790. return false;
  5791. }
  5792.  
  5793. EquipItem(item, DestCell.cell - INVENTORY_MAX_NUM);
  5794. }
  5795. else
  5796. {
  5797. if (item->IsDragonSoul())
  5798. {
  5799. if (item->IsEquipped())
  5800. {
  5801. return DSManager::instance().PullOut(this, DestCell, item);
  5802. }
  5803. else
  5804. {
  5805. if (DestCell.window_type != DRAGON_SOUL_INVENTORY)
  5806. {
  5807. return false;
  5808. }
  5809.  
  5810. if (!DSManager::instance().IsValidCellForThisItem(item, DestCell))
  5811. return false;
  5812. }
  5813. }
  5814.  
  5815. else if (DRAGON_SOUL_INVENTORY == DestCell.window_type)
  5816. return false;
  5817.  
  5818. LPITEM item2;
  5819.  
  5820. if ((item2 = GetItem(DestCell)) && item != item2 && item2->IsStackable() &&
  5821. !IS_SET(item2->GetAntiFlag(), ITEM_ANTIFLAG_STACK) &&
  5822. item2->GetVnum() == item->GetVnum())
  5823. {
  5824. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  5825. if (item2->GetSocket(i) != item->GetSocket(i))
  5826. return false;
  5827.  
  5828. if (count == 0)
  5829. count = item->GetCount();
  5830.  
  5831. 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,
  5832. DestCell.window_type, DestCell.cell, count);
  5833.  
  5834. count = MIN(g_bItemCountLimit - item2->GetCount(), count);
  5835.  
  5836. item->SetCount(item->GetCount() - count);
  5837. item2->SetCount(item2->GetCount() + count);
  5838. return true;
  5839. }
  5840.  
  5841. if (!IsEmptyItemGrid(DestCell, item->GetSize(), Cell.cell))
  5842. return false;
  5843.  
  5844. if (count == 0 || count >= item->GetCount() || !item->IsStackable() || IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_STACK))
  5845. {
  5846. 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,
  5847. DestCell.window_type, DestCell.cell, count);
  5848.  
  5849. item->RemoveFromCharacter();
  5850. #ifdef ENABLE_HIGHLIGHT_NEW_ITEM
  5851. SetItem(DestCell, item, true);
  5852. #else
  5853. SetItem(DestCell, item);
  5854. #endif
  5855. if (INVENTORY == Cell.window_type && INVENTORY == DestCell.window_type)
  5856. SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, DestCell.cell);
  5857. }
  5858. else if (count < item->GetCount())
  5859. {
  5860.  
  5861. 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,
  5862. DestCell.window_type, DestCell.cell, count);
  5863.  
  5864. item->SetCount(item->GetCount() - count);
  5865. LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), count);
  5866.  
  5867. // copy socket -- by mhh
  5868. FN_copy_item_socket(item2, item);
  5869.  
  5870. item2->AddToCharacter(this, DestCell);
  5871.  
  5872. char szBuf[51+1];
  5873. snprintf(szBuf, sizeof(szBuf), "%u %u %u %u ", item2->GetID(), item2->GetCount(), item->GetCount(), item->GetCount() + item2->GetCount());
  5874. LogManager::instance().ItemLog(this, item, "ITEM_SPLIT", szBuf);
  5875. }
  5876. }
  5877.  
  5878. return true;
  5879. }
  5880.  
  5881. namespace NPartyPickupDistribute
  5882. {
  5883. struct FFindOwnership
  5884. {
  5885. LPITEM item;
  5886. LPCHARACTER owner;
  5887.  
  5888. FFindOwnership(LPITEM item)
  5889. : item(item), owner(NULL)
  5890. {
  5891. }
  5892.  
  5893. void operator () (LPCHARACTER ch)
  5894. {
  5895. if (item->IsOwnership(ch))
  5896. owner = ch;
  5897. }
  5898. };
  5899.  
  5900. struct FCountNearMember
  5901. {
  5902. int total;
  5903. int x, y;
  5904.  
  5905. FCountNearMember(LPCHARACTER center )
  5906. : total(0), x(center->GetX()), y(center->GetY())
  5907. {
  5908. }
  5909.  
  5910. void operator () (LPCHARACTER ch)
  5911. {
  5912. if (DISTANCE_APPROX(ch->GetX() - x, ch->GetY() - y) <= PARTY_DEFAULT_RANGE)
  5913. total += 1;
  5914. }
  5915. };
  5916.  
  5917. struct FMoneyDistributor
  5918. {
  5919. int total;
  5920. LPCHARACTER c;
  5921. int x, y;
  5922. int iMoney;
  5923.  
  5924. FMoneyDistributor(LPCHARACTER center, int iMoney)
  5925. : total(0), c(center), x(center->GetX()), y(center->GetY()), iMoney(iMoney)
  5926. {
  5927. }
  5928.  
  5929. void operator ()(LPCHARACTER ch)
  5930. {
  5931. if (ch!=c)
  5932. if (DISTANCE_APPROX(ch->GetX() - x, ch->GetY() - y) <= PARTY_DEFAULT_RANGE)
  5933. {
  5934. ch->PointChange(POINT_GOLD, iMoney, true);
  5935.  
  5936. if (iMoney > 1000)
  5937. {
  5938. LOG_LEVEL_CHECK(LOG_LEVEL_MAX, LogManager::instance().CharLog(ch, iMoney, "GET_GOLD", ""));
  5939. }
  5940. }
  5941. }
  5942. };
  5943. }
  5944.  
  5945. void CHARACTER::GiveGold(int iAmount)
  5946. {
  5947. if (iAmount <= 0)
  5948. return;
  5949.  
  5950. sys_log(0, "GIVE_GOLD: %s %d", GetName(), iAmount);
  5951.  
  5952. if (GetParty())
  5953. {
  5954. LPPARTY pParty = GetParty();
  5955.  
  5956.  
  5957. DWORD dwTotal = iAmount;
  5958. DWORD dwMyAmount = dwTotal;
  5959.  
  5960. NPartyPickupDistribute::FCountNearMember funcCountNearMember(this);
  5961. pParty->ForEachOnlineMember(funcCountNearMember);
  5962.  
  5963. if (funcCountNearMember.total > 1)
  5964. {
  5965. DWORD dwShare = dwTotal / funcCountNearMember.total;
  5966. dwMyAmount -= dwShare * (funcCountNearMember.total - 1);
  5967.  
  5968. NPartyPickupDistribute::FMoneyDistributor funcMoneyDist(this, dwShare);
  5969.  
  5970. pParty->ForEachOnlineMember(funcMoneyDist);
  5971. }
  5972.  
  5973. PointChange(POINT_GOLD, dwMyAmount, true);
  5974.  
  5975. if (dwMyAmount > 1000)
  5976. {
  5977. LOG_LEVEL_CHECK(LOG_LEVEL_MAX, LogManager::instance().CharLog(this, dwMyAmount, "GET_GOLD", ""));
  5978. }
  5979. }
  5980. else
  5981. {
  5982. PointChange(POINT_GOLD, iAmount, true);
  5983.  
  5984. if (iAmount > 1000)
  5985. {
  5986. LOG_LEVEL_CHECK(LOG_LEVEL_MAX, LogManager::instance().CharLog(this, iAmount, "GET_GOLD", ""));
  5987. }
  5988. }
  5989. }
  5990.  
  5991. bool CHARACTER::PickupItem(DWORD dwVID)
  5992. {
  5993. LPITEM item = ITEM_MANAGER::instance().FindByVID(dwVID);
  5994.  
  5995. if (IsObserverMode())
  5996. return false;
  5997.  
  5998. if (!item || !item->GetSectree())
  5999. return false;
  6000.  
  6001. if (item->DistanceValid(this))
  6002. {
  6003. // @fixme150 BEGIN
  6004. if (item->GetType() == ITEM_QUEST)
  6005. {
  6006. if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  6007. {
  6008. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot pickup this item if you're using quests"));
  6009. return false;
  6010. }
  6011. }
  6012. // @fixme150 END
  6013.  
  6014. if (item->IsOwnership(this))
  6015. {
  6016.  
  6017. if (item->GetType() == ITEM_ELK)
  6018. {
  6019. GiveGold(item->GetCount());
  6020. item->RemoveFromGround();
  6021.  
  6022. M2_DESTROY_ITEM(item);
  6023.  
  6024. Save();
  6025. }
  6026.  
  6027. else
  6028. {
  6029. if (item->IsStackable() && !IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_STACK))
  6030. {
  6031. BYTE bCount = item->GetCount();
  6032.  
  6033. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6034. {
  6035. LPITEM item2 = GetInventoryItem(i);
  6036.  
  6037. if (!item2)
  6038. continue;
  6039.  
  6040. if (item2->GetVnum() == item->GetVnum())
  6041. {
  6042. int j;
  6043.  
  6044. for (j = 0; j < ITEM_SOCKET_MAX_NUM; ++j)
  6045. if (item2->GetSocket(j) != item->GetSocket(j))
  6046. break;
  6047.  
  6048. if (j != ITEM_SOCKET_MAX_NUM)
  6049. continue;
  6050.  
  6051. BYTE bCount2 = MIN(g_bItemCountLimit - item2->GetCount(), bCount);
  6052. bCount -= bCount2;
  6053.  
  6054. item2->SetCount(item2->GetCount() + bCount2);
  6055.  
  6056. if (bCount == 0)
  6057. {
  6058. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆŔĚĹŰ Čąµć: %s"), item2->GetName());
  6059. M2_DESTROY_ITEM(item);
  6060. if (item2->GetType() == ITEM_QUEST)
  6061. quest::CQuestManager::instance().PickupItem (GetPlayerID(), item2);
  6062. return true;
  6063. }
  6064. }
  6065. }
  6066.  
  6067. item->SetCount(bCount);
  6068. }
  6069.  
  6070. int iEmptyCell;
  6071. if (item->IsDragonSoul())
  6072. {
  6073. if ((iEmptyCell = GetEmptyDragonSoulInventory(item)) == -1)
  6074. {
  6075. sys_log(0, "No empty ds inventory pid %u size %ud itemid %u", GetPlayerID(), item->GetSize(), item->GetID());
  6076. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽŇÁöÇĎ°í ŔÖ´Â ľĆŔĚĹŰŔĚ łĘą« ¸ą˝Ŕ´Ď´Ů."));
  6077. return false;
  6078. }
  6079. }
  6080. else
  6081. {
  6082. if ((iEmptyCell = GetEmptyInventory(item->GetSize())) == -1)
  6083. {
  6084. sys_log(0, "No empty inventory pid %u size %ud itemid %u", GetPlayerID(), item->GetSize(), item->GetID());
  6085. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽŇÁöÇĎ°í ŔÖ´Â ľĆŔĚĹŰŔĚ łĘą« ¸ą˝Ŕ´Ď´Ů."));
  6086. return false;
  6087. }
  6088. }
  6089.  
  6090. item->RemoveFromGround();
  6091.  
  6092. if (item->IsDragonSoul())
  6093. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  6094. else
  6095. item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
  6096.  
  6097. char szHint[32+1];
  6098. snprintf(szHint, sizeof(szHint), "%s %u %u", item->GetName(), item->GetCount(), item->GetOriginalVnum());
  6099. LogManager::instance().ItemLog(this, item, "GET", szHint);
  6100. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆŔĚĹŰ Čąµć: %s"), item->GetName());
  6101.  
  6102. if (item->GetType() == ITEM_QUEST)
  6103. quest::CQuestManager::instance().PickupItem (GetPlayerID(), item);
  6104. }
  6105.  
  6106. //Motion(MOTION_PICKUP);
  6107. return true;
  6108. }
  6109. else if (!IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_DROP) && GetParty())
  6110. {
  6111.  
  6112. NPartyPickupDistribute::FFindOwnership funcFindOwnership(item);
  6113.  
  6114. GetParty()->ForEachOnlineMember(funcFindOwnership);
  6115.  
  6116. LPCHARACTER owner = funcFindOwnership.owner;
  6117. // @fixme115
  6118. if (!owner)
  6119. return false;
  6120.  
  6121. int iEmptyCell;
  6122.  
  6123. if (item->IsDragonSoul())
  6124. {
  6125. if (!(owner && (iEmptyCell = owner->GetEmptyDragonSoulInventory(item)) != -1))
  6126. {
  6127. owner = this;
  6128.  
  6129. if ((iEmptyCell = GetEmptyDragonSoulInventory(item)) == -1)
  6130. {
  6131. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽŇÁöÇĎ°í ŔÖ´Â ľĆŔĚĹŰŔĚ łĘą« ¸ą˝Ŕ´Ď´Ů."));
  6132. return false;
  6133. }
  6134. }
  6135. }
  6136. else
  6137. {
  6138. if (!(owner && (iEmptyCell = owner->GetEmptyInventory(item->GetSize())) != -1))
  6139. {
  6140. owner = this;
  6141.  
  6142. if ((iEmptyCell = GetEmptyInventory(item->GetSize())) == -1)
  6143. {
  6144. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĽŇÁöÇĎ°í ŔÖ´Â ľĆŔĚĹŰŔĚ łĘą« ¸ą˝Ŕ´Ď´Ů."));
  6145. return false;
  6146. }
  6147. }
  6148. }
  6149.  
  6150. item->RemoveFromGround();
  6151.  
  6152. if (item->IsDragonSoul())
  6153. item->AddToCharacter(owner, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  6154. else
  6155. item->AddToCharacter(owner, TItemPos(INVENTORY, iEmptyCell));
  6156.  
  6157. char szHint[32+1];
  6158. snprintf(szHint, sizeof(szHint), "%s %u %u", item->GetName(), item->GetCount(), item->GetOriginalVnum());
  6159. LogManager::instance().ItemLog(owner, item, "GET", szHint);
  6160.  
  6161. if (owner == this)
  6162. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆŔĚĹŰ Čąµć: %s"), item->GetName());
  6163. else
  6164. {
  6165. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆŔĚĹŰ Čąµć: %s ´ÔŔ¸·ÎşÎĹÍ %s"), GetName(), item->GetName());
  6166. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆŔĚĹŰ Ŕü´Ţ: %s ´Ôżˇ°Ô %s"), owner->GetName(), item->GetName());
  6167. }
  6168.  
  6169. if (item->GetType() == ITEM_QUEST)
  6170. quest::CQuestManager::instance().PickupItem (owner->GetPlayerID(), item);
  6171.  
  6172. return true;
  6173. }
  6174. }
  6175.  
  6176. return false;
  6177. }
  6178.  
  6179. bool CHARACTER::SwapItem(BYTE bCell, BYTE bDestCell)
  6180. {
  6181. if (!CanHandleItem())
  6182. return false;
  6183.  
  6184. TItemPos srcCell(INVENTORY, bCell), destCell(INVENTORY, bDestCell);
  6185.  
  6186.  
  6187.  
  6188. //if (bCell >= INVENTORY_MAX_NUM + WEAR_MAX_NUM || bDestCell >= INVENTORY_MAX_NUM + WEAR_MAX_NUM)
  6189. if (srcCell.IsDragonSoulEquipPosition() || destCell.IsDragonSoulEquipPosition())
  6190. return false;
  6191.  
  6192.  
  6193. if (bCell == bDestCell)
  6194. return false;
  6195.  
  6196.  
  6197. if (srcCell.IsEquipPosition() && destCell.IsEquipPosition())
  6198. return false;
  6199.  
  6200. LPITEM item1, item2;
  6201.  
  6202.  
  6203. if (srcCell.IsEquipPosition())
  6204. {
  6205. item1 = GetInventoryItem(bDestCell);
  6206. item2 = GetInventoryItem(bCell);
  6207. }
  6208. else
  6209. {
  6210. item1 = GetInventoryItem(bCell);
  6211. item2 = GetInventoryItem(bDestCell);
  6212. }
  6213.  
  6214. if (!item1 || !item2)
  6215. return false;
  6216.  
  6217. if (item1 == item2)
  6218. {
  6219. sys_log(0, "[WARNING][WARNING][HACK USER!] : %s %d %d", m_stName.c_str(), bCell, bDestCell);
  6220. return false;
  6221. }
  6222.  
  6223.  
  6224. if (!IsEmptyItemGrid(TItemPos (INVENTORY, item1->GetCell()), item2->GetSize(), item1->GetCell()))
  6225. return false;
  6226.  
  6227.  
  6228. if (TItemPos(EQUIPMENT, item2->GetCell()).IsEquipPosition())
  6229. {
  6230. BYTE bEquipCell = item2->GetCell() - INVENTORY_MAX_NUM;
  6231. BYTE bInvenCell = item1->GetCell();
  6232.  
  6233.  
  6234. if (item2->IsDragonSoul() || item2->GetType() == ITEM_BELT) // @fixme117
  6235. {
  6236. if (false == CanUnequipNow(item2) || false == CanEquipNow(item1))
  6237. return false;
  6238. }
  6239.  
  6240. if (bEquipCell != item1->FindEquipCell(this))
  6241. return false;
  6242.  
  6243. item2->RemoveFromCharacter();
  6244.  
  6245. if (item1->EquipTo(this, bEquipCell))
  6246. item2->AddToCharacter(this, TItemPos(INVENTORY, bInvenCell));
  6247. else
  6248. sys_err("SwapItem cannot equip %s! item1 %s", item2->GetName(), item1->GetName());
  6249. }
  6250. else
  6251. {
  6252. BYTE bCell1 = item1->GetCell();
  6253. BYTE bCell2 = item2->GetCell();
  6254.  
  6255. item1->RemoveFromCharacter();
  6256. item2->RemoveFromCharacter();
  6257.  
  6258. item1->AddToCharacter(this, TItemPos(INVENTORY, bCell2));
  6259. item2->AddToCharacter(this, TItemPos(INVENTORY, bCell1));
  6260. }
  6261.  
  6262. return true;
  6263. }
  6264.  
  6265. bool CHARACTER::UnequipItem(LPITEM item)
  6266. {
  6267. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
  6268. int iWearCell = item->FindEquipCell(this);
  6269. if (iWearCell == WEAR_WEAPON)
  6270. {
  6271. LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
  6272. if (costumeWeapon && !UnequipItem(costumeWeapon))
  6273. {
  6274. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
  6275. return false;
  6276. }
  6277. }
  6278. #endif
  6279.  
  6280. if (false == CanUnequipNow(item))
  6281. return false;
  6282.  
  6283. int pos;
  6284. if (item->IsDragonSoul())
  6285. pos = GetEmptyDragonSoulInventory(item);
  6286. else
  6287. pos = GetEmptyInventory(item->GetSize());
  6288.  
  6289. // HARD CODING
  6290. if (item->GetVnum() == UNIQUE_ITEM_HIDE_ALIGNMENT_TITLE)
  6291. ShowAlignment(true);
  6292.  
  6293. item->RemoveFromCharacter();
  6294. if (item->IsDragonSoul())
  6295. {
  6296. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, pos));
  6297. }
  6298. else
  6299. item->AddToCharacter(this, TItemPos(INVENTORY, pos));
  6300.  
  6301. CheckMaximumPoints();
  6302.  
  6303. return true;
  6304. }
  6305.  
  6306. //
  6307.  
  6308. //
  6309. bool CHARACTER::EquipItem(LPITEM item, int iCandidateCell)
  6310. {
  6311. if (item->IsExchanging())
  6312. return false;
  6313.  
  6314. if (false == item->IsEquipable())
  6315. return false;
  6316.  
  6317. if (false == CanEquipNow(item))
  6318. return false;
  6319.  
  6320. int iWearCell = item->FindEquipCell(this, iCandidateCell);
  6321.  
  6322. if (iWearCell < 0)
  6323. return false;
  6324.  
  6325.  
  6326. if (iWearCell == WEAR_BODY && IsRiding() && (item->GetVnum() >= 11901 && item->GetVnum() <= 11904))
  6327. {
  6328. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸»Ŕ» Ĺş »óĹÂżˇĽ­ żąşąŔ» ŔÔŔ» Ľö ľř˝Ŕ´Ď´Ů."));
  6329. return false;
  6330. }
  6331.  
  6332. if (iWearCell != WEAR_ARROW && IsPolymorphed())
  6333. {
  6334. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µĐ°© Áßżˇ´Â ÂřżëÁßŔÎ Ŕĺşń¸¦ şŻ°ćÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  6335. return false;
  6336. }
  6337.  
  6338. if (FN_check_item_sex(this, item) == false)
  6339. {
  6340. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ľşş°ŔĚ ¸ÂÁöľĘľĆ ŔĚ ľĆŔĚĹŰŔ» »çżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  6341. return false;
  6342. }
  6343.  
  6344.  
  6345. if(item->IsRideItem() && IsRiding())
  6346. {
  6347. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ Ĺ»°ÍŔ» ŔĚżëÁßŔÔ´Ď´Ů."));
  6348. return false;
  6349. }
  6350.  
  6351.  
  6352. DWORD dwCurTime = get_dword_time();
  6353.  
  6354. if (iWearCell != WEAR_ARROW
  6355. && (dwCurTime - GetLastAttackTime() <= 1500 || dwCurTime - m_dwLastSkillTime <= 1500))
  6356. {
  6357. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°ˇ¸¸Č÷ ŔÖŔ» ¶§¸¸ ÂřżëÇŇ Ľö ŔÖ˝Ŕ´Ď´Ů."));
  6358. return false;
  6359. }
  6360.  
  6361. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
  6362. if (iWearCell == WEAR_WEAPON)
  6363. {
  6364. if (item->GetType() == ITEM_WEAPON)
  6365. {
  6366. LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
  6367. if (costumeWeapon && costumeWeapon->GetValue(3) != item->GetSubType() && !UnequipItem(costumeWeapon))
  6368. {
  6369. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
  6370. return false;
  6371. }
  6372. }
  6373. else //fishrod/pickaxe
  6374. {
  6375. LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
  6376. if (costumeWeapon && !UnequipItem(costumeWeapon))
  6377. {
  6378. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
  6379. return false;
  6380. }
  6381. }
  6382. }
  6383. else if (iWearCell == WEAR_COSTUME_WEAPON)
  6384. {
  6385. if (item->GetType() == ITEM_COSTUME && item->GetSubType() == COSTUME_WEAPON)
  6386. {
  6387. LPITEM pkWeapon = GetWear(WEAR_WEAPON);
  6388. if (!pkWeapon || pkWeapon->GetType() != ITEM_WEAPON || item->GetValue(3) != pkWeapon->GetSubType())
  6389. {
  6390. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot equip the costume weapon. Wrong equipped weapon."));
  6391. return false;
  6392. }
  6393. }
  6394. }
  6395. #endif
  6396.  
  6397.  
  6398. if (item->IsDragonSoul())
  6399. {
  6400.  
  6401.  
  6402. if(GetInventoryItem(INVENTORY_MAX_NUM + iWearCell))
  6403. {
  6404. ChatPacket(CHAT_TYPE_INFO, "ŔĚąĚ °°Ŕş Áľ·ůŔÇ żëČĄĽ®Ŕ» ÂřżëÇĎ°í ŔÖ˝Ŕ´Ď´Ů.");
  6405. return false;
  6406. }
  6407.  
  6408. if (!item->EquipTo(this, iWearCell))
  6409. {
  6410. return false;
  6411. }
  6412. }
  6413.  
  6414. else
  6415. {
  6416.  
  6417. if (GetWear(iWearCell) && !IS_SET(GetWear(iWearCell)->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  6418. {
  6419.  
  6420. if (item->GetWearFlag() == WEARABLE_ABILITY)
  6421. return false;
  6422.  
  6423. if (false == SwapItem(item->GetCell(), INVENTORY_MAX_NUM + iWearCell))
  6424. {
  6425. return false;
  6426. }
  6427. }
  6428. else
  6429. {
  6430. BYTE bOldCell = item->GetCell();
  6431.  
  6432. if (item->EquipTo(this, iWearCell))
  6433. {
  6434. SyncQuickslot(QUICKSLOT_TYPE_ITEM, bOldCell, iWearCell);
  6435. }
  6436. }
  6437. }
  6438.  
  6439. if (true == item->IsEquipped())
  6440. {
  6441. if (-1 != item->GetProto()->cLimitRealTimeFirstUseIndex)
  6442. {
  6443.  
  6444. if (0 == item->GetSocket(1))
  6445. {
  6446.  
  6447. long duration = (0 != item->GetSocket(0)) ? item->GetSocket(0) : item->GetProto()->aLimits[(unsigned char)(item->GetProto()->cLimitRealTimeFirstUseIndex)].lValue;
  6448.  
  6449. if (0 == duration)
  6450. duration = 60 * 60 * 24 * 7;
  6451.  
  6452. item->SetSocket(0, time(0) + duration);
  6453. item->StartRealTimeExpireEvent();
  6454. }
  6455.  
  6456. item->SetSocket(1, item->GetSocket(1) + 1);
  6457. }
  6458.  
  6459. if (item->GetVnum() == UNIQUE_ITEM_HIDE_ALIGNMENT_TITLE)
  6460. ShowAlignment(false);
  6461.  
  6462. const DWORD& dwVnum = item->GetVnum();
  6463.  
  6464.  
  6465. if (true == CItemVnumHelper::IsRamadanMoonRing(dwVnum))
  6466. {
  6467. this->EffectPacket(SE_EQUIP_RAMADAN_RING);
  6468. }
  6469.  
  6470. else if (true == CItemVnumHelper::IsHalloweenCandy(dwVnum))
  6471. {
  6472. this->EffectPacket(SE_EQUIP_HALLOWEEN_CANDY);
  6473. }
  6474.  
  6475. else if (true == CItemVnumHelper::IsHappinessRing(dwVnum))
  6476. {
  6477. this->EffectPacket(SE_EQUIP_HAPPINESS_RING);
  6478. }
  6479.  
  6480. else if (true == CItemVnumHelper::IsLovePendant(dwVnum))
  6481. {
  6482. this->EffectPacket(SE_EQUIP_LOVE_PENDANT);
  6483. }
  6484. // ITEM_UNIQUEŔÇ °ćżě, SpecialItemGroupżˇ Á¤ŔǵǾî ŔÖ°í, (item->GetSIGVnum() != NULL)
  6485. //
  6486. else if (ITEM_UNIQUE == item->GetType() && 0 != item->GetSIGVnum())
  6487. {
  6488. const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(item->GetSIGVnum());
  6489. if (NULL != pGroup)
  6490. {
  6491. const CSpecialAttrGroup* pAttrGroup = ITEM_MANAGER::instance().GetSpecialAttrGroup(pGroup->GetAttrVnum(item->GetVnum()));
  6492. if (NULL != pAttrGroup)
  6493. {
  6494. const std::string& std = pAttrGroup->m_stEffectFileName;
  6495. SpecificEffectPacket(std.c_str());
  6496. }
  6497. }
  6498. }
  6499. #ifdef ENABLE_ACCE_SYSTEM
  6500. else if ((item->GetType() == ITEM_COSTUME) && (item->GetSubType() == COSTUME_ACCE))
  6501. this->EffectPacket(SE_EFFECT_ACCE_EQUIP);
  6502. #endif
  6503. if (
  6504. (ITEM_UNIQUE == item->GetType() && UNIQUE_SPECIAL_RIDE == item->GetSubType() && IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE))
  6505. || (ITEM_UNIQUE == item->GetType() && UNIQUE_SPECIAL_MOUNT_RIDE == item->GetSubType() && IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE))
  6506. #ifdef ENABLE_MOUNT_COSTUME_SYSTEM
  6507. || (ITEM_COSTUME == item->GetType() && COSTUME_MOUNT == item->GetSubType())
  6508. #endif
  6509. )
  6510. {
  6511. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  6512. }
  6513.  
  6514. }
  6515.  
  6516. return true;
  6517. }
  6518.  
  6519. void CHARACTER::BuffOnAttr_AddBuffsFromItem(LPITEM pItem)
  6520. {
  6521. for (size_t i = 0; i < sizeof(g_aBuffOnAttrPoints)/sizeof(g_aBuffOnAttrPoints[0]); i++)
  6522. {
  6523. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(g_aBuffOnAttrPoints[i]);
  6524. if (it != m_map_buff_on_attrs.end())
  6525. {
  6526. it->second->AddBuffFromItem(pItem);
  6527. }
  6528. }
  6529. }
  6530.  
  6531. void CHARACTER::BuffOnAttr_RemoveBuffsFromItem(LPITEM pItem)
  6532. {
  6533. for (size_t i = 0; i < sizeof(g_aBuffOnAttrPoints)/sizeof(g_aBuffOnAttrPoints[0]); i++)
  6534. {
  6535. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(g_aBuffOnAttrPoints[i]);
  6536. if (it != m_map_buff_on_attrs.end())
  6537. {
  6538. it->second->RemoveBuffFromItem(pItem);
  6539. }
  6540. }
  6541. }
  6542.  
  6543. void CHARACTER::BuffOnAttr_ClearAll()
  6544. {
  6545. for (TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.begin(); it != m_map_buff_on_attrs.end(); it++)
  6546. {
  6547. CBuffOnAttributes* pBuff = it->second;
  6548. if (pBuff)
  6549. {
  6550. pBuff->Initialize();
  6551. }
  6552. }
  6553. }
  6554.  
  6555. void CHARACTER::BuffOnAttr_ValueChange(BYTE bType, BYTE bOldValue, BYTE bNewValue)
  6556. {
  6557. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(bType);
  6558.  
  6559. if (0 == bNewValue)
  6560. {
  6561. if (m_map_buff_on_attrs.end() == it)
  6562. return;
  6563. else
  6564. it->second->Off();
  6565. }
  6566. else if(0 == bOldValue)
  6567. {
  6568. CBuffOnAttributes* pBuff = NULL;
  6569. if (m_map_buff_on_attrs.end() == it)
  6570. {
  6571. switch (bType)
  6572. {
  6573. case POINT_ENERGY:
  6574. {
  6575. static BYTE abSlot[] = { WEAR_BODY, WEAR_HEAD, WEAR_FOOTS, WEAR_WRIST, WEAR_WEAPON, WEAR_NECK, WEAR_EAR, WEAR_SHIELD };
  6576. static std::vector <BYTE> vec_slots (abSlot, abSlot + _countof(abSlot));
  6577. pBuff = M2_NEW CBuffOnAttributes(this, bType, &vec_slots);
  6578. }
  6579. break;
  6580. case POINT_COSTUME_ATTR_BONUS:
  6581. {
  6582. static BYTE abSlot[] = {
  6583. WEAR_COSTUME_BODY,
  6584. WEAR_COSTUME_HAIR,
  6585. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
  6586. WEAR_COSTUME_WEAPON,
  6587. #endif
  6588. };
  6589. static std::vector <BYTE> vec_slots (abSlot, abSlot + _countof(abSlot));
  6590. pBuff = M2_NEW CBuffOnAttributes(this, bType, &vec_slots);
  6591. }
  6592. break;
  6593. default:
  6594. break;
  6595. }
  6596. m_map_buff_on_attrs.insert(TMapBuffOnAttrs::value_type(bType, pBuff));
  6597.  
  6598. }
  6599. else
  6600. pBuff = it->second;
  6601. if (pBuff != NULL)
  6602. pBuff->On(bNewValue);
  6603. }
  6604. else
  6605. {
  6606. assert (m_map_buff_on_attrs.end() != it);
  6607. it->second->ChangeBuffValue(bNewValue);
  6608. }
  6609. }
  6610.  
  6611.  
  6612. LPITEM CHARACTER::FindSpecifyItem(DWORD vnum) const
  6613. {
  6614. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6615. if (GetInventoryItem(i) && GetInventoryItem(i)->GetVnum() == vnum)
  6616. return GetInventoryItem(i);
  6617.  
  6618. return NULL;
  6619. }
  6620.  
  6621. LPITEM CHARACTER::FindItemByID(DWORD id) const
  6622. {
  6623. for (int i=0 ; i < INVENTORY_MAX_NUM ; ++i)
  6624. {
  6625. if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetID() == id)
  6626. return GetInventoryItem(i);
  6627. }
  6628.  
  6629. for (int i=BELT_INVENTORY_SLOT_START; i < BELT_INVENTORY_SLOT_END ; ++i)
  6630. {
  6631. if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetID() == id)
  6632. return GetInventoryItem(i);
  6633. }
  6634.  
  6635. return NULL;
  6636. }
  6637.  
  6638. int CHARACTER::CountSpecifyItem(DWORD vnum) const
  6639. {
  6640. int count = 0;
  6641. LPITEM item;
  6642.  
  6643. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6644. {
  6645. item = GetInventoryItem(i);
  6646. if (NULL != item && item->GetVnum() == vnum)
  6647. {
  6648.  
  6649. if (m_pkMyShop && m_pkMyShop->IsSellingItem(item->GetID()))
  6650. {
  6651. continue;
  6652. }
  6653. else
  6654. {
  6655. count += item->GetCount();
  6656. }
  6657. }
  6658. }
  6659.  
  6660. return count;
  6661. }
  6662.  
  6663. void CHARACTER::RemoveSpecifyItem(DWORD vnum, DWORD count)
  6664. {
  6665. if (0 == count)
  6666. return;
  6667.  
  6668. for (UINT i = 0; i < INVENTORY_MAX_NUM; ++i)
  6669. {
  6670. if (NULL == GetInventoryItem(i))
  6671. continue;
  6672.  
  6673. if (GetInventoryItem(i)->GetVnum() != vnum)
  6674. continue;
  6675.  
  6676.  
  6677. if(m_pkMyShop)
  6678. {
  6679. bool isItemSelling = m_pkMyShop->IsSellingItem(GetInventoryItem(i)->GetID());
  6680. if (isItemSelling)
  6681. continue;
  6682. }
  6683.  
  6684. if (vnum >= 80003 && vnum <= 80007)
  6685. LogManager::instance().GoldBarLog(GetPlayerID(), GetInventoryItem(i)->GetID(), QUEST, "RemoveSpecifyItem");
  6686.  
  6687. if (count >= GetInventoryItem(i)->GetCount())
  6688. {
  6689. count -= GetInventoryItem(i)->GetCount();
  6690. GetInventoryItem(i)->SetCount(0);
  6691.  
  6692. if (0 == count)
  6693. return;
  6694. }
  6695. else
  6696. {
  6697. GetInventoryItem(i)->SetCount(GetInventoryItem(i)->GetCount() - count);
  6698. return;
  6699. }
  6700. }
  6701.  
  6702.  
  6703. if (count)
  6704. sys_log(0, "CHARACTER::RemoveSpecifyItem cannot remove enough item vnum %u, still remain %d", vnum, count);
  6705. }
  6706.  
  6707. int CHARACTER::CountSpecifyTypeItem(BYTE type) const
  6708. {
  6709. int count = 0;
  6710.  
  6711. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6712. {
  6713. LPITEM pItem = GetInventoryItem(i);
  6714. if (pItem != NULL && pItem->GetType() == type)
  6715. {
  6716. count += pItem->GetCount();
  6717. }
  6718. }
  6719.  
  6720. return count;
  6721. }
  6722.  
  6723. void CHARACTER::RemoveSpecifyTypeItem(BYTE type, DWORD count)
  6724. {
  6725. if (0 == count)
  6726. return;
  6727.  
  6728. for (UINT i = 0; i < INVENTORY_MAX_NUM; ++i)
  6729. {
  6730. if (NULL == GetInventoryItem(i))
  6731. continue;
  6732.  
  6733. if (GetInventoryItem(i)->GetType() != type)
  6734. continue;
  6735.  
  6736.  
  6737. if(m_pkMyShop)
  6738. {
  6739. bool isItemSelling = m_pkMyShop->IsSellingItem(GetInventoryItem(i)->GetID());
  6740. if (isItemSelling)
  6741. continue;
  6742. }
  6743.  
  6744. if (count >= GetInventoryItem(i)->GetCount())
  6745. {
  6746. count -= GetInventoryItem(i)->GetCount();
  6747. GetInventoryItem(i)->SetCount(0);
  6748.  
  6749. if (0 == count)
  6750. return;
  6751. }
  6752. else
  6753. {
  6754. GetInventoryItem(i)->SetCount(GetInventoryItem(i)->GetCount() - count);
  6755. return;
  6756. }
  6757. }
  6758. }
  6759.  
  6760. void CHARACTER::AutoGiveItem(LPITEM item, bool longOwnerShip)
  6761. {
  6762. if (NULL == item)
  6763. {
  6764. sys_err ("NULL point.");
  6765. return;
  6766. }
  6767. if (item->GetOwner())
  6768. {
  6769. sys_err ("item %d 's owner exists!",item->GetID());
  6770. return;
  6771. }
  6772.  
  6773. int cell;
  6774. if (item->IsDragonSoul())
  6775. {
  6776. cell = GetEmptyDragonSoulInventory(item);
  6777. }
  6778. else
  6779. {
  6780. cell = GetEmptyInventory (item->GetSize());
  6781. }
  6782.  
  6783. if (cell != -1)
  6784. {
  6785. if (item->IsDragonSoul())
  6786. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, cell));
  6787. else
  6788. item->AddToCharacter(this, TItemPos(INVENTORY, cell));
  6789.  
  6790. LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
  6791.  
  6792. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_POTION)
  6793. {
  6794. TQuickslot * pSlot;
  6795.  
  6796. if (GetQuickslot(0, &pSlot) && pSlot->type == QUICKSLOT_TYPE_NONE)
  6797. {
  6798. TQuickslot slot;
  6799. slot.type = QUICKSLOT_TYPE_ITEM;
  6800. slot.pos = cell;
  6801. SetQuickslot(0, slot);
  6802. }
  6803. }
  6804. }
  6805. else
  6806. {
  6807. item->AddToGround (GetMapIndex(), GetXYZ());
  6808. #ifdef ENABLE_NEWSTUFF
  6809. item->StartDestroyEvent(g_aiItemDestroyTime[ITEM_DESTROY_TIME_AUTOGIVE]);
  6810. #else
  6811. item->StartDestroyEvent();
  6812. #endif
  6813.  
  6814. if (longOwnerShip)
  6815. item->SetOwnership (this, 300);
  6816. else
  6817. item->SetOwnership (this, 60);
  6818. LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
  6819. }
  6820. }
  6821.  
  6822. LPITEM CHARACTER::AutoGiveItem(DWORD dwItemVnum, BYTE bCount, int iRarePct, bool bMsg)
  6823. {
  6824. TItemTable * p = ITEM_MANAGER::instance().GetTable(dwItemVnum);
  6825.  
  6826. if (!p)
  6827. return NULL;
  6828.  
  6829. DBManager::instance().SendMoneyLog(MONEY_LOG_DROP, dwItemVnum, bCount);
  6830.  
  6831. if (p->dwFlags & ITEM_FLAG_STACKABLE && p->bType != ITEM_BLEND)
  6832. {
  6833. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  6834. {
  6835. LPITEM item = GetInventoryItem(i);
  6836.  
  6837. if (!item)
  6838. continue;
  6839.  
  6840. if (item->GetVnum() == dwItemVnum && FN_check_item_socket(item))
  6841. {
  6842. if (IS_SET(p->dwFlags, ITEM_FLAG_MAKECOUNT))
  6843. {
  6844. if (bCount < p->alValues[1])
  6845. bCount = p->alValues[1];
  6846. }
  6847.  
  6848. BYTE bCount2 = MIN(g_bItemCountLimit - item->GetCount(), bCount);
  6849. bCount -= bCount2;
  6850.  
  6851. item->SetCount(item->GetCount() + bCount2);
  6852.  
  6853. if (bCount == 0)
  6854. {
  6855. if (bMsg)
  6856. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆŔĚĹŰ Čąµć: %s"), item->GetName());
  6857.  
  6858. return item;
  6859. }
  6860. }
  6861. }
  6862. }
  6863.  
  6864. LPITEM item = ITEM_MANAGER::instance().CreateItem(dwItemVnum, bCount, 0, true);
  6865.  
  6866. if (!item)
  6867. {
  6868. sys_err("cannot create item by vnum %u (name: %s)", dwItemVnum, GetName());
  6869. return NULL;
  6870. }
  6871.  
  6872. if (item->GetType() == ITEM_BLEND || item->GetType() == ITEM_UNIQUE)
  6873. {
  6874. for (int i=0; i < INVENTORY_MAX_NUM; i++)
  6875. {
  6876. LPITEM inv_item = GetInventoryItem(i);
  6877.  
  6878. if (inv_item == NULL) continue;
  6879.  
  6880. if (inv_item->GetType() == ITEM_BLEND || inv_item->GetType() == ITEM_UNIQUE)
  6881. {
  6882. if (inv_item->GetVnum() == item->GetVnum())
  6883. {
  6884. if (inv_item->GetSocket(0) == item->GetSocket(0) &&
  6885. inv_item->GetSocket(1) == item->GetSocket(1) &&
  6886. inv_item->GetSocket(2) == item->GetSocket(2) &&
  6887. inv_item->GetCount() < ITEM_MAX_COUNT)
  6888. {
  6889. inv_item->SetCount(inv_item->GetCount() + item->GetCount());
  6890. return inv_item;
  6891. }
  6892. }
  6893. }
  6894. }
  6895. }
  6896.  
  6897. int iEmptyCell;
  6898. if (item->IsDragonSoul())
  6899. {
  6900. iEmptyCell = GetEmptyDragonSoulInventory(item);
  6901. }
  6902. else
  6903. iEmptyCell = GetEmptyInventory(item->GetSize());
  6904.  
  6905. if (iEmptyCell != -1)
  6906. {
  6907. if (bMsg)
  6908. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆŔĚĹŰ Čąµć: %s"), item->GetName());
  6909.  
  6910. if (item->IsDragonSoul())
  6911. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  6912. else
  6913. item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
  6914. LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
  6915.  
  6916. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_POTION)
  6917. {
  6918. TQuickslot * pSlot;
  6919.  
  6920. if (GetQuickslot(0, &pSlot) && pSlot->type == QUICKSLOT_TYPE_NONE)
  6921. {
  6922. TQuickslot slot;
  6923. slot.type = QUICKSLOT_TYPE_ITEM;
  6924. slot.pos = iEmptyCell;
  6925. SetQuickslot(0, slot);
  6926. }
  6927. }
  6928. }
  6929. else
  6930. {
  6931. item->AddToGround(GetMapIndex(), GetXYZ());
  6932. #ifdef ENABLE_NEWSTUFF
  6933. item->StartDestroyEvent(g_aiItemDestroyTime[ITEM_DESTROY_TIME_AUTOGIVE]);
  6934. #else
  6935. item->StartDestroyEvent();
  6936. #endif
  6937.  
  6938.  
  6939.  
  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. }
  6946.  
  6947. sys_log(0,
  6948. "7: %d %d", dwItemVnum, bCount);
  6949. return item;
  6950. }
  6951.  
  6952. bool CHARACTER::GiveItem(LPCHARACTER victim, TItemPos Cell)
  6953. {
  6954. if (!CanHandleItem())
  6955. return false;
  6956.  
  6957. // @fixme150 BEGIN
  6958. if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  6959. {
  6960. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot take this item if you're using quests"));
  6961. return false;
  6962. }
  6963. // @fixme150 END
  6964.  
  6965. LPITEM item = GetItem(Cell);
  6966.  
  6967. if (item && !item->IsExchanging())
  6968. {
  6969. if (victim->CanReceiveItem(this, item))
  6970. {
  6971. victim->ReceiveItem(this, item);
  6972. return true;
  6973. }
  6974. }
  6975.  
  6976. return false;
  6977. }
  6978.  
  6979. bool CHARACTER::CanReceiveItem(LPCHARACTER from, LPITEM item) const
  6980. {
  6981. if (IsPC())
  6982. return false;
  6983.  
  6984. // TOO_LONG_DISTANCE_EXCHANGE_BUG_FIX
  6985. if (DISTANCE_APPROX(GetX() - from->GetX(), GetY() - from->GetY()) > 2000)
  6986. return false;
  6987. // END_OF_TOO_LONG_DISTANCE_EXCHANGE_BUG_FIX
  6988.  
  6989. switch (GetRaceNum())
  6990. {
  6991. case fishing::CAMPFIRE_MOB:
  6992. if (item->GetType() == ITEM_FISH &&
  6993. (item->GetSubType() == FISH_ALIVE || item->GetSubType() == FISH_DEAD))
  6994. return true;
  6995. break;
  6996.  
  6997. case fishing::FISHER_MOB:
  6998. if (item->GetType() == ITEM_ROD)
  6999. return true;
  7000. break;
  7001.  
  7002. // BUILDING_NPC
  7003. case BLACKSMITH_WEAPON_MOB:
  7004. case DEVILTOWER_BLACKSMITH_WEAPON_MOB:
  7005. if (item->GetType() == ITEM_WEAPON &&
  7006. item->GetRefinedVnum())
  7007. return true;
  7008. else
  7009. return false;
  7010. break;
  7011.  
  7012. case BLACKSMITH_ARMOR_MOB:
  7013. case DEVILTOWER_BLACKSMITH_ARMOR_MOB:
  7014. if (item->GetType() == ITEM_ARMOR &&
  7015. (item->GetSubType() == ARMOR_BODY || item->GetSubType() == ARMOR_SHIELD || item->GetSubType() == ARMOR_HEAD) &&
  7016. item->GetRefinedVnum())
  7017. return true;
  7018. else
  7019. return false;
  7020. break;
  7021.  
  7022. case BLACKSMITH_ACCESSORY_MOB:
  7023. case DEVILTOWER_BLACKSMITH_ACCESSORY_MOB:
  7024. if (item->GetType() == ITEM_ARMOR &&
  7025. !(item->GetSubType() == ARMOR_BODY || item->GetSubType() == ARMOR_SHIELD || item->GetSubType() == ARMOR_HEAD) &&
  7026. item->GetRefinedVnum())
  7027. return true;
  7028. else
  7029. return false;
  7030. break;
  7031. // END_OF_BUILDING_NPC
  7032.  
  7033. case BLACKSMITH_MOB:
  7034. if (item->GetRefinedVnum() && item->GetRefineSet() < 500)
  7035. {
  7036. return true;
  7037. }
  7038. else
  7039. {
  7040. return false;
  7041. }
  7042.  
  7043. case BLACKSMITH2_MOB:
  7044. if (item->GetRefineSet() >= 500)
  7045. {
  7046. return true;
  7047. }
  7048. else
  7049. {
  7050. return false;
  7051. }
  7052.  
  7053. case ALCHEMIST_MOB:
  7054. if (item->GetRefinedVnum())
  7055. return true;
  7056. break;
  7057.  
  7058. case 20101:
  7059. case 20102:
  7060. case 20103:
  7061.  
  7062. if (item->GetVnum() == ITEM_REVIVE_HORSE_1)
  7063. {
  7064. if (!IsDead())
  7065. {
  7066. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Áö ľĘŔş ¸»żˇ°Ô Ľ±Ăʸ¦ ¸ÔŔĎ Ľö ľř˝Ŕ´Ď´Ů."));
  7067. return false;
  7068. }
  7069. return true;
  7070. }
  7071. else if (item->GetVnum() == ITEM_HORSE_FOOD_1)
  7072. {
  7073. if (IsDead())
  7074. {
  7075. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Ŕş ¸»żˇ°Ô »ç·á¸¦ ¸ÔŔĎ Ľö ľř˝Ŕ´Ď´Ů."));
  7076. return false;
  7077. }
  7078. return true;
  7079. }
  7080. else if (item->GetVnum() == ITEM_HORSE_FOOD_2 || item->GetVnum() == ITEM_HORSE_FOOD_3)
  7081. {
  7082. return false;
  7083. }
  7084. break;
  7085. case 20104:
  7086. case 20105:
  7087. case 20106:
  7088.  
  7089. if (item->GetVnum() == ITEM_REVIVE_HORSE_2)
  7090. {
  7091. if (!IsDead())
  7092. {
  7093. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Áö ľĘŔş ¸»żˇ°Ô Ľ±Ăʸ¦ ¸ÔŔĎ Ľö ľř˝Ŕ´Ď´Ů."));
  7094. return false;
  7095. }
  7096. return true;
  7097. }
  7098. else if (item->GetVnum() == ITEM_HORSE_FOOD_2)
  7099. {
  7100. if (IsDead())
  7101. {
  7102. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Ŕş ¸»żˇ°Ô »ç·á¸¦ ¸ÔŔĎ Ľö ľř˝Ŕ´Ď´Ů."));
  7103. return false;
  7104. }
  7105. return true;
  7106. }
  7107. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 || item->GetVnum() == ITEM_HORSE_FOOD_3)
  7108. {
  7109. return false;
  7110. }
  7111. break;
  7112. case 20107:
  7113. case 20108:
  7114. case 20109:
  7115.  
  7116. if (item->GetVnum() == ITEM_REVIVE_HORSE_3)
  7117. {
  7118. if (!IsDead())
  7119. {
  7120. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Áö ľĘŔş ¸»żˇ°Ô Ľ±Ăʸ¦ ¸ÔŔĎ Ľö ľř˝Ŕ´Ď´Ů."));
  7121. return false;
  7122. }
  7123. return true;
  7124. }
  7125. else if (item->GetVnum() == ITEM_HORSE_FOOD_3)
  7126. {
  7127. if (IsDead())
  7128. {
  7129. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Ŕş ¸»żˇ°Ô »ç·á¸¦ ¸ÔŔĎ Ľö ľř˝Ŕ´Ď´Ů."));
  7130. return false;
  7131. }
  7132. return true;
  7133. }
  7134. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 || item->GetVnum() == ITEM_HORSE_FOOD_2)
  7135. {
  7136. return false;
  7137. }
  7138. break;
  7139. }
  7140.  
  7141. //if (IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_GIVE))
  7142. {
  7143. return true;
  7144. }
  7145.  
  7146. return false;
  7147. }
  7148.  
  7149. void CHARACTER::ReceiveItem(LPCHARACTER from, LPITEM item)
  7150. {
  7151. if (IsPC())
  7152. return;
  7153.  
  7154. switch (GetRaceNum())
  7155. {
  7156. case fishing::CAMPFIRE_MOB:
  7157. if (item->GetType() == ITEM_FISH && (item->GetSubType() == FISH_ALIVE || item->GetSubType() == FISH_DEAD))
  7158. fishing::Grill(from, item);
  7159. else
  7160. {
  7161. // TAKE_ITEM_BUG_FIX
  7162. from->SetQuestNPCID(GetVID());
  7163. // END_OF_TAKE_ITEM_BUG_FIX
  7164. quest::CQuestManager::instance().TakeItem(from->GetPlayerID(), GetRaceNum(), item);
  7165. }
  7166. break;
  7167.  
  7168. // DEVILTOWER_NPC
  7169. case DEVILTOWER_BLACKSMITH_WEAPON_MOB:
  7170. case DEVILTOWER_BLACKSMITH_ARMOR_MOB:
  7171. case DEVILTOWER_BLACKSMITH_ACCESSORY_MOB:
  7172. if (item->GetRefinedVnum() != 0 && item->GetRefineSet() != 0 && item->GetRefineSet() < 500)
  7173. {
  7174. from->SetRefineNPC(this);
  7175. from->RefineInformation(item->GetCell(), REFINE_TYPE_MONEY_ONLY);
  7176. }
  7177. else
  7178. {
  7179. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔş °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7180. }
  7181. break;
  7182. // END_OF_DEVILTOWER_NPC
  7183.  
  7184. case BLACKSMITH_MOB:
  7185. case BLACKSMITH2_MOB:
  7186. case BLACKSMITH_WEAPON_MOB:
  7187. case BLACKSMITH_ARMOR_MOB:
  7188. case BLACKSMITH_ACCESSORY_MOB:
  7189. if (item->GetRefinedVnum())
  7190. {
  7191. from->SetRefineNPC(this);
  7192. from->RefineInformation(item->GetCell(), REFINE_TYPE_NORMAL);
  7193. }
  7194. else
  7195. {
  7196. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚ ľĆŔĚĹŰŔş °ł·®ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7197. }
  7198. break;
  7199.  
  7200. case 20101:
  7201. case 20102:
  7202. case 20103:
  7203. case 20104:
  7204. case 20105:
  7205. case 20106:
  7206. case 20107:
  7207. case 20108:
  7208. case 20109:
  7209. if (item->GetVnum() == ITEM_REVIVE_HORSE_1 ||
  7210. item->GetVnum() == ITEM_REVIVE_HORSE_2 ||
  7211. item->GetVnum() == ITEM_REVIVE_HORSE_3)
  7212. {
  7213. from->ReviveHorse();
  7214. item->SetCount(item->GetCount()-1);
  7215. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸»żˇ°Ô Ľ±Ăʸ¦ ÁÖľú˝Ŕ´Ď´Ů."));
  7216. }
  7217. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 ||
  7218. item->GetVnum() == ITEM_HORSE_FOOD_2 ||
  7219. item->GetVnum() == ITEM_HORSE_FOOD_3)
  7220. {
  7221. from->FeedHorse();
  7222. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸»żˇ°Ô »ç·á¸¦ ÁÖľú˝Ŕ´Ď´Ů."));
  7223. item->SetCount(item->GetCount()-1);
  7224. EffectPacket(SE_HPUP_RED);
  7225. }
  7226. break;
  7227.  
  7228. default:
  7229. sys_log(0, "TakeItem %s %d %s", from->GetName(), GetRaceNum(), item->GetName());
  7230. from->SetQuestNPCID(GetVID());
  7231. quest::CQuestManager::instance().TakeItem(from->GetPlayerID(), GetRaceNum(), item);
  7232. break;
  7233. }
  7234. }
  7235.  
  7236. bool CHARACTER::IsEquipUniqueItem(DWORD dwItemVnum) const
  7237. {
  7238. {
  7239. LPITEM u = GetWear(WEAR_UNIQUE1);
  7240.  
  7241. if (u && u->GetVnum() == dwItemVnum)
  7242. return true;
  7243. }
  7244.  
  7245. {
  7246. LPITEM u = GetWear(WEAR_UNIQUE2);
  7247.  
  7248. if (u && u->GetVnum() == dwItemVnum)
  7249. return true;
  7250. }
  7251.  
  7252.  
  7253. if (dwItemVnum == UNIQUE_ITEM_RING_OF_LANGUAGE)
  7254. return IsEquipUniqueItem(UNIQUE_ITEM_RING_OF_LANGUAGE_SAMPLE);
  7255.  
  7256. return false;
  7257. }
  7258.  
  7259. // CHECK_UNIQUE_GROUP
  7260. bool CHARACTER::IsEquipUniqueGroup(DWORD dwGroupVnum) const
  7261. {
  7262. {
  7263. LPITEM u = GetWear(WEAR_UNIQUE1);
  7264.  
  7265. if (u && u->GetSpecialGroup() == (int) dwGroupVnum)
  7266. return true;
  7267. }
  7268.  
  7269. {
  7270. LPITEM u = GetWear(WEAR_UNIQUE2);
  7271.  
  7272. if (u && u->GetSpecialGroup() == (int) dwGroupVnum)
  7273. return true;
  7274. }
  7275.  
  7276. return false;
  7277. }
  7278. // END_OF_CHECK_UNIQUE_GROUP
  7279.  
  7280. void CHARACTER::SetRefineMode(int iAdditionalCell)
  7281. {
  7282. m_iRefineAdditionalCell = iAdditionalCell;
  7283. m_bUnderRefine = true;
  7284. }
  7285.  
  7286. void CHARACTER::ClearRefineMode()
  7287. {
  7288. m_bUnderRefine = false;
  7289. SetRefineNPC( NULL );
  7290. }
  7291.  
  7292. bool CHARACTER::GiveItemFromSpecialItemGroup(DWORD dwGroupNum, std::vector<DWORD> &dwItemVnums,
  7293. std::vector<DWORD> &dwItemCounts, std::vector <LPITEM> &item_gets, int &count)
  7294. {
  7295. const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(dwGroupNum);
  7296.  
  7297. if (!pGroup)
  7298. {
  7299. sys_err("cannot find special item group %d", dwGroupNum);
  7300. return false;
  7301. }
  7302.  
  7303. std::vector <int> idxes;
  7304. int n = pGroup->GetMultiIndex(idxes);
  7305.  
  7306. bool bSuccess;
  7307.  
  7308. for (int i = 0; i < n; i++)
  7309. {
  7310. bSuccess = false;
  7311. int idx = idxes[i];
  7312. DWORD dwVnum = pGroup->GetVnum(idx);
  7313. DWORD dwCount = pGroup->GetCount(idx);
  7314. int iRarePct = pGroup->GetRarePct(idx);
  7315. LPITEM item_get = NULL;
  7316. switch (dwVnum)
  7317. {
  7318. case CSpecialItemGroup::GOLD:
  7319. PointChange(POINT_GOLD, dwCount);
  7320. LogManager::instance().CharLog(this, dwCount, "TREASURE_GOLD", "");
  7321.  
  7322. bSuccess = true;
  7323. break;
  7324. case CSpecialItemGroup::EXP:
  7325. {
  7326. PointChange(POINT_EXP, dwCount);
  7327. LogManager::instance().CharLog(this, dwCount, "TREASURE_EXP", "");
  7328.  
  7329. bSuccess = true;
  7330. }
  7331. break;
  7332.  
  7333. case CSpecialItemGroup::MOB:
  7334. {
  7335. sys_log(0, "CSpecialItemGroup::MOB %d", dwCount);
  7336. int x = GetX() + number(-500, 500);
  7337. int y = GetY() + number(-500, 500);
  7338.  
  7339. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(dwCount, GetMapIndex(), x, y, 0, true, -1);
  7340. if (ch)
  7341. ch->SetAggressive();
  7342. bSuccess = true;
  7343. }
  7344. break;
  7345. case CSpecialItemGroup::SLOW:
  7346. {
  7347. sys_log(0, "CSpecialItemGroup::SLOW %d", -(int)dwCount);
  7348. AddAffect(AFFECT_SLOW, POINT_MOV_SPEED, -(int)dwCount, AFF_SLOW, 300, 0, true);
  7349. bSuccess = true;
  7350. }
  7351. break;
  7352. case CSpecialItemGroup::DRAIN_HP:
  7353. {
  7354. int iDropHP = GetMaxHP()*dwCount/100;
  7355. sys_log(0, "CSpecialItemGroup::DRAIN_HP %d", -iDropHP);
  7356. iDropHP = MIN(iDropHP, GetHP()-1);
  7357. sys_log(0, "CSpecialItemGroup::DRAIN_HP %d", -iDropHP);
  7358. PointChange(POINT_HP, -iDropHP);
  7359. bSuccess = true;
  7360. }
  7361. break;
  7362. case CSpecialItemGroup::POISON:
  7363. {
  7364. AttackedByPoison(NULL);
  7365. bSuccess = true;
  7366. }
  7367. break;
  7368. #ifdef ENABLE_WOLFMAN_CHARACTER
  7369. case CSpecialItemGroup::BLEEDING:
  7370. {
  7371. AttackedByBleeding(NULL);
  7372. bSuccess = true;
  7373. }
  7374. break;
  7375. #endif
  7376. case CSpecialItemGroup::MOB_GROUP:
  7377. {
  7378. int sx = GetX() - number(300, 500);
  7379. int sy = GetY() - number(300, 500);
  7380. int ex = GetX() + number(300, 500);
  7381. int ey = GetY() + number(300, 500);
  7382. CHARACTER_MANAGER::instance().SpawnGroup(dwCount, GetMapIndex(), sx, sy, ex, ey, NULL, true);
  7383.  
  7384. bSuccess = true;
  7385. }
  7386. break;
  7387. default:
  7388. {
  7389. item_get = AutoGiveItem(dwVnum, dwCount, iRarePct);
  7390.  
  7391. if (item_get)
  7392. {
  7393. bSuccess = true;
  7394. }
  7395. }
  7396. break;
  7397. }
  7398.  
  7399. if (bSuccess)
  7400. {
  7401. dwItemVnums.push_back(dwVnum);
  7402. dwItemCounts.push_back(dwCount);
  7403. item_gets.push_back(item_get);
  7404. count++;
  7405.  
  7406. }
  7407. else
  7408. {
  7409. return false;
  7410. }
  7411. }
  7412. return bSuccess;
  7413. }
  7414.  
  7415. // NEW_HAIR_STYLE_ADD
  7416. bool CHARACTER::ItemProcess_Hair(LPITEM item, int iDestCell)
  7417. {
  7418. if (item->CheckItemUseLevel(GetLevel()) == false)
  7419. {
  7420.  
  7421. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ľĆÁ÷ ŔĚ ¸Ó¸®¸¦ »çżëÇŇ Ľö ľř´Â ·ąş§ŔÔ´Ď´Ů."));
  7422. return false;
  7423. }
  7424.  
  7425. DWORD hair = item->GetVnum();
  7426.  
  7427. switch (GetJob())
  7428. {
  7429. case JOB_WARRIOR :
  7430. hair -= 72000;
  7431. break;
  7432.  
  7433. case JOB_ASSASSIN :
  7434. hair -= 71250;
  7435. break;
  7436.  
  7437. case JOB_SURA :
  7438. hair -= 70500;
  7439. break;
  7440.  
  7441. case JOB_SHAMAN :
  7442. hair -= 69750;
  7443. break;
  7444. #ifdef ENABLE_WOLFMAN_CHARACTER
  7445. case JOB_WOLFMAN:
  7446. break;
  7447. #endif
  7448. default :
  7449. return false;
  7450. break;
  7451. }
  7452.  
  7453. if (hair == GetPart(PART_HAIR))
  7454. {
  7455. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µżŔĎÇŃ ¸Ó¸® ˝şĹ¸ŔϷδ ±łĂĽÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7456. return true;
  7457. }
  7458.  
  7459. item->SetCount(item->GetCount() - 1);
  7460.  
  7461. SetPart(PART_HAIR, hair);
  7462. UpdatePacket();
  7463.  
  7464. return true;
  7465. }
  7466. // END_NEW_HAIR_STYLE_ADD
  7467.  
  7468. bool CHARACTER::ItemProcess_Polymorph(LPITEM item)
  7469. {
  7470. if (IsPolymorphed())
  7471. {
  7472. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ŔĚąĚ µĐ°©ÁßŔÎ »óĹÂŔÔ´Ď´Ů."));
  7473. return false;
  7474. }
  7475.  
  7476. if (true == IsRiding())
  7477. {
  7478. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µĐ°©ÇŇ Ľö ľř´Â »óĹÂŔÔ´Ď´Ů."));
  7479. return false;
  7480. }
  7481.  
  7482. DWORD dwVnum = item->GetSocket(0);
  7483.  
  7484. if (dwVnum == 0)
  7485. {
  7486. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ŕ߸řµČ µĐ°© ľĆŔĚĹŰŔÔ´Ď´Ů."));
  7487. item->SetCount(item->GetCount()-1);
  7488. return false;
  7489. }
  7490.  
  7491. const CMob* pMob = CMobManager::instance().Get(dwVnum);
  7492.  
  7493. if (pMob == NULL)
  7494. {
  7495. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Ŕ߸řµČ µĐ°© ľĆŔĚĹŰŔÔ´Ď´Ů."));
  7496. item->SetCount(item->GetCount()-1);
  7497. return false;
  7498. }
  7499.  
  7500. switch (item->GetVnum())
  7501. {
  7502. case 70104 :
  7503. case 70105 :
  7504. case 70106 :
  7505. case 70107 :
  7506. case 71093 :
  7507. {
  7508.  
  7509. sys_log(0, "USE_POLYMORPH_BALL PID(%d) vnum(%d)", GetPlayerID(), dwVnum);
  7510.  
  7511.  
  7512. int iPolymorphLevelLimit = MAX(0, 20 - GetLevel() * 3 / 10);
  7513. if (pMob->m_table.bLevel >= GetLevel() + iPolymorphLevelLimit)
  7514. {
  7515. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("łŞş¸´Ů łĘą« łôŔş ·ąş§ŔÇ ¸ó˝şĹͷδ şŻ˝Ĺ ÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7516. return false;
  7517. }
  7518.  
  7519. int iDuration = GetSkillLevel(POLYMORPH_SKILL_ID) == 0 ? 5 : (5 + (5 + GetSkillLevel(POLYMORPH_SKILL_ID)/40 * 25));
  7520. iDuration *= 60;
  7521.  
  7522. DWORD dwBonus = 0;
  7523.  
  7524. dwBonus = (2 + GetSkillLevel(POLYMORPH_SKILL_ID)/40) * 100;
  7525.  
  7526. AddAffect(AFFECT_POLYMORPH, POINT_POLYMORPH, dwVnum, AFF_POLYMORPH, iDuration, 0, true);
  7527. AddAffect(AFFECT_POLYMORPH, POINT_ATT_BONUS, dwBonus, AFF_POLYMORPH, iDuration, 0, false);
  7528.  
  7529. item->SetCount(item->GetCount()-1);
  7530. }
  7531. break;
  7532.  
  7533. case 50322:
  7534. {
  7535.  
  7536.  
  7537.  
  7538.  
  7539.  
  7540. sys_log(0, "USE_POLYMORPH_BOOK: %s(%u) vnum(%u)", GetName(), GetPlayerID(), dwVnum);
  7541.  
  7542. if (CPolymorphUtils::instance().PolymorphCharacter(this, item, pMob) == true)
  7543. {
  7544. CPolymorphUtils::instance().UpdateBookPracticeGrade(this, item);
  7545. }
  7546. else
  7547. {
  7548. }
  7549. }
  7550. break;
  7551.  
  7552. default :
  7553. sys_err("POLYMORPH invalid item passed PID(%d) vnum(%d)", GetPlayerID(), item->GetOriginalVnum());
  7554. return false;
  7555. }
  7556.  
  7557. return true;
  7558. }
  7559.  
  7560. bool CHARACTER::CanDoCube() const
  7561. {
  7562. if (m_bIsObserver) return false;
  7563. if (GetShop()) return false;
  7564. if (GetMyShop()) return false;
  7565. if (m_bUnderRefine) return false;
  7566. if (IsWarping()) return false;
  7567.  
  7568. return true;
  7569. }
  7570.  
  7571. bool CHARACTER::UnEquipSpecialRideUniqueItem()
  7572. {
  7573. LPITEM Unique1 = GetWear(WEAR_UNIQUE1);
  7574. LPITEM Unique2 = GetWear(WEAR_UNIQUE2);
  7575. #ifdef ENABLE_MOUNT_COSTUME_SYSTEM
  7576. LPITEM MountCostume = GetWear(WEAR_COSTUME_MOUNT);
  7577. #endif
  7578.  
  7579. if( NULL != Unique1 )
  7580. {
  7581. if( UNIQUE_GROUP_SPECIAL_RIDE == Unique1->GetSpecialGroup() )
  7582. {
  7583. return UnequipItem(Unique1);
  7584. }
  7585. }
  7586.  
  7587. if( NULL != Unique2 )
  7588. {
  7589. if( UNIQUE_GROUP_SPECIAL_RIDE == Unique2->GetSpecialGroup() )
  7590. {
  7591. return UnequipItem(Unique2);
  7592. }
  7593. }
  7594.  
  7595. #ifdef ENABLE_MOUNT_COSTUME_SYSTEM
  7596. if (MountCostume)
  7597. return UnequipItem(MountCostume);
  7598. #endif
  7599.  
  7600. return true;
  7601. }
  7602.  
  7603. void CHARACTER::AutoRecoveryItemProcess(const EAffectTypes type)
  7604. {
  7605. if (true == IsDead() || true == IsStun())
  7606. return;
  7607.  
  7608. if (false == IsPC())
  7609. return;
  7610.  
  7611. if (AFFECT_AUTO_HP_RECOVERY != type && AFFECT_AUTO_SP_RECOVERY != type)
  7612. return;
  7613.  
  7614. if (NULL != FindAffect(AFFECT_STUN))
  7615. return;
  7616.  
  7617. {
  7618. const DWORD stunSkills[] = { SKILL_TANHWAN, SKILL_GEOMPUNG, SKILL_BYEURAK, SKILL_GIGUNG };
  7619.  
  7620. for (size_t i=0 ; i < sizeof(stunSkills)/sizeof(DWORD) ; ++i)
  7621. {
  7622. const CAffect* p = FindAffect(stunSkills[i]);
  7623.  
  7624. if (NULL != p && AFF_STUN == p->dwFlag)
  7625. return;
  7626. }
  7627. }
  7628.  
  7629. const CAffect* pAffect = FindAffect(type);
  7630. const size_t idx_of_amount_of_used = 1;
  7631. const size_t idx_of_amount_of_full = 2;
  7632.  
  7633. if (NULL != pAffect)
  7634. {
  7635. LPITEM pItem = FindItemByID(pAffect->dwFlag);
  7636.  
  7637. if (NULL != pItem && true == pItem->GetSocket(0))
  7638. {
  7639. if (!CArenaManager::instance().IsArenaMap(GetMapIndex())
  7640. #ifdef ENABLE_NEWSTUFF
  7641. && !(g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(pItem->GetVnum()))
  7642. #endif
  7643. )
  7644. {
  7645. const long amount_of_used = pItem->GetSocket(idx_of_amount_of_used);
  7646. const long amount_of_full = pItem->GetSocket(idx_of_amount_of_full);
  7647.  
  7648. const int32_t avail = amount_of_full - amount_of_used;
  7649.  
  7650. int32_t amount = 0;
  7651.  
  7652. if (AFFECT_AUTO_HP_RECOVERY == type)
  7653. {
  7654. amount = GetMaxHP() - (GetHP() + GetPoint(POINT_HP_RECOVERY));
  7655. }
  7656. else if (AFFECT_AUTO_SP_RECOVERY == type)
  7657. {
  7658. amount = GetMaxSP() - (GetSP() + GetPoint(POINT_SP_RECOVERY));
  7659. }
  7660.  
  7661. if (amount > 0)
  7662. {
  7663. if (avail > amount)
  7664. {
  7665. const int pct_of_used = amount_of_used * 100 / amount_of_full;
  7666. const int pct_of_will_used = (amount_of_used + amount) * 100 / amount_of_full;
  7667.  
  7668. bool bLog = false;
  7669.  
  7670.  
  7671. if ((pct_of_will_used / 10) - (pct_of_used / 10) >= 1)
  7672. bLog = true;
  7673. pItem->SetSocket(idx_of_amount_of_used, amount_of_used + amount, bLog);
  7674. }
  7675. else
  7676. {
  7677. amount = avail;
  7678.  
  7679. ITEM_MANAGER::instance().RemoveItem( pItem );
  7680. }
  7681.  
  7682. if (AFFECT_AUTO_HP_RECOVERY == type)
  7683. {
  7684. PointChange( POINT_HP_RECOVERY, amount );
  7685. EffectPacket( SE_AUTO_HPUP );
  7686. }
  7687. else if (AFFECT_AUTO_SP_RECOVERY == type)
  7688. {
  7689. PointChange( POINT_SP_RECOVERY, amount );
  7690. EffectPacket( SE_AUTO_SPUP );
  7691. }
  7692. }
  7693. }
  7694. else
  7695. {
  7696. pItem->Lock(false);
  7697. pItem->SetSocket(0, false);
  7698. RemoveAffect( const_cast<CAffect*>(pAffect) );
  7699. }
  7700. }
  7701. else
  7702. {
  7703. RemoveAffect( const_cast<CAffect*>(pAffect) );
  7704. }
  7705. }
  7706. }
  7707.  
  7708. bool CHARACTER::IsValidItemPosition(TItemPos Pos) const
  7709. {
  7710. BYTE window_type = Pos.window_type;
  7711. WORD cell = Pos.cell;
  7712.  
  7713. switch (window_type)
  7714. {
  7715. case RESERVED_WINDOW:
  7716. return false;
  7717.  
  7718. case INVENTORY:
  7719. case EQUIPMENT:
  7720. return cell < (INVENTORY_AND_EQUIP_SLOT_MAX);
  7721.  
  7722. case DRAGON_SOUL_INVENTORY:
  7723. return cell < (DRAGON_SOUL_INVENTORY_MAX_NUM);
  7724.  
  7725. case SAFEBOX:
  7726. if (NULL != m_pkSafebox)
  7727. return m_pkSafebox->IsValidPosition(cell);
  7728. else
  7729. return false;
  7730.  
  7731. case MALL:
  7732. if (NULL != m_pkMall)
  7733. return m_pkMall->IsValidPosition(cell);
  7734. else
  7735. return false;
  7736. default:
  7737. return false;
  7738. }
  7739. }
  7740.  
  7741.  
  7742.  
  7743. #define VERIFY_MSG(exp, msg) \
  7744. if (true == (exp)) { \
  7745. ChatPacket(CHAT_TYPE_INFO, LC_TEXT(msg)); \
  7746. return false; \
  7747. }
  7748.  
  7749.  
  7750. bool CHARACTER::CanEquipNow(const LPITEM item, const TItemPos& srcCell, const TItemPos& destCell) /*const*/
  7751. {
  7752. const TItemTable* itemTable = item->GetProto();
  7753. //BYTE itemType = item->GetType();
  7754. //BYTE itemSubType = item->GetSubType();
  7755.  
  7756. switch (GetJob())
  7757. {
  7758. case JOB_WARRIOR:
  7759. if (item->GetAntiFlag() & ITEM_ANTIFLAG_WARRIOR)
  7760. return false;
  7761. break;
  7762.  
  7763. case JOB_ASSASSIN:
  7764. if (item->GetAntiFlag() & ITEM_ANTIFLAG_ASSASSIN)
  7765. return false;
  7766. break;
  7767.  
  7768. case JOB_SHAMAN:
  7769. if (item->GetAntiFlag() & ITEM_ANTIFLAG_SHAMAN)
  7770. return false;
  7771. break;
  7772.  
  7773. case JOB_SURA:
  7774. if (item->GetAntiFlag() & ITEM_ANTIFLAG_SURA)
  7775. return false;
  7776. break;
  7777. #ifdef ENABLE_WOLFMAN_CHARACTER
  7778. case JOB_WOLFMAN:
  7779. if (item->GetAntiFlag() & ITEM_ANTIFLAG_WOLFMAN)
  7780. return false;
  7781. break;
  7782. #endif
  7783. }
  7784.  
  7785. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  7786. {
  7787. long limit = itemTable->aLimits[i].lValue;
  7788. switch (itemTable->aLimits[i].bType)
  7789. {
  7790. case LIMIT_LEVEL:
  7791. if (GetLevel() < limit)
  7792. {
  7793. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("·ąş§ŔĚ ł·ľĆ ÂřżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7794. return false;
  7795. }
  7796. break;
  7797.  
  7798. case LIMIT_STR:
  7799. if (GetPoint(POINT_ST) < limit)
  7800. {
  7801. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±Ů·ÂŔĚ ł·ľĆ ÂřżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7802. return false;
  7803. }
  7804. break;
  7805.  
  7806. case LIMIT_INT:
  7807. if (GetPoint(POINT_IQ) < limit)
  7808. {
  7809. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Áö´ÉŔĚ ł·ľĆ ÂřżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7810. return false;
  7811. }
  7812. break;
  7813.  
  7814. case LIMIT_DEX:
  7815. if (GetPoint(POINT_DX) < limit)
  7816. {
  7817. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ąÎøŔĚ ł·ľĆ ÂřżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7818. return false;
  7819. }
  7820. break;
  7821.  
  7822. case LIMIT_CON:
  7823. if (GetPoint(POINT_HT) < limit)
  7824. {
  7825. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ĂĽ·ÂŔĚ ł·ľĆ ÂřżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7826. return false;
  7827. }
  7828. break;
  7829. }
  7830. }
  7831.  
  7832. if (item->GetWearFlag() & WEARABLE_UNIQUE)
  7833. {
  7834. if ((GetWear(WEAR_UNIQUE1) && GetWear(WEAR_UNIQUE1)->IsSameSpecialGroup(item)) ||
  7835. (GetWear(WEAR_UNIQUE2) && GetWear(WEAR_UNIQUE2)->IsSameSpecialGroup(item)))
  7836. {
  7837. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°°Ŕş Áľ·ůŔÇ ŔŻ´ĎĹ© ľĆŔĚĹŰ µÎ °ł¸¦ µż˝Ăżˇ ŔĺÂřÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7838. return false;
  7839. }
  7840.  
  7841. if (marriage::CManager::instance().IsMarriageUniqueItem(item->GetVnum()) &&
  7842. !marriage::CManager::instance().IsMarried(GetPlayerID()))
  7843. {
  7844. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°áČĄÇĎÁö ľĘŔş »óĹÂżˇĽ­ żąą°Ŕ» ÂřżëÇŇ Ľö ľř˝Ŕ´Ď´Ů."));
  7845. return false;
  7846. }
  7847.  
  7848. }
  7849.  
  7850. return true;
  7851. }
  7852.  
  7853.  
  7854. bool CHARACTER::CanUnequipNow(const LPITEM item, const TItemPos& srcCell, const TItemPos& destCell) /*const*/
  7855. {
  7856.  
  7857. if (ITEM_BELT == item->GetType())
  7858. VERIFY_MSG(CBeltInventoryHelper::IsExistItemInBeltInventory(this), "ş§Ć® ŔÎşĄĹ丮żˇ ľĆŔĚĹŰŔĚ Á¸ŔçÇϸé ÇŘÁ¦ÇŇ Ľö ľř˝Ŕ´Ď´Ů.");
  7859.  
  7860.  
  7861. if (IS_SET(item->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  7862. return false;
  7863.  
  7864.  
  7865. {
  7866. int pos = -1;
  7867.  
  7868. if (item->IsDragonSoul())
  7869. pos = GetEmptyDragonSoulInventory(item);
  7870. else
  7871. pos = GetEmptyInventory(item->GetSize());
  7872.  
  7873. VERIFY_MSG( -1 == pos, "ĽŇÁöÇ°żˇ şó °ř°ŁŔĚ ľř˝Ŕ´Ď´Ů." );
  7874. }
  7875.  
  7876.  
  7877. return true;
  7878. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!