API tools faq
paste
eri000n

Untitled

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