API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jan 24th, 2017
97
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 187.05 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2. #include <stack>
  3. #include "utils.h"
  4. #include "config.h"
  5. #include "char.h"
  6. #include "char_manager.h"
  7. #include "item_manager.h"
  8. #include "desc.h"
  9. #include "desc_client.h"
  10. #include "desc_manager.h"
  11. #include "packet.h"
  12. #include "affect.h"
  13. #include "skill.h"
  14. #include "start_position.h"
  15. #include "mob_manager.h"
  16. #include "db.h"
  17. #include "log.h"
  18. #include "vector.h"
  19. #include "buffer_manager.h"
  20. #include "questmanager.h"
  21. #include "fishing.h"
  22. #include "party.h"
  23. #include "dungeon.h"
  24. #include "refine.h"
  25. #include "unique_item.h"
  26. #include "war_map.h"
  27. #include "xmas_event.h"
  28. #include "marriage.h"
  29. #include "monarch.h"
  30. #include "polymorph.h"
  31. #include "blend_item.h"
  32. #include "castle.h"
  33. #include "BattleArena.h"
  34. #include "arena.h"
  35. #include "threeway_war.h"
  36. #include "safebox.h"
  37. #include "shop.h"
  38. #include "../../common/VnumHelper.h"
  39. #include "DragonSoul.h"
  40. #include "buff_on_attributes.h"
  41. #include "belt.h"
  42.  
  43. const int ITEM_BROKEN_METIN_VNUM = 28960;
  44. const BYTE g_aBuffOnAttrPoints[] = { POINT_ENERGY, POINT_COSTUME_ATTR_BONUS };
  45.  
  46. struct FFindStone {
  47. std::map<DWORD, LPCHARACTER> m_mapStone;
  48.  
  49. void operator()(LPENTITY pEnt) {
  50. if (pEnt->IsType(ENTITY_CHARACTER) == true) {
  51. LPCHARACTER pChar = (LPCHARACTER)pEnt;
  52.  
  53. if (pChar->IsStone() == true) {
  54. m_mapStone[(DWORD)pChar->GetVID()] = pChar;
  55. }
  56. }
  57. }
  58. };
  59.  
  60. static bool IS_SUMMON_ITEM(int vnum) {
  61. switch (vnum) {
  62. case 22000:
  63. case 22010:
  64. case 22011:
  65. case 22020:
  66. case ITEM_MARRIAGE_RING:
  67. return true;
  68. }
  69.  
  70. return false;
  71. }
  72.  
  73. static bool IS_MONKEY_DUNGEON(int map_index) {
  74. switch (map_index) {
  75. case 5:
  76. case 25:
  77. case 45:
  78. case 108:
  79. case 109:
  80. return true;;
  81. }
  82.  
  83. return false;
  84. }
  85.  
  86. bool IS_SUMMONABLE_ZONE(int map_index) {
  87. if (IS_MONKEY_DUNGEON(map_index))
  88. return false;
  89. if (IS_CASTLE_MAP(map_index))
  90. return false;
  91.  
  92. switch (map_index) {
  93. case 66 :
  94. case 71 :
  95. case 72 :
  96. case 73 :
  97. case 193 :
  98. #if 0
  99. case 184 :
  100. case 185 :
  101. case 186 :
  102. case 187 :
  103. case 188 :
  104. case 189 :
  105. #endif
  106. case 216 :
  107. case 217 :
  108. case 208 :
  109. return false;
  110. }
  111.  
  112. if (CBattleArena::IsBattleArenaMap(map_index)) return false;
  113.  
  114. if (map_index > 10000)
  115. return false;
  116.  
  117. return true;
  118. }
  119.  
  120. bool IS_BOTARYABLE_ZONE(int nMapIndex) {
  121. return true;
  122.  
  123. switch (nMapIndex) {
  124. case 1 :
  125. case 3 :
  126. case 21 :
  127. case 23 :
  128. case 41 :
  129. case 43 :
  130. return true;
  131. }
  132.  
  133. return false;
  134. }
  135.  
  136. static bool FN_check_item_socket(LPITEM item) {
  137. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i) {
  138. if (item->GetSocket(i) != item->GetProto()->alSockets[i])
  139. return false;
  140. }
  141.  
  142. return true;
  143. }
  144.  
  145. static void FN_copy_item_socket(LPITEM dest, LPITEM src) {
  146. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i) {
  147. dest->SetSocket(i, src->GetSocket(i));
  148. }
  149. }
  150. static bool FN_check_item_sex(LPCHARACTER ch, LPITEM item) {
  151.  
  152. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_MALE)) {
  153. if (SEX_MALE==GET_SEX(ch))
  154. return false;
  155. }
  156.  
  157. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_FEMALE)) {
  158. if (SEX_FEMALE==GET_SEX(ch))
  159. return false;
  160. }
  161.  
  162. return true;
  163. }
  164.  
  165. bool CHARACTER::CanHandleItem(bool bSkipCheckRefine, bool bSkipObserver) {
  166. if (!bSkipObserver)
  167. if (m_bIsObserver)
  168. return false;
  169.  
  170. if (GetMyShop())
  171. return false;
  172.  
  173. if (!bSkipCheckRefine)
  174. if (m_bUnderRefine)
  175. return false;
  176.  
  177. if (IsCubeOpen() || NULL != DragonSoul_RefineWindow_GetOpener())
  178. return false;
  179.  
  180. if (IsAcceOpen() || IsCubeOpen() || DragonSoul_RefineWindow_GetOpener() != NULL)
  181. return false;
  182.  
  183. if (IsWarping())
  184. return false;
  185.  
  186. return true;
  187. }
  188.  
  189. LPITEM CHARACTER::GetInventoryItem(WORD wCell) const {
  190. return GetItem(TItemPos(INVENTORY, wCell));
  191. }
  192. LPITEM CHARACTER::GetItem(TItemPos Cell) const {
  193. if (!IsValidItemPosition(Cell))
  194. return NULL;
  195. WORD wCell = Cell.cell;
  196. BYTE window_type = Cell.window_type;
  197. switch (window_type) {
  198. case INVENTORY:
  199. case EQUIPMENT:
  200. if (wCell >= INVENTORY_AND_EQUIP_SLOT_MAX) {
  201. sys_err("CHARACTER::GetInventoryItem: invalid item cell %d", wCell);
  202. return NULL;
  203. }
  204. return m_pointsInstant.pItems[wCell];
  205. case DRAGON_SOUL_INVENTORY:
  206. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM) {
  207. sys_err("CHARACTER::GetInventoryItem: invalid DS item cell %d", wCell);
  208. return NULL;
  209. }
  210. return m_pointsInstant.pDSItems[wCell];
  211.  
  212. default:
  213. return NULL;
  214. }
  215. return NULL;
  216. }
  217.  
  218. void CHARACTER::SetItem(TItemPos Cell, LPITEM pItem) {
  219. WORD wCell = Cell.cell;
  220. BYTE window_type = Cell.window_type;
  221. if ((unsigned long)((CItem*)pItem) == 0xff || (unsigned long)((CItem*)pItem) == 0xffffffff) {
  222. sys_err("!!! FATAL ERROR !!! item == 0xff (char: %s cell: %u)", GetName(), wCell);
  223. core_dump();
  224. return;
  225. }
  226.  
  227. if (pItem && pItem->GetOwner()) {
  228. assert(!"GetOwner exist");
  229. return;
  230. }
  231. switch(window_type) {
  232. case INVENTORY:
  233. case EQUIPMENT: {
  234. if (wCell >= INVENTORY_AND_EQUIP_SLOT_MAX) {
  235. sys_err("CHARACTER::SetItem: invalid item cell %d", wCell);
  236. return;
  237. }
  238.  
  239. LPITEM pOld = m_pointsInstant.pItems[wCell];
  240.  
  241. if (pOld) {
  242. if (wCell < INVENTORY_MAX_NUM) {
  243. for (int i = 0; i < pOld->GetSize(); ++i) {
  244. int p = wCell + (i * 5);
  245.  
  246. if (p >= INVENTORY_MAX_NUM)
  247. continue;
  248.  
  249. if (m_pointsInstant.pItems[p] && m_pointsInstant.pItems[p] != pOld)
  250. continue;
  251.  
  252. m_pointsInstant.bItemGrid[p] = 0;
  253. }
  254. } else
  255. m_pointsInstant.bItemGrid[wCell] = 0;
  256. }
  257.  
  258. if (pItem) {
  259. if (wCell < INVENTORY_MAX_NUM) {
  260. for (int i = 0; i < pItem->GetSize(); ++i) {
  261. int p = wCell + (i * 5);
  262.  
  263. if (p >= INVENTORY_MAX_NUM)
  264. continue;
  265.  
  266. m_pointsInstant.bItemGrid[p] = wCell + 1;
  267. }
  268. } else
  269. m_pointsInstant.bItemGrid[wCell] = wCell + 1;
  270. }
  271.  
  272. m_pointsInstant.pItems[wCell] = pItem;
  273. }
  274. break;
  275.  
  276. case DRAGON_SOUL_INVENTORY: {
  277. LPITEM pOld = m_pointsInstant.pDSItems[wCell];
  278.  
  279. if (pOld) {
  280. if (wCell < DRAGON_SOUL_INVENTORY_MAX_NUM) {
  281. for (int i = 0; i < pOld->GetSize(); ++i) {
  282. int p = wCell + (i * DRAGON_SOUL_BOX_COLUMN_NUM);
  283.  
  284. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  285. continue;
  286.  
  287. if (m_pointsInstant.pDSItems[p] && m_pointsInstant.pDSItems[p] != pOld)
  288. continue;
  289.  
  290. m_pointsInstant.wDSItemGrid[p] = 0;
  291. }
  292. } else
  293. m_pointsInstant.wDSItemGrid[wCell] = 0;
  294. }
  295.  
  296. if (pItem) {
  297. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM) {
  298. sys_err("CHARACTER::SetItem: invalid DS item cell %d", wCell);
  299. return;
  300. }
  301.  
  302. if (wCell < DRAGON_SOUL_INVENTORY_MAX_NUM) {
  303. for (int i = 0; i < pItem->GetSize(); ++i) {
  304. int p = wCell + (i * DRAGON_SOUL_BOX_COLUMN_NUM);
  305.  
  306. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  307. continue;
  308.  
  309. m_pointsInstant.wDSItemGrid[p] = wCell + 1;
  310. }
  311. } else
  312. m_pointsInstant.wDSItemGrid[wCell] = wCell + 1;
  313. }
  314.  
  315. m_pointsInstant.pDSItems[wCell] = pItem;
  316. }
  317. break;
  318. default:
  319. sys_err ("Invalid Inventory type %d", window_type);
  320. return;
  321. }
  322.  
  323. if (GetDesc()) {
  324. if (pItem) {
  325. TPacketGCItemSet pack;
  326. pack.header = HEADER_GC_ITEM_SET;
  327. pack.Cell = Cell;
  328.  
  329. pack.count = pItem->GetCount();
  330. pack.vnum = pItem->GetVnum();
  331. pack.flags = pItem->GetFlag();
  332. pack.anti_flags = pItem->GetAntiFlag();
  333. pack.highlight = (Cell.window_type == DRAGON_SOUL_INVENTORY);
  334.  
  335.  
  336. thecore_memcpy(pack.alSockets, pItem->GetSockets(), sizeof(pack.alSockets));
  337. thecore_memcpy(pack.aAttr, pItem->GetAttributes(), sizeof(pack.aAttr));
  338.  
  339. GetDesc()->Packet(&pack, sizeof(TPacketGCItemSet));
  340. } else {
  341. TPacketGCItemDelDeprecated pack;
  342. pack.header = HEADER_GC_ITEM_DEL;
  343. pack.Cell = Cell;
  344. pack.count = 0;
  345. pack.vnum = 0;
  346. memset(pack.alSockets, 0, sizeof(pack.alSockets));
  347. memset(pack.aAttr, 0, sizeof(pack.aAttr));
  348.  
  349. GetDesc()->Packet(&pack, sizeof(TPacketGCItemDelDeprecated));
  350. }
  351. }
  352.  
  353. if (pItem) {
  354. pItem->SetCell(this, wCell);
  355. switch (window_type) {
  356. case INVENTORY:
  357. case EQUIPMENT:
  358. if ((wCell < INVENTORY_MAX_NUM) || (BELT_INVENTORY_SLOT_START <= wCell && BELT_INVENTORY_SLOT_END > wCell))
  359. pItem->SetWindow(INVENTORY);
  360. else
  361. pItem->SetWindow(EQUIPMENT);
  362. break;
  363. case DRAGON_SOUL_INVENTORY:
  364. pItem->SetWindow(DRAGON_SOUL_INVENTORY);
  365. break;
  366. }
  367. }
  368. }
  369.  
  370. LPITEM CHARACTER::GetWear(BYTE bCell) const {
  371. if (bCell >= WEAR_MAX_NUM + DRAGON_SOUL_DECK_MAX_NUM * DS_SLOT_MAX) {
  372. sys_err("CHARACTER::GetWear: invalid wear cell %d", bCell);
  373. return NULL;
  374. }
  375.  
  376. return m_pointsInstant.pItems[INVENTORY_MAX_NUM + bCell];
  377. }
  378.  
  379. void CHARACTER::SetWear(BYTE bCell, LPITEM item) {
  380. if (bCell >= WEAR_MAX_NUM + DRAGON_SOUL_DECK_MAX_NUM * DS_SLOT_MAX) {
  381. sys_err("CHARACTER::SetItem: invalid item cell %d", bCell);
  382. return;
  383. }
  384.  
  385. SetItem(TItemPos (INVENTORY, INVENTORY_MAX_NUM + bCell), item);
  386.  
  387. if (!item && bCell == WEAR_WEAPON) {
  388. if (IsAffectFlag(AFF_GWIGUM))
  389. RemoveAffect(SKILL_GWIGEOM);
  390.  
  391. if (IsAffectFlag(AFF_GEOMGYEONG))
  392. RemoveAffect(SKILL_GEOMKYUNG);
  393. }
  394. }
  395.  
  396. void CHARACTER::ClearItem() {
  397. int i;
  398. LPITEM item;
  399.  
  400. for (i = 0; i < INVENTORY_AND_EQUIP_SLOT_MAX; ++i) {
  401. if ((item = GetInventoryItem(i))) {
  402. item->SetSkipSave(true);
  403. ITEM_MANAGER::instance().FlushDelayedSave(item);
  404.  
  405. item->RemoveFromCharacter();
  406. M2_DESTROY_ITEM(item);
  407.  
  408. SyncQuickslot(QUICKSLOT_TYPE_ITEM, i, 255);
  409. }
  410. }
  411. for (i = 0; i < DRAGON_SOUL_INVENTORY_MAX_NUM; ++i) {
  412. if ((item = GetItem(TItemPos(DRAGON_SOUL_INVENTORY, i)))) {
  413. item->SetSkipSave(true);
  414. ITEM_MANAGER::instance().FlushDelayedSave(item);
  415.  
  416. item->RemoveFromCharacter();
  417. M2_DESTROY_ITEM(item);
  418. }
  419. }
  420. }
  421.  
  422. bool CHARACTER::IsEmptyItemGrid(TItemPos Cell, BYTE bSize, int iExceptionCell) const {
  423. switch (Cell.window_type) {
  424. case INVENTORY: {
  425. BYTE bCell = Cell.cell;
  426.  
  427. ++iExceptionCell;
  428.  
  429. if (Cell.IsBeltInventoryPosition()) {
  430. LPITEM beltItem = GetWear(WEAR_BELT);
  431.  
  432. if (NULL == beltItem)
  433. return false;
  434.  
  435. if (false == CBeltInventoryHelper::IsAvailableCell(bCell - BELT_INVENTORY_SLOT_START, beltItem->GetValue(0)))
  436. return false;
  437.  
  438. if (m_pointsInstant.bItemGrid[bCell]) {
  439. if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell)
  440. return true;
  441.  
  442. return false;
  443. }
  444.  
  445. if (bSize == 1)
  446. return true;
  447.  
  448. } else if (bCell >= INVENTORY_MAX_NUM)
  449. return false;
  450.  
  451. if (m_pointsInstant.bItemGrid[bCell]) {
  452. if (m_pointsInstant.bItemGrid[bCell] == iExceptionCell) {
  453. if (bSize == 1)
  454. return true;
  455.  
  456. int j = 1;
  457. BYTE bPage = bCell / (INVENTORY_MAX_NUM / 5);
  458.  
  459. do {
  460. BYTE p = bCell + (5 * j);
  461.  
  462. if (p >= INVENTORY_MAX_NUM)
  463. return false;
  464.  
  465. if (p / (INVENTORY_MAX_NUM / 5) != bPage)
  466. return false;
  467.  
  468. if (m_pointsInstant.bItemGrid[p])
  469. if (m_pointsInstant.bItemGrid[p] != iExceptionCell)
  470. return false;
  471. } while (++j < bSize);
  472.  
  473. return true;
  474. } else
  475. return false;
  476. }
  477.  
  478. if (1 == bSize)
  479. return true;
  480. else {
  481. int j = 1;
  482. BYTE bPage = bCell / (INVENTORY_MAX_NUM / 5);
  483.  
  484. do {
  485. BYTE p = bCell + (5 * j);
  486.  
  487. if (p >= INVENTORY_MAX_NUM)
  488. return false;
  489.  
  490. if (p / (INVENTORY_MAX_NUM / 5) != bPage)
  491. return false;
  492.  
  493. if (m_pointsInstant.bItemGrid[p])
  494. if (m_pointsInstant.bItemGrid[p] != iExceptionCell)
  495. return false;
  496. } while (++j < bSize);
  497.  
  498. return true;
  499. }
  500. }
  501. break;
  502. case DRAGON_SOUL_INVENTORY: {
  503. WORD wCell = Cell.cell;
  504. if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  505. return false;
  506.  
  507. iExceptionCell++;
  508.  
  509. if (m_pointsInstant.wDSItemGrid[wCell]) {
  510. if (m_pointsInstant.wDSItemGrid[wCell] == iExceptionCell) {
  511. if (bSize == 1)
  512. return true;
  513.  
  514. int j = 1;
  515.  
  516. do {
  517. BYTE p = wCell + (DRAGON_SOUL_BOX_COLUMN_NUM * j);
  518.  
  519. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  520. return false;
  521.  
  522. if (m_pointsInstant.wDSItemGrid[p])
  523. if (m_pointsInstant.wDSItemGrid[p] != iExceptionCell)
  524. return false;
  525. } while (++j < bSize);
  526.  
  527. return true;
  528. } else
  529. return false;
  530. }
  531.  
  532. if (1 == bSize)
  533. return true;
  534. else {
  535. int j = 1;
  536.  
  537. do {
  538. BYTE p = wCell + (DRAGON_SOUL_BOX_COLUMN_NUM * j);
  539.  
  540. if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  541. return false;
  542.  
  543. if (m_pointsInstant.bItemGrid[p])
  544. if (m_pointsInstant.wDSItemGrid[p] != iExceptionCell)
  545. return false;
  546. } while (++j < bSize);
  547.  
  548. return true;
  549. }
  550. }
  551. }
  552. }
  553.  
  554. int CHARACTER::GetEmptyInventory(BYTE size) const {
  555. for ( int i = 0; i < INVENTORY_MAX_NUM; ++i)
  556. if (IsEmptyItemGrid(TItemPos (INVENTORY, i), size))
  557. return i;
  558. return -1;
  559. }
  560.  
  561. int CHARACTER::GetEmptyDragonSoulInventory(LPITEM pItem) const {
  562. if (NULL == pItem || !pItem->IsDragonSoul())
  563. return -1;
  564. if (!DragonSoul_IsQualified()) {
  565. return -1;
  566. }
  567. BYTE bSize = pItem->GetSize();
  568. WORD wBaseCell = DSManager::instance().GetBasePosition(pItem);
  569.  
  570. if (WORD_MAX == wBaseCell)
  571. return -1;
  572.  
  573. for (int i = 0; i < DRAGON_SOUL_BOX_SIZE; ++i)
  574. if (IsEmptyItemGrid(TItemPos(DRAGON_SOUL_INVENTORY, i + wBaseCell), bSize))
  575. return i + wBaseCell;
  576.  
  577. return -1;
  578. }
  579.  
  580. void CHARACTER::CopyDragonSoulItemGrid(std::vector<WORD>& vDragonSoulItemGrid) const {
  581. vDragonSoulItemGrid.resize(DRAGON_SOUL_INVENTORY_MAX_NUM);
  582.  
  583. std::copy(m_pointsInstant.wDSItemGrid, m_pointsInstant.wDSItemGrid + DRAGON_SOUL_INVENTORY_MAX_NUM, vDragonSoulItemGrid.begin());
  584. }
  585.  
  586. int CHARACTER::CountEmptyInventory() const {
  587. int count = 0;
  588.  
  589. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  590. if (GetInventoryItem(i))
  591. count += GetInventoryItem(i)->GetSize();
  592.  
  593. return (INVENTORY_MAX_NUM - count);
  594. }
  595.  
  596. void TransformRefineItem(LPITEM pkOldItem, LPITEM pkNewItem) {
  597. if (pkOldItem->IsAccessoryForSocket()) {
  598. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i) {
  599. pkNewItem->SetSocket(i, pkOldItem->GetSocket(i));
  600. }
  601. } else {
  602. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i) {
  603. if (!pkOldItem->GetSocket(i))
  604. break;
  605. else
  606. pkNewItem->SetSocket(i, 1);
  607. }
  608.  
  609. int slot = 0;
  610.  
  611. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i) {
  612. long socket = pkOldItem->GetSocket(i);
  613.  
  614. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
  615. pkNewItem->SetSocket(slot++, socket);
  616. }
  617.  
  618. }
  619. pkOldItem->CopyAttributeTo(pkNewItem);
  620. }
  621.  
  622. void NotifyRefineSuccess(LPCHARACTER ch, LPITEM item, const char* way) {
  623. if (NULL != ch && item != NULL) {
  624. ch->ChatPacket(CHAT_TYPE_COMMAND, "RefineSuceeded");
  625.  
  626. LogManager::instance().RefineLog(ch->GetPlayerID(), item->GetName(), item->GetID(), item->GetRefineLevel(), 1, way);
  627. }
  628. }
  629.  
  630. void NotifyRefineFail(LPCHARACTER ch, LPITEM item, const char* way, int success = 0) {
  631. if (NULL != ch && NULL != item) {
  632. ch->ChatPacket(CHAT_TYPE_COMMAND, "RefineFailed");
  633.  
  634. LogManager::instance().RefineLog(ch->GetPlayerID(), item->GetName(), item->GetID(), item->GetRefineLevel(), success, way);
  635. }
  636. }
  637.  
  638. void CHARACTER::SetRefineNPC(LPCHARACTER ch) {
  639. if ( ch != NULL ) {
  640. m_dwRefineNPCVID = ch->GetVID();
  641. } else {
  642. m_dwRefineNPCVID = 0;
  643. }
  644. }
  645.  
  646. bool CHARACTER::DoRefine(LPITEM item, bool bMoneyOnly) {
  647. if (!CanHandleItem(true)) {
  648. ClearRefineMode();
  649. return false;
  650. }
  651.  
  652. if (quest::CQuestManager::instance().GetEventFlag("update_refine_time") != 0) {
  653. if (get_global_time() < quest::CQuestManager::instance().GetEventFlag("update_refine_time") + (60 * 5)) {
  654. sys_log(0, "can't refine %d %s", GetPlayerID(), GetName());
  655. return false;
  656. }
  657. }
  658.  
  659. const TRefineTable * prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
  660.  
  661. if (!prt)
  662. return false;
  663.  
  664. DWORD result_vnum = item->GetRefinedVnum();
  665. int cost = ComputeRefineFee(prt->cost);
  666. int RefineChance = GetQuestFlag("main_quest_lv7.refine_chance");
  667.  
  668. if (RefineChance > 0) {
  669. if (!item->CheckItemUseLevel(20) || item->GetType() != ITEM_WEAPON) {
  670. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¹«·á °³·® ±âȸ´Â 20 ÀÌÇÏÀÇ ¹«±â¸¸ °¡´ÉÇÕ´Ï´Ù"));
  671. return false;
  672. }
  673.  
  674. cost = 0;
  675. SetQuestFlag("main_quest_lv7.refine_chance", RefineChance - 1);
  676. }
  677.  
  678. if (result_vnum == 0) {
  679. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ÀÌ»ó °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  680. return false;
  681. }
  682.  
  683. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_TUNING)
  684. return false;
  685.  
  686. TItemTable * pProto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
  687.  
  688. if (!pProto) {
  689. sys_err("DoRefine NOT GET ITEM PROTO %d", item->GetRefinedVnum());
  690. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀº °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  691. return false;
  692. }
  693.  
  694. if (GetGold() < cost) {
  695. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°³·®À» Çϱâ À§ÇÑ µ·ÀÌ ºÎÁ·ÇÕ´Ï´Ù."));
  696. return false;
  697. }
  698.  
  699. if (!bMoneyOnly && !RefineChance) {
  700. for (int i = 0; i < prt->material_count; ++i) {
  701. if (CountSpecifyItem(prt->materials[i].vnum) < prt->materials[i].count) {
  702. if (test_server) {
  703. ChatPacket(CHAT_TYPE_INFO, "Find %d, count %d, require %d", prt->materials[i].vnum, CountSpecifyItem(prt->materials[i].vnum), prt->materials[i].count);
  704. }
  705. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°³·®À» Çϱâ À§ÇÑ Àç·á°¡ ºÎÁ·ÇÕ´Ï´Ù."));
  706. return false;
  707. }
  708. }
  709.  
  710. for (int i = 0; i < prt->material_count; ++i)
  711. RemoveSpecifyItem(prt->materials[i].vnum, prt->materials[i].count);
  712. }
  713.  
  714. int prob = number(1, 100);
  715.  
  716. if (IsRefineThroughGuild() || bMoneyOnly)
  717. prob -= 10;
  718.  
  719. if (prob <= prt->prob) {
  720. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
  721.  
  722. if (pkNewItem) {
  723. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  724. LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
  725.  
  726. BYTE bCell = item->GetCell();
  727.  
  728. NotifyRefineSuccess(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  729. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -cost);
  730. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
  731.  
  732. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  733. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  734.  
  735. sys_log(0, "Refine Success %d", cost);
  736. pkNewItem->AttrLog();
  737. sys_log(0, "PayPee %d", cost);
  738. PayRefineFee(cost);
  739. sys_log(0, "PayPee End %d", cost);
  740. } else {
  741.  
  742. sys_err("cannot create item %u", result_vnum);
  743. NotifyRefineFail(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  744. }
  745. } else {
  746. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -cost);
  747. NotifyRefineFail(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  748. item->AttrLog();
  749. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
  750. PayRefineFee(cost);
  751. }
  752.  
  753. return true;
  754. }
  755.  
  756. enum enum_RefineScrolls {
  757. CHUKBOK_SCROLL = 0,
  758. HYUNIRON_CHN = 1,
  759. YONGSIN_SCROLL = 2,
  760. MUSIN_SCROLL = 3,
  761. YAGONG_SCROLL = 4,
  762. MEMO_SCROLL = 5,
  763. BDRAGON_SCROLL = 6,
  764. ACCE_CLEAN_ATTR = 7,
  765. };
  766.  
  767. bool CHARACTER::DoRefineWithScroll(LPITEM item) {
  768. if (!CanHandleItem(true)) {
  769. ClearRefineMode();
  770. return false;
  771. }
  772.  
  773. ClearRefineMode();
  774.  
  775. if (quest::CQuestManager::instance().GetEventFlag("update_refine_time") != 0) {
  776. if (get_global_time() < quest::CQuestManager::instance().GetEventFlag("update_refine_time") + (60 * 5)) {
  777. sys_log(0, "can't refine %d %s", GetPlayerID(), GetName());
  778. return false;
  779. }
  780. }
  781.  
  782. const TRefineTable * prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
  783.  
  784. if (!prt)
  785. return false;
  786.  
  787. LPITEM pkItemScroll;
  788.  
  789. if (m_iRefineAdditionalCell < 0)
  790. return false;
  791.  
  792. pkItemScroll = GetInventoryItem(m_iRefineAdditionalCell);
  793.  
  794. if (!pkItemScroll)
  795. return false;
  796.  
  797. if (!(pkItemScroll->GetType() == ITEM_USE && pkItemScroll->GetSubType() == USE_TUNING))
  798. return false;
  799.  
  800. if (pkItemScroll->GetVnum() == item->GetVnum())
  801. return false;
  802.  
  803. DWORD result_vnum = item->GetRefinedVnum();
  804. DWORD result_fail_vnum = item->GetRefineFromVnum();
  805.  
  806. if (result_vnum == 0) {
  807. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ÀÌ»ó °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  808. return false;
  809. }
  810.  
  811. if (pkItemScroll->GetValue(0) == MUSIN_SCROLL) {
  812. if (item->GetRefineLevel() >= 4) {
  813. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ °³·®¼­·Î ´õ ÀÌ»ó °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  814. return false;
  815. }
  816. }
  817.  
  818. else if (pkItemScroll->GetValue(0) == MEMO_SCROLL) {
  819. if (item->GetRefineLevel() != pkItemScroll->GetValue(1)) {
  820. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ °³·®¼­·Î °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  821. return false;
  822. }
  823. } else if (pkItemScroll->GetValue(0) == BDRAGON_SCROLL) {
  824. if (item->GetType() != ITEM_METIN || item->GetRefineLevel() != 4) {
  825. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀ¸·Î °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  826. return false;
  827. }
  828. }
  829.  
  830. TItemTable * pProto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
  831.  
  832. if (!pProto) {
  833. sys_err("DoRefineWithScroll NOT GET ITEM PROTO %d", item->GetRefinedVnum());
  834. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀº °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  835. return false;
  836. }
  837.  
  838. if (GetGold() < prt->cost) {
  839. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°³·®À» Çϱâ À§ÇÑ µ·ÀÌ ºÎÁ·ÇÕ´Ï´Ù."));
  840. return false;
  841. }
  842.  
  843. for (int i = 0; i < prt->material_count; ++i) {
  844. if (CountSpecifyItem(prt->materials[i].vnum) < prt->materials[i].count) {
  845. if (test_server) {
  846. ChatPacket(CHAT_TYPE_INFO, "Find %d, count %d, require %d", prt->materials[i].vnum, CountSpecifyItem(prt->materials[i].vnum), prt->materials[i].count);
  847. }
  848. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°³·®À» Çϱâ À§ÇÑ Àç·á°¡ ºÎÁ·ÇÕ´Ï´Ù."));
  849. return false;
  850. }
  851. }
  852.  
  853. for (int i = 0; i < prt->material_count; ++i)
  854. RemoveSpecifyItem(prt->materials[i].vnum, prt->materials[i].count);
  855.  
  856. int prob = number(1, 100);
  857. int success_prob = prt->prob;
  858. bool bDestroyWhenFail = false;
  859.  
  860. const char* szRefineType = "SCROLL";
  861.  
  862. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN || pkItemScroll->GetValue(0) == YONGSIN_SCROLL || pkItemScroll->GetValue(0) == YAGONG_SCROLL) {
  863. const char hyuniron_prob[9] = { 100, 75, 65, 55, 45, 40, 35, 25, 20 };
  864. const char hyuniron_prob_euckr[9] = { 100, 75, 65, 55, 45, 40, 35, 30, 25 };
  865.  
  866. const char yagong_prob[9] = { 100, 100, 90, 80, 70, 60, 50, 30, 20 };
  867. const char yagong_prob_euckr[9] = { 100, 100, 90, 80, 70, 60, 50, 40, 30 };
  868.  
  869. if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL) {
  870. success_prob = hyuniron_prob[MINMAX(0, item->GetRefineLevel(), 8)];
  871. } else if (pkItemScroll->GetValue(0) == YAGONG_SCROLL) {
  872. success_prob = yagong_prob[MINMAX(0, item->GetRefineLevel(), 8)];
  873. }
  874.  
  875. if (test_server) {
  876. ChatPacket(CHAT_TYPE_INFO, "[Only Test] Success_Prob %d, RefineLevel %d ", success_prob, item->GetRefineLevel());
  877. }
  878. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN)
  879. bDestroyWhenFail = true;
  880.  
  881. if (pkItemScroll->GetValue(0) == HYUNIRON_CHN) {
  882. szRefineType = "HYUNIRON";
  883. } else if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL) {
  884. szRefineType = "GOD_SCROLL";
  885. } else if (pkItemScroll->GetValue(0) == YAGONG_SCROLL) {
  886. szRefineType = "YAGONG_SCROLL";
  887. }
  888. }
  889.  
  890. if (pkItemScroll->GetValue(0) == MUSIN_SCROLL) {
  891. success_prob = 100;
  892.  
  893. szRefineType = "MUSIN_SCROLL";
  894. } else if (pkItemScroll->GetValue(0) == MEMO_SCROLL) {
  895. success_prob = 100;
  896. szRefineType = "MEMO_SCROLL";
  897. } else if (pkItemScroll->GetValue(0) == BDRAGON_SCROLL) {
  898. success_prob = 80;
  899. szRefineType = "BDRAGON_SCROLL";
  900. }
  901.  
  902. pkItemScroll->SetCount(pkItemScroll->GetCount() - 1);
  903.  
  904. if (prob <= success_prob) {
  905. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
  906.  
  907. if (pkNewItem) {
  908. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  909. LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
  910.  
  911. BYTE bCell = item->GetCell();
  912.  
  913. NotifyRefineSuccess(this, item, szRefineType);
  914. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -prt->cost);
  915. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
  916.  
  917. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  918. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  919. pkNewItem->AttrLog();
  920. PayRefineFee(prt->cost);
  921. } else {
  922. sys_err("cannot create item %u", result_vnum);
  923. NotifyRefineFail(this, item, szRefineType);
  924. }
  925. } else if (!bDestroyWhenFail && result_fail_vnum) {
  926. LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_fail_vnum, 1, 0, false);
  927.  
  928. if (pkNewItem) {
  929. ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  930. LogManager::instance().ItemLog(this, pkNewItem, "REFINE FAIL", pkNewItem->GetName());
  931.  
  932. BYTE bCell = item->GetCell();
  933.  
  934. DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -prt->cost);
  935. NotifyRefineFail(this, item, szRefineType, -1);
  936. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
  937.  
  938. pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  939. ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  940.  
  941. pkNewItem->AttrLog();
  942. PayRefineFee(prt->cost);
  943. } else {
  944. sys_err("cannot create item %u", result_fail_vnum);
  945. NotifyRefineFail(this, item, szRefineType);
  946. }
  947. } else {
  948. NotifyRefineFail(this, item, szRefineType);
  949.  
  950. PayRefineFee(prt->cost);
  951. }
  952.  
  953. return true;
  954. }
  955.  
  956. bool CHARACTER::RefineInformation(BYTE bCell, BYTE bType, int iAdditionalCell) {
  957. if (bCell > INVENTORY_MAX_NUM)
  958. return false;
  959.  
  960. LPITEM item = GetInventoryItem(bCell);
  961.  
  962. if (!item)
  963. return false;
  964.  
  965. if (bType == REFINE_TYPE_MONEY_ONLY && !GetQuestFlag("deviltower_zone.can_refine")) {
  966. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»ç±Í Ÿ¿ö ¿Ï·á º¸»óÀº Çѹø±îÁö »ç¿ë°¡´ÉÇÕ´Ï´Ù."));
  967. return false;
  968. }
  969.  
  970. TPacketGCRefineInformation p;
  971.  
  972. p.header = HEADER_GC_REFINE_INFORMATION;
  973. p.pos = bCell;
  974. p.src_vnum = item->GetVnum();
  975. p.result_vnum = item->GetRefinedVnum();
  976. p.type = bType;
  977.  
  978. if (p.result_vnum == 0) {
  979. sys_err("RefineInformation p.result_vnum == 0");
  980. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀº °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  981. return false;
  982. }
  983.  
  984. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_TUNING) {
  985. if (bType == 0) {
  986. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀº ÀÌ ¹æ½ÄÀ¸·Î´Â °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  987. return false;
  988. } else {
  989. LPITEM itemScroll = GetInventoryItem(iAdditionalCell);
  990. if (!itemScroll || item->GetVnum() == itemScroll->GetVnum()) {
  991. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°°Àº °³·®¼­¸¦ ÇÕÄ¥ ¼ö´Â ¾ø½À´Ï´Ù."));
  992. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÃູÀÇ ¼­¿Í ÇööÀ» ÇÕÄ¥ ¼ö ÀÖ½À´Ï´Ù."));
  993. return false;
  994. }
  995. }
  996. }
  997.  
  998. CRefineManager & rm = CRefineManager::instance();
  999.  
  1000. const TRefineTable* prt = rm.GetRefineRecipe(item->GetRefineSet());
  1001.  
  1002. if (!prt) {
  1003. sys_err("RefineInformation NOT GET REFINE SET %d", item->GetRefineSet());
  1004. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀº °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  1005. return false;
  1006. }
  1007.  
  1008. if (GetQuestFlag("main_quest_lv7.refine_chance") > 0) {
  1009. if (!item->CheckItemUseLevel(20) || item->GetType() != ITEM_WEAPON) {
  1010. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¹«·á °³·® ±âȸ´Â 20 ÀÌÇÏÀÇ ¹«±â¸¸ °¡´ÉÇÕ´Ï´Ù"));
  1011. return false;
  1012. }
  1013. p.cost = 0;
  1014. } else
  1015. p.cost = ComputeRefineFee(prt->cost);
  1016.  
  1017. p.prob = prt->prob;
  1018. if (bType == REFINE_TYPE_MONEY_ONLY) {
  1019. p.material_count = 0;
  1020. memset(p.materials, 0, sizeof(p.materials));
  1021. } else {
  1022. p.material_count = prt->material_count;
  1023. thecore_memcpy(&p.materials, prt->materials, sizeof(prt->materials));
  1024. }
  1025.  
  1026. GetDesc()->Packet(&p, sizeof(TPacketGCRefineInformation));
  1027.  
  1028. SetRefineMode(iAdditionalCell);
  1029. return true;
  1030. }
  1031.  
  1032. bool CHARACTER::RefineItem(LPITEM pkItem, LPITEM pkTarget) {
  1033. if (!CanHandleItem())
  1034. return false;
  1035.  
  1036. if (pkItem->GetSubType() == USE_TUNING) {
  1037.  
  1038. if (pkItem->GetValue(0) == MUSIN_SCROLL)
  1039. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_MUSIN, pkItem->GetCell());
  1040. else if (pkItem->GetValue(0) == HYUNIRON_CHN)
  1041. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_HYUNIRON, pkItem->GetCell());
  1042. else if (pkItem->GetValue(0) == BDRAGON_SCROLL) {
  1043. if (pkTarget->GetRefineSet() != 702) return false;
  1044. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_BDRAGON, pkItem->GetCell());
  1045. } else {
  1046. if (pkTarget->GetRefineSet() == 501) return false;
  1047. RefineInformation(pkTarget->GetCell(), REFINE_TYPE_SCROLL, pkItem->GetCell());
  1048. }
  1049. } else if (pkItem->GetSubType() == USE_DETACHMENT && IS_SET(pkTarget->GetFlag(), ITEM_FLAG_REFINEABLE)) {
  1050. LogManager::instance().ItemLog(this, pkTarget, "USE_DETACHMENT", pkTarget->GetName());
  1051.  
  1052. bool bHasMetinStone = false;
  1053.  
  1054. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; i++) {
  1055. long socket = pkTarget->GetSocket(i);
  1056. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM) {
  1057. bHasMetinStone = true;
  1058. break;
  1059. }
  1060. }
  1061.  
  1062. if (bHasMetinStone) {
  1063. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i) {
  1064. long socket = pkTarget->GetSocket(i);
  1065. if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM) {
  1066. AutoGiveItem(socket);
  1067. pkTarget->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
  1068. }
  1069. }
  1070. pkItem->SetCount(pkItem->GetCount() - 1);
  1071. return true;
  1072. } else {
  1073. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»©³¾ ¼ö ÀÖ´Â ¸Þƾ¼®ÀÌ ¾ø½À´Ï´Ù."));
  1074. return false;
  1075. }
  1076. }
  1077.  
  1078. return false;
  1079. }
  1080.  
  1081. bool CHARACTER::CleanAcceAttr(LPITEM pkItem, LPITEM pkTarget)
  1082. {
  1083. if (!CanHandleItem())
  1084. return false;
  1085.  
  1086. if (pkTarget->GetType() != ITEM_COSTUME && pkTarget->GetSubType() != COSTUME_ACCE)
  1087. return false;
  1088.  
  1089. if (pkTarget->GetAcceAttributeCount() < 1)
  1090. return false;
  1091.  
  1092. if (pkItem->GetValue(0) == ACCE_CLEAN_ATTR)
  1093. {
  1094. LogManager::instance().ItemLog(this, pkTarget, "USE_DETACHMENT", pkTarget->GetName());
  1095. pkTarget->SetForceAttribute(0, 0, 0);
  1096. pkTarget->SetForceAttribute(1, 0, 0);
  1097. pkTarget->SetForceAttribute(2, 0, 0);
  1098. pkTarget->SetForceAttribute(3, 0, 0);
  1099. pkTarget->SetForceAttribute(4, 0, 0);
  1100. pkTarget->SetForceAttribute(5, 0, 0);
  1101. pkTarget->SetForceAttribute(6, 0, 0);
  1102. pkTarget->SetForceAttribute(7, 0, 0);
  1103. pkTarget->SetForceAttribute(8, 0, 0);
  1104. pkTarget->SetForceAttribute(9, 0, 0);
  1105. pkTarget->SetForceAttribute(10, 0, 0);
  1106. pkTarget->SetForceAttribute(11, 0, 0);
  1107. pkTarget->SetForceAttribute(12, 0, 0);
  1108. pkTarget->SetForceAttribute(13, 0, 0);
  1109. pkTarget->SetForceAttribute(14, 0, 0);
  1110. pkItem->SetCount(pkItem->GetCount() - 1);
  1111. return true;
  1112. }
  1113.  
  1114. return false;
  1115. }
  1116.  
  1117. EVENTFUNC(kill_campfire_event) {
  1118. char_event_info* info = dynamic_cast<char_event_info*>( event->info );
  1119.  
  1120. if ( info == NULL ) {
  1121. sys_err( "kill_campfire_event> <Factor> Null pointer" );
  1122. return 0;
  1123. }
  1124.  
  1125. LPCHARACTER ch = info->ch;
  1126.  
  1127. if (ch == NULL) {
  1128. return 0;
  1129. }
  1130. ch->m_pkMiningEvent = NULL;
  1131. M2_DESTROY_CHARACTER(ch);
  1132. return 0;
  1133. }
  1134.  
  1135. bool CHARACTER::GiveRecallItem(LPITEM item) {
  1136. int idx = GetMapIndex();
  1137. int iEmpireByMapIndex = -1;
  1138.  
  1139. if (idx < 20)
  1140. iEmpireByMapIndex = 1;
  1141. else if (idx < 40)
  1142. iEmpireByMapIndex = 2;
  1143. else if (idx < 60)
  1144. iEmpireByMapIndex = 3;
  1145. else if (idx < 10000)
  1146. iEmpireByMapIndex = 0;
  1147.  
  1148. switch (idx) {
  1149. case 66:
  1150. case 216:
  1151. iEmpireByMapIndex = -1;
  1152. break;
  1153. }
  1154.  
  1155. if (iEmpireByMapIndex && GetEmpire() != iEmpireByMapIndex) {
  1156. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±â¾ïÇØ µÑ ¼ö ¾ø´Â À§Ä¡ ÀÔ´Ï´Ù."));
  1157. return false;
  1158. }
  1159.  
  1160. int pos;
  1161.  
  1162. if (item->GetCount() == 1) {
  1163. item->SetSocket(0, GetX());
  1164. item->SetSocket(1, GetY());
  1165. } else if ((pos = GetEmptyInventory(item->GetSize())) != -1) {
  1166. LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), 1);
  1167.  
  1168. if (NULL != item2) {
  1169. item2->SetSocket(0, GetX());
  1170. item2->SetSocket(1, GetY());
  1171. item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
  1172.  
  1173. item->SetCount(item->GetCount() - 1);
  1174. }
  1175. } else {
  1176. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ÒÁöÇ°¿¡ ºó °ø°£ÀÌ ¾ø½À´Ï´Ù."));
  1177. return false;
  1178. }
  1179.  
  1180. return true;
  1181. }
  1182.  
  1183. void CHARACTER::ProcessRecallItem(LPITEM item) {
  1184. int idx;
  1185.  
  1186. if ((idx = SECTREE_MANAGER::instance().GetMapIndex(item->GetSocket(0), item->GetSocket(1))) == 0)
  1187. return;
  1188.  
  1189. int iEmpireByMapIndex = -1;
  1190.  
  1191. if (idx < 20)
  1192. iEmpireByMapIndex = 1;
  1193. else if (idx < 40)
  1194. iEmpireByMapIndex = 2;
  1195. else if (idx < 60)
  1196. iEmpireByMapIndex = 3;
  1197. else if (idx < 10000)
  1198. iEmpireByMapIndex = 0;
  1199.  
  1200. switch (idx) {
  1201. case 66:
  1202. case 216:
  1203. iEmpireByMapIndex = -1;
  1204. break;
  1205. case 301:
  1206. case 302:
  1207. case 303:
  1208. case 304:
  1209. if( GetLevel() < 90 ) {
  1210. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛÀÇ ·¹º§ Á¦ÇѺ¸´Ù ·¹º§ÀÌ ³·½À´Ï´Ù."));
  1211. return;
  1212. } else
  1213. break;
  1214. }
  1215.  
  1216. if (iEmpireByMapIndex && GetEmpire() != iEmpireByMapIndex) {
  1217. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±â¾ïµÈ À§Ä¡°¡ ŸÁ¦±¹¿¡ ¼ÓÇØ À־ ±ÍȯÇÒ ¼ö ¾ø½À´Ï´Ù."));
  1218. item->SetSocket(0, 0);
  1219. item->SetSocket(1, 0);
  1220. } else {
  1221. sys_log(1, "Recall: %s %d %d -> %d %d", GetName(), GetX(), GetY(), item->GetSocket(0), item->GetSocket(1));
  1222. WarpSet(item->GetSocket(0), item->GetSocket(1));
  1223. item->SetCount(item->GetCount() - 1);
  1224. }
  1225. }
  1226.  
  1227. void CHARACTER::__OpenPrivateShop() {
  1228. unsigned bodyPart = GetPart(PART_MAIN);
  1229. switch (bodyPart) {
  1230. case 0:
  1231. case 1:
  1232. case 2:
  1233. ChatPacket(CHAT_TYPE_COMMAND, "OpenPrivateShop");
  1234. break;
  1235. default:
  1236. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°©¿ÊÀ» ¹þ¾î¾ß °³ÀÎ »óÁ¡À» ¿­ ¼ö ÀÖ½À´Ï´Ù."));
  1237. break;
  1238. }
  1239. }
  1240.  
  1241. void CHARACTER::SendMyShopPriceListCmd(DWORD dwItemVnum, DWORD dwItemPrice) {
  1242. char szLine[256];
  1243. snprintf(szLine, sizeof(szLine), "MyShopPriceList %u %u", dwItemVnum, dwItemPrice);
  1244. ChatPacket(CHAT_TYPE_COMMAND, szLine);
  1245. sys_log(0, szLine);
  1246. }
  1247.  
  1248. void CHARACTER::UseSilkBotaryReal(const TPacketMyshopPricelistHeader* p) {
  1249. const TItemPriceInfo* pInfo = (const TItemPriceInfo*)(p + 1);
  1250.  
  1251. if (!p->byCount)
  1252. SendMyShopPriceListCmd(1, 0);
  1253. else {
  1254. for (int idx = 0; idx < p->byCount; idx++)
  1255. SendMyShopPriceListCmd(pInfo[ idx ].dwVnum, pInfo[ idx ].dwPrice);
  1256. }
  1257.  
  1258. __OpenPrivateShop();
  1259. }
  1260.  
  1261. void CHARACTER::UseSilkBotary(void) {
  1262. if (m_bNoOpenedShop) {
  1263. DWORD dwPlayerID = GetPlayerID();
  1264. db_clientdesc->DBPacket(HEADER_GD_MYSHOP_PRICELIST_REQ, GetDesc()->GetHandle(), &dwPlayerID, sizeof(DWORD));
  1265. m_bNoOpenedShop = false;
  1266. } else {
  1267. __OpenPrivateShop();
  1268. }
  1269. }
  1270.  
  1271. int CalculateConsume(LPCHARACTER ch) {
  1272. static const int WARP_NEED_LIFE_PERCENT = 30;
  1273. static const int WARP_MIN_LIFE_PERCENT = 10;
  1274. int consumeLife = 0;
  1275. {
  1276. const int curLife = ch->GetHP();
  1277. const int needPercent = WARP_NEED_LIFE_PERCENT;
  1278. const int needLife = ch->GetMaxHP() * needPercent / 100;
  1279. if (curLife < needLife) {
  1280. ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("³²Àº »ý¸í·Â ¾çÀÌ ¸ðÀÚ¶ó »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  1281. return -1;
  1282. }
  1283.  
  1284. consumeLife = needLife;
  1285. const int minPercent = WARP_MIN_LIFE_PERCENT;
  1286. const int minLife = ch->GetMaxHP() * minPercent / 100;
  1287. if (curLife - needLife < minLife)
  1288. consumeLife = curLife - minLife;
  1289.  
  1290. if (consumeLife < 0)
  1291. consumeLife = 0;
  1292. }
  1293. return consumeLife;
  1294. }
  1295.  
  1296. int CalculateConsumeSP(LPCHARACTER lpChar) {
  1297. static const int NEED_WARP_SP_PERCENT = 30;
  1298.  
  1299. const int curSP = lpChar->GetSP();
  1300. const int needSP = lpChar->GetMaxSP() * NEED_WARP_SP_PERCENT / 100;
  1301.  
  1302. if (curSP < needSP) {
  1303. lpChar->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("³²Àº Á¤½Å·Â ¾çÀÌ ¸ðÀÚ¶ó »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  1304. return -1;
  1305. }
  1306.  
  1307. return needSP;
  1308. }
  1309.  
  1310. bool CHARACTER::UseItemEx(LPITEM item, TItemPos DestCell) {
  1311. int iLimitRealtimeStartFirstUseFlagIndex = -1;
  1312. int iLimitTimerBasedOnWearFlagIndex = -1;
  1313.  
  1314. WORD wDestCell = DestCell.cell;
  1315. BYTE bDestInven = DestCell.window_type;
  1316. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i) {
  1317. long limitValue = item->GetProto()->aLimits[i].lValue;
  1318.  
  1319. switch (item->GetProto()->aLimits[i].bType) {
  1320. case LIMIT_LEVEL:
  1321. if (GetLevel() < limitValue) {
  1322. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛÀÇ ·¹º§ Á¦ÇѺ¸´Ù ·¹º§ÀÌ ³·½À´Ï´Ù."));
  1323. return false;
  1324. }
  1325. break;
  1326.  
  1327. case LIMIT_REAL_TIME_START_FIRST_USE:
  1328. iLimitRealtimeStartFirstUseFlagIndex = i;
  1329. break;
  1330.  
  1331. case LIMIT_TIMER_BASED_ON_WEAR:
  1332. iLimitTimerBasedOnWearFlagIndex = i;
  1333. break;
  1334. }
  1335. }
  1336.  
  1337. if (test_server) {
  1338. sys_log(0, "USE_ITEM %s, Inven %d, Cell %d, ItemType %d, SubType %d", item->GetName(), bDestInven, wDestCell, item->GetType(), item->GetSubType());
  1339. }
  1340.  
  1341. if ( CArenaManager::instance().IsLimitedItem( GetMapIndex(), item->GetVnum() ) == true ) {
  1342. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ã Áß¿¡´Â ÀÌ¿ëÇÒ ¼ö ¾ø´Â ¹°Ç°ÀÔ´Ï´Ù."));
  1343. return false;
  1344. }
  1345.  
  1346. if (-1 != iLimitRealtimeStartFirstUseFlagIndex) {
  1347. if (0 == item->GetSocket(1)) {
  1348. long duration = (0 != item->GetSocket(0)) ? item->GetSocket(0) : item->GetProto()->aLimits[iLimitRealtimeStartFirstUseFlagIndex].lValue;
  1349.  
  1350. if (0 == duration)
  1351. duration = 60 * 60 * 24 * 7;
  1352.  
  1353. item->SetSocket(0, time(0) + duration);
  1354. item->StartRealTimeExpireEvent();
  1355. }
  1356.  
  1357. if (false == item->IsEquipped())
  1358. item->SetSocket(1, item->GetSocket(1) + 1);
  1359. }
  1360.  
  1361. if(ItemIsBlock( (int)item->GetVnum(), (int)GetMapIndex() )) {
  1362. ChatPacket(CHAT_TYPE_INFO, "[X5CLASSIC]PROIBIDO USO DE POT NESSE MAPA SEU NOOB!");
  1363. return false;
  1364. }
  1365.  
  1366. switch (item->GetType()) {
  1367. case ITEM_HAIR:
  1368. return ItemProcess_Hair(item, wDestCell);
  1369.  
  1370. case ITEM_POLYMORPH:
  1371. return ItemProcess_Polymorph(item);
  1372.  
  1373. case ITEM_QUEST:
  1374. if (GetArena() != NULL || IsObserverMode() == true) {
  1375. if (item->GetVnum() == 50051 || item->GetVnum() == 50052 || item->GetVnum() == 50053) {
  1376. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ã Áß¿¡´Â ÀÌ¿ëÇÒ ¼ö ¾ø´Â ¹°Ç°ÀÔ´Ï´Ù."));
  1377. return false;
  1378. }
  1379. }
  1380.  
  1381. if (!IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE | ITEM_FLAG_QUEST_USE_MULTIPLE)) {
  1382. if (item->GetSIGVnum() == 0) {
  1383. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  1384. } else {
  1385. quest::CQuestManager::instance().SIGUse(GetPlayerID(), item->GetSIGVnum(), item, false);
  1386. }
  1387. }
  1388. break;
  1389.  
  1390. case ITEM_CAMPFIRE: {
  1391. float fx, fy;
  1392. GetDeltaByDegree(GetRotation(), 100.0f, &fx, &fy);
  1393.  
  1394. LPSECTREE tree = SECTREE_MANAGER::instance().Get(GetMapIndex(), (long)(GetX()+fx), (long)(GetY()+fy));
  1395.  
  1396. if (!tree) {
  1397. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸ð´ÚºÒÀ» ÇÇ¿ï ¼ö ¾ø´Â ÁöÁ¡ÀÔ´Ï´Ù."));
  1398. return false;
  1399. }
  1400.  
  1401. if (tree->IsAttr((long)(GetX()+fx), (long)(GetY()+fy), ATTR_WATER)) {
  1402. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¹° ¼Ó¿¡ ¸ð´ÚºÒÀ» ÇÇ¿ï ¼ö ¾ø½À´Ï´Ù."));
  1403. return false;
  1404. }
  1405.  
  1406. LPCHARACTER campfire = CHARACTER_MANAGER::instance().SpawnMob(fishing::CAMPFIRE_MOB, GetMapIndex(), (long)(GetX()+fx), (long)(GetY()+fy), 0, false, number(0, 359));
  1407.  
  1408. char_event_info* info = AllocEventInfo<char_event_info>();
  1409.  
  1410. info->ch = campfire;
  1411.  
  1412. campfire->m_pkMiningEvent = event_create(kill_campfire_event, info, PASSES_PER_SEC(40));
  1413.  
  1414. item->SetCount(item->GetCount() - 1);
  1415. }
  1416. break;
  1417.  
  1418. case ITEM_UNIQUE: {
  1419. switch (item->GetSubType()) {
  1420. case USE_ABILITY_UP: {
  1421. switch (item->GetValue(0)) {
  1422. case APPLY_MOV_SPEED:
  1423. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_MOV_SPEED, item->GetValue(2), AFF_MOV_SPEED_POTION, item->GetValue(1), 0, true, true);
  1424. break;
  1425.  
  1426. case APPLY_ATT_SPEED:
  1427. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ATT_SPEED, item->GetValue(2), AFF_ATT_SPEED_POTION, item->GetValue(1), 0, true, true);
  1428. break;
  1429.  
  1430. case APPLY_STR:
  1431. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ST, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1432. break;
  1433.  
  1434. case APPLY_DEX:
  1435. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_DX, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1436. break;
  1437.  
  1438. case APPLY_CON:
  1439. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_HT, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1440. break;
  1441.  
  1442. case APPLY_INT:
  1443. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_IQ, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1444. break;
  1445.  
  1446. case APPLY_CAST_SPEED:
  1447. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_CASTING_SPEED, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1448. break;
  1449.  
  1450. case APPLY_RESIST_MAGIC:
  1451. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_RESIST_MAGIC, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1452. break;
  1453.  
  1454. case APPLY_ATT_GRADE_BONUS:
  1455. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ATT_GRADE_BONUS,
  1456. item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1457. break;
  1458.  
  1459. case APPLY_DEF_GRADE_BONUS:
  1460. AddAffect(AFFECT_UNIQUE_ABILITY, POINT_DEF_GRADE_BONUS,
  1461. item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  1462. break;
  1463. }
  1464. }
  1465.  
  1466. if (GetDungeon())
  1467. GetDungeon()->UsePotion(this);
  1468.  
  1469. if (GetWarMap())
  1470. GetWarMap()->UsePotion(this, item);
  1471.  
  1472. item->SetCount(item->GetCount() - 1);
  1473. break;
  1474.  
  1475. default: {
  1476. if (item->GetSubType() == USE_SPECIAL) {
  1477. sys_log(0, "ITEM_UNIQUE: USE_SPECIAL %u", item->GetVnum());
  1478.  
  1479. switch (item->GetVnum()) {
  1480. case 71049: {
  1481. UseSilkBotary();
  1482. }
  1483. break;
  1484. }
  1485. } else {
  1486. if (!item->IsEquipped())
  1487. EquipItem(item);
  1488. else
  1489. UnequipItem(item);
  1490. }
  1491. }
  1492. break;
  1493. }
  1494. }
  1495. break;
  1496.  
  1497. case ITEM_COSTUME:
  1498. case ITEM_WEAPON:
  1499. case ITEM_ARMOR:
  1500. case ITEM_ROD:
  1501. case ITEM_RING:
  1502. case ITEM_BELT:
  1503. case ITEM_PICK:
  1504. if (!item->IsEquipped())
  1505. EquipItem(item);
  1506. else
  1507. UnequipItem(item);
  1508. break;
  1509. case ITEM_DS: {
  1510. if (!item->IsEquipped())
  1511. return false;
  1512. return DSManager::instance().PullOut(this, NPOS, item);
  1513. break;
  1514. }
  1515. case ITEM_SPECIAL_DS:
  1516. if (!item->IsEquipped())
  1517. EquipItem(item);
  1518. else
  1519. UnequipItem(item);
  1520. break;
  1521.  
  1522. case ITEM_FISH: {
  1523. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true) {
  1524. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ã Áß¿¡´Â ÀÌ¿ëÇÒ ¼ö ¾ø´Â ¹°Ç°ÀÔ´Ï´Ù."));
  1525. return false;
  1526. }
  1527.  
  1528. if (item->GetSubType() == FISH_ALIVE)
  1529. fishing::UseFish(this, item);
  1530. }
  1531. break;
  1532.  
  1533. case ITEM_TREASURE_BOX: {
  1534. return false;
  1535. }
  1536. break;
  1537.  
  1538. case ITEM_TREASURE_KEY: {
  1539. LPITEM item2;
  1540.  
  1541. if (!GetItem(DestCell) || !(item2 = GetItem(DestCell)))
  1542. return false;
  1543.  
  1544. if (item2->IsExchanging() || item2->IsEquipped()) // Fix
  1545. return false;
  1546.  
  1547. if (item2->GetType() != ITEM_TREASURE_BOX) {
  1548. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¿­¼è·Î ¿©´Â ¹°°ÇÀÌ ¾Æ´Ñ°Í °°´Ù."));
  1549. return false;
  1550. }
  1551.  
  1552. if (item->GetValue(0) == item2->GetValue(0)) {
  1553. DWORD dwBoxVnum = item2->GetVnum();
  1554. std::vector <DWORD> dwVnums;
  1555. std::vector <DWORD> dwCounts;
  1556. std::vector <LPITEM> item_gets(NULL);
  1557. int count = 0;
  1558.  
  1559. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count)) {
  1560. ITEM_MANAGER::instance().RemoveItem(item);
  1561. ITEM_MANAGER::instance().RemoveItem(item2);
  1562.  
  1563. for (int i = 0; i < count; i++) {
  1564. switch (dwVnums[i]) {
  1565. case CSpecialItemGroup::GOLD:
  1566. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ· %d ³ÉÀ» ȹµæÇß½À´Ï´Ù."), dwCounts[i]);
  1567. break;
  1568. case CSpecialItemGroup::EXP:
  1569. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ºÎÅÍ ½ÅºñÇÑ ºûÀÌ ³ª¿É´Ï´Ù."));
  1570. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%dÀÇ °æÇèÄ¡¸¦ ȹµæÇß½À´Ï´Ù."), dwCounts[i]);
  1571. break;
  1572. case CSpecialItemGroup::MOB:
  1573. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ¸ó½ºÅÍ°¡ ³ªÅ¸³µ½À´Ï´Ù!"));
  1574. break;
  1575. case CSpecialItemGroup::SLOW:
  1576. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ³ª¿Â »¡°£ ¿¬±â¸¦ µéÀ̸¶½ÃÀÚ ¿òÁ÷ÀÌ´Â ¼Óµµ°¡ ´À·ÁÁ³½À´Ï´Ù!"));
  1577. break;
  1578. case CSpecialItemGroup::DRAIN_HP:
  1579. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ°¡ °©ÀÚ±â Æø¹ßÇÏ¿´½À´Ï´Ù! »ý¸í·ÂÀÌ °¨¼ÒÇß½À´Ï´Ù."));
  1580. break;
  1581. case CSpecialItemGroup::POISON:
  1582. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ³ª¿Â ³ì»ö ¿¬±â¸¦ µéÀ̸¶½ÃÀÚ µ¶ÀÌ ¿Â¸öÀ¸·Î ÆÛÁý´Ï´Ù!"));
  1583. break;
  1584. case CSpecialItemGroup::MOB_GROUP:
  1585. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ¸ó½ºÅÍ°¡ ³ªÅ¸³µ½À´Ï´Ù!"));
  1586. break;
  1587. default:
  1588. if (item_gets[i]) {
  1589. if (dwCounts[i] > 1)
  1590. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ %s °¡ %d °³ ³ª¿Ô½À´Ï´Ù."), item_gets[i]->GetName(), dwCounts[i]);
  1591. else
  1592. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ %s °¡ ³ª¿Ô½À´Ï´Ù."), item_gets[i]->GetName());
  1593.  
  1594. }
  1595. }
  1596. }
  1597. } else {
  1598. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¿­¼è°¡ ¸ÂÁö ¾Ê´Â °Í °°´Ù."));
  1599. return false;
  1600. }
  1601. } else {
  1602. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¿­¼è°¡ ¸ÂÁö ¾Ê´Â °Í °°´Ù."));
  1603. return false;
  1604. }
  1605. }
  1606. break;
  1607.  
  1608. case ITEM_GIFTBOX: {
  1609. DWORD dwBoxVnum = item->GetVnum();
  1610. std::vector <DWORD> dwVnums;
  1611. std::vector <DWORD> dwCounts;
  1612. std::vector <LPITEM> item_gets(NULL);
  1613. int count = 0;
  1614.  
  1615. if( (dwBoxVnum > 51500 && dwBoxVnum < 52000) || (dwBoxVnum >= 50255 && dwBoxVnum <= 50260) ) {
  1616. if( !(this->DragonSoul_IsQualified()) ) {
  1617. ChatPacket(CHAT_TYPE_INFO,LC_TEXT("¸ÕÀú ¿ëÈ¥¼® Äù½ºÆ®¸¦ ¿Ï·áÇÏ¼Å¾ß ÇÕ´Ï´Ù."));
  1618. return false;
  1619. }
  1620. }
  1621.  
  1622. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count)) {
  1623. item->SetCount(item->GetCount()-1);
  1624.  
  1625. for (int i = 0; i < count; i++) {
  1626. switch (dwVnums[i]) {
  1627. case CSpecialItemGroup::GOLD:
  1628. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ· %d ³ÉÀ» ȹµæÇß½À´Ï´Ù."), dwCounts[i]);
  1629. break;
  1630. case CSpecialItemGroup::EXP:
  1631. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ºÎÅÍ ½ÅºñÇÑ ºûÀÌ ³ª¿É´Ï´Ù."));
  1632. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%dÀÇ °æÇèÄ¡¸¦ ȹµæÇß½À´Ï´Ù."), dwCounts[i]);
  1633. break;
  1634. case CSpecialItemGroup::MOB:
  1635. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ¸ó½ºÅÍ°¡ ³ªÅ¸³µ½À´Ï´Ù!"));
  1636. break;
  1637. case CSpecialItemGroup::SLOW:
  1638. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ³ª¿Â »¡°£ ¿¬±â¸¦ µéÀ̸¶½ÃÀÚ ¿òÁ÷ÀÌ´Â ¼Óµµ°¡ ´À·ÁÁ³½À´Ï´Ù!"));
  1639. break;
  1640. case CSpecialItemGroup::DRAIN_HP:
  1641. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ°¡ °©ÀÚ±â Æø¹ßÇÏ¿´½À´Ï´Ù! »ý¸í·ÂÀÌ °¨¼ÒÇß½À´Ï´Ù."));
  1642. break;
  1643. case CSpecialItemGroup::POISON:
  1644. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ³ª¿Â ³ì»ö ¿¬±â¸¦ µéÀ̸¶½ÃÀÚ µ¶ÀÌ ¿Â¸öÀ¸·Î ÆÛÁý´Ï´Ù!"));
  1645. break;
  1646. case CSpecialItemGroup::MOB_GROUP:
  1647. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ¸ó½ºÅÍ°¡ ³ªÅ¸³µ½À´Ï´Ù!"));
  1648. break;
  1649. default:
  1650. if (item_gets[i]) {
  1651. if (dwCounts[i] > 1)
  1652. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ %s °¡ %d °³ ³ª¿Ô½À´Ï´Ù."), item_gets[i]->GetName(), dwCounts[i]);
  1653. else
  1654. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ %s °¡ ³ª¿Ô½À´Ï´Ù."), item_gets[i]->GetName());
  1655. }
  1656. }
  1657. }
  1658. } else {
  1659. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¾Æ¹«°Íµµ ¾òÀ» ¼ö ¾ø¾ú½À´Ï´Ù."));
  1660. return false;
  1661. }
  1662. }
  1663. break;
  1664.  
  1665. case ITEM_SKILLFORGET: {
  1666. if (!item->GetSocket(0)) {
  1667. ITEM_MANAGER::instance().RemoveItem(item);
  1668. return false;
  1669. }
  1670.  
  1671. DWORD dwVnum = item->GetSocket(0);
  1672.  
  1673. if (SkillLevelDown(dwVnum)) {
  1674. ITEM_MANAGER::instance().RemoveItem(item);
  1675. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("½ºÅ³ ·¹º§À» ³»¸®´Âµ¥ ¼º°øÇÏ¿´½À´Ï´Ù."));
  1676. } else
  1677. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("½ºÅ³ ·¹º§À» ³»¸± ¼ö ¾ø½À´Ï´Ù."));
  1678. }
  1679. break;
  1680.  
  1681. case ITEM_SKILLBOOK: {
  1682. if (IsPolymorphed()) {
  1683. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("º¯½ÅÁß¿¡´Â Ã¥À» ÀÐÀ»¼ö ¾ø½À´Ï´Ù."));
  1684. return false;
  1685. }
  1686.  
  1687. DWORD dwVnum = 0;
  1688.  
  1689. if (item->GetVnum() == 50300) {
  1690. dwVnum = item->GetSocket(0);
  1691. } else {
  1692. dwVnum = item->GetValue(0);
  1693. }
  1694.  
  1695. if (0 == dwVnum) {
  1696. ITEM_MANAGER::instance().RemoveItem(item);
  1697.  
  1698. return false;
  1699. }
  1700.  
  1701. if (true == LearnSkillByBook(dwVnum)) {
  1702. ITEM_MANAGER::instance().RemoveItem(item);
  1703.  
  1704. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  1705.  
  1706. SetSkillNextReadTime(dwVnum, get_global_time() + iReadDelay);
  1707. }
  1708. }
  1709. break;
  1710.  
  1711. case ITEM_USE: {
  1712. if (item->GetVnum() > 50800 && item->GetVnum() <= 50820) {
  1713. if (test_server)
  1714. sys_log (0, "ADD addtional effect : vnum(%d) subtype(%d)", item->GetOriginalVnum(), item->GetSubType());
  1715.  
  1716. int affect_type = AFFECT_EXP_BONUS_EURO_FREE;
  1717. int apply_type = aApplyInfo[item->GetValue(0)].bPointType;
  1718. int apply_value = item->GetValue(2);
  1719. int apply_duration = item->GetValue(1);
  1720.  
  1721. switch (item->GetSubType()) {
  1722. case USE_ABILITY_UP:
  1723. if (FindAffect(affect_type, apply_type)) {
  1724. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì È¿°ú°¡ °É·Á ÀÖ½À´Ï´Ù."));
  1725. return false;
  1726. }
  1727.  
  1728. {
  1729. switch (item->GetValue(0)) {
  1730. case APPLY_MOV_SPEED:
  1731. AddAffect(affect_type, apply_type, apply_value, AFF_MOV_SPEED_POTION, apply_duration, 0, true, true);
  1732. break;
  1733.  
  1734. case APPLY_ATT_SPEED:
  1735. AddAffect(affect_type, apply_type, apply_value, AFF_ATT_SPEED_POTION, apply_duration, 0, true, true);
  1736. break;
  1737.  
  1738. case APPLY_STR:
  1739. case APPLY_DEX:
  1740. case APPLY_CON:
  1741. case APPLY_INT:
  1742. case APPLY_CAST_SPEED:
  1743. case APPLY_RESIST_MAGIC:
  1744. case APPLY_ATT_GRADE_BONUS:
  1745. case APPLY_DEF_GRADE_BONUS:
  1746. AddAffect(affect_type, apply_type, apply_value, 0, apply_duration, 0, true, true);
  1747. break;
  1748. }
  1749. }
  1750.  
  1751. if (GetDungeon())
  1752. GetDungeon()->UsePotion(this);
  1753.  
  1754. if (GetWarMap())
  1755. GetWarMap()->UsePotion(this, item);
  1756.  
  1757. item->SetCount(item->GetCount() - 1);
  1758. break;
  1759.  
  1760. case USE_AFFECT : {
  1761. if (FindAffect(AFFECT_EXP_BONUS_EURO_FREE, aApplyInfo[item->GetValue(1)].bPointType)) {
  1762. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì È¿°ú°¡ °É·Á ÀÖ½À´Ï´Ù."));
  1763. } else {
  1764. AddAffect(AFFECT_EXP_BONUS_EURO_FREE, aApplyInfo[item->GetValue(1)].bPointType, item->GetValue(2), 0, item->GetValue(3), 0, false, true);
  1765. item->SetCount(item->GetCount() - 1);
  1766. }
  1767. }
  1768. break;
  1769.  
  1770. case USE_POTION_NODELAY: {
  1771. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true) {
  1772. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0) {
  1773. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ÃÀå¿¡¼­ »ç¿ëÇÏ½Ç ¼ö ¾ø½À´Ï´Ù."));
  1774. return false;
  1775. }
  1776.  
  1777. switch (item->GetVnum()) {
  1778. case 70020 :
  1779. case 71018 :
  1780. case 71019 :
  1781. case 71020 :
  1782. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000) {
  1783. if (m_nPotionLimit <= 0) {
  1784. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»ç¿ë Á¦ÇÑ·®À» ÃÊ°úÇÏ¿´½À´Ï´Ù."));
  1785. return false;
  1786. }
  1787. }
  1788. break;
  1789.  
  1790. default :
  1791. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ÃÀå¿¡¼­ »ç¿ëÇÏ½Ç ¼ö ¾ø½À´Ï´Ù."));
  1792. return false;
  1793. break;
  1794. }
  1795. }
  1796.  
  1797. bool used = false;
  1798.  
  1799. if (item->GetValue(0) != 0) {
  1800. if (GetHP() < GetMaxHP()) {
  1801. PointChange(POINT_HP, item->GetValue(0) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  1802. EffectPacket(SE_HPUP_RED);
  1803. used = TRUE;
  1804. }
  1805. }
  1806.  
  1807. if (item->GetValue(1) != 0) {
  1808. if (GetSP() < GetMaxSP()) {
  1809. PointChange(POINT_SP, item->GetValue(1) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  1810. EffectPacket(SE_SPUP_BLUE);
  1811. used = TRUE;
  1812. }
  1813. }
  1814.  
  1815. if (item->GetValue(3) != 0) {
  1816. if (GetHP() < GetMaxHP()) {
  1817. PointChange(POINT_HP, item->GetValue(3) * GetMaxHP() / 100);
  1818. EffectPacket(SE_HPUP_RED);
  1819. used = TRUE;
  1820. }
  1821. }
  1822.  
  1823. if (item->GetValue(4) != 0) {
  1824. if (GetSP() < GetMaxSP()) {
  1825. PointChange(POINT_SP, item->GetValue(4) * GetMaxSP() / 100);
  1826. EffectPacket(SE_SPUP_BLUE);
  1827. used = TRUE;
  1828. }
  1829. }
  1830.  
  1831. if (used) {
  1832. if (item->GetVnum() == 50085 || item->GetVnum() == 50086) {
  1833. if (test_server)
  1834. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¿ùº´ ¶Ç´Â Á¾ÀÚ ¸¦ »ç¿ëÇÏ¿´½À´Ï´Ù"));
  1835. SetUseSeedOrMoonBottleTime();
  1836. }
  1837. if (GetDungeon())
  1838. GetDungeon()->UsePotion(this);
  1839.  
  1840. if (GetWarMap())
  1841. GetWarMap()->UsePotion(this, item);
  1842.  
  1843. m_nPotionLimit--;
  1844. item->SetCount(item->GetCount() - 1);
  1845. }
  1846. }
  1847. break;
  1848. }
  1849.  
  1850. return true;
  1851. }
  1852.  
  1853.  
  1854. if (item->GetVnum() >= 27863 && item->GetVnum() <= 27883) {
  1855. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true) {
  1856. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ã Áß¿¡´Â ÀÌ¿ëÇÒ ¼ö ¾ø´Â ¹°Ç°ÀÔ´Ï´Ù."));
  1857. return false;
  1858. }
  1859. }
  1860.  
  1861. if (test_server) {
  1862. sys_log (0, "USE_ITEM %s Type %d SubType %d vnum %d", item->GetName(), item->GetType(), item->GetSubType(), item->GetOriginalVnum());
  1863. }
  1864.  
  1865. switch (item->GetSubType()) {
  1866. case USE_TIME_CHARGE_PER: {
  1867. LPITEM pDestItem = GetItem(DestCell);
  1868. if (NULL == pDestItem) {
  1869. return false;
  1870. }
  1871. if (pDestItem->IsDragonSoul()) {
  1872. int ret;
  1873. char buf[128];
  1874. if (item->GetVnum() == DRAGON_HEART_VNUM) {
  1875. ret = pDestItem->GiveMoreTime_Per((float)item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
  1876. } else {
  1877. ret = pDestItem->GiveMoreTime_Per((float)item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  1878. }
  1879. if (ret > 0) {
  1880. if (item->GetVnum() == DRAGON_HEART_VNUM) {
  1881. 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));
  1882. } else {
  1883. 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));
  1884. }
  1885.  
  1886. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%dÃÊ ¸¸Å­ ÃæÀüµÇ¾ú½À´Ï´Ù."), ret);
  1887. item->SetCount(item->GetCount() - 1);
  1888. LogManager::instance().ItemLog(this, item, "DS_CHARGING_SUCCESS", buf);
  1889. return true;
  1890. } else {
  1891. if (item->GetVnum() == DRAGON_HEART_VNUM) {
  1892. 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));
  1893. } else {
  1894. 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));
  1895. }
  1896.  
  1897. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÃæÀüÇÒ ¼ö ¾ø½À´Ï´Ù."));
  1898. LogManager::instance().ItemLog(this, item, "DS_CHARGING_FAILED", buf);
  1899. return false;
  1900. }
  1901. } else
  1902. return false;
  1903. }
  1904. break;
  1905. case USE_TIME_CHARGE_FIX: {
  1906. LPITEM pDestItem = GetItem(DestCell);
  1907. if (NULL == pDestItem) {
  1908. return false;
  1909. }
  1910. if (pDestItem->IsDragonSoul()) {
  1911. int ret = pDestItem->GiveMoreTime_Fix(item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  1912. char buf[128];
  1913. if (ret) {
  1914. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%dÃÊ ¸¸Å­ ÃæÀüµÇ¾ú½À´Ï´Ù."), ret);
  1915. 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));
  1916. LogManager::instance().ItemLog(this, item, "DS_CHARGING_SUCCESS", buf);
  1917. item->SetCount(item->GetCount() - 1);
  1918. return true;
  1919. } else {
  1920. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÃæÀüÇÒ ¼ö ¾ø½À´Ï´Ù."));
  1921. 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));
  1922. LogManager::instance().ItemLog(this, item, "DS_CHARGING_FAILED", buf);
  1923. return false;
  1924. }
  1925. } else
  1926. return false;
  1927. }
  1928. break;
  1929. case USE_SPECIAL:
  1930.  
  1931. switch (item->GetVnum()) {
  1932.  
  1933. case ITEM_NOG_POCKET: {
  1934. if (FindAffect(AFFECT_NOG_ABILITY)) {
  1935. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì È¿°ú°¡ °É·Á ÀÖ½À´Ï´Ù."));
  1936. return false;
  1937. }
  1938. long time = item->GetValue(0);
  1939. long moveSpeedPer = item->GetValue(1);
  1940. long attPer = item->GetValue(2);
  1941. long expPer = item->GetValue(3);
  1942. AddAffect(AFFECT_NOG_ABILITY, POINT_MOV_SPEED, moveSpeedPer, AFF_MOV_SPEED_POTION, time, 0, true, true);
  1943. AddAffect(AFFECT_NOG_ABILITY, POINT_MALL_ATTBONUS, attPer, AFF_NONE, time, 0, true, true);
  1944. AddAffect(AFFECT_NOG_ABILITY, POINT_MALL_EXPBONUS, expPer, AFF_NONE, time, 0, true, true);
  1945. item->SetCount(item->GetCount() - 1);
  1946. }
  1947. break;
  1948.  
  1949. case ITEM_RAMADAN_CANDY: {
  1950. if (FindAffect(AFFECT_RAMADAN_ABILITY)) // Fix
  1951. {
  1952. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì È¿°ú°¡ °É·Á ÀÖ½À´Ï´Ù."));
  1953. return false;
  1954. }
  1955. long time = item->GetValue(0);
  1956. long moveSpeedPer = item->GetValue(1);
  1957. long attPer = item->GetValue(2);
  1958. long expPer = item->GetValue(3);
  1959. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MOV_SPEED, moveSpeedPer, AFF_MOV_SPEED_POTION, time, 0, true, true);
  1960. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MALL_ATTBONUS, attPer, AFF_NONE, time, 0, true, true);
  1961. AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MALL_EXPBONUS, expPer, AFF_NONE, time, 0, true, true);
  1962. item->SetCount(item->GetCount() - 1);
  1963. }
  1964. break;
  1965. case ITEM_MARRIAGE_RING: {
  1966. marriage::TMarriage* pMarriage = marriage::CManager::instance().Get(GetPlayerID());
  1967. if (pMarriage) {
  1968. if (pMarriage->ch1 != NULL) {
  1969. if (CArenaManager::instance().IsArenaMap(pMarriage->ch1->GetMapIndex()) == true) {
  1970. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ã Áß¿¡´Â ÀÌ¿ëÇÒ ¼ö ¾ø´Â ¹°Ç°ÀÔ´Ï´Ù."));
  1971. break;
  1972. }
  1973. }
  1974.  
  1975. if (pMarriage->ch2 != NULL) {
  1976. if (CArenaManager::instance().IsArenaMap(pMarriage->ch2->GetMapIndex()) == true) {
  1977. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ã Áß¿¡´Â ÀÌ¿ëÇÒ ¼ö ¾ø´Â ¹°Ç°ÀÔ´Ï´Ù."));
  1978. break;
  1979. }
  1980. }
  1981.  
  1982. int consumeSP = CalculateConsumeSP(this);
  1983.  
  1984. if (consumeSP < 0)
  1985. return false;
  1986.  
  1987. PointChange(POINT_SP, -consumeSP, false);
  1988.  
  1989. WarpToPID(pMarriage->GetOther(GetPlayerID()));
  1990. } else
  1991. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°áÈ¥ »óÅ°¡ ¾Æ´Ï¸é °áÈ¥¹ÝÁö¸¦ »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  1992. }
  1993. break;
  1994.  
  1995. case UNIQUE_ITEM_CAPE_OF_COURAGE:
  1996. case 70057:
  1997. case REWARD_BOX_UNIQUE_ITEM_CAPE_OF_COURAGE:
  1998. AggregateMonster();
  1999. item->SetCount(item->GetCount()-1);
  2000. break;
  2001.  
  2002. case UNIQUE_ITEM_WHITE_FLAG:
  2003. ForgetMyAttacker();
  2004. item->SetCount(item->GetCount()-1);
  2005. break;
  2006.  
  2007. case UNIQUE_ITEM_TREASURE_BOX:
  2008. break;
  2009.  
  2010. case 30093:
  2011. case 30094:
  2012. case 30095:
  2013. case 30096: {
  2014. const int MAX_BAG_INFO = 26;
  2015. static struct LuckyBagInfo {
  2016. DWORD count;
  2017. int prob;
  2018. DWORD vnum;
  2019. } b1[MAX_BAG_INFO] = {
  2020. { 1000, 302, 1 },
  2021. { 10, 150, 27002 },
  2022. { 10, 75, 27003 },
  2023. { 10, 100, 27005 },
  2024. { 10, 50, 27006 },
  2025. { 10, 80, 27001 },
  2026. { 10, 50, 27002 },
  2027. { 10, 80, 27004 },
  2028. { 10, 50, 27005 },
  2029. { 1, 10, 50300 },
  2030. { 1, 6, 92 },
  2031. { 1, 2, 132 },
  2032. { 1, 6, 1052 },
  2033. { 1, 2, 1092 },
  2034. { 1, 6, 2082 },
  2035. { 1, 2, 2122 },
  2036. { 1, 6, 3082 },
  2037. { 1, 2, 3122 },
  2038. { 1, 6, 5052 },
  2039. { 1, 2, 5082 },
  2040. { 1, 6, 7082 },
  2041. { 1, 2, 7122 },
  2042. { 1, 1, 11282 },
  2043. { 1, 1, 11482 },
  2044. { 1, 1, 11682 },
  2045. { 1, 1, 11882 },
  2046. };
  2047.  
  2048. struct LuckyBagInfo b2[MAX_BAG_INFO] = {
  2049. { 1000, 302, 1 },
  2050. { 10, 150, 27002 },
  2051. { 10, 75, 27002 },
  2052. { 10, 100, 27005 },
  2053. { 10, 50, 27005 },
  2054. { 10, 80, 27001 },
  2055. { 10, 50, 27002 },
  2056. { 10, 80, 27004 },
  2057. { 10, 50, 27005 },
  2058. { 1, 10, 50300 },
  2059. { 1, 6, 92 },
  2060. { 1, 2, 132 },
  2061. { 1, 6, 1052 },
  2062. { 1, 2, 1092 },
  2063. { 1, 6, 2082 },
  2064. { 1, 2, 2122 },
  2065. { 1, 6, 3082 },
  2066. { 1, 2, 3122 },
  2067. { 1, 6, 5052 },
  2068. { 1, 2, 5082 },
  2069. { 1, 6, 7082 },
  2070. { 1, 2, 7122 },
  2071. { 1, 1, 11282 },
  2072. { 1, 1, 11482 },
  2073. { 1, 1, 11682 },
  2074. { 1, 1, 11882 },
  2075. };
  2076.  
  2077. LuckyBagInfo * bi = NULL;
  2078. bi = b1;
  2079.  
  2080. int pct = number(1, 1000);
  2081.  
  2082. int i;
  2083. for (i=0; i<MAX_BAG_INFO; i++) {
  2084. if (pct <= bi[i].prob)
  2085. break;
  2086. pct -= bi[i].prob;
  2087. }
  2088. if (i>=MAX_BAG_INFO)
  2089. return false;
  2090.  
  2091. if (bi[i].vnum == 50300) {
  2092. GiveRandomSkillBook();
  2093. } else if (bi[i].vnum == 1) {
  2094. PointChange(POINT_GOLD, 1000, true);
  2095. } else {
  2096. AutoGiveItem(bi[i].vnum, bi[i].count);
  2097. }
  2098. ITEM_MANAGER::instance().RemoveItem(item);
  2099. }
  2100. break;
  2101.  
  2102. case 50004: {
  2103. if (item->GetSocket(0)) {
  2104. item->SetSocket(0, item->GetSocket(0) + 1);
  2105. } else {
  2106. int iMapIndex = GetMapIndex();
  2107.  
  2108. PIXEL_POSITION pos;
  2109.  
  2110. if (SECTREE_MANAGER::instance().GetRandomLocation(iMapIndex, pos, 700)) {
  2111. item->SetSocket(0, 1);
  2112. item->SetSocket(1, pos.x);
  2113. item->SetSocket(2, pos.y);
  2114. } else {
  2115. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ °÷¿¡¼± À̺¥Æ®¿ë °¨Áö±â°¡ µ¿ÀÛÇÏÁö ¾Ê´Â°Í °°½À´Ï´Ù."));
  2116. return false;
  2117. }
  2118. }
  2119.  
  2120. int dist = 0;
  2121. float distance = (DISTANCE_SQRT(GetX()-item->GetSocket(1), GetY()-item->GetSocket(2)));
  2122.  
  2123. if (distance < 1000.0f) {
  2124. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("À̺¥Æ®¿ë °¨Áö±â°¡ ½Åºñ·Î¿î ºûÀ» ³»¸ç »ç¶óÁý´Ï´Ù."));
  2125.  
  2126. struct TEventStoneInfo {
  2127. DWORD dwVnum;
  2128. int count;
  2129. int prob;
  2130. };
  2131. const int EVENT_STONE_MAX_INFO = 15;
  2132. TEventStoneInfo info_10[EVENT_STONE_MAX_INFO] = {
  2133. { 27001, 10, 8 },
  2134. { 27004, 10, 6 },
  2135. { 27002, 10, 12 },
  2136. { 27005, 10, 12 },
  2137. { 27100, 1, 9 },
  2138. { 27103, 1, 9 },
  2139. { 27101, 1, 10 },
  2140. { 27104, 1, 10 },
  2141. { 27999, 1, 12 },
  2142.  
  2143. { 25040, 1, 4 },
  2144.  
  2145. { 27410, 1, 0 },
  2146. { 27600, 1, 0 },
  2147. { 25100, 1, 0 },
  2148.  
  2149. { 50001, 1, 0 },
  2150. { 50003, 1, 1 },
  2151. };
  2152. TEventStoneInfo info_7[EVENT_STONE_MAX_INFO] = {
  2153. { 27001, 10, 1 },
  2154. { 27004, 10, 1 },
  2155. { 27004, 10, 9 },
  2156. { 27005, 10, 9 },
  2157. { 27100, 1, 5 },
  2158. { 27103, 1, 5 },
  2159. { 27101, 1, 10 },
  2160. { 27104, 1, 10 },
  2161. { 27999, 1, 14 },
  2162.  
  2163. { 25040, 1, 5 },
  2164.  
  2165. { 27410, 1, 5 },
  2166. { 27600, 1, 5 },
  2167. { 25100, 1, 5 },
  2168.  
  2169. { 50001, 1, 0 },
  2170. { 50003, 1, 5 },
  2171.  
  2172. };
  2173. TEventStoneInfo info_4[EVENT_STONE_MAX_INFO] = {
  2174. { 27001, 10, 0 },
  2175. { 27004, 10, 0 },
  2176. { 27002, 10, 0 },
  2177. { 27005, 10, 0 },
  2178. { 27100, 1, 0 },
  2179. { 27103, 1, 0 },
  2180. { 27101, 1, 0 },
  2181. { 27104, 1, 0 },
  2182. { 27999, 1, 25 },
  2183.  
  2184. { 25040, 1, 0 },
  2185.  
  2186. { 27410, 1, 0 },
  2187. { 27600, 1, 0 },
  2188. { 25100, 1, 15 },
  2189.  
  2190. { 50001, 1, 10 },
  2191. { 50003, 1, 50 },
  2192.  
  2193. };
  2194.  
  2195. {
  2196. TEventStoneInfo* info;
  2197. if (item->GetSocket(0) <= 4)
  2198. info = info_4;
  2199. else if (item->GetSocket(0) <= 7)
  2200. info = info_7;
  2201. else
  2202. info = info_10;
  2203.  
  2204. int prob = number(1, 100);
  2205.  
  2206. for (int i = 0; i < EVENT_STONE_MAX_INFO; ++i) {
  2207. if (!info[i].prob)
  2208. continue;
  2209.  
  2210. if (prob <= info[i].prob) {
  2211. AutoGiveItem(info[i].dwVnum, info[i].count);
  2212. break;
  2213. }
  2214. prob -= info[i].prob;
  2215. }
  2216. }
  2217.  
  2218. char chatbuf[CHAT_MAX_LEN + 1];
  2219. int len = snprintf(chatbuf, sizeof(chatbuf), "StoneDetect %u 0 0", (DWORD)GetVID());
  2220.  
  2221. if (len < 0 || len >= (int) sizeof(chatbuf))
  2222. len = sizeof(chatbuf) - 1;
  2223.  
  2224. ++len;
  2225.  
  2226. TPacketGCChat pack_chat;
  2227. pack_chat.header = HEADER_GC_CHAT;
  2228. pack_chat.size = sizeof(TPacketGCChat) + len;
  2229. pack_chat.type = CHAT_TYPE_COMMAND;
  2230. pack_chat.id = 0;
  2231. pack_chat.bEmpire = GetDesc()->GetEmpire();
  2232.  
  2233. TEMP_BUFFER buf;
  2234. buf.write(&pack_chat, sizeof(TPacketGCChat));
  2235. buf.write(chatbuf, len);
  2236.  
  2237. PacketAround(buf.read_peek(), buf.size());
  2238.  
  2239. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (DETECT_EVENT_STONE) 1");
  2240. return true;
  2241. } else if (distance < 20000)
  2242. dist = 1;
  2243. else if (distance < 70000)
  2244. dist = 2;
  2245. else
  2246. dist = 3;
  2247.  
  2248. const int STONE_DETECT_MAX_TRY = 10;
  2249. if (item->GetSocket(0) >= STONE_DETECT_MAX_TRY) {
  2250. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("À̺¥Æ®¿ë °¨Áö±â°¡ ÈçÀûµµ ¾øÀÌ »ç¶óÁý´Ï´Ù."));
  2251. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (DETECT_EVENT_STONE) 0");
  2252. AutoGiveItem(27002);
  2253. return true;
  2254. }
  2255.  
  2256. if (dist) {
  2257. char chatbuf[CHAT_MAX_LEN + 1];
  2258. int len = snprintf(chatbuf, sizeof(chatbuf),
  2259. "StoneDetect %u %d %d",
  2260. (DWORD)GetVID(), dist, (int)GetDegreeFromPositionXY(GetX(), item->GetSocket(2), item->GetSocket(1), GetY()));
  2261.  
  2262. if (len < 0 || len >= (int) sizeof(chatbuf))
  2263. len = sizeof(chatbuf) - 1;
  2264.  
  2265. ++len;
  2266.  
  2267. TPacketGCChat pack_chat;
  2268. pack_chat.header = HEADER_GC_CHAT;
  2269. pack_chat.size = sizeof(TPacketGCChat) + len;
  2270. pack_chat.type = CHAT_TYPE_COMMAND;
  2271. pack_chat.id = 0;
  2272. pack_chat.bEmpire = GetDesc()->GetEmpire();
  2273.  
  2274. TEMP_BUFFER buf;
  2275. buf.write(&pack_chat, sizeof(TPacketGCChat));
  2276. buf.write(chatbuf, len);
  2277.  
  2278. PacketAround(buf.read_peek(), buf.size());
  2279. }
  2280.  
  2281. }
  2282. break;
  2283.  
  2284. case 27989:
  2285. case 76006: {
  2286. LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(GetMapIndex());
  2287.  
  2288. if (pMap != NULL) {
  2289. item->SetSocket(0, item->GetSocket(0) + 1);
  2290.  
  2291. FFindStone f;
  2292. pMap->for_each(f);
  2293.  
  2294. if (f.m_mapStone.size() > 0) {
  2295. std::map<DWORD, LPCHARACTER>::iterator stone = f.m_mapStone.begin();
  2296.  
  2297. DWORD max = UINT_MAX;
  2298. LPCHARACTER pTarget = stone->second;
  2299.  
  2300. while (stone != f.m_mapStone.end()) {
  2301. DWORD dist = (DWORD)DISTANCE_SQRT(GetX()-stone->second->GetX(), GetY()-stone->second->GetY());
  2302.  
  2303. if (dist != 0 && max > dist) {
  2304. max = dist;
  2305. pTarget = stone->second;
  2306. }
  2307. stone++;
  2308. }
  2309.  
  2310. if (pTarget != NULL) {
  2311. int val = 3;
  2312.  
  2313. if (max < 10000) val = 2;
  2314. else if (max < 70000) val = 1;
  2315.  
  2316. ChatPacket(CHAT_TYPE_COMMAND, "StoneDetect %u %d %d", (DWORD)GetVID(), val,
  2317. (int)GetDegreeFromPositionXY(GetX(), pTarget->GetY(), pTarget->GetX(), GetY()));
  2318. } else {
  2319. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°¨Áö±â¸¦ ÀÛ¿ëÇÏ¿´À¸³ª °¨ÁöµÇ´Â ¿µ¼®ÀÌ ¾ø½À´Ï´Ù."));
  2320. }
  2321. } else {
  2322. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°¨Áö±â¸¦ ÀÛ¿ëÇÏ¿´À¸³ª °¨ÁöµÇ´Â ¿µ¼®ÀÌ ¾ø½À´Ï´Ù."));
  2323. }
  2324.  
  2325. if (item->GetSocket(0) >= 6) {
  2326. ChatPacket(CHAT_TYPE_COMMAND, "StoneDetect %u 0 0", (DWORD)GetVID());
  2327. ITEM_MANAGER::instance().RemoveItem(item);
  2328. }
  2329. }
  2330. break;
  2331. }
  2332. break;
  2333.  
  2334. case 27996:
  2335. item->SetCount(item->GetCount() - 1);
  2336. break;
  2337.  
  2338. case 27987: {
  2339. item->SetCount(item->GetCount() - 1);
  2340.  
  2341. int r = number(1, 100);
  2342.  
  2343. if (r <= 50) {
  2344. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¶°³¿¡¼­ µ¹Á¶°¢ÀÌ ³ª¿Ô½À´Ï´Ù."));
  2345. AutoGiveItem(27990);
  2346. } else {
  2347. const int prob_table_euckr[] = {
  2348. 80, 90, 97
  2349. };
  2350. const int * prob_table = prob_table_euckr;
  2351.  
  2352. if (r <= prob_table[0]) {
  2353. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¶°³°¡ ÈçÀûµµ ¾øÀÌ »ç¶óÁý´Ï´Ù."));
  2354. } else if (r <= prob_table[1]) {
  2355. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¶°³¿¡¼­ ¹éÁøÁÖ°¡ ³ª¿Ô½À´Ï´Ù."));
  2356. AutoGiveItem(27992);
  2357. } else if (r <= prob_table[2]) {
  2358. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¶°³¿¡¼­ ûÁøÁÖ°¡ ³ª¿Ô½À´Ï´Ù."));
  2359. AutoGiveItem(27993);
  2360. } else {
  2361. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á¶°³¿¡¼­ ÇÇÁøÁÖ°¡ ³ª¿Ô½À´Ï´Ù."));
  2362. AutoGiveItem(27994);
  2363. }
  2364. }
  2365. }
  2366. break;
  2367.  
  2368. case 71013:
  2369. CreateFly(number(FLY_FIREWORK1, FLY_FIREWORK6), this);
  2370. item->SetCount(item->GetCount() - 1);
  2371. break;
  2372.  
  2373. case 50100:
  2374. case 50101:
  2375. case 50102:
  2376. case 50103:
  2377. case 50104:
  2378. case 50105:
  2379. case 50106:
  2380. CreateFly(item->GetVnum() - 50100 + FLY_FIREWORK1, this);
  2381. item->SetCount(item->GetCount() - 1);
  2382. break;
  2383.  
  2384. case 50200: {
  2385. __OpenPrivateShop();
  2386. }
  2387. break;
  2388.  
  2389. case fishing::FISH_MIND_PILL_VNUM:
  2390. AddAffect(AFFECT_FISH_MIND_PILL, POINT_NONE, 0, AFF_FISH_MIND, 20*60, 0, true);
  2391. item->SetCount(item->GetCount() - 1);
  2392. break;
  2393.  
  2394. case 50301:
  2395. case 50302:
  2396. case 50303: {
  2397. if (IsPolymorphed() == true) {
  2398. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µÐ°© Áß¿¡´Â ´É·ÂÀ» ¿Ã¸± ¼ö ¾ø½À´Ï´Ù."));
  2399. return false;
  2400. }
  2401.  
  2402. int lv = GetSkillLevel(SKILL_LEADERSHIP);
  2403.  
  2404. if (lv < item->GetValue(0)) {
  2405. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ Ã¥Àº ³Ê¹« ¾î·Á¿ö ÀÌÇØÇϱⰡ Èûµì´Ï´Ù."));
  2406. return false;
  2407. }
  2408.  
  2409. if (lv >= item->GetValue(1)) {
  2410. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ Ã¥Àº ¾Æ¹«¸® ºÁµµ µµ¿òÀÌ µÉ °Í °°Áö ¾Ê½À´Ï´Ù."));
  2411. return false;
  2412. }
  2413.  
  2414. if (LearnSkillByBook(SKILL_LEADERSHIP)) {
  2415. ITEM_MANAGER::instance().RemoveItem(item);
  2416.  
  2417. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2418.  
  2419. SetSkillNextReadTime(SKILL_LEADERSHIP, get_global_time() + iReadDelay);
  2420. }
  2421. }
  2422. break;
  2423.  
  2424. case 50304:
  2425. case 50305:
  2426. case 50306: {
  2427. if (IsPolymorphed()) {
  2428. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("º¯½ÅÁß¿¡´Â Ã¥À» ÀÐÀ»¼ö ¾ø½À´Ï´Ù."));
  2429. return false;
  2430.  
  2431. }
  2432. if (GetSkillLevel(SKILL_COMBO) == 0 && GetLevel() < 30) {
  2433. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("·¹º§ 30ÀÌ µÇ±â Àü¿¡´Â ½ÀµæÇÒ ¼ö ÀÖÀ» °Í °°Áö ¾Ê½À´Ï´Ù."));
  2434. return false;
  2435. }
  2436.  
  2437. if (GetSkillLevel(SKILL_COMBO) == 1 && GetLevel() < 50) {
  2438. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("·¹º§ 50ÀÌ µÇ±â Àü¿¡´Â ½ÀµæÇÒ ¼ö ÀÖÀ» °Í °°Áö ¾Ê½À´Ï´Ù."));
  2439. return false;
  2440. }
  2441.  
  2442. if (GetSkillLevel(SKILL_COMBO) >= 2) {
  2443. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¿¬°è±â´Â ´õÀÌ»ó ¼ö·ÃÇÒ ¼ö ¾ø½À´Ï´Ù."));
  2444. return false;
  2445. }
  2446.  
  2447. int iPct = item->GetValue(0);
  2448.  
  2449. if (LearnSkillByBook(SKILL_COMBO, iPct)) {
  2450. ITEM_MANAGER::instance().RemoveItem(item);
  2451.  
  2452. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2453.  
  2454.  
  2455. SetSkillNextReadTime(SKILL_COMBO, get_global_time() + iReadDelay);
  2456. }
  2457. }
  2458. break;
  2459. case 50311:
  2460. case 50312:
  2461. case 50313: {
  2462. if (IsPolymorphed()) {
  2463. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("º¯½ÅÁß¿¡´Â Ã¥À» ÀÐÀ»¼ö ¾ø½À´Ï´Ù."));
  2464. return false;
  2465.  
  2466. }
  2467. DWORD dwSkillVnum = item->GetValue(0);
  2468. int iPct = MINMAX(0, item->GetValue(1), 100);
  2469. if (GetSkillLevel(dwSkillVnum)>=20 || dwSkillVnum-SKILL_LANGUAGE1+1 == GetEmpire()) {
  2470. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì ¿Ïº®ÇÏ°Ô ¾Ë¾ÆµéÀ» ¼ö ÀÖ´Â ¾ð¾îÀÌ´Ù."));
  2471. return false;
  2472. }
  2473.  
  2474. if (LearnSkillByBook(dwSkillVnum, iPct)) {
  2475. ITEM_MANAGER::instance().RemoveItem(item);
  2476.  
  2477. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2478.  
  2479. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  2480. }
  2481. }
  2482. break;
  2483.  
  2484. case 50061 : {
  2485. if (IsPolymorphed()) {
  2486. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("º¯½ÅÁß¿¡´Â Ã¥À» ÀÐÀ»¼ö ¾ø½À´Ï´Ù."));
  2487. return false;
  2488.  
  2489. }
  2490. DWORD dwSkillVnum = item->GetValue(0);
  2491. int iPct = MINMAX(0, item->GetValue(1), 100);
  2492.  
  2493. if (GetSkillLevel(dwSkillVnum) >= 10) {
  2494. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ÀÌ»ó ¼ö·ÃÇÒ ¼ö ¾ø½À´Ï´Ù."));
  2495. return false;
  2496. }
  2497.  
  2498. if (LearnSkillByBook(dwSkillVnum, iPct)) {
  2499. ITEM_MANAGER::instance().RemoveItem(item);
  2500.  
  2501. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2502.  
  2503. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  2504. }
  2505. }
  2506. break;
  2507.  
  2508. case 50314:
  2509. case 50315:
  2510. case 50316:
  2511. case 50323:
  2512. case 50324:
  2513. case 50325:
  2514. case 50326: {
  2515. if (IsPolymorphed() == true) {
  2516. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µÐ°© Áß¿¡´Â ´É·ÂÀ» ¿Ã¸± ¼ö ¾ø½À´Ï´Ù."));
  2517. return false;
  2518. }
  2519.  
  2520. int iSkillLevelLowLimit = item->GetValue(0);
  2521. int iSkillLevelHighLimit = item->GetValue(1);
  2522. int iPct = MINMAX(0, item->GetValue(2), 100);
  2523. int iLevelLimit = item->GetValue(3);
  2524. DWORD dwSkillVnum = 0;
  2525.  
  2526. switch (item->GetVnum()) {
  2527. case 50314:
  2528. case 50315:
  2529. case 50316:
  2530. dwSkillVnum = SKILL_POLYMORPH;
  2531. break;
  2532.  
  2533. case 50323:
  2534. case 50324:
  2535. dwSkillVnum = SKILL_ADD_HP;
  2536. break;
  2537.  
  2538. case 50325:
  2539. case 50326:
  2540. dwSkillVnum = SKILL_RESIST_PENETRATE;
  2541. break;
  2542.  
  2543. default:
  2544. return false;
  2545. }
  2546.  
  2547. if (0 == dwSkillVnum)
  2548. return false;
  2549.  
  2550. if (GetLevel() < iLevelLimit) {
  2551. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ Ã¥À» ÀÐÀ¸·Á¸é ·¹º§À» ´õ ¿Ã·Á¾ß ÇÕ´Ï´Ù."));
  2552. return false;
  2553. }
  2554.  
  2555. if (GetSkillLevel(dwSkillVnum) >= 40) {
  2556. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ÀÌ»ó ¼ö·ÃÇÒ ¼ö ¾ø½À´Ï´Ù."));
  2557. return false;
  2558. }
  2559.  
  2560. if (GetSkillLevel(dwSkillVnum) < iSkillLevelLowLimit) {
  2561. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ Ã¥Àº ³Ê¹« ¾î·Á¿ö ÀÌÇØÇϱⰡ Èûµì´Ï´Ù."));
  2562. return false;
  2563. }
  2564.  
  2565. if (GetSkillLevel(dwSkillVnum) >= iSkillLevelHighLimit) {
  2566. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ Ã¥À¸·Î´Â ´õ ÀÌ»ó ¼ö·ÃÇÒ ¼ö ¾ø½À´Ï´Ù."));
  2567. return false;
  2568. }
  2569.  
  2570. if (LearnSkillByBook(dwSkillVnum, iPct)) {
  2571. ITEM_MANAGER::instance().RemoveItem(item);
  2572.  
  2573. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2574.  
  2575. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  2576. }
  2577. }
  2578. break;
  2579.  
  2580. case 50902:
  2581. case 50903:
  2582. case 50904: {
  2583. if (IsPolymorphed()) {
  2584. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("º¯½ÅÁß¿¡´Â Ã¥À» ÀÐÀ»¼ö ¾ø½À´Ï´Ù."));
  2585. return false;
  2586.  
  2587. }
  2588. DWORD dwSkillVnum = SKILL_CREATE;
  2589. int iPct = MINMAX(0, item->GetValue(1), 100);
  2590.  
  2591. if (GetSkillLevel(dwSkillVnum)>=40) {
  2592. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ÀÌ»ó ¼ö·ÃÇÒ ¼ö ¾ø½À´Ï´Ù."));
  2593. return false;
  2594. }
  2595.  
  2596. if (LearnSkillByBook(dwSkillVnum, iPct)) {
  2597. ITEM_MANAGER::instance().RemoveItem(item);
  2598.  
  2599. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2600.  
  2601. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  2602.  
  2603. if (test_server) {
  2604. ChatPacket(CHAT_TYPE_INFO, "[TEST_SERVER] Success to learn skill ");
  2605. }
  2606. } else {
  2607. if (test_server) {
  2608. ChatPacket(CHAT_TYPE_INFO, "[TEST_SERVER] Failed to learn skill ");
  2609. }
  2610. }
  2611. }
  2612. break;
  2613.  
  2614. case ITEM_MINING_SKILL_TRAIN_BOOK: {
  2615. if (IsPolymorphed()) {
  2616. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("º¯½ÅÁß¿¡´Â Ã¥À» ÀÐÀ»¼ö ¾ø½À´Ï´Ù."));
  2617. return false;
  2618.  
  2619. }
  2620. DWORD dwSkillVnum = SKILL_MINING;
  2621. int iPct = MINMAX(0, item->GetValue(1), 100);
  2622.  
  2623. if (GetSkillLevel(dwSkillVnum)>=40) {
  2624. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ÀÌ»ó ¼ö·ÃÇÒ ¼ö ¾ø½À´Ï´Ù."));
  2625. return false;
  2626. }
  2627.  
  2628. if (LearnSkillByBook(dwSkillVnum, iPct)) {
  2629. ITEM_MANAGER::instance().RemoveItem(item);
  2630.  
  2631. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2632.  
  2633. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  2634. }
  2635. }
  2636. break;
  2637.  
  2638. case ITEM_HORSE_SKILL_TRAIN_BOOK: {
  2639. if (IsPolymorphed()) {
  2640. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("º¯½ÅÁß¿¡´Â Ã¥À» ÀÐÀ»¼ö ¾ø½À´Ï´Ù."));
  2641. return false;
  2642.  
  2643. }
  2644. DWORD dwSkillVnum = SKILL_HORSE;
  2645. int iPct = MINMAX(0, item->GetValue(1), 100);
  2646.  
  2647. if (GetLevel() < 50) {
  2648. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÁ÷ ½Â¸¶ ½ºÅ³À» ¼ö·ÃÇÒ ¼ö ÀÖ´Â ·¹º§ÀÌ ¾Æ´Õ´Ï´Ù."));
  2649. return false;
  2650. }
  2651.  
  2652. if (!test_server && get_global_time() < GetSkillNextReadTime(dwSkillVnum)) {
  2653. if (FindAffect(AFFECT_SKILL_NO_BOOK_DELAY)) {
  2654. RemoveAffect(AFFECT_SKILL_NO_BOOK_DELAY);
  2655. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á־ȼú¼­¸¦ ÅëÇØ ÁÖÈ­ÀÔ¸¶¿¡¼­ ºüÁ®³ª¿Ô½À´Ï´Ù."));
  2656. } else {
  2657. SkillLearnWaitMoreTimeMessage(GetSkillNextReadTime(dwSkillVnum) - get_global_time());
  2658. return false;
  2659. }
  2660. }
  2661.  
  2662. if (GetPoint(POINT_HORSE_SKILL) >= 20 ||
  2663. GetSkillLevel(SKILL_HORSE_WILDATTACK) + GetSkillLevel(SKILL_HORSE_CHARGE) + GetSkillLevel(SKILL_HORSE_ESCAPE) >= 60 ||
  2664. GetSkillLevel(SKILL_HORSE_WILDATTACK_RANGE) + GetSkillLevel(SKILL_HORSE_CHARGE) + GetSkillLevel(SKILL_HORSE_ESCAPE) >= 60) {
  2665. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ÀÌ»ó ½Â¸¶ ¼ö·Ã¼­¸¦ ÀÐÀ» ¼ö ¾ø½À´Ï´Ù."));
  2666. return false;
  2667. }
  2668.  
  2669. if (number(1, 100) <= iPct) {
  2670. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("½Â¸¶ ¼ö·Ã¼­¸¦ ÀÐ¾î ½Â¸¶ ½ºÅ³ Æ÷ÀÎÆ®¸¦ ¾ò¾ú½À´Ï´Ù."));
  2671. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾òÀº Æ÷ÀÎÆ®·Î´Â ½Â¸¶ ½ºÅ³ÀÇ ·¹º§À» ¿Ã¸± ¼ö ÀÖ½À´Ï´Ù."));
  2672. PointChange(POINT_HORSE_SKILL, 1);
  2673.  
  2674. int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2675.  
  2676. if (!test_server)
  2677. SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  2678. } else {
  2679. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("½Â¸¶ ¼ö·Ã¼­ ÀÌÇØ¿¡ ½ÇÆÐÇÏ¿´½À´Ï´Ù."));
  2680. }
  2681.  
  2682. ITEM_MANAGER::instance().RemoveItem(item);
  2683. }
  2684. break;
  2685.  
  2686. case 70102:
  2687. case 70103: {
  2688. if (GetAlignment() >= 0)
  2689. return false;
  2690.  
  2691. int delta = MIN(-GetAlignment(), item->GetValue(0));
  2692.  
  2693. sys_log(0, "%s ALIGNMENT ITEM %d", GetName(), delta);
  2694.  
  2695. UpdateAlignment(delta);
  2696. item->SetCount(item->GetCount() - 1);
  2697.  
  2698. if (delta / 10 > 0) {
  2699. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¸¶À½ÀÌ ¸¼¾ÆÁö´Â±º. °¡½¿À» Áþ´©¸£´ø ¹«¾ð°¡°¡ Á» °¡º­¿öÁø ´À³¦À̾ß."));
  2700. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼±¾ÇÄ¡°¡ %d Áõ°¡ÇÏ¿´½À´Ï´Ù."), delta/10);
  2701. }
  2702. }
  2703. break;
  2704.  
  2705. case 71107: {
  2706. int val = item->GetValue(0);
  2707. int interval = item->GetValue(1);
  2708. quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetPlayerID());
  2709. int last_use_time = pPC->GetFlag("mythical_peach.last_use_time");
  2710.  
  2711. if (get_global_time() - last_use_time < interval * 60 * 60) {
  2712. if (test_server == false) {
  2713. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÁ÷ »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  2714. return false;
  2715. } else {
  2716. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Å×½ºÆ® ¼­¹ö ½Ã°£Á¦ÇÑ Åë°ú"));
  2717. }
  2718. }
  2719.  
  2720. if (GetAlignment() == 200000) {
  2721. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼±¾ÇÄ¡¸¦ ´õ ÀÌ»ó ¿Ã¸± ¼ö ¾ø½À´Ï´Ù."));
  2722. return false;
  2723. }
  2724.  
  2725. if (200000 - GetAlignment() < val * 10) {
  2726. val = (200000 - GetAlignment()) / 10;
  2727. }
  2728.  
  2729. int old_alignment = GetAlignment() / 10;
  2730.  
  2731. UpdateAlignment(val*10);
  2732.  
  2733. item->SetCount(item->GetCount()-1);
  2734. pPC->SetFlag("mythical_peach.last_use_time", get_global_time());
  2735.  
  2736. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¸¶À½ÀÌ ¸¼¾ÆÁö´Â±º. °¡½¿À» Áþ´©¸£´ø ¹«¾ð°¡°¡ Á» °¡º­¿öÁø ´À³¦À̾ß."));
  2737. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼±¾ÇÄ¡°¡ %d Áõ°¡ÇÏ¿´½À´Ï´Ù."), val);
  2738.  
  2739. char buf[256 + 1];
  2740. snprintf(buf, sizeof(buf), "%d %d", old_alignment, GetAlignment() / 10);
  2741. LogManager::instance().CharLog(this, val, "MYTHICAL_PEACH", buf);
  2742. }
  2743. break;
  2744.  
  2745. case 71109:
  2746. case 72719: {
  2747. LPITEM item2;
  2748.  
  2749. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  2750. return false;
  2751.  
  2752. if (item2->IsExchanging() || item2->IsEquipped()) //Fix
  2753. return false;
  2754.  
  2755. if (item2->GetSocketCount() == 0)
  2756. return false;
  2757.  
  2758. if (item2->IsEquipped())
  2759. return false;
  2760.  
  2761. switch( item2->GetType() ) {
  2762. case ITEM_WEAPON:
  2763. break;
  2764. case ITEM_ARMOR:
  2765. switch (item2->GetSubType()) {
  2766. case ARMOR_EAR:
  2767. case ARMOR_WRIST:
  2768. case ARMOR_NECK:
  2769. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»©³¾ ¿µ¼®ÀÌ ¾ø½À´Ï´Ù"));
  2770. return false;
  2771. }
  2772. break;
  2773.  
  2774. default:
  2775. return false;
  2776. }
  2777.  
  2778. std::stack<long> socket;
  2779.  
  2780. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  2781. socket.push(item2->GetSocket(i));
  2782.  
  2783. int idx = ITEM_SOCKET_MAX_NUM - 1;
  2784.  
  2785. while (socket.size() > 0) {
  2786. if (socket.top() > 2 && socket.top() != ITEM_BROKEN_METIN_VNUM)
  2787. break;
  2788.  
  2789. idx--;
  2790. socket.pop();
  2791. }
  2792.  
  2793. if (socket.size() == 0) {
  2794. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»©³¾ ¿µ¼®ÀÌ ¾ø½À´Ï´Ù"));
  2795. return false;
  2796. }
  2797.  
  2798. LPITEM pItemReward = AutoGiveItem(socket.top());
  2799.  
  2800. if (pItemReward != NULL) {
  2801. item2->SetSocket(idx, 1);
  2802.  
  2803. char buf[256+1];
  2804. snprintf(buf, sizeof(buf), "%s(%u) %s(%u)",
  2805. item2->GetName(), item2->GetID(), pItemReward->GetName(), pItemReward->GetID());
  2806. LogManager::instance().ItemLog(this, item, "USE_DETACHMENT_ONE", buf);
  2807.  
  2808. item->SetCount(item->GetCount() - 1);
  2809. }
  2810. }
  2811. break;
  2812.  
  2813. case 70201:
  2814. case 70202:
  2815. case 70203:
  2816. case 70204:
  2817. case 70205:
  2818. case 70206: {
  2819. if (GetPart(PART_HAIR) >= 1001) {
  2820. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÇöÀç Çì¾î½ºÅ¸ÀÏ¿¡¼­´Â ¿°»ö°ú Å»»öÀÌ ºÒ°¡´ÉÇÕ´Ï´Ù."));
  2821. } else {
  2822. quest::CQuestManager& q = quest::CQuestManager::instance();
  2823. quest::PC* pPC = q.GetPC(GetPlayerID());
  2824.  
  2825. if (pPC) {
  2826. int last_dye_level = pPC->GetFlag("dyeing_hair.last_dye_level");
  2827.  
  2828. if (last_dye_level == 0 ||
  2829. last_dye_level+3 <= GetLevel() ||
  2830. item->GetVnum() == 70201) {
  2831. SetPart(PART_HAIR, item->GetVnum() - 70201);
  2832.  
  2833. if (item->GetVnum() == 70201)
  2834. pPC->SetFlag("dyeing_hair.last_dye_level", 0);
  2835. else
  2836. pPC->SetFlag("dyeing_hair.last_dye_level", GetLevel());
  2837.  
  2838. item->SetCount(item->GetCount() - 1);
  2839. UpdatePacket();
  2840. } else {
  2841. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d ·¹º§ÀÌ µÇ¾î¾ß ´Ù½Ã ¿°»öÇÏ½Ç ¼ö ÀÖ½À´Ï´Ù."), last_dye_level+3);
  2842. }
  2843. }
  2844. }
  2845. }
  2846. break;
  2847.  
  2848. case ITEM_NEW_YEAR_GREETING_VNUM: {
  2849. DWORD dwBoxVnum = ITEM_NEW_YEAR_GREETING_VNUM;
  2850. std::vector <DWORD> dwVnums;
  2851. std::vector <DWORD> dwCounts;
  2852. std::vector <LPITEM> item_gets;
  2853. int count = 0;
  2854.  
  2855. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count)) {
  2856. for (int i = 0; i < count; i++) {
  2857. if (dwVnums[i] == CSpecialItemGroup::GOLD)
  2858. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ· %d ³ÉÀ» ȹµæÇß½À´Ï´Ù."), dwCounts[i]);
  2859. }
  2860.  
  2861. item->SetCount(item->GetCount() - 1);
  2862. }
  2863. }
  2864. break;
  2865.  
  2866. case ITEM_VALENTINE_ROSE:
  2867. case ITEM_VALENTINE_CHOCOLATE: {
  2868. DWORD dwBoxVnum = item->GetVnum();
  2869. std::vector <DWORD> dwVnums;
  2870. std::vector <DWORD> dwCounts;
  2871. std::vector <LPITEM> item_gets(NULL);
  2872. int count = 0;
  2873.  
  2874.  
  2875. if (item->GetVnum() == ITEM_VALENTINE_ROSE && SEX_MALE==GET_SEX(this) ||
  2876. item->GetVnum() == ITEM_VALENTINE_CHOCOLATE && SEX_FEMALE==GET_SEX(this)) {
  2877. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ºº°ÀÌ ¸ÂÁö¾Ê¾Æ ÀÌ ¾ÆÀÌÅÛÀ» ¿­ ¼ö ¾ø½À´Ï´Ù."));
  2878. return false;
  2879. }
  2880.  
  2881.  
  2882. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  2883. item->SetCount(item->GetCount()-1);
  2884. }
  2885. break;
  2886.  
  2887. case ITEM_WHITEDAY_CANDY:
  2888. case ITEM_WHITEDAY_ROSE: {
  2889. DWORD dwBoxVnum = item->GetVnum();
  2890. std::vector <DWORD> dwVnums;
  2891. std::vector <DWORD> dwCounts;
  2892. std::vector <LPITEM> item_gets(NULL);
  2893. int count = 0;
  2894.  
  2895.  
  2896. if (item->GetVnum() == ITEM_WHITEDAY_CANDY && SEX_MALE==GET_SEX(this) ||
  2897. item->GetVnum() == ITEM_WHITEDAY_ROSE && SEX_FEMALE==GET_SEX(this)) {
  2898. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ºº°ÀÌ ¸ÂÁö¾Ê¾Æ ÀÌ ¾ÆÀÌÅÛÀ» ¿­ ¼ö ¾ø½À´Ï´Ù."));
  2899. return false;
  2900. }
  2901.  
  2902.  
  2903. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  2904. item->SetCount(item->GetCount()-1);
  2905. }
  2906. break;
  2907.  
  2908. case 50011: {
  2909. DWORD dwBoxVnum = 50011;
  2910. std::vector <DWORD> dwVnums;
  2911. std::vector <DWORD> dwCounts;
  2912. std::vector <LPITEM> item_gets(NULL);
  2913. int count = 0;
  2914.  
  2915. if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count)) {
  2916. for (int i = 0; i < count; i++) {
  2917. char buf[50 + 1];
  2918. snprintf(buf, sizeof(buf), "%u %u", dwVnums[i], dwCounts[i]);
  2919. LogManager::instance().ItemLog(this, item, "MOONLIGHT_GET", buf);
  2920.  
  2921. item->SetCount(item->GetCount() - 1);
  2922.  
  2923. switch (dwVnums[i]) {
  2924. case CSpecialItemGroup::GOLD:
  2925. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ· %d ³ÉÀ» ȹµæÇß½À´Ï´Ù."), dwCounts[i]);
  2926. break;
  2927.  
  2928. case CSpecialItemGroup::EXP:
  2929. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ºÎÅÍ ½ÅºñÇÑ ºûÀÌ ³ª¿É´Ï´Ù."));
  2930. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%dÀÇ °æÇèÄ¡¸¦ ȹµæÇß½À´Ï´Ù."), dwCounts[i]);
  2931. break;
  2932.  
  2933. case CSpecialItemGroup::MOB:
  2934. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ¸ó½ºÅÍ°¡ ³ªÅ¸³µ½À´Ï´Ù!"));
  2935. break;
  2936.  
  2937. case CSpecialItemGroup::SLOW:
  2938. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ³ª¿Â »¡°£ ¿¬±â¸¦ µéÀ̸¶½ÃÀÚ ¿òÁ÷ÀÌ´Â ¼Óµµ°¡ ´À·ÁÁ³½À´Ï´Ù!"));
  2939. break;
  2940.  
  2941. case CSpecialItemGroup::DRAIN_HP:
  2942. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ°¡ °©ÀÚ±â Æø¹ßÇÏ¿´½À´Ï´Ù! »ý¸í·ÂÀÌ °¨¼ÒÇß½À´Ï´Ù."));
  2943. break;
  2944.  
  2945. case CSpecialItemGroup::POISON:
  2946. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ³ª¿Â ³ì»ö ¿¬±â¸¦ µéÀ̸¶½ÃÀÚ µ¶ÀÌ ¿Â¸öÀ¸·Î ÆÛÁý´Ï´Ù!"));
  2947. break;
  2948.  
  2949. case CSpecialItemGroup::MOB_GROUP:
  2950. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ ¸ó½ºÅÍ°¡ ³ªÅ¸³µ½À´Ï´Ù!"));
  2951. break;
  2952.  
  2953. default:
  2954. if (item_gets[i]) {
  2955. if (dwCounts[i] > 1)
  2956. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ %s °¡ %d °³ ³ª¿Ô½À´Ï´Ù."), item_gets[i]->GetName(), dwCounts[i]);
  2957. else
  2958. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»óÀÚ¿¡¼­ %s °¡ ³ª¿Ô½À´Ï´Ù."), item_gets[i]->GetName());
  2959. }
  2960. break;
  2961. }
  2962. }
  2963. } else {
  2964. ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("¾Æ¹«°Íµµ ¾òÀ» ¼ö ¾ø¾ú½À´Ï´Ù."));
  2965. return false;
  2966. }
  2967. }
  2968. break;
  2969.  
  2970. case ITEM_GIVE_STAT_RESET_COUNT_VNUM: {
  2971. PointChange(POINT_STAT_RESET_COUNT, 1);
  2972. item->SetCount(item->GetCount()-1);
  2973. }
  2974. break;
  2975.  
  2976. case 50107: {
  2977. EffectPacket(SE_CHINA_FIREWORK);
  2978. AddAffect(AFFECT_CHINA_FIREWORK, POINT_STUN_PCT, 30, AFF_CHINA_FIREWORK, 5*60, 0, true);
  2979. item->SetCount(item->GetCount()-1);
  2980. }
  2981. break;
  2982.  
  2983. case 50108: {
  2984. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true) {
  2985. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ã Áß¿¡´Â ÀÌ¿ëÇÒ ¼ö ¾ø´Â ¹°Ç°ÀÔ´Ï´Ù."));
  2986. return false;
  2987. }
  2988.  
  2989. EffectPacket(SE_SPIN_TOP);
  2990. AddAffect(AFFECT_CHINA_FIREWORK, POINT_STUN_PCT, 30, AFF_CHINA_FIREWORK, 5*60, 0, true);
  2991. item->SetCount(item->GetCount()-1);
  2992. }
  2993. break;
  2994.  
  2995. case ITEM_WONSO_BEAN_VNUM:
  2996. PointChange(POINT_HP, GetMaxHP() - GetHP());
  2997. item->SetCount(item->GetCount()-1);
  2998. break;
  2999.  
  3000. case ITEM_WONSO_SUGAR_VNUM:
  3001. PointChange(POINT_SP, GetMaxSP() - GetSP());
  3002. item->SetCount(item->GetCount()-1);
  3003. break;
  3004.  
  3005. case ITEM_WONSO_FRUIT_VNUM:
  3006. PointChange(POINT_STAMINA, GetMaxStamina()-GetStamina());
  3007. item->SetCount(item->GetCount()-1);
  3008. break;
  3009.  
  3010. case ITEM_ELK_VNUM: {
  3011. int iGold = item->GetSocket(0);
  3012. ITEM_MANAGER::instance().RemoveItem(item);
  3013. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ· %d ³ÉÀ» ȹµæÇß½À´Ï´Ù."), iGold);
  3014. PointChange(POINT_GOLD, iGold);
  3015. }
  3016. break;
  3017.  
  3018. //±ºÁÖÀÇ ÁõÇ¥
  3019. case 70021: {
  3020. int HealPrice = quest::CQuestManager::instance().GetEventFlag("MonarchHealGold");
  3021. if (HealPrice == 0)
  3022. HealPrice = 2000000;
  3023.  
  3024. if (CMonarch::instance().HealMyEmpire(this, HealPrice)) {
  3025. char szNotice[256];
  3026. snprintf(szNotice, sizeof(szNotice), LC_TEXT("±ºÁÖÀÇ ÃູÀ¸·Î ÀÌÁö¿ª %s À¯Àú´Â HP,SP°¡ ¸ðµÎ ä¿öÁý´Ï´Ù."), EMPIRE_NAME(GetEmpire()));
  3027. SendNoticeMap(szNotice, GetMapIndex(), false);
  3028.  
  3029. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±ºÁÖÀÇ ÃູÀ» »ç¿ëÇÏ¿´½À´Ï´Ù."));
  3030. }
  3031. }
  3032. break;
  3033.  
  3034. case 27995: {
  3035. }
  3036. break;
  3037.  
  3038. case 71092 : {
  3039. if (m_pkChrTarget != NULL) {
  3040. if (m_pkChrTarget->IsPolymorphed()) {
  3041. m_pkChrTarget->SetPolymorph(0);
  3042. m_pkChrTarget->RemoveAffect(AFFECT_POLYMORPH);
  3043. }
  3044. } else {
  3045. if (IsPolymorphed()) {
  3046. SetPolymorph(0);
  3047. RemoveAffect(AFFECT_POLYMORPH);
  3048. }
  3049. }
  3050. }
  3051. break;
  3052.  
  3053. case 71051 : {
  3054. //return false;
  3055.  
  3056. LPITEM item2;
  3057.  
  3058. if (!IsValidItemPosition(DestCell) || !(item2 = GetInventoryItem(wDestCell)))
  3059. return false;
  3060.  
  3061. if (ITEM_COSTUME == item2->GetType()) //Fix
  3062. {
  3063. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  3064. return false;
  3065. }
  3066.  
  3067. if (item2->IsExchanging() || item2->IsEquipped()) //Fix
  3068. return false;
  3069.  
  3070.  
  3071. if (item2->GetAttributeSetIndex() == -1) {
  3072. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  3073. return false;
  3074. }
  3075.  
  3076. if (item2->AddRareAttribute() == true) {
  3077. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼º°øÀûÀ¸·Î ¼Ó¼ºÀÌ Ãß°¡ µÇ¾ú½À´Ï´Ù"));
  3078.  
  3079. int iAddedIdx = item2->GetRareAttrCount() + 4;
  3080. char buf[21];
  3081. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  3082.  
  3083. LogManager::instance().ItemLog(
  3084. GetPlayerID(),
  3085. item2->GetAttributeType(iAddedIdx),
  3086. item2->GetAttributeValue(iAddedIdx),
  3087. item->GetID(),
  3088. "ADD_RARE_ATTR",
  3089. buf,
  3090. GetDesc()->GetHostName(),
  3091. item->GetOriginalVnum());
  3092.  
  3093. item->SetCount(item->GetCount() - 1);
  3094. } else {
  3095. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ÀÌ»ó ÀÌ ¾ÆÀÌÅÛÀ¸·Î ¼Ó¼ºÀ» Ãß°¡ÇÒ ¼ö ¾ø½À´Ï´Ù"));
  3096. }
  3097. }
  3098. break;
  3099.  
  3100. case 71052 : {
  3101.  
  3102. LPITEM item2;
  3103.  
  3104. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  3105. return false;
  3106.  
  3107. if (ITEM_COSTUME == item2->GetType()) //Fix
  3108. {
  3109. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  3110. return false;
  3111. }
  3112.  
  3113. if (item2->IsExchanging() || item2->IsEquipped()) //Fix
  3114. return false;
  3115.  
  3116. if (item2->GetAttributeSetIndex() == -1) {
  3117. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  3118. return false;
  3119. }
  3120.  
  3121. if (item2->IsEquipped()) {
  3122. ChatPacket(CHAT_TYPE_INFO, "Voce nao pode fazer isso noob.");
  3123. return false;
  3124. }
  3125.  
  3126. if (item2->ChangeRareAttribute() == true) {
  3127. char buf[21];
  3128. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  3129. LogManager::instance().ItemLog(this, item, "CHANGE_RARE_ATTR", buf);
  3130.  
  3131. item->SetCount(item->GetCount() - 1);
  3132. } else {
  3133. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("º¯°æ ½Ãų ¼Ó¼ºÀÌ ¾ø½À´Ï´Ù"));
  3134. }
  3135. }
  3136. break;
  3137.  
  3138. case ITEM_AUTO_HP_RECOVERY_S:
  3139. case ITEM_AUTO_HP_RECOVERY_M:
  3140. case ITEM_AUTO_HP_RECOVERY_L:
  3141. case ITEM_AUTO_HP_RECOVERY_X:
  3142. case ITEM_AUTO_SP_RECOVERY_S:
  3143. case ITEM_AUTO_SP_RECOVERY_M:
  3144. case ITEM_AUTO_SP_RECOVERY_L:
  3145. case ITEM_AUTO_SP_RECOVERY_X:
  3146. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_XS:
  3147. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_S:
  3148. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_XS:
  3149. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_S: {
  3150. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true) {
  3151. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ÃÀå¿¡¼­ »ç¿ëÇÏ½Ç ¼ö ¾ø½À´Ï´Ù."));
  3152. return false;
  3153. }
  3154.  
  3155. EAffectTypes type = AFFECT_NONE;
  3156. bool isSpecialPotion = false;
  3157.  
  3158. switch (item->GetVnum()) {
  3159. case ITEM_AUTO_HP_RECOVERY_X:
  3160. isSpecialPotion = true;
  3161.  
  3162. case ITEM_AUTO_HP_RECOVERY_S:
  3163. case ITEM_AUTO_HP_RECOVERY_M:
  3164. case ITEM_AUTO_HP_RECOVERY_L:
  3165. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_XS:
  3166. case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_S:
  3167. type = AFFECT_AUTO_HP_RECOVERY;
  3168. break;
  3169.  
  3170. case ITEM_AUTO_SP_RECOVERY_X:
  3171. isSpecialPotion = true;
  3172.  
  3173. case ITEM_AUTO_SP_RECOVERY_S:
  3174. case ITEM_AUTO_SP_RECOVERY_M:
  3175. case ITEM_AUTO_SP_RECOVERY_L:
  3176. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_XS:
  3177. case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_S:
  3178. type = AFFECT_AUTO_SP_RECOVERY;
  3179. break;
  3180. }
  3181.  
  3182. if (AFFECT_NONE == type)
  3183. break;
  3184.  
  3185. if (item->GetCount() > 1) {
  3186. int pos = GetEmptyInventory(item->GetSize());
  3187.  
  3188. if (-1 == pos) {
  3189. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ÒÁöÇ°¿¡ ºó °ø°£ÀÌ ¾ø½À´Ï´Ù."));
  3190. break;
  3191. }
  3192.  
  3193. item->SetCount( item->GetCount() - 1 );
  3194.  
  3195. LPITEM item2 = ITEM_MANAGER::instance().CreateItem( item->GetVnum(), 1 );
  3196. item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
  3197.  
  3198. if (item->GetSocket(1) != 0) {
  3199. item2->SetSocket(1, item->GetSocket(1));
  3200. }
  3201.  
  3202. item = item2;
  3203. }
  3204.  
  3205. CAffect* pAffect = FindAffect( type );
  3206.  
  3207. if (NULL == pAffect) {
  3208. EPointTypes bonus = POINT_NONE;
  3209.  
  3210. if (true == isSpecialPotion) {
  3211. if (type == AFFECT_AUTO_HP_RECOVERY) {
  3212. bonus = POINT_MAX_HP_PCT;
  3213. } else if (type == AFFECT_AUTO_SP_RECOVERY) {
  3214. bonus = POINT_MAX_SP_PCT;
  3215. }
  3216. }
  3217.  
  3218. AddAffect( type, bonus, 4, item->GetID(), INFINITE_AFFECT_DURATION, 0, true, false);
  3219.  
  3220. item->Lock(true);
  3221. item->SetSocket(0, true);
  3222.  
  3223. AutoRecoveryItemProcess( type );
  3224. } else {
  3225. if (item->GetID() == pAffect->dwFlag) {
  3226. RemoveAffect( pAffect );
  3227.  
  3228. item->Lock(false);
  3229. item->SetSocket(0, false);
  3230. } else {
  3231. LPITEM old = FindItemByID( pAffect->dwFlag );
  3232.  
  3233. if (NULL != old) {
  3234. old->Lock(false);
  3235. old->SetSocket(0, false);
  3236. }
  3237.  
  3238. RemoveAffect( pAffect );
  3239.  
  3240. EPointTypes bonus = POINT_NONE;
  3241.  
  3242. if (true == isSpecialPotion) {
  3243. if (type == AFFECT_AUTO_HP_RECOVERY) {
  3244. bonus = POINT_MAX_HP_PCT;
  3245. } else if (type == AFFECT_AUTO_SP_RECOVERY) {
  3246. bonus = POINT_MAX_SP_PCT;
  3247. }
  3248. }
  3249.  
  3250. AddAffect( type, bonus, 4, item->GetID(), INFINITE_AFFECT_DURATION, 0, true, false);
  3251.  
  3252. item->Lock(true);
  3253. item->SetSocket(0, true);
  3254.  
  3255. AutoRecoveryItemProcess( type );
  3256. }
  3257. }
  3258. }
  3259. break;
  3260. }
  3261. break;
  3262.  
  3263. case USE_CLEAR: {
  3264. RemoveBadAffect();
  3265. item->SetCount(item->GetCount() - 1);
  3266. }
  3267. break;
  3268.  
  3269. case USE_INVISIBILITY: {
  3270. if (item->GetVnum() == 70026) {
  3271. quest::CQuestManager& q = quest::CQuestManager::instance();
  3272. quest::PC* pPC = q.GetPC(GetPlayerID());
  3273.  
  3274. if (pPC != NULL) {
  3275. int last_use_time = pPC->GetFlag("mirror_of_disapper.last_use_time");
  3276.  
  3277. if (get_global_time() - last_use_time < 10*60) {
  3278. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÁ÷ »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  3279. return false;
  3280. }
  3281.  
  3282. pPC->SetFlag("mirror_of_disapper.last_use_time", get_global_time());
  3283. }
  3284. }
  3285.  
  3286. AddAffect(AFFECT_INVISIBILITY, POINT_NONE, 0, AFF_INVISIBILITY, 300, 0, true);
  3287. item->SetCount(item->GetCount() - 1);
  3288. }
  3289. break;
  3290.  
  3291. case USE_POTION_NODELAY: {
  3292. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true) {
  3293. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0) {
  3294. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ÃÀå¿¡¼­ »ç¿ëÇÏ½Ç ¼ö ¾ø½À´Ï´Ù."));
  3295. return false;
  3296. }
  3297.  
  3298. switch (item->GetVnum()) {
  3299. case 70020 :
  3300. case 71018 :
  3301. case 71019 :
  3302. case 71020 :
  3303. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000) {
  3304. if (m_nPotionLimit <= 0) {
  3305. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»ç¿ë Á¦ÇÑ·®À» ÃÊ°úÇÏ¿´½À´Ï´Ù."));
  3306. return false;
  3307. }
  3308. }
  3309. break;
  3310.  
  3311. default :
  3312. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ÃÀå¿¡¼­ »ç¿ëÇÏ½Ç ¼ö ¾ø½À´Ï´Ù."));
  3313. return false;
  3314. }
  3315. }
  3316.  
  3317. bool used = false;
  3318.  
  3319. if (item->GetValue(0) != 0) {
  3320. if (GetHP() < GetMaxHP()) {
  3321. PointChange(POINT_HP, item->GetValue(0) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  3322. EffectPacket(SE_HPUP_RED);
  3323. used = TRUE;
  3324. }
  3325. }
  3326.  
  3327. if (item->GetValue(1) != 0) {
  3328. if (GetSP() < GetMaxSP()) {
  3329. PointChange(POINT_SP, item->GetValue(1) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  3330. EffectPacket(SE_SPUP_BLUE);
  3331. used = TRUE;
  3332. }
  3333. }
  3334.  
  3335. if (item->GetValue(3) != 0) {
  3336. if (GetHP() < GetMaxHP()) {
  3337. PointChange(POINT_HP, item->GetValue(3) * GetMaxHP() / 100);
  3338. EffectPacket(SE_HPUP_RED);
  3339. used = TRUE;
  3340. }
  3341. }
  3342.  
  3343. if (item->GetValue(4) != 0) {
  3344. if (GetSP() < GetMaxSP()) {
  3345. PointChange(POINT_SP, item->GetValue(4) * GetMaxSP() / 100);
  3346. EffectPacket(SE_SPUP_BLUE);
  3347. used = TRUE;
  3348. }
  3349. }
  3350.  
  3351. if (used) {
  3352. if (item->GetVnum() == 50085 || item->GetVnum() == 50086) {
  3353. if (test_server)
  3354. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¿ùº´ ¶Ç´Â Á¾ÀÚ ¸¦ »ç¿ëÇÏ¿´½À´Ï´Ù"));
  3355. SetUseSeedOrMoonBottleTime();
  3356. }
  3357. if (GetDungeon())
  3358. GetDungeon()->UsePotion(this);
  3359.  
  3360. if (GetWarMap())
  3361. GetWarMap()->UsePotion(this, item);
  3362.  
  3363. m_nPotionLimit--;
  3364.  
  3365. item->SetCount(item->GetCount() - 1);
  3366. }
  3367. }
  3368. break;
  3369.  
  3370. case USE_POTION:
  3371. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true) {
  3372. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0) {
  3373. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ÃÀå¿¡¼­ »ç¿ëÇÏ½Ç ¼ö ¾ø½À´Ï´Ù."));
  3374. return false;
  3375. }
  3376.  
  3377. switch (item->GetVnum()) {
  3378. case 27001 :
  3379. case 27002 :
  3380. case 27003 :
  3381. case 27004 :
  3382. case 27005 :
  3383. case 27006 :
  3384. if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000) {
  3385. if (m_nPotionLimit <= 0) {
  3386. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»ç¿ë Á¦ÇÑ·®À» ÃÊ°úÇÏ¿´½À´Ï´Ù."));
  3387. return false;
  3388. }
  3389. }
  3390. break;
  3391.  
  3392. default :
  3393. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·ÃÀå¿¡¼­ »ç¿ëÇÏ½Ç ¼ö ¾ø½À´Ï´Ù."));
  3394. return false;
  3395. }
  3396. }
  3397.  
  3398. if (item->GetValue(1) != 0) {
  3399. if (GetPoint(POINT_SP_RECOVERY) + GetSP() >= GetMaxSP()) {
  3400. return false;
  3401. }
  3402.  
  3403. PointChange(POINT_SP_RECOVERY, item->GetValue(1) * MIN(200, (100 + GetPoint(POINT_POTION_BONUS))) / 100);
  3404. StartAffectEvent();
  3405. EffectPacket(SE_SPUP_BLUE);
  3406. }
  3407.  
  3408. if (item->GetValue(0) != 0) {
  3409. if (GetPoint(POINT_HP_RECOVERY) + GetHP() >= GetMaxHP()) {
  3410. return false;
  3411. }
  3412.  
  3413. PointChange(POINT_HP_RECOVERY, item->GetValue(0) * MIN(200, (100 + GetPoint(POINT_POTION_BONUS))) / 100);
  3414. StartAffectEvent();
  3415. EffectPacket(SE_HPUP_RED);
  3416. }
  3417.  
  3418. if (GetDungeon())
  3419. GetDungeon()->UsePotion(this);
  3420.  
  3421. if (GetWarMap())
  3422. GetWarMap()->UsePotion(this, item);
  3423.  
  3424. item->SetCount(item->GetCount() - 1);
  3425. m_nPotionLimit--;
  3426. break;
  3427.  
  3428. case USE_POTION_CONTINUE: {
  3429. if (item->GetValue(0) != 0) {
  3430. AddAffect(AFFECT_HP_RECOVER_CONTINUE, POINT_HP_RECOVER_CONTINUE, item->GetValue(0), 0, item->GetValue(2), 0, true);
  3431. } else if (item->GetValue(1) != 0) {
  3432. AddAffect(AFFECT_SP_RECOVER_CONTINUE, POINT_SP_RECOVER_CONTINUE, item->GetValue(1), 0, item->GetValue(2), 0, true);
  3433. } else
  3434. return false;
  3435. }
  3436.  
  3437. if (GetDungeon())
  3438. GetDungeon()->UsePotion(this);
  3439.  
  3440. if (GetWarMap())
  3441. GetWarMap()->UsePotion(this, item);
  3442.  
  3443. item->SetCount(item->GetCount() - 1);
  3444. break;
  3445.  
  3446. case USE_ABILITY_UP: {
  3447. switch (item->GetValue(0)) {
  3448. case APPLY_MOV_SPEED:
  3449. AddAffect(AFFECT_MOV_SPEED, POINT_MOV_SPEED, item->GetValue(2), AFF_MOV_SPEED_POTION, item->GetValue(1), 0, true);
  3450. break;
  3451.  
  3452. case APPLY_ATT_SPEED:
  3453. AddAffect(AFFECT_ATT_SPEED, POINT_ATT_SPEED, item->GetValue(2), AFF_ATT_SPEED_POTION, item->GetValue(1), 0, true);
  3454. break;
  3455.  
  3456. case APPLY_STR:
  3457. AddAffect(AFFECT_STR, POINT_ST, item->GetValue(2), 0, item->GetValue(1), 0, true);
  3458. break;
  3459.  
  3460. case APPLY_DEX:
  3461. AddAffect(AFFECT_DEX, POINT_DX, item->GetValue(2), 0, item->GetValue(1), 0, true);
  3462. break;
  3463.  
  3464. case APPLY_CON:
  3465. AddAffect(AFFECT_CON, POINT_HT, item->GetValue(2), 0, item->GetValue(1), 0, true);
  3466. break;
  3467.  
  3468. case APPLY_INT:
  3469. AddAffect(AFFECT_INT, POINT_IQ, item->GetValue(2), 0, item->GetValue(1), 0, true);
  3470. break;
  3471.  
  3472. case APPLY_CAST_SPEED:
  3473. AddAffect(AFFECT_CAST_SPEED, POINT_CASTING_SPEED, item->GetValue(2), 0, item->GetValue(1), 0, true);
  3474. break;
  3475.  
  3476. case APPLY_ATT_GRADE_BONUS:
  3477. AddAffect(AFFECT_ATT_GRADE, POINT_ATT_GRADE_BONUS,
  3478. item->GetValue(2), 0, item->GetValue(1), 0, true);
  3479. break;
  3480.  
  3481. case APPLY_DEF_GRADE_BONUS:
  3482. AddAffect(AFFECT_DEF_GRADE, POINT_DEF_GRADE_BONUS,
  3483. item->GetValue(2), 0, item->GetValue(1), 0, true);
  3484. break;
  3485. }
  3486. }
  3487.  
  3488. if (GetDungeon())
  3489. GetDungeon()->UsePotion(this);
  3490.  
  3491. if (GetWarMap())
  3492. GetWarMap()->UsePotion(this, item);
  3493.  
  3494. item->SetCount(item->GetCount() - 1);
  3495. break;
  3496.  
  3497. case USE_TALISMAN: {
  3498. const int TOWN_PORTAL = 1;
  3499. const int MEMORY_PORTAL = 2;
  3500.  
  3501. if (GetMapIndex() == 200 || GetMapIndex() == 113) {
  3502. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÇöÀç À§Ä¡¿¡¼­ »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  3503. return false;
  3504. }
  3505.  
  3506. if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true) {
  3507. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ë·Ã Áß¿¡´Â ÀÌ¿ëÇÒ ¼ö ¾ø´Â ¹°Ç°ÀÔ´Ï´Ù."));
  3508. return false;
  3509. }
  3510.  
  3511. if (m_pkWarpEvent) {
  3512. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("À̵¿ÇÒ Áغñ°¡ µÇ¾îÀÖÀ½À¸·Î ±ÍȯºÎ¸¦ »ç¿ëÇÒ¼ö ¾ø½À´Ï´Ù"));
  3513. return false;
  3514. }
  3515. int consumeLife = CalculateConsume(this);
  3516.  
  3517. if (consumeLife < 0)
  3518. return false;
  3519.  
  3520. if (item->GetValue(0) == TOWN_PORTAL) {
  3521. if (item->GetSocket(0) == 0) {
  3522. if (!GetDungeon())
  3523. if (!GiveRecallItem(item))
  3524. return false;
  3525.  
  3526. PIXEL_POSITION posWarp;
  3527.  
  3528. if (SECTREE_MANAGER::instance().GetRecallPositionByEmpire(GetMapIndex(), GetEmpire(), posWarp)) {
  3529. PointChange(POINT_HP, -consumeLife, false);
  3530. WarpSet(posWarp.x, posWarp.y);
  3531. } else {
  3532. sys_err("CHARACTER::UseItem : cannot find spawn position (name %s, %d x %d)", GetName(), GetX(), GetY());
  3533. }
  3534. } else {
  3535. if (test_server)
  3536. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¿ø·¡ À§Ä¡·Î º¹±Í"));
  3537.  
  3538. ProcessRecallItem(item);
  3539. }
  3540. } else if (item->GetValue(0) == MEMORY_PORTAL) {
  3541. if (item->GetSocket(0) == 0) {
  3542. if (GetDungeon()) {
  3543. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´øÀü ¾È¿¡¼­´Â %s%s »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."),
  3544. item->GetName(),
  3545. g_iUseLocale ? "" : (under_han(item->GetName()) ? LC_TEXT("À»") : LC_TEXT("¸¦")));
  3546. return false;
  3547. }
  3548.  
  3549. if (!GiveRecallItem(item))
  3550. return false;
  3551. } else {
  3552. PointChange(POINT_HP, -consumeLife, false);
  3553. ProcessRecallItem(item);
  3554. }
  3555. }
  3556. }
  3557. break;
  3558.  
  3559. case USE_TUNING:
  3560. case USE_DETACHMENT: {
  3561. LPITEM item2;
  3562.  
  3563. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  3564. return false;
  3565.  
  3566. if (item2->IsExchanging() || item2->IsEquipped()) //Fix
  3567. return false;
  3568.  
  3569. if (item2->GetVnum() >= 28330 && item2->GetVnum() <= 28343) {
  3570. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("+3 ¿µ¼®Àº ÀÌ ¾ÆÀÌÅÛÀ¸·Î °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù"));
  3571. return false;
  3572. }
  3573. if (item->GetValue(0) == ACCE_CLEAN_ATTR)
  3574. {
  3575. CleanAcceAttr(item, item2);
  3576. }
  3577. if (item2->GetVnum() >= 28430 && item2->GetVnum() <= 28443) {
  3578. if (item->GetVnum() == 71056) {
  3579. RefineItem(item, item2);
  3580. } else {
  3581. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¿µ¼®Àº ÀÌ ¾ÆÀÌÅÛÀ¸·Î °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù"));
  3582. }
  3583. } else {
  3584. RefineItem(item, item2);
  3585. }
  3586. }
  3587. break;
  3588.  
  3589. case USE_PUT_INTO_BELT_SOCKET:
  3590. case USE_PUT_INTO_RING_SOCKET:
  3591. case USE_PUT_INTO_ACCESSORY_SOCKET:
  3592. case USE_ADD_ACCESSORY_SOCKET:
  3593. case USE_CLEAN_SOCKET:
  3594. case USE_CHANGE_ATTRIBUTE:
  3595. case USE_CHANGE_ATTRIBUTE2 :
  3596. case USE_ADD_ATTRIBUTE:
  3597. case USE_ADD_ATTRIBUTE2: {
  3598. LPITEM item2;
  3599. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  3600. return false;
  3601.  
  3602. if (item2->IsEquipped()) {
  3603. BuffOnAttr_RemoveBuffsFromItem(item2);
  3604. }
  3605.  
  3606. if (ITEM_COSTUME == item2->GetType()) {
  3607. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  3608. return false;
  3609. }
  3610.  
  3611. if (item2->IsExchanging())
  3612. return false;
  3613.  
  3614. if (item2->IsEquipped())
  3615. return false;
  3616.  
  3617. switch (item->GetSubType()) {
  3618. case USE_CLEAN_SOCKET: {
  3619. int i;
  3620. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i) {
  3621. if (item2->GetSocket(i) == ITEM_BROKEN_METIN_VNUM)
  3622. break;
  3623. }
  3624.  
  3625. if (i == ITEM_SOCKET_MAX_NUM) {
  3626. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("û¼ÒÇÒ ¼®ÀÌ ¹ÚÇôÀÖÁö ¾Ê½À´Ï´Ù."));
  3627. return false;
  3628. }
  3629.  
  3630. int j = 0;
  3631.  
  3632. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i) {
  3633. if (item2->GetSocket(i) != ITEM_BROKEN_METIN_VNUM && item2->GetSocket(i) != 0)
  3634. item2->SetSocket(j++, item2->GetSocket(i));
  3635. }
  3636.  
  3637. for (; j < ITEM_SOCKET_MAX_NUM; ++j) {
  3638. if (item2->GetSocket(j) > 0)
  3639. item2->SetSocket(j, 1);
  3640. }
  3641.  
  3642. {
  3643. char buf[21];
  3644. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  3645. LogManager::instance().ItemLog(this, item, "CLEAN_SOCKET", buf);
  3646. }
  3647.  
  3648. item->SetCount(item->GetCount() - 1);
  3649.  
  3650. }
  3651. break;
  3652.  
  3653. case USE_CHANGE_ATTRIBUTE :
  3654. if (item2->IsEquipped()){
  3655. ChatPacket(CHAT_TYPE_INFO, "Voce nao pode fazer isso noob.");
  3656. return false;
  3657. }
  3658.  
  3659. if (item2->GetAttributeSetIndex() == -1) {
  3660. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  3661. return false;
  3662. }
  3663.  
  3664. if (item2->GetAttributeCount() == 0) {
  3665. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("º¯°æÇÒ ¼Ó¼ºÀÌ ¾ø½À´Ï´Ù."));
  3666. return false;
  3667. }
  3668.  
  3669. if (GM_PLAYER == GetGMLevel() && false == test_server) {
  3670. quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetPlayerID());
  3671. }
  3672.  
  3673. if (item->GetSubType() == USE_CHANGE_ATTRIBUTE2) {
  3674. int aiChangeProb[ITEM_ATTRIBUTE_MAX_LEVEL] = {
  3675. 0, 0, 30, 40, 3
  3676. };
  3677.  
  3678. item2->ChangeAttribute(aiChangeProb);
  3679. } else if (item->GetVnum() == 76014) {
  3680. int aiChangeProb[ITEM_ATTRIBUTE_MAX_LEVEL] = {
  3681. 0, 10, 50, 39, 1
  3682. };
  3683.  
  3684. item2->ChangeAttribute(aiChangeProb);
  3685. }
  3686.  
  3687. else {
  3688. if (item->GetVnum() == 71151 || item->GetVnum() == 76023) {
  3689. if ((item2->GetType() == ITEM_WEAPON) || (item2->GetType() == ITEM_ARMOR && item2->GetSubType() == ARMOR_BODY)) {
  3690. bool bCanUse = true;
  3691. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i) {
  3692. if (item2->GetLimitType(i) == LIMIT_LEVEL && item2->GetLimitValue(i) > 40) {
  3693. bCanUse = false;
  3694. break;
  3695. }
  3696. }
  3697. if (false == bCanUse) {
  3698. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Àû¿ë ·¹º§º¸´Ù ³ô¾Æ »ç¿ëÀÌ ºÒ°¡´ÉÇÕ´Ï´Ù."));
  3699. break;
  3700. }
  3701. } else {
  3702. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¹«±â¿Í °©¿Ê¿¡¸¸ »ç¿ë °¡´ÉÇÕ´Ï´Ù."));
  3703. break;
  3704. }
  3705. }
  3706. item2->ChangeAttribute();
  3707. }
  3708.  
  3709. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÏ¿´½À´Ï´Ù."));
  3710. {
  3711. char buf[21];
  3712. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  3713. LogManager::instance().ItemLog(this, item, "CHANGE_ATTRIBUTE", buf);
  3714. }
  3715.  
  3716. item->SetCount(item->GetCount() - 1);
  3717. break;
  3718.  
  3719. case USE_ADD_ATTRIBUTE :
  3720. if (item2->GetAttributeSetIndex() == -1) {
  3721. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  3722. return false;
  3723. }
  3724.  
  3725. if (item2->GetAttributeCount() < 4) {
  3726. if (item->GetVnum() == 71152 || item->GetVnum() == 76024) {
  3727. if ((item2->GetType() == ITEM_WEAPON)
  3728. || (item2->GetType() == ITEM_ARMOR && item2->GetSubType() == ARMOR_BODY)) {
  3729. bool bCanUse = true;
  3730. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i) {
  3731. if (item2->GetLimitType(i) == LIMIT_LEVEL && item2->GetLimitValue(i) > 40) {
  3732. bCanUse = false;
  3733. break;
  3734. }
  3735. }
  3736. if (false == bCanUse) {
  3737. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Àû¿ë ·¹º§º¸´Ù ³ô¾Æ »ç¿ëÀÌ ºÒ°¡´ÉÇÕ´Ï´Ù."));
  3738. break;
  3739. }
  3740. } else {
  3741. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¹«±â¿Í °©¿Ê¿¡¸¸ »ç¿ë °¡´ÉÇÕ´Ï´Ù."));
  3742. break;
  3743. }
  3744. }
  3745. char buf[21];
  3746. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  3747.  
  3748. if (number(1, 100) <= aiItemAttributeAddPercent[item2->GetAttributeCount()]) {
  3749. item2->AddAttribute();
  3750. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼º Ãß°¡¿¡ ¼º°øÇÏ¿´½À´Ï´Ù."));
  3751.  
  3752. int iAddedIdx = item2->GetAttributeCount() - 1;
  3753. LogManager::instance().ItemLog(
  3754. GetPlayerID(),
  3755. item2->GetAttributeType(iAddedIdx),
  3756. item2->GetAttributeValue(iAddedIdx),
  3757. item->GetID(),
  3758. "ADD_ATTRIBUTE_SUCCESS",
  3759. buf,
  3760. GetDesc()->GetHostName(),
  3761. item->GetOriginalVnum());
  3762. } else {
  3763. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼º Ãß°¡¿¡ ½ÇÆÐÇÏ¿´½À´Ï´Ù."));
  3764. LogManager::instance().ItemLog(this, item, "ADD_ATTRIBUTE_FAIL", buf);
  3765. }
  3766.  
  3767. item->SetCount(item->GetCount() - 1);
  3768. } else {
  3769. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õÀÌ»ó ÀÌ ¾ÆÀÌÅÛÀ» ÀÌ¿ëÇÏ¿© ¼Ó¼ºÀ» Ãß°¡ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  3770. }
  3771. break;
  3772.  
  3773. case USE_ADD_ATTRIBUTE2 :
  3774. if (item2->GetAttributeSetIndex() == -1) {
  3775. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼ºÀ» º¯°æÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  3776. return false;
  3777. }
  3778.  
  3779. if (item2->GetAttributeCount() == 4) {
  3780. char buf[21];
  3781. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  3782.  
  3783. if (number(1, 100) <= aiItemAttributeAddPercent[item2->GetAttributeCount()]) {
  3784. item2->AddAttribute();
  3785. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼º Ãß°¡¿¡ ¼º°øÇÏ¿´½À´Ï´Ù."));
  3786.  
  3787. int iAddedIdx = item2->GetAttributeCount() - 1;
  3788. LogManager::instance().ItemLog(
  3789. GetPlayerID(),
  3790. item2->GetAttributeType(iAddedIdx),
  3791. item2->GetAttributeValue(iAddedIdx),
  3792. item->GetID(),
  3793. "ADD_ATTRIBUTE2_SUCCESS",
  3794. buf,
  3795. GetDesc()->GetHostName(),
  3796. item->GetOriginalVnum());
  3797. } else {
  3798. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼Ó¼º Ãß°¡¿¡ ½ÇÆÐÇÏ¿´½À´Ï´Ù."));
  3799. LogManager::instance().ItemLog(this, item, "ADD_ATTRIBUTE2_FAIL", buf);
  3800. }
  3801.  
  3802. item->SetCount(item->GetCount() - 1);
  3803. } else if (item2->GetAttributeCount() == 5) {
  3804. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´õ ÀÌ»ó ÀÌ ¾ÆÀÌÅÛÀ» ÀÌ¿ëÇÏ¿© ¼Ó¼ºÀ» Ãß°¡ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  3805. } else if (item2->GetAttributeCount() < 4) {
  3806. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸ÕÀú Àç°¡ºñ¼­¸¦ ÀÌ¿ëÇÏ¿© ¼Ó¼ºÀ» Ãß°¡½ÃÄÑ ÁÖ¼¼¿ä."));
  3807. } else {
  3808. sys_err("ADD_ATTRIBUTE2 : Item has wrong AttributeCount(%d)", item2->GetAttributeCount());
  3809. }
  3810. break;
  3811.  
  3812. case USE_ADD_ACCESSORY_SOCKET: {
  3813. char buf[21];
  3814. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  3815.  
  3816. if (item2->IsAccessoryForSocket()) {
  3817. if (item2->GetAccessorySocketMaxGrade() < ITEM_ACCESSORY_SOCKET_MAX_NUM) {
  3818. if (number(1, 100) <= 50) {
  3819. item2->SetAccessorySocketMaxGrade(item2->GetAccessorySocketMaxGrade() + 1);
  3820. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ÒÄÏÀÌ ¼º°øÀûÀ¸·Î Ãß°¡µÇ¾ú½À´Ï´Ù."));
  3821. LogManager::instance().ItemLog(this, item, "ADD_SOCKET_SUCCESS", buf);
  3822. } else {
  3823. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ÒÄÏ Ãß°¡¿¡ ½ÇÆÐÇÏ¿´½À´Ï´Ù."));
  3824. LogManager::instance().ItemLog(this, item, "ADD_SOCKET_FAIL", buf);
  3825. }
  3826.  
  3827. item->SetCount(item->GetCount() - 1);
  3828. } else {
  3829. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾×¼¼¼­¸®¿¡´Â ´õÀÌ»ó ¼ÒÄÏÀ» Ãß°¡ÇÒ °ø°£ÀÌ ¾ø½À´Ï´Ù."));
  3830. }
  3831. } else {
  3832. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀ¸·Î ¼ÒÄÏÀ» Ãß°¡ÇÒ ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  3833. }
  3834. }
  3835. break;
  3836.  
  3837. case USE_PUT_INTO_BELT_SOCKET:
  3838. case USE_PUT_INTO_ACCESSORY_SOCKET:
  3839. if (item2->IsAccessoryForSocket() && item->CanPutInto(item2)) {
  3840. char buf[21];
  3841. snprintf(buf, sizeof(buf), "%u", item2->GetID());
  3842.  
  3843. if (item2->GetAccessorySocketGrade() < item2->GetAccessorySocketMaxGrade()) {
  3844. if (number(1, 100) <= aiAccessorySocketPutPct[item2->GetAccessorySocketGrade()]) {
  3845. item2->SetAccessorySocketGrade(item2->GetAccessorySocketGrade() + 1);
  3846. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀåÂø¿¡ ¼º°øÇÏ¿´½À´Ï´Ù."));
  3847. LogManager::instance().ItemLog(this, item, "PUT_SOCKET_SUCCESS", buf);
  3848. } else {
  3849. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀåÂø¿¡ ½ÇÆÐÇÏ¿´½À´Ï´Ù."));
  3850. LogManager::instance().ItemLog(this, item, "PUT_SOCKET_FAIL", buf);
  3851. }
  3852.  
  3853. item->SetCount(item->GetCount() - 1);
  3854. } else {
  3855. if (item2->GetAccessorySocketMaxGrade() == 0)
  3856. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸ÕÀú ´ÙÀ̾Ƹóµå·Î ¾Ç¼¼¼­¸®¿¡ ¼ÒÄÏÀ» Ãß°¡ÇؾßÇÕ´Ï´Ù."));
  3857. else if (item2->GetAccessorySocketMaxGrade() < ITEM_ACCESSORY_SOCKET_MAX_NUM) {
  3858. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾×¼¼¼­¸®¿¡´Â ´õÀÌ»ó ÀåÂøÇÒ ¼ÒÄÏÀÌ ¾ø½À´Ï´Ù."));
  3859. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´ÙÀ̾Ƹóµå·Î ¼ÒÄÏÀ» Ãß°¡ÇؾßÇÕ´Ï´Ù."));
  3860. } else
  3861. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾×¼¼¼­¸®¿¡´Â ´õÀÌ»ó º¸¼®À» ÀåÂøÇÒ ¼ö ¾ø½À´Ï´Ù."));
  3862. }
  3863. } else {
  3864. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀ» ÀåÂøÇÒ ¼ö ¾ø½À´Ï´Ù."));
  3865. }
  3866. break;
  3867. }
  3868. if (item2->IsEquipped()) {
  3869. BuffOnAttr_AddBuffsFromItem(item2);
  3870. }
  3871. }
  3872. break;
  3873.  
  3874. case USE_BAIT: {
  3875.  
  3876. if (m_pkFishingEvent) {
  3877. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("³¬½Ã Áß¿¡ ¹Ì³¢¸¦ °¥¾Æ³¢¿ï ¼ö ¾ø½À´Ï´Ù."));
  3878. return false;
  3879. }
  3880.  
  3881. LPITEM weapon = GetWear(WEAR_WEAPON);
  3882.  
  3883. if (!weapon || weapon->GetType() != ITEM_ROD)
  3884. return false;
  3885.  
  3886. if (weapon->GetSocket(2)) {
  3887. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì ²ÈÇôÀÖ´ø ¹Ì³¢¸¦ »©°í %s¸¦ ³¢¿ó´Ï´Ù."), item->GetName());
  3888. } else {
  3889. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("³¬½Ã´ë¿¡ %s¸¦ ¹Ì³¢·Î ³¢¿ó´Ï´Ù."), item->GetName());
  3890. }
  3891.  
  3892. weapon->SetSocket(2, item->GetValue(0));
  3893. item->SetCount(item->GetCount() - 1);
  3894. }
  3895. break;
  3896.  
  3897. case USE_MOVE:
  3898. case USE_TREASURE_BOX:
  3899. case USE_MONEYBAG:
  3900. break;
  3901.  
  3902. case USE_AFFECT : {
  3903. if (FindAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType)) {
  3904. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì È¿°ú°¡ °É·Á ÀÖ½À´Ï´Ù."));
  3905. } else {
  3906. AddAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType, item->GetValue(2), 0, item->GetValue(3), 0, false);
  3907. item->SetCount(item->GetCount() - 1);
  3908. }
  3909. }
  3910. break;
  3911.  
  3912. case USE_CREATE_STONE:
  3913. AutoGiveItem(number(28000, 28013));
  3914. item->SetCount(item->GetCount() - 1);
  3915. break;
  3916.  
  3917. case USE_RECIPE : {
  3918. LPITEM pSource1 = FindSpecifyItem(item->GetValue(1));
  3919. DWORD dwSourceCount1 = item->GetValue(2);
  3920.  
  3921. LPITEM pSource2 = FindSpecifyItem(item->GetValue(3));
  3922. DWORD dwSourceCount2 = item->GetValue(4);
  3923.  
  3924. if (dwSourceCount1 != 0) {
  3925. if (pSource1 == NULL) {
  3926. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¹°¾à Á¶ÇÕÀ» À§ÇÑ Àç·á°¡ ºÎÁ·ÇÕ´Ï´Ù."));
  3927. return false;
  3928. }
  3929. }
  3930.  
  3931. if (dwSourceCount2 != 0) {
  3932. if (pSource2 == NULL) {
  3933. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¹°¾à Á¶ÇÕÀ» À§ÇÑ Àç·á°¡ ºÎÁ·ÇÕ´Ï´Ù."));
  3934. return false;
  3935. }
  3936. }
  3937.  
  3938. if (pSource1 != NULL) {
  3939. if (pSource1->GetCount() < dwSourceCount1) {
  3940. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Àç·á(%s)°¡ ºÎÁ·ÇÕ´Ï´Ù."), pSource1->GetName());
  3941. return false;
  3942. }
  3943.  
  3944. pSource1->SetCount(pSource1->GetCount() - dwSourceCount1);
  3945. }
  3946.  
  3947. if (pSource2 != NULL) {
  3948. if (pSource2->GetCount() < dwSourceCount2) {
  3949. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Àç·á(%s)°¡ ºÎÁ·ÇÕ´Ï´Ù."), pSource2->GetName());
  3950. return false;
  3951. }
  3952.  
  3953. pSource2->SetCount(pSource2->GetCount() - dwSourceCount2);
  3954. }
  3955.  
  3956. LPITEM pBottle = FindSpecifyItem(50901);
  3957.  
  3958. if (!pBottle || pBottle->GetCount() < 1) {
  3959. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ºó º´ÀÌ ¸ðÀÚ¸¨´Ï´Ù."));
  3960. return false;
  3961. }
  3962.  
  3963. pBottle->SetCount(pBottle->GetCount() - 1);
  3964.  
  3965. if (number(1, 100) > item->GetValue(5)) {
  3966. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¹°¾à Á¦Á¶¿¡ ½ÇÆÐÇß½À´Ï´Ù."));
  3967. return false;
  3968. }
  3969.  
  3970. AutoGiveItem(item->GetValue(0));
  3971. }
  3972. break;
  3973. }
  3974. }
  3975. break;
  3976.  
  3977. case ITEM_METIN: {
  3978. LPITEM item2;
  3979.  
  3980. if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  3981. return false;
  3982.  
  3983. if (item2->IsExchanging())
  3984. return false;
  3985.  
  3986. if (item2->GetType() == ITEM_PICK) return false;
  3987. if (item2->GetType() == ITEM_ROD) return false;
  3988.  
  3989. int i;
  3990.  
  3991. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i) {
  3992. DWORD dwVnum;
  3993.  
  3994. if ((dwVnum = item2->GetSocket(i)) <= 2)
  3995. continue;
  3996.  
  3997. TItemTable * p = ITEM_MANAGER::instance().GetTable(dwVnum);
  3998.  
  3999. if (!p)
  4000. continue;
  4001.  
  4002. if (item->GetValue(5) == p->alValues[5]) {
  4003. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°°Àº Á¾·ùÀÇ ¸Þƾ¼®Àº ¿©·¯°³ ºÎÂøÇÒ ¼ö ¾ø½À´Ï´Ù."));
  4004. return false;
  4005. }
  4006. }
  4007.  
  4008. if (item2->GetType() == ITEM_ARMOR) {
  4009. if (!IS_SET(item->GetWearFlag(), WEARABLE_BODY) || !IS_SET(item2->GetWearFlag(), WEARABLE_BODY)) {
  4010. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¸Þƾ¼®Àº Àåºñ¿¡ ºÎÂøÇÒ ¼ö ¾ø½À´Ï´Ù."));
  4011. return false;
  4012. }
  4013. } else if (item2->GetType() == ITEM_WEAPON) {
  4014. if (!IS_SET(item->GetWearFlag(), WEARABLE_WEAPON)) {
  4015. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¸Þƾ¼®Àº ¹«±â¿¡ ºÎÂøÇÒ ¼ö ¾ø½À´Ï´Ù."));
  4016. return false;
  4017. }
  4018. } else {
  4019. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ºÎÂøÇÒ ¼ö ÀÖ´Â ½½·ÔÀÌ ¾ø½À´Ï´Ù."));
  4020. return false;
  4021. }
  4022.  
  4023. for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  4024. if (item2->GetSocket(i) >= 1 && item2->GetSocket(i) <= 2 && item2->GetSocket(i) >= item->GetValue(2)) {
  4025. if (number(1, 100) <= 100) {
  4026. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸Þƾ¼® ºÎÂø¿¡ ¼º°øÇÏ¿´½À´Ï´Ù."));
  4027. item2->SetSocket(i, item->GetVnum());
  4028. } else {
  4029. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸Þƾ¼® ºÎÂø¿¡ ½ÇÆÐÇÏ¿´½À´Ï´Ù."));
  4030. item2->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
  4031. }
  4032.  
  4033. LogManager::instance().ItemLog(this, item2, "SOCKET", item->GetName());
  4034. ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (METIN)");
  4035. break;
  4036. }
  4037.  
  4038. if (i == ITEM_SOCKET_MAX_NUM)
  4039. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ºÎÂøÇÒ ¼ö ÀÖ´Â ½½·ÔÀÌ ¾ø½À´Ï´Ù."));
  4040. }
  4041. break;
  4042.  
  4043. case ITEM_AUTOUSE:
  4044. case ITEM_MATERIAL:
  4045. case ITEM_SPECIAL:
  4046. case ITEM_TOOL:
  4047. case ITEM_LOTTERY:
  4048. break;
  4049.  
  4050. case ITEM_TOTEM: {
  4051. if (!item->IsEquipped())
  4052. EquipItem(item);
  4053. }
  4054. break;
  4055.  
  4056. case ITEM_BLEND:
  4057. sys_log(0, "ITEM_BLEND");
  4058.  
  4059. if (Blend_Item_find(item->GetVnum())) {
  4060. if (item->GetSocket(0) >= static_cast<long>(_countof(aApplyInfo))) {
  4061. sys_err("INVALID_BLEND_ITEM (id: %u, vnum: %u). Apply type is %ld", item->GetID(), item->GetVnum(), item->GetSocket(0));
  4062. return false;
  4063. }
  4064.  
  4065. int iApplyType = aApplyInfo[item->GetSocket(0)].bPointType;
  4066. int iApplyValue = item->GetSocket(1), iApplyDuration = item->GetSocket(2);
  4067.  
  4068. if (FindAffect(AFFECT_BLEND, iApplyType)) {
  4069. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("AI©öI E¢¯¡Æu¡Æ¢® ¡ÆE¡¤A AO¨öA¢¥I¢¥U."));
  4070. return false;
  4071. }
  4072.  
  4073. item->ModifyPoints(false);
  4074. item->SetCount(item->GetCount() - 1);
  4075. AddAffect(AFFECT_BLEND, iApplyType, iApplyValue, 0, iApplyDuration, 0, false);
  4076. }
  4077. break;
  4078.  
  4079. case ITEM_EXTRACT: {
  4080. LPITEM pDestItem = GetItem(DestCell);
  4081. if (NULL == pDestItem) {
  4082. return false;
  4083. }
  4084. switch (item->GetSubType()) {
  4085. case EXTRACT_DRAGON_SOUL:
  4086. if (pDestItem->IsDragonSoul()) {
  4087. return DSManager::instance().PullOut(this, NPOS, pDestItem, item);
  4088. }
  4089. return false;
  4090. case EXTRACT_DRAGON_HEART:
  4091. if (pDestItem->IsDragonSoul()) {
  4092. return DSManager::instance().ExtractDragonHeart(this, pDestItem, item);
  4093. }
  4094. return false;
  4095. default:
  4096. return false;
  4097. }
  4098. }
  4099. break;
  4100.  
  4101. case ITEM_NONE:
  4102. sys_err("Item type NONE %s", item->GetName());
  4103. break;
  4104.  
  4105. default:
  4106. sys_log(0, "UseItemEx: Unknown type %s %d", item->GetName(), item->GetType());
  4107. return false;
  4108. }
  4109.  
  4110. return true;
  4111. }
  4112.  
  4113. int g_nPortalLimitTime = 10;
  4114.  
  4115. bool CHARACTER::UseItem(TItemPos Cell, TItemPos DestCell) {
  4116. WORD wCell = Cell.cell;
  4117. BYTE window_type = Cell.window_type;
  4118. WORD wDestCell = DestCell.cell;
  4119. BYTE bDestInven = DestCell.window_type;
  4120. LPITEM item;
  4121.  
  4122. if (!CanHandleItem())
  4123. return false;
  4124.  
  4125. if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
  4126. return false;
  4127.  
  4128. sys_log(0, "%s: USE_ITEM %s (inven %d, cell: %d)", GetName(), item->GetName(), window_type, wCell);
  4129.  
  4130. if (item->IsExchanging())
  4131. return false;
  4132.  
  4133. if (!item->CanUsedBy(this)) {
  4134. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±ºÁ÷ÀÌ ¸ÂÁö¾Ê¾Æ ÀÌ ¾ÆÀÌÅÛÀ» »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  4135. return false;
  4136. }
  4137.  
  4138. if (IsStun())
  4139. return false;
  4140.  
  4141. if (false == FN_check_item_sex(this, item)) {
  4142. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ºº°ÀÌ ¸ÂÁö¾Ê¾Æ ÀÌ ¾ÆÀÌÅÛÀ» »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  4143. return false;
  4144. }
  4145.  
  4146. if (IS_SUMMON_ITEM(item->GetVnum())) {
  4147. if (false == IS_SUMMONABLE_ZONE(GetMapIndex())) {
  4148. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»ç¿ëÇÒ¼ö ¾ø½À´Ï´Ù."));
  4149. return false;
  4150. }
  4151.  
  4152. if (CThreeWayWar::instance().IsThreeWayWarMapIndex(GetMapIndex())) {
  4153. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("»ï°Å¸® ÀüÅõ Âü°¡Áß¿¡´Â ±ÍȯºÎ,±Íȯ±â¾ïºÎ¸¦ »ç¿ëÇÒ¼ö ¾ø½À´Ï´Ù."));
  4154. return false;
  4155. }
  4156. int iPulse = thecore_pulse();
  4157.  
  4158. if (iPulse - GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime)) {
  4159. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("â°í¸¦ ¿¬ÈÄ %dÃÊ À̳»¿¡´Â ±ÍȯºÎ,±Íȯ±â¾ïºÎ¸¦ »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."), g_nPortalLimitTime);
  4160.  
  4161. if (test_server)
  4162. ChatPacket(CHAT_TYPE_INFO, "[TestOnly]Pulse %d LoadTime %d PASS %d", iPulse, GetSafeboxLoadTime(), PASSES_PER_SEC(g_nPortalLimitTime));
  4163. return false;
  4164. }
  4165.  
  4166. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || IsAcceOpen()) {
  4167. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°Å·¡Ã¢,â°í µîÀ» ¿¬ »óÅ¿¡¼­´Â ±ÍȯºÎ,±Íȯ±â¾ïºÎ ¸¦ »ç¿ëÇÒ¼ö ¾ø½À´Ï´Ù."));
  4168. return false;
  4169. }
  4170.  
  4171. if (iPulse - GetRefineTime() < PASSES_PER_SEC(g_nPortalLimitTime)) {
  4172. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛ °³·®ÈÄ %dÃÊ À̳»¿¡´Â ±ÍȯºÎ,±Íȯ±â¾ïºÎ¸¦ »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."), g_nPortalLimitTime);
  4173. return false;
  4174. }
  4175.  
  4176. if (iPulse - GetMyShopTime() < PASSES_PER_SEC(g_nPortalLimitTime)) {
  4177. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°³ÀλóÁ¡ »ç¿ëÈÄ %dÃÊ À̳»¿¡´Â ±ÍȯºÎ,±Íȯ±â¾ïºÎ¸¦ »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."), g_nPortalLimitTime);
  4178. return false;
  4179. }
  4180.  
  4181.  
  4182.  
  4183. if (item->GetVnum() != 70302) {
  4184. PIXEL_POSITION posWarp;
  4185.  
  4186. int x = 0;
  4187. int y = 0;
  4188.  
  4189. double nDist = 0;
  4190. const double nDistant = 5000.0;
  4191.  
  4192. if (item->GetVnum() == 22010) {
  4193. x = item->GetSocket(0) - GetX();
  4194. y = item->GetSocket(1) - GetY();
  4195. } else if (item->GetVnum() == 22000) {
  4196. SECTREE_MANAGER::instance().GetRecallPositionByEmpire(GetMapIndex(), GetEmpire(), posWarp);
  4197.  
  4198. if (item->GetSocket(0) == 0) {
  4199. x = posWarp.x - GetX();
  4200. y = posWarp.y - GetY();
  4201. } else {
  4202. x = item->GetSocket(0) - GetX();
  4203. y = item->GetSocket(1) - GetY();
  4204. }
  4205. }
  4206.  
  4207. nDist = sqrt(pow((float)x,2) + pow((float)y,2));
  4208.  
  4209. if (nDistant > nDist) {
  4210. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("À̵¿ µÇ¾îÁú À§Ä¡¿Í ³Ê¹« °¡±î¿ö ±ÍȯºÎ¸¦ »ç¿ëÇÒ¼ö ¾ø½À´Ï´Ù."));
  4211. if (test_server)
  4212. ChatPacket(CHAT_TYPE_INFO, "PossibleDistant %f nNowDist %f", nDistant,nDist);
  4213. return false;
  4214. }
  4215. }
  4216.  
  4217. if (iPulse - GetExchangeTime() < PASSES_PER_SEC(g_nPortalLimitTime)) {
  4218. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°Å·¡ ÈÄ %dÃÊ À̳»¿¡´Â ±ÍȯºÎ,±Íȯ±â¾ïºÎµîÀ» »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."), g_nPortalLimitTime);
  4219. return false;
  4220. }
  4221.  
  4222. }
  4223.  
  4224. if (item->GetVnum() == 50200 | item->GetVnum() == 71049) {
  4225. if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen() || IsAcceOpen()) {
  4226. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°Å·¡Ã¢,â°í µîÀ» ¿¬ »óÅ¿¡¼­´Â º¸µû¸®,ºñ´Üº¸µû¸®¸¦ »ç¿ëÇÒ¼ö ¾ø½À´Ï´Ù."));
  4227. return false;
  4228. }
  4229.  
  4230. }
  4231.  
  4232. if (IS_SET(item->GetFlag(), ITEM_FLAG_LOG)) {
  4233. DWORD vid = item->GetVID();
  4234. DWORD oldCount = item->GetCount();
  4235. DWORD vnum = item->GetVnum();
  4236.  
  4237. char hint[ITEM_NAME_MAX_LEN + 32 + 1];
  4238. int len = snprintf(hint, sizeof(hint) - 32, "%s", item->GetName());
  4239.  
  4240. if (len < 0 || len >= (int) sizeof(hint) - 32)
  4241. len = (sizeof(hint) - 32) - 1;
  4242.  
  4243. bool ret = UseItemEx(item, DestCell);
  4244.  
  4245. if (NULL == ITEM_MANAGER::instance().FindByVID(vid)) {
  4246. LogManager::instance().ItemLog(this, vid, vnum, "REMOVE", hint);
  4247. } else if (oldCount != item->GetCount()) {
  4248. snprintf(hint + len, sizeof(hint) - len, " %u", oldCount - 1);
  4249. LogManager::instance().ItemLog(this, vid, vnum, "USE_ITEM", hint);
  4250. }
  4251. return (ret);
  4252. } else
  4253. return UseItemEx(item, DestCell);
  4254. }
  4255.  
  4256. bool CHARACTER::DropItem(TItemPos Cell, BYTE bCount) {
  4257. LPITEM item = NULL;
  4258.  
  4259. if (!CanHandleItem()) {
  4260. if (NULL != DragonSoul_RefineWindow_GetOpener())
  4261. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°­È­Ã¢À» ¿¬ »óÅ¿¡¼­´Â ¾ÆÀÌÅÛÀ» ¿Å±æ ¼ö ¾ø½À´Ï´Ù."));
  4262. return false;
  4263. }
  4264.  
  4265. if (IsDead())
  4266. return false;
  4267.  
  4268. if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
  4269. return false;
  4270.  
  4271. if (item->IsExchanging())
  4272. return false;
  4273.  
  4274. if (true == item->isLocked())
  4275. return false;
  4276.  
  4277. if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  4278. return false;
  4279.  
  4280. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP | ITEM_ANTIFLAG_GIVE)) {
  4281. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¹ö¸± ¼ö ¾ø´Â ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  4282. return false;
  4283. }
  4284.  
  4285. if (bCount == 0 || bCount > item->GetCount())
  4286. bCount = item->GetCount();
  4287.  
  4288. SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, 255);
  4289.  
  4290. LPITEM pkItemToDrop;
  4291.  
  4292. if (bCount == item->GetCount()) {
  4293. item->RemoveFromCharacter();
  4294. pkItemToDrop = item;
  4295. } else {
  4296. if (bCount == 0) {
  4297. if (test_server)
  4298. sys_log(0, "[DROP_ITEM] drop item count == 0");
  4299. return false;
  4300. }
  4301.  
  4302. item->SetCount(item->GetCount() - bCount);
  4303. ITEM_MANAGER::instance().FlushDelayedSave(item);
  4304.  
  4305. pkItemToDrop = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), bCount);
  4306.  
  4307. FN_copy_item_socket(pkItemToDrop, item);
  4308.  
  4309. char szBuf[51 + 1];
  4310. snprintf(szBuf, sizeof(szBuf), "%u %u", pkItemToDrop->GetID(), pkItemToDrop->GetCount());
  4311. LogManager::instance().ItemLog(this, item, "ITEM_SPLIT", szBuf);
  4312. }
  4313.  
  4314. PIXEL_POSITION pxPos = GetXYZ();
  4315.  
  4316. if (pkItemToDrop->AddToGround(GetMapIndex(), pxPos)) {
  4317. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¶³¾îÁø ¾ÆÀÌÅÛÀº 3ºÐ ÈÄ »ç¶óÁý´Ï´Ù."));
  4318. pkItemToDrop->StartDestroyEvent(5);
  4319.  
  4320. ITEM_MANAGER::instance().FlushDelayedSave(pkItemToDrop);
  4321.  
  4322. char szHint[32 + 1];
  4323. snprintf(szHint, sizeof(szHint), "%u %u", pkItemToDrop->GetOriginalVnum(), pkItemToDrop->GetCount());
  4324. LogManager::instance().ItemLog(this, pkItemToDrop, "DROP", szHint);
  4325. }
  4326. return true;
  4327. }
  4328.  
  4329. bool CHARACTER::DropGold(int gold)
  4330. {
  4331. return false;
  4332. }
  4333.  
  4334. bool CHARACTER::MoveItem(TItemPos Cell, TItemPos DestCell, BYTE count) {
  4335. LPITEM item = NULL;
  4336.  
  4337. if (!IsValidItemPosition(Cell))
  4338. return false;
  4339.  
  4340. if (!(item = GetItem(Cell)))
  4341. return false;
  4342.  
  4343. if (item->IsExchanging())
  4344. return false;
  4345.  
  4346. if (item->GetCount() < count)
  4347. return false;
  4348.  
  4349. if (INVENTORY == Cell.window_type && Cell.cell >= INVENTORY_MAX_NUM && IS_SET(item->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  4350. return false;
  4351.  
  4352. if (true == item->isLocked())
  4353. return false;
  4354.  
  4355. if (!IsValidItemPosition(DestCell)) {
  4356. return false;
  4357. }
  4358.  
  4359. if (!CanHandleItem()) {
  4360. if (NULL != DragonSoul_RefineWindow_GetOpener())
  4361. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°­È­Ã¢À» ¿¬ »óÅ¿¡¼­´Â ¾ÆÀÌÅÛÀ» ¿Å±æ ¼ö ¾ø½À´Ï´Ù."));
  4362. return false;
  4363. }
  4364.  
  4365. if (DestCell.IsBeltInventoryPosition() && false == CBeltInventoryHelper::CanMoveIntoBeltInventory(item)) {
  4366. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀº º§Æ® Àκ¥Å丮·Î ¿Å±æ ¼ö ¾ø½À´Ï´Ù."));
  4367. return false;
  4368. }
  4369.  
  4370. if (Cell.IsEquipPosition() && !CanUnequipNow(item))
  4371. return false;
  4372.  
  4373. if (DestCell.IsEquipPosition()) {
  4374. if (GetItem(DestCell)) {
  4375. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì Àåºñ¸¦ Âø¿ëÇÏ°í ÀÖ½À´Ï´Ù."));
  4376.  
  4377. return false;
  4378. }
  4379.  
  4380. EquipItem(item, DestCell.cell - INVENTORY_MAX_NUM);
  4381. } else {
  4382. if (item->IsDragonSoul()) {
  4383. if (item->IsEquipped()) {
  4384. return DSManager::instance().PullOut(this, DestCell, item);
  4385. } else {
  4386. if (DestCell.window_type != DRAGON_SOUL_INVENTORY) {
  4387. return false;
  4388. }
  4389.  
  4390. if (!DSManager::instance().IsValidCellForThisItem(item, DestCell))
  4391. return false;
  4392. }
  4393. } else if (DRAGON_SOUL_INVENTORY == DestCell.window_type)
  4394. return false;
  4395.  
  4396. LPITEM item2;
  4397.  
  4398. if ((item2 = GetItem(DestCell)) && item != item2 && item2->IsStackable() &&
  4399. !IS_SET(item2->GetAntiFlag(), ITEM_ANTIFLAG_STACK) &&
  4400. item2->GetVnum() == item->GetVnum()) {
  4401. for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  4402. if (item2->GetSocket(i) != item->GetSocket(i))
  4403. return false;
  4404.  
  4405. if (count == 0)
  4406. count = item->GetCount();
  4407.  
  4408. 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,
  4409. DestCell.window_type, DestCell.cell, count);
  4410.  
  4411. count = MIN(200 - item2->GetCount(), count);
  4412.  
  4413. item->SetCount(item->GetCount() - count);
  4414. item2->SetCount(item2->GetCount() + count);
  4415. return true;
  4416. }
  4417.  
  4418. if (!IsEmptyItemGrid(DestCell, item->GetSize(), Cell.cell))
  4419. return false;
  4420.  
  4421. if (count == 0 || count >= item->GetCount() || !item->IsStackable() || IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_STACK)) {
  4422. 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,
  4423. DestCell.window_type, DestCell.cell, count);
  4424.  
  4425. item->RemoveFromCharacter();
  4426. SetItem(DestCell, item);
  4427.  
  4428. if (INVENTORY == Cell.window_type && INVENTORY == DestCell.window_type)
  4429. SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, DestCell.cell);
  4430. } else if (count < item->GetCount()) {
  4431.  
  4432. 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,
  4433. DestCell.window_type, DestCell.cell, count);
  4434.  
  4435. item->SetCount(item->GetCount() - count);
  4436. LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), count);
  4437.  
  4438. FN_copy_item_socket(item2, item);
  4439.  
  4440. item2->AddToCharacter(this, DestCell);
  4441.  
  4442. char szBuf[51+1];
  4443. snprintf(szBuf, sizeof(szBuf), "%u %u %u %u ", item2->GetID(), item2->GetCount(), item->GetCount(), item->GetCount() + item2->GetCount());
  4444. LogManager::instance().ItemLog(this, item, "ITEM_SPLIT", szBuf);
  4445. }
  4446. }
  4447.  
  4448. return true;
  4449. }
  4450.  
  4451. namespace NPartyPickupDistribute {
  4452. struct FFindOwnership {
  4453. LPITEM item;
  4454. LPCHARACTER owner;
  4455.  
  4456. FFindOwnership(LPITEM item)
  4457. : item(item), owner(NULL) {
  4458. }
  4459.  
  4460. void operator () (LPCHARACTER ch) {
  4461. if (item->IsOwnership(ch))
  4462. owner = ch;
  4463. }
  4464. };
  4465.  
  4466. struct FCountNearMember {
  4467. int total;
  4468. int x, y;
  4469.  
  4470. FCountNearMember(LPCHARACTER center )
  4471. : total(0), x(center->GetX()), y(center->GetY()) {
  4472. }
  4473.  
  4474. void operator () (LPCHARACTER ch) {
  4475. if (DISTANCE_APPROX(ch->GetX() - x, ch->GetY() - y) <= PARTY_DEFAULT_RANGE)
  4476. total += 1;
  4477. }
  4478. };
  4479.  
  4480. struct FMoneyDistributor {
  4481. int total;
  4482. LPCHARACTER c;
  4483. int x, y;
  4484. int iMoney;
  4485.  
  4486. FMoneyDistributor(LPCHARACTER center, int iMoney)
  4487. : total(0), c(center), x(center->GetX()), y(center->GetY()), iMoney(iMoney) {
  4488. }
  4489.  
  4490. void operator ()(LPCHARACTER ch) {
  4491. if (ch!=c)
  4492. if (DISTANCE_APPROX(ch->GetX() - x, ch->GetY() - y) <= PARTY_DEFAULT_RANGE) {
  4493. ch->PointChange(POINT_GOLD, iMoney, true);
  4494.  
  4495. if (iMoney > 1000)
  4496. LogManager::instance().CharLog(ch, iMoney, "GET_GOLD", "");
  4497. }
  4498. }
  4499. };
  4500. }
  4501.  
  4502. void CHARACTER::GiveGold(int iAmount) {
  4503. if (iAmount <= 0)
  4504. return;
  4505.  
  4506. sys_log(0, "GIVE_GOLD: %s %d", GetName(), iAmount);
  4507.  
  4508. if (GetParty()) {
  4509. LPPARTY pParty = GetParty();
  4510. DWORD dwTotal = iAmount;
  4511. DWORD dwMyAmount = dwTotal;
  4512.  
  4513. NPartyPickupDistribute::FCountNearMember funcCountNearMember(this);
  4514. pParty->ForEachOnlineMember(funcCountNearMember);
  4515.  
  4516. if (funcCountNearMember.total > 1) {
  4517. DWORD dwShare = dwTotal / funcCountNearMember.total;
  4518. dwMyAmount -= dwShare * (funcCountNearMember.total - 1);
  4519.  
  4520. NPartyPickupDistribute::FMoneyDistributor funcMoneyDist(this, dwShare);
  4521.  
  4522. pParty->ForEachOnlineMember(funcMoneyDist);
  4523. }
  4524.  
  4525. PointChange(POINT_GOLD, dwMyAmount, true);
  4526.  
  4527. if (dwMyAmount > 1000)
  4528. LogManager::instance().CharLog(this, dwMyAmount, "GET_GOLD", "");
  4529. } else {
  4530. PointChange(POINT_GOLD, iAmount, true);
  4531.  
  4532. if (iAmount > 1000)
  4533. LogManager::instance().CharLog(this, iAmount, "GET_GOLD", "");
  4534.  
  4535. }
  4536. }
  4537.  
  4538. bool CHARACTER::PickupItem(DWORD dwVID) {
  4539. LPITEM item = ITEM_MANAGER::instance().FindByVID(dwVID);
  4540.  
  4541. if (IsObserverMode())
  4542. return false;
  4543.  
  4544. if (!item || !item->GetSectree())
  4545. return false;
  4546.  
  4547. if (item->DistanceValid(this)) {
  4548. if (item->IsOwnership(this)) {
  4549.  
  4550. if (item->GetType() == ITEM_ELK) {
  4551. GiveGold(item->GetCount());
  4552. item->RemoveFromGround();
  4553.  
  4554. M2_DESTROY_ITEM(item);
  4555.  
  4556. Save();
  4557. } else {
  4558. if (item->IsStackable() && !IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_STACK)) {
  4559. BYTE bCount = item->GetCount();
  4560.  
  4561. for (int i = 0; i < INVENTORY_MAX_NUM; ++i) {
  4562. LPITEM item2 = GetInventoryItem(i);
  4563.  
  4564. if (!item2)
  4565. continue;
  4566.  
  4567. if (item2->GetVnum() == item->GetVnum()) {
  4568. int j;
  4569.  
  4570. for (j = 0; j < ITEM_SOCKET_MAX_NUM; ++j)
  4571. if (item2->GetSocket(j) != item->GetSocket(j))
  4572. break;
  4573.  
  4574. if (j != ITEM_SOCKET_MAX_NUM)
  4575. continue;
  4576.  
  4577. BYTE bCount2 = MIN(200 - item2->GetCount(), bCount);
  4578. bCount -= bCount2;
  4579.  
  4580. item2->SetCount(item2->GetCount() + bCount2);
  4581.  
  4582. if (bCount == 0) {
  4583. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛ È¹µæ: %s"), item2->GetName());
  4584. M2_DESTROY_ITEM(item);
  4585. if (item2->GetType() == ITEM_QUEST)
  4586. quest::CQuestManager::instance().PickupItem (GetPlayerID(), item2);
  4587. return true;
  4588. }
  4589. }
  4590. }
  4591.  
  4592. item->SetCount(bCount);
  4593. }
  4594.  
  4595. int iEmptyCell;
  4596. if (item->IsDragonSoul()) {
  4597. if ((iEmptyCell = GetEmptyDragonSoulInventory(item)) == -1) {
  4598. sys_log(0, "No empty ds inventory pid %u size %ud itemid %u", GetPlayerID(), item->GetSize(), item->GetID());
  4599. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ÒÁöÇÏ°í ÀÖ´Â ¾ÆÀÌÅÛÀÌ ³Ê¹« ¸¹½À´Ï´Ù."));
  4600. return false;
  4601. }
  4602. } else {
  4603. if ((iEmptyCell = GetEmptyInventory(item->GetSize())) == -1) {
  4604. sys_log(0, "No empty inventory pid %u size %ud itemid %u", GetPlayerID(), item->GetSize(), item->GetID());
  4605. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ÒÁöÇÏ°í ÀÖ´Â ¾ÆÀÌÅÛÀÌ ³Ê¹« ¸¹½À´Ï´Ù."));
  4606. return false;
  4607. }
  4608. }
  4609.  
  4610. item->RemoveFromGround();
  4611.  
  4612. if (item->IsDragonSoul())
  4613. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  4614. else
  4615. item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
  4616.  
  4617. char szHint[32+1];
  4618. snprintf(szHint, sizeof(szHint), "%s %u %u", item->GetName(), item->GetCount(), item->GetOriginalVnum());
  4619. LogManager::instance().ItemLog(this, item, "GET", szHint);
  4620. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛ È¹µæ: %s"), item->GetName());
  4621.  
  4622. if (item->GetType() == ITEM_QUEST)
  4623. quest::CQuestManager::instance().PickupItem (GetPlayerID(), item);
  4624. }
  4625. return true;
  4626. } else if (!IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_DROP) && GetParty()) {
  4627. NPartyPickupDistribute::FFindOwnership funcFindOwnership(item);
  4628.  
  4629. GetParty()->ForEachOnlineMember(funcFindOwnership);
  4630.  
  4631. LPCHARACTER owner = funcFindOwnership.owner;
  4632.  
  4633. if (!owner) {
  4634. return false;
  4635. }
  4636.  
  4637. int iEmptyCell;
  4638.  
  4639. if (item->IsDragonSoul()) {
  4640. if (!(owner && (iEmptyCell = owner->GetEmptyDragonSoulInventory(item)) != -1)) {
  4641. owner = this;
  4642.  
  4643. if ((iEmptyCell = GetEmptyDragonSoulInventory(item)) == -1) {
  4644. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ÒÁöÇÏ°í ÀÖ´Â ¾ÆÀÌÅÛÀÌ ³Ê¹« ¸¹½À´Ï´Ù."));
  4645. return false;
  4646. }
  4647. }
  4648. } else {
  4649. if (!(owner && (iEmptyCell = owner->GetEmptyInventory(item->GetSize())) != -1)) {
  4650. owner = this;
  4651.  
  4652. if ((iEmptyCell = GetEmptyInventory(item->GetSize())) == -1) {
  4653. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ÒÁöÇÏ°í ÀÖ´Â ¾ÆÀÌÅÛÀÌ ³Ê¹« ¸¹½À´Ï´Ù."));
  4654. return false;
  4655. }
  4656. }
  4657. }
  4658.  
  4659. item->RemoveFromGround();
  4660.  
  4661. if (item->IsDragonSoul())
  4662. item->AddToCharacter(owner, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  4663. else
  4664. item->AddToCharacter(owner, TItemPos(INVENTORY, iEmptyCell));
  4665.  
  4666. char szHint[32+1];
  4667. snprintf(szHint, sizeof(szHint), "%u %u", item->GetOriginalVnum(), item->GetCount());
  4668. LogManager::instance().ItemLog(owner, item, "GET", szHint);
  4669.  
  4670. if (owner == this)
  4671. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛ È¹µæ: %s"), item->GetName());
  4672. else {
  4673. owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛ È¹µæ: %s ´ÔÀ¸·ÎºÎÅÍ %s"), GetName(), item->GetName());
  4674. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛ Àü´Þ: %s ´Ô¿¡°Ô %s"), owner->GetName(), item->GetName());
  4675. }
  4676.  
  4677. if (item->GetType() == ITEM_QUEST)
  4678. quest::CQuestManager::instance().PickupItem (owner->GetPlayerID(), item);
  4679.  
  4680. return true;
  4681. }
  4682. }
  4683.  
  4684. return false;
  4685. }
  4686.  
  4687. bool CHARACTER::SwapItem(BYTE bCell, BYTE bDestCell)
  4688. {
  4689. if (!CanHandleItem())
  4690. return false;
  4691.  
  4692. TItemPos srcCell(INVENTORY, bCell), destCell(INVENTORY, bDestCell);
  4693.  
  4694. // ¿Ã¹Ù¸¥ Cell ÀÎÁö °Ë»ç
  4695. // ¿ëÈ¥¼®Àº SwapÇÒ ¼ö ¾øÀ¸¹Ç·Î, ¿©±â¼­ °É¸².
  4696. //if (bCell >= INVENTORY_MAX_NUM + WEAR_MAX_NUM || bDestCell >= INVENTORY_MAX_NUM + WEAR_MAX_NUM)
  4697. if (srcCell.IsDragonSoulEquipPosition() || destCell.IsDragonSoulEquipPosition())
  4698. return false;
  4699.  
  4700. // °°Àº CELL ÀÎÁö °Ë»ç
  4701. if (bCell == bDestCell)
  4702. return false;
  4703.  
  4704. // µÑ ´Ù Àåºñâ À§Ä¡¸é Swap ÇÒ ¼ö ¾ø´Ù.
  4705. if (srcCell.IsEquipPosition() && destCell.IsEquipPosition())
  4706. return false;
  4707.  
  4708. LPITEM item1, item2;
  4709.  
  4710. // item2°¡ Àåºñâ¿¡ ÀÖ´Â °ÍÀÌ µÇµµ·Ï.
  4711. if (srcCell.IsEquipPosition())
  4712. {
  4713. item1 = GetInventoryItem(bDestCell);
  4714. item2 = GetInventoryItem(bCell);
  4715. }
  4716. else
  4717. {
  4718. item1 = GetInventoryItem(bCell);
  4719. item2 = GetInventoryItem(bDestCell);
  4720. }
  4721.  
  4722. if (!item1 || !item2)
  4723. return false;
  4724.  
  4725. if (item1 == item2)
  4726. {
  4727. sys_log(0, "[WARNING][WARNING][HACK USER!] : %s %d %d", m_stName.c_str(), bCell, bDestCell);
  4728. return false;
  4729. }
  4730.  
  4731. // item2°¡ bCellÀ§Ä¡¿¡ µé¾î°¥ ¼ö ÀÖ´ÂÁö È®ÀÎÇÑ´Ù.
  4732. if (!IsEmptyItemGrid(TItemPos (INVENTORY, item1->GetCell()), item2->GetSize(), item1->GetCell()))
  4733. return false;
  4734.  
  4735. // ¹Ù²Ü ¾ÆÀÌÅÛÀÌ Àåºñâ¿¡ ÀÖÀ¸¸é
  4736. if (TItemPos(EQUIPMENT, item2->GetCell()).IsEquipPosition())
  4737. {
  4738. BYTE bEquipCell = item2->GetCell() - INVENTORY_MAX_NUM;
  4739. BYTE bInvenCell = item1->GetCell();
  4740.  
  4741. // Âø¿ëÁßÀÎ ¾ÆÀÌÅÛÀ» ¹þÀ» ¼ö ÀÖ°í, Âø¿ë ¿¹Á¤ ¾ÆÀÌÅÛÀÌ Âø¿ë °¡´ÉÇÑ »óÅ¿©¾ß¸¸ ÁøÇà
  4742. //if (false == CanUnequipNow(item2) || false == CanEquipNow(item1))
  4743. if (false == CanEquipNow(item1))
  4744. return false;
  4745. if (item2->IsDragonSoul() && false == CanUnequipNow(item2))
  4746. return false;
  4747.  
  4748. if (bEquipCell != item1->FindEquipCell(this)) // °°Àº À§Ä¡À϶§¸¸ Çã¿ë
  4749. return false;
  4750.  
  4751. item2->RemoveFromCharacter();
  4752.  
  4753. if (item1->EquipTo(this, bEquipCell))
  4754. item2->AddToCharacter(this, TItemPos(INVENTORY, bInvenCell));
  4755. else
  4756. sys_err("SwapItem cannot equip %s! item1 %s", item2->GetName(), item1->GetName());
  4757. }
  4758. else
  4759. {
  4760. BYTE bCell1 = item1->GetCell();
  4761. BYTE bCell2 = item2->GetCell();
  4762.  
  4763. item1->RemoveFromCharacter();
  4764. item2->RemoveFromCharacter();
  4765.  
  4766. item1->AddToCharacter(this, TItemPos(INVENTORY, bCell2));
  4767. item2->AddToCharacter(this, TItemPos(INVENTORY, bCell1));
  4768. }
  4769.  
  4770. return true;
  4771. }
  4772.  
  4773. bool CHARACTER::UnequipItem(LPITEM item) {
  4774. int pos;
  4775.  
  4776. if (false == CanUnequipNow(item))
  4777. return false;
  4778.  
  4779. if (item->IsDragonSoul())
  4780. pos = GetEmptyDragonSoulInventory(item);
  4781. else
  4782. pos = GetEmptyInventory(item->GetSize());
  4783.  
  4784. if (item->GetVnum() == UNIQUE_ITEM_HIDE_ALIGNMENT_TITLE)
  4785. ShowAlignment(true);
  4786.  
  4787. item->RemoveFromCharacter();
  4788. if (item->IsDragonSoul()) {
  4789. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, pos));
  4790. } else
  4791. item->AddToCharacter(this, TItemPos(INVENTORY, pos));
  4792.  
  4793. CheckMaximumPoints();
  4794.  
  4795. return true;
  4796. }
  4797.  
  4798. bool CHARACTER::EquipItem(LPITEM item, int iCandidateCell) {
  4799. if (item->IsExchanging())
  4800. return false;
  4801.  
  4802. if (ITEM_BELT == item->GetType() && CBeltInventoryHelper::IsExistItemInBeltInventory(this))
  4803. return false;
  4804.  
  4805. if (false == item->IsEquipable())
  4806. return false;
  4807.  
  4808. if (false == CanEquipNow(item))
  4809. return false;
  4810.  
  4811. int iWearCell = item->FindEquipCell(this, iCandidateCell);
  4812.  
  4813. if (iWearCell < 0)
  4814. return false;
  4815.  
  4816. if (iWearCell == WEAR_BODY && IsRiding() && (item->GetVnum() >= 11901 && item->GetVnum() <= 11904)) {
  4817. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸»À» ź »óÅ¿¡¼­ ¿¹º¹À» ÀÔÀ» ¼ö ¾ø½À´Ï´Ù."));
  4818. return false;
  4819. }
  4820.  
  4821. if (iWearCell != WEAR_ARROW && IsPolymorphed()) {
  4822. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µÐ°© Áß¿¡´Â Âø¿ëÁßÀÎ Àåºñ¸¦ º¯°æÇÒ ¼ö ¾ø½À´Ï´Ù."));
  4823. return false;
  4824. }
  4825.  
  4826. if (FN_check_item_sex(this, item) == false) {
  4827. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¼ºº°ÀÌ ¸ÂÁö¾Ê¾Æ ÀÌ ¾ÆÀÌÅÛÀ» »ç¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  4828. return false;
  4829. }
  4830.  
  4831. if(item->IsRideItem() && IsRiding()) {
  4832. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì Å»°ÍÀ» ÀÌ¿ëÁßÀÔ´Ï´Ù."));
  4833. return false;
  4834. }
  4835.  
  4836. DWORD dwCurTime = get_dword_time();
  4837.  
  4838. if (iWearCell != WEAR_ARROW
  4839. && (dwCurTime - GetLastAttackTime() <= 1500 || dwCurTime - m_dwLastSkillTime <= 1500)) {
  4840. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°¡¸¸È÷ ÀÖÀ» ¶§¸¸ Âø¿ëÇÒ ¼ö ÀÖ½À´Ï´Ù."));
  4841. return false;
  4842. }
  4843.  
  4844. if (item->IsDragonSoul()) {
  4845. if(GetInventoryItem(INVENTORY_MAX_NUM + iWearCell)) {
  4846. ChatPacket(CHAT_TYPE_INFO, "ÀÌ¹Ì °°Àº Á¾·ùÀÇ ¿ëÈ¥¼®À» Âø¿ëÇÏ°í ÀÖ½À´Ï´Ù.");
  4847. return false;
  4848. }
  4849.  
  4850. if (!item->EquipTo(this, iWearCell)) {
  4851. return false;
  4852. }
  4853. } else {
  4854. if (GetWear(iWearCell) && !IS_SET(GetWear(iWearCell)->GetFlag(), ITEM_FLAG_IRREMOVABLE)) {
  4855. if (item->GetWearFlag() == WEARABLE_ABILITY)
  4856. return false;
  4857.  
  4858. if (false == SwapItem(item->GetCell(), INVENTORY_MAX_NUM + iWearCell)) {
  4859. return false;
  4860. }
  4861. } else {
  4862. BYTE bOldCell = item->GetCell();
  4863.  
  4864. if (item->EquipTo(this, iWearCell)) {
  4865. SyncQuickslot(QUICKSLOT_TYPE_ITEM, bOldCell, iWearCell);
  4866. }
  4867. }
  4868. }
  4869.  
  4870. if (true == item->IsEquipped()) {
  4871. if (-1 != item->GetProto()->cLimitRealTimeFirstUseIndex) {
  4872.  
  4873. if (0 == item->GetSocket(1)) {
  4874. long duration = (0 != item->GetSocket(0)) ? item->GetSocket(0) : item->GetProto()->aLimits[item->GetProto()->cLimitRealTimeFirstUseIndex].lValue;
  4875.  
  4876. if (0 == duration)
  4877. duration = 60 * 60 * 24 * 7;
  4878.  
  4879. item->SetSocket(0, time(0) + duration);
  4880. item->StartRealTimeExpireEvent();
  4881. }
  4882.  
  4883. item->SetSocket(1, item->GetSocket(1) + 1);
  4884. }
  4885.  
  4886. if (item->GetVnum() == UNIQUE_ITEM_HIDE_ALIGNMENT_TITLE)
  4887. ShowAlignment(false);
  4888.  
  4889. const DWORD& dwVnum = item->GetVnum();
  4890.  
  4891. if (true == CItemVnumHelper::IsRamadanMoonRing(dwVnum)) {
  4892. this->EffectPacket(SE_EQUIP_RAMADAN_RING);
  4893. } else if (true == CItemVnumHelper::IsHalloweenCandy(dwVnum)) {
  4894. this->EffectPacket(SE_EQUIP_HALLOWEEN_CANDY);
  4895. } else if (true == CItemVnumHelper::IsHappinessRing(dwVnum)) {
  4896. this->EffectPacket(SE_EQUIP_HAPPINESS_RING);
  4897. } else if (true == CItemVnumHelper::IsLovePendant(dwVnum)) {
  4898. this->EffectPacket(SE_EQUIP_LOVE_PENDANT);
  4899. } else if (true == CItemVnumHelper::IsAcce_Grade1(dwVnum)) {
  4900. this->EffectPacket(SE_EQUIP_ACCE_1);
  4901. } else if (true == CItemVnumHelper::IsAcce_Grade2(dwVnum)) {
  4902. this->EffectPacket(SE_EQUIP_ACCE_2);
  4903. } else if (true == CItemVnumHelper::IsAcce_Grade3(dwVnum)) {
  4904. this->EffectPacket(SE_EQUIP_ACCE_3);
  4905. } else if (true == CItemVnumHelper::IsAcce_Grade4(dwVnum)) {
  4906. this->EffectPacket(SE_EQUIP_ACCE_4);
  4907. } else if (ITEM_UNIQUE == item->GetType() && 0 != item->GetSIGVnum()) {
  4908. const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(item->GetSIGVnum());
  4909. if (NULL != pGroup) {
  4910. const CSpecialAttrGroup* pAttrGroup = ITEM_MANAGER::instance().GetSpecialAttrGroup(pGroup->GetAttrVnum(item->GetVnum()));
  4911. if (NULL != pAttrGroup) {
  4912. const std::string& std = pAttrGroup->m_stEffectFileName;
  4913. SpecificEffectPacket(std.c_str());
  4914. }
  4915. }
  4916. }
  4917.  
  4918. if (UNIQUE_SPECIAL_RIDE == item->GetSubType() && IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE)) {
  4919. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  4920. }
  4921. if (COSTUME_MOUNT == item->GetSubType()) {
  4922. quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  4923. }
  4924. }
  4925.  
  4926. CheckMaximumPoints();
  4927.  
  4928. return true;
  4929. }
  4930.  
  4931. void CHARACTER::BuffOnAttr_AddBuffsFromItem(LPITEM pItem) {
  4932. for (int i = 0; i < sizeof(g_aBuffOnAttrPoints)/sizeof(g_aBuffOnAttrPoints[0]); i++) {
  4933. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(g_aBuffOnAttrPoints[i]);
  4934. if (it != m_map_buff_on_attrs.end()) {
  4935. it->second->AddBuffFromItem(pItem);
  4936. }
  4937. }
  4938. }
  4939.  
  4940. void CHARACTER::BuffOnAttr_RemoveBuffsFromItem(LPITEM pItem) {
  4941. for (int i = 0; i < sizeof(g_aBuffOnAttrPoints)/sizeof(g_aBuffOnAttrPoints[0]); i++) {
  4942. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(g_aBuffOnAttrPoints[i]);
  4943. if (it != m_map_buff_on_attrs.end()) {
  4944. it->second->RemoveBuffFromItem(pItem);
  4945. }
  4946. }
  4947. }
  4948.  
  4949. void CHARACTER::BuffOnAttr_ClearAll() {
  4950. for (TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.begin(); it != m_map_buff_on_attrs.end(); it++) {
  4951. CBuffOnAttributes* pBuff = it->second;
  4952. if (pBuff) {
  4953. pBuff->Initialize();
  4954. }
  4955. }
  4956. }
  4957.  
  4958. void CHARACTER::BuffOnAttr_ValueChange(BYTE bType, BYTE bOldValue, BYTE bNewValue) {
  4959. TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(bType);
  4960.  
  4961. if (0 == bNewValue) {
  4962. if (m_map_buff_on_attrs.end() == it)
  4963. return;
  4964. else
  4965. it->second->Off();
  4966. } else if(0 == bOldValue) {
  4967. CBuffOnAttributes* pBuff;
  4968. if (m_map_buff_on_attrs.end() == it) {
  4969. switch (bType) {
  4970. case POINT_ENERGY: {
  4971. static BYTE abSlot[] = { WEAR_BODY, WEAR_HEAD, WEAR_FOOTS, WEAR_WRIST, WEAR_WEAPON, WEAR_NECK, WEAR_EAR, WEAR_SHIELD };
  4972. static std::vector <BYTE> vec_slots (abSlot, abSlot + _countof(abSlot));
  4973. pBuff = M2_NEW CBuffOnAttributes(this, bType, &vec_slots);
  4974. }
  4975. break;
  4976. case POINT_COSTUME_ATTR_BONUS: {
  4977. static BYTE abSlot[] = {WEAR_COSTUME_BODY, WEAR_COSTUME_HAIR,WEAR_COSTUME_WEAPON,WEAR_COSTUME_MOUNT};
  4978. static std::vector <BYTE> vec_slots (abSlot, abSlot + _countof(abSlot));
  4979. pBuff = M2_NEW CBuffOnAttributes(this, bType, &vec_slots);
  4980. }
  4981. break;
  4982. default:
  4983. break;
  4984. }
  4985. m_map_buff_on_attrs.insert(TMapBuffOnAttrs::value_type(bType, pBuff));
  4986.  
  4987. } else
  4988. pBuff = it->second;
  4989.  
  4990. pBuff->On(bNewValue);
  4991. } else {
  4992. if (m_map_buff_on_attrs.end() == it)
  4993. return;
  4994. else
  4995. it->second->ChangeBuffValue(bNewValue);
  4996. }
  4997. }
  4998.  
  4999.  
  5000. LPITEM CHARACTER::FindSpecifyItem(DWORD vnum) const {
  5001. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  5002. if (GetInventoryItem(i) && GetInventoryItem(i)->GetVnum() == vnum)
  5003. return GetInventoryItem(i);
  5004.  
  5005. return NULL;
  5006. }
  5007.  
  5008. LPITEM CHARACTER::FindItemByID(DWORD id) const {
  5009. for (int i=0 ; i < INVENTORY_MAX_NUM ; ++i) {
  5010. if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetID() == id)
  5011. return GetInventoryItem(i);
  5012. }
  5013.  
  5014. for (int i=BELT_INVENTORY_SLOT_START; i < BELT_INVENTORY_SLOT_END ; ++i) {
  5015. if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetID() == id)
  5016. return GetInventoryItem(i);
  5017. }
  5018.  
  5019. return NULL;
  5020. }
  5021.  
  5022. int CHARACTER::CountSpecifyItem(DWORD vnum) const {
  5023. int count = 0;
  5024. LPITEM item;
  5025.  
  5026. for (int i = 0; i < INVENTORY_MAX_NUM; ++i) {
  5027. item = GetInventoryItem(i);
  5028. if (NULL != item && item->GetVnum() == vnum) {
  5029. if (m_pkMyShop && m_pkMyShop->IsSellingItem(item->GetID())) {
  5030. continue;
  5031. } else {
  5032. count += item->GetCount();
  5033. }
  5034. }
  5035. }
  5036.  
  5037. return count;
  5038. }
  5039.  
  5040. void CHARACTER::RemoveSpecifyItem(DWORD vnum, DWORD count) {
  5041. if (0 == count)
  5042. return;
  5043.  
  5044. for (UINT i = 0; i < INVENTORY_MAX_NUM; ++i) {
  5045. if (NULL == GetInventoryItem(i))
  5046. continue;
  5047.  
  5048. if (GetInventoryItem(i)->GetVnum() != vnum)
  5049. continue;
  5050.  
  5051. if(m_pkMyShop) {
  5052. bool isItemSelling = m_pkMyShop->IsSellingItem(GetInventoryItem(i)->GetID());
  5053. if (isItemSelling)
  5054. continue;
  5055. }
  5056.  
  5057. if (vnum >= 80003 && vnum <= 80007)
  5058. LogManager::instance().GoldBarLog(GetPlayerID(), GetInventoryItem(i)->GetID(), QUEST, "RemoveSpecifyItem");
  5059.  
  5060. if (count >= GetInventoryItem(i)->GetCount()) {
  5061. count -= GetInventoryItem(i)->GetCount();
  5062. GetInventoryItem(i)->SetCount(0);
  5063.  
  5064. if (0 == count)
  5065. return;
  5066. } else {
  5067. GetInventoryItem(i)->SetCount(GetInventoryItem(i)->GetCount() - count);
  5068. return;
  5069. }
  5070. }
  5071.  
  5072. if (count)
  5073. sys_log(0, "CHARACTER::RemoveSpecifyItem cannot remove enough item vnum %u, still remain %d", vnum, count);
  5074. }
  5075.  
  5076. int CHARACTER::CountSpecifyTypeItem(BYTE type) const {
  5077. int count = 0;
  5078.  
  5079. for (int i = 0; i < INVENTORY_MAX_NUM; ++i) {
  5080. LPITEM pItem = GetInventoryItem(i);
  5081. if (pItem != NULL && pItem->GetType() == type) {
  5082. count += pItem->GetCount();
  5083. }
  5084. }
  5085.  
  5086. return count;
  5087. }
  5088.  
  5089. void CHARACTER::RemoveSpecifyTypeItem(BYTE type, DWORD count) {
  5090. if (0 == count)
  5091. return;
  5092.  
  5093. for (UINT i = 0; i < INVENTORY_MAX_NUM; ++i) {
  5094. if (NULL == GetInventoryItem(i))
  5095. continue;
  5096.  
  5097. if (GetInventoryItem(i)->GetType() != type)
  5098. continue;
  5099.  
  5100. if(m_pkMyShop) {
  5101. bool isItemSelling = m_pkMyShop->IsSellingItem(GetInventoryItem(i)->GetID());
  5102. if (isItemSelling)
  5103. continue;
  5104. }
  5105.  
  5106. if (count >= GetInventoryItem(i)->GetCount()) {
  5107. count -= GetInventoryItem(i)->GetCount();
  5108. GetInventoryItem(i)->SetCount(0);
  5109.  
  5110. if (0 == count)
  5111. return;
  5112. } else {
  5113. GetInventoryItem(i)->SetCount(GetInventoryItem(i)->GetCount() - count);
  5114. return;
  5115. }
  5116. }
  5117. }
  5118.  
  5119. void CHARACTER::AutoGiveItem(LPITEM item, bool longOwnerShip) {
  5120. if (NULL == item) {
  5121. sys_err ("NULL point.");
  5122. return;
  5123. }
  5124. if (item->GetOwner()) {
  5125. sys_err ("item %d 's owner exists!",item->GetID());
  5126. return;
  5127. }
  5128.  
  5129. int cell;
  5130. if (item->IsDragonSoul()) {
  5131. cell = GetEmptyDragonSoulInventory(item);
  5132. } else {
  5133. cell = GetEmptyInventory (item->GetSize());
  5134. }
  5135.  
  5136. if (cell != -1) {
  5137. if (item->IsDragonSoul())
  5138. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, cell));
  5139. else
  5140. item->AddToCharacter(this, TItemPos(INVENTORY, cell));
  5141.  
  5142. LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
  5143.  
  5144. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_POTION) {
  5145. TQuickslot * pSlot;
  5146.  
  5147. if (GetQuickslot(0, &pSlot) && pSlot->type == QUICKSLOT_TYPE_NONE) {
  5148. TQuickslot slot;
  5149. slot.type = QUICKSLOT_TYPE_ITEM;
  5150. slot.pos = cell;
  5151. SetQuickslot(0, slot);
  5152. }
  5153. }
  5154. } else {
  5155. item->AddToGround (GetMapIndex(), GetXYZ());
  5156. item->StartDestroyEvent();
  5157.  
  5158. if (longOwnerShip)
  5159. item->SetOwnership (this, 120);
  5160. else
  5161. item->SetOwnership (this, 30);
  5162. LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
  5163. }
  5164. }
  5165.  
  5166. LPITEM CHARACTER::AutoGiveItem(DWORD dwItemVnum, BYTE bCount, int iRarePct, bool bMsg) {
  5167. TItemTable * p = ITEM_MANAGER::instance().GetTable(dwItemVnum);
  5168.  
  5169. if (!p)
  5170. return NULL;
  5171.  
  5172. DBManager::instance().SendMoneyLog(MONEY_LOG_DROP, dwItemVnum, bCount);
  5173.  
  5174. if (p->dwFlags & ITEM_FLAG_STACKABLE && p->bType != ITEM_BLEND) {
  5175. for (int i = 0; i < INVENTORY_MAX_NUM; ++i) {
  5176. LPITEM item = GetInventoryItem(i);
  5177.  
  5178. if (!item)
  5179. continue;
  5180.  
  5181. if (item->GetVnum() == dwItemVnum && FN_check_item_socket(item)) {
  5182. if (IS_SET(p->dwFlags, ITEM_FLAG_MAKECOUNT)) {
  5183. if (bCount < p->alValues[1])
  5184. bCount = p->alValues[1];
  5185. }
  5186.  
  5187. BYTE bCount2 = MIN(200 - item->GetCount(), bCount);
  5188. bCount -= bCount2;
  5189.  
  5190. item->SetCount(item->GetCount() + bCount2);
  5191.  
  5192. if (bCount == 0) {
  5193. if (bMsg)
  5194. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛ È¹µæ: %s"), item->GetName());
  5195.  
  5196. return item;
  5197. }
  5198. }
  5199. }
  5200. }
  5201.  
  5202. LPITEM item = ITEM_MANAGER::instance().CreateItem(dwItemVnum, bCount, 0, true);
  5203.  
  5204. if (!item) {
  5205. sys_err("cannot create item by vnum %u (name: %s)", dwItemVnum, GetName());
  5206. return NULL;
  5207. }
  5208.  
  5209. if (item->GetType() == ITEM_BLEND) {
  5210. for (int i=0; i < INVENTORY_MAX_NUM; i++) {
  5211. LPITEM inv_item = GetInventoryItem(i);
  5212.  
  5213. if (inv_item == NULL)
  5214. continue;
  5215.  
  5216. if (inv_item->GetType() == ITEM_BLEND) {
  5217. if (inv_item->GetVnum() == item->GetVnum()) {
  5218. if (inv_item->GetSocket(0) == item->GetSocket(0) &&
  5219. inv_item->GetSocket(1) == item->GetSocket(1) &&
  5220. inv_item->GetSocket(2) == item->GetSocket(2) &&
  5221. inv_item->GetCount() < ITEM_MAX_COUNT) {
  5222.  
  5223. inv_item->SetCount(inv_item->GetCount() + item->GetCount());
  5224. return inv_item;
  5225. }
  5226. }
  5227. }
  5228. }
  5229. }
  5230.  
  5231. int iEmptyCell;
  5232. if (item->IsDragonSoul()) {
  5233. iEmptyCell = GetEmptyDragonSoulInventory(item);
  5234. } else
  5235. iEmptyCell = GetEmptyInventory(item->GetSize());
  5236.  
  5237. if (iEmptyCell != -1) {
  5238. if (bMsg)
  5239. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛ È¹µæ: %s"), item->GetName());
  5240.  
  5241. if (item->IsDragonSoul())
  5242. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  5243. else
  5244. item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
  5245. LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
  5246.  
  5247. if (item->GetType() == ITEM_USE && item->GetSubType() == USE_POTION) {
  5248. TQuickslot * pSlot;
  5249.  
  5250. if (GetQuickslot(0, &pSlot) && pSlot->type == QUICKSLOT_TYPE_NONE) {
  5251. TQuickslot slot;
  5252. slot.type = QUICKSLOT_TYPE_ITEM;
  5253. slot.pos = iEmptyCell;
  5254. SetQuickslot(0, slot);
  5255. }
  5256. }
  5257. } else {
  5258. item->AddToGround(GetMapIndex(), GetXYZ());
  5259. item->StartDestroyEvent();
  5260. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP))
  5261. item->SetOwnership(this, 120);
  5262. else
  5263. item->SetOwnership(this, 30);
  5264. LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
  5265. }
  5266.  
  5267. sys_log(0,
  5268. "7: %d %d", dwItemVnum, bCount);
  5269. return item;
  5270. }
  5271.  
  5272. LPITEM CHARACTER::AutoGiveAcce(DWORD dwItemVnum, BYTE bCount, int iSocketTwo, int iRarePct, bool bMsg)
  5273. {
  5274. TItemTable * p = ITEM_MANAGER::instance().GetTable(dwItemVnum);
  5275. if (!p)
  5276. return NULL;
  5277.  
  5278. DBManager::instance().SendMoneyLog(MONEY_LOG_DROP, dwItemVnum, bCount);
  5279.  
  5280. if (p->dwFlags & ITEM_FLAG_STACKABLE && p->bType != ITEM_BLEND)
  5281. {
  5282. for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  5283. {
  5284. LPITEM item = GetInventoryItem(i);
  5285. if (!item)
  5286. continue;
  5287.  
  5288. if (item->GetVnum() == dwItemVnum && FN_check_item_socket(item))
  5289. {
  5290. if (IS_SET(p->dwFlags, ITEM_FLAG_MAKECOUNT))
  5291. {
  5292. if (bCount < p->alValues[1])
  5293. bCount = p->alValues[1];
  5294. }
  5295.  
  5296. BYTE bCount2 = MIN(200 - item->GetCount(), bCount);
  5297. bCount -= bCount2;
  5298.  
  5299. item->SetCount(item->GetCount() + bCount2);
  5300. if (bCount == 0)
  5301. {
  5302. if (bMsg)
  5303. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛ È¹µæ: %s"), item->GetName());
  5304.  
  5305. return item;
  5306. }
  5307. }
  5308. }
  5309. }
  5310.  
  5311. LPITEM item = ITEM_MANAGER::instance().CreateItem(dwItemVnum, bCount, 0, true);
  5312. if (!item)
  5313. {
  5314. sys_err("Cannot create item by vnum %u (name: %s).", dwItemVnum, GetName());
  5315. return NULL;
  5316. }
  5317.  
  5318. int iEmptyCell;
  5319. if (item->IsDragonSoul())
  5320. {
  5321. iEmptyCell = GetEmptyDragonSoulInventory(item);
  5322. }
  5323. else
  5324. iEmptyCell = GetEmptyInventory(item->GetSize());
  5325.  
  5326. if (iEmptyCell != -1)
  5327. {
  5328. if (bMsg)
  5329. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÀÌÅÛ È¹µæ: %s"), item->GetName());
  5330.  
  5331. if (item->IsDragonSoul())
  5332. item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  5333. else
  5334. item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
  5335.  
  5336. item->SetSocket(1, iSocketTwo);
  5337. LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
  5338. }
  5339. else
  5340. {
  5341. item->AddToGround(GetMapIndex(), GetXYZ());
  5342. item->SetSocket(1, iSocketTwo);
  5343. item->StartDestroyEvent();
  5344. if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP))
  5345. item->SetOwnership(this, 120);
  5346. else
  5347. item->SetOwnership(this, 30);
  5348.  
  5349. LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
  5350. }
  5351.  
  5352. sys_log(0, "Acce received: %d %d", dwItemVnum, bCount);
  5353. return item;
  5354. }
  5355.  
  5356. bool CHARACTER::GiveItem(LPCHARACTER victim, TItemPos Cell) {
  5357. if (!CanHandleItem())
  5358. return false;
  5359.  
  5360. LPITEM item = GetItem(Cell);
  5361.  
  5362. if (item && !item->IsExchanging()) {
  5363. if (victim->CanReceiveItem(this, item)) {
  5364. victim->ReceiveItem(this, item);
  5365. return true;
  5366. }
  5367. }
  5368.  
  5369. return false;
  5370. }
  5371.  
  5372. bool CHARACTER::CanReceiveItem(LPCHARACTER from, LPITEM item) const
  5373. {
  5374. if (IsPC())
  5375. return false;
  5376.  
  5377. // TOO_LONG_DISTANCE_EXCHANGE_BUG_FIX
  5378. if (DISTANCE_APPROX(GetX() - from->GetX(), GetY() - from->GetY()) > 2000)
  5379. return false;
  5380. // END_OF_TOO_LONG_DISTANCE_EXCHANGE_BUG_FIX
  5381.  
  5382. switch (GetRaceNum())
  5383. {
  5384. case fishing::CAMPFIRE_MOB:
  5385. if (item->GetType() == ITEM_FISH &&
  5386. (item->GetSubType() == FISH_ALIVE || item->GetSubType() == FISH_DEAD))
  5387. return true;
  5388. break;
  5389.  
  5390. case fishing::FISHER_MOB:
  5391. if (item->GetType() == ITEM_ROD)
  5392. return true;
  5393. break;
  5394.  
  5395. // BUILDING_NPC
  5396. case BLACKSMITH_WEAPON_MOB:
  5397. case DEVILTOWER_BLACKSMITH_WEAPON_MOB:
  5398. if (item->GetType() == ITEM_WEAPON &&
  5399. item->GetRefinedVnum())
  5400. return true;
  5401. else
  5402. return false;
  5403. break;
  5404.  
  5405. case BLACKSMITH_ARMOR_MOB:
  5406. case DEVILTOWER_BLACKSMITH_ARMOR_MOB:
  5407. if (item->GetType() == ITEM_ARMOR &&
  5408. (item->GetSubType() == ARMOR_BODY || item->GetSubType() == ARMOR_SHIELD || item->GetSubType() == ARMOR_HEAD) &&
  5409. item->GetRefinedVnum())
  5410. return true;
  5411. else
  5412. return false;
  5413. break;
  5414.  
  5415. case BLACKSMITH_ACCESSORY_MOB:
  5416. case DEVILTOWER_BLACKSMITH_ACCESSORY_MOB:
  5417. if (item->GetType() == ITEM_ARMOR &&
  5418. !(item->GetSubType() == ARMOR_BODY || item->GetSubType() == ARMOR_SHIELD || item->GetSubType() == ARMOR_HEAD) &&
  5419. item->GetRefinedVnum())
  5420. return true;
  5421. else
  5422. return false;
  5423. break;
  5424. // END_OF_BUILDING_NPC
  5425.  
  5426. case BLACKSMITH_MOB:
  5427. if (item->GetRefinedVnum() && item->GetRefineSet() < 500)
  5428. {
  5429. return true;
  5430. }
  5431. else
  5432. {
  5433. return false;
  5434. }
  5435.  
  5436. case BLACKSMITH2_MOB:
  5437. if (item->GetRefineSet() >= 500)
  5438. {
  5439. return true;
  5440. }
  5441. else
  5442. {
  5443. return false;
  5444. }
  5445.  
  5446. case ALCHEMIST_MOB:
  5447. if (item->GetRefinedVnum())
  5448. return true;
  5449. break;
  5450.  
  5451. case 20101:
  5452. case 20102:
  5453. case 20103:
  5454. // ÃÊ±Þ ¸»
  5455. if (item->GetVnum() == ITEM_REVIVE_HORSE_1)
  5456. {
  5457. if (!IsDead())
  5458. {
  5459. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Áö ¾ÊÀº ¸»¿¡°Ô ¼±Ãʸ¦ ¸ÔÀÏ ¼ö ¾ø½À´Ï´Ù."));
  5460. return false;
  5461. }
  5462. return true;
  5463. }
  5464. else if (item->GetVnum() == ITEM_HORSE_FOOD_1)
  5465. {
  5466. if (IsDead())
  5467. {
  5468. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Àº ¸»¿¡°Ô »ç·á¸¦ ¸ÔÀÏ ¼ö ¾ø½À´Ï´Ù."));
  5469. return false;
  5470. }
  5471. return true;
  5472. }
  5473. else if (item->GetVnum() == ITEM_HORSE_FOOD_2 || item->GetVnum() == ITEM_HORSE_FOOD_3)
  5474. {
  5475. return false;
  5476. }
  5477. break;
  5478. case 20104:
  5479. case 20105:
  5480. case 20106:
  5481. // Áß±Þ ¸»
  5482. if (item->GetVnum() == ITEM_REVIVE_HORSE_2)
  5483. {
  5484. if (!IsDead())
  5485. {
  5486. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Áö ¾ÊÀº ¸»¿¡°Ô ¼±Ãʸ¦ ¸ÔÀÏ ¼ö ¾ø½À´Ï´Ù."));
  5487. return false;
  5488. }
  5489. return true;
  5490. }
  5491. else if (item->GetVnum() == ITEM_HORSE_FOOD_2)
  5492. {
  5493. if (IsDead())
  5494. {
  5495. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Àº ¸»¿¡°Ô »ç·á¸¦ ¸ÔÀÏ ¼ö ¾ø½À´Ï´Ù."));
  5496. return false;
  5497. }
  5498. return true;
  5499. }
  5500. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 || item->GetVnum() == ITEM_HORSE_FOOD_3)
  5501. {
  5502. return false;
  5503. }
  5504. break;
  5505. case 20107:
  5506. case 20108:
  5507. case 20109:
  5508. // °í±Þ ¸»
  5509. if (item->GetVnum() == ITEM_REVIVE_HORSE_3)
  5510. {
  5511. if (!IsDead())
  5512. {
  5513. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Áö ¾ÊÀº ¸»¿¡°Ô ¼±Ãʸ¦ ¸ÔÀÏ ¼ö ¾ø½À´Ï´Ù."));
  5514. return false;
  5515. }
  5516. return true;
  5517. }
  5518. else if (item->GetVnum() == ITEM_HORSE_FOOD_3)
  5519. {
  5520. if (IsDead())
  5521. {
  5522. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Á×Àº ¸»¿¡°Ô »ç·á¸¦ ¸ÔÀÏ ¼ö ¾ø½À´Ï´Ù."));
  5523. return false;
  5524. }
  5525. return true;
  5526. }
  5527. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 || item->GetVnum() == ITEM_HORSE_FOOD_2)
  5528. {
  5529. return false;
  5530. }
  5531. break;
  5532. }
  5533.  
  5534. //if (IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_GIVE))
  5535. {
  5536. return true;
  5537. }
  5538.  
  5539. return false;
  5540. }
  5541.  
  5542. void CHARACTER::ReceiveItem(LPCHARACTER from, LPITEM item)
  5543. {
  5544. if (IsPC())
  5545. return;
  5546.  
  5547. switch (GetRaceNum())
  5548. {
  5549. case fishing::CAMPFIRE_MOB:
  5550. if (item->GetType() == ITEM_FISH && (item->GetSubType() == FISH_ALIVE || item->GetSubType() == FISH_DEAD))
  5551. fishing::Grill(from, item);
  5552. else
  5553. {
  5554. // TAKE_ITEM_BUG_FIX
  5555. from->SetQuestNPCID(GetVID());
  5556. // END_OF_TAKE_ITEM_BUG_FIX
  5557. quest::CQuestManager::instance().TakeItem(from->GetPlayerID(), GetRaceNum(), item);
  5558. }
  5559. break;
  5560.  
  5561. // DEVILTOWER_NPC
  5562. case DEVILTOWER_BLACKSMITH_WEAPON_MOB:
  5563. case DEVILTOWER_BLACKSMITH_ARMOR_MOB:
  5564. case DEVILTOWER_BLACKSMITH_ACCESSORY_MOB:
  5565. if (item->GetRefinedVnum() != 0 && item->GetRefineSet() != 0 && item->GetRefineSet() < 500)
  5566. {
  5567. from->SetRefineNPC(this);
  5568. from->RefineInformation(item->GetCell(), REFINE_TYPE_MONEY_ONLY);
  5569. }
  5570. else
  5571. {
  5572. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀº °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  5573. }
  5574. break;
  5575. // END_OF_DEVILTOWER_NPC
  5576.  
  5577. case BLACKSMITH_MOB:
  5578. case BLACKSMITH2_MOB:
  5579. case BLACKSMITH_WEAPON_MOB:
  5580. case BLACKSMITH_ARMOR_MOB:
  5581. case BLACKSMITH_ACCESSORY_MOB:
  5582. if (item->GetRefinedVnum())
  5583. {
  5584. from->SetRefineNPC(this);
  5585. from->RefineInformation(item->GetCell(), REFINE_TYPE_NORMAL);
  5586. }
  5587. else
  5588. {
  5589. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ ¾ÆÀÌÅÛÀº °³·®ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  5590. }
  5591. break;
  5592.  
  5593. case 20101:
  5594. case 20102:
  5595. case 20103:
  5596. case 20104:
  5597. case 20105:
  5598. case 20106:
  5599. case 20107:
  5600. case 20108:
  5601. case 20109:
  5602. if (item->GetVnum() == ITEM_REVIVE_HORSE_1 ||
  5603. item->GetVnum() == ITEM_REVIVE_HORSE_2 ||
  5604. item->GetVnum() == ITEM_REVIVE_HORSE_3)
  5605. {
  5606. from->ReviveHorse();
  5607. item->SetCount(item->GetCount()-1);
  5608. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸»¿¡°Ô ¼±Ãʸ¦ ÁÖ¾ú½À´Ï´Ù."));
  5609. }
  5610. else if (item->GetVnum() == ITEM_HORSE_FOOD_1 ||
  5611. item->GetVnum() == ITEM_HORSE_FOOD_2 ||
  5612. item->GetVnum() == ITEM_HORSE_FOOD_3)
  5613. {
  5614. from->FeedHorse();
  5615. from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¸»¿¡°Ô »ç·á¸¦ ÁÖ¾ú½À´Ï´Ù."));
  5616. item->SetCount(item->GetCount()-1);
  5617. EffectPacket(SE_HPUP_RED);
  5618. }
  5619. break;
  5620.  
  5621. default:
  5622. sys_log(0, "TakeItem %s %d %s", from->GetName(), GetRaceNum(), item->GetName());
  5623. from->SetQuestNPCID(GetVID());
  5624. quest::CQuestManager::instance().TakeItem(from->GetPlayerID(), GetRaceNum(), item);
  5625. break;
  5626. }
  5627. }
  5628.  
  5629. bool CHARACTER::IsEquipUniqueItem(DWORD dwItemVnum) const
  5630. {
  5631. {
  5632. LPITEM u = GetWear(WEAR_UNIQUE1);
  5633.  
  5634. if (u && u->GetVnum() == dwItemVnum)
  5635. return true;
  5636. }
  5637.  
  5638. {
  5639. LPITEM u = GetWear(WEAR_UNIQUE2);
  5640.  
  5641. if (u && u->GetVnum() == dwItemVnum)
  5642. return true;
  5643. }
  5644.  
  5645. {
  5646. LPITEM u = GetWear(WEAR_COSTUME_MOUNT);
  5647.  
  5648. if (u && u->GetVnum() == dwItemVnum)
  5649. return true;
  5650. }
  5651.  
  5652. if (dwItemVnum == UNIQUE_ITEM_RING_OF_LANGUAGE)
  5653. return IsEquipUniqueItem(UNIQUE_ITEM_RING_OF_LANGUAGE_SAMPLE);
  5654.  
  5655. return false;
  5656. }
  5657.  
  5658. bool CHARACTER::IsEquipUniqueGroup(DWORD dwGroupVnum) const
  5659. {
  5660. {
  5661. LPITEM u = GetWear(WEAR_UNIQUE1);
  5662.  
  5663. if (u && u->GetSpecialGroup() == (int)dwGroupVnum)
  5664. return true;
  5665. }
  5666.  
  5667. {
  5668. LPITEM u = GetWear(WEAR_UNIQUE2);
  5669.  
  5670. if (u && u->GetSpecialGroup() == (int)dwGroupVnum)
  5671. return true;
  5672. }
  5673.  
  5674. {
  5675. LPITEM u = GetWear(WEAR_COSTUME_MOUNT);
  5676.  
  5677. if (u && u->GetSpecialGroup() == (int)dwGroupVnum)
  5678. return true;
  5679. }
  5680.  
  5681. return false;
  5682. }
  5683.  
  5684. void CHARACTER::SetRefineMode(int iAdditionalCell) {
  5685. m_iRefineAdditionalCell = iAdditionalCell;
  5686. m_bUnderRefine = true;
  5687. }
  5688.  
  5689. void CHARACTER::ClearRefineMode() {
  5690. m_bUnderRefine = false;
  5691. SetRefineNPC( NULL );
  5692. }
  5693.  
  5694. bool CHARACTER::GiveItemFromSpecialItemGroup(DWORD dwGroupNum, std::vector<DWORD> &dwItemVnums,std::vector<DWORD> &dwItemCounts, std::vector <LPITEM> &item_gets, int &count) {
  5695. const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(dwGroupNum);
  5696.  
  5697. if (!pGroup) {
  5698. sys_err("cannot find special item group %d", dwGroupNum);
  5699. return false;
  5700. }
  5701.  
  5702. std::vector <int> idxes;
  5703. int n = pGroup->GetMultiIndex(idxes);
  5704.  
  5705. bool bSuccess;
  5706.  
  5707. for (int i = 0; i < n; i++) {
  5708. bSuccess = false;
  5709. int idx = idxes[i];
  5710. DWORD dwVnum = pGroup->GetVnum(idx);
  5711. DWORD dwCount = pGroup->GetCount(idx);
  5712. int iRarePct = pGroup->GetRarePct(idx);
  5713. LPITEM item_get = NULL;
  5714. switch (dwVnum) {
  5715. case CSpecialItemGroup::GOLD:
  5716. PointChange(POINT_GOLD, dwCount);
  5717. LogManager::instance().CharLog(this, dwCount, "TREASURE_GOLD", "");
  5718.  
  5719. bSuccess = true;
  5720. break;
  5721. case CSpecialItemGroup::EXP: {
  5722. PointChange(POINT_EXP, dwCount);
  5723. LogManager::instance().CharLog(this, dwCount, "TREASURE_EXP", "");
  5724.  
  5725. bSuccess = true;
  5726. }
  5727. break;
  5728.  
  5729. case CSpecialItemGroup::MOB: {
  5730. sys_log(0, "CSpecialItemGroup::MOB %d", dwCount);
  5731. int x = GetX() + number(-500, 500);
  5732. int y = GetY() + number(-500, 500);
  5733.  
  5734. LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(dwCount, GetMapIndex(), x, y, 0, true, -1);
  5735. if (ch)
  5736. ch->SetAggressive();
  5737. bSuccess = true;
  5738. }
  5739. break;
  5740. case CSpecialItemGroup::SLOW: {
  5741. sys_log(0, "CSpecialItemGroup::SLOW %d", -(int)dwCount);
  5742. AddAffect(AFFECT_SLOW, POINT_MOV_SPEED, -(int)dwCount, AFF_SLOW, 300, 0, true);
  5743. bSuccess = true;
  5744. }
  5745. break;
  5746. case CSpecialItemGroup::DRAIN_HP: {
  5747. int iDropHP = GetMaxHP()*dwCount/100;
  5748. sys_log(0, "CSpecialItemGroup::DRAIN_HP %d", -iDropHP);
  5749. iDropHP = MIN(iDropHP, GetHP()-1);
  5750. sys_log(0, "CSpecialItemGroup::DRAIN_HP %d", -iDropHP);
  5751. PointChange(POINT_HP, -iDropHP);
  5752. bSuccess = true;
  5753. }
  5754. break;
  5755. case CSpecialItemGroup::POISON: {
  5756. AttackedByPoison(NULL);
  5757. bSuccess = true;
  5758. }
  5759. break;
  5760.  
  5761. case CSpecialItemGroup::MOB_GROUP: {
  5762. int sx = GetX() - number(300, 500);
  5763. int sy = GetY() - number(300, 500);
  5764. int ex = GetX() + number(300, 500);
  5765. int ey = GetY() + number(300, 500);
  5766. CHARACTER_MANAGER::instance().SpawnGroup(dwCount, GetMapIndex(), sx, sy, ex, ey, NULL, true);
  5767.  
  5768. bSuccess = true;
  5769. }
  5770. break;
  5771. default: {
  5772. item_get = AutoGiveItem(dwVnum, dwCount, iRarePct);
  5773.  
  5774. if (item_get) {
  5775. bSuccess = true;
  5776. }
  5777. }
  5778. break;
  5779. }
  5780.  
  5781. if (bSuccess) {
  5782. dwItemVnums.push_back(dwVnum);
  5783. dwItemCounts.push_back(dwCount);
  5784. item_gets.push_back(item_get);
  5785. count++;
  5786.  
  5787. } else {
  5788. return false;
  5789. }
  5790. }
  5791. return bSuccess;
  5792. }
  5793.  
  5794. bool CHARACTER::ItemProcess_Hair(LPITEM item, int iDestCell) {
  5795.  
  5796. if (item->CheckItemUseLevel(GetLevel()) == false) {
  5797. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¾ÆÁ÷ ÀÌ ¸Ó¸®¸¦ »ç¿ëÇÒ ¼ö ¾ø´Â ·¹º§ÀÔ´Ï´Ù."));
  5798. return false;
  5799. }
  5800.  
  5801. DWORD hair = item->GetVnum();
  5802.  
  5803. switch (GetJob()) {
  5804. case JOB_WARRIOR :
  5805. hair -= 72000;
  5806. break;
  5807.  
  5808. case JOB_ASSASSIN :
  5809. hair -= 71250;
  5810. break;
  5811.  
  5812. case JOB_SURA :
  5813. hair -= 70500;
  5814. break;
  5815.  
  5816. case JOB_SHAMAN :
  5817. hair -= 69750;
  5818. break;
  5819.  
  5820. default :
  5821. return false;
  5822. break;
  5823. }
  5824.  
  5825. if (hair == GetPart(PART_HAIR)) {
  5826. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µ¿ÀÏÇÑ ¸Ó¸® ½ºÅ¸ÀϷδ ±³Ã¼ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  5827. return true;
  5828. }
  5829.  
  5830. item->SetCount(item->GetCount() - 1);
  5831.  
  5832. SetPart(PART_HAIR, hair);
  5833. UpdatePacket();
  5834.  
  5835. return true;
  5836. }
  5837.  
  5838. bool CHARACTER::ItemProcess_Polymorph(LPITEM item) {
  5839. if (IsPolymorphed()) {
  5840. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÌ¹Ì µÐ°©ÁßÀÎ »óÅÂÀÔ´Ï´Ù."));
  5841. return false;
  5842. }
  5843.  
  5844. if (true == IsRiding()) {
  5845. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("µÐ°©ÇÒ ¼ö ¾ø´Â »óÅÂÀÔ´Ï´Ù."));
  5846. return false;
  5847. }
  5848.  
  5849. DWORD dwVnum = item->GetSocket(0);
  5850.  
  5851. if (dwVnum == 0) {
  5852. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("À߸øµÈ µÐ°© ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  5853. item->SetCount(item->GetCount()-1);
  5854. return false;
  5855. }
  5856.  
  5857. const CMob* pMob = CMobManager::instance().Get(dwVnum);
  5858.  
  5859. if (pMob == NULL) {
  5860. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("À߸øµÈ µÐ°© ¾ÆÀÌÅÛÀÔ´Ï´Ù."));
  5861. item->SetCount(item->GetCount()-1);
  5862. return false;
  5863. }
  5864.  
  5865. switch (item->GetVnum()) {
  5866. case 70104 :
  5867. case 70105 :
  5868. case 70106 :
  5869. case 70107 :
  5870. case 71093 : {
  5871. sys_log(0, "USE_POLYMORPH_BALL PID(%d) vnum(%d)", GetPlayerID(), dwVnum);
  5872. int iPolymorphLevelLimit = MAX(0, 20 - GetLevel() * 3 / 10);
  5873. if (pMob->m_table.bLevel >= GetLevel() + iPolymorphLevelLimit) {
  5874. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("³ªº¸´Ù ³Ê¹« ³ôÀº ·¹º§ÀÇ ¸ó½ºÅͷδ º¯½Å ÇÒ ¼ö ¾ø½À´Ï´Ù."));
  5875. return false;
  5876. }
  5877.  
  5878. int iDuration = GetSkillLevel(POLYMORPH_SKILL_ID) == 0 ? 5 : (5 + (5 + GetSkillLevel(POLYMORPH_SKILL_ID)/40 * 25));
  5879. iDuration *= 60;
  5880.  
  5881. DWORD dwBonus = 0;
  5882.  
  5883.  
  5884. dwBonus = (2 + GetSkillLevel(POLYMORPH_SKILL_ID)/40) * 100;
  5885.  
  5886.  
  5887. AddAffect(AFFECT_POLYMORPH, POINT_POLYMORPH, dwVnum, AFF_POLYMORPH, iDuration, 0, true);
  5888. AddAffect(AFFECT_POLYMORPH, POINT_ATT_BONUS, dwBonus, AFF_POLYMORPH, iDuration, 0, false);
  5889.  
  5890. item->SetCount(item->GetCount()-1);
  5891. }
  5892. break;
  5893.  
  5894. case 50322: {
  5895. sys_log(0, "USE_POLYMORPH_BOOK: %s(%u) vnum(%u)", GetName(), GetPlayerID(), dwVnum);
  5896.  
  5897. if (CPolymorphUtils::instance().PolymorphCharacter(this, item, pMob) == true) {
  5898. CPolymorphUtils::instance().UpdateBookPracticeGrade(this, item);
  5899. } else {
  5900. }
  5901. }
  5902. break;
  5903.  
  5904. default :
  5905. sys_err("POLYMORPH invalid item passed PID(%d) vnum(%d)", GetPlayerID(), item->GetOriginalVnum());
  5906. return false;
  5907. }
  5908.  
  5909. return true;
  5910. }
  5911.  
  5912. bool CHARACTER::CanDoAcce() const
  5913. {
  5914. if (m_bIsObserver)
  5915. return false;
  5916.  
  5917. if (GetShop())
  5918. return false;
  5919.  
  5920. if (GetMyShop())
  5921. return false;
  5922.  
  5923. if (m_bUnderRefine)
  5924. return false;
  5925.  
  5926. if (IsWarping())
  5927. return false;
  5928.  
  5929. return true;
  5930. }
  5931.  
  5932. bool CHARACTER::CanDoCube() const {
  5933. if (m_bIsObserver)
  5934. return false;
  5935.  
  5936. if (GetShop())
  5937. return false;
  5938.  
  5939. if (GetMyShop())
  5940. return false;
  5941.  
  5942. if (m_bUnderRefine)
  5943. return false;
  5944.  
  5945. if (IsWarping())
  5946. return false;
  5947.  
  5948. return true;
  5949. }
  5950.  
  5951. bool CHARACTER::UnEquipSpecialRideUniqueItem()
  5952. {
  5953. LPITEM Unique1 = GetWear(WEAR_UNIQUE1);
  5954. LPITEM Unique2 = GetWear(WEAR_UNIQUE2);
  5955. LPITEM Unique3 = GetWear(WEAR_COSTUME_MOUNT);
  5956.  
  5957. if (NULL != Unique1)
  5958. {
  5959. if (UNIQUE_GROUP_SPECIAL_RIDE == Unique1->GetSpecialGroup())
  5960. {
  5961. return UnequipItem(Unique1);
  5962. }
  5963. }
  5964.  
  5965. if (NULL != Unique2)
  5966. {
  5967. if (UNIQUE_GROUP_SPECIAL_RIDE == Unique2->GetSpecialGroup())
  5968. {
  5969. return UnequipItem(Unique2);
  5970. }
  5971. }
  5972.  
  5973. if (NULL != Unique3)
  5974. {
  5975. if (UNIQUE_GROUP_SPECIAL_RIDE == Unique3->GetSpecialGroup())
  5976. {
  5977. return UnequipItem(Unique3);
  5978. }
  5979. }
  5980.  
  5981. return true;
  5982. }
  5983.  
  5984. void CHARACTER::AutoRecoveryItemProcess(const EAffectTypes type) {
  5985. if (true == IsDead() || true == IsStun())
  5986. return;
  5987.  
  5988. if (false == IsPC())
  5989. return;
  5990.  
  5991. if (AFFECT_AUTO_HP_RECOVERY != type && AFFECT_AUTO_SP_RECOVERY != type)
  5992. return;
  5993.  
  5994. if (NULL != FindAffect(AFFECT_STUN))
  5995. return;
  5996.  
  5997. {
  5998. const DWORD stunSkills[] = { SKILL_TANHWAN, SKILL_GEOMPUNG, SKILL_BYEURAK, SKILL_GIGUNG };
  5999.  
  6000. for (size_t i=0 ; i < sizeof(stunSkills)/sizeof(DWORD) ; ++i) {
  6001. const CAffect* p = FindAffect(stunSkills[i]);
  6002.  
  6003. if (NULL != p && AFF_STUN == p->dwFlag)
  6004. return;
  6005. }
  6006. }
  6007.  
  6008. const CAffect* pAffect = FindAffect(type);
  6009. const size_t idx_of_amount_of_used = 1;
  6010. const size_t idx_of_amount_of_full = 2;
  6011.  
  6012. if (NULL != pAffect) {
  6013. LPITEM pItem = FindItemByID(pAffect->dwFlag);
  6014.  
  6015. if (NULL != pItem && true == pItem->GetSocket(0)) {
  6016. if (false == CArenaManager::instance().IsArenaMap(GetMapIndex())) {
  6017. const long amount_of_used = pItem->GetSocket(idx_of_amount_of_used);
  6018. const long amount_of_full = pItem->GetSocket(idx_of_amount_of_full);
  6019.  
  6020. const int32_t avail = amount_of_full - amount_of_used;
  6021.  
  6022. int32_t amount = 0;
  6023.  
  6024. if (AFFECT_AUTO_HP_RECOVERY == type) {
  6025. amount = GetMaxHP() - (GetHP() + GetPoint(POINT_HP_RECOVERY));
  6026. } else if (AFFECT_AUTO_SP_RECOVERY == type) {
  6027. amount = GetMaxSP() - (GetSP() + GetPoint(POINT_SP_RECOVERY));
  6028. }
  6029.  
  6030. if (amount > 0) {
  6031. if (avail > amount) {
  6032. const int pct_of_used = amount_of_used * 100 / amount_of_full;
  6033. const int pct_of_will_used = (amount_of_used + amount) * 100 / amount_of_full;
  6034.  
  6035. bool bLog = false;
  6036. if ((pct_of_will_used / 10) - (pct_of_used / 10) >= 1)
  6037. bLog = true;
  6038. pItem->SetSocket(idx_of_amount_of_used, amount_of_used + amount, bLog);
  6039. } else {
  6040. amount = avail;
  6041.  
  6042. ITEM_MANAGER::instance().RemoveItem( pItem );
  6043. }
  6044.  
  6045. if (AFFECT_AUTO_HP_RECOVERY == type) {
  6046. PointChange( POINT_HP_RECOVERY, amount );
  6047. EffectPacket( SE_AUTO_HPUP );
  6048. } else if (AFFECT_AUTO_SP_RECOVERY == type) {
  6049. PointChange( POINT_SP_RECOVERY, amount );
  6050. EffectPacket( SE_AUTO_SPUP );
  6051. }
  6052. }
  6053. } else {
  6054. pItem->Lock(false);
  6055. pItem->SetSocket(0, false);
  6056. RemoveAffect( const_cast<CAffect*>(pAffect) );
  6057. }
  6058. } else {
  6059. RemoveAffect( const_cast<CAffect*>(pAffect) );
  6060. }
  6061. }
  6062. }
  6063.  
  6064. bool CHARACTER::IsValidItemPosition(TItemPos Pos) const {
  6065. BYTE window_type = Pos.window_type;
  6066. WORD cell = Pos.cell;
  6067.  
  6068. switch (window_type) {
  6069. case RESERVED_WINDOW:
  6070. return false;
  6071.  
  6072. case INVENTORY:
  6073. case EQUIPMENT:
  6074. return cell < (INVENTORY_AND_EQUIP_SLOT_MAX);
  6075.  
  6076. case DRAGON_SOUL_INVENTORY:
  6077. return cell < (DRAGON_SOUL_INVENTORY_MAX_NUM);
  6078.  
  6079. case SAFEBOX:
  6080. if (NULL != m_pkSafebox)
  6081. return m_pkSafebox->IsValidPosition(cell);
  6082. else
  6083. return false;
  6084.  
  6085. case MALL:
  6086. if (NULL != m_pkMall)
  6087. return m_pkMall->IsValidPosition(cell);
  6088. else
  6089. return false;
  6090. default:
  6091. return false;
  6092. }
  6093. }
  6094.  
  6095.  
  6096. #define VERIFY_MSG(exp, msg) \
  6097. if (true == (exp)) { \
  6098. ChatPacket(CHAT_TYPE_INFO, LC_TEXT(msg)); \
  6099. return false; \
  6100. }
  6101.  
  6102. bool CHARACTER::CanEquipNow(const LPITEM item, const TItemPos& srcCell, const TItemPos& destCell) {
  6103. const TItemTable* itemTable = item->GetProto();
  6104. BYTE itemType = item->GetType();
  6105. BYTE itemSubType = item->GetSubType();
  6106.  
  6107. switch (GetJob()) {
  6108. case JOB_WARRIOR:
  6109. if (item->GetAntiFlag() & ITEM_ANTIFLAG_WARRIOR)
  6110. return false;
  6111. break;
  6112.  
  6113. case JOB_ASSASSIN:
  6114. if (item->GetAntiFlag() & ITEM_ANTIFLAG_ASSASSIN)
  6115. return false;
  6116. break;
  6117.  
  6118. case JOB_SHAMAN:
  6119. if (item->GetAntiFlag() & ITEM_ANTIFLAG_SHAMAN)
  6120. return false;
  6121. break;
  6122.  
  6123. case JOB_SURA:
  6124. if (item->GetAntiFlag() & ITEM_ANTIFLAG_SURA)
  6125. return false;
  6126. break;
  6127. }
  6128.  
  6129. for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i) {
  6130. long limit = itemTable->aLimits[i].lValue;
  6131. switch (itemTable->aLimits[i].bType) {
  6132. case LIMIT_LEVEL:
  6133. if (GetLevel() < limit) {
  6134. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("·¹º§ÀÌ ³·¾Æ Âø¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  6135. return false;
  6136. }
  6137. break;
  6138.  
  6139. case LIMIT_STR:
  6140. if (GetPoint(POINT_ST) < limit) {
  6141. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("±Ù·ÂÀÌ ³·¾Æ Âø¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  6142. return false;
  6143. }
  6144. break;
  6145.  
  6146. case LIMIT_INT:
  6147. if (GetPoint(POINT_IQ) < limit) {
  6148. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Áö´ÉÀÌ ³·¾Æ Âø¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  6149. return false;
  6150. }
  6151. break;
  6152.  
  6153. case LIMIT_DEX:
  6154. if (GetPoint(POINT_DX) < limit) {
  6155. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("¹ÎøÀÌ ³·¾Æ Âø¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  6156. return false;
  6157. }
  6158. break;
  6159.  
  6160. case LIMIT_CON:
  6161. if (GetPoint(POINT_HT) < limit) {
  6162. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ü·ÂÀÌ ³·¾Æ Âø¿ëÇÒ ¼ö ¾ø½À´Ï´Ù."));
  6163. return false;
  6164. }
  6165. break;
  6166. }
  6167. }
  6168.  
  6169. if (item->GetWearFlag() & WEARABLE_UNIQUE)
  6170. {
  6171. if ((GetWear(WEAR_UNIQUE1) && GetWear(WEAR_UNIQUE1)->IsSameSpecialGroup(item)) ||
  6172. (GetWear(WEAR_UNIQUE2) && GetWear(WEAR_UNIQUE2)->IsSameSpecialGroup(item)) ||
  6173. (GetWear(WEAR_COSTUME_MOUNT) && GetWear(WEAR_COSTUME_MOUNT)->IsSameSpecialGroup(item)))
  6174. {
  6175. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Voce nao pode anexar os mesmos dois tipos de itens exclusivos ao mesmo tempo."));
  6176. return false;
  6177. }
  6178.  
  6179. if (marriage::CManager::instance().IsMarriageUniqueItem(item->GetVnum()) &&
  6180. !marriage::CManager::instance().IsMarried(GetPlayerID()))
  6181. {
  6182. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Voce nao pode usar o seu dom no estado solteira."));
  6183. return false;
  6184. }
  6185.  
  6186. }
  6187.  
  6188. #ifdef __WEAPON_COSTUME_SYSTEM__
  6189. #ifdef __NEW_ARROW_SYSTEM__
  6190. if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_ARROW && item->GetSubType() != WEAPON_UNLIMITED_ARROW)
  6191. #else
  6192. if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_ARROW)
  6193. #endif
  6194. {
  6195. LPITEM pkItem = GetWear(WEAR_COSTUME_WEAPON);
  6196. if (pkItem)
  6197. {
  6198. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("For can do this unwear the costume weapon."));
  6199. return false;
  6200. }
  6201. }
  6202. else if (item->GetType() == ITEM_COSTUME && item->GetSubType() == COSTUME_WEAPON)
  6203. {
  6204. LPITEM pkItem = GetWear(WEAR_WEAPON);
  6205. if (!pkItem)
  6206. {
  6207. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't wear a costume weapon without have a weapon weared."));
  6208. return false;
  6209. }
  6210. else if (item->GetValue(3) != pkItem->GetSubType())
  6211. {
  6212. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You can't wear a costume weapon who has different type of your weapon."));
  6213. return false;
  6214. }
  6215. }
  6216.  
  6217. if (item->GetType() == ITEM_ROD || item->GetType() == ITEM_PICK)
  6218. {
  6219. LPITEM pkItem = GetWear(WEAR_COSTUME_WEAPON);
  6220. if (pkItem)
  6221. {
  6222. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("For can do this unwear the costume weapon."));
  6223. return false;
  6224. }
  6225. }
  6226. #endif
  6227.  
  6228. return true;
  6229. }
  6230.  
  6231. bool CHARACTER::CanUnequipNow(const LPITEM item, const TItemPos& srcCell, const TItemPos& destCell)
  6232. {
  6233. if (ITEM_BELT == item->GetType())
  6234. VERIFY_MSG(CBeltInventoryHelper::IsExistItemInBeltInventory(this), "?? ????? ???? ???? ??? ? ????.");
  6235.  
  6236. // ??? ??? ? ?? ???
  6237. if (IS_SET(item->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  6238. return false;
  6239.  
  6240. // ??? unequip? ????? ?? ? ? ??? ?? ? ??
  6241. {
  6242. int pos = -1;
  6243. if (item->IsDragonSoul())
  6244. pos = GetEmptyDragonSoulInventory(item);
  6245. else
  6246. pos = GetEmptyInventory(item->GetSize());
  6247.  
  6248. VERIFY_MSG( -1 == pos, "???? ? ??? ????." );
  6249. }
  6250.  
  6251. #ifdef __WEAPON_COSTUME_SYSTEM__
  6252. #ifdef __NEW_ARROW_SYSTEM__
  6253. if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_ARROW && item->GetSubType() != WEAPON_UNLIMITED_ARROW)
  6254. #else
  6255. if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_ARROW)
  6256. #endif
  6257. {
  6258. LPITEM pkItem = GetWear(WEAR_COSTUME_WEAPON);
  6259. if (pkItem)
  6260. {
  6261. ChatPacket(CHAT_TYPE_INFO, LC_TEXT("For can do this unwear the costume weapon."));
  6262. return false;
  6263. }
  6264. }
  6265. #endif
  6266.  
  6267. return true;
  6268. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!