SHARE
TWEET

Untitled

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