API tools faq
paste
Guest User

Untitled

a guest
May 9th, 2025
93
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 277.17 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2.  
  3. #include <stack>
  4.  
  5. #include "utils.h"
  6. #include "config.h"
  7. #include "char.h"
  8. #include "char_manager.h"
  9. #include "item_manager.h"
  10. #include "desc.h"
  11. #include "desc_client.h"
  12. #include "desc_manager.h"
  13. #include "packet.h"
  14. #include "affect.h"
  15. #include "skill.h"
  16. #include "start_position.h"
  17. #include "mob_manager.h"
  18. #include "db.h"
  19. #include "log.h"
  20. #include "vector.h"
  21. #include "buffer_manager.h"
  22. #include "questmanager.h"
  23. #include "fishing.h"
  24. #include "party.h"
  25. #include "dungeon.h"
  26. #include "refine.h"
  27. #include "unique_item.h"
  28. #include "war_map.h"
  29. #include "xmas_event.h"
  30. #include "marriage.h"
  31. #include "monarch.h"
  32. #include "polymorph.h"
  33. #include "blend_item.h"
  34. #include "castle.h"
  35. #include "BattleArena.h"
  36. #include "arena.h"
  37. #include "pcbang.h"
  38. #include "threeway_war.h"
  39. #include "PulseManager.h"
  40. #include "safebox.h"
  41. #include "shop.h"
  42.  
  43. #ifdef ENABLE_NEWSTUFF
  44. #include "pvp.h"
  45. #endif
  46. #include "../../common/VnumHelper.h"
  47. #include "DragonSoul.h"
  48. #include "buff_on_attributes.h"
  49. #include "belt_inventory_helper.h"
  50. #include "../../common/CommonDefines.h"
  51.  
  52. #if defined(__BL_OFFICIAL_LOOT_FILTER__)
  53. #include "loot_filter.h"
  54. #endif
  55. #ifdef ENABLE_SWITCHBOT_WORLDARD
  56. #include "switchbonus.h"
  57. #endif
  58.  
  59. #ifdef ENABLE_AFFECT_ITEMS_PLUS
  60. static const int IGNORED_AFF_ITEMS[] = {71101,71016,71001,71094}; //Insert item vnums here for ignoring.
  61. #endif
  62.  
  63. #define ENABLE_EFFECT_EXTRAPOT
  64. #define ENABLE_BOOKS_STACKFIX
  65.  
  66. enum {ITEM_BROKEN_METIN_VNUM = 28960};
  67. extern int stone_chance; // Chance Stone Chance
  68.  
  69. // CHANGE_ITEM_ATTRIBUTES
  70. // const DWORD CHARACTER::msc_dwDefaultChangeItemAttrCycle = 10;
  71. const char CHARACTER::msc_szLastChangeItemAttrFlag[] = "Item.LastChangeItemAttr";
  72. // const char CHARACTER::msc_szChangeItemAttrCycleFlag[] = "change_itemattr_cycle";
  73. // END_OF_CHANGE_ITEM_ATTRIBUTES
  74. const BYTE g_aBuffOnAttrPoints[] = { POINT_ENERGY, POINT_COSTUME_ATTR_BONUS };
  75.  
  76. struct FFindStone
  77. {
  78.     std::map<DWORD, LPCHARACTER> m_mapStone;
  79.  
  80.     void operator()(LPENTITY pEnt)
  81.     {
  82.         if (pEnt->IsType(ENTITY_CHARACTER) == true)
  83.         {
  84.             LPCHARACTER pChar = (LPCHARACTER)pEnt;
  85.  
  86.             if (pChar->IsStone() == true)
  87.             {
  88.                 m_mapStone[(DWORD)pChar->GetVID()] = pChar;
  89.             }
  90.         }
  91.     }
  92. };
  93.  
  94.  
  95.  
  96. static bool IS_SUMMON_ITEM(int vnum)
  97. {
  98.     switch (vnum)
  99.     {
  100.         case 22000:
  101.         case 22010:
  102.         case 22011:
  103.         case 22020:
  104.         case ITEM_MARRIAGE_RING:
  105.             return true;
  106.     }
  107.  
  108.     return false;
  109. }
  110.  
  111. static bool IS_MONKEY_DUNGEON(int map_index)
  112. {
  113.     switch (map_index)
  114.     {
  115.         case 5:
  116.         case 25:
  117.         case 45:
  118.         case 108:
  119.         case 109:
  120.             return true;;
  121.     }
  122.  
  123.     return false;
  124. }
  125.  
  126. bool IS_SUMMONABLE_ZONE(int map_index)
  127. {
  128.     if (IS_MONKEY_DUNGEON(map_index))
  129.         return false;
  130.     // 성
  131.     if (IS_CASTLE_MAP(map_index))
  132.         return false;
  133.  
  134.     switch (map_index)
  135.     {
  136.         case 66 :
  137.         // case 71 :    // araxnes 2os
  138.         // case 72 :    // eksoria_01
  139.         // case 73 :    // eksoria_02
  140.         case 193 :
  141. #if 0
  142.         case 184 :
  143.         case 185 :
  144.         case 186 :
  145.         case 187 :
  146.         case 188 :
  147.         case 189 :
  148. #endif
  149.  
  150.         // case 216 :   // asca
  151.         // case 217 :   // spiderdungeon_03
  152.         // case 208 :   // dwmatio drakou
  153.  
  154.         case 113 : // OX Event 맵
  155.             return false;
  156.     }
  157.  
  158.     if (CBattleArena::IsBattleArenaMap(map_index)) return false;
  159.  
  160.     if (map_index > 10000) return false;
  161.  
  162.     return true;
  163. }
  164.  
  165. bool IS_BOTARYABLE_ZONE(int nMapIndex)
  166. {
  167.     if (!g_bEnableBootaryCheck) return true;
  168.  
  169.     switch (nMapIndex)
  170.     {
  171.         case 1 :
  172.         case 3 :
  173.         case 21 :
  174.         case 23 :
  175.         case 41 :
  176.         case 43 :
  177.             return true;
  178.     }
  179.  
  180.     return false;
  181. }
  182.  
  183.  
  184. static bool FN_check_item_socket(LPITEM item)
  185. {
  186.     for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  187.     {
  188.         if (item->GetSocket(i) != item->GetProto()->alSockets[i])
  189.             return false;
  190.     }
  191.  
  192.     return true;
  193. }
  194.  
  195. // item socket 복사 -- by mhh
  196. static void FN_copy_item_socket(LPITEM dest, LPITEM src)
  197. {
  198.     for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  199.     {
  200.         dest->SetSocket(i, src->GetSocket(i));
  201.     }
  202. }
  203. static bool FN_check_item_sex(LPCHARACTER ch, LPITEM item)
  204. {
  205.    
  206.     if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_MALE))
  207.     {
  208.         if (SEX_MALE==GET_SEX(ch))
  209.             return false;
  210.     }
  211.    
  212.     if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_FEMALE))
  213.     {
  214.         if (SEX_FEMALE==GET_SEX(ch))
  215.             return false;
  216.     }
  217.  
  218.     return true;
  219. }
  220.  
  221.  
  222. /////////////////////////////////////////////////////////////////////////////
  223. // ITEM HANDLING
  224. /////////////////////////////////////////////////////////////////////////////
  225. bool CHARACTER::CanHandleItem(bool bSkipCheckRefine, bool bSkipObserver)
  226. {
  227.     if (!bSkipObserver)
  228.         if (m_bIsObserver)
  229.             return false;
  230.  
  231.     if (GetMyShop())
  232.         return false;
  233.  
  234.     if (!bSkipCheckRefine)
  235.         if (m_bUnderRefine)
  236.             return false;
  237.  
  238.     if (IsCubeOpen() || NULL != DragonSoul_RefineWindow_GetOpener())
  239.         return false;
  240.  
  241. #if defined(__BL_MAILBOX__)
  242.     if (GetMailBox())
  243.         return false;
  244. #endif
  245.  
  246. #if defined(__BL_TRANSMUTATION__)
  247.     if (GetTransmutation())
  248.         return false;
  249. #endif
  250.  
  251.     if (IsWarping())
  252.         return false;
  253.    
  254. #ifdef ENABLE_ACCE_SYSTEM
  255.     if ((m_bAcceCombination) || (m_bAcceAbsorption))
  256.         return false;
  257. #endif
  258.     return true;
  259. }
  260.  
  261. #ifdef ENABLE_SWITCHBOT_WORLDARD
  262. LPITEM CHARACTER::GetSwitchBotItem(WORD wCell) const
  263. {
  264.     return GetItem(TItemPos(SWITCHBOT, wCell));
  265. }
  266. #endif
  267.  
  268. LPITEM CHARACTER::GetInventoryItem(WORD wCell) const
  269. {
  270.     return GetItem(TItemPos(INVENTORY, wCell));
  271. }
  272.  
  273. LPITEM CHARACTER::GetItem(TItemPos Cell) const
  274. {
  275.     if (!m_PlayerSlots)
  276.         return nullptr;
  277.  
  278.     if (!IsValidItemPosition(Cell))
  279.         return NULL;
  280.     WORD wCell = Cell.cell;
  281.     BYTE window_type = Cell.window_type;
  282.     switch (window_type)
  283.     {
  284.     case INVENTORY:
  285.     case EQUIPMENT:
  286.         if (wCell >= INVENTORY_AND_EQUIP_SLOT_MAX)
  287.         {
  288.             sys_err("CHARACTER::GetInventoryItem: invalid item cell %d", wCell);
  289.             return NULL;
  290.         }
  291.         return m_PlayerSlots->pItems[wCell];
  292.     case DRAGON_SOUL_INVENTORY:
  293.         if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  294.         {
  295.             sys_err("CHARACTER::GetInventoryItem: invalid DS item cell %d", wCell);
  296.             return NULL;
  297.         }
  298.         return m_PlayerSlots->pDSItems[wCell];
  299. #ifdef ENABLE_SWITCHBOT_WORLDARD
  300.     case SWITCHBOT:
  301.         if (wCell >= SWITCHBOT_SLOT_MAX)
  302.         {
  303.             sys_err("CHARACTER::GetInventoryItem: invalid SWITCHBOT item cell %d", wCell);
  304.             return NULL;
  305.         }
  306.         return m_PlayerSlots->pSBItems[wCell];     
  307. #endif
  308.  
  309.     default:
  310.         return NULL;
  311.     }
  312.     return NULL;
  313. }
  314.  
  315. #ifdef __SWAP_ITEM_SYSTEM__
  316. LPITEM CHARACTER::GetItem_NEW(const TItemPos& Cell) const
  317. {
  318.     LPITEM cellItem = GetItem(Cell);
  319.     if (cellItem)
  320.         return cellItem;
  321.  
  322.     //There's no item in this cell, but that does not mean there is not an item which currently uses up this cell.
  323.     WORD bCell = Cell.cell;
  324.     BYTE bPage = bCell / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT);
  325.  
  326.     for (int j = -2; j < 0; ++j)
  327.     {
  328.         BYTE p = bCell + (5 * j);
  329.  
  330.         if (p / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT) != bPage)
  331.             continue;
  332.  
  333.         if (p >= INVENTORY_MAX_NUM) //Eeh just for the sake of...
  334.             continue;
  335.  
  336.         LPITEM curCellItem = GetItem(TItemPos(INVENTORY, p));
  337.         if (!curCellItem)
  338.             continue;
  339.  
  340.         if (p + (curCellItem->GetSize() - 1) * 5 < Cell.cell) //Doesn't reach Cell.cell
  341.             continue;
  342.  
  343.         return curCellItem;
  344.     }
  345.  
  346.     return NULL;
  347. }
  348. #endif
  349.  
  350. #if defined(__BL_ENABLE_PICKUP_ITEM_EFFECT__)
  351. void CHARACTER::SetItem(TItemPos Cell, LPITEM pItem, bool bHighlight)
  352. #else
  353. void CHARACTER::SetItem(TItemPos Cell, LPITEM pItem)
  354. #endif
  355. {
  356.     if (!m_PlayerSlots)
  357.         return;
  358.  
  359.     WORD wCell = Cell.cell;
  360.     BYTE window_type = Cell.window_type;
  361.     if ((unsigned long)((CItem*)pItem) == 0xff || (unsigned long)((CItem*)pItem) == 0xffffffff)
  362.     {
  363.         sys_err("!!! FATAL ERROR !!! item == 0xff (char: %s cell: %u)", GetName(), wCell);
  364.         core_dump();
  365.         return;
  366.     }
  367.  
  368.     if (pItem && pItem->GetOwner())
  369.     {
  370.         assert(!"GetOwner exist");
  371.         return;
  372.     }
  373.    
  374.     switch(window_type)
  375.     {
  376.     case INVENTORY:
  377.     case EQUIPMENT:
  378.         {
  379.             if (wCell >= INVENTORY_AND_EQUIP_SLOT_MAX)
  380.             {
  381.                 sys_err("CHARACTER::SetItem: invalid item cell %d", wCell);
  382.                 return;
  383.             }
  384.  
  385.             LPITEM pOld = m_PlayerSlots->pItems[wCell];
  386.  
  387.             if (pOld)
  388.             {
  389.                 if (wCell < INVENTORY_MAX_NUM)
  390.                 {
  391.                     for (int i = 0; i < pOld->GetSize(); ++i)
  392.                     {
  393.                         int p = wCell + (i * 5);
  394.  
  395.                         if (p >= INVENTORY_MAX_NUM)
  396.                             continue;
  397.  
  398.                         if (m_PlayerSlots->pItems[p] && m_PlayerSlots->pItems[p] != pOld)
  399.                             continue;
  400.  
  401.                         m_PlayerSlots->bItemGrid[p] = 0;
  402.                     }
  403.                 }
  404.                 else
  405.                     m_PlayerSlots->bItemGrid[wCell] = 0;
  406.             }
  407.  
  408.             if (pItem)
  409.             {
  410.                 if (wCell < INVENTORY_MAX_NUM)
  411.                 {
  412.                     for (int i = 0; i < pItem->GetSize(); ++i)
  413.                     {
  414.                         int p = wCell + (i * 5);
  415.  
  416.                         if (p >= INVENTORY_MAX_NUM)
  417.                             continue;
  418.  
  419.                         // wCell + 1 로 하는 것은 빈곳을 체크할 때 같은
  420.                         // 아이템은 예외처리하기 위함
  421.                         m_PlayerSlots->bItemGrid[p] = wCell + 1;
  422.                     }
  423.                 }
  424.                 else
  425.                     m_PlayerSlots->bItemGrid[wCell] = wCell + 1;
  426.             }
  427.  
  428.             m_PlayerSlots->pItems[wCell] = pItem;
  429.         }
  430.         break;
  431.    
  432.     case DRAGON_SOUL_INVENTORY:
  433.         {
  434.             LPITEM pOld = m_PlayerSlots->pDSItems[wCell];
  435.  
  436.             if (pOld)
  437.             {
  438.                 if (wCell < DRAGON_SOUL_INVENTORY_MAX_NUM)
  439.                 {
  440.                     for (int i = 0; i < pOld->GetSize(); ++i)
  441.                     {
  442.                         int p = wCell + (i * DRAGON_SOUL_BOX_COLUMN_NUM);
  443.  
  444.                         if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  445.                             continue;
  446.  
  447.                         if (m_PlayerSlots->pDSItems[p] && m_PlayerSlots->pDSItems[p] != pOld)
  448.                             continue;
  449.  
  450.                         m_PlayerSlots->wDSItemGrid[p] = 0;
  451.                     }
  452.                 }
  453.                 else
  454.                     m_PlayerSlots->wDSItemGrid[wCell] = 0;
  455.             }
  456.  
  457.             if (pItem)
  458.             {
  459.                 if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  460.                 {
  461.                     sys_err("CHARACTER::SetItem: invalid DS item cell %d", wCell);
  462.                     return;
  463.                 }
  464.  
  465.                 if (wCell < DRAGON_SOUL_INVENTORY_MAX_NUM)
  466.                 {
  467.                     for (int i = 0; i < pItem->GetSize(); ++i)
  468.                     {
  469.                         int p = wCell + (i * DRAGON_SOUL_BOX_COLUMN_NUM);
  470.  
  471.                         if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  472.                             continue;
  473.                        
  474.                         m_PlayerSlots->wDSItemGrid[p] = wCell + 1;
  475.                     }
  476.                 }
  477.                 else
  478.                     m_PlayerSlots->wDSItemGrid[wCell] = wCell + 1;
  479.             }
  480.  
  481.             m_PlayerSlots->pDSItems[wCell] = pItem;
  482.         }
  483.         break;
  484.  
  485. #ifdef ENABLE_SWITCHBOT_WORLDARD
  486.     case SWITCHBOT:
  487.         {
  488.             if (wCell >= SWITCHBOT_SLOT_MAX)
  489.             {
  490.                 sys_err("CHARACTER::SetItem: invalid SWITCHBOT item cell %d", wCell);
  491.                 return;
  492.             }
  493.             LPITEM pOld = m_PlayerSlots->pSBItems[wCell];
  494.  
  495.             if (pOld && pItem)
  496.             {
  497.                 return;
  498.             }
  499.  
  500.             if(pItem)
  501.             {
  502.                 CSwitchBonus::Instance().SendSBItem(this,pItem);
  503.             }else{
  504.                 CSwitchBonus::Instance().ClearSB(this);
  505.             }
  506.  
  507.  
  508.             m_PlayerSlots->pSBItems[wCell] = pItem;
  509.  
  510.         }
  511.         break; 
  512. #endif
  513.  
  514.     default:
  515.         sys_err ("Invalid Inventory type %d", window_type);
  516.         return;
  517.     }
  518.  
  519.     if (GetDesc())
  520.     {
  521.        
  522.         if (pItem)
  523.         {
  524.             TPacketGCItemSet pack;
  525.             pack.header = HEADER_GC_ITEM_SET;
  526.             pack.Cell = Cell;
  527.  
  528.             pack.count = pItem->GetCount();
  529.             pack.vnum = pItem->GetVnum();
  530.             pack.flags = pItem->GetFlag();
  531.             pack.anti_flags = pItem->GetAntiFlag();
  532. #if defined(__BL_ENABLE_PICKUP_ITEM_EFFECT__)
  533.             pack.highlight = bHighlight;
  534. #else
  535.             pack.highlight = (Cell.window_type == DRAGON_SOUL_INVENTORY);
  536. #endif
  537.  
  538.             thecore_memcpy(pack.alSockets, pItem->GetSockets(), sizeof(pack.alSockets));
  539.             thecore_memcpy(pack.aAttr, pItem->GetAttributes(), sizeof(pack.aAttr));
  540. #if defined(__BL_TRANSMUTATION__)
  541.             pack.dwTransmutationVnum = pItem->GetTransmutationVnum();
  542. #endif
  543.  
  544.             GetDesc()->Packet(&pack, sizeof(TPacketGCItemSet));
  545.         }
  546.         else
  547.         {
  548.             TPacketGCItemDelDeprecated pack;
  549.             pack.header = HEADER_GC_ITEM_DEL;
  550.             pack.Cell = Cell;
  551.             pack.count = 0;
  552.             pack.vnum = 0;
  553.             memset(pack.alSockets, 0, sizeof(pack.alSockets));
  554.             memset(pack.aAttr, 0, sizeof(pack.aAttr));
  555. #if defined(__BL_TRANSMUTATION__)
  556.             pack.dwTransmutationVnum = 0;
  557. #endif
  558.  
  559.             GetDesc()->Packet(&pack, sizeof(TPacketGCItemDelDeprecated));
  560.         }
  561.     }
  562.  
  563.     if (pItem)
  564.     {
  565.         pItem->SetCell(this, wCell);
  566.         switch (window_type)
  567.         {
  568.         case INVENTORY:
  569.         case EQUIPMENT:
  570.             if ((wCell < INVENTORY_MAX_NUM) || (BELT_INVENTORY_SLOT_START <= wCell && BELT_INVENTORY_SLOT_END > wCell))
  571.                 pItem->SetWindow(INVENTORY);
  572.             else
  573.                 pItem->SetWindow(EQUIPMENT);
  574.             break;
  575.         case DRAGON_SOUL_INVENTORY:
  576.             pItem->SetWindow(DRAGON_SOUL_INVENTORY);
  577.             break;
  578. #ifdef ENABLE_SWITCHBOT_WORLDARD
  579.         case SWITCHBOT:
  580.             pItem->SetWindow(SWITCHBOT);
  581.             break;
  582. #endif
  583.         }
  584.     }
  585.  
  586. #ifdef ENABLE_ITEM_SAFE_FLUSH
  587.     if (pItem && m_PlayerSlots)
  588.         m_PlayerSlots->setTouchedItems.emplace(pItem->GetID());
  589. #endif
  590. }
  591.  
  592. LPITEM CHARACTER::GetWear(BYTE bCell) const
  593. {
  594.     if (!m_PlayerSlots)
  595.         return nullptr;
  596.  
  597.     if (bCell >= WEAR_MAX_NUM + DRAGON_SOUL_DECK_MAX_NUM * DS_SLOT_MAX)
  598.     {
  599.         sys_err("CHARACTER::GetWear: invalid wear cell %d", bCell);
  600.         return NULL;
  601.     }
  602.  
  603.     return m_PlayerSlots->pItems[INVENTORY_MAX_NUM + bCell];
  604. }
  605.  
  606. void CHARACTER::SetWear(BYTE bCell, LPITEM item)
  607. {
  608.    
  609.     if (bCell >= WEAR_MAX_NUM + DRAGON_SOUL_DECK_MAX_NUM * DS_SLOT_MAX)
  610.     {
  611.         sys_err("CHARACTER::SetItem: invalid item cell %d", bCell);
  612.         return;
  613.     }
  614.  
  615. #if defined(__BL_ENABLE_PICKUP_ITEM_EFFECT__)
  616.     SetItem(TItemPos(INVENTORY, INVENTORY_MAX_NUM + bCell), item, false);
  617. #else
  618.     SetItem(TItemPos (INVENTORY, INVENTORY_MAX_NUM + bCell), item);
  619. #endif
  620.  
  621. /*
  622.     if (!item && bCell == WEAR_WEAPON)
  623.     {
  624.         if (IsAffectFlag(AFF_GWIGUM))
  625.             RemoveAffect(SKILL_GWIGEOM);
  626.  
  627.         if (IsAffectFlag(AFF_GEOMGYEONG))
  628.             RemoveAffect(SKILL_GEOMKYUNG);
  629.     }
  630. */
  631.  
  632. #ifdef ENABLE_MOUNT_LIKE_HORSE
  633.     if (item)
  634.         CalcMountBonusBySeal(item);
  635. #endif
  636. }
  637.  
  638. void CHARACTER::ClearItem()
  639. {
  640.     int     i;
  641.     LPITEM  item;
  642.  
  643.     for (i = 0; i < INVENTORY_AND_EQUIP_SLOT_MAX; ++i)
  644.     {
  645.         if ((item = GetInventoryItem(i)))
  646.         {
  647.             item->SetSkipSave(true);
  648.             ITEM_MANAGER::instance().FlushDelayedSave(item);
  649.  
  650.             item->RemoveFromCharacter();
  651.             M2_DESTROY_ITEM(item);
  652.  
  653.             SyncQuickslot(QUICKSLOT_TYPE_ITEM, i, 255);
  654.         }
  655.     }
  656.     for (i = 0; i < DRAGON_SOUL_INVENTORY_MAX_NUM; ++i)
  657.     {
  658.         if ((item = GetItem(TItemPos(DRAGON_SOUL_INVENTORY, i))))
  659.         {
  660.             item->SetSkipSave(true);
  661.             ITEM_MANAGER::instance().FlushDelayedSave(item);
  662.  
  663.             item->RemoveFromCharacter();
  664.             M2_DESTROY_ITEM(item);
  665.         }
  666.     }
  667. #ifdef ENABLE_SWITCHBOT_WORLDARD
  668.     for (i = 0; i < SWITCHBOT_SLOT_MAX; ++i)
  669.     {
  670.         if ((item = GetItem(TItemPos(SWITCHBOT, i))))
  671.         {
  672.             item->SetSkipSave(true);
  673.             ITEM_MANAGER::instance().FlushDelayedSave(item);
  674.  
  675.             item->RemoveFromCharacter();
  676.             M2_DESTROY_ITEM(item);
  677.         }
  678.     }
  679. #endif
  680. }
  681.  
  682. bool CHARACTER::IsEmptyItemGrid(TItemPos Cell, BYTE bSize, int iExceptionCell) const
  683. {
  684.     if (!m_PlayerSlots)
  685.         return false;
  686.  
  687.     switch (Cell.window_type)
  688.     {
  689.         case INVENTORY:
  690.         {
  691.             UINT bCell = Cell.cell;
  692.  
  693.             // bItemCell은 0이 false임을 나타내기 위해 + 1 해서 처리한다.
  694.             // 따라서 iExceptionCell에 1을 더해 비교한다.
  695.             ++iExceptionCell;
  696.  
  697.             if (Cell.IsBeltInventoryPosition())
  698.             {
  699.                 LPITEM beltItem = GetWear(WEAR_BELT);
  700.  
  701.                 if (NULL == beltItem)
  702.                     return false;
  703.  
  704.                 if (false == CBeltInventoryHelper::IsAvailableCell(bCell - BELT_INVENTORY_SLOT_START, beltItem->GetValue(0)))
  705.                     return false;
  706.  
  707.                 if (m_PlayerSlots->bItemGrid[bCell])
  708.                 {
  709.                     if (m_PlayerSlots->bItemGrid[bCell] == iExceptionCell)
  710.                         return true;
  711.  
  712.                     return false;
  713.                 }
  714.  
  715.                 if (bSize == 1)
  716.                     return true;
  717.             }
  718.             else if (bCell >= INVENTORY_MAX_NUM)
  719.                 return false;
  720.  
  721.             if (m_PlayerSlots->bItemGrid[bCell])
  722.             {
  723.                 if (m_PlayerSlots->bItemGrid[bCell] == iExceptionCell)
  724.                 {
  725.                     if (bSize == 1)
  726.                         return true;
  727.  
  728.                     int j = 1;
  729.                     BYTE bPage = bCell / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT);
  730.  
  731.                     do
  732.                     {
  733.                         UINT p = bCell + (5 * j);
  734.  
  735.                         if (p >= INVENTORY_MAX_NUM)
  736.                             return false;
  737.  
  738.                         if (p / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT) != bPage)
  739.                             return false;
  740.  
  741.                         if (m_PlayerSlots->bItemGrid[p])
  742.                             if (m_PlayerSlots->bItemGrid[p] != iExceptionCell)
  743.                                 return false;
  744.                     } while (++j < bSize);
  745.  
  746.                     return true;
  747.                 }
  748.                 else
  749.                     return false;
  750.             }
  751.  
  752.             if (1 == bSize)
  753.                 return true;
  754.             else
  755.             {
  756.                 int j = 1;
  757.                 BYTE bPage = bCell / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT);
  758.  
  759.                 do
  760.                 {
  761.                     UINT p = bCell + (5 * j);
  762.  
  763.                     if (p >= INVENTORY_MAX_NUM)
  764.                         return false;
  765.  
  766.                     if (p / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT) != bPage)
  767.                         return false;
  768.  
  769.                     if (m_PlayerSlots->bItemGrid[p])
  770.                         if (m_PlayerSlots->bItemGrid[p] != iExceptionCell)
  771.                             return false;
  772.                 } while (++j < bSize);
  773.  
  774.                 return true;
  775.             }
  776.         }
  777.         break;
  778. #ifdef ENABLE_SWITCHBOT_WORLDARD
  779.     case SWITCHBOT:
  780.         {
  781.             WORD wCell = Cell.cell;
  782.             if (wCell >= SWITCHBOT_SLOT_MAX){
  783.                 return false;  
  784.             }
  785.  
  786.             if(m_PlayerSlots->pSBItems[wCell]){
  787.                 return false;
  788.             }
  789.  
  790.             return true;           
  791.         }
  792.         break;
  793. #endif
  794.     case DRAGON_SOUL_INVENTORY:
  795.         {
  796.             WORD wCell = Cell.cell;
  797.             if (wCell >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  798.                 return false;
  799.  
  800.             // bItemCell은 0이 false임을 나타내기 위해 + 1 해서 처리한다.
  801.             // 따라서 iExceptionCell에 1을 더해 비교한다.
  802.             iExceptionCell++;
  803.  
  804.             if (m_PlayerSlots->wDSItemGrid[wCell])
  805.             {
  806.                 if (m_PlayerSlots->wDSItemGrid[wCell] == iExceptionCell)
  807.                 {
  808.                     if (bSize == 1)
  809.                         return true;
  810.  
  811.                     int j = 1;
  812.  
  813.                     do
  814.                     {
  815.                         int p = wCell + (DRAGON_SOUL_BOX_COLUMN_NUM * j);
  816.  
  817.                         if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  818.                             return false;
  819.  
  820.                         if (m_PlayerSlots->wDSItemGrid[p])
  821.                             if (m_PlayerSlots->wDSItemGrid[p] != iExceptionCell)
  822.                                 return false;
  823.                     }
  824.                     while (++j < bSize);
  825.  
  826.                     return true;
  827.                 }
  828.                 else
  829.                     return false;
  830.             }
  831.  
  832.             // 크기가 1이면 한칸을 차지하는 것이므로 그냥 리턴
  833.             if (1 == bSize)
  834.                 return true;
  835.             else
  836.             {
  837.                 int j = 1;
  838.  
  839.                 do
  840.                 {
  841.                     int p = wCell + (DRAGON_SOUL_BOX_COLUMN_NUM * j);
  842.  
  843.                     if (p >= DRAGON_SOUL_INVENTORY_MAX_NUM)
  844.                         return false;
  845.  
  846.                     if (m_PlayerSlots->bItemGrid[p])
  847.                         if (m_PlayerSlots->wDSItemGrid[p] != iExceptionCell)
  848.                             return false;
  849.                 }
  850.                 while (++j < bSize);
  851.  
  852.                 return true;
  853.             }
  854.         }
  855.  
  856.     }
  857.     return false;
  858. }
  859.  
  860. int CHARACTER::GetEmptyInventory(BYTE size) const
  861. {
  862.     for ( int i = 0; i < INVENTORY_MAX_NUM; ++i)
  863.         if (IsEmptyItemGrid(TItemPos (INVENTORY, i), size))
  864.             return i;
  865.     return -1;
  866. }
  867.  
  868. int CHARACTER::GetEmptyDragonSoulInventory(LPITEM pItem) const
  869. {
  870.     if (NULL == pItem || !pItem->IsDragonSoul())
  871.         return -1;
  872.     if (!DragonSoul_IsQualified())
  873.     {
  874.         return -1;
  875.     }
  876.     BYTE bSize = pItem->GetSize();
  877.     WORD wBaseCell = DSManager::instance().GetBasePosition(pItem);
  878.  
  879.     if (WORD_MAX == wBaseCell)
  880.         return -1;
  881.  
  882.     for (int i = 0; i < DRAGON_SOUL_BOX_SIZE; ++i)
  883.         if (IsEmptyItemGrid(TItemPos(DRAGON_SOUL_INVENTORY, i + wBaseCell), bSize))
  884.             return i + wBaseCell;
  885.  
  886.     return -1;
  887. }
  888.  
  889. void CHARACTER::CopyDragonSoulItemGrid(std::vector<WORD>& vDragonSoulItemGrid) const
  890. {
  891.     vDragonSoulItemGrid.resize(DRAGON_SOUL_INVENTORY_MAX_NUM);
  892.  
  893.     std::copy(m_PlayerSlots->wDSItemGrid, m_PlayerSlots->wDSItemGrid + DRAGON_SOUL_INVENTORY_MAX_NUM, vDragonSoulItemGrid.begin());
  894. }
  895.  
  896. int CHARACTER::CountEmptyInventory() const
  897. {
  898.     int count = 0;
  899.  
  900.     for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  901.         if (GetInventoryItem(i))
  902.             count += GetInventoryItem(i)->GetSize();
  903.  
  904.     return (INVENTORY_MAX_NUM - count);
  905. }
  906.  
  907. void TransformRefineItem(LPITEM pkOldItem, LPITEM pkNewItem)
  908. {
  909.     // ACCESSORY_REFINE
  910.     if (pkOldItem->IsAccessoryForSocket())
  911.     {
  912.         for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  913.         {
  914.             pkNewItem->SetSocket(i, pkOldItem->GetSocket(i));
  915.         }
  916.         //pkNewItem->StartAccessorySocketExpireEvent();
  917.     }
  918.     // END_OF_ACCESSORY_REFINE
  919.     else
  920.     {
  921.        
  922.         for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  923.         {
  924.             if (!pkOldItem->GetSocket(i))
  925.                 break;
  926.             else
  927.                 pkNewItem->SetSocket(i, 1);
  928.         }
  929.  
  930.        
  931.         int slot = 0;
  932.  
  933.         for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  934.         {
  935.             long socket = pkOldItem->GetSocket(i);
  936.  
  937.             if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
  938.                 pkNewItem->SetSocket(slot++, socket);
  939.         }
  940.  
  941.     }
  942.  
  943.    
  944.     pkOldItem->CopyAttributeTo(pkNewItem);
  945. }
  946.  
  947. void NotifyRefineSuccess(LPCHARACTER ch, LPITEM item, const char* way)
  948. {
  949.     if (NULL != ch && item != NULL)
  950.     {
  951.         ch->ChatPacket(CHAT_TYPE_COMMAND, "RefineSuceeded");
  952.  
  953.         LogManager::instance().RefineLog(ch->GetPlayerID(), item->GetName(), item->GetID(), item->GetRefineLevel(), 1, way);
  954.     }
  955. }
  956.  
  957. void NotifyRefineFail(LPCHARACTER ch, LPITEM item, const char* way, int success = 0)
  958. {
  959.     if (NULL != ch && NULL != item)
  960.     {
  961.         ch->ChatPacket(CHAT_TYPE_COMMAND, "RefineFailed");
  962.  
  963.         LogManager::instance().RefineLog(ch->GetPlayerID(), item->GetName(), item->GetID(), item->GetRefineLevel(), success, way);
  964.     }
  965. }
  966.  
  967. void CHARACTER::SetRefineNPC(LPCHARACTER ch)
  968. {
  969.     if ( ch != NULL )
  970.     {
  971.         m_dwRefineNPCVID = ch->GetVID();
  972.     }
  973.     else
  974.     {
  975.         m_dwRefineNPCVID = 0;
  976.     }
  977. }
  978.  
  979. bool CHARACTER::DoRefine(LPITEM item, bool bMoneyOnly)
  980. {
  981.     if (!CanHandleItem(true))
  982.     {
  983.         ClearRefineMode();
  984.         return false;
  985.     }
  986.  
  987. #ifdef ENABLE_STONES_STACKFIX
  988.     DWORD pos = GetEmptyInventory(item->GetSize());
  989.  
  990.     if (-1 == pos){
  991.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
  992.         return false;
  993.     }
  994. #endif
  995.  
  996.     if (quest::CQuestManager::instance().GetEventFlag("update_refine_time") != 0)
  997.     {
  998.         if (get_global_time() < quest::CQuestManager::instance().GetEventFlag("update_refine_time") + (60 * 5))
  999.         {
  1000.             sys_log(0, "can't refine %d %s", GetPlayerID(), GetName());
  1001.             return false;
  1002.         }
  1003.     }
  1004.  
  1005.     const TRefineTable * prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
  1006.  
  1007.     if (!prt)
  1008.         return false;
  1009.  
  1010.     DWORD result_vnum = item->GetRefinedVnum();
  1011.  
  1012.     // REFINE_COST
  1013.     int cost = ComputeRefineFee(prt->cost);
  1014.  
  1015.     int RefineChance = GetQuestFlag("main_quest_lv7.refine_chance");
  1016.  
  1017.     if (RefineChance > 0)
  1018.     {
  1019.         if (!item->CheckItemUseLevel(20) || item->GetType() != ITEM_WEAPON)
  1020.         {
  1021.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무료 개량 기회는 20 이하의 무기만 가능합니다"));
  1022.             return false;
  1023.         }
  1024.  
  1025.         cost = 0;
  1026.         SetQuestFlag("main_quest_lv7.refine_chance", RefineChance - 1);
  1027.     }
  1028.     // END_OF_REFINE_COST
  1029.  
  1030.     if (result_vnum == 0)
  1031.     {
  1032.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 개량할 수 없습니다."));
  1033.         return false;
  1034.     }
  1035.  
  1036.     if (item->GetType() == ITEM_USE && item->GetSubType() == USE_TUNING)
  1037.         return false;
  1038.  
  1039.     TItemTable * pProto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
  1040.  
  1041.     if (!pProto)
  1042.     {
  1043.         sys_err("DoRefine NOT GET ITEM PROTO %d", item->GetRefinedVnum());
  1044.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  1045.         return false;
  1046.     }
  1047.  
  1048.     // REFINE_COST
  1049.     if (GetGold() < cost)
  1050.     {
  1051.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 돈이 부족합니다."));
  1052.         return false;
  1053.     }
  1054.  
  1055.     if (!bMoneyOnly && !RefineChance)
  1056.     {
  1057.         for (int i = 0; i < prt->material_count; ++i)
  1058.         {
  1059.             if (CountSpecifyItem(prt->materials[i].vnum) < prt->materials[i].count)
  1060.             {
  1061.                 if (test_server)
  1062.                 {
  1063.                     ChatPacket(CHAT_TYPE_INFO, "Find %d, count %d, require %d", prt->materials[i].vnum, CountSpecifyItem(prt->materials[i].vnum), prt->materials[i].count);
  1064.                 }
  1065.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 재료가 부족합니다."));
  1066.                 return false;
  1067.             }
  1068.         }
  1069.  
  1070.         for (int i = 0; i < prt->material_count; ++i)
  1071.             RemoveSpecifyItem(prt->materials[i].vnum, prt->materials[i].count);
  1072.     }
  1073.  
  1074.     int prob = number(1, 100);
  1075.  
  1076.     if (IsRefineThroughGuild() || bMoneyOnly)
  1077.         prob -= 10;
  1078.  
  1079.     // END_OF_REFINE_COST
  1080.  
  1081.     if (prob <= prt->prob)
  1082.     {
  1083.         LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
  1084.  
  1085.         if (pkNewItem)
  1086.         {
  1087.             ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  1088.             LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
  1089.  
  1090.             BYTE bCell = item->GetCell();
  1091.  
  1092.             // DETAIL_REFINE_LOG
  1093.             NotifyRefineSuccess(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  1094.             DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -cost);
  1095. #ifdef ENABLE_STONES_STACKFIX
  1096.             if (item->GetType() == ITEM_METIN) {
  1097.                 item->SetCount(item->GetCount() - 1);
  1098.                 pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, pos));
  1099.                 ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1100.             }
  1101.             else {
  1102.                 ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
  1103.                 ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1104.                 pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1105.             }
  1106. #else
  1107.             pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1108.             ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
  1109. #endif
  1110.             ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1111.  
  1112.             sys_log(0, "Refine Success %d", cost);
  1113.             pkNewItem->AttrLog();
  1114.             //PointChange(POINT_GOLD, -cost);
  1115.             sys_log(0, "PayPee %d", cost);
  1116.             PayRefineFee(cost);
  1117.             sys_log(0, "PayPee End %d", cost);
  1118.         }
  1119.         else
  1120.         {
  1121.             // DETAIL_REFINE_LOG
  1122.            
  1123.             sys_err("cannot create item %u", result_vnum);
  1124.             NotifyRefineFail(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  1125.             // END_OF_DETAIL_REFINE_LOG
  1126.         }
  1127.     }
  1128.     else
  1129.     {
  1130.         DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -cost);
  1131.         NotifyRefineFail(this, item, IsRefineThroughGuild() ? "GUILD" : "POWER");
  1132.         item->AttrLog();
  1133. #ifdef ENABLE_STONES_STACKFIX
  1134.         item->SetCount(item->GetCount() - 1);
  1135. #else
  1136.         ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
  1137. #endif
  1138.  
  1139.         //PointChange(POINT_GOLD, -cost);
  1140.         PayRefineFee(cost);
  1141.     }
  1142.  
  1143.     return true;
  1144. }
  1145.  
  1146. enum enum_RefineScrolls
  1147. {
  1148.     CHUKBOK_SCROLL = 0,
  1149.     HYUNIRON_CHN   = 1,
  1150.     YONGSIN_SCROLL = 2,
  1151.     MUSIN_SCROLL   = 3,
  1152.     YAGONG_SCROLL  = 4,
  1153.     MEMO_SCROLL    = 5,
  1154.     BDRAGON_SCROLL  = 6,
  1155. #if defined(__SOUL_SYSTEM__)
  1156.     SOUL_AWAKE_SCROLL = 8,
  1157.     SOUL_EVOLVE_SCROLL = 9,
  1158. #endif
  1159. };
  1160.  
  1161. #if defined(__SOUL_SYSTEM__)
  1162. bool CHARACTER::DoRefineSoul(LPITEM item)
  1163. {
  1164.     if (!CanHandleItem(true))
  1165.     {
  1166.         ClearRefineMode();
  1167.         return false;
  1168.     }
  1169.  
  1170.     ClearRefineMode();
  1171.  
  1172.     const TRefineTable* prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
  1173.     if (!prt)
  1174.         return false;
  1175.  
  1176.     if (m_iRefineAdditionalCell < 0)
  1177.         return false;
  1178.  
  1179.     LPITEM item_scroll = GetInventoryItem(m_iRefineAdditionalCell);
  1180.     if (item_scroll == nullptr)
  1181.         return false;
  1182.  
  1183.     if (!(item_scroll->GetType() == ITEM_USE && item_scroll->GetSubType() == USE_TUNING))
  1184.         return false;
  1185.  
  1186.     if (item_scroll->GetVnum() == item->GetVnum())
  1187.         return false;
  1188.  
  1189.     DWORD result_vnum = item->GetRefinedVnum();
  1190.     if (result_vnum == 0)
  1191.     {
  1192.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("´o AI≫o °³·®CO ¼o ¾ø½A´I´U."));
  1193.         return false;
  1194.     }
  1195.  
  1196.     TItemTable* proto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
  1197.     if (!proto)
  1198.     {
  1199.         sys_err("DoRefineSoul NOT GET ITEM PROTO %d", item->GetRefinedVnum());
  1200.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("AI ¾ÆAIAUAº °³·®CO ¼o ¾ø½A´I´U."));
  1201.         return false;
  1202.     }
  1203.  
  1204.     int prob = number(1, 100);
  1205.     int success_prob = prt->prob;
  1206.  
  1207.     switch (item_scroll->GetValue(0))
  1208.     {
  1209.         case SOUL_AWAKE_SCROLL:
  1210.             success_prob = 100;
  1211.             break;
  1212.  
  1213.         case SOUL_EVOLVE_SCROLL:
  1214.             success_prob = soul_refine_prob[MINMAX(0, item->GetValue(1), SOUL_GRADE_MAX)];
  1215.             break;
  1216.     }
  1217.  
  1218.     item_scroll->SetCount(item_scroll->GetCount() - 1);
  1219.  
  1220.     if (prob <= success_prob)
  1221.     {
  1222.         LPITEM new_item = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
  1223.         if (new_item)
  1224.         {
  1225.             WORD wCell = item->GetCell();
  1226.  
  1227.             LogManager::instance().ItemLog(this, new_item, "SOUL REFINE FAIL", new_item->GetName());
  1228.             ChatPacket(CHAT_TYPE_COMMAND, "RefineSoulSuceeded");
  1229.  
  1230.             ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (SOUL REFINE FAIL)");
  1231.  
  1232.             new_item->AddToCharacter(this, TItemPos(INVENTORY, wCell));
  1233.             ITEM_MANAGER::instance().FlushDelayedSave(new_item);
  1234.         }
  1235.         else
  1236.         {
  1237.             sys_err("cannot create item %u", result_vnum);
  1238.             ChatPacket(CHAT_TYPE_COMMAND, "RefineSoulFailed");
  1239.         }
  1240.     }
  1241.     else
  1242.     {
  1243.         ChatPacket(CHAT_TYPE_COMMAND, "RefineSoulFailed");
  1244.     }
  1245.  
  1246.     return true;
  1247. }
  1248. #endif
  1249.  
  1250. bool CHARACTER::DoRefineWithScroll(LPITEM item)
  1251. {
  1252.     if (!CanHandleItem(true))
  1253.     {
  1254.         ClearRefineMode();
  1255.         return false;
  1256.     }
  1257.  
  1258. #ifdef ENABLE_STONES_STACKFIX
  1259.     DWORD pos = GetEmptyInventory(item->GetSize());
  1260.  
  1261.     if (-1 == pos){
  1262.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
  1263.         return false;
  1264.     }
  1265. #endif
  1266.  
  1267.     ClearRefineMode();
  1268.  
  1269.     if (quest::CQuestManager::instance().GetEventFlag("update_refine_time") != 0)
  1270.     {
  1271.         if (get_global_time() < quest::CQuestManager::instance().GetEventFlag("update_refine_time") + (60 * 5))
  1272.         {
  1273.             sys_log(0, "can't refine %d %s", GetPlayerID(), GetName());
  1274.             return false;
  1275.         }
  1276.     }
  1277.  
  1278.     const TRefineTable * prt = CRefineManager::instance().GetRefineRecipe(item->GetRefineSet());
  1279.  
  1280.     if (!prt)
  1281.         return false;
  1282.  
  1283.     LPITEM pkItemScroll;
  1284.  
  1285.    
  1286.     if (m_iRefineAdditionalCell < 0)
  1287.         return false;
  1288.  
  1289.     pkItemScroll = GetInventoryItem(m_iRefineAdditionalCell);
  1290.  
  1291.     if (!pkItemScroll)
  1292.         return false;
  1293.  
  1294.     if (!(pkItemScroll->GetType() == ITEM_USE && pkItemScroll->GetSubType() == USE_TUNING))
  1295.         return false;
  1296.  
  1297.     if (pkItemScroll->GetVnum() == item->GetVnum())
  1298.         return false;
  1299.  
  1300.     DWORD result_vnum = item->GetRefinedVnum();
  1301.     DWORD result_fail_vnum = item->GetRefineFromVnum();
  1302.  
  1303.     if (result_vnum == 0)
  1304.     {
  1305.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 개량할 수 없습니다."));
  1306.         return false;
  1307.     }
  1308.  
  1309.     // MUSIN_SCROLL
  1310.     if (pkItemScroll->GetValue(0) == MUSIN_SCROLL)
  1311.     {
  1312.         if (item->GetRefineLevel() >= 4)
  1313.         {
  1314.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 개량서로 더 이상 개량할 수 없습니다."));
  1315.             return false;
  1316.         }
  1317.     }
  1318.     // END_OF_MUSIC_SCROLL
  1319.  
  1320.     else if (pkItemScroll->GetValue(0) == MEMO_SCROLL)
  1321.     {
  1322.         if (item->GetRefineLevel() != pkItemScroll->GetValue(1))
  1323.         {
  1324.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 개량서로 개량할 수 없습니다."));
  1325.             return false;
  1326.         }
  1327.     }
  1328.     else if (pkItemScroll->GetValue(0) == BDRAGON_SCROLL)
  1329.     {
  1330.         if (item->GetType() != ITEM_METIN || item->GetRefineLevel() != 4)
  1331.         {
  1332.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템으로 개량할 수 없습니다."));
  1333.             return false;
  1334.         }
  1335.     }
  1336.  
  1337.     TItemTable * pProto = ITEM_MANAGER::instance().GetTable(item->GetRefinedVnum());
  1338.  
  1339.     if (!pProto)
  1340.     {
  1341.         sys_err("DoRefineWithScroll NOT GET ITEM PROTO %d", item->GetRefinedVnum());
  1342.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  1343.         return false;
  1344.     }
  1345.  
  1346.     if (GetGold() < prt->cost)
  1347.     {
  1348.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 돈이 부족합니다."));
  1349.         return false;
  1350.     }
  1351.  
  1352.     for (int i = 0; i < prt->material_count; ++i)
  1353.     {
  1354.         if (CountSpecifyItem(prt->materials[i].vnum) < prt->materials[i].count)
  1355.         {
  1356.             if (test_server)
  1357.             {
  1358.                 ChatPacket(CHAT_TYPE_INFO, "Find %d, count %d, require %d", prt->materials[i].vnum, CountSpecifyItem(prt->materials[i].vnum), prt->materials[i].count);
  1359.             }
  1360.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개량을 하기 위한 재료가 부족합니다."));
  1361.             return false;
  1362.         }
  1363.     }
  1364.  
  1365.     for (int i = 0; i < prt->material_count; ++i)
  1366.         RemoveSpecifyItem(prt->materials[i].vnum, prt->materials[i].count);
  1367.  
  1368.     int prob = number(1, 100);
  1369.     int success_prob = prt->prob;
  1370.     bool bDestroyWhenFail = false;
  1371.  
  1372.     const char* szRefineType = "SCROLL";
  1373.  
  1374.     if (pkItemScroll->GetValue(0) == HYUNIRON_CHN ||
  1375.         pkItemScroll->GetValue(0) == YONGSIN_SCROLL ||
  1376.         pkItemScroll->GetValue(0) == YAGONG_SCROLL)
  1377.     {
  1378.         const char hyuniron_prob[9] = { 100, 75, 65, 55, 45, 40, 35, 25, 20 };
  1379.         const char yagong_prob[9] = { 100, 100, 90, 80, 70, 60, 50, 30, 20 };
  1380.  
  1381.         if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL)
  1382.         {
  1383.             success_prob = hyuniron_prob[MINMAX(0, item->GetRefineLevel(), 8)];
  1384.         }
  1385.         else if (pkItemScroll->GetValue(0) == YAGONG_SCROLL)
  1386.         {
  1387.             success_prob = yagong_prob[MINMAX(0, item->GetRefineLevel(), 8)];
  1388.         }
  1389.         else if (pkItemScroll->GetValue(0) == HYUNIRON_CHN) {} // @fixme121
  1390.         else
  1391.         {
  1392.             sys_err("REFINE : Unknown refine scroll item. Value0: %d", pkItemScroll->GetValue(0));
  1393.         }
  1394.  
  1395.         if (test_server)
  1396.         {
  1397.             ChatPacket(CHAT_TYPE_INFO, "[Only Test] Success_Prob %d, RefineLevel %d ", success_prob, item->GetRefineLevel());
  1398.         }
  1399.         if (pkItemScroll->GetValue(0) == HYUNIRON_CHN)
  1400.             bDestroyWhenFail = true;
  1401.  
  1402.         // DETAIL_REFINE_LOG
  1403.         if (pkItemScroll->GetValue(0) == HYUNIRON_CHN)
  1404.         {
  1405.             szRefineType = "HYUNIRON";
  1406.         }
  1407.         else if (pkItemScroll->GetValue(0) == YONGSIN_SCROLL)
  1408.         {
  1409.             szRefineType = "GOD_SCROLL";
  1410.         }
  1411.         else if (pkItemScroll->GetValue(0) == YAGONG_SCROLL)
  1412.         {
  1413.             szRefineType = "YAGONG_SCROLL";
  1414.         }
  1415.         // END_OF_DETAIL_REFINE_LOG
  1416.     }
  1417.  
  1418.     // DETAIL_REFINE_LOG
  1419.     if (pkItemScroll->GetValue(0) == MUSIN_SCROLL)
  1420.     {
  1421.         success_prob = 100;
  1422.  
  1423.         szRefineType = "MUSIN_SCROLL";
  1424.     }
  1425.     // END_OF_DETAIL_REFINE_LOG
  1426.     else if (pkItemScroll->GetValue(0) == MEMO_SCROLL)
  1427.     {
  1428.         success_prob = 100;
  1429.         szRefineType = "MEMO_SCROLL";
  1430.     }
  1431.     else if (pkItemScroll->GetValue(0) == BDRAGON_SCROLL)
  1432.     {
  1433.         success_prob = 80;
  1434.         szRefineType = "BDRAGON_SCROLL";
  1435.     }
  1436.  
  1437.     pkItemScroll->SetCount(pkItemScroll->GetCount() - 1);
  1438.  
  1439.     if (prob <= success_prob)
  1440.     {
  1441.        
  1442.         LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_vnum, 1, 0, false);
  1443.  
  1444.         if (pkNewItem)
  1445.         {
  1446.             ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  1447.             LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
  1448.  
  1449.             BYTE bCell = item->GetCell();
  1450.  
  1451.             NotifyRefineSuccess(this, item, szRefineType);
  1452.             DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -prt->cost);
  1453. #ifdef ENABLE_STONES_STACKFIX
  1454.             if (item->GetType() == ITEM_METIN) {
  1455.                 item->SetCount(item->GetCount() - 1);
  1456.                 pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, pos));
  1457.                 ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1458.             }
  1459.             else {
  1460.                 ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
  1461.                 ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1462.                 pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1463.             }
  1464. #else
  1465.             pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1466.             ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE SUCCESS)");
  1467. #endif
  1468.             ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1469.             pkNewItem->AttrLog();
  1470.             //PointChange(POINT_GOLD, -prt->cost);
  1471.             PayRefineFee(prt->cost);
  1472.         }
  1473.         else
  1474.         {
  1475.            
  1476.             sys_err("cannot create item %u", result_vnum);
  1477.             NotifyRefineFail(this, item, szRefineType);
  1478.         }
  1479.     }
  1480.     else if (!bDestroyWhenFail && result_fail_vnum)
  1481.     {
  1482.        
  1483.         LPITEM pkNewItem = ITEM_MANAGER::instance().CreateItem(result_fail_vnum, 1, 0, false);
  1484.  
  1485.         if (pkNewItem)
  1486.         {
  1487.             ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
  1488.             LogManager::instance().ItemLog(this, pkNewItem, "REFINE FAIL", pkNewItem->GetName());
  1489.  
  1490.             BYTE bCell = item->GetCell();
  1491.  
  1492.             DBManager::instance().SendMoneyLog(MONEY_LOG_REFINE, item->GetVnum(), -prt->cost);
  1493.             NotifyRefineFail(this, item, szRefineType, -1);
  1494. #ifdef ENABLE_STONES_STACKFIX
  1495.             if (item->GetType() == ITEM_METIN) {
  1496.                 item->SetCount(item->GetCount() - 1);
  1497.                 pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, pos));
  1498.                 ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1499.             }
  1500.             else {
  1501.                 ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
  1502.                 ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1503.                 pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1504.             }
  1505. #else
  1506.             pkNewItem->AddToCharacter(this, TItemPos(INVENTORY, bCell));
  1507.             ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (REFINE FAIL)");
  1508. #endif
  1509.             ITEM_MANAGER::instance().FlushDelayedSave(pkNewItem);
  1510.  
  1511.             pkNewItem->AttrLog();
  1512.  
  1513.             //PointChange(POINT_GOLD, -prt->cost);
  1514.             PayRefineFee(prt->cost);
  1515.         }
  1516.         else
  1517.         {
  1518.            
  1519.             sys_err("cannot create item %u", result_fail_vnum);
  1520.             NotifyRefineFail(this, item, szRefineType);
  1521.         }
  1522.     }
  1523.     else
  1524.     {
  1525.         NotifyRefineFail(this, item, szRefineType);
  1526.  
  1527.         PayRefineFee(prt->cost);
  1528.     }
  1529.  
  1530.     return true;
  1531. }
  1532.  
  1533. bool CHARACTER::RefineInformation(BYTE bCell, BYTE bType, int iAdditionalCell)
  1534. {
  1535.     if (bCell > INVENTORY_MAX_NUM)
  1536.         return false;
  1537.  
  1538.     LPITEM item = GetInventoryItem(bCell);
  1539.  
  1540.     if (!item)
  1541.         return false;
  1542.  
  1543.     // REFINE_COST
  1544.     if (bType == REFINE_TYPE_MONEY_ONLY && !GetQuestFlag("deviltower_zone.can_refine"))
  1545.     {
  1546.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사귀 타워 완료 보상은 한번까지 사용가능합니다."));
  1547.         return false;
  1548.     }
  1549.     // END_OF_REFINE_COST
  1550.  
  1551.     TPacketGCRefineInformation p;
  1552.  
  1553.     p.header = HEADER_GC_REFINE_INFORMATION;
  1554.     p.pos = bCell;
  1555.     p.src_vnum = item->GetVnum();
  1556.     p.result_vnum = item->GetRefinedVnum();
  1557.     p.type = bType;
  1558.  
  1559.     if (p.result_vnum == 0)
  1560.     {
  1561.         sys_err("RefineInformation p.result_vnum == 0");
  1562.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  1563.         return false;
  1564.     }
  1565.  
  1566.     if (item->GetType() == ITEM_USE && item->GetSubType() == USE_TUNING)
  1567.     {
  1568.         if (bType == 0)
  1569.         {
  1570.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 이 방식으로는 개량할 수 없습니다."));
  1571.             return false;
  1572.         }
  1573.         else
  1574.         {
  1575.             LPITEM itemScroll = GetInventoryItem(iAdditionalCell);
  1576.             if (!itemScroll || item->GetVnum() == itemScroll->GetVnum())
  1577.             {
  1578.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("같은 개량서를 합칠 수는 없습니다."));
  1579.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("축복의 서와 현철을 합칠 수 있습니다."));
  1580.                 return false;
  1581.             }
  1582.         }
  1583.     }
  1584.  
  1585. #if defined(__SOUL_SYSTEM__)
  1586.     if (bType == REFINE_TYPE_SOUL_AWAKE || bType == REFINE_TYPE_SOUL_EVOLVE)
  1587.     {
  1588.         p.cost = 0;
  1589.         p.prob = bType == REFINE_TYPE_SOUL_AWAKE ? 100 : soul_refine_prob[MINMAX(0, item->GetValue(1), SOUL_GRADE_MAX)];
  1590.         p.material_count = 0;
  1591.         std::memset(p.materials, 0, sizeof(p.materials));
  1592.  
  1593.         GetDesc()->Packet(&p, sizeof(TPacketGCRefineInformation));
  1594.  
  1595.         SetRefineMode(iAdditionalCell);
  1596.         return true;
  1597.     }
  1598. #endif
  1599.  
  1600.     CRefineManager & rm = CRefineManager::instance();
  1601.     const TRefineTable* prt = rm.GetRefineRecipe(item->GetRefineSet());
  1602.  
  1603.     if (!prt)
  1604.     {
  1605.         sys_err("RefineInformation NOT GET REFINE SET %d", item->GetRefineSet());
  1606.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  1607.         return false;
  1608.     }
  1609.  
  1610.     // REFINE_COST
  1611.  
  1612.     //MAIN_QUEST_LV7
  1613.     if (GetQuestFlag("main_quest_lv7.refine_chance") > 0)
  1614.     {
  1615.        
  1616.         if (!item->CheckItemUseLevel(20) || item->GetType() != ITEM_WEAPON)
  1617.         {
  1618.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무료 개량 기회는 20 이하의 무기만 가능합니다"));
  1619.             return false;
  1620.         }
  1621.         p.cost = 0;
  1622.     }
  1623.     else
  1624.         p.cost = ComputeRefineFee(prt->cost);
  1625.  
  1626.     //END_MAIN_QUEST_LV7
  1627.     p.prob = prt->prob;
  1628.     if (bType == REFINE_TYPE_MONEY_ONLY)
  1629.     {
  1630.         p.material_count = 0;
  1631.         memset(p.materials, 0, sizeof(p.materials));
  1632.     }
  1633.     else
  1634.     {
  1635.         p.material_count = prt->material_count;
  1636.         thecore_memcpy(&p.materials, prt->materials, sizeof(prt->materials));
  1637.     }
  1638.     // END_OF_REFINE_COST
  1639.  
  1640.     GetDesc()->Packet(&p, sizeof(TPacketGCRefineInformation));
  1641.  
  1642.     SetRefineMode(iAdditionalCell);
  1643.     return true;
  1644. }
  1645.  
  1646. bool CHARACTER::RefineItem(LPITEM pkItem, LPITEM pkTarget)
  1647. {
  1648.     if (!CanHandleItem())
  1649.         return false;
  1650.  
  1651.     if (pkItem->GetSubType() == USE_TUNING)
  1652.     {
  1653.        
  1654.        
  1655.         // MUSIN_SCROLL
  1656.         if (pkItem->GetValue(0) == MUSIN_SCROLL)
  1657.             RefineInformation(pkTarget->GetCell(), REFINE_TYPE_MUSIN, pkItem->GetCell());
  1658.         // END_OF_MUSIN_SCROLL
  1659.         else if (pkItem->GetValue(0) == HYUNIRON_CHN)
  1660.             RefineInformation(pkTarget->GetCell(), REFINE_TYPE_HYUNIRON, pkItem->GetCell());
  1661.         else if (pkItem->GetValue(0) == BDRAGON_SCROLL)
  1662.         {
  1663.             if (pkTarget->GetRefineSet() != 702) return false;
  1664.             RefineInformation(pkTarget->GetCell(), REFINE_TYPE_BDRAGON, pkItem->GetCell());
  1665.         }
  1666. #if defined(__SOUL_SYSTEM__)
  1667.         else if (pkItem->GetValue(0) == SOUL_AWAKE_SCROLL)
  1668.         {
  1669.             if (pkTarget->GetValue(0) >= SOUL_GRADE_ILUMINED) return false;
  1670.             RefineInformation(pkTarget->GetCell(), REFINE_TYPE_SOUL_AWAKE, pkItem->GetCell());
  1671.         }
  1672.         else if (pkItem->GetValue(0) == SOUL_EVOLVE_SCROLL)
  1673.         {
  1674.             if (pkTarget->GetValue(0) >= SOUL_GRADE_ILUMINED) return false;
  1675.             RefineInformation(pkTarget->GetCell(), REFINE_TYPE_SOUL_EVOLVE, pkItem->GetCell());
  1676.         }
  1677. #endif
  1678.         else
  1679.         {
  1680.             if (pkTarget->GetRefineSet() == 501) return false;
  1681.             RefineInformation(pkTarget->GetCell(), REFINE_TYPE_SCROLL, pkItem->GetCell());
  1682.         }
  1683.     }
  1684.     else if (pkItem->GetSubType() == USE_DETACHMENT && IS_SET(pkTarget->GetFlag(), ITEM_FLAG_REFINEABLE))
  1685.     {
  1686.         LogManager::instance().ItemLog(this, pkTarget, "USE_DETACHMENT", pkTarget->GetName());
  1687.  
  1688.         bool bHasMetinStone = false;
  1689.  
  1690.         for (int i = 0; i < ITEM_SOCKET_MAX_NUM; i++)
  1691.         {
  1692.             long socket = pkTarget->GetSocket(i);
  1693.             if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
  1694.             {
  1695.                 bHasMetinStone = true;
  1696.                 break;
  1697.             }
  1698.         }
  1699.  
  1700.         if (bHasMetinStone)
  1701.         {
  1702.             for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  1703.             {
  1704.                 long socket = pkTarget->GetSocket(i);
  1705.                 if (socket > 2 && socket != ITEM_BROKEN_METIN_VNUM)
  1706.                 {
  1707.                     AutoGiveItem(socket);
  1708.                     //TItemTable* pTable = ITEM_MANAGER::instance().GetTable(pkTarget->GetSocket(i));
  1709.                     //pkTarget->SetSocket(i, pTable->alValues[2]);
  1710.                    
  1711.                     pkTarget->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
  1712.                 }
  1713.             }
  1714.             pkItem->SetCount(pkItem->GetCount() - 1);
  1715.             return true;
  1716.         }
  1717.         else
  1718.         {
  1719.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빼낼 수 있는 메틴석이 없습니다."));
  1720.             return false;
  1721.         }
  1722.     }
  1723.  
  1724.     return false;
  1725. }
  1726.  
  1727. EVENTFUNC(kill_campfire_event)
  1728. {
  1729.     char_event_info* info = dynamic_cast<char_event_info*>( event->info );
  1730.  
  1731.     if ( info == NULL )
  1732.     {
  1733.         sys_err( "kill_campfire_event> <Factor> Null pointer" );
  1734.         return 0;
  1735.     }
  1736.  
  1737.     LPCHARACTER ch = info->ch;
  1738.  
  1739.     if (ch == NULL) { // <Factor>
  1740.         return 0;
  1741.     }
  1742.     ch->m_pkMiningEvent = NULL;
  1743.     M2_DESTROY_CHARACTER(ch);
  1744.     return 0;
  1745. }
  1746.  
  1747. bool CHARACTER::GiveRecallItem(LPITEM item)
  1748. {
  1749.     int idx = GetMapIndex();
  1750.     int iEmpireByMapIndex = -1;
  1751.  
  1752.     if (idx < 20)
  1753.         iEmpireByMapIndex = 1;
  1754.     else if (idx < 40)
  1755.         iEmpireByMapIndex = 2;
  1756.     else if (idx < 60)
  1757.         iEmpireByMapIndex = 3;
  1758.     else if (idx < 10000)
  1759.         iEmpireByMapIndex = 0;
  1760.  
  1761.     switch (idx)
  1762.     {
  1763.         case 66:
  1764.         case 216:
  1765.             iEmpireByMapIndex = -1;
  1766.             break;
  1767.     }
  1768.  
  1769.     if (iEmpireByMapIndex && GetEmpire() != iEmpireByMapIndex)
  1770.     {
  1771.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("기억해 둘 수 없는 위치 입니다."));
  1772.         return false;
  1773.     }
  1774.  
  1775.     int pos;
  1776.  
  1777.     if (item->GetCount() == 1) 
  1778.     {
  1779.         item->SetSocket(0, GetX());
  1780.         item->SetSocket(1, GetY());
  1781.     }
  1782.     else if ((pos = GetEmptyInventory(item->GetSize())) != -1)
  1783.     {
  1784.         LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), 1);
  1785.  
  1786.         if (NULL != item2)
  1787.         {
  1788.             item2->SetSocket(0, GetX());
  1789.             item2->SetSocket(1, GetY());
  1790.             item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
  1791.  
  1792.             item->SetCount(item->GetCount() - 1);
  1793.         }
  1794.     }
  1795.     else
  1796.     {
  1797.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지품에 빈 공간이 없습니다."));
  1798.         return false;
  1799.     }
  1800.  
  1801.     return true;
  1802. }
  1803.  
  1804. void CHARACTER::ProcessRecallItem(LPITEM item)
  1805. {
  1806.     int idx;
  1807.  
  1808.     if ((idx = SECTREE_MANAGER::instance().GetMapIndex(item->GetSocket(0), item->GetSocket(1))) == 0)
  1809.         return;
  1810.  
  1811.     int iEmpireByMapIndex = -1;
  1812.  
  1813.     if (idx < 20)
  1814.         iEmpireByMapIndex = 1;
  1815.     else if (idx < 40)
  1816.         iEmpireByMapIndex = 2;
  1817.     else if (idx < 60)
  1818.         iEmpireByMapIndex = 3;
  1819.     else if (idx < 10000)
  1820.         iEmpireByMapIndex = 0;
  1821.  
  1822.     switch (idx)
  1823.     {
  1824.         case 66:
  1825.         case 216:
  1826.             iEmpireByMapIndex = -1;
  1827.             break;
  1828.         // 악룡군도 일때
  1829.         case 301:
  1830.         case 302:
  1831.         case 303:
  1832.         case 304:
  1833.             if( GetLevel() < 90 )
  1834.             {
  1835.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템의 레벨 제한보다 레벨이 낮습니다."));
  1836.                 return;
  1837.             }
  1838.             else
  1839.                 break;
  1840.     }
  1841.  
  1842.     if (iEmpireByMapIndex && GetEmpire() != iEmpireByMapIndex)
  1843.     {
  1844.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("기억된 위치가 타제국에 속해 있어서 귀환할 수 없습니다."));
  1845.         item->SetSocket(0, 0);
  1846.         item->SetSocket(1, 0);
  1847.     }
  1848.     else
  1849.     {
  1850.         sys_log(1, "Recall: %s %d %d -> %d %d", GetName(), GetX(), GetY(), item->GetSocket(0), item->GetSocket(1));
  1851.         WarpSet(item->GetSocket(0), item->GetSocket(1));
  1852.         item->SetCount(item->GetCount() - 1);
  1853.     }
  1854. }
  1855.  
  1856. void CHARACTER::__OpenPrivateShop()
  1857. {
  1858. #ifdef ENABLE_OPEN_SHOP_WITH_ARMOR
  1859.     ChatPacket(CHAT_TYPE_COMMAND, "OpenPrivateShop");
  1860. #else
  1861.     unsigned bodyPart = GetPart(PART_MAIN);
  1862.     switch (bodyPart)
  1863.     {
  1864.         case 0:
  1865.         case 1:
  1866.         case 2:
  1867.             ChatPacket(CHAT_TYPE_COMMAND, "OpenPrivateShop");
  1868.             break;
  1869.         default:
  1870.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("갑옷을 벗어야 개인 상점을 열 수 있습니다."));
  1871.             break;
  1872.     }
  1873. #endif
  1874. }
  1875.  
  1876. // MYSHOP_PRICE_LIST
  1877. /*
  1878. void CHARACTER::SendMyShopPriceListCmd(DWORD dwItemVnum, DWORD dwItemPrice)
  1879. {
  1880.     char szLine[256];
  1881.     snprintf(szLine, sizeof(szLine), "MyShopPriceList %u %u", dwItemVnum, dwItemPrice);
  1882.     ChatPacket(CHAT_TYPE_COMMAND, szLine);
  1883.     sys_log(0, szLine);
  1884. }
  1885. */
  1886. void CHARACTER::SendMyShopPriceListCmd(DWORD dwItemVnum, long long dwItemPrice)
  1887. {
  1888.     char szLine[256];
  1889.     snprintf(szLine, sizeof(szLine), "MyShopPriceList %u %lld", dwItemVnum, dwItemPrice);
  1890.     ChatPacket(CHAT_TYPE_COMMAND, szLine);
  1891.     sys_log(0, szLine);
  1892. }
  1893.  
  1894. //
  1895.  
  1896. //
  1897. void CHARACTER::UseSilkBotaryReal(const TPacketMyshopPricelistHeader* p)
  1898. {
  1899.     const TItemPriceInfo* pInfo = (const TItemPriceInfo*)(p + 1);
  1900.  
  1901.     if (!p->byCount)
  1902.        
  1903.         SendMyShopPriceListCmd(1, 0);
  1904.     else {
  1905.         for (int idx = 0; idx < p->byCount; idx++)
  1906.             SendMyShopPriceListCmd(pInfo[ idx ].dwVnum, pInfo[ idx ].dwPrice);
  1907.     }
  1908.  
  1909.     __OpenPrivateShop();
  1910. }
  1911.  
  1912. //
  1913.  
  1914.  
  1915. //
  1916. void CHARACTER::UseSilkBotary(void)
  1917. {
  1918.     if (m_bNoOpenedShop) {
  1919.         DWORD dwPlayerID = GetPlayerID();
  1920.         db_clientdesc->DBPacket(HEADER_GD_MYSHOP_PRICELIST_REQ, GetDesc()->GetHandle(), &dwPlayerID, sizeof(DWORD));
  1921.         m_bNoOpenedShop = false;
  1922.     } else {
  1923.         __OpenPrivateShop();
  1924.     }
  1925. }
  1926. // END_OF_MYSHOP_PRICE_LIST
  1927.  
  1928. #ifdef ENABLE_NEW_AFFECT_POTION
  1929. void CHARACTER::SetAffectPotion(LPITEM item)
  1930. {
  1931.     if (!item)
  1932.         return;
  1933.  
  1934.     int iPotionAffects[] = {AFFECT_POTION_1, AFFECT_POTION_2, AFFECT_POTION_3, AFFECT_POTION_4, AFFECT_POTION_5, AFFECT_POTION_6};
  1935.     int iPotionVnums[] = {50821, 50822, 50823, 50824, 50825, 50826};
  1936.    
  1937.     for (int i = 0; i < _countof(iPotionVnums); i++)
  1938.     {
  1939.         if (item->GetVnum() == iPotionVnums[i])
  1940. #ifdef ENABLE_DEWS_PLUS
  1941.             AddAffect(iPotionAffects[i], APPLY_NONE, 0, AFF_NONE, INFINITE_AFFECT_DURATION, 0, false, false);      
  1942. #else
  1943.             AddAffect(iPotionAffects[i], APPLY_NONE, 0, AFF_NONE, item->GetSocket(2), 0, false, false);
  1944. #endif
  1945.     }
  1946. }
  1947.  
  1948. void CHARACTER::RemoveAffectPotion(LPITEM item)
  1949. {
  1950.     if (!item)
  1951.         return;
  1952.  
  1953.     int iPotionAffects[] = {AFFECT_POTION_1, AFFECT_POTION_2, AFFECT_POTION_3, AFFECT_POTION_4, AFFECT_POTION_5, AFFECT_POTION_6};
  1954.     int iPotionVnums[] = {50821, 50822, 50823, 50824, 50825, 50826};
  1955.    
  1956.     for (int i = 0; i < _countof(iPotionVnums); i++)
  1957.     {
  1958.         if (item->GetVnum() == iPotionVnums[i])
  1959.             RemoveAffect(iPotionAffects[i]);   
  1960.     }
  1961. }
  1962. #endif
  1963.  
  1964. int CalculateConsume(LPCHARACTER ch)
  1965. {
  1966.     static const int WARP_NEED_LIFE_PERCENT = 30;
  1967.     static const int WARP_MIN_LIFE_PERCENT  = 10;
  1968.     // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  1969.     int consumeLife = 0;
  1970.     {
  1971.         // CheckNeedLifeForWarp
  1972.         const int curLife       = ch->GetHP();
  1973.         const int needPercent   = WARP_NEED_LIFE_PERCENT;
  1974.         const int needLife = ch->GetMaxHP() * needPercent / 100;
  1975.         if (curLife < needLife)
  1976.         {
  1977.             ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("남은 생명력 양이 모자라 사용할 수 없습니다."));
  1978.             return -1;
  1979.         }
  1980.  
  1981.         consumeLife = needLife;
  1982.  
  1983.  
  1984.        
  1985.         const int minPercent    = WARP_MIN_LIFE_PERCENT;
  1986.         const int minLife   = ch->GetMaxHP() * minPercent / 100;
  1987.         if (curLife - needLife < minLife)
  1988.             consumeLife = curLife - minLife;
  1989.  
  1990.         if (consumeLife < 0)
  1991.             consumeLife = 0;
  1992.     }
  1993.     // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  1994.     return consumeLife;
  1995. }
  1996.  
  1997. int CalculateConsumeSP(LPCHARACTER lpChar)
  1998. {
  1999.     static const int NEED_WARP_SP_PERCENT = 30;
  2000.  
  2001.     const int curSP = lpChar->GetSP();
  2002.     const int needSP = lpChar->GetMaxSP() * NEED_WARP_SP_PERCENT / 100;
  2003.  
  2004.     if (curSP < needSP)
  2005.     {
  2006.         lpChar->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("남은 정신력 양이 모자라 사용할 수 없습니다."));
  2007.         return -1;
  2008.     }
  2009.  
  2010.     return needSP;
  2011. }
  2012.  
  2013. #ifdef ENABLE_YMIR_AFFECT_FIX
  2014. /*********************************************************************
  2015. * date        : 2016.07.19
  2016. * file        : char_item.cpp
  2017. * author        : VegaS
  2018. * description :
  2019. A guy from another forum say that:
  2020.  
  2021. *   ''I need help to correct some potions and other item, what putting on F1, F2, F3 and F4, uses, log out,
  2022. *   ''enter the game by clicking and gives bug and gets the double effect.''
  2023.  
  2024. * I see all people have other protection about this with other method shit in python like a :
  2025. *   He blocked inventory for open to 5 second to login or you cannot used quickslot on taskbar for 5 second or he change type on item_proto client for cannot put in taskbar etc..or other people make a restriction
  2026. *   in char_quickslot.cpp in function add, but that is not good is much better for make a timer for that, no for restriction item to put in other zone.
  2027. */ 
  2028. bool CHARACTER::CheckTimeUsed(LPITEM item)
  2029. {
  2030.     switch (item->GetVnum())
  2031.     {
  2032. /****************
  2033. * Type = 27 -> ITEM_BLEND (Delete the other case you do not want for check)
  2034. */ 
  2035.         case 50821: case 50822: case 50823: case 50824: case 50825: case 50826:
  2036.  
  2037. /****************
  2038. * SubType = 7 -> USE_ABILITY_UP (Delete the other case you do not want for check)
  2039. */ 
  2040.         case 27866: case 27868: case 27870: case 27873: case 39026: case 50093: case 50094:    
  2041.         case 50123: case 50801: case 50802: case 50817: case 50818: case 50819: case 50820:
  2042. /****************
  2043. * SubType = 8 -> USE_AFFECT (Delete the other case you do not want for check)
  2044. */ 
  2045.         case 39010: case 39017: case 39018: case 39019: case 39020: case 39024: case 39025:
  2046.         case 39031: case 50813: case 50814: case 71014: case 71015: case 71016: case 71017:
  2047.         case 71027: case 71028: case 71029: case 71030: case 71034: case 71044: case 71045:
  2048.         case 71101: case 71102: case 71153: case 71154: case 71155: case 71156: case 72025:
  2049.         case 72026: case 72027: case 72031: case 72032: case 72033: case 72034: case 72035:
  2050.         case 72036: case 72037: case 72038: case 72039: case 72040: case 72041: case 72042:
  2051.         case 72046: case 72047: case 72048: case 72312: case 72313: case 72501: case 72502:
  2052.         case 76003: case 76017: case 76018:
  2053.  
  2054.             int pGetTime[] = {10}; // Set timer for how you need a long after you login for can use item
  2055.            
  2056.             int pGetFlag = GetQuestFlag("item.last_time"); // Get questflag where him set from input_login.cpp (Not change)
  2057.            
  2058.             const char* pGetMessage[] = {"|cFFd0ffcc|H|hYou cannot use |cFFc9ff00|H|h[%s] |cFFd0ffcc|H|honly after passing |cFFec03e2|H|h[%u] |cFFd0ffcc|H|hseconds of logging!"}; // Get message when you use time so fast
  2059.            
  2060.             if (pGetFlag) // Initializate questflag on item
  2061.             {
  2062.                 if (get_global_time() < pGetFlag + pGetTime[0]) // Initializate to get a + second for questflag
  2063.                 {
  2064.                     ChatPacket(CHAT_TYPE_INFO, pGetMessage[0], item->GetName(), pGetTime[0]);   // Get message
  2065.                     return false; // Returns false if you use the item quicker than those seconds
  2066.                 }
  2067.             }  
  2068.         break; 
  2069.     }  
  2070.         return true;
  2071. }
  2072. #endif
  2073.  
  2074. // #define ENABLE_FIREWORK_STUN
  2075. // #define ENABLE_ADDSTONE_FAILURE
  2076. bool CHARACTER::UseItemEx(LPITEM item, TItemPos DestCell)
  2077. {
  2078.     int iLimitRealtimeStartFirstUseFlagIndex = -1;
  2079.     //int iLimitTimerBasedOnWearFlagIndex = -1;
  2080.  
  2081.     WORD wDestCell = DestCell.cell;
  2082.     BYTE bDestInven = DestCell.window_type;
  2083.     for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  2084.     {
  2085.         long limitValue = item->GetProto()->aLimits[i].lValue;
  2086.  
  2087.         switch (item->GetProto()->aLimits[i].bType)
  2088.         {
  2089.             case LIMIT_LEVEL:
  2090.                 if (GetLevel() < limitValue)
  2091.                 {
  2092.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템의 레벨 제한보다 레벨이 낮습니다."));
  2093.                     return false;
  2094.                 }
  2095.                 break;
  2096.  
  2097.             case LIMIT_REAL_TIME_START_FIRST_USE:
  2098.                 iLimitRealtimeStartFirstUseFlagIndex = i;
  2099.                 break;
  2100.  
  2101.             case LIMIT_TIMER_BASED_ON_WEAR:
  2102.                 //iLimitTimerBasedOnWearFlagIndex = i;
  2103.                 break;
  2104.         }
  2105.     }
  2106.  
  2107.     if (test_server)
  2108.     {
  2109.         sys_log(0, "USE_ITEM %s, Inven %d, Cell %d, ItemType %d, SubType %d", item->GetName(), bDestInven, wDestCell, item->GetType(), item->GetSubType());
  2110.     }
  2111.  
  2112. #ifdef ENABLE_IBEAST_MAP_RESTRICTION
  2113.     if (IsOnRestrictedMap())
  2114.     {
  2115.         for (int i = 0; i < sizeof(MapRestrictedItemVnums) / sizeof(*MapRestrictedItemVnums); i++)
  2116.             if (MapRestrictedItemVnums[i] == item->GetVnum())
  2117.             {
  2118.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("can_not_use_item"));
  2119.                 return false;
  2120.             }
  2121.     }
  2122. #endif
  2123.  
  2124.     if ( CArenaManager::instance().IsLimitedItem( GetMapIndex(), item->GetVnum() ) == true )
  2125.     {
  2126.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2127.         return false;
  2128.     }
  2129. #ifdef ENABLE_NEWSTUFF
  2130.     else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && IsLimitedPotionOnPVP(item->GetVnum()))
  2131.     {
  2132.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2133.         return false;
  2134.     }
  2135. #endif
  2136.  
  2137.     // @fixme402 (IsLoadedAffect to block affect hacking)
  2138.     if (!IsLoadedAffect())
  2139.     {
  2140.         ChatPacket(CHAT_TYPE_INFO, "Affects are not loaded yet!");
  2141.         return false;
  2142.     }
  2143.  
  2144.     // @fixme141 BEGIN
  2145.     if (TItemPos(item->GetWindow(), item->GetCell()).IsBeltInventoryPosition())
  2146.     {
  2147.         LPITEM beltItem = GetWear(WEAR_BELT);
  2148.  
  2149.         if (NULL == beltItem)
  2150.         {
  2151.             ChatPacket(CHAT_TYPE_INFO, "<Belt> You can't use this item if you have no equipped belt.");
  2152.             return false;
  2153.         }
  2154.  
  2155.         if (false == CBeltInventoryHelper::IsAvailableCell(item->GetCell() - BELT_INVENTORY_SLOT_START, beltItem->GetValue(0)))
  2156.         {
  2157.             ChatPacket(CHAT_TYPE_INFO, "<Belt> You can't use this item if you don't upgrade your belt.");
  2158.             return false;
  2159.         }
  2160.     }
  2161.     // @fixme141 END
  2162.  
  2163.    
  2164.     if (-1 != iLimitRealtimeStartFirstUseFlagIndex)
  2165.     {
  2166.        
  2167.         if (0 == item->GetSocket(1))
  2168.         {
  2169.            
  2170.             long duration = (0 != item->GetSocket(0)) ? item->GetSocket(0) : item->GetProto()->aLimits[iLimitRealtimeStartFirstUseFlagIndex].lValue;
  2171.  
  2172.             if (0 == duration)
  2173.                 duration = 60 * 60 * 24 * 7;
  2174.  
  2175.             item->SetSocket(0, time(0) + duration);
  2176.             item->StartRealTimeExpireEvent();
  2177.         }
  2178.  
  2179.         if (false == item->IsEquipped())
  2180.             item->SetSocket(1, item->GetSocket(1) + 1);
  2181.     }
  2182.  
  2183.     switch (item->GetType())
  2184.     {
  2185.         case ITEM_HAIR:
  2186.             return ItemProcess_Hair(item, wDestCell);
  2187.  
  2188.         case ITEM_POLYMORPH:
  2189.             return ItemProcess_Polymorph(item);
  2190.  
  2191.         case ITEM_QUEST:
  2192. #ifdef ENABLE_QUEST_DND_EVENT
  2193.             if (IS_SET(item->GetFlag(), ITEM_FLAG_APPLICABLE))
  2194.             {
  2195.                 LPITEM item2;
  2196.  
  2197.                 if (!GetItem(DestCell) || !(item2 = GetItem(DestCell)))
  2198.                     return false;
  2199.  
  2200.                 if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  2201.                     return false;
  2202.  
  2203.                 quest::CQuestManager::instance().DND(GetPlayerID(), item, item2, false);
  2204.                 return true;
  2205.             }
  2206. #endif
  2207.  
  2208.             if (GetArena() != NULL || IsObserverMode() == true)
  2209.             {
  2210.                 if (item->GetVnum() == 50051 || item->GetVnum() == 50052 || item->GetVnum() == 50053)
  2211.                 {
  2212.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2213.                     return false;
  2214.                 }
  2215.             }
  2216. #if defined(__BL_MAILBOX__)
  2217.             if (item->GetVnum() == MOBILE_MAILBOX)
  2218.             {
  2219.                 CMailBox::Open(this);
  2220.             }
  2221. #endif
  2222. #ifdef __AUTO_QUQUE_ATTACK__
  2223.             if (item->GetVnum() >= 61400 && item->GetVnum() <= 61405)
  2224.             {
  2225.                 if (item->isLocked() || item->IsExchanging())
  2226.                     return false;
  2227.                 else if (FindAffect(AFFECT_AUTO_METIN_FARM)) {
  2228.                     ChatPacket(CHAT_TYPE_INFO, "You has already affect.");
  2229.                     return false;
  2230.                 }
  2231.                 ChatPacket(CHAT_TYPE_INFO, "Affect successfully added.");
  2232.                 AddAffect(AFFECT_AUTO_METIN_FARM, 0, 0, AFF_NONE, item->GetValue(0) == 999 ? INFINITE_AFFECT_DURATION : 60 * 60 * 24 * item->GetValue(0), 0, false);
  2233.                 item->SetCount(item->GetCount() - 1);
  2234.                 return true;
  2235.             }
  2236. #endif
  2237. #ifdef __RENEWAL_BRAVE_CAPE__
  2238.             if (item->GetVnum() >= 20570 && item->GetVnum() <= 20575)
  2239.             {
  2240.                 if (FindAffect(AFFECT_BRAVE_CAPE))
  2241.                 {
  2242.                     ChatPacket(CHAT_TYPE_INFO, "You already has this affect!");
  2243.                     return false;
  2244.                 }
  2245.                 const int timeAdd = item->GetValue(0) > 30 ? INFINITE_AFFECT_DURATION : 60 * 60 * 24 * item->GetValue(0);
  2246.                 if (!timeAdd)
  2247.                 {
  2248.                     ChatPacket(CHAT_TYPE_INFO, "[SYSTEM] Contact game master. This item not has time data!");
  2249.                     return false;
  2250.                 }
  2251.  
  2252.                 AddAffect(AFFECT_BRAVE_CAPE, POINT_NONE, 0, AFF_NONE, timeAdd, 0, 0, false);
  2253.                 item->SetCount(item->GetCount() - 1);
  2254.                 return true;
  2255.             }
  2256. #endif
  2257.             if (!IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE | ITEM_FLAG_QUEST_USE_MULTIPLE))
  2258.             {
  2259.                 if (item->GetSIGVnum() == 0)
  2260.                 {
  2261.                     quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  2262.                 }
  2263.                 else
  2264.                 {
  2265.                     quest::CQuestManager::instance().SIGUse(GetPlayerID(), item->GetSIGVnum(), item, false);
  2266.                 }
  2267.             }
  2268.             break;
  2269.  
  2270.         case ITEM_CAMPFIRE:
  2271.             {
  2272.                 float fx, fy;
  2273.                 GetDeltaByDegree(GetRotation(), 100.0f, &fx, &fy);
  2274.  
  2275.                 LPSECTREE tree = SECTREE_MANAGER::instance().Get(GetMapIndex(), (long)(GetX()+fx), (long)(GetY()+fy));
  2276.  
  2277.                 if (!tree)
  2278.                 {
  2279.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("모닥불을 피울 수 없는 지점입니다."));
  2280.                     return false;
  2281.                 }
  2282.  
  2283.                 if (tree->IsAttr((long)(GetX()+fx), (long)(GetY()+fy), ATTR_WATER))
  2284.                 {
  2285.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물 속에 모닥불을 피울 수 없습니다."));
  2286.                     return false;
  2287.                 }
  2288.  
  2289.                 LPCHARACTER campfire = CHARACTER_MANAGER::instance().SpawnMob(fishing::CAMPFIRE_MOB, GetMapIndex(), (long)(GetX()+fx), (long)(GetY()+fy), 0, false, number(0, 359));
  2290.  
  2291.                 char_event_info* info = AllocEventInfo<char_event_info>();
  2292.  
  2293.                 info->ch = campfire;
  2294.  
  2295.                 campfire->m_pkMiningEvent = event_create(kill_campfire_event, info, PASSES_PER_SEC(40));
  2296.  
  2297.                 item->SetCount(item->GetCount() - 1);
  2298.             }
  2299.             break;
  2300.  
  2301.         case ITEM_UNIQUE:
  2302.             {
  2303.                 switch (item->GetSubType())
  2304.                 {
  2305.                     case USE_ABILITY_UP:
  2306.                         {
  2307.                             switch (item->GetValue(0))
  2308.                             {
  2309.                                 case APPLY_MOV_SPEED:
  2310.                                     AddAffect(AFFECT_UNIQUE_ABILITY, POINT_MOV_SPEED, item->GetValue(2), AFF_MOV_SPEED_POTION, item->GetValue(1), 0, true, true);
  2311.                                     break;
  2312.  
  2313.                                 case APPLY_ATT_SPEED:
  2314.                                     AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ATT_SPEED, item->GetValue(2), AFF_ATT_SPEED_POTION, item->GetValue(1), 0, true, true);
  2315.                                     break;
  2316.  
  2317.                                 case APPLY_STR:
  2318.                                     AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ST, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2319.                                     break;
  2320.  
  2321.                                 case APPLY_DEX:
  2322.                                     AddAffect(AFFECT_UNIQUE_ABILITY, POINT_DX, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2323.                                     break;
  2324.  
  2325.                                 case APPLY_CON:
  2326.                                     AddAffect(AFFECT_UNIQUE_ABILITY, POINT_HT, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2327.                                     break;
  2328.  
  2329.                                 case APPLY_INT:
  2330.                                     AddAffect(AFFECT_UNIQUE_ABILITY, POINT_IQ, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2331.                                     break;
  2332.  
  2333.                                 case APPLY_CAST_SPEED:
  2334.                                     AddAffect(AFFECT_UNIQUE_ABILITY, POINT_CASTING_SPEED, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2335.                                     break;
  2336.  
  2337.                                 case APPLY_RESIST_MAGIC:
  2338.                                     AddAffect(AFFECT_UNIQUE_ABILITY, POINT_RESIST_MAGIC, item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2339.                                     break;
  2340.  
  2341.                                 case APPLY_ATT_GRADE_BONUS:
  2342.                                     AddAffect(AFFECT_UNIQUE_ABILITY, POINT_ATT_GRADE_BONUS,
  2343.                                             item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2344.                                     break;
  2345.  
  2346.                                 case APPLY_DEF_GRADE_BONUS:
  2347.                                     AddAffect(AFFECT_UNIQUE_ABILITY, POINT_DEF_GRADE_BONUS,
  2348.                                             item->GetValue(2), 0, item->GetValue(1), 0, true, true);
  2349.                                     break;
  2350.                             }
  2351.                         }
  2352.  
  2353.                         if (GetDungeon())
  2354.                             GetDungeon()->UsePotion(this);
  2355.  
  2356.                         if (GetWarMap())
  2357.                             GetWarMap()->UsePotion(this, item);
  2358.  
  2359.                         item->SetCount(item->GetCount() - 1);
  2360.                         break;
  2361.  
  2362.                     default:
  2363.                         {
  2364.                             if (item->GetSubType() == USE_SPECIAL)
  2365.                             {
  2366.                                 sys_log(0, "ITEM_UNIQUE: USE_SPECIAL %u", item->GetVnum());
  2367.  
  2368.                                 switch (item->GetVnum())
  2369.                                 {
  2370.                                     case 71049:
  2371.                                         if (g_bEnableBootaryCheck)
  2372.                                         {
  2373.                                             if (IS_BOTARYABLE_ZONE(GetMapIndex()) == true)
  2374.                                             {
  2375.                                                 UseSilkBotary();
  2376.                                             }
  2377.                                             else
  2378.                                             {
  2379.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개인 상점을 열 수 없는 지역입니다"));
  2380.                                             }
  2381.                                         }
  2382.                                         else
  2383.                                         {
  2384.                                             UseSilkBotary();
  2385.                                         }
  2386.                                         break;
  2387.                                 }
  2388.                             }
  2389.                             else
  2390.                             {
  2391.                                 if (!item->IsEquipped())
  2392.                                     EquipItem(item);
  2393.                                 else
  2394.                                     UnequipItem(item);
  2395.                             }
  2396.                         }
  2397.                         break;
  2398.                 }
  2399.             }
  2400.             break;
  2401.  
  2402.         case ITEM_COSTUME:
  2403.         case ITEM_WEAPON:
  2404.         case ITEM_ARMOR:
  2405.         case ITEM_ROD:
  2406.         case ITEM_RING:
  2407.         case ITEM_BELT:
  2408. // #ifdef __PET_SYSTEM__
  2409.         // case ITEM_NORMAL_PET:
  2410. // #endif
  2411.             // MINING
  2412.         case ITEM_PICK:
  2413.             // END_OF_MINING
  2414.             if (!item->IsEquipped())
  2415.                 EquipItem(item);
  2416.             else
  2417.                 UnequipItem(item);
  2418.             break;
  2419.            
  2420.            
  2421.            
  2422.            
  2423.         case ITEM_DS:
  2424.             {
  2425.                 if (!item->IsEquipped())
  2426.                     return false;
  2427.                 return DSManager::instance().PullOut(this, NPOS, item);
  2428.             break;
  2429.             }
  2430.         case ITEM_SPECIAL_DS:
  2431.             if (!item->IsEquipped())
  2432.                 EquipItem(item);
  2433.             else
  2434.                 UnequipItem(item);
  2435.             break;
  2436.  
  2437.         case ITEM_FISH:
  2438.             {
  2439.                 if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  2440.                 {
  2441.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2442.                     return false;
  2443.                 }
  2444. #ifdef ENABLE_NEWSTUFF
  2445.                 else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  2446.                 {
  2447.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2448.                     return false;
  2449.                 }
  2450. #endif
  2451.  
  2452.                 if (item->GetSubType() == FISH_ALIVE)
  2453.                     fishing::UseFish(this, item);
  2454.             }
  2455.             break;
  2456.  
  2457.         case ITEM_TREASURE_BOX:
  2458.             {
  2459.                 return false;
  2460.                
  2461.             }
  2462.             break;
  2463.  
  2464.         case ITEM_TREASURE_KEY:
  2465.             {
  2466.                 LPITEM item2;
  2467.  
  2468.                 if (!GetItem(DestCell) || !(item2 = GetItem(DestCell)))
  2469.                     return false;
  2470.  
  2471.                 if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  2472.                     return false;
  2473.  
  2474.                 if (item2->GetType() != ITEM_TREASURE_BOX)
  2475.                 {
  2476.                     ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠로 여는 물건이 아닌것 같다."));
  2477.                     return false;
  2478.                 }
  2479.  
  2480.                 if (item->GetValue(0) == item2->GetValue(0))
  2481.                 {
  2482.                     DWORD dwBoxVnum = item2->GetVnum();
  2483.                     std::vector <DWORD> dwVnums;
  2484.                     std::vector <DWORD> dwCounts;
  2485.                     std::vector <LPITEM> item_gets(0);
  2486.                     int count = 0;
  2487.  
  2488.                     if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  2489.                     {
  2490.                         ITEM_MANAGER::instance().RemoveItem(item);
  2491.                         ITEM_MANAGER::instance().RemoveItem(item2);
  2492.  
  2493.                         for (int i = 0; i < count; i++){
  2494.                             switch (dwVnums[i])
  2495.                             {
  2496.                                 case CSpecialItemGroup::GOLD:
  2497.                                     #if defined(__CHATTING_WINDOW_RENEWAL__)
  2498.                                     ChatPacket(CHAT_TYPE_MONEY_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  2499.                                     #else
  2500.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  2501.                                     #endif
  2502.                                     break;
  2503.                                 case CSpecialItemGroup::EXP:
  2504.                                     #if defined(__CHATTING_WINDOW_RENEWAL__)
  2505.                                     ChatPacket(CHAT_TYPE_EXP_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
  2506.                                     ChatPacket(CHAT_TYPE_EXP_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
  2507.                                     #else
  2508.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
  2509.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
  2510.                                     #endif
  2511.                                     break;
  2512.                                 case CSpecialItemGroup::MOB:
  2513.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  2514.                                     break;
  2515.                                 case CSpecialItemGroup::SLOW:
  2516.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 빨간 연기를 들이마시자 움직이는 속도가 느려졌습니다!"));
  2517.                                     break;
  2518.                                 case CSpecialItemGroup::DRAIN_HP:
  2519.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자가 갑자기 폭발하였습니다! 생명력이 감소했습니다."));
  2520.                                     break;
  2521.                                 case CSpecialItemGroup::POISON:
  2522.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  2523.                                     break;
  2524. #ifdef ENABLE_WOLFMAN_CHARACTER
  2525.                                 case CSpecialItemGroup::BLEEDING:
  2526.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  2527.                                     break;
  2528. #endif
  2529.                                 case CSpecialItemGroup::MOB_GROUP:
  2530.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  2531.                                     break;
  2532.                                 default:
  2533.                                     if (item_gets[i])
  2534.                                     {
  2535.                                         #if defined(__CHATTING_WINDOW_RENEWAL__)
  2536.                                         if (dwCounts[i] > 1)
  2537.                                             ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
  2538.                                         else
  2539.                                             ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
  2540.                                         #else
  2541.                                         if (dwCounts[i] > 1)
  2542.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
  2543.                                         else
  2544.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
  2545.                                         #endif
  2546.  
  2547.                                     }
  2548.                             }
  2549.                         }
  2550.                     }
  2551.                     else
  2552.                     {
  2553.                         ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠가 맞지 않는 것 같다."));
  2554.                         return false;
  2555.                     }
  2556.                 }
  2557.                 else
  2558.                 {
  2559.                     ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("열쇠가 맞지 않는 것 같다."));
  2560.                     return false;
  2561.                 }
  2562.             }
  2563.             break;
  2564.  
  2565. #ifdef ENABLE_CHEST_OPEN_RENEWAL
  2566.         case ITEM_GIFTBOX:
  2567.             {
  2568.                 int iEmptyCell;
  2569.                 const char* string;
  2570.                 if (item->IsDragonSoul())
  2571.                 {
  2572.                     iEmptyCell = GetEmptyDragonSoulInventory(item);
  2573.                     string = "There isn't enough space in your ds inventory.";
  2574.                 }
  2575.                 else
  2576.                 {
  2577.                     iEmptyCell = GetEmptyInventory(item->GetSize());
  2578.                     string = "There isn't enough space in your inventory.";
  2579.                 }
  2580.  
  2581.                 if (iEmptyCell == -1)
  2582.                 {
  2583.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT(string));
  2584.                     return false;
  2585.                 }
  2586.                
  2587.                 OpenChestItem(item);
  2588.             }
  2589.             break;
  2590. #else
  2591.         case ITEM_GIFTBOX:
  2592.             {
  2593.                 #ifdef ENABLE_NEWSTUFF
  2594.                 if (g_BoxUseTimeLimitValue && !PulseManager::Instance().IncreaseClock(GetPlayerID(), ePulse::BoxOpening, std::chrono::milliseconds(g_BoxUseTimeLimitValue)))
  2595.                 {
  2596.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 골드를 버릴 수 없습니다."));
  2597.                     return false;
  2598.                 }
  2599.                 #endif
  2600.                 DWORD dwBoxVnum = item->GetVnum();
  2601.                 std::vector <DWORD> dwVnums;
  2602.                 std::vector <DWORD> dwCounts;
  2603.                 std::vector <LPITEM> item_gets(0);
  2604.                 int count = 0;
  2605.  
  2606.                 if( dwBoxVnum > 51500 && dwBoxVnum < 52000 )   
  2607.                 {
  2608.                     if( !(this->DragonSoul_IsQualified()) )
  2609.                     {
  2610.                         ChatPacket(CHAT_TYPE_INFO,LC_TEXT("먼저 용혼석 퀘스트를 완료하셔야 합니다."));
  2611.                         return false;
  2612.                     }
  2613.                 }
  2614.  
  2615.                 if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  2616.                 {
  2617.                     item->SetCount(item->GetCount()-1);
  2618.  
  2619.                     for (int i = 0; i < count; i++){
  2620.                         switch (dwVnums[i])
  2621.                         {
  2622.                         case CSpecialItemGroup::GOLD:
  2623.                             #if defined(__CHATTING_WINDOW_RENEWAL__)
  2624.                             ChatPacket(CHAT_TYPE_MONEY_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  2625.                             #else
  2626.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  2627.                             #endif
  2628.                             break;
  2629.                         case CSpecialItemGroup::EXP:
  2630.                             #if defined(__CHATTING_WINDOW_RENEWAL__)
  2631.                             ChatPacket(CHAT_TYPE_EXP_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
  2632.                             ChatPacket(CHAT_TYPE_EXP_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
  2633.                             #else
  2634.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
  2635.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
  2636.                             #endif
  2637.                             break;
  2638.                         case CSpecialItemGroup::MOB:
  2639.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  2640.                             break;
  2641.                         case CSpecialItemGroup::SLOW:
  2642.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 빨간 연기를 들이마시자 움직이는 속도가 느려졌습니다!"));
  2643.                             break;
  2644.                         case CSpecialItemGroup::DRAIN_HP:
  2645.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자가 갑자기 폭발하였습니다! 생명력이 감소했습니다."));
  2646.                             break;
  2647.                         case CSpecialItemGroup::POISON:
  2648.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  2649.                             break;
  2650. #ifdef ENABLE_WOLFMAN_CHARACTER
  2651.                         case CSpecialItemGroup::BLEEDING:
  2652.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  2653.                             break;
  2654. #endif
  2655.                         case CSpecialItemGroup::MOB_GROUP:
  2656.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  2657.                             break;
  2658.                         default:
  2659.                             if (item_gets[i])
  2660.                             {
  2661.                                 #if defined(__CHATTING_WINDOW_RENEWAL__)
  2662.                                 if (dwCounts[i] > 1)
  2663.                                     ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
  2664.                                 else
  2665.                                     ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
  2666.                                 #else
  2667.                                 if (dwCounts[i] > 1)
  2668.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
  2669.                                 else
  2670.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
  2671.                                 #endif
  2672.                             }
  2673.                         }
  2674.                     }
  2675.                 }
  2676.                 else
  2677.                 {
  2678.                     ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("아무것도 얻을 수 없었습니다."));
  2679.                     return false;
  2680.                 }
  2681.             }
  2682.             break;
  2683. #endif
  2684.  
  2685.         case ITEM_SKILLFORGET:
  2686.             {
  2687.                 if (!item->GetSocket(0))
  2688.                 {
  2689.                     ITEM_MANAGER::instance().RemoveItem(item);
  2690.                     return false;
  2691.                 }
  2692.  
  2693.                 DWORD dwVnum = item->GetSocket(0);
  2694.  
  2695.                 if (SkillLevelDown(dwVnum))
  2696.                 {
  2697.                     ITEM_MANAGER::instance().RemoveItem(item);
  2698.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("스킬 레벨을 내리는데 성공하였습니다."));
  2699.                 }
  2700.                 else
  2701.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("스킬 레벨을 내릴 수 없습니다."));
  2702.             }
  2703.             break;
  2704.  
  2705.         case ITEM_SKILLBOOK:
  2706.             {
  2707.                 if (IsPolymorphed())
  2708.                 {
  2709.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  2710.                     return false;
  2711.                 }
  2712.  
  2713.                 DWORD dwVnum = 0;
  2714.  
  2715.                 if (item->GetVnum() == 50300)
  2716.                 {
  2717.                     dwVnum = item->GetSocket(0);
  2718.                 }
  2719.                 else
  2720.                 {
  2721.                    
  2722.                     dwVnum = item->GetValue(0);
  2723.                 }
  2724.  
  2725.                 if (0 == dwVnum)
  2726.                 {
  2727.                     ITEM_MANAGER::instance().RemoveItem(item);
  2728.  
  2729.                     return false;
  2730.                 }
  2731.  
  2732.                 if (true == LearnSkillByBook(dwVnum))
  2733.                 {
  2734. #ifdef ENABLE_BOOKS_STACKFIX
  2735.                     item->SetCount(item->GetCount() - 1);
  2736. #else
  2737.                     ITEM_MANAGER::instance().RemoveItem(item);
  2738. #endif
  2739.  
  2740.                     int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  2741.  
  2742.                     if (distribution_test_server)
  2743.                         iReadDelay /= 3;
  2744.  
  2745.                     SetSkillNextReadTime(dwVnum, get_global_time() + iReadDelay);
  2746.                 }
  2747.             }
  2748.             break;
  2749.  
  2750.         case ITEM_USE:
  2751.             {
  2752.                 if (item->GetVnum() > 50800 && item->GetVnum() <= 50820)
  2753.                 {
  2754.                     if (test_server)
  2755.                         sys_log (0, "ADD addtional effect : vnum(%d) subtype(%d)", item->GetOriginalVnum(), item->GetSubType());
  2756.  
  2757.                     int affect_type = AFFECT_EXP_BONUS_EURO_FREE;
  2758.                     int apply_type = aApplyInfo[item->GetValue(0)].bPointType;
  2759.                     int apply_value = item->GetValue(2);
  2760.                     int apply_duration = item->GetValue(1);
  2761.  
  2762.                     switch (item->GetSubType())
  2763.                     {
  2764.                         case USE_ABILITY_UP:
  2765. #ifdef ENABLE_YMIR_AFFECT_FIX
  2766.                             if ((CheckTimeUsed(item) == false)) {   return false;   }
  2767. #endif
  2768.                             if (FindAffect(affect_type, apply_type))
  2769.                             {
  2770.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  2771.                                 return false;
  2772.                             }
  2773.  
  2774.                             {
  2775.                                 switch (item->GetValue(0))
  2776.                                 {
  2777.                                     case APPLY_MOV_SPEED:
  2778.                                         AddAffect(affect_type, apply_type, apply_value, AFF_MOV_SPEED_POTION, apply_duration, 0, true, true);
  2779.                                         break;
  2780.  
  2781.                                     case APPLY_ATT_SPEED:
  2782.                                         AddAffect(affect_type, apply_type, apply_value, AFF_ATT_SPEED_POTION, apply_duration, 0, true, true);
  2783.                                         break;
  2784.  
  2785.                                     case APPLY_STR:
  2786.                                     case APPLY_DEX:
  2787.                                     case APPLY_CON:
  2788.                                     case APPLY_INT:
  2789.                                     case APPLY_CAST_SPEED:
  2790.                                     case APPLY_RESIST_MAGIC:
  2791.                                     case APPLY_ATT_GRADE_BONUS:
  2792.                                     case APPLY_DEF_GRADE_BONUS:
  2793.                                         AddAffect(affect_type, apply_type, apply_value, 0, apply_duration, 0, true, true);
  2794.                                         break;
  2795.                                 }
  2796.                             }
  2797.  
  2798.                             if (GetDungeon())
  2799.                                 GetDungeon()->UsePotion(this);
  2800.  
  2801.                             if (GetWarMap())
  2802.                                 GetWarMap()->UsePotion(this, item);
  2803.  
  2804.                             item->SetCount(item->GetCount() - 1);
  2805.                             break;
  2806.  
  2807.                     case USE_POTION_NODELAY:
  2808.                         {
  2809.                             if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  2810.                             {
  2811.                                 if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
  2812.                                 {
  2813.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  2814.                                     return false;
  2815.                                 }
  2816.  
  2817.                                 switch (item->GetVnum())
  2818.                                 {
  2819.                                     case 70020 :
  2820.                                     case 71018 :
  2821.                                     case 71019 :
  2822.                                     case 71020 :
  2823.                                         if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
  2824.                                         {
  2825.                                             if (m_nPotionLimit <= 0)
  2826.                                             {
  2827.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용 제한량을 초과하였습니다."));
  2828.                                                 return false;
  2829.                                             }
  2830.                                         }
  2831.                                         break;
  2832.  
  2833.                                     default :
  2834.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  2835.                                         return false;
  2836.                                         break;
  2837.                                 }
  2838.                             }
  2839. #ifdef ENABLE_NEWSTUFF
  2840.                             else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  2841.                             {
  2842.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2843.                                 return false;
  2844.                             }
  2845. #endif
  2846.  
  2847.                             bool used = false;
  2848.  
  2849.                             if (item->GetValue(0) != 0)
  2850.                             {
  2851.                                 if (GetHP() < GetMaxHP())
  2852.                                 {
  2853.                                     PointChange(POINT_HP, item->GetValue(0) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  2854.                                     EffectPacket(SE_HPUP_RED);
  2855.                                     used = TRUE;
  2856.                                 }
  2857.                             }
  2858.  
  2859.                             if (item->GetValue(1) != 0)
  2860.                             {
  2861.                                 if (GetSP() < GetMaxSP())
  2862.                                 {
  2863.                                     PointChange(POINT_SP, item->GetValue(1) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  2864.                                     EffectPacket(SE_SPUP_BLUE);
  2865.                                     used = TRUE;
  2866.                                 }
  2867.                             }
  2868.  
  2869.                             if (item->GetValue(3) != 0)
  2870.                             {
  2871.                                 if (GetHP() < GetMaxHP())
  2872.                                 {
  2873.                                     PointChange(POINT_HP, item->GetValue(3) * GetMaxHP() / 100);
  2874.                                     EffectPacket(SE_HPUP_RED);
  2875.                                     used = TRUE;
  2876.                                 }
  2877.                             }
  2878.  
  2879.                             if (item->GetValue(4) != 0)
  2880.                             {
  2881.                                 if (GetSP() < GetMaxSP())
  2882.                                 {
  2883.                                     PointChange(POINT_SP, item->GetValue(4) * GetMaxSP() / 100);
  2884.                                     EffectPacket(SE_SPUP_BLUE);
  2885.                                     used = TRUE;
  2886.                                 }
  2887.                             }
  2888.  
  2889.                             if (used)
  2890.                             {
  2891.                                 if (item->GetVnum() == 50085 || item->GetVnum() == 50086)
  2892.                                 {
  2893.                                     if (test_server)
  2894.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("월병 또는 종자 를 사용하였습니다"));
  2895.                                     SetUseSeedOrMoonBottleTime();
  2896.                                 }
  2897.                                 if (GetDungeon())
  2898.                                     GetDungeon()->UsePotion(this);
  2899.  
  2900.                                 if (GetWarMap())
  2901.                                     GetWarMap()->UsePotion(this, item);
  2902.  
  2903.                                 m_nPotionLimit--;
  2904.  
  2905.                                 //RESTRICT_USE_SEED_OR_MOONBOTTLE
  2906.                                 item->SetCount(item->GetCount() - 1);
  2907.                                 //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
  2908.                             }
  2909.                         }
  2910.                         break;
  2911.                     }
  2912.  
  2913.                     return true;
  2914.                 }
  2915.  
  2916.  
  2917.                 if (item->GetVnum() >= 27863 && item->GetVnum() <= 27883)
  2918.                 {
  2919.                     if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  2920.                     {
  2921.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2922.                         return false;
  2923.                     }
  2924. #ifdef ENABLE_NEWSTUFF
  2925.                     else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  2926.                     {
  2927.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  2928.                         return false;
  2929.                     }
  2930. #endif
  2931.                 }
  2932.  
  2933.                 if (test_server)
  2934.                 {
  2935.                      sys_log (0, "USE_ITEM %s Type %d SubType %d vnum %d", item->GetName(), item->GetType(), item->GetSubType(), item->GetOriginalVnum());
  2936.                 }
  2937.  
  2938.                 switch (item->GetSubType())
  2939.                 {
  2940. #ifdef ENABLE_COSTUME_TIME_EXTENDER
  2941.                     case USE_EXTEND_TIME:
  2942.                         {
  2943.                             LPITEM item2;
  2944.  
  2945.                             if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  2946.                                 return false;
  2947.  
  2948.                             if (item2->IsExchanging() || item2->IsEquipped())
  2949.                             {
  2950.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("costume_time_cannot_use"));
  2951.                                 return false;
  2952.                             }
  2953.  
  2954.                             switch (item2->GetSubType())
  2955.                             {
  2956.                                 case COSTUME_BODY:
  2957.                                 case COSTUME_HAIR:
  2958.                                 case COSTUME_WEAPON:
  2959.                                 {
  2960.                                     item2->SetSocket(0, item2->GetSocket(0) + item->GetValue(0));
  2961.                                     item->SetCount(item->GetCount() - 1);
  2962.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("costume_time_added"));
  2963.                                     break;
  2964.                                 }
  2965.                                 default:
  2966.                                 {
  2967.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("costume_time_wrong_item"));
  2968.                                     break;
  2969.                                 }
  2970.                             }
  2971.                         }
  2972.                         break;
  2973. #endif
  2974.                     case USE_TIME_CHARGE_PER:
  2975.                         {
  2976.                             LPITEM pDestItem = GetItem(DestCell);
  2977.                             if (NULL == pDestItem)
  2978.                             {
  2979.                                 return false;
  2980.                             }
  2981.                            
  2982.                             if (pDestItem->IsDragonSoul())
  2983.                             {
  2984.                                 int ret;
  2985.                                 char buf[128];
  2986.                                 if (item->GetVnum() == DRAGON_HEART_VNUM)
  2987.                                 {
  2988.                                     ret = pDestItem->GiveMoreTime_Per((float)item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
  2989.                                 }
  2990.                                 else
  2991.                                 {
  2992.                                     ret = pDestItem->GiveMoreTime_Per((float)item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  2993.                                 }
  2994.                                 if (ret > 0)
  2995.                                 {
  2996.                                     if (item->GetVnum() == DRAGON_HEART_VNUM)
  2997.                                     {
  2998.                                         sprintf(buf, "Inc %ds by item{VN:%d SOC%d:%ld}", ret, item->GetVnum(), ITEM_SOCKET_CHARGING_AMOUNT_IDX, item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
  2999.                                     }
  3000.                                     else
  3001.                                     {
  3002.                                         sprintf(buf, "Inc %ds by item{VN:%d VAL%d:%ld}", ret, item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  3003.                                     }
  3004.  
  3005.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d초 만큼 충전되었습니다."), ret);
  3006.                                     item->SetCount(item->GetCount() - 1);
  3007.                                     LogManager::instance().ItemLog(this, item, "DS_CHARGING_SUCCESS", buf);
  3008.                                     return true;
  3009.                                 }
  3010.                                 else
  3011.                                 {
  3012.                                     if (item->GetVnum() == DRAGON_HEART_VNUM)
  3013.                                     {
  3014.                                         sprintf(buf, "No change by item{VN:%d SOC%d:%ld}", item->GetVnum(), ITEM_SOCKET_CHARGING_AMOUNT_IDX, item->GetSocket(ITEM_SOCKET_CHARGING_AMOUNT_IDX));
  3015.                                     }
  3016.                                     else
  3017.                                     {
  3018.                                         sprintf(buf, "No change by item{VN:%d VAL%d:%ld}", item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  3019.                                     }
  3020.  
  3021.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("충전할 수 없습니다."));
  3022.                                     LogManager::instance().ItemLog(this, item, "DS_CHARGING_FAILED", buf);
  3023.                                     return false;
  3024.                                 }
  3025.                             }
  3026.                             else
  3027.                                 return false;
  3028.                         }
  3029.                         break;
  3030.                     case USE_TIME_CHARGE_FIX:
  3031.                         {
  3032.                             LPITEM pDestItem = GetItem(DestCell);
  3033.                             if (NULL == pDestItem)
  3034.                             {
  3035.                                 return false;
  3036.                             }
  3037.                            
  3038.                             if (pDestItem->IsDragonSoul())
  3039.                             {
  3040.                                 int ret = pDestItem->GiveMoreTime_Fix(item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  3041.                                 char buf[128];
  3042.                                 if (ret)
  3043.                                 {
  3044.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d초 만큼 충전되었습니다."), ret);
  3045.                                     sprintf(buf, "Increase %ds by item{VN:%d VAL%d:%ld}", ret, item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  3046.                                     LogManager::instance().ItemLog(this, item, "DS_CHARGING_SUCCESS", buf);
  3047.                                     item->SetCount(item->GetCount() - 1);
  3048.                                     return true;
  3049.                                 }
  3050.                                 else
  3051.                                 {
  3052.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("충전할 수 없습니다."));
  3053.                                     sprintf(buf, "No change by item{VN:%d VAL%d:%ld}", item->GetVnum(), ITEM_VALUE_CHARGING_AMOUNT_IDX, item->GetValue(ITEM_VALUE_CHARGING_AMOUNT_IDX));
  3054.                                     LogManager::instance().ItemLog(this, item, "DS_CHARGING_FAILED", buf);
  3055.                                     return false;
  3056.                                 }
  3057.                             }
  3058.                             else
  3059.                                 return false;
  3060.                         }
  3061.                         break;
  3062.                     case USE_SPECIAL:
  3063.                         switch (item->GetVnum())
  3064.                         {
  3065. #if defined(__BL_TRANSMUTATION__)
  3066.                             case TRANSMUTATION_REVERSAL:
  3067.                                 LPITEM item2;
  3068.                                 if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  3069.                                     return false;
  3070.  
  3071.                                 if (item2->IsExchanging())
  3072.                                     return false;
  3073.                                
  3074.                                 if (item2->isLocked())
  3075.                                     return false;
  3076.  
  3077.                                 if (item2->GetTransmutationVnum() == 0)
  3078.                                     return false;
  3079.  
  3080.                                 item2->SetTransmutationVnum(0);
  3081.                                 item2->UpdatePacket();
  3082.  
  3083.                                 item->SetCount(item->GetCount() - 1);
  3084.                                 break;
  3085. #endif
  3086.                             case ITEM_NOG_POCKET:
  3087.                                 {
  3088.                                     /*
  3089.                                     란주능력치 : item_proto value 의미
  3090.                                         이동속도  value 1
  3091.                                         공격력     value 2
  3092.                                         경험치   value 3
  3093.                                         지속시간  value 0 (단위 초)
  3094.  
  3095.                                     */
  3096.                                     if (FindAffect(AFFECT_NOG_ABILITY))
  3097.                                     {
  3098.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  3099.                                         return false;
  3100.                                     }
  3101.                                     long time = item->GetValue(0);
  3102.                                     long moveSpeedPer   = item->GetValue(1);
  3103.                                     long attPer = item->GetValue(2);
  3104.                                     long expPer         = item->GetValue(3);
  3105.                                     AddAffect(AFFECT_NOG_ABILITY, POINT_MOV_SPEED, moveSpeedPer, AFF_MOV_SPEED_POTION, time, 0, true, true);
  3106.                                     AddAffect(AFFECT_NOG_ABILITY, POINT_MALL_ATTBONUS, attPer, AFF_NONE, time, 0, true, true);
  3107.                                     AddAffect(AFFECT_NOG_ABILITY, POINT_MALL_EXPBONUS, expPer, AFF_NONE, time, 0, true, true);
  3108.                                     item->SetCount(item->GetCount() - 1);
  3109.                                 }
  3110.                                 break;
  3111.  
  3112.                            
  3113.                             case ITEM_RAMADAN_CANDY:
  3114.                                 {
  3115.                                     /*
  3116.                                     사탕능력치 : item_proto value 의미
  3117.                                         이동속도  value 1
  3118.                                         공격력     value 2
  3119.                                         경험치   value 3
  3120.                                         지속시간  value 0 (단위 초)
  3121.  
  3122.                                     */
  3123.                                     // @fixme147 BEGIN
  3124.                                     if (FindAffect(AFFECT_RAMADAN_ABILITY))
  3125.                                     {
  3126.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  3127.                                         return false;
  3128.                                     }
  3129.                                     // @fixme147 END
  3130.                                     long time = item->GetValue(0);
  3131.                                     long moveSpeedPer   = item->GetValue(1);
  3132.                                     long attPer = item->GetValue(2);
  3133.                                     long expPer         = item->GetValue(3);
  3134.                                     AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MOV_SPEED, moveSpeedPer, AFF_MOV_SPEED_POTION, time, 0, true, true);
  3135.                                     AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MALL_ATTBONUS, attPer, AFF_NONE, time, 0, true, true);
  3136.                                     AddAffect(AFFECT_RAMADAN_ABILITY, POINT_MALL_EXPBONUS, expPer, AFF_NONE, time, 0, true, true);
  3137.                                     item->SetCount(item->GetCount() - 1);
  3138.                                 }
  3139.                                 break;
  3140.                             case ITEM_MARRIAGE_RING:
  3141.                                 {
  3142.                                     marriage::TMarriage* pMarriage = marriage::CManager::instance().Get(GetPlayerID());
  3143.                                     if (pMarriage)
  3144.                                     {
  3145.                                         if (pMarriage->ch1 != NULL)
  3146.                                         {
  3147.                                             if (CArenaManager::instance().IsArenaMap(pMarriage->ch1->GetMapIndex()) == true)
  3148.                                             {
  3149.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  3150.                                                 break;
  3151.                                             }
  3152.                                         }
  3153.  
  3154.                                         if (pMarriage->ch2 != NULL)
  3155.                                         {
  3156.                                             if (CArenaManager::instance().IsArenaMap(pMarriage->ch2->GetMapIndex()) == true)
  3157.                                             {
  3158.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  3159.                                                 break;
  3160.                                             }
  3161.                                         }
  3162.  
  3163.                                         int consumeSP = CalculateConsumeSP(this);
  3164.  
  3165.                                         if (consumeSP < 0)
  3166.                                             return false;
  3167.  
  3168.                                         PointChange(POINT_SP, -consumeSP, false);
  3169.  
  3170.                                         WarpToPID(pMarriage->GetOther(GetPlayerID()));
  3171.                                     }
  3172.                                     else
  3173.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("결혼 상태가 아니면 결혼반지를 사용할 수 없습니다."));
  3174.                                 }
  3175.                                 break;
  3176.  
  3177.                                
  3178.                             case UNIQUE_ITEM_CAPE_OF_COURAGE:
  3179.                                
  3180.                             case 70057:
  3181.                             case REWARD_BOX_UNIQUE_ITEM_CAPE_OF_COURAGE:
  3182.                                 AggregateMonster();
  3183.                                 item->SetCount(item->GetCount()-1);
  3184.                                 break;
  3185.  
  3186. #ifdef ENABLE_ACCE_SYSTEM
  3187.                             case ACCE_REVERSAL_VNUM_1:
  3188.                             case ACCE_REVERSAL_VNUM_2:
  3189.                             {
  3190.                                 LPITEM item2;
  3191.                                 if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  3192.                                     return false;
  3193.  
  3194.                                 if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  3195.                                     return false;
  3196.  
  3197.                                 if (!CleanAcceAttr(item, item2))
  3198.                                     return false;
  3199.                                 item->SetCount(item->GetCount()-1);
  3200.                                 break;
  3201.                             }
  3202. #endif
  3203.  
  3204.                             case UNIQUE_ITEM_WHITE_FLAG:
  3205.                                 ForgetMyAttacker();
  3206.                                 item->SetCount(item->GetCount()-1);
  3207.                                 break;
  3208.  
  3209.                             case UNIQUE_ITEM_TREASURE_BOX:
  3210.                                 break;
  3211.  
  3212.                             case 30093:
  3213.                             case 30094:
  3214.                             case 30095:
  3215.                             case 30096:
  3216.                                
  3217.                                 {
  3218.                                     const int MAX_BAG_INFO = 26;
  3219.                                     static struct LuckyBagInfo
  3220.                                     {
  3221.                                         DWORD count;
  3222.                                         int prob;
  3223.                                         DWORD vnum;
  3224.                                     } b1[MAX_BAG_INFO] =
  3225.                                     {
  3226.                                         { 1000, 302,    1 },
  3227.                                         { 10,   150,    27002 },
  3228.                                         { 10,   75, 27003 },
  3229.                                         { 10,   100,    27005 },
  3230.                                         { 10,   50, 27006 },
  3231.                                         { 10,   80, 27001 },
  3232.                                         { 10,   50, 27002 },
  3233.                                         { 10,   80, 27004 },
  3234.                                         { 10,   50, 27005 },
  3235.                                         { 1,    10, 50300 },
  3236.                                         { 1,    6,  92 },
  3237.                                         { 1,    2,  132 },
  3238.                                         { 1,    6,  1052 },
  3239.                                         { 1,    2,  1092 },
  3240.                                         { 1,    6,  2082 },
  3241.                                         { 1,    2,  2122 },
  3242.                                         { 1,    6,  3082 },
  3243.                                         { 1,    2,  3122 },
  3244.                                         { 1,    6,  5052 },
  3245.                                         { 1,    2,  5082 },
  3246.                                         { 1,    6,  7082 },
  3247.                                         { 1,    2,  7122 },
  3248.                                         { 1,    1,  11282 },
  3249.                                         { 1,    1,  11482 },
  3250.                                         { 1,    1,  11682 },
  3251.                                         { 1,    1,  11882 },
  3252.                                     };
  3253.  
  3254.                                     LuckyBagInfo * bi = NULL;
  3255.                                     bi = b1;
  3256.  
  3257.                                     int pct = number(1, 1000);
  3258.  
  3259.                                     int i;
  3260.                                     for (i=0;i<MAX_BAG_INFO;i++)
  3261.                                     {
  3262.                                         if (pct <= bi[i].prob)
  3263.                                             break;
  3264.                                         pct -= bi[i].prob;
  3265.                                     }
  3266.                                     if (i>=MAX_BAG_INFO)
  3267.                                         return false;
  3268.  
  3269.                                     if (bi[i].vnum == 50300)
  3270.                                     {
  3271.                                        
  3272.                                         GiveRandomSkillBook();
  3273.                                     }
  3274.                                     else if (bi[i].vnum == 1)
  3275.                                     {
  3276.                                         PointChange(POINT_GOLD, 1000, true);
  3277.                                     }
  3278.                                     else
  3279.                                     {
  3280.                                         AutoGiveItem(bi[i].vnum, bi[i].count);
  3281.                                     }
  3282.                                     ITEM_MANAGER::instance().RemoveItem(item);
  3283.                                 }
  3284.                                 break;
  3285.  
  3286.                             case 50004:
  3287.                                 {
  3288.                                     if (item->GetSocket(0))
  3289.                                     {
  3290.                                         item->SetSocket(0, item->GetSocket(0) + 1);
  3291.                                     }
  3292.                                     else
  3293.                                     {
  3294.                                        
  3295.                                         int iMapIndex = GetMapIndex();
  3296.  
  3297.                                         PIXEL_POSITION pos;
  3298.  
  3299.                                         if (SECTREE_MANAGER::instance().GetRandomLocation(iMapIndex, pos, 700))
  3300.                                         {
  3301.                                             item->SetSocket(0, 1);
  3302.                                             item->SetSocket(1, pos.x);
  3303.                                             item->SetSocket(2, pos.y);
  3304.                                         }
  3305.                                         else
  3306.                                         {
  3307.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 곳에선 이벤트용 감지기가 동작하지 않는것 같습니다."));
  3308.                                             return false;
  3309.                                         }
  3310.                                     }
  3311.  
  3312.                                     int dist = 0;
  3313.                                     float distance = (DISTANCE_SQRT(GetX()-item->GetSocket(1), GetY()-item->GetSocket(2)));
  3314.  
  3315.                                     if (distance < 1000.0f)
  3316.                                     {
  3317.                                        
  3318.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이벤트용 감지기가 신비로운 빛을 내며 사라집니다."));
  3319.  
  3320.                                        
  3321.                                         struct TEventStoneInfo
  3322.                                         {
  3323.                                             DWORD dwVnum;
  3324.                                             int count;
  3325.                                             int prob;
  3326.                                         };
  3327.                                         const int EVENT_STONE_MAX_INFO = 15;
  3328.                                         TEventStoneInfo info_10[EVENT_STONE_MAX_INFO] =
  3329.                                         {
  3330.                                             { 27001, 10,  8 },
  3331.                                             { 27004, 10,  6 },
  3332.                                             { 27002, 10, 12 },
  3333.                                             { 27005, 10, 12 },
  3334.                                             { 27100,  1,  9 },
  3335.                                             { 27103,  1,  9 },
  3336.                                             { 27101,  1, 10 },
  3337.                                             { 27104,  1, 10 },
  3338.                                             { 27999,  1, 12 },
  3339.  
  3340.                                             { 25040,  1,  4 },
  3341.  
  3342.                                             { 27410,  1,  0 },
  3343.                                             { 27600,  1,  0 },
  3344.                                             { 25100,  1,  0 },
  3345.  
  3346.                                             { 50001,  1,  0 },
  3347.                                             { 50003,  1,  1 },
  3348.                                         };
  3349.                                         TEventStoneInfo info_7[EVENT_STONE_MAX_INFO] =
  3350.                                         {
  3351.                                             { 27001, 10,  1 },
  3352.                                             { 27004, 10,  1 },
  3353.                                             { 27004, 10,  9 },
  3354.                                             { 27005, 10,  9 },
  3355.                                             { 27100,  1,  5 },
  3356.                                             { 27103,  1,  5 },
  3357.                                             { 27101,  1, 10 },
  3358.                                             { 27104,  1, 10 },
  3359.                                             { 27999,  1, 14 },
  3360.  
  3361.                                             { 25040,  1,  5 },
  3362.  
  3363.                                             { 27410,  1,  5 },
  3364.                                             { 27600,  1,  5 },
  3365.                                             { 25100,  1,  5 },
  3366.  
  3367.                                             { 50001,  1,  0 },
  3368.                                             { 50003,  1,  5 },
  3369.  
  3370.                                         };
  3371.                                         TEventStoneInfo info_4[EVENT_STONE_MAX_INFO] =
  3372.                                         {
  3373.                                             { 27001, 10,  0 },
  3374.                                             { 27004, 10,  0 },
  3375.                                             { 27002, 10,  0 },
  3376.                                             { 27005, 10,  0 },
  3377.                                             { 27100,  1,  0 },
  3378.                                             { 27103,  1,  0 },
  3379.                                             { 27101,  1,  0 },
  3380.                                             { 27104,  1,  0 },
  3381.                                             { 27999,  1, 25 },
  3382.  
  3383.                                             { 25040,  1,  0 },
  3384.  
  3385.                                             { 27410,  1,  0 },
  3386.                                             { 27600,  1,  0 },
  3387.                                             { 25100,  1, 15 },
  3388.  
  3389.                                             { 50001,  1, 10 },
  3390.                                             { 50003,  1, 50 },
  3391.  
  3392.                                         };
  3393.  
  3394.                                         {
  3395.                                             TEventStoneInfo* info;
  3396.                                             if (item->GetSocket(0) <= 4)
  3397.                                                 info = info_4;
  3398.                                             else if (item->GetSocket(0) <= 7)
  3399.                                                 info = info_7;
  3400.                                             else
  3401.                                                 info = info_10;
  3402.  
  3403.                                             int prob = number(1, 100);
  3404.  
  3405.                                             for (int i = 0; i < EVENT_STONE_MAX_INFO; ++i)
  3406.                                             {
  3407.                                                 if (!info[i].prob)
  3408.                                                     continue;
  3409.  
  3410.                                                 if (prob <= info[i].prob)
  3411.                                                 {
  3412.                                                     if (info[i].dwVnum == 50001)
  3413.                                                     {
  3414.                                                         DWORD * pdw = M2_NEW DWORD[2];
  3415.  
  3416.                                                         pdw[0] = info[i].dwVnum;
  3417.                                                         pdw[1] = info[i].count;
  3418.  
  3419.                                                        
  3420.                                                         DBManager::instance().ReturnQuery(QID_LOTTO, GetPlayerID(), pdw,
  3421.                                                                 "INSERT INTO lotto_list VALUES(0, 'server%s', %u, NOW())",
  3422.                                                                 get_table_postfix(), GetPlayerID());
  3423.                                                     }
  3424.                                                     else
  3425.                                                         AutoGiveItem(info[i].dwVnum, info[i].count);
  3426.  
  3427.                                                     break;
  3428.                                                 }
  3429.                                                 prob -= info[i].prob;
  3430.                                             }
  3431.                                         }
  3432.  
  3433.                                         char chatbuf[CHAT_MAX_LEN + 1];
  3434.                                         int len = snprintf(chatbuf, sizeof(chatbuf), "StoneDetect %u 0 0", (DWORD)GetVID());
  3435.  
  3436.                                         if (len < 0 || len >= (int) sizeof(chatbuf))
  3437.                                             len = sizeof(chatbuf) - 1;
  3438.  
  3439.                                         ++len;  
  3440.  
  3441.                                         TPacketGCChat pack_chat;
  3442.                                         pack_chat.header    = HEADER_GC_CHAT;
  3443.                                         pack_chat.size      = sizeof(TPacketGCChat) + len;
  3444.                                         pack_chat.type      = CHAT_TYPE_COMMAND;
  3445.                                         pack_chat.id        = 0;
  3446.                                         pack_chat.bEmpire   = GetDesc()->GetEmpire();
  3447.                                         //pack_chat.id  = vid;
  3448.  
  3449.                                         TEMP_BUFFER buf;
  3450.                                         buf.write(&pack_chat, sizeof(TPacketGCChat));
  3451.                                         buf.write(chatbuf, len);
  3452.  
  3453.                                         PacketAround(buf.read_peek(), buf.size());
  3454.  
  3455.                                         ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (DETECT_EVENT_STONE) 1");
  3456.                                         return true;
  3457.                                     }
  3458.                                     else if (distance < 20000)
  3459.                                         dist = 1;
  3460.                                     else if (distance < 70000)
  3461.                                         dist = 2;
  3462.                                     else
  3463.                                         dist = 3;
  3464.  
  3465.                                    
  3466.                                     const int STONE_DETECT_MAX_TRY = 10;
  3467.                                     if (item->GetSocket(0) >= STONE_DETECT_MAX_TRY)
  3468.                                     {
  3469.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이벤트용 감지기가 흔적도 없이 사라집니다."));
  3470.                                         ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (DETECT_EVENT_STONE) 0");
  3471.                                         AutoGiveItem(27002);
  3472.                                         return true;
  3473.                                     }
  3474.  
  3475.                                     if (dist)
  3476.                                     {
  3477.                                         char chatbuf[CHAT_MAX_LEN + 1];
  3478.                                         int len = snprintf(chatbuf, sizeof(chatbuf),
  3479.                                                 "StoneDetect %u %d %d",
  3480.                                                 (DWORD)GetVID(), dist, (int)GetDegreeFromPositionXY(GetX(), item->GetSocket(2), item->GetSocket(1), GetY()));
  3481.  
  3482.                                         if (len < 0 || len >= (int) sizeof(chatbuf))
  3483.                                             len = sizeof(chatbuf) - 1;
  3484.  
  3485.                                         ++len;  
  3486.  
  3487.                                         TPacketGCChat pack_chat;
  3488.                                         pack_chat.header    = HEADER_GC_CHAT;
  3489.                                         pack_chat.size      = sizeof(TPacketGCChat) + len;
  3490.                                         pack_chat.type      = CHAT_TYPE_COMMAND;
  3491.                                         pack_chat.id        = 0;
  3492.                                         pack_chat.bEmpire   = GetDesc()->GetEmpire();
  3493.                                         //pack_chat.id      = vid;
  3494.  
  3495.                                         TEMP_BUFFER buf;
  3496.                                         buf.write(&pack_chat, sizeof(TPacketGCChat));
  3497.                                         buf.write(chatbuf, len);
  3498.  
  3499.                                         PacketAround(buf.read_peek(), buf.size());
  3500.                                     }
  3501.  
  3502.                                 }
  3503.                                 break;
  3504.  
  3505.                             case 27989:
  3506.                             case 76006:
  3507.                                 {
  3508.                                     LPSECTREE_MAP pMap = SECTREE_MANAGER::instance().GetMap(GetMapIndex());
  3509.  
  3510.                                     if (pMap != NULL)
  3511.                                     {
  3512.                                         item->SetSocket(0, item->GetSocket(0) + 1);
  3513.  
  3514.                                         FFindStone f;
  3515.  
  3516.                                         // <Factor> SECTREE::for_each -> SECTREE::for_each_entity
  3517.                                         pMap->for_each(f);
  3518.  
  3519.                                         if (f.m_mapStone.size() > 0)
  3520.                                         {
  3521.                                             std::map<DWORD, LPCHARACTER>::iterator stone = f.m_mapStone.begin();
  3522.  
  3523.                                             DWORD max = UINT_MAX;
  3524.                                             LPCHARACTER pTarget = stone->second;
  3525.  
  3526.                                             while (stone != f.m_mapStone.end())
  3527.                                             {
  3528.                                                 DWORD dist = (DWORD)DISTANCE_SQRT(GetX()-stone->second->GetX(), GetY()-stone->second->GetY());
  3529.  
  3530.                                                 if (dist != 0 && max > dist)
  3531.                                                 {
  3532.                                                     max = dist;
  3533.                                                     pTarget = stone->second;
  3534.                                                 }
  3535.                                                 stone++;
  3536.                                             }
  3537.  
  3538.                                             if (pTarget != NULL)
  3539.                                             {
  3540.                                                 int val = 3;
  3541.  
  3542.                                                 if (max < 10000) val = 2;
  3543.                                                 else if (max < 70000) val = 1;
  3544.  
  3545.                                                 ChatPacket(CHAT_TYPE_COMMAND, "StoneDetect %u %d %d", (DWORD)GetVID(), val,
  3546.                                                         (int)GetDegreeFromPositionXY(GetX(), pTarget->GetY(), pTarget->GetX(), GetY()));
  3547.                                             }
  3548.                                             else
  3549.                                             {
  3550.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("감지기를 작용하였으나 감지되는 영석이 없습니다."));
  3551.                                             }
  3552.                                         }
  3553.                                         else
  3554.                                         {
  3555.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("감지기를 작용하였으나 감지되는 영석이 없습니다."));
  3556.                                         }
  3557.  
  3558.                                         if (item->GetSocket(0) >= 6)
  3559.                                         {
  3560.                                             ChatPacket(CHAT_TYPE_COMMAND, "StoneDetect %u 0 0", (DWORD)GetVID());
  3561.                                             ITEM_MANAGER::instance().RemoveItem(item);
  3562.                                         }
  3563.                                     }
  3564.                                     break;
  3565.                                 }
  3566.                                 break;
  3567.  
  3568.                             case 27996:
  3569.                                 item->SetCount(item->GetCount() - 1);
  3570.                                 AttackedByPoison(NULL); // @warme008
  3571.                                 break;
  3572.  
  3573.                             case 27987:
  3574.                                
  3575.                                 // 30  꽝
  3576.                                
  3577.                                
  3578.                                
  3579.                                 {
  3580.                                     item->SetCount(item->GetCount() - 1);
  3581.  
  3582.                                     int r = number(1, 100);
  3583.  
  3584.                                     if (r <= 50)
  3585.                                     {
  3586.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 돌조각이 나왔습니다."));
  3587.                                         AutoGiveItem(27990);
  3588.                                     }
  3589.                                     else
  3590.                                     {
  3591.                                         const int prob_table_gb2312[] =
  3592.                                         {
  3593.                                             95, 97, 99
  3594.                                         };
  3595.  
  3596.                                         const int * prob_table = prob_table_gb2312;
  3597.  
  3598.                                         if (r <= prob_table[0])
  3599.                                         {
  3600.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개가 흔적도 없이 사라집니다."));
  3601.                                         }
  3602.                                         else if (r <= prob_table[1])
  3603.                                         {
  3604.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 백진주가 나왔습니다."));
  3605.                                             AutoGiveItem(27992);
  3606.                                         }
  3607.                                         else if (r <= prob_table[2])
  3608.                                         {
  3609.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 청진주가 나왔습니다."));
  3610.                                             AutoGiveItem(27993);
  3611.                                         }
  3612.                                         else
  3613.                                         {
  3614.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("조개에서 피진주가 나왔습니다."));
  3615.                                             AutoGiveItem(27994);
  3616.                                         }
  3617.                                     }
  3618.                                 }
  3619.                                 break;
  3620.  
  3621.                             case 71013:
  3622.                                 CreateFly(number(FLY_FIREWORK1, FLY_FIREWORK6), this);
  3623.                                 item->SetCount(item->GetCount() - 1);
  3624.                                 break;
  3625.  
  3626.                             case 50100:
  3627.                             case 50101:
  3628.                             case 50102:
  3629.                             case 50103:
  3630.                             case 50104:
  3631.                             case 50105:
  3632.                             case 50106:
  3633.                                 CreateFly(item->GetVnum() - 50100 + FLY_FIREWORK1, this);
  3634.                                 item->SetCount(item->GetCount() - 1);
  3635.                                 break;
  3636.  
  3637.                             case 50200:
  3638.                                 if (g_bEnableBootaryCheck)
  3639.                                 {
  3640.                                     if (IS_BOTARYABLE_ZONE(GetMapIndex()) == true)
  3641.                                     {
  3642.                                         __OpenPrivateShop();
  3643.                                     }
  3644.                                     else
  3645.                                     {
  3646.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개인 상점을 열 수 없는 지역입니다"));
  3647.                                     }
  3648.                                 }
  3649.                                 #ifdef ENABLE_GM_RESTRICTION
  3650.                                 if (IsGM() == true)
  3651.                                 {
  3652.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GameMasters can't build private shops."));
  3653.                                     return false;
  3654.                                 }
  3655.                                 #endif
  3656.                                 else
  3657.                                 {
  3658.                                     __OpenPrivateShop();
  3659.                                 }
  3660.                                 break;
  3661.  
  3662.                             case fishing::FISH_MIND_PILL_VNUM:
  3663.                                 AddAffect(AFFECT_FISH_MIND_PILL, POINT_NONE, 0, AFF_FISH_MIND, 20*60, 0, true);
  3664.                                 item->SetCount(item->GetCount() - 1);
  3665.                                 break;
  3666.  
  3667.                             case 50301:
  3668.                             case 50302:
  3669.                             case 50303:
  3670.                                 {
  3671.                                     if (IsPolymorphed() == true)
  3672.                                     {
  3673.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑 중에는 능력을 올릴 수 없습니다."));
  3674.                                         return false;
  3675.                                     }
  3676.  
  3677.                                     int lv = GetSkillLevel(SKILL_LEADERSHIP);
  3678.  
  3679.                                     if (lv < item->GetValue(0))
  3680.                                     {
  3681.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책은 너무 어려워 이해하기가 힘듭니다."));
  3682.                                         return false;
  3683.                                     }
  3684.  
  3685.                                     if (lv >= item->GetValue(1))
  3686.                                     {
  3687.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책은 아무리 봐도 도움이 될 것 같지 않습니다."));
  3688.                                         return false;
  3689.                                     }
  3690.  
  3691.                                     if (LearnSkillByBook(SKILL_LEADERSHIP))
  3692.                                     {
  3693. #ifdef ENABLE_BOOKS_STACKFIX
  3694.                                         item->SetCount(item->GetCount() - 1);
  3695. #else
  3696.                                         ITEM_MANAGER::instance().RemoveItem(item);
  3697. #endif
  3698.  
  3699.                                         int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3700.                                         if (distribution_test_server) iReadDelay /= 3;
  3701.  
  3702.                                         SetSkillNextReadTime(SKILL_LEADERSHIP, get_global_time() + iReadDelay);
  3703.                                     }
  3704.                                 }
  3705.                                 break;
  3706.  
  3707.                             case 50304:
  3708.                             case 50305:
  3709.                             case 50306:
  3710.                                 {
  3711.                                     if (IsPolymorphed())
  3712.                                     {
  3713.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3714.                                         return false;
  3715.  
  3716.                                     }
  3717.                                     if (GetSkillLevel(SKILL_COMBO) == 0 && GetLevel() < 30)
  3718.                                     {
  3719.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("레벨 30이 되기 전에는 습득할 수 있을 것 같지 않습니다."));
  3720.                                         return false;
  3721.                                     }
  3722.  
  3723.                                     if (GetSkillLevel(SKILL_COMBO) == 1 && GetLevel() < 50)
  3724.                                     {
  3725.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("레벨 50이 되기 전에는 습득할 수 있을 것 같지 않습니다."));
  3726.                                         return false;
  3727.                                     }
  3728.  
  3729.                                     if (GetSkillLevel(SKILL_COMBO) >= 2)
  3730.                                     {
  3731.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("연계기는 더이상 수련할 수 없습니다."));
  3732.                                         return false;
  3733.                                     }
  3734.  
  3735.                                     int iPct = item->GetValue(0);
  3736.  
  3737.                                     if (LearnSkillByBook(SKILL_COMBO, iPct))
  3738.                                     {
  3739. #ifdef ENABLE_BOOKS_STACKFIX
  3740.                                         item->SetCount(item->GetCount() - 1);
  3741. #else
  3742.                                         ITEM_MANAGER::instance().RemoveItem(item);
  3743. #endif
  3744.  
  3745.                                         int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3746.                                         if (distribution_test_server) iReadDelay /= 3;
  3747.  
  3748.                                         SetSkillNextReadTime(SKILL_COMBO, get_global_time() + iReadDelay);
  3749.                                     }
  3750.                                 }
  3751.                                 break;
  3752.                             case 50311:
  3753.                             case 50312:
  3754.                             case 50313:
  3755.                                 {
  3756.                                     if (IsPolymorphed())
  3757.                                     {
  3758.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3759.                                         return false;
  3760.  
  3761.                                     }
  3762.                                     DWORD dwSkillVnum = item->GetValue(0);
  3763.                                     int iPct = MINMAX(0, item->GetValue(1), 100);
  3764.                                     if (GetSkillLevel(dwSkillVnum)>=20 || dwSkillVnum-SKILL_LANGUAGE1+1 == GetEmpire())
  3765.                                     {
  3766.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 완벽하게 알아들을 수 있는 언어이다."));
  3767.                                         return false;
  3768.                                     }
  3769.  
  3770.                                     if (LearnSkillByBook(dwSkillVnum, iPct))
  3771.                                     {
  3772. #ifdef ENABLE_BOOKS_STACKFIX
  3773.                                         item->SetCount(item->GetCount() - 1);
  3774. #else
  3775.                                         ITEM_MANAGER::instance().RemoveItem(item);
  3776. #endif
  3777.  
  3778.                                         int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3779.                                         if (distribution_test_server) iReadDelay /= 3;
  3780.  
  3781.                                         SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3782.                                     }
  3783.                                 }
  3784.                                 break;
  3785.  
  3786.                             case 50061 :
  3787.                                 {
  3788.                                     if (IsPolymorphed())
  3789.                                     {
  3790.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3791.                                         return false;
  3792.  
  3793.                                     }
  3794.                                     DWORD dwSkillVnum = item->GetValue(0);
  3795.                                     int iPct = MINMAX(0, item->GetValue(1), 100);
  3796.  
  3797.                                     if (GetSkillLevel(dwSkillVnum) >= 10)
  3798.                                     {
  3799.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
  3800.                                         return false;
  3801.                                     }
  3802.  
  3803.                                     if (LearnSkillByBook(dwSkillVnum, iPct))
  3804.                                     {
  3805. #ifdef ENABLE_BOOKS_STACKFIX
  3806.                                         item->SetCount(item->GetCount() - 1);
  3807. #else
  3808.                                         ITEM_MANAGER::instance().RemoveItem(item);
  3809. #endif
  3810.  
  3811.                                         int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3812.                                         if (distribution_test_server) iReadDelay /= 3;
  3813.  
  3814.                                         SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3815.                                     }
  3816.                                 }
  3817.                                 break;
  3818.  
  3819.                             case 50314: case 50315: case 50316:
  3820.                             case 50323: case 50324:
  3821.                             case 50325: case 50326:
  3822.                                 {
  3823.                                     if (IsPolymorphed() == true)
  3824.                                     {
  3825.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑 중에는 능력을 올릴 수 없습니다."));
  3826.                                         return false;
  3827.                                     }
  3828.  
  3829.                                     int iSkillLevelLowLimit = item->GetValue(0);
  3830.                                     int iSkillLevelHighLimit = item->GetValue(1);
  3831.                                     int iPct = MINMAX(0, item->GetValue(2), 100);
  3832.                                     int iLevelLimit = item->GetValue(3);
  3833.                                     DWORD dwSkillVnum = 0;
  3834.  
  3835.                                     switch (item->GetVnum())
  3836.                                     {
  3837.                                         case 50314: case 50315: case 50316:
  3838.                                             dwSkillVnum = SKILL_POLYMORPH;
  3839.                                             break;
  3840.  
  3841.                                         case 50323: case 50324:
  3842.                                             dwSkillVnum = SKILL_ADD_HP;
  3843.                                             break;
  3844.  
  3845.                                         case 50325: case 50326:
  3846.                                             dwSkillVnum = SKILL_RESIST_PENETRATE;
  3847.                                             break;
  3848.  
  3849.                                         default:
  3850.                                             return false;
  3851.                                     }
  3852.  
  3853.                                     if (0 == dwSkillVnum)
  3854.                                         return false;
  3855.  
  3856.                                     if (GetLevel() < iLevelLimit)
  3857.                                     {
  3858.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책을 읽으려면 레벨을 더 올려야 합니다."));
  3859.                                         return false;
  3860.                                     }
  3861.  
  3862.                                     if (GetSkillLevel(dwSkillVnum) >= 40)
  3863.                                     {
  3864.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
  3865.                                         return false;
  3866.                                     }
  3867.  
  3868.                                     if (GetSkillLevel(dwSkillVnum) < iSkillLevelLowLimit)
  3869.                                     {
  3870.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책은 너무 어려워 이해하기가 힘듭니다."));
  3871.                                         return false;
  3872.                                     }
  3873.  
  3874.                                     if (GetSkillLevel(dwSkillVnum) >= iSkillLevelHighLimit)
  3875.                                     {
  3876.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 책으로는 더 이상 수련할 수 없습니다."));
  3877.                                         return false;
  3878.                                     }
  3879.  
  3880.                                     if (LearnSkillByBook(dwSkillVnum, iPct))
  3881.                                     {
  3882. #ifdef ENABLE_BOOKS_STACKFIX
  3883.                                         item->SetCount(item->GetCount() - 1);
  3884. #else
  3885.                                         ITEM_MANAGER::instance().RemoveItem(item);
  3886. #endif
  3887.  
  3888.                                         int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3889.                                         if (distribution_test_server) iReadDelay /= 3;
  3890.  
  3891.                                         SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3892.                                     }
  3893.                                 }
  3894.                                 break;
  3895.  
  3896.                             case 50902:
  3897.                             case 50903:
  3898.                             case 50904:
  3899.                                 {
  3900.                                     if (IsPolymorphed())
  3901.                                     {
  3902.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3903.                                         return false;
  3904.  
  3905.                                     }
  3906.                                     DWORD dwSkillVnum = SKILL_CREATE;
  3907.                                     int iPct = MINMAX(0, item->GetValue(1), 100);
  3908.  
  3909.                                     if (GetSkillLevel(dwSkillVnum)>=40)
  3910.                                     {
  3911.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
  3912.                                         return false;
  3913.                                     }
  3914.  
  3915.                                     if (LearnSkillByBook(dwSkillVnum, iPct))
  3916.                                     {
  3917. #ifdef ENABLE_BOOKS_STACKFIX
  3918.                                         item->SetCount(item->GetCount() - 1);
  3919. #else
  3920.                                         ITEM_MANAGER::instance().RemoveItem(item);
  3921. #endif
  3922.  
  3923.                                         int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3924.                                         if (distribution_test_server) iReadDelay /= 3;
  3925.  
  3926.                                         SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3927.  
  3928.                                         if (test_server)
  3929.                                         {
  3930.                                             ChatPacket(CHAT_TYPE_INFO, "[TEST_SERVER] Success to learn skill ");
  3931.                                         }
  3932.                                     }
  3933.                                     else
  3934.                                     {
  3935.                                         if (test_server)
  3936.                                         {
  3937.                                             ChatPacket(CHAT_TYPE_INFO, "[TEST_SERVER] Failed to learn skill ");
  3938.                                         }
  3939.                                     }
  3940.                                 }
  3941.                                 break;
  3942.  
  3943.                                 // MINING
  3944.                             case ITEM_MINING_SKILL_TRAIN_BOOK:
  3945.                                 {
  3946.                                     if (IsPolymorphed())
  3947.                                     {
  3948.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3949.                                         return false;
  3950.  
  3951.                                     }
  3952.                                     DWORD dwSkillVnum = SKILL_MINING;
  3953.                                     int iPct = MINMAX(0, item->GetValue(1), 100);
  3954.  
  3955.                                     if (GetSkillLevel(dwSkillVnum)>=40)
  3956.                                     {
  3957.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 수련할 수 없습니다."));
  3958.                                         return false;
  3959.                                     }
  3960.  
  3961.                                     if (LearnSkillByBook(dwSkillVnum, iPct))
  3962.                                     {
  3963. #ifdef ENABLE_BOOKS_STACKFIX
  3964.                                         item->SetCount(item->GetCount() - 1);
  3965. #else
  3966.                                         ITEM_MANAGER::instance().RemoveItem(item);
  3967. #endif
  3968.  
  3969.                                         int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  3970.                                         if (distribution_test_server) iReadDelay /= 3;
  3971.  
  3972.                                         SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  3973.                                     }
  3974.                                 }
  3975.                                 break;
  3976.                                 // END_OF_MINING
  3977.  
  3978.                             case ITEM_HORSE_SKILL_TRAIN_BOOK:
  3979.                                 {
  3980.                                     if (IsPolymorphed())
  3981.                                     {
  3982.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변신중에는 책을 읽을수 없습니다."));
  3983.                                         return false;
  3984.  
  3985.                                     }
  3986.                                     DWORD dwSkillVnum = SKILL_HORSE;
  3987.                                     int iPct = MINMAX(0, item->GetValue(1), 100);
  3988.  
  3989.                                     if (GetLevel() < 50)
  3990.                                     {
  3991.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 승마 스킬을 수련할 수 있는 레벨이 아닙니다."));
  3992.                                         return false;
  3993.                                     }
  3994.  
  3995.                                     if (!test_server && get_global_time() < GetSkillNextReadTime(dwSkillVnum))
  3996.                                     {
  3997.                                         if (FindAffect(AFFECT_SKILL_NO_BOOK_DELAY))
  3998.                                         {
  3999.                                            
  4000.                                             RemoveAffect(AFFECT_SKILL_NO_BOOK_DELAY);
  4001.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("주안술서를 통해 주화입마에서 빠져나왔습니다."));
  4002.                                         }
  4003.                                         else
  4004.                                         {
  4005.                                             SkillLearnWaitMoreTimeMessage(GetSkillNextReadTime(dwSkillVnum) - get_global_time());
  4006.                                             return false;
  4007.                                         }
  4008.                                     }
  4009.  
  4010.                                     if (GetPoint(POINT_HORSE_SKILL) >= 20 ||
  4011.                                             GetSkillLevel(SKILL_HORSE_WILDATTACK) + GetSkillLevel(SKILL_HORSE_CHARGE) + GetSkillLevel(SKILL_HORSE_ESCAPE) >= 60 ||
  4012.                                             GetSkillLevel(SKILL_HORSE_WILDATTACK_RANGE) + GetSkillLevel(SKILL_HORSE_CHARGE) + GetSkillLevel(SKILL_HORSE_ESCAPE) >= 60)
  4013.                                     {
  4014.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 승마 수련서를 읽을 수 없습니다."));
  4015.                                         return false;
  4016.                                     }
  4017.  
  4018.                                     if (number(1, 100) <= iPct)
  4019.                                     {
  4020.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("승마 수련서를 읽어 승마 스킬 포인트를 얻었습니다."));
  4021.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("얻은 포인트로는 승마 스킬의 레벨을 올릴 수 있습니다."));
  4022.                                         PointChange(POINT_HORSE_SKILL, 1);
  4023.  
  4024.                                         int iReadDelay = number(SKILLBOOK_DELAY_MIN, SKILLBOOK_DELAY_MAX);
  4025.                                         if (distribution_test_server) iReadDelay /= 3;
  4026.  
  4027.                                         if (!test_server)
  4028.                                             SetSkillNextReadTime(dwSkillVnum, get_global_time() + iReadDelay);
  4029.                                     }
  4030.                                     else
  4031.                                     {
  4032.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("승마 수련서 이해에 실패하였습니다."));
  4033.                                     }
  4034. #ifdef ENABLE_BOOKS_STACKFIX
  4035.                                     item->SetCount(item->GetCount() - 1);
  4036. #else
  4037.                                     ITEM_MANAGER::instance().RemoveItem(item);
  4038. #endif
  4039.                                 }
  4040.                                 break;
  4041.  
  4042.                             case 70102:
  4043.                             case 70103:
  4044.                                 {
  4045.                                     if (GetAlignment() >= 0)
  4046.                                         return false;
  4047.  
  4048.                                     int delta = MIN(-GetAlignment(), item->GetValue(0));
  4049.  
  4050.                                     sys_log(0, "%s ALIGNMENT ITEM %d", GetName(), delta);
  4051.  
  4052.                                     UpdateAlignment(delta);
  4053.                                     item->SetCount(item->GetCount() - 1);
  4054.  
  4055.                                     if (delta / 10 > 0)
  4056.                                     {
  4057.                                         ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("마음이 맑아지는군. 가슴을 짓누르던 무언가가 좀 가벼워진 느낌이야."));
  4058.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("선악치가 %d 증가하였습니다."), delta/10);
  4059.                                     }
  4060.                                 }
  4061.                                 break;
  4062.  
  4063.                             case 71107:
  4064.                                 {
  4065.                                     int val = item->GetValue(0);
  4066.                                     int interval = item->GetValue(1);
  4067.                                     quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetPlayerID());
  4068.                                     int last_use_time = pPC->GetFlag("mythical_peach.last_use_time");
  4069.  
  4070.                                     if (get_global_time() - last_use_time < interval * 60 * 60)
  4071.                                     {
  4072.                                         if (test_server == false)
  4073.                                         {
  4074.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 사용할 수 없습니다."));
  4075.                                             return false;
  4076.                                         }
  4077.                                         else
  4078.                                         {
  4079.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("테스트 서버 시간제한 통과"));
  4080.                                         }
  4081.                                     }
  4082.  
  4083.                                     if (GetAlignment() == 200000)
  4084.                                     {
  4085.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("선악치를 더 이상 올릴 수 없습니다."));
  4086.                                         return false;
  4087.                                     }
  4088.  
  4089.                                     if (200000 - GetAlignment() < val * 10)
  4090.                                     {
  4091.                                         val = (200000 - GetAlignment()) / 10;
  4092.                                     }
  4093.  
  4094.                                     int old_alignment = GetAlignment() / 10;
  4095.  
  4096.                                     UpdateAlignment(val*10);
  4097.  
  4098.                                     item->SetCount(item->GetCount()-1);
  4099.                                     pPC->SetFlag("mythical_peach.last_use_time", get_global_time());
  4100.  
  4101.                                     ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("마음이 맑아지는군. 가슴을 짓누르던 무언가가 좀 가벼워진 느낌이야."));
  4102.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("선악치가 %d 증가하였습니다."), val);
  4103.  
  4104.                                     char buf[256 + 1];
  4105.                                     snprintf(buf, sizeof(buf), "%d %d", old_alignment, GetAlignment() / 10);
  4106.                                     LogManager::instance().CharLog(this, val, "MYTHICAL_PEACH", buf);
  4107.                                 }
  4108.                                 break;
  4109.  
  4110.                             case 71109:
  4111.                             case 72719:
  4112.                                 {
  4113.                                     LPITEM item2;
  4114.  
  4115.                                     if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  4116.                                         return false;
  4117.  
  4118.                                     if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  4119.                                         return false;
  4120.  
  4121.                                     if (item2->GetSocketCount() == 0)
  4122.                                         return false;
  4123.  
  4124.                                     switch( item2->GetType() )
  4125.                                     {
  4126.                                         case ITEM_WEAPON:
  4127.                                             break;
  4128.                                         case ITEM_ARMOR:
  4129.                                             switch (item2->GetSubType())
  4130.                                             {
  4131.                                             case ARMOR_EAR:
  4132.                                             case ARMOR_WRIST:
  4133.                                             case ARMOR_NECK:
  4134.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빼낼 영석이 없습니다"));
  4135.                                                 return false;
  4136.                                             }
  4137.                                             break;
  4138.  
  4139.                                         default:
  4140.                                             return false;
  4141.                                     }
  4142.  
  4143.                                     std::stack<long> socket;
  4144.  
  4145.                                     for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  4146.                                         socket.push(item2->GetSocket(i));
  4147.  
  4148.                                     int idx = ITEM_SOCKET_MAX_NUM - 1;
  4149.  
  4150.                                     while (socket.size() > 0)
  4151.                                     {
  4152.                                         if (socket.top() > 2 && socket.top() != ITEM_BROKEN_METIN_VNUM)
  4153.                                             break;
  4154.  
  4155.                                         idx--;
  4156.                                         socket.pop();
  4157.                                     }
  4158.  
  4159.                                     if (socket.size() == 0)
  4160.                                     {
  4161.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빼낼 영석이 없습니다"));
  4162.                                         return false;
  4163.                                     }
  4164.  
  4165.                                     LPITEM pItemReward = AutoGiveItem(socket.top());
  4166.  
  4167.                                     if (pItemReward != NULL)
  4168.                                     {
  4169.                                         item2->SetSocket(idx, 1);
  4170.  
  4171.                                         char buf[256+1];
  4172.                                         snprintf(buf, sizeof(buf), "%s(%u) %s(%u)",
  4173.                                                 item2->GetName(), item2->GetID(), pItemReward->GetName(), pItemReward->GetID());
  4174.                                         LogManager::instance().ItemLog(this, item, "USE_DETACHMENT_ONE", buf);
  4175.  
  4176.                                         item->SetCount(item->GetCount() - 1);
  4177.                                     }
  4178.                                 }
  4179.                                 break;
  4180.  
  4181.                             case 70201:  
  4182.                             case 70202:  
  4183.                             case 70203:  
  4184.                             case 70204:  
  4185.                             case 70205:  
  4186.                             case 70206:  
  4187.                                 {
  4188.                                     // NEW_HAIR_STYLE_ADD
  4189.                                     if (GetPart(PART_HAIR) >= 1001)
  4190.                                     {
  4191.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("현재 헤어스타일에서는 염색과 탈색이 불가능합니다."));
  4192.                                     }
  4193.                                     // END_NEW_HAIR_STYLE_ADD
  4194.                                     else
  4195.                                     {
  4196.                                         quest::CQuestManager& q = quest::CQuestManager::instance();
  4197.                                         quest::PC* pPC = q.GetPC(GetPlayerID());
  4198.  
  4199.                                         if (pPC)
  4200.                                         {
  4201.                                             int last_dye_level = pPC->GetFlag("dyeing_hair.last_dye_level");
  4202.  
  4203.                                             if (last_dye_level == 0 ||
  4204.                                                     last_dye_level+3 <= GetLevel() ||
  4205.                                                     item->GetVnum() == 70201)
  4206.                                             {
  4207.                                                 SetPart(PART_HAIR, item->GetVnum() - 70201);
  4208.  
  4209.                                                 if (item->GetVnum() == 70201)
  4210.                                                     pPC->SetFlag("dyeing_hair.last_dye_level", 0);
  4211.                                                 else
  4212.                                                     pPC->SetFlag("dyeing_hair.last_dye_level", GetLevel());
  4213.  
  4214.                                                 item->SetCount(item->GetCount() - 1);
  4215.                                                 UpdatePacket();
  4216.                                             }
  4217.                                             else
  4218.                                             {
  4219.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d 레벨이 되어야 다시 염색하실 수 있습니다."), last_dye_level+3);
  4220.                                             }
  4221.                                         }
  4222.                                     }
  4223.                                 }
  4224.                                 break;
  4225.  
  4226.                             case ITEM_NEW_YEAR_GREETING_VNUM:
  4227.                                 {
  4228.                                     DWORD dwBoxVnum = ITEM_NEW_YEAR_GREETING_VNUM;
  4229.                                     std::vector <DWORD> dwVnums;
  4230.                                     std::vector <DWORD> dwCounts;
  4231.                                     std::vector <LPITEM> item_gets;
  4232.                                     int count = 0;
  4233.  
  4234.                                     if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  4235.                                     {
  4236.                                         for (int i = 0; i < count; i++)
  4237.                                         {
  4238.                                             if (dwVnums[i] == CSpecialItemGroup::GOLD)
  4239.                                             #if defined(__CHATTING_WINDOW_RENEWAL__)
  4240.                                             ChatPacket(CHAT_TYPE_MONEY_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  4241.                                             #else
  4242.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  4243.                                             #endif
  4244.                                         }
  4245.  
  4246.                                         item->SetCount(item->GetCount() - 1);
  4247.                                     }
  4248.                                 }
  4249.                                 break;
  4250.  
  4251.                             case ITEM_VALENTINE_ROSE:
  4252.                             case ITEM_VALENTINE_CHOCOLATE:
  4253.                                 {
  4254.                                     DWORD dwBoxVnum = item->GetVnum();
  4255.                                     std::vector <DWORD> dwVnums;
  4256.                                     std::vector <DWORD> dwCounts;
  4257.                                     std::vector <LPITEM> item_gets(0);
  4258.                                     int count = 0;
  4259.  
  4260.  
  4261.                                     if (((item->GetVnum() == ITEM_VALENTINE_ROSE) && (SEX_MALE==GET_SEX(this))) ||
  4262.                                         ((item->GetVnum() == ITEM_VALENTINE_CHOCOLATE) && (SEX_FEMALE==GET_SEX(this))))
  4263.                                     {
  4264.                                        
  4265.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 열 수 없습니다."));
  4266.                                         return false;
  4267.                                     }
  4268.  
  4269.  
  4270.                                     if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  4271.                                         item->SetCount(item->GetCount()-1);
  4272.                                 }
  4273.                                 break;
  4274.  
  4275.                             case ITEM_WHITEDAY_CANDY:
  4276.                             case ITEM_WHITEDAY_ROSE:
  4277.                                 {
  4278.                                     DWORD dwBoxVnum = item->GetVnum();
  4279.                                     std::vector <DWORD> dwVnums;
  4280.                                     std::vector <DWORD> dwCounts;
  4281.                                     std::vector <LPITEM> item_gets(0);
  4282.                                     int count = 0;
  4283.  
  4284.  
  4285.                                     if (((item->GetVnum() == ITEM_WHITEDAY_CANDY) && (SEX_MALE==GET_SEX(this))) ||
  4286.                                         ((item->GetVnum() == ITEM_WHITEDAY_ROSE) && (SEX_FEMALE==GET_SEX(this))))
  4287.                                     {
  4288.                                        
  4289.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 열 수 없습니다."));
  4290.                                         return false;
  4291.                                     }
  4292.  
  4293.  
  4294.                                     if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  4295.                                         item->SetCount(item->GetCount()-1);
  4296.                                 }
  4297.                                 break;
  4298.  
  4299.                             case 50011:
  4300.                                 {
  4301.                                     DWORD dwBoxVnum = 50011;
  4302.                                     std::vector <DWORD> dwVnums;
  4303.                                     std::vector <DWORD> dwCounts;
  4304.                                     std::vector <LPITEM> item_gets(0);
  4305.                                     int count = 0;
  4306.  
  4307.                                     if (GiveItemFromSpecialItemGroup(dwBoxVnum, dwVnums, dwCounts, item_gets, count))
  4308.                                     {
  4309.                                         for (int i = 0; i < count; i++)
  4310.                                         {
  4311.                                             char buf[50 + 1];
  4312.                                             snprintf(buf, sizeof(buf), "%u %u", dwVnums[i], dwCounts[i]);
  4313.                                             LogManager::instance().ItemLog(this, item, "MOONLIGHT_GET", buf);
  4314.  
  4315.                                             //ITEM_MANAGER::instance().RemoveItem(item);
  4316.                                             item->SetCount(item->GetCount() - 1);
  4317.  
  4318.                                             switch (dwVnums[i])
  4319.                                             {
  4320.                                             case CSpecialItemGroup::GOLD:
  4321.                                                 #if defined(__CHATTING_WINDOW_RENEWAL__)
  4322.                                                 ChatPacket(CHAT_TYPE_MONEY_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  4323.                                                 #else
  4324.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), dwCounts[i]);
  4325.                                                 #endif
  4326.                                                 break;
  4327.  
  4328.                                             case CSpecialItemGroup::EXP:
  4329.                                                 #if defined(__CHATTING_WINDOW_RENEWAL__)
  4330.                                                 ChatPacket(CHAT_TYPE_EXP_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
  4331.                                                 ChatPacket(CHAT_TYPE_EXP_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
  4332.                                                 #else
  4333.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
  4334.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%d의 경험치를 획득했습니다."), dwCounts[i]);
  4335.                                                 #endif
  4336.                                                 break;
  4337.  
  4338.                                             case CSpecialItemGroup::MOB:
  4339.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  4340.                                                 break;
  4341.  
  4342.                                             case CSpecialItemGroup::SLOW:
  4343.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 빨간 연기를 들이마시자 움직이는 속도가 느려졌습니다!"));
  4344.                                                 break;
  4345.  
  4346.                                             case CSpecialItemGroup::DRAIN_HP:
  4347.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자가 갑자기 폭발하였습니다! 생명력이 감소했습니다."));
  4348.                                                 break;
  4349.  
  4350.                                             case CSpecialItemGroup::POISON:
  4351.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  4352.                                                 break;
  4353. #ifdef ENABLE_WOLFMAN_CHARACTER
  4354.                                             case CSpecialItemGroup::BLEEDING:
  4355.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  4356.                                                 break;
  4357. #endif
  4358.                                             case CSpecialItemGroup::MOB_GROUP:
  4359.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  4360.                                                 break;
  4361.  
  4362.                                             default:
  4363.                                                 if (item_gets[i])
  4364.                                                 {
  4365.                                                     #if defined(__CHATTING_WINDOW_RENEWAL__)
  4366.                                                     if (dwCounts[i] > 1)
  4367.                                                         ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
  4368.                                                     else
  4369.                                                         ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
  4370.                                                     #else
  4371.                                                     if (dwCounts[i] > 1)
  4372.                                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 %d 개 나왔습니다."), item_gets[i]->GetName(), dwCounts[i]);
  4373.                                                     else
  4374.                                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), item_gets[i]->GetName());
  4375.                                                     #endif
  4376.                                                 }
  4377.                                                 break;
  4378.                                             }
  4379.                                         }
  4380.                                     }
  4381.                                     else
  4382.                                     {
  4383.                                         ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("아무것도 얻을 수 없었습니다."));
  4384.                                         return false;
  4385.                                     }
  4386.                                 }
  4387.                                 break;
  4388.  
  4389.                             case ITEM_GIVE_STAT_RESET_COUNT_VNUM:
  4390.                                 {
  4391.                                     //PointChange(POINT_GOLD, -iCost);
  4392.                                     PointChange(POINT_STAT_RESET_COUNT, 1);
  4393.                                     item->SetCount(item->GetCount()-1);
  4394.                                 }
  4395.                                 break;
  4396.  
  4397.                             case 50107:
  4398.                                 {
  4399.                                     if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  4400.                                     {
  4401.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  4402.                                         return false;
  4403.                                     }
  4404. #ifdef ENABLE_NEWSTUFF
  4405.                                     else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  4406.                                     {
  4407.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  4408.                                         return false;
  4409.                                     }
  4410. #endif
  4411.  
  4412.                                     EffectPacket(SE_CHINA_FIREWORK);
  4413. #ifdef ENABLE_FIREWORK_STUN
  4414.                                    
  4415.                                     AddAffect(AFFECT_CHINA_FIREWORK, POINT_STUN_PCT, 30, AFF_CHINA_FIREWORK, 5*60, 0, true);
  4416. #endif
  4417.                                     item->SetCount(item->GetCount()-1);
  4418.                                 }
  4419.                                 break;
  4420.  
  4421.                             case 50108:
  4422.                                 {
  4423.                                     if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  4424.                                     {
  4425.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  4426.                                         return false;
  4427.                                     }
  4428. #ifdef ENABLE_NEWSTUFF
  4429.                                     else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  4430.                                     {
  4431.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  4432.                                         return false;
  4433.                                     }
  4434. #endif
  4435.  
  4436.                                     EffectPacket(SE_SPIN_TOP);
  4437. #ifdef ENABLE_FIREWORK_STUN
  4438.                                    
  4439.                                     AddAffect(AFFECT_CHINA_FIREWORK, POINT_STUN_PCT, 30, AFF_CHINA_FIREWORK, 5*60, 0, true);
  4440. #endif
  4441.                                     item->SetCount(item->GetCount()-1);
  4442.                                 }
  4443.                                 break;
  4444.  
  4445.                             case ITEM_WONSO_BEAN_VNUM:
  4446.                                 PointChange(POINT_HP, GetMaxHP() - GetHP());
  4447.                                 item->SetCount(item->GetCount()-1);
  4448.                                 break;
  4449.  
  4450.                             case ITEM_WONSO_SUGAR_VNUM:
  4451.                                 PointChange(POINT_SP, GetMaxSP() - GetSP());
  4452.                                 item->SetCount(item->GetCount()-1);
  4453.                                 break;
  4454.  
  4455.                             case ITEM_WONSO_FRUIT_VNUM:
  4456.                                 PointChange(POINT_STAMINA, GetMaxStamina()-GetStamina());
  4457.                                 item->SetCount(item->GetCount()-1);
  4458.                                 break;
  4459.  
  4460.                             case 90008: // VCARD
  4461.                             case 90009: // VCARD
  4462.                                 VCardUse(this, this, item);
  4463.                                 break;
  4464.  
  4465.                             case ITEM_ELK_VNUM:
  4466.                                 {
  4467.                                     int iGold = item->GetSocket(0);
  4468.                                     ITEM_MANAGER::instance().RemoveItem(item);
  4469.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %d 냥을 획득했습니다."), iGold);
  4470.                                     PointChange(POINT_GOLD, iGold);
  4471.                                 }
  4472.                                 break;
  4473.  
  4474.                                
  4475.                             case 70021:
  4476.                                 {
  4477.                                     int HealPrice = quest::CQuestManager::instance().GetEventFlag("MonarchHealGold");
  4478.                                     if (HealPrice == 0)
  4479.                                         HealPrice = 2000000;
  4480.  
  4481.                                     if (CMonarch::instance().HealMyEmpire(this, HealPrice))
  4482.                                     {
  4483.                                         char szNotice[256];
  4484.                                         snprintf(szNotice, sizeof(szNotice), LC_TEXT("군주의 축복으로 이지역 %s 유저는 HP,SP가 모두 채워집니다."), EMPIRE_NAME(GetEmpire()));
  4485.                                         SendNoticeMap(szNotice, GetMapIndex(), false);
  4486.  
  4487.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("군주의 축복을 사용하였습니다."));
  4488.                                     }
  4489.                                 }
  4490.                                 break;
  4491.  
  4492.                             case 27995:
  4493.                                 {
  4494.                                 }
  4495.                                 break;
  4496.  
  4497.                             case 71092 :
  4498.                                 {
  4499.                                     if (m_pkChrTarget != NULL)
  4500.                                     {
  4501.                                         if (m_pkChrTarget->IsPolymorphed())
  4502.                                         {
  4503.                                             m_pkChrTarget->SetPolymorph(0);
  4504.                                             m_pkChrTarget->RemoveAffect(AFFECT_POLYMORPH);
  4505.                                         }
  4506.                                     }
  4507.                                     else
  4508.                                     {
  4509.                                         if (IsPolymorphed())
  4510.                                         {
  4511.                                             SetPolymorph(0);
  4512.                                             RemoveAffect(AFFECT_POLYMORPH);
  4513.                                         }
  4514.                                     }
  4515.                                 }
  4516.                                 break;
  4517.  
  4518.                             case 71051 :
  4519.                                 {
  4520.                                     LPITEM item2;
  4521.  
  4522.                                     if (!IsValidItemPosition(DestCell) || !(item2 = GetInventoryItem(wDestCell)))
  4523.                                         return false;
  4524.  
  4525.                                     if (ITEM_COSTUME == item2->GetType()) // @fixme124
  4526.                                     {
  4527.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("no_6_7_costumes_bonus."));
  4528.                                         return false;
  4529.                                     }
  4530.  
  4531.                                     if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  4532.                                         return false;
  4533.  
  4534.                                     if (item2->GetAttributeSetIndex() == -1)
  4535.                                     {
  4536.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  4537.                                         return false;
  4538.                                     }
  4539.  
  4540.                                     if (item2->AddRareAttribute() == true)
  4541.                                     {
  4542.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("67_on_equip_true"));
  4543.  
  4544.                                         int iAddedIdx = item2->GetRareAttrCount() + 4;
  4545.                                         char buf[21];
  4546.                                         snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4547.  
  4548.                                         LogManager::instance().ItemLog(
  4549.                                                 GetPlayerID(),
  4550.                                                 item2->GetAttributeType(iAddedIdx),
  4551.                                                 item2->GetAttributeValue(iAddedIdx),
  4552.                                                 item->GetID(),
  4553.                                                 "ADD_RARE_ATTR",
  4554.                                                 buf,
  4555.                                                 GetDesc()->GetHostName(),
  4556.                                                 item->GetOriginalVnum());
  4557.  
  4558.                                         item->SetCount(item->GetCount() - 1);
  4559.                                     }
  4560.                                     else
  4561.                                     {
  4562.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("max_67_on_epuip"));
  4563.                                     }
  4564.                                 }
  4565.                                 break;
  4566.  
  4567.                             case 71052 :
  4568.                                 {
  4569.                                    
  4570.                                     LPITEM item2;
  4571.  
  4572.                                     if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  4573.                                         return false;
  4574.  
  4575.                                     if (ITEM_COSTUME == item2->GetType()) // @fixme124
  4576.                                     {
  4577.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("no_6_7_costumes_bonus."));
  4578.                                         return false;
  4579.                                     }
  4580.  
  4581.                                     if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  4582.                                         return false;
  4583.  
  4584.                                     if (item2->GetAttributeSetIndex() == -1)
  4585.                                     {
  4586.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  4587.                                         return false;
  4588.                                     }
  4589.  
  4590.                                     if (item2->ChangeRareAttribute() == true)
  4591.                                     {
  4592.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("67_on_change_true"));
  4593.                                         char buf[21];
  4594.                                         snprintf(buf, sizeof(buf), "%u", item2->GetID());
  4595.                                         LogManager::instance().ItemLog(this, item, "CHANGE_RARE_ATTR", buf);
  4596.  
  4597.                                         item->SetCount(item->GetCount() - 1);
  4598.                                     }
  4599.                                     else
  4600.                                     {
  4601.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("no_67_on_equip"));
  4602.                                     }
  4603.                                 }
  4604.                                 break;
  4605.                             /*
  4606.                             // COSTUME BONUS CHANGE
  4607.                             case 31230 : // random bonuses 1-3
  4608.                                 {
  4609.                                     // 유럽, 싱가폴, 베트남 진재가 사용금지
  4610.                                     LPITEM item2;
  4611.  
  4612.                                     if (!IsValidItemPosition(DestCell) || !(item2 = GetInventoryItem(wDestCell)))
  4613.                                         return false;
  4614.  
  4615.                                     if (ITEM_COSTUME != item2->GetType() || (ITEM_COSTUME == item2->GetType() && (item2->GetSubType() == COSTUME_ACCE || item2->GetSubType() == COSTUME_MOUNT))) // @fixme124
  4616.                                     {
  4617.                                         ChatPacket(CHAT_TYPE_INFO, "Only for costumes");
  4618.                                         return false;
  4619.                                     }
  4620.  
  4621.                                     if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  4622.                                         return false;
  4623.  
  4624.                                     // if (item2->GetAttributeSetIndex() == -1)
  4625.                                     // {
  4626.                                         // ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  4627.                                         // return false;
  4628.                                     // }
  4629.                                    
  4630.                                     int weapon_bonus_list[] = {3, 4, 5, 6, 15, 16, 12, 17, 63, 22, 19, 21}; // 12 (11)
  4631.                                     int armor_bonus_list[] = {23, 24, 1, 2, 9, 53, 39}; // 7 (6)
  4632.                                     int hair_bonus_list[] = {17, 63, 19, 22, 21, 45, 10, 11}; // 8 (7)
  4633.  
  4634.                                     int weapon_value_list[] = {
  4635.                                                               8, 10, 12,  //bonus zwtikotita 3
  4636.                                                               8, 10, 12,  //bonus eufuia 4
  4637.                                                               8, 10, 12,  //bonus dinami 5
  4638.                                                               8, 10, 12,  //bonus eukinisia 6
  4639.                                                               5, 10, 10,  //bonus crit 15
  4640.                                                               5, 10, 10,  //bonus diatrisi 16
  4641.                                                               5, 8, 8,  //bonus poison 12
  4642.                                                               5, 10, 10,  //bonus imi 17
  4643.                                                               5, 10, 15,  //bonus terata 63
  4644.                                                               10, 20, 20, //bonus diavolos 22
  4645.                                                               10, 20, 20, //bonus ork 19
  4646.                                                               10, 20, 20  //bonus apethanto 21
  4647.                                                               };
  4648.                                     int armor_value_list[] = {
  4649.                                                              5, 10, 10,         //bonus apporofisi hp 23
  4650.                                                              5, 10, 10,         //bonus apporofisi sp 24
  4651.                                                              1000, 2000, 3000,  //megisto hp 1
  4652.                                                              100, 200, 300,     //megisto sp 2
  4653.                                                              5, 10, 20,         //taxitita mageias 9
  4654.                                                              25, 50, 75,        //aksia epithesis 53
  4655.                                                              5, 10, 10          //pithanotita anaklasis fusikwn epithesewn
  4656.                                                              };
  4657.                                     int hair_value_list[] =  {
  4658.                                                              5, 10, 10,     //bonus imi 17
  4659.                                                              5, 10, 15,     //bonus terata 63
  4660.                                                              10, 20, 20,    //bonus ork 19
  4661.                                                              10, 20, 20,    //bonus diavolo 22
  4662.                                                              10, 20, 20,    //bonus apethanto 21
  4663.                                                              10, 20, 20,    //bonus diplasia antikeimena 45
  4664.                                                              5, 10, 20,     //bonus anagenisi hp 10
  4665.                                                              5, 10, 20      //bonus anagenisi sp 11
  4666.                                                              };
  4667.  
  4668.                                     bool is_costume_weapon = false;
  4669.                                     bool is_costume_armor = false;
  4670.                                     bool is_costume_hair = false;
  4671.                                     int bonus_number = 0;
  4672.                                     int bonus_count = 1;
  4673.                                     int bonus1 = 0;
  4674.                                     int bonus2 = 0;
  4675.                                     int bonus3 = 0;
  4676.                                     int bonus1_id = 0;
  4677.                                     int bonus2_id = 0;
  4678.                                     int bonus3_id = 0;
  4679.                                     int bonus1_value = 0;
  4680.                                     int bonus2_value = 0;
  4681.                                     int bonus3_value = 0;
  4682.  
  4683.                                     // TYPE PERC
  4684.                                     int type_perc = number(1, 100);
  4685.                                     if (type_perc <= 10){
  4686.                                         bonus_count = 3;
  4687.                                     } else if (type_perc <= 25){
  4688.                                         bonus_count = 2;
  4689.                                     }
  4690.  
  4691.                                     // ITEM TYPE
  4692.                                     if (item2->GetSubType() == COSTUME_WEAPON){
  4693.                                         is_costume_weapon = true;
  4694.                                     } else if (item2->GetSubType() == COSTUME_BODY){
  4695.                                         is_costume_armor = true;
  4696.                                     } else if (item2->GetSubType() == COSTUME_HAIR){
  4697.                                         is_costume_hair = true;
  4698.                                     }
  4699.  
  4700.                                     while(bonus_number != bonus_count)
  4701.                                     {
  4702.                                         if (bonus_count >= 1){
  4703.                                             if (is_costume_weapon){
  4704.                                                 bonus1 = number(0, 11);
  4705.                                                 bonus1_id = number((0+bonus1*3), (2+bonus1*3));
  4706.                                                 bonus1_value = weapon_value_list[bonus1_id];
  4707.                                                 bonus1 = weapon_bonus_list[bonus1];
  4708.                                             } else if (is_costume_armor){
  4709.                                                 bonus1 = number(0, 6);
  4710.                                                 bonus1_id = number((0+bonus1*3), (2+bonus1*3));
  4711.                                                 bonus1_value = armor_value_list[bonus1_id];
  4712.                                                 bonus1 = armor_bonus_list[bonus1];
  4713.                                             } else if (is_costume_hair){
  4714.                                                 bonus1 = number(0, 7);
  4715.                                                 bonus1_id = number((0+bonus1*3), (2+bonus1*3));
  4716.                                                 bonus1_value = hair_value_list[bonus1_id];
  4717.                                                 bonus1 = hair_bonus_list[bonus1];
  4718.                                             }
  4719.                                         }
  4720.                                         if (bonus_count >= 2){
  4721.                                             if (is_costume_weapon){
  4722.                                                 bonus2 = number(0, 11);
  4723.                                                 bonus2_id = number((0+bonus2*3), (2+bonus2*3));
  4724.                                                 bonus2_value = weapon_value_list[bonus2_id];
  4725.                                                 bonus2 = weapon_bonus_list[bonus2];
  4726.                                             } else if (is_costume_armor){
  4727.                                                 bonus2 = number(0, 6);
  4728.                                                 bonus2_id = number((0+bonus2*3), (2+bonus2*3));
  4729.                                                 bonus2_value = armor_value_list[bonus2_id];
  4730.                                                 bonus2 = armor_bonus_list[bonus2];
  4731.                                             } else if (is_costume_hair){
  4732.                                                 bonus2 = number(0, 7);
  4733.                                                 bonus2_id = number((0+bonus2*3), (2+bonus2*3));
  4734.                                                 bonus2_value = hair_value_list[bonus2_id];
  4735.                                                 bonus2 = hair_bonus_list[bonus2];
  4736.                                             }
  4737.                                         }
  4738.                                         if (bonus_count >= 3){
  4739.                                             if (is_costume_weapon){
  4740.                                                 bonus3 = number(0, 11);
  4741.                                                 bonus3_id = number((0+bonus3*3), (2+bonus3*3));
  4742.                                                 bonus3_value = weapon_value_list[bonus3_id];
  4743.                                                 bonus3 = weapon_bonus_list[bonus3];
  4744.                                             } else if (is_costume_armor){
  4745.                                                 bonus3 = number(0, 6);
  4746.                                                 bonus3_id = number((0+bonus3*3), (2+bonus3*3));
  4747.                                                 bonus3_value = armor_value_list[bonus3_id];
  4748.                                                 bonus3 = armor_bonus_list[bonus3];
  4749.                                             } else if (is_costume_hair){
  4750.                                                 bonus3 = number(0, 7);
  4751.                                                 bonus3_id = number((0+bonus3*3), (2+bonus3*3));
  4752.                                                 bonus3_value = hair_value_list[bonus3_id];
  4753.                                                 bonus3 = hair_bonus_list[bonus3];
  4754.                                             }
  4755.                                         }
  4756.                                         // PASS...
  4757.                                         if (bonus_count == 1 || (bonus_count == 2 && bonus1 != bonus2) || (bonus_count == 3 && bonus1 != bonus2 && bonus1 != bonus3 && bonus2 != bonus3)){
  4758.                                             bonus_number = bonus_count;
  4759.                                         }
  4760.                                     }
  4761.  
  4762.                                     // SET BONUS
  4763.                                     item2->ClearAttribute();
  4764.                                     if (bonus_count >= 1){
  4765.                                         item2->SetForceAttribute(0, bonus1, bonus1_value);
  4766.                                     }
  4767.                                     if (bonus_count >= 2){
  4768.                                         item2->SetForceAttribute(1, bonus2, bonus2_value);
  4769.                                     }
  4770.                                     if (bonus_count >= 3){
  4771.                                         item2->SetForceAttribute(2, bonus3, bonus3_value);
  4772.                                     }
  4773.                                    
  4774.                                     item->SetCount(item->GetCount() - 1);
  4775.                                 }
  4776.                                 break;
  4777.  
  4778.                             case 31231 : // mix bonuses (same count)
  4779.                                 {
  4780.                                     LPITEM item2;
  4781.  
  4782.                                     if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  4783.                                         return false;
  4784.  
  4785.                                     if (ITEM_COSTUME != item2->GetType() || (ITEM_COSTUME == item2->GetType() && (item2->GetSubType() == COSTUME_ACCE || item2->GetSubType() == COSTUME_MOUNT))) // @fixme124
  4786.                                     {
  4787.                                         ChatPacket(CHAT_TYPE_INFO, "Only for costumes");
  4788.                                         return false;
  4789.                                     }
  4790.  
  4791.                                     if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  4792.                                         return false;
  4793.  
  4794.                                     if (item2->GetAttributeCount() == 0 || item2->GetAttributeCount() > 3)
  4795.                                     {
  4796.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  4797.                                         return false;
  4798.                                     }
  4799.                                    
  4800.                                     int bonus_count = item2->GetAttributeCount();
  4801.  
  4802.                                     int weapon_bonus_list[] = {3, 4, 5, 6, 15, 16, 12, 17, 63, 22, 19, 21}; // 12 (11)
  4803.                                     int armor_bonus_list[] = {23, 24, 1, 2, 9, 53, 39}; // 7 (6)
  4804.                                     int hair_bonus_list[] = {17, 63, 19, 22, 21, 45, 10, 11}; // 8 (7)
  4805.  
  4806.                                     int weapon_value_list[] = {
  4807.                                                               8, 10, 12,  //bonus zwtikotita 3
  4808.                                                               8, 10, 12,  //bonus eufuia 4
  4809.                                                               8, 10, 12,  //bonus dinami 5
  4810.                                                               8, 10, 12,  //bonus eukinisia 6
  4811.                                                               5, 10, 10,  //bonus crit 15
  4812.                                                               5, 10, 10,  //bonus diatrisi 16
  4813.                                                               5, 8, 8,  //bonus poison 12
  4814.                                                               5, 10, 10,  //bonus imi 17
  4815.                                                               5, 10, 15,  //bonus terata 63
  4816.                                                               10, 20, 20, //bonus diavolos 22
  4817.                                                               10, 20, 20, //bonus ork 19
  4818.                                                               10, 20, 20  //bonus apethanto 21
  4819.                                                               };
  4820.                                     int armor_value_list[] = {
  4821.                                                              5, 10, 10,         //bonus apporofisi hp 23
  4822.                                                              5, 10, 10,         //bonus apporofisi sp 24
  4823.                                                              1000, 2000, 3000,  //megisto hp 1
  4824.                                                              100, 200, 300,     //megisto sp 2
  4825.                                                              5, 10, 20,         //taxitita mageias 9
  4826.                                                              25, 50, 75,        //aksia epithesis 53
  4827.                                                              5, 10, 10          //pithanotita anaklasis fusikwn epithesewn
  4828.                                                              };
  4829.                                     int hair_value_list[] =  {
  4830.                                                              5, 10, 10,     //bonus imi 17
  4831.                                                              5, 10, 15,     //bonus terata 63
  4832.                                                              10, 20, 20,    //bonus ork 19
  4833.                                                              10, 20, 20,    //bonus diavolo 22
  4834.                                                              10, 20, 20,    //bonus apethanto 21
  4835.                                                              10, 20, 20,    //bonus diplasia antikeimena 45
  4836.                                                              5, 10, 20,     //bonus anagenisi hp 10
  4837.                                                              5, 10, 20      //bonus anagenisi sp 11
  4838.                                                              };
  4839.  
  4840.                                     bool is_costume_weapon = false;
  4841.                                     bool is_costume_armor = false;
  4842.                                     bool is_costume_hair = false;
  4843.                                     int bonus_number = 0;
  4844.                                     int bonus1 = 0;
  4845.                                     int bonus2 = 0;
  4846.                                     int bonus3 = 0;
  4847.                                     int bonus1_id = 0;
  4848.                                     int bonus2_id = 0;
  4849.                                     int bonus3_id = 0;
  4850.                                     int bonus1_value = 0;
  4851.                                     int bonus2_value = 0;
  4852.                                     int bonus3_value = 0;
  4853.  
  4854.                                     // ITEM TYPE
  4855.                                     if (item2->GetSubType() == COSTUME_WEAPON){
  4856.                                         is_costume_weapon = true;
  4857.                                     } else if (item2->GetSubType() == COSTUME_BODY){
  4858.                                         is_costume_armor = true;
  4859.                                     } else if (item2->GetSubType() == COSTUME_HAIR){
  4860.                                         is_costume_hair = true;
  4861.                                     }
  4862.  
  4863.                                     while(bonus_number != bonus_count)
  4864.                                     {
  4865.                                         if (bonus_count >= 1){
  4866.                                             if (is_costume_weapon){
  4867.                                                 bonus1 = number(0, 11);
  4868.                                                 bonus1_id = number((0+bonus1*3), (2+bonus1*3));
  4869.                                                 bonus1_value = weapon_value_list[bonus1_id];
  4870.                                                 bonus1 = weapon_bonus_list[bonus1];
  4871.                                             } else if (is_costume_armor){
  4872.                                                 bonus1 = number(0, 6);
  4873.                                                 bonus1_id = number((0+bonus1*3), (2+bonus1*3));
  4874.                                                 bonus1_value = armor_value_list[bonus1_id];
  4875.                                                 bonus1 = armor_bonus_list[bonus1];
  4876.                                             } else if (is_costume_hair){
  4877.                                                 bonus1 = number(0, 7);
  4878.                                                 bonus1_id = number((0+bonus1*3), (2+bonus1*3));
  4879.                                                 bonus1_value = hair_value_list[bonus1_id];
  4880.                                                 bonus1 = hair_bonus_list[bonus1];
  4881.                                             }
  4882.                                         }
  4883.                                         if (bonus_count >= 2){
  4884.                                             if (is_costume_weapon){
  4885.                                                 bonus2 = number(0, 11);
  4886.                                                 bonus2_id = number((0+bonus2*3), (2+bonus2*3));
  4887.                                                 bonus2_value = weapon_value_list[bonus2_id];
  4888.                                                 bonus2 = weapon_bonus_list[bonus2];
  4889.                                             } else if (is_costume_armor){
  4890.                                                 bonus2 = number(0, 6);
  4891.                                                 bonus2_id = number((0+bonus2*3), (2+bonus2*3));
  4892.                                                 bonus2_value = armor_value_list[bonus2_id];
  4893.                                                 bonus2 = armor_bonus_list[bonus2];
  4894.                                             } else if (is_costume_hair){
  4895.                                                 bonus2 = number(0, 7);
  4896.                                                 bonus2_id = number((0+bonus2*3), (2+bonus2*3));
  4897.                                                 bonus2_value = hair_value_list[bonus2_id];
  4898.                                                 bonus2 = hair_bonus_list[bonus2];
  4899.                                             }
  4900.                                         }
  4901.                                         if (bonus_count >= 3){
  4902.                                             if (is_costume_weapon){
  4903.                                                 bonus3 = number(0, 11);
  4904.                                                 bonus3_id = number((0+bonus3*3), (2+bonus3*3));
  4905.                                                 bonus3_value = weapon_value_list[bonus3_id];
  4906.                                                 bonus3 = weapon_bonus_list[bonus3];
  4907.                                             } else if (is_costume_armor){
  4908.                                                 bonus3 = number(0, 6);
  4909.                                                 bonus3_id = number((0+bonus3*3), (2+bonus3*3));
  4910.                                                 bonus3_value = armor_value_list[bonus3_id];
  4911.                                                 bonus3 = armor_bonus_list[bonus3];
  4912.                                             } else if (is_costume_hair){
  4913.                                                 bonus3 = number(0, 7);
  4914.                                                 bonus3_id = number((0+bonus3*3), (2+bonus3*3));
  4915.                                                 bonus3_value = hair_value_list[bonus3_id];
  4916.                                                 bonus3 = hair_bonus_list[bonus3];
  4917.                                             }
  4918.                                         }
  4919.                                         // PASS...
  4920.                                         if (bonus_count == 1 || (bonus_count == 2 && bonus1 != bonus2) || (bonus_count == 3 && bonus1 != bonus2 && bonus1 != bonus3 && bonus2 != bonus3)){
  4921.                                             bonus_number = bonus_count;
  4922.                                         }
  4923.                                     }
  4924.  
  4925.                                     // SET BONUS
  4926.                                     item2->ClearAttribute();
  4927.                                     if (bonus_count >= 1){
  4928.                                         item2->SetForceAttribute(0, bonus1, bonus1_value);
  4929.                                     }
  4930.                                     if (bonus_count >= 2){
  4931.                                         item2->SetForceAttribute(1, bonus2, bonus2_value);
  4932.                                     }
  4933.                                     if (bonus_count >= 3){
  4934.                                         item2->SetForceAttribute(2, bonus3, bonus3_value);
  4935.                                     }
  4936.                                    
  4937.                                     item->SetCount(item->GetCount() - 1);
  4938.                                 }
  4939.                                 break;
  4940.                             */
  4941.  
  4942.                             case ITEM_AUTO_HP_RECOVERY_S:
  4943.                             case ITEM_AUTO_HP_RECOVERY_M:
  4944.                             case ITEM_AUTO_HP_RECOVERY_L:
  4945.                             case ITEM_AUTO_HP_RECOVERY_X:
  4946.                             case ITEM_AUTO_SP_RECOVERY_S:
  4947.                             case ITEM_AUTO_SP_RECOVERY_M:
  4948.                             case ITEM_AUTO_SP_RECOVERY_L:
  4949.                             case ITEM_AUTO_SP_RECOVERY_X:
  4950.                             case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_XS:
  4951.                             case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_S:
  4952.                             case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_XS:
  4953.                             case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_S:
  4954.                             case FUCKING_BRAZIL_ITEM_AUTO_SP_RECOVERY_S:
  4955.                             case FUCKING_BRAZIL_ITEM_AUTO_HP_RECOVERY_S:
  4956.                                 {
  4957.                                     if (!PulseManager::Instance().IncreaseClock(GetPlayerID(), ePulse::UseElixir, std::chrono::milliseconds(5000)))
  4958.                                     {
  4959.                                         ChatPacket(CHAT_TYPE_INFO, "You will be able to use the elixir again in %.2f seconds.", PULSEMANAGER_CLOCK_TO_SEC2(GetPlayerID(), ePulse::UseElixir));
  4960.                                         return false;
  4961.                                     }
  4962.  
  4963.                                     EAffectTypes type = AFFECT_NONE;
  4964.                                     bool isSpecialPotion = false;
  4965.  
  4966.                                     if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true || GetMapIndex() == 213)
  4967.                                     {
  4968.                                         if(isSpecialPotion){
  4969.                                             //EAffectTypes type = AFFECT_NONE;
  4970.                                             isSpecialPotion = false;
  4971.                                         }
  4972.  
  4973.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  4974.                                         return false;
  4975.                                     }
  4976. #ifdef ENABLE_NEWSTUFF
  4977.                                     else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  4978.                                     {
  4979.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  4980.                                         return false;
  4981.                                     }
  4982. #endif
  4983.  
  4984.                                     switch (item->GetVnum())
  4985.                                     {
  4986.                                         case ITEM_AUTO_HP_RECOVERY_X:
  4987.                                             isSpecialPotion = true;
  4988.  
  4989.                                         case ITEM_AUTO_HP_RECOVERY_S:
  4990.                                         case ITEM_AUTO_HP_RECOVERY_M:
  4991.                                         case ITEM_AUTO_HP_RECOVERY_L:
  4992.                                         case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_XS:
  4993.                                         case REWARD_BOX_ITEM_AUTO_HP_RECOVERY_S:
  4994.                                         case FUCKING_BRAZIL_ITEM_AUTO_HP_RECOVERY_S:
  4995.                                             type = AFFECT_AUTO_HP_RECOVERY;
  4996.                                             break;
  4997.  
  4998.                                         case ITEM_AUTO_SP_RECOVERY_X:
  4999.                                             isSpecialPotion = true;
  5000.  
  5001.                                         case ITEM_AUTO_SP_RECOVERY_S:
  5002.                                         case ITEM_AUTO_SP_RECOVERY_M:
  5003.                                         case ITEM_AUTO_SP_RECOVERY_L:
  5004.                                         case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_XS:
  5005.                                         case REWARD_BOX_ITEM_AUTO_SP_RECOVERY_S:
  5006.                                         case FUCKING_BRAZIL_ITEM_AUTO_SP_RECOVERY_S:
  5007.                                             type = AFFECT_AUTO_SP_RECOVERY;
  5008.                                             break;
  5009.                                     }
  5010.  
  5011.                                     if (AFFECT_NONE == type)
  5012.                                         break;
  5013.  
  5014.                                     if (item->GetCount() > 1)
  5015.                                     {
  5016.                                         int pos = GetEmptyInventory(item->GetSize());
  5017.  
  5018.                                         if (-1 == pos)
  5019.                                         {
  5020.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지품에 빈 공간이 없습니다."));
  5021.                                             break;
  5022.                                         }
  5023.  
  5024.                                         item->SetCount( item->GetCount() - 1 );
  5025.  
  5026.                                         LPITEM item2 = ITEM_MANAGER::instance().CreateItem( item->GetVnum(), 1 );
  5027.                                         item2->AddToCharacter(this, TItemPos(INVENTORY, pos));
  5028.  
  5029.                                         if (item->GetSocket(1) != 0)
  5030.                                         {
  5031.                                             item2->SetSocket(1, item->GetSocket(1));
  5032.                                         }
  5033.  
  5034.                                         item = item2;
  5035.                                     }
  5036.  
  5037.                                     CAffect* pAffect = FindAffect( type );
  5038.  
  5039.                                     if (NULL == pAffect)
  5040.                                     {
  5041.                                         EPointTypes bonus = POINT_NONE;
  5042.  
  5043.                                         if (true == isSpecialPotion)
  5044.                                         {
  5045.                                             if (type == AFFECT_AUTO_HP_RECOVERY)
  5046.                                             {
  5047.                                                 bonus = POINT_MAX_HP_PCT;
  5048.                                             }
  5049.                                             else if (type == AFFECT_AUTO_SP_RECOVERY)
  5050.                                             {
  5051.                                                 bonus = POINT_MAX_SP_PCT;
  5052.                                             }
  5053.                                         }
  5054.  
  5055.                                         AddAffect( type, bonus, 4, item->GetID(), INFINITE_AFFECT_DURATION, 0, true, false);
  5056.  
  5057.                                         item->Lock(true);
  5058.                                         item->SetSocket(0, true);
  5059.  
  5060.                                         AutoRecoveryItemProcess( type );
  5061.                                     }
  5062.                                     else
  5063.                                     {
  5064.                                         if (item->GetID() == pAffect->dwFlag)
  5065.                                         {
  5066.                                             RemoveAffect( pAffect );
  5067.  
  5068.                                             item->Lock(false);
  5069.                                             item->SetSocket(0, false);
  5070.                                         }
  5071.                                         else
  5072.                                         {
  5073.                                             LPITEM old = FindItemByID( pAffect->dwFlag );
  5074.  
  5075.                                             if (NULL != old)
  5076.                                             {
  5077.                                                 old->Lock(false);
  5078.                                                 old->SetSocket(0, false);
  5079.                                             }
  5080.  
  5081.                                             RemoveAffect( pAffect );
  5082.  
  5083.                                             EPointTypes bonus = POINT_NONE;
  5084.  
  5085.                                             if (true == isSpecialPotion)
  5086.                                             {
  5087.                                                 if (type == AFFECT_AUTO_HP_RECOVERY)
  5088.                                                 {
  5089.                                                     bonus = POINT_MAX_HP_PCT;
  5090.                                                 }
  5091.                                                 else if (type == AFFECT_AUTO_SP_RECOVERY)
  5092.                                                 {
  5093.                                                     bonus = POINT_MAX_SP_PCT;
  5094.                                                 }
  5095.                                             }
  5096.  
  5097.                                             AddAffect( type, bonus, 4, item->GetID(), INFINITE_AFFECT_DURATION, 0, true, false);
  5098.  
  5099.                                             item->Lock(true);
  5100.                                             item->SetSocket(0, true);
  5101.  
  5102.                                             AutoRecoveryItemProcess( type );
  5103.                                         }
  5104.                                     }
  5105.                                 }
  5106.                                 break;
  5107.                         }
  5108.                         break;
  5109.  
  5110.                     case USE_CLEAR:
  5111.                         {
  5112.                             switch (item->GetVnum())
  5113.                             {
  5114. #ifdef ENABLE_WOLFMAN_CHARACTER
  5115.                                 case 27124: // Bandage
  5116.                                     RemoveBleeding();
  5117.                                     break;
  5118. #endif
  5119.                                 case 27874: // Grilled Perch
  5120.                                 default:
  5121.                                     // RemoveBadAffect();
  5122.                                     RemovePoison();
  5123.                                     RemoveFire();
  5124.                                     RemoveAffect(AFFECT_SLOW);
  5125.                                     break;
  5126.                             }
  5127.                             item->SetCount(item->GetCount() - 1);
  5128.                         }
  5129.                         break;
  5130.  
  5131.                     case USE_INVISIBILITY:
  5132.                         {
  5133.                             if (item->GetVnum() == 70026)
  5134.                             {
  5135.                                 quest::CQuestManager& q = quest::CQuestManager::instance();
  5136.                                 quest::PC* pPC = q.GetPC(GetPlayerID());
  5137.  
  5138.                                 if (pPC != NULL)
  5139.                                 {
  5140.                                     int last_use_time = pPC->GetFlag("mirror_of_disapper.last_use_time");
  5141.  
  5142.                                     if (get_global_time() - last_use_time < 10*60)
  5143.                                     {
  5144.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 사용할 수 없습니다."));
  5145.                                         return false;
  5146.                                     }
  5147.  
  5148.                                     pPC->SetFlag("mirror_of_disapper.last_use_time", get_global_time());
  5149.                                 }
  5150.                             }
  5151.  
  5152.                             AddAffect(AFFECT_INVISIBILITY, POINT_NONE, 0, AFF_INVISIBILITY, 300, 0, true);
  5153.                             item->SetCount(item->GetCount() - 1);
  5154.                         }
  5155.                         break;
  5156.  
  5157.                     case USE_POTION_NODELAY:
  5158.                         {
  5159.                             if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  5160.                             {
  5161.                                 if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
  5162.                                 {
  5163.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  5164.                                     return false;
  5165.                                 }
  5166.  
  5167.                                 switch (item->GetVnum())
  5168.                                 {
  5169.                                     case 70020 :
  5170.                                     case 71018 :
  5171.                                     case 71019 :
  5172.                                     case 71020 :
  5173.                                         if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
  5174.                                         {
  5175.                                             if (m_nPotionLimit <= 0)
  5176.                                             {
  5177.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용 제한량을 초과하였습니다."));
  5178.                                                 return false;
  5179.                                             }
  5180.                                         }
  5181.                                         break;
  5182.  
  5183.                                     default :
  5184.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  5185.                                         return false;
  5186.                                 }
  5187.                             }
  5188. #ifdef ENABLE_NEWSTUFF
  5189.                             else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  5190.                             {
  5191.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  5192.                                 return false;
  5193.                             }
  5194. #endif
  5195.  
  5196.                             bool used = false;
  5197.  
  5198.                             if (item->GetValue(0) != 0)
  5199.                             {
  5200.                                 if (GetHP() < GetMaxHP())
  5201.                                 {
  5202.                                     PointChange(POINT_HP, item->GetValue(0) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  5203.                                     EffectPacket(SE_HPUP_RED);
  5204.                                     used = TRUE;
  5205.                                 }
  5206.                             }
  5207.  
  5208.                             if (item->GetValue(1) != 0)
  5209.                             {
  5210.                                 if (GetSP() < GetMaxSP())
  5211.                                 {
  5212.                                     PointChange(POINT_SP, item->GetValue(1) * (100 + GetPoint(POINT_POTION_BONUS)) / 100);
  5213.                                     EffectPacket(SE_SPUP_BLUE);
  5214.                                     used = TRUE;
  5215.                                 }
  5216.                             }
  5217.  
  5218.                             if (item->GetValue(3) != 0)
  5219.                             {
  5220.                                 if (GetHP() < GetMaxHP())
  5221.                                 {
  5222.                                     PointChange(POINT_HP, item->GetValue(3) * GetMaxHP() / 100);
  5223.                                     EffectPacket(SE_HPUP_RED);
  5224.                                     used = TRUE;
  5225.                                 }
  5226.                             }
  5227.  
  5228.                             if (item->GetValue(4) != 0)
  5229.                             {
  5230.                                 if (GetSP() < GetMaxSP())
  5231.                                 {
  5232.                                     PointChange(POINT_SP, item->GetValue(4) * GetMaxSP() / 100);
  5233.                                     EffectPacket(SE_SPUP_BLUE);
  5234.                                     used = TRUE;
  5235.                                 }
  5236.                             }
  5237.  
  5238.                             if (used)
  5239.                             {
  5240.                                 if (item->GetVnum() == 50085 || item->GetVnum() == 50086)
  5241.                                 {
  5242.                                     if (test_server)
  5243.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("월병 또는 종자 를 사용하였습니다"));
  5244.                                     SetUseSeedOrMoonBottleTime();
  5245.                                 }
  5246.                                 if (GetDungeon())
  5247.                                     GetDungeon()->UsePotion(this);
  5248.  
  5249.                                 if (GetWarMap())
  5250.                                     GetWarMap()->UsePotion(this, item);
  5251.  
  5252.                                 m_nPotionLimit--;
  5253.  
  5254.                                 //RESTRICT_USE_SEED_OR_MOONBOTTLE
  5255.                                 item->SetCount(item->GetCount() - 1);
  5256.                                 //END_RESTRICT_USE_SEED_OR_MOONBOTTLE
  5257.                             }
  5258.                         }
  5259.                         break;
  5260.  
  5261.                     case USE_POTION:
  5262.                         if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  5263.                         {
  5264.                             if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit") > 0)
  5265.                             {
  5266.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  5267.                                 return false;
  5268.                             }
  5269.  
  5270.                             switch (item->GetVnum())
  5271.                             {
  5272.                                 case 27001 :
  5273.                                 case 27002 :
  5274.                                 case 27003 :
  5275.                                 case 27004 :
  5276.                                 case 27005 :
  5277.                                 case 27006 :
  5278.                                     if (quest::CQuestManager::instance().GetEventFlag("arena_potion_limit_count") < 10000)
  5279.                                     {
  5280.                                         if (m_nPotionLimit <= 0)
  5281.                                         {
  5282.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("사용 제한량을 초과하였습니다."));
  5283.                                             return false;
  5284.                                         }
  5285.                                     }
  5286.                                     break;
  5287.  
  5288.                                 default :
  5289.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련장에서 사용하실 수 없습니다."));
  5290.                                     return false;
  5291.                             }
  5292.                         }
  5293. #ifdef ENABLE_NEWSTUFF
  5294.                         else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  5295.                         {
  5296.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  5297.                             return false;
  5298.                         }
  5299. #endif
  5300.  
  5301.                         if (item->GetValue(1) != 0)
  5302.                         {
  5303.                             if (GetPoint(POINT_SP_RECOVERY) + GetSP() >= GetMaxSP())
  5304.                             {
  5305.                                 return false;
  5306.                             }
  5307.  
  5308.                             PointChange(POINT_SP_RECOVERY, item->GetValue(1) * MIN(200, (100 + GetPoint(POINT_POTION_BONUS))) / 100);
  5309.                             StartAffectEvent();
  5310.                             EffectPacket(SE_SPUP_BLUE);
  5311.                         }
  5312.  
  5313.                         if (item->GetValue(0) != 0)
  5314.                         {
  5315.                             if (GetPoint(POINT_HP_RECOVERY) + GetHP() >= GetMaxHP())
  5316.                             {
  5317.                                 return false;
  5318.                             }
  5319.  
  5320.                             PointChange(POINT_HP_RECOVERY, item->GetValue(0) * MIN(200, (100 + GetPoint(POINT_POTION_BONUS))) / 100);
  5321.                             StartAffectEvent();
  5322.                             EffectPacket(SE_HPUP_RED);
  5323.                         }
  5324.  
  5325.                         if (GetDungeon())
  5326.                             GetDungeon()->UsePotion(this);
  5327.  
  5328.                         if (GetWarMap())
  5329.                             GetWarMap()->UsePotion(this, item);
  5330.  
  5331.                         item->SetCount(item->GetCount() - 1);
  5332.                         m_nPotionLimit--;
  5333.                         break;
  5334.  
  5335.                     case USE_POTION_CONTINUE:
  5336.                         {
  5337.                             if (item->GetValue(0) != 0)
  5338.                             {
  5339.                                 AddAffect(AFFECT_HP_RECOVER_CONTINUE, POINT_HP_RECOVER_CONTINUE, item->GetValue(0), 0, item->GetValue(2), 0, true);
  5340.                             }
  5341.                             else if (item->GetValue(1) != 0)
  5342.                             {
  5343.                                 AddAffect(AFFECT_SP_RECOVER_CONTINUE, POINT_SP_RECOVER_CONTINUE, item->GetValue(1), 0, item->GetValue(2), 0, true);
  5344.                             }
  5345.                             else
  5346.                                 return false;
  5347.                         }
  5348.  
  5349.                         if (GetDungeon())
  5350.                             GetDungeon()->UsePotion(this);
  5351.  
  5352.                         if (GetWarMap())
  5353.                             GetWarMap()->UsePotion(this, item);
  5354.  
  5355.                         item->SetCount(item->GetCount() - 1);
  5356.                         break;
  5357.  
  5358.                     case USE_ABILITY_UP:
  5359.                         {
  5360.                             switch (item->GetValue(0))
  5361.                             {
  5362.                                 case APPLY_MOV_SPEED:
  5363.                                     AddAffect(AFFECT_MOV_SPEED, POINT_MOV_SPEED, item->GetValue(2), AFF_MOV_SPEED_POTION, item->GetValue(1), 0, true);
  5364. #ifdef ENABLE_EFFECT_EXTRAPOT
  5365.                                     EffectPacket(SE_DXUP_PURPLE);
  5366. #endif
  5367.                                     break;
  5368.  
  5369.                                 case APPLY_ATT_SPEED:
  5370.                                     AddAffect(AFFECT_ATT_SPEED, POINT_ATT_SPEED, item->GetValue(2), AFF_ATT_SPEED_POTION, item->GetValue(1), 0, true);
  5371. #ifdef ENABLE_EFFECT_EXTRAPOT
  5372.                                     EffectPacket(SE_SPEEDUP_GREEN);
  5373. #endif
  5374.                                     break;
  5375.  
  5376.                                 case APPLY_STR:
  5377.                                     AddAffect(AFFECT_STR, POINT_ST, item->GetValue(2), 0, item->GetValue(1), 0, true);
  5378.                                     break;
  5379.  
  5380.                                 case APPLY_DEX:
  5381.                                     AddAffect(AFFECT_DEX, POINT_DX, item->GetValue(2), 0, item->GetValue(1), 0, true);
  5382.                                     break;
  5383.  
  5384.                                 case APPLY_CON:
  5385.                                     AddAffect(AFFECT_CON, POINT_HT, item->GetValue(2), 0, item->GetValue(1), 0, true);
  5386.                                     break;
  5387.  
  5388.                                 case APPLY_INT:
  5389.                                     AddAffect(AFFECT_INT, POINT_IQ, item->GetValue(2), 0, item->GetValue(1), 0, true);
  5390.                                     break;
  5391.  
  5392.                                 case APPLY_CAST_SPEED:
  5393.                                     AddAffect(AFFECT_CAST_SPEED, POINT_CASTING_SPEED, item->GetValue(2), 0, item->GetValue(1), 0, true);
  5394.                                     break;
  5395.  
  5396.                                 case APPLY_ATT_GRADE_BONUS:
  5397.                                     AddAffect(AFFECT_ATT_GRADE, POINT_ATT_GRADE_BONUS,
  5398.                                             item->GetValue(2), 0, item->GetValue(1), 0, true);
  5399.                                     break;
  5400.  
  5401.                                 case APPLY_DEF_GRADE_BONUS:
  5402.                                     AddAffect(AFFECT_DEF_GRADE, POINT_DEF_GRADE_BONUS,
  5403.                                             item->GetValue(2), 0, item->GetValue(1), 0, true);
  5404.                                     break;
  5405.                             }
  5406.                         }
  5407.  
  5408.                         if (GetDungeon())
  5409.                             GetDungeon()->UsePotion(this);
  5410.  
  5411.                         if (GetWarMap())
  5412.                             GetWarMap()->UsePotion(this, item);
  5413.  
  5414.                         item->SetCount(item->GetCount() - 1);
  5415.                         break;
  5416.  
  5417.                     case USE_TALISMAN:
  5418.                         {
  5419.                             const int TOWN_PORTAL   = 1;
  5420.                             const int MEMORY_PORTAL = 2;
  5421.  
  5422.  
  5423.                            
  5424.                             if (GetMapIndex() == 200 || GetMapIndex() == 113)
  5425.                             {
  5426.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("현재 위치에서 사용할 수 없습니다."));
  5427.                                 return false;
  5428.                             }
  5429.  
  5430.                             if (CArenaManager::instance().IsArenaMap(GetMapIndex()) == true)
  5431.                             {
  5432.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  5433.                                 return false;
  5434.                             }
  5435. #ifdef ENABLE_NEWSTUFF
  5436.                             else if (g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(item->GetVnum()))
  5437.                             {
  5438.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("대련 중에는 이용할 수 없는 물품입니다."));
  5439.                                 return false;
  5440.                             }
  5441. #endif
  5442.  
  5443.                             if (m_pkWarpEvent)
  5444.                             {
  5445.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이동할 준비가 되어있음으로 귀환부를 사용할수 없습니다"));
  5446.                                 return false;
  5447.                             }
  5448.  
  5449.                             // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  5450.                             int consumeLife = CalculateConsume(this);
  5451.  
  5452.                             if (consumeLife < 0)
  5453.                                 return false;
  5454.                             // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  5455.  
  5456.                             if (item->GetValue(0) == TOWN_PORTAL)
  5457.                             {
  5458.                                 if (item->GetSocket(0) == 0)
  5459.                                 {
  5460.                                     if (!GetDungeon())
  5461.                                         if (!GiveRecallItem(item))
  5462.                                             return false;
  5463.  
  5464.                                     PIXEL_POSITION posWarp;
  5465.  
  5466.                                     if (SECTREE_MANAGER::instance().GetRecallPositionByEmpire(GetMapIndex(), GetEmpire(), posWarp))
  5467.                                     {
  5468.                                         // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  5469.                                         PointChange(POINT_HP, -consumeLife, false);
  5470.                                         // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  5471.  
  5472.                                         WarpSet(posWarp.x, posWarp.y);
  5473.                                     }
  5474.                                     else
  5475.                                     {
  5476.                                         sys_err("CHARACTER::UseItem : cannot find spawn position (name %s, %d x %d)", GetName(), GetX(), GetY());
  5477.                                     }
  5478.                                 }
  5479.                                 else
  5480.                                 {
  5481.                                     if (test_server)
  5482.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("원래 위치로 복귀"));
  5483.  
  5484.                                     ProcessRecallItem(item);
  5485.                                 }
  5486.                             }
  5487.                             else if (item->GetValue(0) == MEMORY_PORTAL)
  5488.                             {
  5489.                                 if (item->GetSocket(0) == 0)
  5490.                                 {
  5491.                                     if (GetDungeon())
  5492.                                     {
  5493.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("던전 안에서는 %s%s 사용할 수 없습니다."),
  5494.                                                 item->GetName(),
  5495.                                                 "");
  5496.                                         return false;
  5497.                                     }
  5498.  
  5499.                                     if (!GiveRecallItem(item))
  5500.                                         return false;
  5501.                                 }
  5502.                                 else
  5503.                                 {
  5504.                                     // CONSUME_LIFE_WHEN_USE_WARP_ITEM
  5505.                                     PointChange(POINT_HP, -consumeLife, false);
  5506.                                     // END_OF_CONSUME_LIFE_WHEN_USE_WARP_ITEM
  5507.  
  5508.                                     ProcessRecallItem(item);
  5509.                                 }
  5510.                             }
  5511.                         }
  5512.                         break;
  5513.  
  5514.                     case USE_TUNING:
  5515.                     case USE_DETACHMENT:
  5516.                         {
  5517.                             LPITEM item2;
  5518.  
  5519.                             if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  5520.                                 return false;
  5521.  
  5522.                             if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  5523.                                 return false;
  5524.  
  5525.                             if (item2->GetVnum() >= 28330 && item2->GetVnum() <= 28343)
  5526.                             {
  5527.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("+3 영석은 이 아이템으로 개량할 수 없습니다"));
  5528.                                 return false;
  5529.                             }
  5530. #ifdef ENABLE_ACCE_SYSTEM
  5531.                             if (item->GetValue(0) == ACCE_CLEAN_ATTR_VALUE0
  5532.                                 || item->GetVnum() == ACCE_REVERSAL_VNUM_1
  5533.                                 || item->GetVnum() == ACCE_REVERSAL_VNUM_2
  5534.                             )
  5535.                             {
  5536.                                 if (!CleanAcceAttr(item, item2))
  5537.                                     return false;
  5538.                                 item->SetCount(item->GetCount()-1);
  5539.                                 return true;
  5540.                             }
  5541. #endif
  5542. #if defined(__SOUL_SYSTEM__)
  5543.                             if (item->GetValue(0) == SOUL_AWAKE_SCROLL || item->GetValue(0) == SOUL_EVOLVE_SCROLL)
  5544.                             {
  5545.                                 if (item2->GetValue(0) >= SOUL_GRADE_ILUMINED)
  5546.                                 {
  5547.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("[Soul System] %s is already at the highest level."), item2->GetName());
  5548.                                     return false;
  5549.                                 }
  5550.                             }
  5551. #endif
  5552.                             if (item2->GetVnum() >= 28430 && item2->GetVnum() <= 28443)  
  5553.                             {
  5554.                                 if (item->GetVnum() == 71056)
  5555.                                 {
  5556.                                     RefineItem(item, item2);
  5557.                                 }
  5558.                                 else
  5559.                                 {
  5560.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("영석은 이 아이템으로 개량할 수 없습니다"));
  5561.                                 }
  5562.                             }
  5563.  
  5564.                             else
  5565.                             {
  5566.                                 RefineItem(item, item2);
  5567.                             }
  5568.                         }
  5569.                         break;
  5570.  
  5571.                     case USE_CHANGE_COSTUME_ATTR:
  5572.                     case USE_RESET_COSTUME_ATTR:
  5573.                         {
  5574.                             LPITEM item2;
  5575.                             if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  5576.                                 return false;
  5577.  
  5578.                             if (item2->IsEquipped())
  5579.                             {
  5580.                                 BuffOnAttr_RemoveBuffsFromItem(item2);
  5581.                             }
  5582.  
  5583.                             if (ITEM_COSTUME != item2->GetType())
  5584.                             {
  5585.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  5586.                                 return false;
  5587.                             }
  5588.  
  5589.                             if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  5590.                                 return false;
  5591.  
  5592.                             if (item2->GetAttributeSetIndex() == -1)
  5593.                             {
  5594.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  5595.                                 return false;
  5596.                             }
  5597.  
  5598.                             if (item2->GetAttributeCount() == 0)
  5599.                             {
  5600.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변경할 속성이 없습니다."));
  5601.                                 return false;
  5602.                             }
  5603.  
  5604.                             switch (item->GetSubType())
  5605.                             {
  5606.                                 case USE_CHANGE_COSTUME_ATTR:
  5607.                                     item2->ChangeAttribute();
  5608.                                     {
  5609.                                         char buf[21];
  5610.                                         snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5611.                                         LogManager::instance().ItemLog(this, item, "CHANGE_COSTUME_ATTR", buf);
  5612.                                     }
  5613.                                     break;
  5614.                                 case USE_RESET_COSTUME_ATTR:
  5615.                                     item2->ClearAttribute();
  5616.                                     item2->AlterToMagicItem();
  5617.                                     {
  5618.                                         char buf[21];
  5619.                                         snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5620.                                         LogManager::instance().ItemLog(this, item, "RESET_COSTUME_ATTR", buf);
  5621.                                     }
  5622.                                     break;
  5623.                             }
  5624.  
  5625.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경하였습니다."));
  5626.  
  5627.                             item->SetCount(item->GetCount() - 1);
  5628.                             break;
  5629.                         }
  5630.  
  5631.                         //  ACCESSORY_REFINE & ADD/CHANGE_ATTRIBUTES
  5632.                     case USE_PUT_INTO_BELT_SOCKET:
  5633.                     case USE_PUT_INTO_RING_SOCKET:
  5634.                     case USE_PUT_INTO_ACCESSORY_SOCKET:
  5635.                     case USE_ADD_ACCESSORY_SOCKET:
  5636.                     case USE_CLEAN_SOCKET:
  5637.                     case USE_CHANGE_ATTRIBUTE:
  5638.                     case USE_CHANGE_ATTRIBUTE2 :
  5639.                     case USE_ADD_ATTRIBUTE:
  5640.                     case USE_ADD_ATTRIBUTE2:
  5641.                         {
  5642.                             LPITEM item2;
  5643.                             if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  5644.                                 return false;
  5645.  
  5646.                             if (item2->IsEquipped())
  5647.                             {
  5648.                                 BuffOnAttr_RemoveBuffsFromItem(item2);
  5649.                             }
  5650.  
  5651.                            
  5652.                            
  5653.                            
  5654.                             if (ITEM_COSTUME == item2->GetType())
  5655.                             {
  5656.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  5657.                                 return false;
  5658.                             }
  5659.  
  5660.                             if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  5661.                                 return false;
  5662.  
  5663.                             switch (item->GetSubType())
  5664.                             {
  5665.                                 case USE_CLEAN_SOCKET:
  5666.                                     {
  5667.                                         int i;
  5668.                                         for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  5669.                                         {
  5670.                                             if (item2->GetSocket(i) == ITEM_BROKEN_METIN_VNUM)
  5671.                                                 break;
  5672.                                         }
  5673.  
  5674.                                         if (i == ITEM_SOCKET_MAX_NUM)
  5675.                                         {
  5676.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("청소할 석이 박혀있지 않습니다."));
  5677.                                             return false;
  5678.                                         }
  5679.  
  5680.                                         int j = 0;
  5681.  
  5682.                                         for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  5683.                                         {
  5684.                                             if (item2->GetSocket(i) != ITEM_BROKEN_METIN_VNUM && item2->GetSocket(i) != 0)
  5685.                                                 item2->SetSocket(j++, item2->GetSocket(i));
  5686.                                         }
  5687.  
  5688.                                         for (; j < ITEM_SOCKET_MAX_NUM; ++j)
  5689.                                         {
  5690.                                             if (item2->GetSocket(j) > 0)
  5691.                                                 item2->SetSocket(j, 1);
  5692.                                         }
  5693.  
  5694.                                         {
  5695.                                             char buf[21];
  5696.                                             snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5697.                                             LogManager::instance().ItemLog(this, item, "CLEAN_SOCKET", buf);
  5698.                                         }
  5699.  
  5700.                                         item->SetCount(item->GetCount() - 1);
  5701.  
  5702.                                     }
  5703.                                     break;
  5704.  
  5705.                                 case USE_CHANGE_ATTRIBUTE :
  5706.                                 case USE_CHANGE_ATTRIBUTE2 : // @fixme123
  5707.                                     if (item2->GetAttributeSetIndex() == -1)
  5708.                                     {
  5709.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  5710.                                         return false;
  5711.                                     }
  5712.  
  5713.                                     if (item2->GetAttributeCount() == 0)
  5714.                                     {
  5715.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("변경할 속성이 없습니다."));
  5716.                                         return false;
  5717.                                     }
  5718.  
  5719.                                     if ((GM_PLAYER == GetGMLevel()) && (false == test_server) && (g_dwItemBonusChangeTime > 0))
  5720.                                     {
  5721.                                         DWORD dwChangeItemAttrCycle = g_dwItemBonusChangeTime;
  5722.  
  5723.                                         quest::PC* pPC = quest::CQuestManager::instance().GetPC(GetPlayerID());
  5724.  
  5725.                                         if (pPC)
  5726.                                         {
  5727.                                             DWORD dwNowSec = get_global_time();
  5728.  
  5729.                                             DWORD dwLastChangeItemAttrSec = pPC->GetFlag(msc_szLastChangeItemAttrFlag);
  5730.  
  5731.                                             if (dwLastChangeItemAttrSec + dwChangeItemAttrCycle > dwNowSec)
  5732.                                             {
  5733.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 바꾼지 %d분 이내에는 다시 변경할 수 없습니다.(%d 분 남음)"),
  5734.                                                         dwChangeItemAttrCycle, dwChangeItemAttrCycle - (dwNowSec - dwLastChangeItemAttrSec));
  5735.                                                 return false;
  5736.                                             }
  5737.  
  5738.                                             pPC->SetFlag(msc_szLastChangeItemAttrFlag, dwNowSec);
  5739.                                         }
  5740.                                     }
  5741.  
  5742.                                     if (item->GetSubType() == USE_CHANGE_ATTRIBUTE2)
  5743.                                     {
  5744.                                         int aiChangeProb[ITEM_ATTRIBUTE_MAX_LEVEL] =
  5745.                                         {
  5746.                                             0, 0, 30, 40, 3
  5747.                                         };
  5748.  
  5749.                                         item2->ChangeAttribute(aiChangeProb);
  5750.                                     }
  5751.                                     else if (item->GetVnum() == 76014)
  5752.                                     {
  5753.                                         int aiChangeProb[ITEM_ATTRIBUTE_MAX_LEVEL] =
  5754.                                         {
  5755.                                             0, 10, 50, 39, 1
  5756.                                         };
  5757.  
  5758.                                         item2->ChangeAttribute(aiChangeProb);
  5759.                                     }
  5760.  
  5761.                                     else
  5762.                                     {
  5763.                                        
  5764.                                        
  5765.                                         if (item->GetVnum() == 71151 || item->GetVnum() == 76023)
  5766.                                         {
  5767.                                             if ((item2->GetType() == ITEM_WEAPON)
  5768.                                                 || (item2->GetType() == ITEM_ARMOR && item2->GetSubType() == ARMOR_BODY))
  5769.                                             {
  5770.                                                 bool bCanUse = true;
  5771.                                                 for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  5772.                                                 {
  5773.                                                     if (item2->GetLimitType(i) == LIMIT_LEVEL && item2->GetLimitValue(i) > 40)
  5774.                                                     {
  5775.                                                         bCanUse = false;
  5776.                                                         break;
  5777.                                                     }
  5778.                                                 }
  5779.                                                 if (false == bCanUse)
  5780.                                                 {
  5781.                                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("적용 레벨보다 높아 사용이 불가능합니다."));
  5782.                                                     break;
  5783.                                                 }
  5784.                                             }
  5785.                                             else
  5786.                                             {
  5787.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무기와 갑옷에만 사용 가능합니다."));
  5788.                                                 break;
  5789.                                             }
  5790.                                         }
  5791.                                         item2->ChangeAttribute();
  5792.                                     }
  5793.  
  5794.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경하였습니다."));
  5795.                                     {
  5796.                                         char buf[21];
  5797.                                         snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5798.                                         LogManager::instance().ItemLog(this, item, "CHANGE_ATTRIBUTE", buf);
  5799.                                     }
  5800.  
  5801.                                     item->SetCount(item->GetCount() - 1);
  5802.                                     break;
  5803.  
  5804.                                 case USE_ADD_ATTRIBUTE :
  5805.                                     if (item2->GetAttributeSetIndex() == -1)
  5806.                                     {
  5807.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  5808.                                         return false;
  5809.                                     }
  5810.  
  5811.                                     if (item2->GetAttributeCount() < 4)
  5812.                                     {
  5813.                                        
  5814.                                        
  5815.                                         if (item->GetVnum() == 71152 || item->GetVnum() == 76024)
  5816.                                         {
  5817.                                             if ((item2->GetType() == ITEM_WEAPON)
  5818.                                                 || (item2->GetType() == ITEM_ARMOR && item2->GetSubType() == ARMOR_BODY))
  5819.                                             {
  5820.                                                 bool bCanUse = true;
  5821.                                                 for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  5822.                                                 {
  5823.                                                     if (item2->GetLimitType(i) == LIMIT_LEVEL && item2->GetLimitValue(i) > 40)
  5824.                                                     {
  5825.                                                         bCanUse = false;
  5826.                                                         break;
  5827.                                                     }
  5828.                                                 }
  5829.                                                 if (false == bCanUse)
  5830.                                                 {
  5831.                                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("적용 레벨보다 높아 사용이 불가능합니다."));
  5832.                                                     break;
  5833.                                                 }
  5834.                                             }
  5835.                                             else
  5836.                                             {
  5837.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("무기와 갑옷에만 사용 가능합니다."));
  5838.                                                 break;
  5839.                                             }
  5840.                                         }
  5841.                                         char buf[21];
  5842.                                         snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5843.  
  5844.                                         if (number(1, 100) <= aiItemAttributeAddPercent[item2->GetAttributeCount()])
  5845.                                         {
  5846.                                             item2->AddAttribute();
  5847.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 성공하였습니다."));
  5848.  
  5849.                                             int iAddedIdx = item2->GetAttributeCount() - 1;
  5850.                                             LogManager::instance().ItemLog(
  5851.                                                     GetPlayerID(),
  5852.                                                     item2->GetAttributeType(iAddedIdx),
  5853.                                                     item2->GetAttributeValue(iAddedIdx),
  5854.                                                     item->GetID(),
  5855.                                                     "ADD_ATTRIBUTE_SUCCESS",
  5856.                                                     buf,
  5857.                                                     GetDesc()->GetHostName(),
  5858.                                                     item->GetOriginalVnum());
  5859.                                         }
  5860.                                         else
  5861.                                         {
  5862.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 실패하였습니다."));
  5863.                                             LogManager::instance().ItemLog(this, item, "ADD_ATTRIBUTE_FAIL", buf);
  5864.                                         }
  5865.  
  5866.                                         item->SetCount(item->GetCount() - 1);
  5867.                                     }
  5868.                                     else
  5869.                                     {
  5870.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더이상 이 아이템을 이용하여 속성을 추가할 수 없습니다."));
  5871.                                     }
  5872.                                     break;
  5873.  
  5874.                                 case USE_ADD_ATTRIBUTE2 :
  5875.                                    
  5876.                                    
  5877.                                     if (item2->GetAttributeSetIndex() == -1)
  5878.                                     {
  5879.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성을 변경할 수 없는 아이템입니다."));
  5880.                                         return false;
  5881.                                     }
  5882.  
  5883.                                    
  5884.                                     if (item2->GetAttributeCount() == 4)
  5885.                                     {
  5886.                                         char buf[21];
  5887.                                         snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5888.  
  5889.                                         if (number(1, 100) <= aiItemAttributeAddPercent[item2->GetAttributeCount()])
  5890.                                         {
  5891.                                             item2->AddAttribute();
  5892.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 성공하였습니다."));
  5893.  
  5894.                                             int iAddedIdx = item2->GetAttributeCount() - 1;
  5895.                                             LogManager::instance().ItemLog(
  5896.                                                     GetPlayerID(),
  5897.                                                     item2->GetAttributeType(iAddedIdx),
  5898.                                                     item2->GetAttributeValue(iAddedIdx),
  5899.                                                     item->GetID(),
  5900.                                                     "ADD_ATTRIBUTE2_SUCCESS",
  5901.                                                     buf,
  5902.                                                     GetDesc()->GetHostName(),
  5903.                                                     item->GetOriginalVnum());
  5904.                                         }
  5905.                                         else
  5906.                                         {
  5907.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("속성 추가에 실패하였습니다."));
  5908.                                             LogManager::instance().ItemLog(this, item, "ADD_ATTRIBUTE2_FAIL", buf);
  5909.                                         }
  5910.  
  5911.                                         item->SetCount(item->GetCount() - 1);
  5912.                                     }
  5913.                                     else if (item2->GetAttributeCount() == 5)
  5914.                                     {
  5915.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("더 이상 이 아이템을 이용하여 속성을 추가할 수 없습니다."));
  5916.                                     }
  5917.                                     else if (item2->GetAttributeCount() < 4)
  5918.                                     {
  5919.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("먼저 재가비서를 이용하여 속성을 추가시켜 주세요."));
  5920.                                     }
  5921.                                     else
  5922.                                     {
  5923.                                         // wtf ?!
  5924.                                         sys_err("ADD_ATTRIBUTE2 : Item has wrong AttributeCount(%d)", item2->GetAttributeCount());
  5925.                                     }
  5926.                                     break;
  5927.  
  5928.                                 case USE_ADD_ACCESSORY_SOCKET:
  5929.                                     {
  5930.                                         char buf[21];
  5931.                                         snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5932.  
  5933.                                         if (item2->IsAccessoryForSocket())
  5934.                                         {
  5935.                                             if (item2->GetAccessorySocketMaxGrade() < ITEM_ACCESSORY_SOCKET_MAX_NUM)
  5936.                                             {
  5937.                                                 if (number(1, 100) <= 100)
  5938.                                                 {
  5939.                                                     item2->SetAccessorySocketMaxGrade(item2->GetAccessorySocketMaxGrade() + 1);
  5940.                                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소켓이 성공적으로 추가되었습니다."));
  5941.                                                     LogManager::instance().ItemLog(this, item, "ADD_SOCKET_SUCCESS", buf);
  5942.                                                 }
  5943.                                                 else
  5944.                                                 {
  5945.                                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소켓 추가에 실패하였습니다."));
  5946.                                                     LogManager::instance().ItemLog(this, item, "ADD_SOCKET_FAIL", buf);
  5947.                                                 }
  5948.  
  5949.                                                 item->SetCount(item->GetCount() - 1);
  5950.                                             }
  5951.                                             else
  5952.                                             {
  5953.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 액세서리에는 더이상 소켓을 추가할 공간이 없습니다."));
  5954.                                             }
  5955.                                         }
  5956.                                         else
  5957.                                         {
  5958.                                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템으로 소켓을 추가할 수 없는 아이템입니다."));
  5959.                                         }
  5960.                                     }
  5961.                                     break;
  5962.  
  5963.                                 case USE_PUT_INTO_BELT_SOCKET:
  5964.                                 case USE_PUT_INTO_ACCESSORY_SOCKET:
  5965.                                     if (item2->IsAccessoryForSocket() && item->CanPutInto(item2))
  5966.                                     {
  5967.                                         char buf[21];
  5968.                                         snprintf(buf, sizeof(buf), "%u", item2->GetID());
  5969.  
  5970.                                         if (item2->GetAccessorySocketGrade() < item2->GetAccessorySocketMaxGrade())
  5971.                                         // if (item2->GetAccessorySocketGrade() <= item2->GetAccessorySocketMaxGrade())
  5972.                                         {
  5973.                                             if (number(1, 100) <= aiAccessorySocketPutPct[item2->GetAccessorySocketGrade()])
  5974.                                             {
  5975.                                                 item2->SetAccessorySocketGrade(item2->GetAccessorySocketGrade() + 1);
  5976.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("장착에 성공하였습니다."));
  5977.                                                 LogManager::instance().ItemLog(this, item, "PUT_SOCKET_SUCCESS", buf);
  5978.                                             }
  5979.                                             else
  5980.                                             {
  5981.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("장착에 실패하였습니다."));
  5982.                                                 LogManager::instance().ItemLog(this, item, "PUT_SOCKET_FAIL", buf);
  5983.                                             }
  5984.  
  5985.                                             item->SetCount(item->GetCount() - 1);
  5986.                                         }
  5987.                                         else
  5988.                                         {
  5989.                                             if (item2->GetAccessorySocketMaxGrade() == 0)
  5990.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("먼저 다이아몬드로 악세서리에 소켓을 추가해야합니다."));
  5991.                                             else if (item2->GetAccessorySocketMaxGrade() < ITEM_ACCESSORY_SOCKET_MAX_NUM)
  5992.                                             {
  5993.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 액세서리에는 더이상 장착할 소켓이 없습니다."));
  5994.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("다이아몬드로 소켓을 추가해야합니다."));
  5995.                                             }
  5996.                                             else
  5997.                                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 액세서리에는 더이상 보석을 장착할 수 없습니다."));
  5998.                                         }
  5999.                                     }
  6000.                                     else
  6001.                                     {
  6002.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템을 장착할 수 없습니다."));
  6003.                                     }
  6004.                                     break;
  6005.                             }
  6006.                             if (item2->IsEquipped())
  6007.                             {
  6008.                                 BuffOnAttr_AddBuffsFromItem(item2);
  6009.                             }
  6010.                         }
  6011.                         break;
  6012.                         //  END_OF_ACCESSORY_REFINE & END_OF_ADD_ATTRIBUTES & END_OF_CHANGE_ATTRIBUTES
  6013.  
  6014.                     case USE_BAIT:
  6015.                         {
  6016.  
  6017.                             if (m_pkFishingEvent)
  6018.                             {
  6019.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("낚시 중에 미끼를 갈아끼울 수 없습니다."));
  6020.                                 return false;
  6021.                             }
  6022.  
  6023.                             LPITEM weapon = GetWear(WEAR_WEAPON);
  6024.  
  6025.                             if (!weapon || weapon->GetType() != ITEM_ROD)
  6026.                                 return false;
  6027.  
  6028.                             if (weapon->GetSocket(2))
  6029.                             {
  6030.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 꽂혀있던 미끼를 빼고 %s를 끼웁니다."), item->GetName());
  6031.                             }
  6032.                             else
  6033.                             {
  6034.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("낚시대에 %s를 미끼로 끼웁니다."), item->GetName());
  6035.                             }
  6036.  
  6037.                             weapon->SetSocket(2, item->GetValue(0));
  6038.                             item->SetCount(item->GetCount() - 1);
  6039.                         }
  6040.                         break;
  6041.  
  6042.                     case USE_MOVE:
  6043.                     case USE_TREASURE_BOX:
  6044.                     case USE_MONEYBAG:
  6045.                         break;
  6046.  
  6047. #ifdef ENABLE_AFFECT_ITEMS_PLUS
  6048.                     case USE_AFFECT :
  6049.                         {
  6050.                             if (!PulseManager::Instance().IncreaseClock(GetPlayerID(), ePulse::UseAffectItem, std::chrono::milliseconds(5000)))
  6051.                             {
  6052.                                 ChatPacket(CHAT_TYPE_INFO, "You will be able to use this item again in %.2f seconds.", PULSEMANAGER_CLOCK_TO_SEC2(GetPlayerID(), ePulse::UseAffectItem));
  6053.                                 return false;
  6054.                             }
  6055.  
  6056.                             #if defined(__BL_OFFICIAL_LOOT_FILTER__) && defined(__PREMIUM_LOOT_FILTER__)
  6057.                             if (item->GetValue(0) == AFFECT_LOOTING_SYSTEM)
  6058.                             {
  6059.                                 CAffect* pkAff = FindAffect(AFFECT_LOOTING_SYSTEM);
  6060.                                 long lDur = item->GetValue(3);
  6061.  
  6062.                                 if (pkAff)
  6063.                                 {
  6064.                                     if (lDur > 0)
  6065.                                     {
  6066.                                         if (pkAff->lDuration > LONG_MAX - lDur)
  6067.                                         {
  6068.                                             ChatPacket(CHAT_TYPE_NOTICE, "The duration of the affect cannot be increased any more.");
  6069.                                             return false;
  6070.                                         }
  6071.                                     }
  6072.                                     else
  6073.                                     {
  6074.                                         sys_err("AFFECT_LOOTING_SYSTEM, lDur not a positive value.");
  6075.                                         return false;
  6076.                                     }
  6077.  
  6078.                                     lDur += pkAff->lDuration;
  6079.  
  6080.                                     RemoveAffect(pkAff);
  6081.                                     ChatPacket(CHAT_TYPE_NOTICE, "Loot filter duration extended.");
  6082.                                 }
  6083.                                 else
  6084.                                 {
  6085.                                     ChatPacket(CHAT_TYPE_NOTICE, "Loot filter activated.");
  6086.                                 }
  6087.  
  6088.                                 AddAffect(AFFECT_LOOTING_SYSTEM, POINT_NONE, 0, AFF_NONE, lDur, 0, false);
  6089.                                 item->SetCount(item->GetCount() - 1);
  6090.                                 return true;
  6091.                             }
  6092.                             #endif
  6093.  
  6094.                             #ifdef ENABLE_YMIR_AFFECT_FIX
  6095.                             if ((CheckTimeUsed(item) == false)) {   return false;   }
  6096.                             #endif
  6097.                             int affect_type = item->GetValue(0);
  6098.                             int apply_type  = aApplyInfo[item->GetValue(1)].bPointType;
  6099.                             int apply_value = item->GetValue(2);
  6100.                             int affect_state_socket = 0;
  6101.                            
  6102.                             CAffect* pAffect = FindAffect(affect_type, apply_type);
  6103.                             for (unsigned int i = 0; i < sizeof(IGNORED_AFF_ITEMS)/sizeof(*IGNORED_AFF_ITEMS); i++)
  6104.                             {
  6105.                                 if ((unsigned int)IGNORED_AFF_ITEMS[i] == item->GetVnum())
  6106.                                 {
  6107.                                     if (FindAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType))
  6108.                                     {
  6109.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  6110.                                         return false;
  6111.                                     }
  6112.                                    
  6113.                                     AddAffect(affect_type, apply_type, apply_value, item->GetID(), item->GetValue(3), 0, false);
  6114.                                     item->SetCount(item->GetCount() - 1);      
  6115.                                     return false;
  6116.                                 }
  6117.                             }
  6118.  
  6119.                             if (pAffect == NULL)
  6120.                             {              
  6121.                                 AddAffect(affect_type, apply_type, apply_value, item->GetID(), INFINITE_AFFECT_DURATION, 0, false);
  6122.                                 item->SetSocket(affect_state_socket, 1);
  6123.                                 item->Lock(true);
  6124.                             }
  6125.                             else
  6126.                             {
  6127.                                 if (item->GetID() == pAffect->dwFlag)
  6128.                                 {
  6129.                                     RemoveAffect( pAffect );
  6130.                                     item->Lock(false);
  6131.                                     item->SetSocket(affect_state_socket, 0);
  6132.                                 }
  6133.                                 else
  6134.                                 {
  6135.                                     LPITEM old = FindItemByID( pAffect->dwFlag );
  6136.                                     if (NULL != old)
  6137.                                     {
  6138.                                         old->Lock(false);
  6139.                                         old->SetSocket(affect_state_socket, 0);
  6140.                                     }
  6141.                                    
  6142.                                     RemoveAffect(pAffect);
  6143.                            
  6144.                                     AddAffect(affect_type, apply_type, apply_value, item->GetID(), INFINITE_AFFECT_DURATION, 0, false);
  6145.                                     item->SetSocket(affect_state_socket, 1);
  6146.                                     item->Lock(true);
  6147.                                 }
  6148.                             }
  6149.                         }
  6150.                         break;
  6151. #else
  6152.                     case USE_AFFECT :
  6153.                         {
  6154.                             if (FindAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType))
  6155.                             {
  6156.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  6157.                             }
  6158.                             else
  6159.                             {
  6160.                                 // PC_BANG_ITEM_ADD
  6161.                                 if (item->IsPCBangItem() == true)
  6162.                                 {
  6163.                                     // PC방인지 체크해서 처리
  6164.                                     if (CPCBangManager::instance().IsPCBangIP(GetDesc()->GetHostName()) == false)
  6165.                                     {
  6166.                                         // PC방이 아님!
  6167.                                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 PC방에서만 사용할 수 있습니다."));
  6168.                                         return false;
  6169.                                     }
  6170.                                 }
  6171.                                 // END_PC_BANG_ITEM_ADD
  6172.  
  6173.                                 AddAffect(item->GetValue(0), aApplyInfo[item->GetValue(1)].bPointType, item->GetValue(2), 0, item->GetValue(3), 0, false);
  6174.                                 item->SetCount(item->GetCount() - 1);
  6175.  
  6176.                             }
  6177.                         }
  6178.                         break; 
  6179. #endif
  6180.  
  6181.                     case USE_CREATE_STONE:
  6182.                         AutoGiveItem(number(28000, 28013));
  6183.                         item->SetCount(item->GetCount() - 1);
  6184.                         break;
  6185.  
  6186.                    
  6187.                     case USE_RECIPE :
  6188.                         {
  6189.                             LPITEM pSource1 = FindSpecifyItem(item->GetValue(1));
  6190.                             DWORD dwSourceCount1 = item->GetValue(2);
  6191.  
  6192.                             LPITEM pSource2 = FindSpecifyItem(item->GetValue(3));
  6193.                             DWORD dwSourceCount2 = item->GetValue(4);
  6194.  
  6195.                             if (dwSourceCount1 != 0)
  6196.                             {
  6197.                                 if (pSource1 == NULL)
  6198.                                 {
  6199.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물약 조합을 위한 재료가 부족합니다."));
  6200.                                     return false;
  6201.                                 }
  6202.                             }
  6203.  
  6204.                             if (dwSourceCount2 != 0)
  6205.                             {
  6206.                                 if (pSource2 == NULL)
  6207.                                 {
  6208.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물약 조합을 위한 재료가 부족합니다."));
  6209.                                     return false;
  6210.                                 }
  6211.                             }
  6212.  
  6213.                             if (pSource1 != NULL)
  6214.                             {
  6215.                                 if (pSource1->GetCount() < dwSourceCount1)
  6216.                                 {
  6217.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("재료(%s)가 부족합니다."), pSource1->GetName());
  6218.                                     return false;
  6219.                                 }
  6220.  
  6221.                                 pSource1->SetCount(pSource1->GetCount() - dwSourceCount1);
  6222.                             }
  6223.  
  6224.                             if (pSource2 != NULL)
  6225.                             {
  6226.                                 if (pSource2->GetCount() < dwSourceCount2)
  6227.                                 {
  6228.                                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("재료(%s)가 부족합니다."), pSource2->GetName());
  6229.                                     return false;
  6230.                                 }
  6231.  
  6232.                                 pSource2->SetCount(pSource2->GetCount() - dwSourceCount2);
  6233.                             }
  6234.  
  6235.                             LPITEM pBottle = FindSpecifyItem(50901);
  6236.  
  6237.                             if (!pBottle || pBottle->GetCount() < 1)
  6238.                             {
  6239.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("빈 병이 모자릅니다."));
  6240.                                 return false;
  6241.                             }
  6242.  
  6243.                             pBottle->SetCount(pBottle->GetCount() - 1);
  6244.  
  6245.                             if (number(1, 100) > item->GetValue(5))
  6246.                             {
  6247.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("물약 제조에 실패했습니다."));
  6248.                                 return false;
  6249.                             }
  6250.  
  6251.                             AutoGiveItem(item->GetValue(0));
  6252.                         }
  6253.                         break;
  6254.                 }
  6255.             }
  6256.             break;
  6257.  
  6258.         case ITEM_METIN:
  6259.             {
  6260.                 LPITEM item2;
  6261.  
  6262.                 if (!IsValidItemPosition(DestCell) || !(item2 = GetItem(DestCell)))
  6263.                     return false;
  6264.  
  6265.                 if (item2->IsExchanging() || item2->IsEquipped()) // @fixme114
  6266.                     return false;
  6267.  
  6268.                 if (item2->GetType() == ITEM_PICK) return false;
  6269.                 if (item2->GetType() == ITEM_ROD) return false;
  6270.  
  6271.                 int i;
  6272.  
  6273.                 for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  6274.                 {
  6275.                     DWORD dwVnum;
  6276.  
  6277.                     if ((dwVnum = item2->GetSocket(i)) <= 2)
  6278.                         continue;
  6279.  
  6280.                     TItemTable * p = ITEM_MANAGER::instance().GetTable(dwVnum);
  6281.  
  6282.                     if (!p)
  6283.                         continue;
  6284.  
  6285.                     if (item->GetValue(5) == p->alValues[5])
  6286.                     {
  6287.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("같은 종류의 메틴석은 여러개 부착할 수 없습니다."));
  6288.                         return false;
  6289.                     }
  6290.                 }
  6291.  
  6292.                 if (item2->GetType() == ITEM_ARMOR)
  6293.                 {
  6294.                     if (!IS_SET(item->GetWearFlag(), WEARABLE_BODY) || !IS_SET(item2->GetWearFlag(), WEARABLE_BODY))
  6295.                     {
  6296.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 메틴석은 장비에 부착할 수 없습니다."));
  6297.                         return false;
  6298.                     }
  6299.                 }
  6300.                 else if (item2->GetType() == ITEM_WEAPON)
  6301.                 {
  6302.                     if (!IS_SET(item->GetWearFlag(), WEARABLE_WEAPON))
  6303.                     {
  6304.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 메틴석은 무기에 부착할 수 없습니다."));
  6305.                         return false;
  6306.                     }
  6307.                 }
  6308.                 else
  6309.                 {
  6310.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("부착할 수 있는 슬롯이 없습니다."));
  6311.                     return false;
  6312.                 }
  6313.  
  6314.                 for (i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  6315.                     if (item2->GetSocket(i) >= 1 && item2->GetSocket(i) <= 2 && item2->GetSocket(i) >= item->GetValue(2))
  6316.                     {
  6317.                         /*
  6318.                         if (number(1, 100) <= 100)
  6319.                         {
  6320.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("메틴석 부착에 성공하였습니다."));
  6321.                             item2->SetSocket(i, item->GetVnum());
  6322.                         }
  6323.                         else
  6324.                         {
  6325.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("메틴석 부착에 실패하였습니다."));
  6326.                             item2->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
  6327.                         }
  6328.                         */
  6329.                         // Stein Chance
  6330.                         if (number(1, 100) <= stone_chance) // Erfolgreich
  6331.                         {
  6332.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("메틴석 부착에 성공하였습니다."));
  6333.                             item2->SetSocket(i, item->GetVnum());
  6334.                         }
  6335.                         else // Nicht Erfolgreich
  6336.                         {
  6337.                             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("메틴석 부착에 실패하였습니다."));
  6338.                             item2->SetSocket(i, ITEM_BROKEN_METIN_VNUM);
  6339.                         }
  6340.  
  6341.                         LogManager::instance().ItemLog(this, item2, "SOCKET", item->GetName());
  6342. #ifdef ENABLE_STONES_STACKFIX
  6343.                         item->SetCount(item->GetCount() - 1);
  6344. #else
  6345.                         ITEM_MANAGER::instance().RemoveItem(item, "REMOVE (METIN)");
  6346. #endif
  6347.                         break;
  6348.                     }
  6349.  
  6350.                 if (i == ITEM_SOCKET_MAX_NUM)
  6351.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("부착할 수 있는 슬롯이 없습니다."));
  6352.             }
  6353.             break;
  6354.  
  6355.         case ITEM_AUTOUSE:
  6356.         case ITEM_MATERIAL:
  6357.         case ITEM_SPECIAL:
  6358.         case ITEM_TOOL:
  6359.         case ITEM_LOTTERY:
  6360.             break;
  6361.  
  6362.         case ITEM_TOTEM:
  6363.             {
  6364.                 if (!item->IsEquipped())
  6365.                     EquipItem(item);
  6366.             }
  6367.             break;
  6368.         /*
  6369.         case ITEM_BLEND:
  6370. #ifdef ENABLE_YMIR_AFFECT_FIX
  6371.             if ((CheckTimeUsed(item) == false)) {   return false;   }
  6372. #endif
  6373.  
  6374.             sys_log(0,"ITEM_BLEND!!");
  6375.             if (Blend_Item_find(item->GetVnum()))
  6376.             {
  6377.                 int     affect_type     = AFFECT_BLEND;
  6378.                 int     apply_type      = aApplyInfo[item->GetSocket(0)].bPointType;
  6379.                 int     apply_value     = item->GetSocket(1);
  6380.                 int     apply_duration  = item->GetSocket(2);
  6381.  
  6382.                 if (FindAffect(affect_type, apply_type))
  6383.                 {
  6384.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  6385.                 }
  6386.                 else
  6387.                 {
  6388.                     if (FindAffect(AFFECT_EXP_BONUS_EURO_FREE, POINT_RESIST_MAGIC))
  6389.                     {
  6390.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  6391.                     }
  6392.                     else
  6393.                     {
  6394.                         AddAffect(affect_type, apply_type, apply_value, 0, apply_duration, 0, false);
  6395.                         item->SetCount(item->GetCount() - 1);
  6396.                     }
  6397.                 }
  6398.             }
  6399.             break;
  6400.         */
  6401. #ifdef ENABLE_DEWS_PLUS
  6402.         case ITEM_BLEND:   
  6403.             sys_log(0,"ITEM_BLEND!!");
  6404.             if (Blend_Item_find(item->GetVnum()))
  6405.             {
  6406.                 int     affect_type     = AFFECT_BLEND;
  6407.                 if (item->GetSocket(0) >= (int)_countof(aApplyInfo))
  6408.                 {
  6409.                     sys_err ("INVALID BLEND ITEM(id : %d, vnum : %d). APPLY TYPE IS %d.", item->GetID(), item->GetVnum(), item->GetSocket(0));
  6410.                     return false;
  6411.                 }
  6412.                 int     apply_type      = aApplyInfo[item->GetSocket(0)].bPointType;
  6413.                 int     apply_value     = item->GetSocket(1);
  6414.                
  6415.                 CAffect* pAffect = FindAffect(affect_type, apply_type);
  6416.                 item->SetSocket(2, 0);
  6417.                 if (pAffect == NULL)
  6418.                 {              
  6419.                     AddAffect(affect_type, apply_type, apply_value, item->GetID(), INFINITE_AFFECT_DURATION, 0, false);
  6420.                     item->SetSocket(2, 1);
  6421.                     item->Lock(true);
  6422.                     #ifdef ENABLE_NEW_AFFECT_POTION
  6423.                     SetAffectPotion(item);
  6424.                     #endif
  6425.                 }
  6426.                 else
  6427.                 {
  6428.                     if (item->GetID() == pAffect->dwFlag)
  6429.                     {
  6430.                         RemoveAffect( pAffect );
  6431.                         item->Lock(false);
  6432.                         item->SetSocket(2, 0);
  6433.                         #ifdef ENABLE_NEW_AFFECT_POTION
  6434.                         RemoveAffectPotion(item);
  6435.                         #endif
  6436.                     }
  6437.                     else
  6438.                     {
  6439.                         LPITEM old = FindItemByID( pAffect->dwFlag );
  6440.                         if (NULL != old)
  6441.                         {
  6442.                             old->Lock(false);
  6443.                             old->SetSocket(2, 0);
  6444.                         }
  6445.                        
  6446.                         RemoveAffect(pAffect);
  6447.                         #ifdef ENABLE_NEW_AFFECT_POTION
  6448.                         RemoveAffectPotion(item);
  6449.                         #endif
  6450.                
  6451.                         AddAffect(affect_type, apply_type, apply_value, item->GetID(), INFINITE_AFFECT_DURATION, 0, false);
  6452.                         item->SetSocket(2, 1);
  6453.                         item->Lock(true);
  6454.                         #ifdef ENABLE_NEW_AFFECT_POTION
  6455.                         SetAffectPotion(item);
  6456.                         #endif
  6457.                     }
  6458.                 }
  6459.             }
  6460.             break;     
  6461. #else
  6462.         case ITEM_BLEND:
  6463.             // 새로운 약초들
  6464.             sys_log(0,"ITEM_BLEND!!");
  6465.             if (Blend_Item_find(item->GetVnum()))
  6466.             {
  6467.                 int     affect_type     = AFFECT_BLEND;
  6468.                 int     apply_type      = aApplyInfo[item->GetSocket(0)].bPointType;
  6469.                 int     apply_value     = item->GetSocket(1);
  6470.                 int     apply_duration  = item->GetSocket(2);
  6471.  
  6472.                 if (FindAffect(affect_type, apply_type))
  6473.                 {
  6474.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  6475.                 }
  6476.                 else
  6477.                 {
  6478.                     if (FindAffect(AFFECT_EXP_BONUS_EURO_FREE, POINT_RESIST_MAGIC))
  6479.                     {
  6480.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 효과가 걸려 있습니다."));
  6481.                     }
  6482.                     else
  6483.                     {
  6484.                         AddAffect(affect_type, apply_type, apply_value, 0, apply_duration, 0, false);
  6485.                         #ifdef ENABLE_NEW_AFFECT_POTION
  6486.                         SetAffectPotion(item);
  6487.                         #endif
  6488.                         item->SetCount(item->GetCount() - 1);
  6489.                     }
  6490.                 }
  6491.             }
  6492.             break;
  6493. #endif
  6494.        
  6495.         case ITEM_EXTRACT:
  6496.             {
  6497.                 LPITEM pDestItem = GetItem(DestCell);
  6498.                 if (NULL == pDestItem)
  6499.                 {
  6500.                     return false;
  6501.                 }
  6502.                 switch (item->GetSubType())
  6503.                 {
  6504.                 case EXTRACT_DRAGON_SOUL:
  6505.                     if (pDestItem->IsDragonSoul())
  6506.                     {
  6507.                         return DSManager::instance().PullOut(this, NPOS, pDestItem, item);
  6508.                     }
  6509.                     return false;
  6510.                 case EXTRACT_DRAGON_HEART:
  6511.                     if (pDestItem->IsDragonSoul())
  6512.                     {
  6513.                         return DSManager::instance().ExtractDragonHeart(this, pDestItem, item);
  6514.                     }
  6515.                     return false;
  6516.                 default:
  6517.                     return false;
  6518.                 }
  6519.             }
  6520.             break;
  6521.  
  6522. #if defined(__SOUL_SYSTEM__)
  6523.         case ITEM_SOUL:
  6524.         {
  6525.             struct SoulData
  6526.             {
  6527.                 WORD point_type;
  6528.                 DWORD affect_flag;
  6529.             };
  6530.             std::unordered_map<BYTE, SoulData> soul_map
  6531.             {
  6532.                 { RED_SOUL, { AFF_SOUL_RED, AFF_SOUL_RED }, },
  6533.                 { BLUE_SOUL, { AFF_SOUL_BLUE, AFF_SOUL_BLUE }, },
  6534.             };
  6535.  
  6536.             const auto& it = soul_map.find(item->GetSubType());
  6537.             if (it == soul_map.end())
  6538.             {
  6539.                 sys_err("ITEM_SOUL: Unknown SubType");
  6540.                 return false;
  6541.             }
  6542.  
  6543.             const auto& soul = it->second;
  6544.  
  6545.             CAffect* affect = nullptr;
  6546.             for (auto const& it : GetAffectContainer())
  6547.             {
  6548.                 if (it != nullptr && it->dwType == AFFECT_SOUL)
  6549.                 {
  6550.                     if (it->bApplyOn == soul.point_type)
  6551.                         if (item->GetSocket(1) != TRUE)
  6552.                             return false;
  6553.  
  6554.                     affect = it;
  6555.                     continue;
  6556.                 }
  6557.             }
  6558.  
  6559.             if (item->GetSocket(1) != TRUE)
  6560.             {
  6561.                 AddAffect(AFFECT_SOUL, soul.point_type, item->GetID(), affect ? AFF_NONE : soul.affect_flag, item->GetSocket(0), 0, false /* override */);
  6562.  
  6563.                 if (affect)
  6564.                 {
  6565.                     std::vector<CAffect> tmp_affects;
  6566.                     std::vector<CAffect*> to_remove;
  6567.                     for (const auto& [k, v] : soul_map)
  6568.                     {
  6569.                         CAffect* affect = FindAffect(AFFECT_SOUL, v.point_type);
  6570.                         if (affect)
  6571.                         {
  6572.                             tmp_affects.emplace_back(*affect);
  6573.                             to_remove.emplace_back(affect);
  6574.                         }
  6575.                     }
  6576.  
  6577.                     if (!to_remove.empty())
  6578.                     {
  6579.                         for (const auto& it : to_remove)
  6580.                             RemoveAffect(it);
  6581.                     }
  6582.  
  6583.                     if (!tmp_affects.empty())
  6584.                     {
  6585.                         for (const auto& it : tmp_affects)
  6586.                             AddAffect(it.dwType, it.bApplyOn, it.lApplyValue, AFF_NONE, it.lDuration, 0, false /* override */);
  6587.                     }
  6588.  
  6589.                     AddAffect(AFFECT_SOUL, AFF_SOUL_MIX, 0, AFF_SOUL_MIX, item->GetSocket(0), 0, false /* override */);
  6590.                 }
  6591.  
  6592.                 item->SetSocket(1, TRUE);
  6593.                 item->Lock(true);
  6594.             }
  6595.             else
  6596.             {
  6597.                 RemoveAffect(AFFECT_SOUL, soul.point_type);
  6598.                 RemoveAffect(AFFECT_SOUL, AFF_SOUL_MIX); // AFF_SOUL_MIX
  6599.  
  6600.                 std::vector<CAffect> tmp_affects;
  6601.                 std::vector<CAffect*> to_remove;
  6602.                 for (const auto& affect : GetAffectContainer())
  6603.                 {
  6604.                     if (affect != nullptr && affect->dwType == AFFECT_SOUL)
  6605.                     {
  6606.                         tmp_affects.emplace_back(*affect);
  6607.                         to_remove.emplace_back(affect);
  6608.                     }
  6609.                 }
  6610.  
  6611.                 for (const auto& affect : to_remove)
  6612.                     RemoveAffect(affect);
  6613.  
  6614.                 if (!tmp_affects.empty())
  6615.                 {
  6616.                     for (const auto& affect : tmp_affects)
  6617.                     {
  6618.                         auto it = std::find_if(soul_map.begin(), soul_map.end(), [&](const auto& kv_pair) {
  6619.                             return kv_pair.second.point_type == affect.bApplyOn;
  6620.                             });
  6621.                
  6622.                         if (it != soul_map.end())
  6623.                             AddAffect(affect.dwType, affect.bApplyOn, affect.lApplyValue, it->second.affect_flag, affect.lDuration, 0, false/*override*/);
  6624.                     }
  6625.                 }
  6626.  
  6627.                 item->SetSocket(1, FALSE);
  6628.                 item->Lock(false);
  6629.             }
  6630.         }
  6631.         break;
  6632. #endif
  6633.  
  6634.         case ITEM_NONE:
  6635.             sys_err("Item type NONE %s", item->GetName());
  6636.             break;
  6637.  
  6638.         default:
  6639.             sys_log(0, "UseItemEx: Unknown type %s %d", item->GetName(), item->GetType());
  6640.             return false;
  6641.     }
  6642.  
  6643.     return true;
  6644. }
  6645.  
  6646. int g_nPortalLimitTime = 10;
  6647.  
  6648. bool CHARACTER::UseItem(TItemPos Cell, TItemPos DestCell)
  6649. {
  6650.     WORD wCell = Cell.cell;
  6651.     BYTE window_type = Cell.window_type;
  6652.     //WORD wDestCell = DestCell.cell;
  6653.     //BYTE bDestInven = DestCell.window_type;
  6654.     LPITEM item;
  6655.  
  6656.     if (!CanHandleItem())
  6657.         return false;
  6658.  
  6659.     if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
  6660.             return false;
  6661.  
  6662.     sys_log(0, "%s: USE_ITEM %s (inven %d, cell: %d)", GetName(), item->GetName(), window_type, wCell);
  6663.  
  6664.     if (item->IsExchanging())
  6665.         return false;
  6666.  
  6667.     if (!item->CanUsedBy(this))
  6668.     {
  6669.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("군직이 맞지않아 이 아이템을 사용할 수 없습니다."));
  6670.         return false;
  6671.     }
  6672.  
  6673.     if (IsStun())
  6674.         return false;
  6675.  
  6676.     if (false == FN_check_item_sex(this, item))
  6677.     {
  6678.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 사용할 수 없습니다."));
  6679.         return false;
  6680.     }
  6681.  
  6682.     //PREVENT_TRADE_WINDOW
  6683.     if (IS_SUMMON_ITEM(item->GetVnum()))
  6684.     {
  6685.         if (false == IS_SUMMONABLE_ZONE(GetMapIndex()))
  6686.         {
  6687.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot warp there."));
  6688.             return false;
  6689.         }
  6690.  
  6691.         if (CThreeWayWar::instance().IsThreeWayWarMapIndex(GetMapIndex()))
  6692.         {
  6693.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("삼거리 전투 참가중에는 귀환부,귀환기억부를 사용할수 없습니다."));
  6694.             return false;
  6695.         }
  6696.         int iPulse = thecore_pulse();
  6697.  
  6698.        
  6699.         if (iPulse - GetSafeboxLoadTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  6700.         {
  6701.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("창고를 연후 %d초 이내에는 귀환부,귀환기억부를 사용할 수 없습니다."), g_nPortalLimitTime);
  6702.  
  6703.             if (test_server)
  6704.                 ChatPacket(CHAT_TYPE_INFO, "[TestOnly]Pulse %d LoadTime %d PASS %d", iPulse, GetSafeboxLoadTime(), PASSES_PER_SEC(g_nPortalLimitTime));
  6705.             return false;
  6706.         }
  6707.  
  6708.        
  6709.         if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen()
  6710. #if defined(__BL_TRANSMUTATION__)
  6711.             || GetTransmutation()
  6712. #endif
  6713. #if defined(__BL_MAILBOX__)
  6714.             || GetMailBox()
  6715. #endif
  6716.         )
  6717.         {
  6718.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 귀환부,귀환기억부 를 사용할수 없습니다."));
  6719.             return false;
  6720.         }
  6721.  
  6722.         //PREVENT_REFINE_HACK
  6723.        
  6724.         {
  6725.             if (iPulse - GetRefineTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  6726.             {
  6727.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 개량후 %d초 이내에는 귀환부,귀환기억부를 사용할 수 없습니다."), g_nPortalLimitTime);
  6728.                 return false;
  6729.             }
  6730.         }
  6731.         //END_PREVENT_REFINE_HACK
  6732.  
  6733. #if defined(__BL_MAILBOX__)
  6734.         {
  6735.             if (iPulse - GetMyMailBoxTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  6736.             {
  6737.                 ChatPacket(CHAT_TYPE_INFO, "You cannot use a Return Scroll %d seconds after opening a mailbox.", g_nPortalLimitTime);
  6738.                 return false;
  6739.             }
  6740.         }
  6741. #endif
  6742.  
  6743.         //PREVENT_ITEM_COPY
  6744.         {
  6745.             if (iPulse - GetMyShopTime() < PASSES_PER_SEC(g_nPortalLimitTime))
  6746.             {
  6747.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("개인상점 사용후 %d초 이내에는 귀환부,귀환기억부를 사용할 수 없습니다."), g_nPortalLimitTime);
  6748.                 return false;
  6749.             }
  6750.  
  6751.         }
  6752.         //END_PREVENT_ITEM_COPY
  6753.  
  6754.         if (item->GetVnum() != 70302)
  6755.         {
  6756.             PIXEL_POSITION posWarp;
  6757.  
  6758.             int x = 0;
  6759.             int y = 0;
  6760.  
  6761.             double nDist = 0;
  6762.             const double nDistant = 5000.0;
  6763.            
  6764.             if (item->GetVnum() == 22010)
  6765.             {
  6766.                 x = item->GetSocket(0) - GetX();
  6767.                 y = item->GetSocket(1) - GetY();
  6768.             }
  6769.            
  6770.             else if (item->GetVnum() == 22000)
  6771.             {
  6772.                 SECTREE_MANAGER::instance().GetRecallPositionByEmpire(GetMapIndex(), GetEmpire(), posWarp);
  6773.  
  6774.                 if (item->GetSocket(0) == 0)
  6775.                 {
  6776.                     x = posWarp.x - GetX();
  6777.                     y = posWarp.y - GetY();
  6778.                 }
  6779.                 else
  6780.                 {
  6781.                     x = item->GetSocket(0) - GetX();
  6782.                     y = item->GetSocket(1) - GetY();
  6783.                 }
  6784.             }
  6785.  
  6786.             nDist = sqrt(pow((float)x,2) + pow((float)y,2));
  6787.  
  6788.             if (nDistant > nDist)
  6789.             {
  6790.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이동 되어질 위치와 너무 가까워 귀환부를 사용할수 없습니다."));
  6791.                 if (test_server)
  6792.                     ChatPacket(CHAT_TYPE_INFO, "PossibleDistant %f nNowDist %f", nDistant,nDist);
  6793.                 return false;
  6794.             }
  6795.         }
  6796.  
  6797.         //PREVENT_PORTAL_AFTER_EXCHANGE
  6798.        
  6799.         if (iPulse - GetExchangeTime()  < PASSES_PER_SEC(g_nPortalLimitTime))
  6800.         {
  6801.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래 후 %d초 이내에는 귀환부,귀환기억부등을 사용할 수 없습니다."), g_nPortalLimitTime);
  6802.             return false;
  6803.         }
  6804.         //END_PREVENT_PORTAL_AFTER_EXCHANGE
  6805.  
  6806.     }
  6807.  
  6808.     std::vector<DWORD> faretres = { 79501, 79502, 79503, 79504 };
  6809.     const LPITEM weap = GetWear(WEAR_WEAPON);
  6810.     if (weap && weap->GetType() == ITEM_WEAPON && weap->GetSubType() != WEAPON_BOW && std::find(faretres.begin(), faretres.end(), item->GetVnum()) != faretres.end())
  6811.     {
  6812.         ChatPacket(CHAT_TYPE_INFO, "[Quiver]To equip the quiver you must be wearing a Bow.");
  6813.         return false;
  6814.     }
  6815.  
  6816.  
  6817.     // MOUNT BLOCK
  6818.     static const std::unordered_set<int> restrictedMaps = {1, 21, 41, 103, 105, 110, 111, 114, 118, 119, 120, 199, 213};
  6819.  
  6820.     if ((item->GetType() == 28 && item->GetSubType() == 2) && (restrictedMaps.find(GetMapIndex()) != restrictedMaps.end() || CWarMapManager::instance().IsWarMap(GetMapIndex())))
  6821.     {
  6822.         ChatPacket(CHAT_TYPE_INFO, "You can't ride here!");
  6823.         return false;
  6824.     }
  6825.  
  6826. /*
  6827.     //psaria
  6828.     if ((item->GetType() == 3 && item->GetSubType() == 12) && (GetMapIndex() == 1 || GetMapIndex() == 3 || GetMapIndex() == 21 || GetMapIndex() == 23 || GetMapIndex() == 41
  6829.         || GetMapIndex() == 43 || GetMapIndex() == 65 || GetMapIndex() == 114 || CWarMapManager::instance().IsWarMap(GetMapIndex())))
  6830.     {
  6831.         ChatPacket(CHAT_TYPE_INFO, "You can't use fish here!");
  6832.         return false;
  6833.     }
  6834. */
  6835.  
  6836. #ifdef ENABLE_PVP_TALISMAN
  6837.     // TALISMAN BLOCK
  6838.     static const std::unordered_set<int> restrictedTalismanMaps = {1, 3, 21, 23, 41, 43};
  6839.  
  6840.     if (item->GetVnum() == PVP_TALISMAN_VNUM && (restrictedTalismanMaps.find(GetMapIndex()) != restrictedTalismanMaps.end() || CWarMapManager::instance().IsWarMap(GetMapIndex())))
  6841.     {
  6842.         ChatPacket(CHAT_TYPE_INFO, "You can't use Talisman here!");
  6843.         return false;
  6844.     }
  6845. #endif
  6846.  
  6847.     if ((item->GetVnum() == 50200) || (item->GetVnum() == 71049))
  6848.     {
  6849.         if (GetExchange() || GetMyShop() || GetShopOwner() || IsOpenSafebox() || IsCubeOpen()
  6850. #if defined(__BL_TRANSMUTATION__)
  6851.             || GetTransmutation()
  6852. #endif
  6853. #if defined(__BL_MAILBOX__)
  6854.             || GetMailBox()
  6855. #endif
  6856.         )
  6857.         {
  6858.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("거래창,창고 등을 연 상태에서는 보따리,비단보따리를 사용할수 없습니다."));
  6859.             return false;
  6860.         }
  6861.  
  6862.     }
  6863.     //END_PREVENT_TRADE_WINDOW
  6864.  
  6865.     // @fixme150 BEGIN
  6866.     if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  6867.     {
  6868.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot use this item if you're using quests"));
  6869.         return false;
  6870.     }
  6871.     // @fixme150 END
  6872.  
  6873.     if (IS_SET(item->GetFlag(), ITEM_FLAG_LOG))
  6874.     {
  6875.         DWORD vid = item->GetVID();
  6876.         DWORD oldCount = item->GetCount();
  6877.         DWORD vnum = item->GetVnum();
  6878.  
  6879.         char hint[ITEM_NAME_MAX_LEN + 32 + 1];
  6880.         int len = snprintf(hint, sizeof(hint) - 32, "%s", item->GetName());
  6881.  
  6882.         if (len < 0 || len >= (int) sizeof(hint) - 32)
  6883.             len = (sizeof(hint) - 32) - 1;
  6884.  
  6885.         bool ret = UseItemEx(item, DestCell);
  6886.  
  6887.         if (NULL == ITEM_MANAGER::instance().FindByVID(vid))
  6888.         {
  6889.             LogManager::instance().ItemLog(this, vid, vnum, "REMOVE", hint);
  6890.         }
  6891.         else if (oldCount != item->GetCount())
  6892.         {
  6893.             snprintf(hint + len, sizeof(hint) - len, " %u", oldCount - 1);
  6894.             LogManager::instance().ItemLog(this, vid, vnum, "USE_ITEM", hint);
  6895.         }
  6896.         return (ret);
  6897.     }
  6898.     else
  6899.         return UseItemEx(item, DestCell);
  6900. }
  6901.  
  6902. bool CHARACTER::DropItem(TItemPos Cell, BYTE bCount)
  6903. {
  6904.     LPITEM item = NULL;
  6905.  
  6906.     #ifdef ENABLE_GM_RESTRICTION
  6907.     if (IsGM() == true)
  6908.     {
  6909.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("GameMasters can't drop items."));
  6910.         return false;
  6911.     }
  6912.     #endif
  6913.  
  6914.     const std::vector<WORD> m_dwBlockedMapIdx = { 1, 21, 41, 3, 23, 43 };
  6915.     if (std::find(m_dwBlockedMapIdx.begin(), m_dwBlockedMapIdx.end(), GetMapIndex()) != m_dwBlockedMapIdx.end())
  6916.     {
  6917.         ChatPacket(CHAT_TYPE_INFO, "You can't drop items at this map.");
  6918.         return false;
  6919.     }
  6920.  
  6921.     if (!CanHandleItem())
  6922.     {
  6923.         if (NULL != DragonSoul_RefineWindow_GetOpener())
  6924.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("강화창을 연 상태에서는 아이템을 옮길 수 없습니다."));
  6925.         return false;
  6926.     }
  6927.  
  6928. #ifdef ENABLE_NEWSTUFF
  6929.     if (g_ItemDropTimeLimitValue && !PulseManager::Instance().IncreaseClock(GetPlayerID(), ePulse::ItemDrop, std::chrono::milliseconds(g_ItemDropTimeLimitValue)))
  6930.     {
  6931.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 골드를 버릴 수 없습니다."));
  6932.         return false;
  6933.     }
  6934. #endif
  6935.  
  6936.     if (IsDead())
  6937.         return false;
  6938.  
  6939.     if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
  6940.         return false;
  6941.  
  6942.     if (item->IsExchanging())
  6943.         return false;
  6944.  
  6945.     if (true == item->isLocked())
  6946.         return false;
  6947.  
  6948.     if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  6949.         return false;
  6950.  
  6951.     if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP | ITEM_ANTIFLAG_GIVE))
  6952.     {
  6953.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("버릴 수 없는 아이템입니다."));
  6954.         return false;
  6955.     }
  6956.  
  6957.     if (bCount == 0 || bCount > item->GetCount())
  6958.         bCount = item->GetCount();
  6959.  
  6960.     SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, 255);
  6961.  
  6962.     LPITEM pkItemToDrop;
  6963.  
  6964.     if (bCount == item->GetCount())
  6965.     {
  6966.         item->RemoveFromCharacter();
  6967.         pkItemToDrop = item;
  6968.     }
  6969.     else
  6970.     {
  6971.         if (bCount == 0)
  6972.         {
  6973.             if (test_server)
  6974.                 sys_log(0, "[DROP_ITEM] drop item count == 0");
  6975.             return false;
  6976.         }
  6977.  
  6978.         item->SetCount(item->GetCount() - bCount);
  6979.         ITEM_MANAGER::instance().FlushDelayedSave(item);
  6980.  
  6981.         pkItemToDrop = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), bCount);
  6982.  
  6983.         // copy item socket -- by mhh
  6984.         FN_copy_item_socket(pkItemToDrop, item);
  6985.  
  6986.         char szBuf[51 + 1];
  6987.         snprintf(szBuf, sizeof(szBuf), "%u %u", pkItemToDrop->GetID(), pkItemToDrop->GetCount());
  6988.         LogManager::instance().ItemLog(this, item, "ITEM_SPLIT", szBuf);
  6989.     }
  6990.  
  6991.     PIXEL_POSITION pxPos = GetXYZ();
  6992.  
  6993.     if (pkItemToDrop->AddToGround(GetMapIndex(), pxPos))
  6994.     {
  6995.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("떨어진 아이템은 3분 후 사라집니다."));
  6996. // #ifdef ENABLE_NEWSTUFF
  6997.         // pkItemToDrop->StartDestroyEvent(g_aiItemDestroyTime[ITEM_DESTROY_TIME_DROPITEM]);
  6998. // #else
  6999.         pkItemToDrop->StartDestroyEvent(15);
  7000. // #endif
  7001.  
  7002.         ITEM_MANAGER::instance().FlushDelayedSave(pkItemToDrop);
  7003.  
  7004.         char szHint[32 + 1];
  7005.         snprintf(szHint, sizeof(szHint), "%s %u %u", pkItemToDrop->GetName(), pkItemToDrop->GetCount(), pkItemToDrop->GetOriginalVnum());
  7006.         LogManager::instance().ItemLog(this, pkItemToDrop, "DROP", szHint);
  7007.         //Motion(MOTION_PICKUP);
  7008.     }
  7009.  
  7010.     return true;
  7011. }
  7012.  
  7013. bool CHARACTER::DestroyItem(TItemPos Cell)
  7014. {
  7015.     LPITEM item = NULL;
  7016.  
  7017.     if (!CanHandleItem())
  7018.     {
  7019.         if (NULL != DragonSoul_RefineWindow_GetOpener())
  7020.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("강화창을 연 상태에서는 아이템을 옮길 수 없습니다."));
  7021.         return false;
  7022.     }
  7023.  
  7024.     if (IsDead())
  7025.         return false;
  7026.  
  7027.     if (!IsValidItemPosition(Cell) || !(item = GetItem(Cell)))
  7028.         return false;
  7029.  
  7030.     if (item->IsExchanging())
  7031.         return false;
  7032.  
  7033.     if (true == item->isLocked())
  7034.         return false;
  7035.  
  7036.     if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  7037.         return false;
  7038.    
  7039.     if (item->GetCount() <= 0)
  7040.         return false;
  7041.  
  7042.     SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, 255);
  7043.  
  7044.     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You have deleted %s."), item->GetName());
  7045.     ITEM_MANAGER::instance().RemoveItem(item, "DESTROYED BY PLAYER");
  7046.  
  7047.     return true;
  7048. }
  7049.  
  7050. bool CHARACTER::DropGold(int gold)
  7051. {
  7052. /*
  7053.     if (gold <= 0 || gold > GetGold())
  7054.         return false;
  7055.  
  7056.     if (!CanHandleItem())
  7057.         return false;
  7058.  
  7059.     if (0 != g_GoldDropTimeLimitValue)
  7060.     {
  7061.         if (get_dword_time() < m_dwLastGoldDropTime+g_GoldDropTimeLimitValue)
  7062.         {
  7063.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 골드를 버릴 수 없습니다."));
  7064.             return false;
  7065.         }
  7066.     }
  7067.  
  7068.     m_dwLastGoldDropTime = get_dword_time();
  7069.  
  7070.     LPITEM item = ITEM_MANAGER::instance().CreateItem(1, gold);
  7071.  
  7072.     if (item)
  7073.     {
  7074.         PIXEL_POSITION pos = GetXYZ();
  7075.  
  7076.         if (item->AddToGround(GetMapIndex(), pos))
  7077.         {
  7078.             //Motion(MOTION_PICKUP);
  7079.             PointChange(POINT_GOLD, -gold, true);
  7080.  
  7081.             if (gold > 1000)
  7082.                 LogManager::instance().CharLog(this, gold, "DROP_GOLD", "");
  7083.  
  7084. #ifdef ENABLE_NEWSTUFF
  7085.             item->StartDestroyEvent(g_aiItemDestroyTime[ITEM_DESTROY_TIME_DROPGOLD]);
  7086. #else
  7087.             item->StartDestroyEvent();
  7088. #endif
  7089.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("떨어진 아이템은 %d분 후 사라집니다."), 150/60);
  7090.         }
  7091.  
  7092.         Save();
  7093.         return true;
  7094.     }
  7095. */
  7096.  
  7097.     return false;
  7098. }
  7099.  
  7100. #ifdef ENABLE_CHEQUE_SYSTEM
  7101. bool CHARACTER::DropCheque(int cheque)
  7102. {
  7103.     return false; // If you don't want to be able to drop won
  7104.     /*
  7105.     if (cheque <= 0 || cheque > GetCheque())
  7106.         return false;
  7107.     if (cheque >= CHEQUE_MAX)
  7108.         return false;
  7109.     if (!CanHandleItem())
  7110.         return false;
  7111.     LPITEM item = ITEM_MANAGER::instance().CreateItem(80020, cheque);
  7112.     if (item)
  7113.     {
  7114.         PIXEL_POSITION pos = GetXYZ();
  7115.         if (item->AddToGround(GetMapIndex(), pos))
  7116.         {
  7117.             PointChange(POINT_CHEQUE, -cheque, true);
  7118.             item->StartDestroyEvent(60);
  7119.         }
  7120.         Save();
  7121.         return true;
  7122.     }
  7123.     return false;
  7124.     */
  7125. }
  7126. #endif
  7127.  
  7128. bool CHARACTER::MoveItem(TItemPos Cell, TItemPos DestCell, BYTE count)
  7129. {
  7130.     if (Cell.IsSamePosition(DestCell)) // @fixme196 (check same slot n same window aliases)
  7131.         return false;
  7132.  
  7133.     if (!IsValidItemPosition(Cell))
  7134.         return false;
  7135.  
  7136.     LPITEM item = NULL;
  7137.     if (!(item = GetItem(Cell)))
  7138.         return false;
  7139.  
  7140.     if (item->IsExchanging())
  7141.         return false;
  7142.  
  7143.     if (item->GetCount() < count)
  7144.         return false;
  7145.  
  7146.     if (INVENTORY == Cell.window_type && Cell.cell >= INVENTORY_MAX_NUM && IS_SET(item->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  7147.         return false;
  7148.  
  7149.     if (true == item->isLocked())
  7150.         return false;
  7151.  
  7152.     if (!IsValidItemPosition(DestCell))
  7153.     {
  7154.         return false;
  7155.     }
  7156.  
  7157.     if (!CanHandleItem())
  7158.     {
  7159.         if (NULL != DragonSoul_RefineWindow_GetOpener())
  7160.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("강화창을 연 상태에서는 아이템을 옮길 수 없습니다."));
  7161.         return false;
  7162.     }
  7163.  
  7164. #ifdef ENABLE_MOUNT_LIKE_HORSE
  7165.     if (item->IsMount() && item->IsEquipped() && DestCell.IsDefaultInventoryPosition()) {
  7166.         StopRiding();
  7167.         HorseSummon(false);
  7168.     }
  7169. #endif
  7170.  
  7171.     // MOUNT BLOCK
  7172.     static const std::unordered_set<int> restrictedMountMaps = {1, 21, 41, 114, 118, 119, 120, 199, 213};
  7173.     if ((item->GetType() == 28 && item->GetSubType() == 2) && (restrictedMountMaps.find(GetMapIndex()) != restrictedMountMaps.end() || CWarMapManager::instance().IsWarMap(GetMapIndex())))
  7174.     {
  7175.         ChatPacket(CHAT_TYPE_INFO, "You can't ride here!");
  7176.         return false;
  7177.     }
  7178.  
  7179. #ifdef ENABLE_PVP_TALISMAN
  7180.     static const std::unordered_set<int> restrictedTalismanMaps = {1, 3, 21, 23, 41, 43};
  7181.  
  7182.     if (item->GetVnum() == PVP_TALISMAN_VNUM && (restrictedTalismanMaps.find(GetMapIndex()) != restrictedTalismanMaps.end() || CWarMapManager::instance().IsWarMap(GetMapIndex())))
  7183.     {
  7184.         ChatPacket(CHAT_TYPE_INFO, "You can't use this here!");
  7185.         return false;
  7186.     }
  7187. #endif
  7188.  
  7189.     if (DestCell.IsBeltInventoryPosition() && false == CBeltInventoryHelper::CanMoveIntoBeltInventory(item))
  7190.     {
  7191.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 벨트 인벤토리로 옮길 수 없습니다."));
  7192.         return false;
  7193.     }
  7194.  
  7195.     if (Cell.IsEquipPosition())
  7196.     {
  7197.         if (!CanUnequipNow(item))
  7198.             return false;
  7199.  
  7200. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
  7201.         int iWearCell = item->FindEquipCell(this);
  7202.         if (iWearCell == WEAR_WEAPON)
  7203.         {
  7204.             LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
  7205.             if (costumeWeapon && !UnequipItem(costumeWeapon))
  7206.             {
  7207.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
  7208.                 return false;
  7209.             }
  7210.  
  7211.             if (!IsEmptyItemGrid(DestCell, item->GetSize(), Cell.cell))
  7212.                 return UnequipItem(item);
  7213.         }
  7214. #endif
  7215.     }
  7216.  
  7217. #ifdef ENABLE_SWITCHBOT_WORLDARD
  7218.     if (DestCell.IsSwitchBotPosition())
  7219.     {
  7220.         if (CSwitchBonus::Instance().CanMoveIntoSB(item) == false){
  7221.             return false;
  7222.         }
  7223.  
  7224.         if(GetItem(TItemPos(SWITCHBOT, 0))){
  7225.             return false;
  7226.         }
  7227.        
  7228.     }
  7229. #endif
  7230.  
  7231.     if (DestCell.IsEquipPosition())
  7232.     {
  7233.         if (GetItem(DestCell)) 
  7234.         {
  7235.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 장비를 착용하고 있습니다."));
  7236.  
  7237.             return false;
  7238.         }
  7239.  
  7240.         EquipItem(item, DestCell.cell - INVENTORY_MAX_NUM);
  7241.     }
  7242.     else
  7243.     {
  7244.         if (item->IsDragonSoul())
  7245.         {
  7246.             if (item->IsEquipped())
  7247.             {
  7248.                 return DSManager::instance().PullOut(this, DestCell, item);
  7249.             }
  7250.             else
  7251.             {
  7252.                 if (DestCell.window_type != DRAGON_SOUL_INVENTORY)
  7253.                 {
  7254.                     return false;
  7255.                 }
  7256.  
  7257.                 if (!DSManager::instance().IsValidCellForThisItem(item, DestCell))
  7258.                     return false;
  7259.             }
  7260.         }
  7261.        
  7262.         else if (DRAGON_SOUL_INVENTORY == DestCell.window_type)
  7263.             return false;
  7264.  
  7265.         LPITEM item2;
  7266.  
  7267.         if ((item2 = GetItem(DestCell)) && item != item2 && item2->IsStackable() &&
  7268.                 !IS_SET(item2->GetAntiFlag(), ITEM_ANTIFLAG_STACK) &&
  7269.                 item2->GetVnum() == item->GetVnum())
  7270.         {
  7271.             for (int i = 0; i < ITEM_SOCKET_MAX_NUM; ++i)
  7272.                 if (item2->GetSocket(i) != item->GetSocket(i))
  7273.                     return false;
  7274.  
  7275.             if (count == 0)
  7276.                 count = item->GetCount();
  7277.  
  7278.             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,
  7279.                 DestCell.window_type, DestCell.cell, count);
  7280.  
  7281.             count = MIN(g_bItemCountLimit - item2->GetCount(), count);
  7282.  
  7283.             item->SetCount(item->GetCount() - count);
  7284.             item2->SetCount(item2->GetCount() + count);
  7285.             return true;
  7286.         }
  7287.  
  7288.         // if (!IsEmptyItemGrid(DestCell, item->GetSize(), Cell.cell))
  7289.         if (!IsEmptyItemGrid(DestCell, item->GetSize(), Cell.window_type == DestCell.window_type ? Cell.cell : -1))
  7290.         {
  7291. #ifdef __SWAP_ITEM_SYSTEM__
  7292.             if (count != 0 && count != item->GetCount())
  7293.                 return false;
  7294.  
  7295.             if (!DestCell.IsDefaultInventoryPosition() || !Cell.IsDefaultInventoryPosition())
  7296.                 return false;
  7297.  
  7298.             LPITEM targetItem = GetItem_NEW(DestCell);
  7299.  
  7300.             if (targetItem && targetItem->GetVID() == item->GetVID())
  7301.                 return false;
  7302.  
  7303.             if (targetItem)
  7304.             {
  7305.                 DestCell = TItemPos(INVENTORY, targetItem->GetCell());
  7306.             }
  7307.  
  7308. #ifdef SWAP_ITEM_TASKBAR_FIX
  7309.             if (item->IsQuickslotRestricted())
  7310.             {
  7311.                 int dstQS = GetQuickslotPosition(QUICKSLOT_TYPE_ITEM, DestCell.cell);
  7312.                 if (dstQS >= 0)
  7313.                 {
  7314.                     this->ChatPacket(
  7315.                         CHAT_TYPE_INFO,
  7316.                         LC_TEXT("You cannot move this item into that slot; it is restricted.")
  7317.                     );
  7318.                     return false;
  7319.                 }
  7320.             }
  7321. #endif
  7322.  
  7323.             if (item->IsExchanging() || (targetItem && targetItem->IsExchanging()))
  7324.                 return false;
  7325.  
  7326.             BYTE basePage = DestCell.cell / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT);
  7327.             std::map<WORD, LPITEM> moveItemMap;
  7328.             BYTE sizeLeft = item->GetSize();
  7329.  
  7330.             for (WORD i = 0; i < item->GetSize(); ++i)
  7331.             {
  7332.                 WORD cellNumber = DestCell.cell + i * 5;
  7333.  
  7334.                 BYTE cPage = cellNumber / (INVENTORY_MAX_NUM / INVENTORY_PAGE_COUNT);
  7335.                 if (basePage != cPage)
  7336.                     return false;
  7337.  
  7338.                 LPITEM mvItem = GetItem(TItemPos(INVENTORY, cellNumber));
  7339.                 if (mvItem)
  7340.                 {
  7341.                     if (mvItem->GetSize() > item->GetSize())
  7342.                         return false;
  7343.  
  7344.                     if (mvItem->IsExchanging())
  7345.                         return false;
  7346.  
  7347.                     moveItemMap.insert({ Cell.cell + i * 5, mvItem });
  7348.                     sizeLeft -= mvItem->GetSize();
  7349.  
  7350.                     if (mvItem->GetSize() > 1)
  7351.                         i += mvItem->GetSize() - 1;
  7352.                 }
  7353.                 else
  7354.                 {
  7355.                     sizeLeft -= 1;
  7356.                 }
  7357.             }
  7358.  
  7359.             if (sizeLeft != 0)
  7360.                 return false;
  7361.  
  7362.             std::map<WORD, WORD> syncCells;
  7363.  
  7364.             syncCells.insert({ GetQuickslotPosition(QUICKSLOT_TYPE_ITEM, item->GetCell()), DestCell.cell });
  7365.             item->RemoveFromCharacter();
  7366.  
  7367.             for (auto it = moveItemMap.begin(); it != moveItemMap.end(); ++it)
  7368.             {
  7369.                 WORD toCellNumber = it->first;
  7370.                 LPITEM mvItem = it->second;
  7371.  
  7372.                 syncCells.insert({ GetQuickslotPosition(QUICKSLOT_TYPE_ITEM, mvItem->GetCell()), toCellNumber });
  7373.                 mvItem->RemoveFromCharacter();
  7374.  
  7375.                 SetItem(TItemPos(INVENTORY, toCellNumber), mvItem);
  7376.             }
  7377.  
  7378.             SetItem(DestCell, item);
  7379.  
  7380.             for (auto& sCell : syncCells)
  7381.             {
  7382.                 TQuickslot qs;
  7383.                 qs.type = QUICKSLOT_TYPE_ITEM;
  7384.                 qs.pos = sCell.second;
  7385.  
  7386.                 SetQuickslot(sCell.first, qs);
  7387.             }
  7388.  
  7389.             return true;
  7390. #else
  7391.             return false;
  7392. #endif
  7393.         }
  7394.  
  7395.         if (count == 0 || count >= item->GetCount() || !item->IsStackable() || IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_STACK))
  7396.         {
  7397.             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,
  7398.                 DestCell.window_type, DestCell.cell, count);
  7399.  
  7400.             item->RemoveFromCharacter();
  7401. #if defined(__BL_ENABLE_PICKUP_ITEM_EFFECT__)
  7402.             SetItem(DestCell, item, false);
  7403. #else
  7404.             SetItem(DestCell, item);
  7405. #endif
  7406. // #ifdef __PET_SYSTEM__
  7407.             // if(ITEM_NORMAL_PET == item->GetType())
  7408.             // {
  7409.                 // quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  7410.             // }
  7411. // #endif
  7412.             if (INVENTORY == Cell.window_type && INVENTORY == DestCell.window_type)
  7413.                 SyncQuickslot(QUICKSLOT_TYPE_ITEM, Cell.cell, DestCell.cell);
  7414.         }
  7415.         else if (count < item->GetCount())
  7416.         {
  7417.  
  7418.             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,
  7419.                 DestCell.window_type, DestCell.cell, count);
  7420.  
  7421.             item->SetCount(item->GetCount() - count);
  7422.             LPITEM item2 = ITEM_MANAGER::instance().CreateItem(item->GetVnum(), count);
  7423.  
  7424.             // copy socket -- by mhh
  7425.             FN_copy_item_socket(item2, item);
  7426.  
  7427. #if defined(__BL_ENABLE_PICKUP_ITEM_EFFECT__)
  7428.             item2->AddToCharacter(this, DestCell, false);
  7429. #else
  7430.             item2->AddToCharacter(this, DestCell);
  7431. #endif
  7432.  
  7433.             char szBuf[51+1];
  7434.             snprintf(szBuf, sizeof(szBuf), "%u %u %u %u ", item2->GetID(), item2->GetCount(), item->GetCount(), item->GetCount() + item2->GetCount());
  7435.             LogManager::instance().ItemLog(this, item, "ITEM_SPLIT", szBuf);
  7436.         }
  7437.     }
  7438.  
  7439.     return true;
  7440. }
  7441.  
  7442. namespace NPartyPickupDistribute
  7443. {
  7444.     struct FFindOwnership
  7445.     {
  7446.         LPITEM item;
  7447.         LPCHARACTER owner;
  7448.  
  7449.         FFindOwnership(LPITEM item)
  7450.             : item(item), owner(NULL)
  7451.         {
  7452.         }
  7453.  
  7454.         void operator () (LPCHARACTER ch)
  7455.         {
  7456.             if (item->IsOwnership(ch))
  7457.                 owner = ch;
  7458.         }
  7459.     };
  7460.  
  7461.     struct FCountNearMember
  7462.     {
  7463.         int     total;
  7464.         int     x, y;
  7465.  
  7466.         FCountNearMember(LPCHARACTER center )
  7467.             : total(0), x(center->GetX()), y(center->GetY())
  7468.         {
  7469.         }
  7470.  
  7471.         void operator () (LPCHARACTER ch)
  7472.         {
  7473.             if (DISTANCE_APPROX(ch->GetX() - x, ch->GetY() - y) <= PARTY_DEFAULT_RANGE)
  7474.                 total += 1;
  7475.         }
  7476.     };
  7477.  
  7478.     struct FMoneyDistributor
  7479.     {
  7480.         int     total;
  7481.         LPCHARACTER c;
  7482.         int     x, y;
  7483.         int     iMoney;
  7484.  
  7485.         FMoneyDistributor(LPCHARACTER center, int iMoney)
  7486.             : total(0), c(center), x(center->GetX()), y(center->GetY()), iMoney(iMoney)
  7487.         {
  7488.         }
  7489.  
  7490.         void operator ()(LPCHARACTER ch)
  7491.         {
  7492.             if (ch!=c)
  7493.                 if (DISTANCE_APPROX(ch->GetX() - x, ch->GetY() - y) <= PARTY_DEFAULT_RANGE)
  7494.                 {
  7495.                     ch->PointChange(POINT_GOLD, iMoney, true);
  7496.  
  7497.                     if (iMoney > 1000) // Aμ¿ø AI≫o¸¸ ±a·ICN´U.
  7498.                         LogManager::instance().CharLog(ch, iMoney, "GET_GOLD", "");
  7499.                 }
  7500.         }
  7501.     };
  7502. }
  7503.  
  7504. // void CHARACTER::GiveGold(int iAmount)
  7505. void CHARACTER::GiveGold(long long iAmount)
  7506. {
  7507.     if (iAmount <= 0)
  7508.         return;
  7509.  
  7510.     // sys_log(0, "GIVE_GOLD: %s %d", GetName(), iAmount);
  7511.     sys_log(0, "GIVE_GOLD: %s %lld", GetName(), iAmount);
  7512.  
  7513.     if (GetParty())
  7514.     {
  7515.         LPPARTY pParty = GetParty();
  7516.  
  7517.         // DWORD dwTotal = iAmount;
  7518.         // DWORD dwMyAmount = dwTotal;
  7519.         long long dwTotal = iAmount;
  7520.         long long dwMyAmount = dwTotal;
  7521.  
  7522.         NPartyPickupDistribute::FCountNearMember funcCountNearMember(this);
  7523.         pParty->ForEachOnlineMember(funcCountNearMember);
  7524.  
  7525.         if (funcCountNearMember.total > 1)
  7526.         {
  7527.             DWORD dwShare = dwTotal / funcCountNearMember.total;
  7528.             dwMyAmount -= dwShare * (funcCountNearMember.total - 1);
  7529.  
  7530.             NPartyPickupDistribute::FMoneyDistributor funcMoneyDist(this, dwShare);
  7531.  
  7532.             pParty->ForEachOnlineMember(funcMoneyDist);
  7533.         }
  7534.  
  7535.         PointChange(POINT_GOLD, dwMyAmount, true);
  7536.  
  7537.         if (dwMyAmount > 1000)
  7538.         {
  7539.             LOG_LEVEL_CHECK(LOG_LEVEL_MAX, LogManager::instance().CharLog(this, dwMyAmount, "GET_GOLD", ""));
  7540.         }
  7541.     }
  7542.     else
  7543.     {
  7544.         PointChange(POINT_GOLD, iAmount, true);
  7545.  
  7546.         if (iAmount > 1000)
  7547.         {
  7548.             LOG_LEVEL_CHECK(LOG_LEVEL_MAX, LogManager::instance().CharLog(this, iAmount, "GET_GOLD", ""));
  7549.         }
  7550.     }
  7551. }
  7552.  
  7553. #ifdef ENABLE_CHEQUE_SYSTEM
  7554. void CHARACTER::GiveCheque(int iAmount)
  7555. {
  7556.     if (iAmount <= 0)
  7557.         return;
  7558.  
  7559.     PointChange(POINT_CHEQUE, iAmount, true);
  7560. }
  7561. #endif
  7562.  
  7563. bool CHARACTER::PickupItem(DWORD dwVID)
  7564. {
  7565.     LPITEM item = ITEM_MANAGER::instance().FindByVID(dwVID);
  7566.  
  7567.     if (IsObserverMode())
  7568.         return false;
  7569.  
  7570.     if (!item || !item->GetSectree())
  7571.         return false;
  7572.  
  7573.     if (item->DistanceValid(this))
  7574.     {
  7575.         // @fixme150 BEGIN
  7576.         if (item->GetType() == ITEM_QUEST)
  7577.         {
  7578.             if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  7579.             {
  7580.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot pickup this item if you're using quests"));
  7581.                 return false;
  7582.             }
  7583.         }
  7584.         // @fixme150 END
  7585.  
  7586.         if (item->IsOwnership(this))
  7587.         {
  7588. #if defined(__BL_OFFICIAL_LOOT_FILTER__)
  7589.             if (GetLootFilter() && !GetLootFilter()->CanPickUpItem(item))
  7590.             {
  7591.                 if (!GetLootFilter()->IsLootFilteredItem(dwVID))
  7592.                 {
  7593.                     GetLootFilter()->InsertLootFilteredItem(dwVID);
  7594.  
  7595.                     if (GetDesc())
  7596.                     {
  7597.                         TPacketGCLootFilter p;
  7598.                         p.header = HEADER_GC_LOOT_FILTER;
  7599.                         p.enable = false;
  7600.                         p.vid = dwVID;
  7601.                         GetDesc()->Packet(&p, sizeof(p));
  7602.                     }
  7603.                 }
  7604.                
  7605.                 // ChatPacket(CHAT_TYPE_INFO, "No loot will be collected as the loot filter is deactivated.");
  7606.                 return false;
  7607.             }
  7608. #endif
  7609.  
  7610.             if (item->GetType() == ITEM_ELK)
  7611.             {
  7612.                 GiveGold(item->GetCount());
  7613.                 item->RemoveFromGround();
  7614.  
  7615.                 M2_DESTROY_ITEM(item);
  7616.  
  7617.                 Save();
  7618.             }
  7619. #ifdef ENABLE_CHEQUE_SYSTEM
  7620.             else if (item->GetType() == ITEM_CHEQUE)
  7621.             {
  7622.                 if (item->GetCount() + GetCheque() > CHEQUE_MAX - 1)
  7623.                     return false;
  7624.                 GiveCheque(item->GetCount());
  7625.                 item->RemoveFromGround();
  7626.                 M2_DESTROY_ITEM(item);
  7627.                 Save();
  7628.             }
  7629. #endif
  7630.            
  7631.             else
  7632.             {
  7633.                 if (item->IsStackable() && !IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_STACK))
  7634.                 {
  7635.                     BYTE bCount = item->GetCount();
  7636.  
  7637.                     for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  7638.                     {
  7639.                         LPITEM item2 = GetInventoryItem(i);
  7640.  
  7641.                         if (!item2)
  7642.                             continue;
  7643.  
  7644.                         if (item2->GetVnum() == item->GetVnum())
  7645.                         {
  7646.                             int j;
  7647.  
  7648.                             for (j = 0; j < ITEM_SOCKET_MAX_NUM; ++j)
  7649.                                 if (item2->GetSocket(j) != item->GetSocket(j))
  7650.                                     break;
  7651.  
  7652.                             if (j != ITEM_SOCKET_MAX_NUM)
  7653.                                 continue;
  7654.  
  7655.                             BYTE bCount2 = MIN(g_bItemCountLimit - item2->GetCount(), bCount);
  7656.                             bCount -= bCount2;
  7657.  
  7658.                             item2->SetCount(item2->GetCount() + bCount2);
  7659.  
  7660.                             if (bCount == 0)
  7661.                             {
  7662.                                 #if defined(__CHATTING_WINDOW_RENEWAL__)
  7663.                                 ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("아이템 획득: %s"), item2->GetName());
  7664.                                 #else
  7665.                                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item2->GetName());
  7666.                                 #endif
  7667.                                 M2_DESTROY_ITEM(item);
  7668.                                 if (item2->GetType() == ITEM_QUEST)
  7669.                                     quest::CQuestManager::instance().PickupItem (GetPlayerID(), item2);
  7670.                                 return true;
  7671.                             }
  7672.                         }
  7673.                     }
  7674.  
  7675.                     item->SetCount(bCount);
  7676.                 }
  7677.  
  7678.                 int iEmptyCell;
  7679.                 if (item->IsDragonSoul())
  7680.                 {
  7681.                     if ((iEmptyCell = GetEmptyDragonSoulInventory(item)) == -1)
  7682.                     {
  7683.                         sys_log(0, "No empty ds inventory pid %u size %ud itemid %u", GetPlayerID(), item->GetSize(), item->GetID());
  7684.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
  7685.                         return false;
  7686.                     }
  7687.                 }
  7688.                 else
  7689.                 {
  7690.                     if ((iEmptyCell = GetEmptyInventory(item->GetSize())) == -1)
  7691.                     {
  7692.                         sys_log(0, "No empty inventory pid %u size %ud itemid %u", GetPlayerID(), item->GetSize(), item->GetID());
  7693.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
  7694.                         return false;
  7695.                     }
  7696.                 }
  7697.  
  7698.                 item->RemoveFromGround();
  7699.  
  7700.                 if (item->IsDragonSoul())
  7701.                     item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  7702.                 else
  7703.                     item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
  7704.  
  7705.                 char szHint[32+1];
  7706.                 snprintf(szHint, sizeof(szHint), "%s %u %u", item->GetName(), item->GetCount(), item->GetOriginalVnum());
  7707.                 LogManager::instance().ItemLog(this, item, "GET", szHint);
  7708.                 #if defined(__CHATTING_WINDOW_RENEWAL__)
  7709.                 ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  7710.                 #else
  7711.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  7712.                 #endif
  7713.  
  7714.                 if (item->GetType() == ITEM_QUEST)
  7715.                     quest::CQuestManager::instance().PickupItem (GetPlayerID(), item);
  7716.             }
  7717.  
  7718.             //Motion(MOTION_PICKUP);
  7719.             return true;
  7720.         }
  7721.         else if (!IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_GIVE | ITEM_ANTIFLAG_DROP) && GetParty())
  7722.         {
  7723.            
  7724.             NPartyPickupDistribute::FFindOwnership funcFindOwnership(item);
  7725.  
  7726.             GetParty()->ForEachOnlineMember(funcFindOwnership);
  7727.  
  7728.             LPCHARACTER owner = funcFindOwnership.owner;
  7729.             // @fixme115
  7730.             if (!owner)
  7731.                 return false;
  7732.  
  7733.             int iEmptyCell;
  7734.  
  7735.             if (item->IsDragonSoul())
  7736.             {
  7737.                 if (!(owner && (iEmptyCell = owner->GetEmptyDragonSoulInventory(item)) != -1))
  7738.                 {
  7739.                     owner = this;
  7740.  
  7741.                     if ((iEmptyCell = GetEmptyDragonSoulInventory(item)) == -1)
  7742.                     {
  7743.                         owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
  7744.                         return false;
  7745.                     }
  7746.                 }
  7747.             }
  7748.             else
  7749.             {
  7750.                 if (!(owner && (iEmptyCell = owner->GetEmptyInventory(item->GetSize())) != -1))
  7751.                 {
  7752.                     owner = this;
  7753.  
  7754.                     if ((iEmptyCell = GetEmptyInventory(item->GetSize())) == -1)
  7755.                     {
  7756.                         owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("소지하고 있는 아이템이 너무 많습니다."));
  7757.                         return false;
  7758.                     }
  7759.                 }
  7760.             }
  7761.  
  7762. #if defined(__BL_OFFICIAL_LOOT_FILTER__)
  7763.             if (owner->GetLootFilter() && !owner->GetLootFilter()->CanPickUpItem(item))
  7764.             {
  7765.                 if (owner == this)
  7766.                 {
  7767.                     if (!owner->GetLootFilter()->IsLootFilteredItem(dwVID))
  7768.                     {
  7769.                         owner->GetLootFilter()->InsertLootFilteredItem(dwVID);
  7770.  
  7771.                         if (owner->GetDesc())
  7772.                         {
  7773.                             TPacketGCLootFilter p;
  7774.                             p.header = HEADER_GC_LOOT_FILTER;
  7775.                             p.enable = false;
  7776.                             p.vid = dwVID;
  7777.                             owner->GetDesc()->Packet(&p, sizeof(p));
  7778.                         }
  7779.                     }
  7780.  
  7781.                     // ChatPacket(CHAT_TYPE_INFO, "No loot will be collected as the loot filter is deactivated.");
  7782.                 }
  7783.                 // else
  7784.                 // {
  7785.                     // ChatPacket(CHAT_TYPE_INFO, "No loot will be collected as a party member's loot filter is deactivated.");
  7786.                 // }
  7787.  
  7788.                 return false;
  7789.             }
  7790. #endif
  7791.  
  7792.             item->RemoveFromGround(); // o.O strange
  7793.  
  7794.             if (item->IsDragonSoul())
  7795.                 item->AddToCharacter(owner, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  7796.             else
  7797.                 item->AddToCharacter(owner, TItemPos(INVENTORY, iEmptyCell));
  7798.  
  7799.             char szHint[32+1];
  7800.             snprintf(szHint, sizeof(szHint), "%s %u %u", item->GetName(), item->GetCount(), item->GetOriginalVnum());
  7801.             LogManager::instance().ItemLog(owner, item, "GET", szHint);
  7802.  
  7803.             if (owner == this)
  7804.                 #if defined(__CHATTING_WINDOW_RENEWAL__)
  7805.                 ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  7806.                 #else
  7807.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  7808.                 #endif
  7809.             else
  7810.             {
  7811.                 owner->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s 님으로부터 %s"), GetName(), item->GetName());
  7812.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 전달: %s 님에게 %s"), owner->GetName(), item->GetName());
  7813.             }
  7814.  
  7815.             if (item->GetType() == ITEM_QUEST)
  7816.                 quest::CQuestManager::instance().PickupItem (owner->GetPlayerID(), item);
  7817.  
  7818.             return true;
  7819.         }
  7820.     }
  7821.  
  7822.     return false;
  7823. }
  7824.  
  7825. // bool CHARACTER::SwapItem(BYTE bCell, BYTE bDestCell)
  7826. bool CHARACTER::SwapItem(DWORD bCell, DWORD bDestCell)
  7827. {
  7828.     if (!CanHandleItem())
  7829.         return false;
  7830.  
  7831.     TItemPos srcCell(INVENTORY, bCell), destCell(INVENTORY, bDestCell);
  7832.  
  7833.     //if (bCell >= INVENTORY_MAX_NUM + WEAR_MAX_NUM || bDestCell >= INVENTORY_MAX_NUM + WEAR_MAX_NUM)
  7834.     if (srcCell.IsDragonSoulEquipPosition() || destCell.IsDragonSoulEquipPosition())
  7835.         return false;
  7836.  
  7837.    
  7838.     if (bCell == bDestCell)
  7839.         return false;
  7840.  
  7841.    
  7842.     if (srcCell.IsEquipPosition() && destCell.IsEquipPosition())
  7843.         return false;
  7844.  
  7845.     LPITEM item1, item2;
  7846.  
  7847.    
  7848.     if (srcCell.IsEquipPosition())
  7849.     {
  7850.         item1 = GetInventoryItem(bDestCell);
  7851.         item2 = GetInventoryItem(bCell);
  7852.     }
  7853.     else
  7854.     {
  7855.         item1 = GetInventoryItem(bCell);
  7856.         item2 = GetInventoryItem(bDestCell);
  7857.     }
  7858.  
  7859.     if (!item1 || !item2)
  7860.         return false;
  7861.  
  7862.     if (item1 == item2)
  7863.     {
  7864.         sys_log(0, "[WARNING][WARNING][HACK USER!] : %s %d %d", m_stName.c_str(), bCell, bDestCell);
  7865.         return false;
  7866.     }
  7867.  
  7868.     if (!IsEmptyItemGrid(TItemPos (INVENTORY, item1->GetCell()), item2->GetSize(), item1->GetCell()))
  7869.         return false;
  7870.  
  7871.     if (item2->GetType() == ITEM_WEAPON)
  7872.     {
  7873.         if (IsAffectFlag(AFF_GWIGUM))
  7874.             RemoveAffect(SKILL_GWIGEOM);
  7875.  
  7876.         if (IsAffectFlag(AFF_GEOMGYEONG))
  7877.             RemoveAffect(SKILL_GEOMKYUNG);
  7878.     }
  7879.  
  7880.     if (TItemPos(EQUIPMENT, item2->GetCell()).IsEquipPosition())
  7881.     {
  7882.         BYTE bEquipCell = item2->GetCell() - INVENTORY_MAX_NUM;
  7883.         BYTE bInvenCell = item1->GetCell();
  7884.  
  7885.        
  7886.         if (item2->IsDragonSoul() || item2->GetType() == ITEM_BELT) // @fixme117
  7887.         {
  7888.             if (false == CanUnequipNow(item2) || false == CanEquipNow(item1))
  7889.                 return false;
  7890.         }
  7891.  
  7892.         if (bEquipCell != item1->FindEquipCell(this))
  7893. // #ifdef __PET_SYSTEM__
  7894.         // if(ITEM_NORMAL_PET == item2->GetType())
  7895.         // {
  7896.             // quest::CQuestManager::instance().UseItem(GetPlayerID(), item2, false);
  7897.         // }   
  7898. // #endif
  7899.             return false;
  7900.  
  7901.         item2->RemoveFromCharacter();
  7902.  
  7903.         if (item1->EquipTo(this, bEquipCell))
  7904. #if defined(__BL_ENABLE_PICKUP_ITEM_EFFECT__)
  7905.             item2->AddToCharacter(this, TItemPos(INVENTORY, bInvenCell), false);
  7906. #else
  7907.             item2->AddToCharacter(this, TItemPos(INVENTORY, bInvenCell));
  7908. #endif
  7909.         else
  7910.             sys_err("SwapItem cannot equip %s! item1 %s", item2->GetName(), item1->GetName());
  7911. #ifdef ENABLE_PVP_TALISMAN
  7912.         if (item2->GetVnum() == PVP_TALISMAN_VNUM)
  7913.             if (HasPvPTalisman())
  7914.             {
  7915.                 ResetPvPTalismanEffect();
  7916.                 UpdatePacket();
  7917.             }
  7918. #endif
  7919.     }
  7920.     else
  7921.     {
  7922.         BYTE bCell1 = item1->GetCell();
  7923.         BYTE bCell2 = item2->GetCell();
  7924.  
  7925.         item1->RemoveFromCharacter();
  7926.         item2->RemoveFromCharacter();
  7927.  
  7928. #if defined(__BL_ENABLE_PICKUP_ITEM_EFFECT__)
  7929.         item1->AddToCharacter(this, TItemPos(INVENTORY, bCell2), false);
  7930.         item2->AddToCharacter(this, TItemPos(INVENTORY, bCell1), false);
  7931. #else
  7932.         item1->AddToCharacter(this, TItemPos(INVENTORY, bCell2));
  7933.         item2->AddToCharacter(this, TItemPos(INVENTORY, bCell1));
  7934. #endif
  7935.     }
  7936. #ifdef ENABLE_MOUNT_LIKE_HORSE
  7937.     if (item1->IsMount() && item2->IsMount() && destCell.IsEquipPosition())
  7938.         HorseSummon(true);
  7939. #endif
  7940.  
  7941.     return true;
  7942. }
  7943.  
  7944. bool CHARACTER::UnequipItem(LPITEM item)
  7945. {
  7946. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
  7947.     int iWearCell = item->FindEquipCell(this);
  7948.     if (iWearCell == WEAR_WEAPON)
  7949.     {
  7950.         LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
  7951.         if (costumeWeapon && !UnequipItem(costumeWeapon))
  7952.         {
  7953.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
  7954.             return false;
  7955.         }
  7956.     }
  7957. #endif
  7958.  
  7959.     #ifdef ENABLE_PVP_TALISMAN
  7960.     if(item->GetVnum() == PVP_TALISMAN_VNUM)
  7961.     {
  7962.         this->ResetPvPTalismanEffect();
  7963.         this->UpdatePacket();
  7964.     }
  7965.     #endif
  7966.  
  7967. #ifdef ENABLE_MOUNT_LIKE_HORSE
  7968.     if (item->IsMount()) {
  7969.         StopRiding();
  7970.         HorseSummon(false);
  7971.     }
  7972. #endif
  7973.  
  7974.     if (false == CanUnequipNow(item))
  7975.         return false;
  7976.  
  7977.     std::vector<DWORD> faretres = { 79501, 79502, 79503, 79504 };
  7978.     const LPITEM faretra = GetWear(WEAR_ARROW);
  7979.     if (item->GetType() == ITEM_WEAPON && item->GetSubType() == WEAPON_BOW) {
  7980.         if (faretra && std::find(faretres.begin(), faretres.end(), faretra->GetVnum()) != faretres.end()) {
  7981.             ChatPacket(CHAT_TYPE_INFO, "[Quiver]Remove the quiver first to take out the Bow.");
  7982.             return false;
  7983.         }
  7984.     }
  7985.  
  7986.     int pos;
  7987.     if (item->IsDragonSoul())
  7988.         pos = GetEmptyDragonSoulInventory(item);
  7989.     else
  7990.         pos = GetEmptyInventory(item->GetSize());
  7991.  
  7992.     // HARD CODING
  7993.     if (item->GetVnum() == UNIQUE_ITEM_HIDE_ALIGNMENT_TITLE)
  7994.         ShowAlignment(true);
  7995.  
  7996. // #ifdef __PET_SYSTEM__
  7997.     // if(ITEM_NORMAL_PET == item->GetType())
  7998.     // {
  7999.         // quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  8000.     // }
  8001. // #endif
  8002.  
  8003.     item->RemoveFromCharacter();
  8004.     if (item->IsDragonSoul())
  8005.     {
  8006.         item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, pos));
  8007.     }
  8008.     else
  8009. #if defined(__BL_ENABLE_PICKUP_ITEM_EFFECT__)
  8010.         item->AddToCharacter(this, TItemPos(INVENTORY, pos), false);
  8011. #else
  8012.         item->AddToCharacter(this, TItemPos(INVENTORY, pos));
  8013. #endif
  8014.  
  8015.     CheckMaximumPoints();
  8016.  
  8017.     return true;
  8018. }
  8019.  
  8020. //
  8021.  
  8022. //
  8023. bool CHARACTER::EquipItem(LPITEM item, int iCandidateCell)
  8024. {
  8025.     if (item->IsExchanging())
  8026.         return false;
  8027.  
  8028.     if (false == item->IsEquipable())
  8029.         return false;
  8030.  
  8031.     if (false == CanEquipNow(item))
  8032.         return false;
  8033.  
  8034.     int iWearCell = item->FindEquipCell(this, iCandidateCell);
  8035.  
  8036.     if (iWearCell < 0)
  8037.         return false;
  8038.  
  8039.     std::vector<DWORD> faretres = { 79501, 79502, 79503, 79504 };
  8040.     const LPITEM faretra = GetWear(WEAR_ARROW);
  8041.     if (item->GetType() == ITEM_WEAPON && item->GetSubType() != WEAPON_BOW) {
  8042.         if (faretra && std::find(faretres.begin(), faretres.end(), faretra->GetVnum()) != faretres.end()) {
  8043.             ChatPacket(CHAT_TYPE_INFO, "[Quiver]To equip the quiver you must be wearing a Bow.");
  8044.             return false;
  8045.         }
  8046.     }
  8047.  
  8048.     if (iWearCell == WEAR_BODY && IsRiding() && (item->GetVnum() >= 11901 && item->GetVnum() <= 11904))
  8049.     {
  8050.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("말을 탄 상태에서 예복을 입을 수 없습니다."));
  8051.         return false;
  8052.     }
  8053.  
  8054.     if (iWearCell != WEAR_ARROW && IsPolymorphed())
  8055.     {
  8056.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑 중에는 착용중인 장비를 변경할 수 없습니다."));
  8057.         return false;
  8058.     }
  8059.  
  8060.     if (FN_check_item_sex(this, item) == false)
  8061.     {
  8062.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("성별이 맞지않아 이 아이템을 사용할 수 없습니다."));
  8063.         return false;
  8064.     }
  8065.  
  8066.    
  8067.     if(item->IsRideItem() && IsRiding())
  8068.     {
  8069.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 탈것을 이용중입니다."));
  8070.         return false;
  8071.     }
  8072.  
  8073.    
  8074.     DWORD dwCurTime = get_dword_time();
  8075.    
  8076.     /*
  8077.     // CHECK SLOTS
  8078.     DWORD uslot1 = 0;
  8079.     if (GetWear(WEAR_RING1) && GetWear(WEAR_RING1)->GetVnum())
  8080.         uslot1 = GetWear(WEAR_RING1)->GetVnum();
  8081.     DWORD uslot2 = 0;
  8082.     if (GetWear(WEAR_RING2) && GetWear(WEAR_RING2)->GetVnum())
  8083.         uslot2 = GetWear(WEAR_RING2)->GetVnum();
  8084.     DWORD uslot3 = 0;
  8085.     if (GetWear(WEAR_UNIQUE1) && GetWear(WEAR_UNIQUE1)->GetVnum())
  8086.         uslot3 = GetWear(WEAR_UNIQUE1)->GetVnum();
  8087.     DWORD uslot4 = 0;
  8088.     if (GetWear(WEAR_UNIQUE2) && GetWear(WEAR_UNIQUE2)->GetVnum())
  8089.         uslot4 = GetWear(WEAR_UNIQUE2)->GetVnum();
  8090.    
  8091.     if (uslot1 == item->GetVnum() || uslot2 == item->GetVnum() || uslot3 == item->GetVnum() || uslot4 == item->GetVnum())
  8092.     {
  8093.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("no_same_item_twice"));
  8094.         return false;
  8095.     }
  8096.    
  8097.     // to add new item just copy uslot1 - uslot4, add new vnum here and second part:  && (item->GetVnum() == 71148 || item->GetVnum() == 71149 || item->GetVnum() == 71145)
  8098.     if ( ((uslot1 == 71148 || uslot2 == 71148 || uslot3 == 71148 || uslot4 == 71148 || uslot1 == 71149 || uslot2 == 71149 || uslot3 == 71149 || uslot4 == 71149 || uslot1 == 71145 || uslot2 == 71145 || uslot3 == 71145 || uslot4 == 71145) && (item->GetVnum() == 71148 || item->GetVnum() == 71149 || item->GetVnum() == 71145) ) )
  8099.     {
  8100.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("no_pro_items_together"));
  8101.         return false;
  8102.     }
  8103.     */
  8104.     // END
  8105.  
  8106.     if (iWearCell != WEAR_ARROW
  8107.         && (dwCurTime - GetLastAttackTime() <= 1500 || dwCurTime - m_dwLastSkillTime <= 1500))
  8108.     {
  8109.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("가만히 있을 때만 착용할 수 있습니다."));
  8110.         return false;
  8111.     }
  8112.  
  8113. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
  8114.     if (iWearCell == WEAR_WEAPON)
  8115.     {
  8116.         if (item->GetType() == ITEM_WEAPON)
  8117.         {
  8118.             LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
  8119.             if (costumeWeapon && costumeWeapon->GetValue(3) != item->GetSubType() && !UnequipItem(costumeWeapon))
  8120.             {
  8121.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
  8122.                 return false;
  8123.             }
  8124.         }
  8125.         else //fishrod/pickaxe
  8126.         {
  8127.             LPITEM costumeWeapon = GetWear(WEAR_COSTUME_WEAPON);
  8128.             if (costumeWeapon && !UnequipItem(costumeWeapon))
  8129.             {
  8130.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot unequip the costume weapon. Not enough space."));
  8131.                 return false;
  8132.             }
  8133.         }
  8134.     }
  8135.     else if (iWearCell == WEAR_COSTUME_WEAPON)
  8136.     {
  8137.         if (item->GetType() == ITEM_COSTUME && item->GetSubType() == COSTUME_WEAPON)
  8138.         {
  8139.             LPITEM pkWeapon = GetWear(WEAR_WEAPON);
  8140.             if (!pkWeapon || pkWeapon->GetType() != ITEM_WEAPON || item->GetValue(3) != pkWeapon->GetSubType())
  8141.             {
  8142.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot equip the costume weapon. Wrong equipped weapon."));
  8143.                 return false;
  8144.             }
  8145.         }
  8146.     }
  8147. #endif
  8148.  
  8149.    
  8150.     if (item->IsDragonSoul())
  8151.     {
  8152.        
  8153.        
  8154.         if(GetInventoryItem(INVENTORY_MAX_NUM + iWearCell))
  8155.         {
  8156.             ChatPacket(CHAT_TYPE_INFO, "이미 같은 종류의 용혼석을 착용하고 있습니다.");
  8157.             return false;
  8158.         }
  8159.  
  8160.         if (!item->EquipTo(this, iWearCell))
  8161.         {
  8162.             return false;
  8163.         }
  8164.     }
  8165.    
  8166.     else
  8167.     {
  8168.        
  8169.         if (GetWear(iWearCell) && !IS_SET(GetWear(iWearCell)->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  8170.         {
  8171.            
  8172.             if (item->GetWearFlag() == WEARABLE_ABILITY)
  8173.                 return false;
  8174.  
  8175.             if (false == SwapItem(item->GetCell(), INVENTORY_MAX_NUM + iWearCell))
  8176.             {
  8177.                 return false;
  8178.             }
  8179.         }
  8180.         else
  8181.         {
  8182.             BYTE bOldCell = item->GetCell();
  8183.  
  8184.             if (item->EquipTo(this, iWearCell))
  8185.             {
  8186.                 SyncQuickslot(QUICKSLOT_TYPE_ITEM, bOldCell, iWearCell);
  8187.             }
  8188.         }
  8189.     }
  8190.  
  8191.     if (true == item->IsEquipped())
  8192.     {
  8193.        
  8194.         if (-1 != item->GetProto()->cLimitRealTimeFirstUseIndex)
  8195.         {
  8196.            
  8197.             if (0 == item->GetSocket(1))
  8198.             {
  8199.                
  8200.                 long duration = (0 != item->GetSocket(0)) ? item->GetSocket(0) : item->GetProto()->aLimits[(unsigned char)(item->GetProto()->cLimitRealTimeFirstUseIndex)].lValue;
  8201.  
  8202.                 if (0 == duration)
  8203.                     duration = 60 * 60 * 24 * 7;
  8204.  
  8205.                 item->SetSocket(0, time(0) + duration);
  8206.                 item->StartRealTimeExpireEvent();
  8207.             }
  8208.  
  8209.             item->SetSocket(1, item->GetSocket(1) + 1);
  8210.         }
  8211.  
  8212.         if (item->GetVnum() == UNIQUE_ITEM_HIDE_ALIGNMENT_TITLE)
  8213.             ShowAlignment(false);
  8214.  
  8215.         const DWORD& dwVnum = item->GetVnum();
  8216.  
  8217.        
  8218.         if (true == CItemVnumHelper::IsRamadanMoonRing(dwVnum))
  8219.         {
  8220.             this->EffectPacket(SE_EQUIP_RAMADAN_RING);
  8221.         }
  8222.        
  8223.         else if (true == CItemVnumHelper::IsHalloweenCandy(dwVnum))
  8224.         {
  8225.             this->EffectPacket(SE_EQUIP_HALLOWEEN_CANDY);
  8226.         }
  8227.        
  8228.         else if (true == CItemVnumHelper::IsHappinessRing(dwVnum))
  8229.         {
  8230.             this->EffectPacket(SE_EQUIP_HAPPINESS_RING);
  8231.         }
  8232.        
  8233.         else if (true == CItemVnumHelper::IsLovePendant(dwVnum))
  8234.         {
  8235.             this->EffectPacket(SE_EQUIP_LOVE_PENDANT);
  8236.         }
  8237.         // ITEM_UNIQUE의 경우, SpecialItemGroup에 정의되어 있고, (item->GetSIGVnum() != NULL)
  8238.         //
  8239.         else if (ITEM_UNIQUE == item->GetType() && 0 != item->GetSIGVnum())
  8240.         {
  8241.             const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(item->GetSIGVnum());
  8242.             if (NULL != pGroup)
  8243.             {
  8244.                 const CSpecialAttrGroup* pAttrGroup = ITEM_MANAGER::instance().GetSpecialAttrGroup(pGroup->GetAttrVnum(item->GetVnum()));
  8245.                 if (NULL != pAttrGroup)
  8246.                 {
  8247.                     const std::string& std = pAttrGroup->m_stEffectFileName;
  8248.                     SpecificEffectPacket(std.c_str());
  8249.                 }
  8250.             }
  8251.         }
  8252. #ifdef ENABLE_ACCE_SYSTEM
  8253.         else if ((item->GetType() == ITEM_COSTUME) && (item->GetSubType() == COSTUME_ACCE))
  8254.             this->EffectPacket(SE_EFFECT_ACCE_EQUIP);
  8255. #endif
  8256.         if (
  8257.             (ITEM_UNIQUE == item->GetType() && UNIQUE_SPECIAL_RIDE == item->GetSubType() && IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE))
  8258.             || (ITEM_UNIQUE == item->GetType() && UNIQUE_SPECIAL_MOUNT_RIDE == item->GetSubType() && IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_USE))
  8259. #ifdef ENABLE_MOUNT_COSTUME_SYSTEM
  8260.             || (ITEM_COSTUME == item->GetType() && COSTUME_MOUNT == item->GetSubType())
  8261. #endif
  8262.         )
  8263.         {
  8264.             quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  8265.         }
  8266. // #ifdef __PET_SYSTEM__
  8267.         // else if(ITEM_NORMAL_PET == item->GetType())
  8268.         // {
  8269.             // quest::CQuestManager::instance().UseItem(GetPlayerID(), item, false);
  8270.         // }
  8271. // #endif
  8272.     }
  8273.  
  8274.     #ifdef ENABLE_PVP_TALISMAN
  8275.     if(item->GetVnum() == PVP_TALISMAN_VNUM)
  8276.     {
  8277.         if (quest::CQuestManager::instance().GetEventFlag("pvptalisman") == 0)
  8278.         {
  8279.             ChatPacket(CHAT_TYPE_INFO, "You can not equip this item now.");
  8280.             return false;
  8281.         }
  8282.         else if (GetMapIndex() != 199){
  8283.             ChatPacket(CHAT_TYPE_INFO, "This item can only be used in Epic Map.");
  8284.             return false;
  8285.         }
  8286.         this->SetPvPTalismanEffect();
  8287.         this->UpdatePacket();
  8288.     }
  8289.     #endif
  8290.  
  8291. #ifdef ENABLE_MOUNT_LIKE_HORSE
  8292.     if (item->IsMount())
  8293.         HorseSummon(true);
  8294. #endif
  8295.  
  8296.     return true;
  8297. }
  8298.  
  8299. void CHARACTER::BuffOnAttr_AddBuffsFromItem(LPITEM pItem)
  8300. {
  8301.     for (size_t i = 0; i < sizeof(g_aBuffOnAttrPoints)/sizeof(g_aBuffOnAttrPoints[0]); i++)
  8302.     {
  8303.         TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(g_aBuffOnAttrPoints[i]);
  8304.         if (it != m_map_buff_on_attrs.end())
  8305.         {
  8306.             it->second->AddBuffFromItem(pItem);
  8307.         }
  8308.     }
  8309. }
  8310.  
  8311. void CHARACTER::BuffOnAttr_RemoveBuffsFromItem(LPITEM pItem)
  8312. {
  8313.     for (size_t i = 0; i < sizeof(g_aBuffOnAttrPoints)/sizeof(g_aBuffOnAttrPoints[0]); i++)
  8314.     {
  8315.         TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(g_aBuffOnAttrPoints[i]);
  8316.         if (it != m_map_buff_on_attrs.end())
  8317.         {
  8318.             it->second->RemoveBuffFromItem(pItem);
  8319.         }
  8320.     }
  8321. }
  8322.  
  8323. void CHARACTER::BuffOnAttr_ClearAll()
  8324. {
  8325.     for (TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.begin(); it != m_map_buff_on_attrs.end(); it++)
  8326.     {
  8327.         CBuffOnAttributes* pBuff = it->second;
  8328.         if (pBuff)
  8329.         {
  8330.             pBuff->Initialize();
  8331.         }
  8332.     }
  8333. }
  8334.  
  8335. void CHARACTER::BuffOnAttr_ValueChange(BYTE bType, BYTE bOldValue, BYTE bNewValue)
  8336. {
  8337.     TMapBuffOnAttrs::iterator it = m_map_buff_on_attrs.find(bType);
  8338.  
  8339.     if (0 == bNewValue)
  8340.     {
  8341.         if (m_map_buff_on_attrs.end() == it)
  8342.             return;
  8343.         else
  8344.             it->second->Off();
  8345.     }
  8346.     else if(0 == bOldValue)
  8347.     {
  8348.         CBuffOnAttributes* pBuff = NULL;
  8349.         if (m_map_buff_on_attrs.end() == it)
  8350.         {
  8351.             switch (bType)
  8352.             {
  8353.             case POINT_ENERGY:
  8354.                 {
  8355.                     static BYTE abSlot[] = { WEAR_BODY, WEAR_HEAD, WEAR_FOOTS, WEAR_WRIST, WEAR_WEAPON, WEAR_NECK, WEAR_EAR, WEAR_SHIELD };
  8356.                     static std::vector <BYTE> vec_slots (abSlot, abSlot + _countof(abSlot));
  8357.                     pBuff = M2_NEW CBuffOnAttributes(this, bType, &vec_slots);
  8358.                 }
  8359.                 break;
  8360.             case POINT_COSTUME_ATTR_BONUS:
  8361.                 {
  8362.                     static BYTE abSlot[] = {
  8363.                         WEAR_COSTUME_BODY,
  8364.                         WEAR_COSTUME_HAIR,
  8365. #ifdef ENABLE_WEAPON_COSTUME_SYSTEM
  8366.                         WEAR_COSTUME_WEAPON,
  8367. #endif
  8368.                     };
  8369.                     static std::vector <BYTE> vec_slots (abSlot, abSlot + _countof(abSlot));
  8370.                     pBuff = M2_NEW CBuffOnAttributes(this, bType, &vec_slots);
  8371.                 }
  8372.                 break;
  8373.             default:
  8374.                 break;
  8375.             }
  8376.             m_map_buff_on_attrs.insert(TMapBuffOnAttrs::value_type(bType, pBuff));
  8377.  
  8378.         }
  8379.         else
  8380.             pBuff = it->second;
  8381.         if (pBuff != NULL)
  8382.             pBuff->On(bNewValue);
  8383.     }
  8384.     else
  8385.     {
  8386.         assert (m_map_buff_on_attrs.end() != it);
  8387.         it->second->ChangeBuffValue(bNewValue);
  8388.     }
  8389. }
  8390.  
  8391.  
  8392. LPITEM CHARACTER::FindSpecifyItem(DWORD vnum) const
  8393. {
  8394.     for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  8395.         if (GetInventoryItem(i) && GetInventoryItem(i)->GetVnum() == vnum)
  8396.             return GetInventoryItem(i);
  8397.  
  8398.     return NULL;
  8399. }
  8400.  
  8401. LPITEM CHARACTER::FindItemByID(DWORD id) const
  8402. {
  8403.     for (int i=0 ; i < INVENTORY_MAX_NUM ; ++i)
  8404.     {
  8405.         if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetID() == id)
  8406.             return GetInventoryItem(i);
  8407.     }
  8408.  
  8409.     for (int i=BELT_INVENTORY_SLOT_START; i < BELT_INVENTORY_SLOT_END ; ++i)
  8410.     {
  8411.         if (NULL != GetInventoryItem(i) && GetInventoryItem(i)->GetID() == id)
  8412.             return GetInventoryItem(i);
  8413.     }
  8414.  
  8415.     return NULL;
  8416. }
  8417.  
  8418. int CHARACTER::CountSpecifyItem(DWORD vnum) const
  8419. {
  8420.     int count = 0;
  8421.     LPITEM item;
  8422.  
  8423.     for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  8424.     {
  8425.         item = GetInventoryItem(i);
  8426.         if (NULL != item && item->GetVnum() == vnum)
  8427.         {
  8428.            
  8429.             if (m_pkMyShop && m_pkMyShop->IsSellingItem(item->GetID()))
  8430.             {
  8431.                 continue;
  8432.             }
  8433.             else
  8434.             {
  8435.                 count += item->GetCount();
  8436.             }
  8437.         }
  8438.     }
  8439.  
  8440.     return count;
  8441. }
  8442.  
  8443. void CHARACTER::RemoveSpecifyItem(DWORD vnum, DWORD count)
  8444. {
  8445.     if (0 == count)
  8446.         return;
  8447.  
  8448.     for (UINT i = 0; i < INVENTORY_MAX_NUM; ++i)
  8449.     {
  8450.         if (NULL == GetInventoryItem(i))
  8451.             continue;
  8452.  
  8453.         if (GetInventoryItem(i)->GetVnum() != vnum)
  8454.             continue;
  8455.  
  8456.        
  8457.         if(m_pkMyShop)
  8458.         {
  8459.             bool isItemSelling = m_pkMyShop->IsSellingItem(GetInventoryItem(i)->GetID());
  8460.             if (isItemSelling)
  8461.                 continue;
  8462.         }
  8463.  
  8464.         if (vnum >= 80003 && vnum <= 80007)
  8465.             LogManager::instance().GoldBarLog(GetPlayerID(), GetInventoryItem(i)->GetID(), QUEST, "RemoveSpecifyItem");
  8466.  
  8467.         if (count >= GetInventoryItem(i)->GetCount())
  8468.         {
  8469.             count -= GetInventoryItem(i)->GetCount();
  8470.             GetInventoryItem(i)->SetCount(0);
  8471.  
  8472.             if (0 == count)
  8473.                 return;
  8474.         }
  8475.         else
  8476.         {
  8477.             GetInventoryItem(i)->SetCount(GetInventoryItem(i)->GetCount() - count);
  8478.             return;
  8479.         }
  8480.     }
  8481.  
  8482.    
  8483.     if (count)
  8484.         sys_log(0, "CHARACTER::RemoveSpecifyItem cannot remove enough item vnum %u, still remain %d", vnum, count);
  8485. }
  8486.  
  8487. int CHARACTER::CountSpecifyTypeItem(BYTE type) const
  8488. {
  8489.     int count = 0;
  8490.  
  8491.     for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  8492.     {
  8493.         LPITEM pItem = GetInventoryItem(i);
  8494.         if (pItem != NULL && pItem->GetType() == type)
  8495.         {
  8496.             count += pItem->GetCount();
  8497.         }
  8498.     }
  8499.  
  8500.     return count;
  8501. }
  8502.  
  8503. void CHARACTER::RemoveSpecifyTypeItem(BYTE type, DWORD count)
  8504. {
  8505.     if (0 == count)
  8506.         return;
  8507.  
  8508.     for (UINT i = 0; i < INVENTORY_MAX_NUM; ++i)
  8509.     {
  8510.         if (NULL == GetInventoryItem(i))
  8511.             continue;
  8512.  
  8513.         if (GetInventoryItem(i)->GetType() != type)
  8514.             continue;
  8515.  
  8516.        
  8517.         if(m_pkMyShop)
  8518.         {
  8519.             bool isItemSelling = m_pkMyShop->IsSellingItem(GetInventoryItem(i)->GetID());
  8520.             if (isItemSelling)
  8521.                 continue;
  8522.         }
  8523.  
  8524.         if (count >= GetInventoryItem(i)->GetCount())
  8525.         {
  8526.             count -= GetInventoryItem(i)->GetCount();
  8527.             GetInventoryItem(i)->SetCount(0);
  8528.  
  8529.             if (0 == count)
  8530.                 return;
  8531.         }
  8532.         else
  8533.         {
  8534.             GetInventoryItem(i)->SetCount(GetInventoryItem(i)->GetCount() - count);
  8535.             return;
  8536.         }
  8537.     }
  8538. }
  8539.  
  8540. void CHARACTER::AutoGiveItem(LPITEM item, bool longOwnerShip)
  8541. {
  8542.     if (NULL == item)
  8543.     {
  8544.         sys_err ("NULL point.");
  8545.         return;
  8546.     }
  8547.     if (item->GetOwner())
  8548.     {
  8549.         sys_err ("item %d 's owner exists!",item->GetID());
  8550.         return;
  8551.     }
  8552.  
  8553.     int cell;
  8554.     if (item->IsDragonSoul())
  8555.     {
  8556.         cell = GetEmptyDragonSoulInventory(item);
  8557.     }
  8558.     else
  8559.     {
  8560.         cell = GetEmptyInventory (item->GetSize());
  8561.     }
  8562.  
  8563.     if (cell != -1)
  8564.     {
  8565.         if (item->IsDragonSoul())
  8566.             item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, cell));
  8567.         else
  8568.             item->AddToCharacter(this, TItemPos(INVENTORY, cell));
  8569.  
  8570.         LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
  8571.  
  8572.         if (item->GetType() == ITEM_USE && item->GetSubType() == USE_POTION)
  8573.         {
  8574.             TQuickslot * pSlot;
  8575.  
  8576.             if (GetQuickslot(0, &pSlot) && pSlot->type == QUICKSLOT_TYPE_NONE)
  8577.             {
  8578.                 TQuickslot slot;
  8579.                 slot.type = QUICKSLOT_TYPE_ITEM;
  8580.                 slot.pos = cell;
  8581.                 SetQuickslot(0, slot);
  8582.             }
  8583.         }
  8584.     }
  8585.     else
  8586.     {
  8587.         if (GetGMLevel() > GM_PLAYER)
  8588.         {
  8589.             ChatPacket(CHAT_TYPE_INFO, "No drop allowed.");
  8590.             return;
  8591.         }
  8592.         item->AddToGround (GetMapIndex(), GetXYZ());
  8593. #ifdef ENABLE_NEWSTUFF
  8594.         item->StartDestroyEvent(g_aiItemDestroyTime[ITEM_DESTROY_TIME_AUTOGIVE]);
  8595. #else
  8596.         item->StartDestroyEvent();
  8597. #endif
  8598.  
  8599.         if (longOwnerShip)
  8600.             item->SetOwnership (this, 300);
  8601.         else
  8602.             item->SetOwnership (this, 60);
  8603.         LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
  8604.     }
  8605. }
  8606.  
  8607. LPITEM CHARACTER::AutoGiveItem(DWORD dwItemVnum, BYTE bCount, int iRarePct, bool bMsg)
  8608. {
  8609.     TItemTable * p = ITEM_MANAGER::instance().GetTable(dwItemVnum);
  8610.  
  8611.     if (!p)
  8612.         return NULL;
  8613.  
  8614.     DBManager::instance().SendMoneyLog(MONEY_LOG_DROP, dwItemVnum, bCount);
  8615.  
  8616.     if (p->dwFlags & ITEM_FLAG_STACKABLE && p->bType != ITEM_BLEND)
  8617.     {
  8618.         for (int i = 0; i < INVENTORY_MAX_NUM; ++i)
  8619.         {
  8620.             LPITEM item = GetInventoryItem(i);
  8621.  
  8622.             if (!item)
  8623.                 continue;
  8624.  
  8625.             if (item->GetVnum() == dwItemVnum && FN_check_item_socket(item))
  8626.             {
  8627.                 if (IS_SET(p->dwFlags, ITEM_FLAG_MAKECOUNT))
  8628.                 {
  8629.                     if (bCount < p->alValues[1])
  8630.                         bCount = p->alValues[1];
  8631.                 }
  8632.  
  8633.                 BYTE bCount2 = MIN(g_bItemCountLimit - item->GetCount(), bCount);
  8634.                 bCount -= bCount2;
  8635.  
  8636.                 item->SetCount(item->GetCount() + bCount2);
  8637.  
  8638.                 if (bCount == 0)
  8639.                 {
  8640.                     if (bMsg)
  8641.                         #if defined(__CHATTING_WINDOW_RENEWAL__)
  8642.                         ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  8643.                         #else
  8644.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  8645.                         #endif
  8646.  
  8647.                     return item;
  8648.                 }
  8649.             }
  8650.         }
  8651.     }
  8652.  
  8653.     LPITEM item = ITEM_MANAGER::instance().CreateItem(dwItemVnum, bCount, 0, true);
  8654.  
  8655.     if (!item)
  8656.     {
  8657.         sys_err("cannot create item by vnum %u (name: %s)", dwItemVnum, GetName());
  8658.         return NULL;
  8659.     }
  8660.  
  8661.     if (item->GetType() == ITEM_BLEND)
  8662.     {
  8663.         for (int i=0; i < INVENTORY_MAX_NUM; i++)
  8664.         {
  8665.             LPITEM inv_item = GetInventoryItem(i);
  8666.  
  8667.             if (inv_item == NULL) continue;
  8668.  
  8669.             if (inv_item->GetType() == ITEM_BLEND)
  8670.             {
  8671.                 if (inv_item->GetVnum() == item->GetVnum())
  8672.                 {
  8673.                     if (inv_item->GetSocket(0) == item->GetSocket(0) &&
  8674.                             inv_item->GetSocket(1) == item->GetSocket(1) &&
  8675.                             inv_item->GetSocket(2) == item->GetSocket(2) &&
  8676.                             inv_item->GetCount() + item->GetCount() <= g_bItemCountLimit)
  8677.                     {
  8678.                         inv_item->SetCount(inv_item->GetCount() + item->GetCount());
  8679.                         // Memory Leak Fix
  8680.                         M2_DESTROY_ITEM(item);
  8681.                         return inv_item;
  8682.                     }
  8683.                 }
  8684.             }
  8685.         }
  8686.     }
  8687.  
  8688.     int iEmptyCell;
  8689.     if (item->IsDragonSoul())
  8690.     {
  8691.         iEmptyCell = GetEmptyDragonSoulInventory(item);
  8692.     }
  8693.     else
  8694.         iEmptyCell = GetEmptyInventory(item->GetSize());
  8695.  
  8696.     if (iEmptyCell != -1)
  8697.     {
  8698.         if (bMsg)
  8699.             #if defined(__CHATTING_WINDOW_RENEWAL__)
  8700.             ChatPacket(CHAT_TYPE_ITEM_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  8701.             #else
  8702.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아이템 획득: %s"), item->GetName());
  8703.             #endif
  8704.  
  8705.         if (item->IsDragonSoul())
  8706.             item->AddToCharacter(this, TItemPos(DRAGON_SOUL_INVENTORY, iEmptyCell));
  8707.         else
  8708.             item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyCell));
  8709.         LogManager::instance().ItemLog(this, item, "SYSTEM", item->GetName());
  8710.  
  8711.         if (item->GetType() == ITEM_USE && item->GetSubType() == USE_POTION)
  8712.         {
  8713.             TQuickslot * pSlot;
  8714.  
  8715.             if (GetQuickslot(0, &pSlot) && pSlot->type == QUICKSLOT_TYPE_NONE)
  8716.             {
  8717.                 TQuickslot slot;
  8718.                 slot.type = QUICKSLOT_TYPE_ITEM;
  8719.                 slot.pos = iEmptyCell;
  8720.                 SetQuickslot(0, slot);
  8721.             }
  8722.         }
  8723.     }
  8724.     else
  8725.     {
  8726.         item->AddToGround(GetMapIndex(), GetXYZ());
  8727. #ifdef ENABLE_NEWSTUFF
  8728.         item->StartDestroyEvent(g_aiItemDestroyTime[ITEM_DESTROY_TIME_AUTOGIVE]);
  8729. #else
  8730.         item->StartDestroyEvent();
  8731. #endif
  8732.        
  8733.        
  8734.        
  8735.         if (IS_SET(item->GetAntiFlag(), ITEM_ANTIFLAG_DROP))
  8736.             item->SetOwnership(this, 300);
  8737.         else
  8738.             item->SetOwnership(this, 60);
  8739.         LogManager::instance().ItemLog(this, item, "SYSTEM_DROP", item->GetName());
  8740.     }
  8741.  
  8742.     sys_log(0,
  8743.         "7: %d %d", dwItemVnum, bCount);
  8744.     return item;
  8745. }
  8746.  
  8747. bool CHARACTER::GiveItem(LPCHARACTER victim, TItemPos Cell)
  8748. {
  8749.     if (!CanHandleItem())
  8750.         return false;
  8751.  
  8752.     // @fixme150 BEGIN
  8753.     if (quest::CQuestManager::instance().GetPCForce(GetPlayerID())->IsRunning() == true)
  8754.     {
  8755.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("You cannot take this item if you're using quests"));
  8756.         return false;
  8757.     }
  8758.     // @fixme150 END
  8759.  
  8760.     LPITEM item = GetItem(Cell);
  8761.  
  8762.     if (item && !item->IsExchanging())
  8763.     {
  8764.         if (victim->CanReceiveItem(this, item))
  8765.         {
  8766.             victim->ReceiveItem(this, item);
  8767.             return true;
  8768.         }
  8769.     }
  8770.  
  8771.     return false;
  8772. }
  8773.  
  8774. bool CHARACTER::CanReceiveItem(LPCHARACTER from, LPITEM item) const
  8775. {
  8776.     if (IsPC())
  8777.         return false;
  8778.  
  8779.     // TOO_LONG_DISTANCE_EXCHANGE_BUG_FIX
  8780.     if (DISTANCE_APPROX(GetX() - from->GetX(), GetY() - from->GetY()) > 2000)
  8781.         return false;
  8782.     // END_OF_TOO_LONG_DISTANCE_EXCHANGE_BUG_FIX
  8783.  
  8784.     switch (GetRaceNum())
  8785.     {
  8786.         case fishing::CAMPFIRE_MOB:
  8787.             if (item->GetType() == ITEM_FISH &&
  8788.                     (item->GetSubType() == FISH_ALIVE || item->GetSubType() == FISH_DEAD))
  8789.                 return true;
  8790.             break;
  8791.  
  8792.         case fishing::FISHER_MOB:
  8793.             if (item->GetType() == ITEM_ROD)
  8794.                 return true;
  8795.             break;
  8796.  
  8797.             // BUILDING_NPC
  8798.         case BLACKSMITH_WEAPON_MOB:
  8799.         case DEVILTOWER_BLACKSMITH_WEAPON_MOB:
  8800.             if (item->GetType() == ITEM_WEAPON &&
  8801.                     item->GetRefinedVnum())
  8802.                 return true;
  8803.             else
  8804.                 return false;
  8805.             break;
  8806.  
  8807.         case BLACKSMITH_ARMOR_MOB:
  8808.         case DEVILTOWER_BLACKSMITH_ARMOR_MOB:
  8809.             if (item->GetType() == ITEM_ARMOR &&
  8810.                     (item->GetSubType() == ARMOR_BODY || item->GetSubType() == ARMOR_SHIELD || item->GetSubType() == ARMOR_HEAD) &&
  8811.                     item->GetRefinedVnum())
  8812.                 return true;
  8813.             else
  8814.                 return false;
  8815.             break;
  8816.  
  8817.         case BLACKSMITH_ACCESSORY_MOB:
  8818.         case DEVILTOWER_BLACKSMITH_ACCESSORY_MOB:
  8819.             if (item->GetType() == ITEM_ARMOR &&
  8820.                     !(item->GetSubType() == ARMOR_BODY || item->GetSubType() == ARMOR_SHIELD || item->GetSubType() == ARMOR_HEAD) &&
  8821.                     item->GetRefinedVnum())
  8822.                 return true;
  8823.             else
  8824.                 return false;
  8825.             break;
  8826.             // END_OF_BUILDING_NPC
  8827.  
  8828.         case BLACKSMITH_MOB:
  8829.             if (item->GetRefinedVnum() && item->GetRefineSet() < 500)
  8830.             {
  8831.                 return true;
  8832.             }
  8833.             else
  8834.             {
  8835.                 return false;
  8836.             }
  8837.  
  8838.         case BLACKSMITH2_MOB:
  8839.             if (item->GetRefineSet() >= 500)
  8840.             {
  8841.                 return true;
  8842.             }
  8843.             else
  8844.             {
  8845.                 return false;
  8846.             }
  8847.  
  8848.         case ALCHEMIST_MOB:
  8849.             if (item->GetRefinedVnum())
  8850.                 return true;
  8851.             break;
  8852.  
  8853.         case 20101:
  8854.         case 20102:
  8855.         case 20103:
  8856.            
  8857.             if (item->GetVnum() == ITEM_REVIVE_HORSE_1)
  8858.             {
  8859.                 if (!IsDead())
  8860.                 {
  8861.                     from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽지 않은 말에게 선초를 먹일 수 없습니다."));
  8862.                     return false;
  8863.                 }
  8864.                 return true;
  8865.             }
  8866.             else if (item->GetVnum() == ITEM_HORSE_FOOD_1)
  8867.             {
  8868.                 if (IsDead())
  8869.                 {
  8870.                     from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽은 말에게 사료를 먹일 수 없습니다."));
  8871.                     return false;
  8872.                 }
  8873.                 return true;
  8874.             }
  8875.             else if (item->GetVnum() == ITEM_HORSE_FOOD_2 || item->GetVnum() == ITEM_HORSE_FOOD_3)
  8876.             {
  8877.                 return false;
  8878.             }
  8879.             break;
  8880.         case 20104:
  8881.         case 20105:
  8882.         case 20106:
  8883.            
  8884.             if (item->GetVnum() == ITEM_REVIVE_HORSE_2)
  8885.             {
  8886.                 if (!IsDead())
  8887.                 {
  8888.                     from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽지 않은 말에게 선초를 먹일 수 없습니다."));
  8889.                     return false;
  8890.                 }
  8891.                 return true;
  8892.             }
  8893.             else if (item->GetVnum() == ITEM_HORSE_FOOD_2)
  8894.             {
  8895.                 if (IsDead())
  8896.                 {
  8897.                     from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽은 말에게 사료를 먹일 수 없습니다."));
  8898.                     return false;
  8899.                 }
  8900.                 return true;
  8901.             }
  8902.             else if (item->GetVnum() == ITEM_HORSE_FOOD_1 || item->GetVnum() == ITEM_HORSE_FOOD_3)
  8903.             {
  8904.                 return false;
  8905.             }
  8906.             break;
  8907.         case 20107:
  8908.         case 20108:
  8909.         case 20109:
  8910.            
  8911.             if (item->GetVnum() == ITEM_REVIVE_HORSE_3)
  8912.             {
  8913.                 if (!IsDead())
  8914.                 {
  8915.                     from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽지 않은 말에게 선초를 먹일 수 없습니다."));
  8916.                     return false;
  8917.                 }
  8918.                 return true;
  8919.             }
  8920.             else if (item->GetVnum() == ITEM_HORSE_FOOD_3)
  8921.             {
  8922.                 if (IsDead())
  8923.                 {
  8924.                     from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("죽은 말에게 사료를 먹일 수 없습니다."));
  8925.                     return false;
  8926.                 }
  8927.                 return true;
  8928.             }
  8929.             else if (item->GetVnum() == ITEM_HORSE_FOOD_1 || item->GetVnum() == ITEM_HORSE_FOOD_2)
  8930.             {
  8931.                 return false;
  8932.             }
  8933.             break;
  8934.     }
  8935.  
  8936.     //if (IS_SET(item->GetFlag(), ITEM_FLAG_QUEST_GIVE))
  8937.     {
  8938.         return true;
  8939.     }
  8940.  
  8941.     return false;
  8942. }
  8943.  
  8944. void CHARACTER::ReceiveItem(LPCHARACTER from, LPITEM item)
  8945. {
  8946.     if (IsPC())
  8947.         return;
  8948.  
  8949.     switch (GetRaceNum())
  8950.     {
  8951.         case fishing::CAMPFIRE_MOB:
  8952.             if (item->GetType() == ITEM_FISH && (item->GetSubType() == FISH_ALIVE || item->GetSubType() == FISH_DEAD))
  8953.                 fishing::Grill(from, item);
  8954.             else
  8955.             {
  8956.                 // TAKE_ITEM_BUG_FIX
  8957.                 from->SetQuestNPCID(GetVID());
  8958.                 // END_OF_TAKE_ITEM_BUG_FIX
  8959.                 quest::CQuestManager::instance().TakeItem(from->GetPlayerID(), GetRaceNum(), item);
  8960.             }
  8961.             break;
  8962.  
  8963.             // DEVILTOWER_NPC
  8964.         case DEVILTOWER_BLACKSMITH_WEAPON_MOB:
  8965.         case DEVILTOWER_BLACKSMITH_ARMOR_MOB:
  8966.         case DEVILTOWER_BLACKSMITH_ACCESSORY_MOB:
  8967.             if (item->GetRefinedVnum() != 0 && item->GetRefineSet() != 0 && item->GetRefineSet() < 500)
  8968.             {
  8969.                 from->SetRefineNPC(this);
  8970.                 from->RefineInformation(item->GetCell(), REFINE_TYPE_MONEY_ONLY);
  8971.             }
  8972.             else
  8973.             {
  8974.                 from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  8975.             }
  8976.             break;
  8977.             // END_OF_DEVILTOWER_NPC
  8978.  
  8979.         case BLACKSMITH_MOB:
  8980.         case BLACKSMITH2_MOB:
  8981.         case BLACKSMITH_WEAPON_MOB:
  8982.         case BLACKSMITH_ARMOR_MOB:
  8983.         case BLACKSMITH_ACCESSORY_MOB:
  8984.             if (item->GetRefinedVnum())
  8985.             {
  8986.                 from->SetRefineNPC(this);
  8987.                 from->RefineInformation(item->GetCell(), REFINE_TYPE_NORMAL);
  8988.             }
  8989.             else
  8990.             {
  8991.                 from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이 아이템은 개량할 수 없습니다."));
  8992.             }
  8993.             break;
  8994.  
  8995.         case 20101:
  8996.         case 20102:
  8997.         case 20103:
  8998.         case 20104:
  8999.         case 20105:
  9000.         case 20106:
  9001.         case 20107:
  9002.         case 20108:
  9003.         case 20109:
  9004.             if (item->GetVnum() == ITEM_REVIVE_HORSE_1 ||
  9005.                     item->GetVnum() == ITEM_REVIVE_HORSE_2 ||
  9006.                     item->GetVnum() == ITEM_REVIVE_HORSE_3)
  9007.             {
  9008.                 from->ReviveHorse();
  9009.                 item->SetCount(item->GetCount()-1);
  9010.                 from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("말에게 선초를 주었습니다."));
  9011.             }
  9012.             else if (item->GetVnum() == ITEM_HORSE_FOOD_1 ||
  9013.                     item->GetVnum() == ITEM_HORSE_FOOD_2 ||
  9014.                     item->GetVnum() == ITEM_HORSE_FOOD_3)
  9015.             {
  9016.                 from->FeedHorse();
  9017.                 from->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("말에게 사료를 주었습니다."));
  9018.                 item->SetCount(item->GetCount()-1);
  9019.                 EffectPacket(SE_HPUP_RED);
  9020.             }
  9021.             break;
  9022.  
  9023.         default:
  9024.             sys_log(0, "TakeItem %s %d %s", from->GetName(), GetRaceNum(), item->GetName());
  9025.             from->SetQuestNPCID(GetVID());
  9026.             quest::CQuestManager::instance().TakeItem(from->GetPlayerID(), GetRaceNum(), item);
  9027.             break;
  9028.     }
  9029. }
  9030.  
  9031. bool CHARACTER::IsEquipUniqueItem(DWORD dwItemVnum) const
  9032. {
  9033.     {
  9034.         LPITEM u = GetWear(WEAR_UNIQUE1);
  9035.  
  9036.         if (u && u->GetVnum() == dwItemVnum)
  9037.             return true;
  9038.     }
  9039.  
  9040.     {
  9041.         LPITEM u = GetWear(WEAR_UNIQUE2);
  9042.  
  9043.         if (u && u->GetVnum() == dwItemVnum)
  9044.             return true;
  9045.     }
  9046.  
  9047.    
  9048.     if (dwItemVnum == UNIQUE_ITEM_RING_OF_LANGUAGE)
  9049.         return IsEquipUniqueItem(UNIQUE_ITEM_RING_OF_LANGUAGE_SAMPLE);
  9050.  
  9051.     return false;
  9052. }
  9053.  
  9054. // CHECK_UNIQUE_GROUP
  9055. bool CHARACTER::IsEquipUniqueGroup(DWORD dwGroupVnum) const
  9056. {
  9057.     {
  9058.         LPITEM u = GetWear(WEAR_UNIQUE1);
  9059.  
  9060.         if (u && u->GetSpecialGroup() == (int) dwGroupVnum)
  9061.             return true;
  9062.     }
  9063.  
  9064.     {
  9065.         LPITEM u = GetWear(WEAR_UNIQUE2);
  9066.  
  9067.         if (u && u->GetSpecialGroup() == (int) dwGroupVnum)
  9068.             return true;
  9069.     }
  9070.  
  9071.     return false;
  9072. }
  9073. // END_OF_CHECK_UNIQUE_GROUP
  9074.  
  9075. void CHARACTER::SetRefineMode(int iAdditionalCell)
  9076. {
  9077.     m_iRefineAdditionalCell = iAdditionalCell;
  9078.     m_bUnderRefine = true;
  9079. }
  9080.  
  9081. void CHARACTER::ClearRefineMode()
  9082. {
  9083.     m_bUnderRefine = false;
  9084.     SetRefineNPC( NULL );
  9085. }
  9086.  
  9087. #ifdef SEARCH_BOX_SYSTEM
  9088. bool CHARACTER::InformationSpecialItemGroup(DWORD dwGroupNum, std::vector<DWORD> &dwItemVnums, std::vector<DWORD> &dwItemCounts, std::vector <LPITEM> &item_gets, int &count)
  9089. {
  9090.     const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(dwGroupNum);
  9091.     if (!pGroup)
  9092.     {
  9093.         return false;
  9094.     }
  9095.  
  9096.     bool bSuccess;
  9097.     DWORD CountTotal = pGroup->GetItemGroup();
  9098.  
  9099.     for (int i = 0; i < CountTotal; i++)
  9100.     {
  9101.         DWORD dwVnum = pGroup->GetVnum(i);
  9102.         DWORD dwCount = pGroup->GetCount(i);
  9103.         bSuccess = true;
  9104.  
  9105.         if (bSuccess)
  9106.         {
  9107.             dwItemVnums.push_back(dwVnum);
  9108.             dwItemCounts.push_back(dwCount);
  9109.            
  9110.         }
  9111.         count = CountTotal;
  9112.  
  9113.     }
  9114.     return bSuccess;
  9115.  
  9116. }
  9117. #endif
  9118.  
  9119. #ifdef ENABLE_CHEST_OPEN_RENEWAL
  9120. bool CHARACTER::OpenChestItem(TItemPos pos, BYTE bOpenCount)
  9121. {
  9122.     LPITEM item;
  9123.     if (!CanHandleItem())
  9124.         return false;
  9125.    
  9126.     if (!IsValidItemPosition(pos) || !(item = GetItem(pos)))
  9127.         return false;
  9128.    
  9129.     if (item->IsExchanging())
  9130.         return false;
  9131.    
  9132.     if (IsStun())
  9133.         return false;
  9134.    
  9135.     return OpenChestItem(item, bOpenCount);
  9136. }
  9137.  
  9138. bool CHARACTER::OpenChestItem(LPITEM item, BYTE bOpenCount)
  9139. {
  9140.     if (!item)
  9141.         return false;
  9142.    
  9143.     if (!CanHandleItem())
  9144.         return false;
  9145.    
  9146.     if (item->IsExchanging())
  9147.         return false;
  9148.    
  9149.     if (IsStun())
  9150.         return false;
  9151.    
  9152.     DWORD dwGroupNum = item->GetVnum();
  9153.     const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(dwGroupNum);
  9154.     if (!pGroup)
  9155.     {
  9156.         sys_err("cannot find special item group %d", dwGroupNum);
  9157.         return false;
  9158.     }
  9159.  
  9160.     // if box rewards length is greater than the inventory available space -> do not open the box
  9161.     int requiredSlots = (pGroup->m_bType == CSpecialItemGroup::PCT) ? pGroup->GetGroupSize() : 1;
  9162.     int freeSlots = CountEmptyInventory();
  9163.  
  9164.     if (freeSlots < requiredSlots) {
  9165.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("Not enough inventory space."));
  9166.         return false;
  9167.     }
  9168.     // end
  9169.  
  9170.     if (item->isLocked())
  9171.     {
  9172.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("<창고> 이 아이템은 넣을 수 없습니다."));
  9173.         return false;
  9174.     }
  9175.    
  9176.     BYTE loopCount = MINMAX(1, MIN(bOpenCount, item->GetCount()), 200);
  9177.     if (loopCount > item->GetCount())
  9178.     {
  9179.         sys_err("loopCount > item->GetCount() %d", dwGroupNum);
  9180.         return false;
  9181.     }
  9182.    
  9183.     item->Lock(true);
  9184.     if (test_server)
  9185.         ChatPacket(CHAT_TYPE_INFO, "Opening %d times of %d", loopCount, dwGroupNum);
  9186.    
  9187.     // umap of all itemVnums|Counts given at the end
  9188.     std::unordered_map<DWORD, long long> wGivenItems;
  9189.     for (auto oCount = 0; oCount < loopCount; oCount++)
  9190.     {
  9191.         std::vector<int> itemIndexes;
  9192.         int itemIndexesCount = pGroup->GetMultiIndex(itemIndexes);
  9193.        
  9194.         for (auto index = 0; index < itemIndexesCount; index++)
  9195.         {
  9196.             DWORD dwVnum = pGroup->GetVnum(itemIndexes[index]);
  9197.             DWORD dwCount = pGroup->GetCount(itemIndexes[index]);
  9198.            
  9199.             long long llItemCount = wGivenItems.count(dwVnum) > 0 ? wGivenItems[dwVnum] + dwCount : dwCount;
  9200.             wGivenItems[dwVnum] = llItemCount;
  9201.         }
  9202.     }
  9203.  
  9204.     if (wGivenItems.size() < 1)
  9205.     {
  9206.         ChatPacket(CHAT_TYPE_TALKING, LC_TEXT("아무것도 얻을 수 없었습니다."));
  9207.         if (item)
  9208.             item->Lock(false);
  9209.         return false;
  9210.     }
  9211.  
  9212.     item->Lock(false);
  9213.     // item->SetCount(MAX(0, item->GetCount() - loopCount));
  9214.     std::vector<DWORD> infiniteBoxVnums = {27200,27201,27202,27203};
  9215.  
  9216.     bool bReusableChest = (std::find(infiniteBoxVnums.begin(), infiniteBoxVnums.end(), item->GetVnum()) != infiniteBoxVnums.end());
  9217.     if (!bReusableChest)
  9218.     {
  9219.         item->SetCount(MAX(0, item->GetCount() - loopCount));
  9220.     }
  9221.     else
  9222.     {
  9223.         if (g_BoxUseTimeLimitValue && !PulseManager::Instance().IncreaseClock(GetPlayerID(), ePulse::BoxOpening, std::chrono::milliseconds(g_BoxUseTimeLimitValue)))
  9224.         {
  9225.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 골드를 버릴 수 없습니다."));
  9226.             return false;
  9227.         }
  9228.     }
  9229.  
  9230.     for (auto& info : wGivenItems)
  9231.     {
  9232.         DWORD dwItemVnum = info.first;
  9233.         long long llItemCount = info.second;
  9234.        
  9235.         LPITEM pItem;
  9236.         switch (dwItemVnum)
  9237.         {
  9238.             case CSpecialItemGroup::GOLD:
  9239.             {
  9240.                 PointChange(POINT_GOLD, llItemCount);
  9241.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("돈 %lld 냥을 획득했습니다."), llItemCount);
  9242.             }
  9243.             break;
  9244.            
  9245.             case CSpecialItemGroup::EXP:
  9246.             {
  9247.                 PointChange(POINT_EXP, llItemCount);
  9248.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 부터 신비한 빛이 나옵니다."));
  9249.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("%lld의 경험치를 획득했습니다."), llItemCount);
  9250.             }
  9251.             break;
  9252.            
  9253.             case CSpecialItemGroup::MOB:
  9254.             {
  9255.                 int x = GetX() + number(-500, 500);
  9256.                 int y = GetY() + number(-500, 500);
  9257.                
  9258.                 LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(llItemCount, GetMapIndex(), x, y, 0, true, -1);
  9259.                 if (ch)
  9260.                     ch->SetAggressive();
  9261.                
  9262.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  9263.             }
  9264.             break;
  9265.            
  9266.             case CSpecialItemGroup::SLOW:
  9267.             {
  9268.                 sys_log(0, "CSpecialItemGroup::SLOW %d", -(int)llItemCount);
  9269.                 AddAffect(AFFECT_SLOW, POINT_MOV_SPEED, -(int)llItemCount, AFF_SLOW, 300, 0, true);
  9270.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 빨간 연기를 들이마시자 움직이는 속도가 느려졌습니다!"));
  9271.             }
  9272.             break;
  9273.            
  9274.             case CSpecialItemGroup::DRAIN_HP:
  9275.             {
  9276.                 int iDropHP = GetMaxHP()*llItemCount/100;
  9277.                 iDropHP = MIN(iDropHP, GetHP()-1);
  9278.                 PointChange(POINT_HP, -iDropHP);
  9279.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자가 갑자기 폭발하였습니다! 생명력이 감소했습니다."));
  9280.             }
  9281.             break;
  9282.            
  9283.             case CSpecialItemGroup::POISON:
  9284.             {
  9285.                 AttackedByPoison(NULL);
  9286.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  9287.             }
  9288.             break;
  9289.            
  9290. #ifdef ENABLE_WOLFMAN_CHARACTER
  9291.             case CSpecialItemGroup::BLEEDING:
  9292.             {
  9293.                 AttackedByBleeding(NULL);
  9294.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 나온 녹색 연기를 들이마시자 독이 온몸으로 퍼집니다!"));
  9295.             }
  9296.             break;
  9297. #endif
  9298.             case CSpecialItemGroup::MOB_GROUP:
  9299.             {
  9300.                 int sx = GetX() - number(300, 500);
  9301.                 int sy = GetY() - number(300, 500);
  9302.                 int ex = GetX() + number(300, 500);
  9303.                 int ey = GetY() + number(300, 500);
  9304.                 CHARACTER_MANAGER::instance().SpawnGroup(llItemCount, GetMapIndex(), sx, sy, ex, ey, NULL, true);
  9305.                 ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 몬스터가 나타났습니다!"));
  9306.             }
  9307.             break;
  9308.             default:
  9309.             {
  9310.                 if (llItemCount > g_bItemCountLimit)
  9311.                 {
  9312.                     for(auto itemIndex = llItemCount; itemIndex > 0; itemIndex -= g_bItemCountLimit)
  9313.                     {
  9314.                         WORD wCount = MIN(itemIndex, g_bItemCountLimit);
  9315.                         pItem = AutoGiveItem(dwItemVnum, wCount, -1, false);
  9316.                     }
  9317.                 }
  9318.                 else if ((pItem = AutoGiveItem(dwItemVnum, llItemCount, -1, false)))
  9319.                 {
  9320.                     if (!pItem->IsStackable() && llItemCount > 1)
  9321.                     {
  9322.                         for (auto itemIndex = 0; itemIndex < (llItemCount - 1); itemIndex++)
  9323.                             pItem = AutoGiveItem(dwItemVnum, 1, -1, false);
  9324.                     }
  9325.                 }
  9326.                
  9327.                 // std::string itemName = "[IN;" + std::to_string(dwItemVnum) + "]";
  9328.                 // if (llItemCount > 1)
  9329.                     // ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 %lld 개 나왔습니다."), itemName.c_str(), llItemCount);
  9330.                 // else
  9331.                     // ChatPacket(CHAT_TYPE_INFO, LC_TEXT("상자에서 %s 가 나왔습니다."), itemName.c_str());
  9332.                
  9333.                 if (pItem)
  9334.                 {
  9335.                     if (llItemCount > 1)
  9336.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("open_box_text_multiple %s %lld."), pItem->GetName(), llItemCount);
  9337.                     else
  9338.                         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("open_box_text_single %s."), pItem->GetName());
  9339.                 }
  9340.             }
  9341.             break;
  9342.         }
  9343.     }
  9344.    
  9345.     return true;
  9346. }
  9347. #endif
  9348.  
  9349. bool CHARACTER::GiveItemFromSpecialItemGroup(DWORD dwGroupNum, std::vector<DWORD> &dwItemVnums,
  9350.                                             std::vector<DWORD> &dwItemCounts, std::vector <LPITEM> &item_gets, int &count)
  9351. {
  9352.     const CSpecialItemGroup* pGroup = ITEM_MANAGER::instance().GetSpecialItemGroup(dwGroupNum);
  9353.  
  9354.     if (!pGroup)
  9355.     {
  9356.         sys_err("cannot find special item group %d", dwGroupNum);
  9357.         return false;
  9358.     }
  9359.  
  9360.     std::vector <int> idxes;
  9361.     int n = pGroup->GetMultiIndex(idxes);
  9362.  
  9363.     bool bSuccess;
  9364.  
  9365.     for (int i = 0; i < n; i++)
  9366.     {
  9367.         bSuccess = false;
  9368.         int idx = idxes[i];
  9369.         DWORD dwVnum = pGroup->GetVnum(idx);
  9370.         DWORD dwCount = pGroup->GetCount(idx);
  9371.         int iRarePct = pGroup->GetRarePct(idx);
  9372.         LPITEM item_get = NULL;
  9373.         switch (dwVnum)
  9374.         {
  9375.             case CSpecialItemGroup::GOLD:
  9376.                 PointChange(POINT_GOLD, dwCount);
  9377.                 LogManager::instance().CharLog(this, dwCount, "TREASURE_GOLD", "");
  9378.  
  9379.                 bSuccess = true;
  9380.                 break;
  9381.             case CSpecialItemGroup::EXP:
  9382.                 {
  9383.                     PointChange(POINT_EXP, dwCount);
  9384.                     LogManager::instance().CharLog(this, dwCount, "TREASURE_EXP", "");
  9385.  
  9386.                     bSuccess = true;
  9387.                 }
  9388.                 break;
  9389.  
  9390.             case CSpecialItemGroup::MOB:
  9391.                 {
  9392.                     sys_log(0, "CSpecialItemGroup::MOB %d", dwCount);
  9393.                     int x = GetX() + number(-500, 500);
  9394.                     int y = GetY() + number(-500, 500);
  9395.  
  9396.                     LPCHARACTER ch = CHARACTER_MANAGER::instance().SpawnMob(dwCount, GetMapIndex(), x, y, 0, true, -1);
  9397.                     if (ch)
  9398.                         ch->SetAggressive();
  9399.                     bSuccess = true;
  9400.                 }
  9401.                 break;
  9402.             case CSpecialItemGroup::SLOW:
  9403.                 {
  9404.                     sys_log(0, "CSpecialItemGroup::SLOW %d", -(int)dwCount);
  9405.                     AddAffect(AFFECT_SLOW, POINT_MOV_SPEED, -(int)dwCount, AFF_SLOW, 300, 0, true);
  9406.                     bSuccess = true;
  9407.                 }
  9408.                 break;
  9409.             case CSpecialItemGroup::DRAIN_HP:
  9410.                 {
  9411.                     int iDropHP = GetMaxHP()*dwCount/100;
  9412.                     sys_log(0, "CSpecialItemGroup::DRAIN_HP %d", -iDropHP);
  9413.                     iDropHP = MIN(iDropHP, GetHP()-1);
  9414.                     sys_log(0, "CSpecialItemGroup::DRAIN_HP %d", -iDropHP);
  9415.                     PointChange(POINT_HP, -iDropHP);
  9416.                     bSuccess = true;
  9417.                 }
  9418.                 break;
  9419.             case CSpecialItemGroup::POISON:
  9420.                 {
  9421.                     AttackedByPoison(NULL);
  9422.                     bSuccess = true;
  9423.                 }
  9424.                 break;
  9425. #ifdef ENABLE_WOLFMAN_CHARACTER
  9426.             case CSpecialItemGroup::BLEEDING:
  9427.                 {
  9428.                     AttackedByBleeding(NULL);
  9429.                     bSuccess = true;
  9430.                 }
  9431.                 break;
  9432. #endif
  9433.             case CSpecialItemGroup::MOB_GROUP:
  9434.                 {
  9435.                     int sx = GetX() - number(300, 500);
  9436.                     int sy = GetY() - number(300, 500);
  9437.                     int ex = GetX() + number(300, 500);
  9438.                     int ey = GetY() + number(300, 500);
  9439.                     CHARACTER_MANAGER::instance().SpawnGroup(dwCount, GetMapIndex(), sx, sy, ex, ey, NULL, true);
  9440.  
  9441.                     bSuccess = true;
  9442.                 }
  9443.                 break;
  9444. #ifdef ENABLE_POLYMORPH_CHESTS
  9445.             case CSpecialItemGroup::POLY: {
  9446.                 LPITEM item = ITEM_MANAGER::instance().CreateItem(70104, 1, 0, true);
  9447.                 if (item)
  9448.                 {
  9449.                     item->SetSocket(0, static_cast<int>(dwCount));
  9450.                     int iEmptyPos = GetEmptyInventory(item->GetSize());
  9451.    
  9452.                     if (iEmptyPos != -1)
  9453.                     {
  9454.                         item->AddToCharacter(this, TItemPos(INVENTORY, iEmptyPos));
  9455.                         bSuccess = true;
  9456.                     }
  9457.                     else
  9458.                     {
  9459.                         M2_DESTROY_ITEM(item);
  9460.                         bSuccess = false;
  9461.                     }
  9462.                 }
  9463.             }
  9464.             break;
  9465. #endif
  9466.             default:
  9467.                 {
  9468.                     item_get = AutoGiveItem(dwVnum, dwCount, iRarePct);
  9469.  
  9470.                     if (item_get)
  9471.                     {
  9472.                         bSuccess = true;
  9473.                     }
  9474.                 }
  9475.                 break;
  9476.         }
  9477.  
  9478.         if (bSuccess)
  9479.         {
  9480.             dwItemVnums.push_back(dwVnum);
  9481.             dwItemCounts.push_back(dwCount);
  9482.             item_gets.push_back(item_get);
  9483.             count++;
  9484.  
  9485.         }
  9486.         else
  9487.         {
  9488.             return false;
  9489.         }
  9490.     }
  9491.     return bSuccess;
  9492. }
  9493.  
  9494. // NEW_HAIR_STYLE_ADD
  9495. bool CHARACTER::ItemProcess_Hair(LPITEM item, int iDestCell)
  9496. {
  9497.     if (item->CheckItemUseLevel(GetLevel()) == false)
  9498.     {
  9499.        
  9500.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("아직 이 머리를 사용할 수 없는 레벨입니다."));
  9501.         return false;
  9502.     }
  9503.  
  9504.     DWORD hair = item->GetVnum();
  9505.  
  9506.     switch (GetJob())
  9507.     {
  9508.         case JOB_WARRIOR :
  9509.             hair -= 72000;
  9510.             break;
  9511.  
  9512.         case JOB_ASSASSIN :
  9513.             hair -= 71250;
  9514.             break;
  9515.  
  9516.         case JOB_SURA :
  9517.             hair -= 70500;
  9518.             break;
  9519.  
  9520.         case JOB_SHAMAN :
  9521.             hair -= 69750;
  9522.             break;
  9523. #ifdef ENABLE_WOLFMAN_CHARACTER
  9524.         case JOB_WOLFMAN:
  9525.             break;
  9526. #endif
  9527.         default :
  9528.             return false;
  9529.             break;
  9530.     }
  9531.  
  9532.     if (hair == GetPart(PART_HAIR))
  9533.     {
  9534.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("동일한 머리 스타일로는 교체할 수 없습니다."));
  9535.         return true;
  9536.     }
  9537.  
  9538.     item->SetCount(item->GetCount() - 1);
  9539.  
  9540.     SetPart(PART_HAIR, hair);
  9541.     UpdatePacket();
  9542.  
  9543.     return true;
  9544. }
  9545. // END_NEW_HAIR_STYLE_ADD
  9546.  
  9547. bool CHARACTER::ItemProcess_Polymorph(LPITEM item)
  9548. {
  9549.     if (IsPolymorphed())
  9550.     {
  9551.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("이미 둔갑중인 상태입니다."));
  9552.         return false;
  9553.     }
  9554.  
  9555.     if (true == IsRiding())
  9556.     {
  9557.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("둔갑할 수 없는 상태입니다."));
  9558.         return false;
  9559.     }
  9560.  
  9561.     DWORD dwVnum = item->GetSocket(0);
  9562.  
  9563.     if (dwVnum == 0)
  9564.     {
  9565.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("잘못된 둔갑 아이템입니다."));
  9566.         item->SetCount(item->GetCount()-1);
  9567.         return false;
  9568.     }
  9569.  
  9570.     const CMob* pMob = CMobManager::instance().Get(dwVnum);
  9571.  
  9572.     if (pMob == NULL)
  9573.     {
  9574.         ChatPacket(CHAT_TYPE_INFO, LC_TEXT("잘못된 둔갑 아이템입니다."));
  9575.         item->SetCount(item->GetCount()-1);
  9576.         return false;
  9577.     }
  9578.  
  9579.     switch (item->GetVnum())
  9580.     {
  9581.         case 70104 :
  9582.         case 70105 :
  9583.         case 70106 :
  9584.         case 70107 :
  9585.         case 71093 :
  9586.             {
  9587.                
  9588.                 sys_log(0, "USE_POLYMORPH_BALL PID(%d) vnum(%d)", GetPlayerID(), dwVnum);
  9589.  
  9590.                
  9591.                 int iPolymorphLevelLimit = MAX(0, 20 - GetLevel() * 3 / 10);
  9592.                 if (pMob->m_table.bLevel >= GetLevel() + iPolymorphLevelLimit)
  9593.                 {
  9594.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("나보다 너무 높은 레벨의 몬스터로는 변신 할 수 없습니다."));
  9595.                     return false;
  9596.                 }
  9597.  
  9598.                 int iDuration = GetSkillLevel(POLYMORPH_SKILL_ID) == 0 ? 5 : (5 + (5 + GetSkillLevel(POLYMORPH_SKILL_ID)/40 * 25));
  9599.                 iDuration *= 60;
  9600.  
  9601.                 DWORD dwBonus = 0;
  9602.  
  9603.                 dwBonus = (2 + GetSkillLevel(POLYMORPH_SKILL_ID)/40) * 100;
  9604.  
  9605.                 AddAffect(AFFECT_POLYMORPH, POINT_POLYMORPH, dwVnum, AFF_POLYMORPH, iDuration, 0, true);
  9606.                 AddAffect(AFFECT_POLYMORPH, POINT_ATT_BONUS, dwBonus, AFF_POLYMORPH, iDuration, 0, false);
  9607.  
  9608.                 item->SetCount(item->GetCount()-1);
  9609.             }
  9610.             break;
  9611.  
  9612.         case 50322:
  9613.             {
  9614.                
  9615.  
  9616.                
  9617.                
  9618.                
  9619.                 sys_log(0, "USE_POLYMORPH_BOOK: %s(%u) vnum(%u)", GetName(), GetPlayerID(), dwVnum);
  9620.  
  9621.                 if (CPolymorphUtils::instance().PolymorphCharacter(this, item, pMob) == true)
  9622.                 {
  9623.                     CPolymorphUtils::instance().UpdateBookPracticeGrade(this, item);
  9624.                 }
  9625.                 else
  9626.                 {
  9627.                 }
  9628.             }
  9629.             break;
  9630.  
  9631.         default :
  9632.             sys_err("POLYMORPH invalid item passed PID(%d) vnum(%d)", GetPlayerID(), item->GetOriginalVnum());
  9633.             return false;
  9634.     }
  9635.  
  9636.     return true;
  9637. }
  9638.  
  9639. #if defined(__SOUL_SYSTEM__)
  9640. void CHARACTER::SoulItemProcess(ESoulSubType eSubType)
  9641. {
  9642.     LPITEM item = nullptr;
  9643.     for (const auto& it : GetAffectContainer())
  9644.     {
  9645.         if (it == nullptr || it->dwType != AFFECT_SOUL)
  9646.             continue;
  9647.  
  9648.         switch (eSubType)
  9649.         {
  9650.             case ESoulSubType::RED_SOUL:
  9651.             {
  9652.                 if (it->bApplyOn == AFF_SOUL_RED)
  9653.                     item = FindItemByID(it->lApplyValue);
  9654.             }
  9655.             break;
  9656.  
  9657.             case ESoulSubType::BLUE_SOUL:
  9658.             {
  9659.                 if (it->bApplyOn == AFF_SOUL_BLUE)
  9660.                     item = FindItemByID(it->lApplyValue);
  9661.             }
  9662.             break;
  9663.         }
  9664.     }
  9665.  
  9666.     if (item == nullptr)
  9667.         return;
  9668.  
  9669.     if (!item->isLocked() || item->GetSocket(1) != TRUE)
  9670.         return;
  9671.  
  9672.     auto data = item->GetSocket(2);
  9673.     auto keep_time = data / 10000;
  9674.     //auto max_time = item->GetLimitValue(1);
  9675.     auto min_time = 60;
  9676.  
  9677.     // Minimum use time.
  9678.     if (keep_time < min_time)
  9679.         return;
  9680.  
  9681.     /*
  9682.     * Since the `remain_count` is added after the `keep_time`
  9683.     * we can decrease `data` directly because the count
  9684.     * stays at the end of `data`.
  9685.     */
  9686.     if (test_server)
  9687.         data -= 5;
  9688.     else
  9689.         --data; /* remain_count */;
  9690.  
  9691.     /*
  9692.     * If the remaining count is equal or below to zero
  9693.     * then set the socket data to 0 and start the soul
  9694.     * timer event.
  9695.     */
  9696.     auto remain_count = data % 10000;
  9697.     if (remain_count <= 0)
  9698.     {
  9699.         item->SetSocket(2, 0);
  9700.         item->ResetSoulTimerUseEvent();
  9701.         return;
  9702.     }
  9703.  
  9704.     // Update the item with the new data (decreased count)
  9705.     item->SetSocket(2, data, false /* log */);
  9706. }
  9707.  
  9708. int CHARACTER::GetSoulDamage(ESoulSubType eSubType) const
  9709. {
  9710.     LPITEM item = nullptr;
  9711.     for (const auto& it : GetAffectContainer())
  9712.     {
  9713.         if (it == nullptr || it->dwType != AFFECT_SOUL)
  9714.             continue;
  9715.  
  9716.         switch (eSubType)
  9717.         {
  9718.             case ESoulSubType::RED_SOUL:
  9719.             {
  9720.                 if (it->bApplyOn == AFF_SOUL_RED)
  9721.                     item = FindItemByID(it->lApplyValue);
  9722.             }
  9723.             break;
  9724.  
  9725.             case ESoulSubType::BLUE_SOUL:
  9726.             {
  9727.                 if (it->bApplyOn == AFF_SOUL_BLUE)
  9728.                     item = FindItemByID(it->lApplyValue);
  9729.             }
  9730.             break;
  9731.         }
  9732.     }
  9733.  
  9734.     if (item == nullptr)
  9735.         return 0;
  9736.  
  9737.     if (item->GetSocket(1) != TRUE)
  9738.         return 0;
  9739.  
  9740.     auto value = 0;
  9741.     auto data = item->GetSocket(2);
  9742.     auto keep_time = data / 10000;
  9743.  
  9744.     auto max_time = item->GetLimitValue(1);
  9745.     auto min_time = 60;
  9746.  
  9747.     // Minimum use time.
  9748.     if (keep_time < min_time)
  9749.         return 0;
  9750.  
  9751.     if (keep_time >= max_time)
  9752.         return item->GetValue(5);
  9753.  
  9754.     // Damage values in value field (3, 4, 5)
  9755.     auto value_field = 3 + std::floor(keep_time / (max_time - min_time));
  9756.     if (value_field < ITEM_VALUES_MAX_NUM)
  9757.         value = item->GetValue(value_field);
  9758.  
  9759.     return value;
  9760. }
  9761. #endif
  9762.  
  9763. bool CHARACTER::CanDoCube() const
  9764. {
  9765.     if (m_bIsObserver)  return false;
  9766.     if (GetShop())      return false;
  9767.     if (GetMyShop())    return false;
  9768.     if (m_bUnderRefine) return false;
  9769.     if (IsWarping())    return false;
  9770.  
  9771.     return true;
  9772. }
  9773.  
  9774. bool CHARACTER::UnEquipSpecialRideUniqueItem()
  9775. {
  9776.     LPITEM Unique1 = GetWear(WEAR_UNIQUE1);
  9777.     LPITEM Unique2 = GetWear(WEAR_UNIQUE2);
  9778. #ifdef ENABLE_MOUNT_COSTUME_SYSTEM
  9779.     LPITEM MountCostume = GetWear(WEAR_COSTUME_MOUNT);
  9780. #endif
  9781.  
  9782.     if( NULL != Unique1 )
  9783.     {
  9784.         if( UNIQUE_GROUP_SPECIAL_RIDE == Unique1->GetSpecialGroup() )
  9785.         {
  9786.             return UnequipItem(Unique1);
  9787.         }
  9788.     }
  9789.  
  9790.     if( NULL != Unique2 )
  9791.     {
  9792.         if( UNIQUE_GROUP_SPECIAL_RIDE == Unique2->GetSpecialGroup() )
  9793.         {
  9794.             return UnequipItem(Unique2);
  9795.         }
  9796.     }
  9797.  
  9798. #ifdef ENABLE_MOUNT_COSTUME_SYSTEM
  9799.     if (MountCostume)
  9800.         return UnequipItem(MountCostume);
  9801. #endif
  9802.  
  9803.     return true;
  9804. }
  9805.  
  9806. void CHARACTER::AutoRecoveryItemProcess(const EAffectTypes type)
  9807. {
  9808.     if (true == IsDead() || true == IsStun())
  9809.         return;
  9810.  
  9811.     if (false == IsPC())
  9812.         return;
  9813.  
  9814.     if (AFFECT_AUTO_HP_RECOVERY != type && AFFECT_AUTO_SP_RECOVERY != type)
  9815.         return;
  9816.  
  9817. #ifdef ENABLE_IBEAST_MAP_RESTRICTION
  9818.     if (IsOnRestrictedMap())
  9819.     {
  9820.         if (AFFECT_AUTO_HP_RECOVERY == type || AFFECT_AUTO_SP_RECOVERY == type)
  9821.             return;
  9822.     }
  9823. #endif
  9824.  
  9825.     if (NULL != FindAffect(AFFECT_STUN))
  9826.         return;
  9827.  
  9828.     {
  9829.         const DWORD stunSkills[] = { SKILL_TANHWAN, SKILL_GEOMPUNG, SKILL_BYEURAK, SKILL_GIGUNG };
  9830.  
  9831.         for (size_t i=0 ; i < sizeof(stunSkills)/sizeof(DWORD) ; ++i)
  9832.         {
  9833.             const CAffect* p = FindAffect(stunSkills[i]);
  9834.  
  9835.             if (NULL != p && AFF_STUN == p->dwFlag)
  9836.                 return;
  9837.         }
  9838.     }
  9839.  
  9840.     const CAffect* pAffect = FindAffect(type);
  9841.     const size_t idx_of_amount_of_used = 1;
  9842.     const size_t idx_of_amount_of_full = 2;
  9843.  
  9844.     if (NULL != pAffect)
  9845.     {
  9846.         LPITEM pItem = FindItemByID(pAffect->dwFlag);
  9847.  
  9848.         if (NULL != pItem && true == pItem->GetSocket(0))
  9849.         {
  9850.             if (!CArenaManager::instance().IsArenaMap(GetMapIndex())
  9851. #ifdef ENABLE_NEWSTUFF
  9852.                 && !(g_NoPotionsOnPVP && CPVPManager::instance().IsFighting(GetPlayerID()) && !IsAllowedPotionOnPVP(pItem->GetVnum()))
  9853. #endif
  9854.             )
  9855.             {
  9856.                 const long amount_of_used = pItem->GetSocket(idx_of_amount_of_used);
  9857.                 const long amount_of_full = pItem->GetSocket(idx_of_amount_of_full);
  9858.  
  9859.                 const int32_t avail = amount_of_full - amount_of_used;
  9860.  
  9861.                 int32_t amount = 0;
  9862.                 const float recovery_factor = 0.75f;
  9863.  
  9864.                 if (AFFECT_AUTO_HP_RECOVERY == type)
  9865.                 {
  9866.                     amount = GetMaxHP() - (GetHP() + GetPoint(POINT_HP_RECOVERY));
  9867.                     // Apply the recovery factor to reduce the recovery rate
  9868.                     amount = static_cast<int32_t>(amount * recovery_factor);
  9869.                 }
  9870.                 else if (AFFECT_AUTO_SP_RECOVERY == type)
  9871.                 {
  9872.                     amount = GetMaxSP() - (GetSP() + GetPoint(POINT_SP_RECOVERY));
  9873.                 }
  9874.  
  9875.                 if (amount > 0)
  9876.                 {
  9877.                     if (avail > amount)
  9878.                     {
  9879.                         const int pct_of_used = amount_of_used * 100 / amount_of_full;
  9880.                         const int pct_of_will_used = (amount_of_used + amount) * 100 / amount_of_full;
  9881.  
  9882.                         bool bLog = false;
  9883.                        
  9884.                        
  9885.                         if ((pct_of_will_used / 10) - (pct_of_used / 10) >= 1)
  9886.                             bLog = true;
  9887.                         pItem->SetSocket(idx_of_amount_of_used, amount_of_used + amount, bLog);
  9888.                     }
  9889.                     else
  9890.                     {
  9891.                         amount = avail;
  9892.  
  9893.                         ITEM_MANAGER::instance().RemoveItem( pItem );
  9894.                     }
  9895.  
  9896.                     if (AFFECT_AUTO_HP_RECOVERY == type)
  9897.                     {
  9898.                         PointChange( POINT_HP_RECOVERY, amount );
  9899.                         EffectPacket( SE_AUTO_HPUP );
  9900.                     }
  9901.                     else if (AFFECT_AUTO_SP_RECOVERY == type)
  9902.                     {
  9903.                         PointChange( POINT_SP_RECOVERY, amount );
  9904.                         EffectPacket( SE_AUTO_SPUP );
  9905.                     }
  9906.                 }
  9907.             }
  9908.             else
  9909.             {
  9910.                 pItem->Lock(false);
  9911.                 pItem->SetSocket(0, false);
  9912.                 RemoveAffect( const_cast<CAffect*>(pAffect) );
  9913.             }
  9914.         }
  9915.         else
  9916.         {
  9917.             RemoveAffect( const_cast<CAffect*>(pAffect) );
  9918.         }
  9919.     }
  9920. }
  9921.  
  9922. bool CHARACTER::IsValidItemPosition(TItemPos Pos) const
  9923. {
  9924.     BYTE window_type = Pos.window_type;
  9925.     WORD cell = Pos.cell;
  9926.  
  9927.     switch (window_type)
  9928.     {
  9929.     case RESERVED_WINDOW:
  9930.         return false;
  9931.  
  9932.     case INVENTORY:
  9933.     case EQUIPMENT:
  9934.         return cell < (INVENTORY_AND_EQUIP_SLOT_MAX);
  9935.  
  9936.     case DRAGON_SOUL_INVENTORY:
  9937.         return cell < (DRAGON_SOUL_INVENTORY_MAX_NUM);
  9938.  
  9939.     case SAFEBOX:
  9940.         if (NULL != m_pkSafebox)
  9941.             return m_pkSafebox->IsValidPosition(cell);
  9942.         else
  9943.             return false;
  9944.  
  9945.     case MALL:
  9946.         if (NULL != m_pkMall)
  9947.             return m_pkMall->IsValidPosition(cell);
  9948.         else
  9949.             return false;
  9950.  
  9951. #ifdef ENABLE_SWITCHBOT_WORLDARD
  9952.     case SWITCHBOT:
  9953.         return cell < SWITCHBOT_SLOT_MAX;
  9954. #endif
  9955.  
  9956.     default:
  9957.         return false;
  9958.     }
  9959. }
  9960.  
  9961.  
  9962.  
  9963. #define VERIFY_MSG(exp, msg)  \
  9964.     if (true == (exp)) { \
  9965.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT(msg)); \
  9966.             return false; \
  9967.     }
  9968.  
  9969.  
  9970. bool CHARACTER::CanEquipNow(const LPITEM item, const TItemPos& srcCell, const TItemPos& destCell) /*const*/
  9971. {
  9972.     const TItemTable* itemTable = item->GetProto();
  9973.     //BYTE itemType = item->GetType();
  9974.     //BYTE itemSubType = item->GetSubType();
  9975.  
  9976.     switch (GetJob())
  9977.     {
  9978.         case JOB_WARRIOR:
  9979.             if (item->GetAntiFlag() & ITEM_ANTIFLAG_WARRIOR)
  9980.                 return false;
  9981.             break;
  9982.  
  9983.         case JOB_ASSASSIN:
  9984.             if (item->GetAntiFlag() & ITEM_ANTIFLAG_ASSASSIN)
  9985.                 return false;
  9986.             break;
  9987.  
  9988.         case JOB_SHAMAN:
  9989.             if (item->GetAntiFlag() & ITEM_ANTIFLAG_SHAMAN)
  9990.                 return false;
  9991.             break;
  9992.  
  9993.         case JOB_SURA:
  9994.             if (item->GetAntiFlag() & ITEM_ANTIFLAG_SURA)
  9995.                 return false;
  9996.             break;
  9997. #ifdef ENABLE_WOLFMAN_CHARACTER
  9998.         case JOB_WOLFMAN:
  9999.             if (item->GetAntiFlag() & ITEM_ANTIFLAG_WOLFMAN)
  10000.                 return false;
  10001.             break;
  10002. #endif
  10003.     }
  10004.  
  10005.     for (int i = 0; i < ITEM_LIMIT_MAX_NUM; ++i)
  10006.     {
  10007.         long limit = itemTable->aLimits[i].lValue;
  10008.         switch (itemTable->aLimits[i].bType)
  10009.         {
  10010.             case LIMIT_LEVEL:
  10011.                 if (GetLevel() < limit)
  10012.                 {
  10013.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("레벨이 낮아 착용할 수 없습니다."));
  10014.                     return false;
  10015.                 }
  10016.                 break;
  10017.  
  10018.             case LIMIT_STR:
  10019.                 if (GetPoint(POINT_ST) < limit)
  10020.                 {
  10021.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("근력이 낮아 착용할 수 없습니다."));
  10022.                     return false;
  10023.                 }
  10024.                 break;
  10025.  
  10026.             case LIMIT_INT:
  10027.                 if (GetPoint(POINT_IQ) < limit)
  10028.                 {
  10029.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("지능이 낮아 착용할 수 없습니다."));
  10030.                     return false;
  10031.                 }
  10032.                 break;
  10033.  
  10034.             case LIMIT_DEX:
  10035.                 if (GetPoint(POINT_DX) < limit)
  10036.                 {
  10037.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("민첩이 낮아 착용할 수 없습니다."));
  10038.                     return false;
  10039.                 }
  10040.                 break;
  10041.  
  10042.             case LIMIT_CON:
  10043.                 if (GetPoint(POINT_HT) < limit)
  10044.                 {
  10045.                     ChatPacket(CHAT_TYPE_INFO, LC_TEXT("체력이 낮아 착용할 수 없습니다."));
  10046.                     return false;
  10047.                 }
  10048.                 break;
  10049.         }
  10050.     }
  10051.  
  10052.     if (item->GetWearFlag() & WEARABLE_UNIQUE)
  10053.     {
  10054.         if ((GetWear(WEAR_UNIQUE1) && GetWear(WEAR_UNIQUE1)->IsSameSpecialGroup(item)) ||
  10055.             (GetWear(WEAR_UNIQUE2) && GetWear(WEAR_UNIQUE2)->IsSameSpecialGroup(item)))
  10056.         {
  10057.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("같은 종류의 유니크 아이템 두 개를 동시에 장착할 수 없습니다."));
  10058.             return false;
  10059.         }
  10060.  
  10061.         if (marriage::CManager::instance().IsMarriageUniqueItem(item->GetVnum()) &&
  10062.             !marriage::CManager::instance().IsMarried(GetPlayerID()))
  10063.         {
  10064.             ChatPacket(CHAT_TYPE_INFO, LC_TEXT("결혼하지 않은 상태에서 예물을 착용할 수 없습니다."));
  10065.             return false;
  10066.         }
  10067.  
  10068.     }
  10069.  
  10070.     return true;
  10071. }
  10072.  
  10073.  
  10074. bool CHARACTER::CanUnequipNow(const LPITEM item, const TItemPos& srcCell, const TItemPos& destCell) /*const*/
  10075. {
  10076.  
  10077.     if (ITEM_BELT == item->GetType())
  10078.         VERIFY_MSG(CBeltInventoryHelper::IsExistItemInBeltInventory(this), "벨트 인벤토리에 아이템이 존재하면 해제할 수 없습니다.");
  10079.  
  10080.     if (IS_SET(item->GetFlag(), ITEM_FLAG_IRREMOVABLE))
  10081.         return false;
  10082.     {
  10083.         int pos = -1;
  10084.  
  10085.         if (item->IsDragonSoul())
  10086.             pos = GetEmptyDragonSoulInventory(item);
  10087.         else
  10088.             pos = GetEmptyInventory(item->GetSize());
  10089.  
  10090.         VERIFY_MSG( -1 == pos, "소지품에 빈 공간이 없습니다." );
  10091.     }
  10092.     if (item->GetType() == ITEM_WEAPON)
  10093.     {
  10094.         if (IsAffectFlag(AFF_GWIGUM))
  10095.             RemoveAffect(SKILL_GWIGEOM);
  10096.  
  10097.         if (IsAffectFlag(AFF_GEOMGYEONG))
  10098.             RemoveAffect(SKILL_GEOMKYUNG);
  10099.     }
  10100.  
  10101.     return true;
  10102. }
  10103.  
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!